Impossible to `Describe` generic types with conditional about superstruct HOT 2 OPEN

type Validating<T extends Types = Types> = {
  type: T;
  value: T extends Types.One ? string : never;
};

const Validating: Describe<Validating> = object({
  type: enums(Object.values(Types)),
  // eslint-disable-next-line @typescript-eslint/no-explicit-any
  value: dynamic((_, ctx): any => {
    const type: Types = ctx.branch.at(-2)?.type ?? Types.One;
    if (type === Types.One) {
      return string();
    } else {
      return literal(undefined);
    }
  }),
});

type Validating<T extends Types = Types> = {
  type: T;
  value: T extends Types.One ? string[] : never;
};

const Validating: Describe<Validating> = object({
  type: enums(Object.values(Types)),
  // eslint-disable-next-line @typescript-eslint/no-explicit-any
  value: dynamic((_, ctx): any => {
    const type: Types = ctx.branch.at(-2)?.type ?? Types.One;
    if (type === Types.One) {
      return array(string());
    } else {
      return literal(undefined);
    }
  }),
});

const Validating: Describe<Validating> = object({
  type: enums(Object.values(Types)),
  // eslint-disable-next-line @typescript-eslint/no-explicit-any
  value: dynamic((_, ctx): any => {
    const type: Types = ctx.branch.at(-2)?.type ?? Types.One;
    if (type === Types.One) {
      return array(string());
    } else {
      return literal(undefined);
    }
  }) as unknown as Describe<Validating["value"]>,
});

export function discriminatorMapping<
  D extends string,
  Mapping extends Record<string, TypeAny>
>(
  discriminator: D,
  mapping: Mapping
): Struct<Simplify<DiscriminatedUnion<D, Mapping>>, null> {
  return  dynamic<any>((v: any = {}) => {
    const discriminatorValue = (v as any)[discriminator];
    const matched = mapping[discriminatorValue];

    if (typeof (v as any)[discriminator] === "undefined" || !matched) {
      return object({
        [discriminator]: enums(Object.keys(mapping))
      });
    }

    return object({
      [discriminator]: literal(discriminatorValue),
      ...matched.schema
    });
  });
}


type DiscriminatedUnion<
  D extends string,
  Mapping extends Record<string, TypeAny>
> = ValueOf<{
  [K in keyof Mapping]: { [k in D]: K } & Infer<Mapping[K]>;
}>;

type ValueOf<T> = T[keyof T];

enum NetType {
  AIRGAP = "AIRGAP",
  DIRECT = "DIRECT",
}

const t: Struct<{ netType: NetType.AIRGAP } | { netType: NetType.DIRECT, endpoint: string  }> = discriminatorMapping("netType", {
    [NetType.AIRGAP]: object(),
    [NetType.DIRECT]: object({
      endpoint: string()
    })
  }
)