VariantSchema

declare function fields<A extends Struct<any>>(self: A): A[typeof TypeId];

declare function make<Variants extends readonly Array<string>, Default extends string>(options: {
  readonly defaultVariant: Default;
  readonly variants: Variants;
}): {
  readonly Class: <Self = never>(identifier: string) => <Fields extends Fields>(fields: Fields & Validate<Fields, Variants[number]>, annotations?: any) => [Self] extends [never] ? "Missing `Self` generic - use `class Self extends Class<Self>()({ ... })`" : ClassFromFields<Self, Fields, ExtractFields<Default, Fields, true>> & { [V in string]: Struct<Simplify<ExtractFields<V, Fields, false>>> };
  readonly extract: {
    <V extends string>(variant: V): <A extends Struct<any>>(self: A) => Extract<V, A, V extends Default ? true : false>;
    <V extends string, A extends Struct<any>>(self: A, variant: V): Extract<V, A, V extends Default ? true : false>;
  };
  readonly Field: <A extends ConfigWithKeys<Variants[number]>>(config: A & { [K in string | number | symbol]: never }) => Field<A>;
  readonly fieldEvolve: {
    <Self extends any, Mapping extends any>(f: Mapping): (self: Self) => Field<Self extends Field<S> ? { [K in string | number | symbol]: K extends keyof Mapping ? Mapping[K] extends (arg: any) => any ? ReturnType<any[any]> : S[K] : S[K] } : { [K in string]: K extends keyof Mapping ? Mapping[K] extends (arg: any) => any ? ReturnType<any[any]> : Self : Self }>;
    <Self extends any, Mapping extends any>(self: Self, f: Mapping): Field<Self extends Field<S> ? { [K in string | number | symbol]: K extends keyof Mapping ? Mapping[K] extends (arg: any) => any ? ReturnType<any[any]> : S[K] : S[K] } : { [K in string]: K extends keyof Mapping ? Mapping[K] extends (arg: any) => any ? ReturnType<any[any]> : Self : Self }>;
  };
  readonly FieldExcept: <Keys extends readonly Array<Variants[number]>>(...keys: Keys) => <S extends any>(schema: S) => Field<{ [K in string]: S }>;
  readonly fieldFromKey: {
    <Self extends any, Mapping extends any>(mapping: Mapping): (self: Self) => Field<Self extends Field<S> ? { [K in string | number | symbol]: K extends keyof Mapping ? Mapping[K] extends string ? Rename<S[K], any[any]> : S[K] : S[K] } : { [K in string]: K extends keyof Mapping ? Mapping[K] extends string ? Rename<Self, any[any]> : Self : Self }>;
    <Self extends any, Mapping extends any>(self: Self, mapping: Mapping): Field<Self extends Field<S> ? { [K in string | number | symbol]: K extends keyof Mapping ? Mapping[K] extends string ? Rename<S[K], any[any]> : S[K] : S[K] } : { [K in string]: K extends keyof Mapping ? Mapping[K] extends string ? Rename<Self, any[any]> : Self : Self }>;
  };
  readonly FieldOnly: <Keys extends readonly Array<Variants[number]>>(...keys: Keys) => <S extends any>(schema: S) => Field<{ [K in string]: S }>;
  readonly Struct: <A extends Fields>(fields: A & Validate<A, Variants[number]>) => Struct<A>;
  readonly Union: <Members extends readonly Array<Struct<any>>>(...members: Members) => Union<Members> & Variants<Members, Variants[number]>;
}

type Extract<V extends string, A extends Struct<any>, IsDefault = false> = [A] extends [
  Struct<infer Fields>,
]
  ? IsDefault extends true
    ? [A] extends [Schema.Schema.Any]
      ? A
      : Schema.Struct<Schema.Simplify<ExtractFields<V, Fields>>>
    : Schema.Struct<Schema.Simplify<ExtractFields<V, Fields>>>
  : never;

type ExtractFields<V extends string, Fields extends Struct.Fields, IsDefault = false> = {
  [K in keyof Fields]: [Fields[K]] extends [Struct<infer _>]
    ? Extract<V, Fields[K], IsDefault>
    : [Fields[K]] extends [Field<infer Config>]
      ? [Config[V]] extends [Schema.Schema.All | Schema.PropertySignature.All]
        ? Config[V]
        : never
      : [Fields[K]] extends [Schema.Schema.All | Schema.PropertySignature.All]
        ? Fields[K]
        : never;
};

declare function isField(u: unknown): u is Field<any>;

declare function isStruct(u: unknown): u is Struct<any>;

interface Class<
  Self,
  Fields extends Struct.Fields,
  SchemaFields extends Schema.Struct.Fields,
  A,
  I,
  R,
  C,
>
  extends Schema<Self, Schema.Simplify<I>, R>, Struct<Schema.Simplify<Fields>> {
  constructor(
    props: RequiredKeys<C> extends never ? any : Simplify<C>,
    options?: {
      readonly disableValidation?: boolean;
    },
  );
  readonly ast: Transformation;
  readonly fields: Simplify<SchemaFields>;
  readonly identifier: string;
  annotations(annotations: Schema<Self>): SchemaClass<Self, I, R>;
  make<Args extends Array<any>, X>(this: (...args: Args) => X, ...args: Args): X;
}

interface Field<in out A extends Field.Config> extends Pipeable {
  readonly [FieldTypeId]: typeof FieldTypeId;
  readonly schemas: A;
}

interface fromKey<S extends Schema.Schema.All, Key extends string> extends PropertySignature<
  ":",
  Type<S>,
  Key,
  ":",
  Encoded<S>,
  false,
  Context<S>
> {}

interface Struct<in out A extends Field.Fields> extends Pipeable {
  readonly [TypeId]: A;
}

interface Union<Members extends ReadonlyArray<Struct<any>>> extends Union<{
  [K in keyof Members]: [Members[K]] extends [Schema.Schema.All] ? Members[K] : never;
}> {}

declare function Override<A>(value: A): A & Brand<"Override">;

declare const Overrideable: <From, IFrom, RFrom, To, ITo, R>(
  from: any,
  to: any,
  options: {
    readonly constructorDefault?: () => To;
    readonly decode?: any;
    readonly generate: (_: Option<ITo>) => Effect<From, ParseIssue, R>;
  },
) => Overrideable<To, IFrom, RFrom | R>;

interface Overrideable<To, From, R = never> extends PropertySignature<
  ":",
  (To & Brand<"Override">) | undefined,
  never,
  ":",
  From,
  true,
  R
> {}

declare const FieldTypeId: unique symbol;

type FieldTypeId = typeof FieldTypeId;

declare const TypeId: unique symbol;

type TypeId = typeof TypeId;