declare const fields: <A extends Struct<any>>(self: A) => A[TypeId]

declare const make: <const Variants extends ReadonlyArray<string>, const Default extends Variants[number]>(options: {
  readonly variants: Variants
  readonly defaultVariant: Default
}) => {
  readonly Struct: <const A extends Struct.Fields>(fields: A & Struct.Validate<A, Variants[number]>) => Struct<A>
  readonly Field: <const A extends Field.ConfigWithKeys<Variants[number]>>(
    config: A & { readonly [K in Exclude<keyof A, Variants[number]>]: never }
  ) => Field<A>
  readonly FieldOnly: <const Keys extends ReadonlyArray<Variants[number]>>(
    ...keys: Keys
  ) => <S extends Schema.Schema.All | Schema.PropertySignature.All>(
    schema: S
  ) => Field<{ readonly [K in Keys[number]]: S }>
  readonly FieldExcept: <const Keys extends ReadonlyArray<Variants[number]>>(
    ...keys: Keys
  ) => <S extends Schema.Schema.All | Schema.PropertySignature.All>(
    schema: S
  ) => Field<{ readonly [K in Exclude<Variants[number], Keys[number]>]: S }>
  readonly fieldEvolve: {
    <
      Self extends Field<any> | Field.ValueAny,
      const Mapping extends Self extends Field<infer S>
        ? { readonly [K in keyof S]?: (variant: S[K]) => Field.ValueAny }
        : { readonly [K in Variants[number]]?: (variant: Self) => Field.ValueAny }
    >(
      f: Mapping
    ): (
      self: Self
    ) => Field<
      Self extends Field<infer S>
        ? {
            readonly [K in keyof S]: K extends keyof Mapping
              ? Mapping[K] extends (arg: any) => any
                ? ReturnType<Mapping[K]>
                : S[K]
              : S[K]
          }
        : {
            readonly [K in Variants[number]]: K extends keyof Mapping
              ? Mapping[K] extends (arg: any) => any
                ? ReturnType<Mapping[K]>
                : Self
              : Self
          }
    >
    <
      Self extends Field<any> | Field.ValueAny,
      const Mapping extends Self extends Field<infer S>
        ? { readonly [K in keyof S]?: (variant: S[K]) => Field.ValueAny }
        : { readonly [K in Variants[number]]?: (variant: Self) => Field.ValueAny }
    >(
      self: Self,
      f: Mapping
    ): Field<
      Self extends Field<infer S>
        ? {
            readonly [K in keyof S]: K extends keyof Mapping
              ? Mapping[K] extends (arg: any) => any
                ? ReturnType<Mapping[K]>
                : S[K]
              : S[K]
          }
        : {
            readonly [K in Variants[number]]: K extends keyof Mapping
              ? Mapping[K] extends (arg: any) => any
                ? ReturnType<Mapping[K]>
                : Self
              : Self
          }
    >
  }
  readonly fieldFromKey: {
    <
      Self extends Field<any> | Field.ValueAny,
      const Mapping extends Self extends Field<infer S>
        ? { readonly [K in keyof S]?: string }
        : { readonly [K in Variants[number]]?: string }
    >(
      mapping: Mapping
    ): (
      self: Self
    ) => Field<
      Self extends Field<infer S>
        ? {
            readonly [K in keyof S]: K extends keyof Mapping
              ? Mapping[K] extends string
                ? fromKey.Rename<S[K], Mapping[K]>
                : S[K]
              : S[K]
          }
        : {
            readonly [K in Variants[number]]: K extends keyof Mapping
              ? Mapping[K] extends string
                ? fromKey.Rename<Self, Mapping[K]>
                : Self
              : Self
          }
    >
    <
      Self extends Field<any> | Field.ValueAny,
      const Mapping extends Self extends Field<infer S>
        ? { readonly [K in keyof S]?: string }
        : { readonly [K in Variants[number]]?: string }
    >(
      self: Self,
      mapping: Mapping
    ): Field<
      Self extends Field<infer S>
        ? {
            readonly [K in keyof S]: K extends keyof Mapping
              ? Mapping[K] extends string
                ? fromKey.Rename<S[K], Mapping[K]>
                : S[K]
              : S[K]
          }
        : {
            readonly [K in Variants[number]]: K extends keyof Mapping
              ? Mapping[K] extends string
                ? fromKey.Rename<Self, Mapping[K]>
                : Self
              : Self
          }
    >
  }
  readonly Class: <Self = never>(
    identifier: string
  ) => <const Fields extends Struct.Fields>(
    fields: Fields & Struct.Validate<Fields, Variants[number]>,
    annotations?: Schema.Annotations.Schema<Self>
  ) => [Self] extends [never]
    ? MissingSelfGeneric
    : ClassFromFields<Self, Fields, ExtractFields<Default, Fields, true>> & {
        readonly [V in Variants[number]]: Extract<V, Struct<Fields>>
      }
  readonly Union: <const Members extends ReadonlyArray<Struct<any>>>(
    ...members: Members
  ) => Union<Members> & Union.Variants<Members, Variants[number]>
  readonly extract: {
    <V extends Variants[number]>(
      variant: V
    ): <A extends Struct<any>>(self: A) => Extract<V, A, V extends Default ? true : false>
    <V extends Variants[number], A extends Struct<any>>(
      self: A,
      variant: V
    ): Extract<V, A, V extends Default ? true : false>
  }
}

type Extract<V, A, IsDefault> = [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, Fields, IsDefault> = {
  readonly [K in keyof Fields as [Fields[K]] extends [Field<infer Config>]
    ? V extends keyof Config
      ? K
      : never
    : K]: [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 const isField: (u: unknown) => u is Field<any>

declare const isStruct: (u: unknown) => u is Struct<any>

export interface Class<Self, Fields extends Struct.Fields, SchemaFields extends Schema.Struct.Fields, A, I, R, C>
  extends Schema.Schema<Self, Schema.Simplify<I>, R>,
    Struct<Schema.Simplify<Fields>> {
  new (
    props: RequiredKeys<C> extends never ? void | Schema.Simplify<C> : Schema.Simplify<C>,
    options?: {
      readonly disableValidation?: boolean
    }
  ): A

  readonly ast: AST.Transformation

  make<Args extends Array<any>, X>(this: { new (...args: Args): X }, ...args: Args): X

  annotations(annotations: Schema.Annotations.Schema<Self>): Schema.SchemaClass<Self, I, R>

  readonly identifier: string
  readonly fields: Schema.Simplify<SchemaFields>
}

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

type Any = { readonly [FieldTypeId]: FieldTypeId }

type Config = {
  readonly [key: string]: Schema.Schema.All | Schema.PropertySignature.All | undefined
}

type ConfigWithKeys<K> = {
  readonly [P in K]?: Schema.Schema.All | Schema.PropertySignature.All
}

type Fields = {
  readonly [key: string]: Schema.Schema.All | Schema.PropertySignature.All | Field<any> | Struct<any> | undefined
}

export interface Struct<in out A extends Field.Fields> extends Pipeable {
  readonly [TypeId]: A
  /** @internal */
  [cacheSymbol]?: Record<string, Schema.Schema.All>
}

type Any = { readonly [TypeId]: any }

type Fields = {
  readonly [key: string]: Schema.Schema.All | Schema.PropertySignature.All | Field<any> | Struct<any> | undefined
}

type Validate<A, Variant> = {
  readonly [K in keyof A]: A[K] extends { readonly [TypeId]: infer _ }
    ? Validate<A[K], Variant>
    : A[K] extends Field<infer Config>
      ? [keyof Config] extends [Variant]
        ? {}
        : "field must have valid variants"
      : {}
}

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

type Union.Variants<Members, Variants> = {
    readonly [Variant in Variants]: Schema.Union<
      {
        [K in keyof Members]: Extract<Variant, Members[K]>
      }
    >
  }

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

type Rename<S, Key> =
  S extends Schema.PropertySignature<
    infer _TypeToken,
    infer _Type,
    infer _Key,
    infer _EncodedToken,
    infer _Encoded,
    infer _HasDefault,
    infer _R
  >
    ? Schema.PropertySignature<_TypeToken, _Type, Key, _EncodedToken, _Encoded, _HasDefault, _R>
    : S extends Schema.Schema.All
      ? fromKey<S, Key>
      : never

declare const Override: <A>(value: A) => A & Brand<"Override">

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

export interface Overrideable<To, From, R = never>
  extends Schema.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