Schema

declare function exitSchema<SA, SI, FA, FI, R>(
  self: WithResult<SA, SI, FA, FI, R>,
): Schema<Exit<SA, FA>, ExitEncoded<SI, FI, unknown>, R>;

declare function failureSchema<SA, SI, FA, FI, R>(
  self: WithResult<SA, SI, FA, FI, R>,
): Schema<FA, FI, R>;

declare function serializableSchema<A, I, R>(self: Serializable<A, I, R>): Schema<A, I, R>;

declare function successSchema<SA, SI, FA, FI, R>(
  self: WithResult<SA, SI, FA, FI, R>,
): Schema<SA, SI, R>;

interface Annotable<Self extends Schema<A, I, R>, A, I = A, R = never> extends Schema<A, I, R> {
  annotations(annotations: GenericSchema<A>): Self;
}

interface AnnotableClass<Self extends Schema<A, I, R>, A, I = A, R = never> extends Annotable<
  Self,
  A,
  I,
  R
> {
  constructor(_: never);
}

declare const annotations: {
  <S extends All>(annotations: GenericSchema<Type<S>>): (self: S) => ReturnType<S["annotations"]>;
  <S extends All>(self: S, annotations: GenericSchema<Type<S>>): ReturnType<S["annotations"]>;
};

interface AnnotableDeclare<
  Self extends declare<A, I, P, R>,
  A,
  I = A,
  P extends ReadonlyArray<Schema.All> = readonly [],
  R = Schema.Context<P[number]>,
> extends declare<A, I, P, R> {
  constructor(_: never);
  annotations(annotations: Schema<A>): Self;
}

interface Array$<Value extends Schema.Any> extends TupleType<[], [Value]> {
  constructor(_: never);
  readonly value: Value;
  annotations(annotations: Schema<readonly Array<Type<Value>>>): Array$<Value>;
}

interface ArrayEnsure<Value extends Schema.Any> extends transform<
  Union<[Value, Array$<Value>]>,
  Array$<SchemaClass<Schema.Type<Value>>>
> {
  constructor(_: never);
}

interface brand<S extends Schema.Any, B extends string | symbol> extends BrandSchema<
  Schema.Type<S> & Brand<B>,
  Schema.Encoded<S>,
  Schema.Context<S>
> {
  constructor(_: never);
  readonly from: S;
  annotations(annotations: Schema<Type<S> & Brand<B>>): brand<S, B>;
}

interface Cause<E extends Schema.All, D extends Schema.All> extends transform<
  SchemaClass<
    CauseEncoded<Schema.Type<E>, Schema.Type<Defect>>,
    CauseEncoded<Schema.Encoded<E>, Schema.Encoded<Defect>>,
    Schema.Context<E> | Schema.Context<D>
  >,
  CauseFromSelf<SchemaClass<Schema.Type<E>>, SchemaClass<Schema.Type<D>>>
> {
  constructor(_: never);
}

interface CauseFromSelf<E extends Schema.All, D extends Schema.All> extends AnnotableDeclare<
  CauseFromSelf<E, D>,
  cause_.Cause<Schema.Type<E>>,
  cause_.Cause<Schema.Encoded<E>>,
  [E, D]
> {
  constructor(_: never);
}

interface Chunk<Value extends Schema.Any> extends transform<
  Array$<Value>,
  ChunkFromSelf<SchemaClass<Schema.Type<Value>>>
> {
  constructor(_: never);
}

interface ChunkFromSelf<Value extends Schema.Any> extends AnnotableDeclare<
  ChunkFromSelf<Value>,
  chunk_.Chunk<Schema.Type<Value>>,
  chunk_.Chunk<Schema.Encoded<Value>>,
  [Value]
> {
  constructor(_: never);
}

interface Class<Self, Fields extends Struct.Fields, I, R, C, Inherited, Proto> extends Schema<Self, Simplify<I>, R> {
  constructor(props: RequiredKeys<C> extends never ? void | { [K in string | number | symbol]: C[K] } : { [K in string | number | symbol]: C[K] }, options?: MakeOptions);
  readonly ast: Transformation;
  readonly fields: { [K in string | number | symbol]: Fields[K] };
  readonly identifier: string;
  annotations(annotations: Schema<Self>): SchemaClass<Self, { [K in string | number | symbol]: I[K] }, R>;
  extend<Extended = never>(identifier: string): <NewFields extends Fields>(fields: NewFields | HasFields<NewFields>, annotations?: ClassAnnotations<Extended, { [K in string | number | symbol]: Type<Fields & NewFields>[K] }>) => [Extended] extends [never] ? "Missing `Self` generic - use `class Self extends Base.extend<Self>()({ ... })`" : Class<Extended, Fields & NewFields, I & { [K in string | number | symbol]: Encoded<NewFields[K]> } & { [K in string | number | symbol]: Encoded<NewFields[K]> }, R | Context<NewFields[keyof NewFields]>, C & Constructor<NewFields>, Self, Proto>;
  make<C extends (...args: Array<any>) => any>(this: C, ...args: ConstructorParameters<C>): InstanceType<C>;
  transformOrFail<Transformed = never>(identifier: string): <NewFields extends Fields, R2, R3>(fields: NewFields, options: {
    readonly decode: (input: { [K in string | number | symbol]: Type<Fields>[K] }, options: ParseOptions, ast: Transformation) => Effect<{ [K in string | number | symbol]: Type<Fields & NewFields>[K] }, ParseIssue, R2>;
    readonly encode: (input: { [K in string | number | symbol]: Type<Fields & NewFields>[K] }, options: ParseOptions, ast: Transformation) => Effect<Type<Fields>, ParseIssue, R3>;
  }, annotations?: ClassAnnotations<Transformed, { [K in string | number | symbol]: Type<Fields & NewFields>[K] }>) => [Transformed] extends [never] ? "Missing `Self` generic - use `class Self extends Base.transformOrFail<Self>()({ ... })`" : Class<Transformed, Fields & NewFields, I, R | R2 | R3 | Context<NewFields[keyof NewFields]>, C & Constructor<NewFields>, Self, Proto>;
  transformOrFailFrom<Transformed = never>(identifier: string): <NewFields extends Fields, R2, R3>(fields: NewFields, options: {
    readonly decode: (input: { [K in string | number | symbol]: I[K] }, options: ParseOptions, ast: Transformation) => Effect<{ [K in string | number | symbol]: I & { [K in string | number | symbol]: Encoded<NewFields[K]> } & { [K in string | number | symbol]: Encoded<...[...]> }[K] }, ParseIssue, R2>;
    readonly encode: (input: { [K in string | number | symbol]: I & { [K in string | number | symbol]: Encoded<NewFields[K]> } & { [K in string | number | symbol]: Encoded<NewFields[K]> }[K] }, options: ParseOptions, ast: Transformation) => Effect<I, ParseIssue, R3>;
  }, annotations?: ClassAnnotations<Transformed, { [K in string | number | symbol]: Type<Fields & NewFields>[K] }>) => [Transformed] extends [never] ? "Missing `Self` generic - use `class Self extends Base.transformOrFailFrom<Self>()({ ... })`" : Class<Transformed, Fields & NewFields, I, R | R2 | R3 | Context<NewFields[keyof NewFields]>, C & Constructor<NewFields>, Self, Proto>;
}

interface Data<Value extends Schema.Any> extends transform<
  Value,
  DataFromSelf<SchemaClass<Schema.Type<Value>>>
> {
  constructor(_: never);
}

interface DataFromSelf<Value extends Schema.Any> extends AnnotableDeclare<
  DataFromSelf<Value>,
  Schema.Type<Value>,
  Schema.Encoded<Value>,
  [Value]
> {
  constructor(_: never);
}

interface declare<
  A,
  I = A,
  P extends ReadonlyArray<Schema.All> = readonly [],
  R = Schema.Context<P[number]>,
> extends AnnotableClass<declare<A, I, P, R>, A, I, R> {
  constructor(_: never);
  readonly typeParameters: Readonly<P>;
}

interface Either<Right extends Schema.All, Left extends Schema.All> extends transform<
  Union<
    [
      Struct<{
        _tag: Literal<["Right"]>;
        right: Right;
      }>,
      Struct<{
        _tag: Literal<["Left"]>;
        left: Left;
      }>,
    ]
  >,
  EitherFromSelf<SchemaClass<Schema.Type<Right>>, SchemaClass<Schema.Type<Left>>>
> {
  constructor(_: never);
}

interface EitherFromSelf<R extends Schema.All, L extends Schema.All> extends AnnotableDeclare<
  EitherFromSelf<R, L>,
  either_.Either<Schema.Type<R>, Schema.Type<L>>,
  either_.Either<Schema.Encoded<R>, Schema.Encoded<L>>,
  [R, L]
> {
  constructor(_: never);
}

interface EitherFromUnion<Right extends Schema.All, Left extends Schema.All> extends transform<
  Union<
    [
      transform<
        Right,
        Struct<{
          _tag: Literal<["Right"]>;
          right: SchemaClass<Schema.Type<Right>>;
        }>
      >,
      transform<
        Left,
        Struct<{
          _tag: Literal<["Left"]>;
          right: SchemaClass<Schema.Type<Left>>;
        }>
      >,
    ]
  >,
  EitherFromSelf<SchemaClass<Schema.Type<Right>>, SchemaClass<Schema.Type<Left>>>
> {
  constructor(_: never);
}

interface Enums<A extends EnumsDefinition> extends AnnotableClass<Enums<A>, A[keyof A]> {
  constructor(_: never);
  readonly enums: A;
}

interface Exit<A extends Schema.All, E extends Schema.All, D extends Schema.All> extends transform<
  Union<
    [
      Struct<{
        _tag: Literal<["Failure"]>;
        cause: SchemaClass<
          CauseEncoded<Schema.Type<E>, Schema.Type<D>>,
          CauseEncoded<Schema.Encoded<E>, Schema.Encoded<D>>,
          Schema.Context<E> | Schema.Context<D>
        >;
      }>,
      Struct<{
        _tag: Literal<["Success"]>;
        value: A;
      }>,
    ]
  >,
  ExitFromSelf<
    SchemaClass<Schema.Type<A>>,
    SchemaClass<Schema.Type<E>>,
    SchemaClass<Schema.Type<D>>
  >
> {
  constructor(_: never);
}

interface ExitFromSelf<
  A extends Schema.All,
  E extends Schema.All,
  D extends Schema.All,
> extends AnnotableDeclare<
  ExitFromSelf<A, E, D>,
  exit_.Exit<Schema.Type<A>, Schema.Type<E>>,
  exit_.Exit<Schema.Encoded<A>, Schema.Encoded<E>>,
  [A, E, D]
> {
  constructor(_: never);
}

interface extend<Self extends Schema.Any, That extends Schema.Any> extends AnnotableClass<
  extend<Self, That>,
  Schema.Type<Self> & Schema.Type<That>,
  Schema.Encoded<Self> & Schema.Encoded<That>,
  Schema.Context<Self> | Schema.Context<That>
> {
  constructor(_: never);
}

interface filter<From extends Schema.Any> extends refine<Schema.Type<From>, From> {
  constructor(_: never);
}

interface filterEffect<S extends Schema.Any, FD = never> extends transformOrFail<
  S,
  SchemaClass<Schema.Type<S>>,
  FD
> {
  constructor(_: never);
}

interface HashMap<K extends Schema.Any, V extends Schema.Any> extends transform<
  Array$<Tuple2<K, V>>,
  HashMapFromSelf<SchemaClass<Schema.Type<K>>, SchemaClass<Schema.Type<V>>>
> {
  constructor(_: never);
}

interface HashMapFromSelf<K extends Schema.Any, V extends Schema.Any> extends AnnotableDeclare<
  HashMapFromSelf<K, V>,
  hashMap_.HashMap<Schema.Type<K>, Schema.Type<V>>,
  hashMap_.HashMap<Schema.Encoded<K>, Schema.Encoded<V>>,
  [K, V]
> {
  constructor(_: never);
}

interface HashSet<Value extends Schema.Any> extends transform<
  Array$<Value>,
  HashSetFromSelf<SchemaClass<Schema.Type<Value>>>
> {
  constructor(_: never);
}

interface HashSetFromSelf<Value extends Schema.Any> extends AnnotableDeclare<
  HashSetFromSelf<Value>,
  hashSet_.HashSet<Schema.Type<Value>>,
  hashSet_.HashSet<Schema.Encoded<Value>>,
  [Value]
> {
  constructor(_: never);
}

interface instanceOf<A> extends AnnotableDeclare<instanceOf<A>, A> {
  constructor(_: never);
}

interface List<Value extends Schema.Any> extends transform<
  Array$<Value>,
  ListFromSelf<SchemaClass<Schema.Type<Value>>>
> {
  constructor(_: never);
}

interface ListFromSelf<Value extends Schema.Any> extends AnnotableDeclare<
  ListFromSelf<Value>,
  list_.List<Schema.Type<Value>>,
  list_.List<Schema.Encoded<Value>>,
  [Value]
> {
  constructor(_: never);
}

interface Literal<
  Literals extends array_.NonEmptyReadonlyArray<AST.LiteralValue>,
> extends AnnotableClass<Literal<Literals>, Literals[number]> {
  constructor(_: never);
  readonly literals: Readonly<Literals>;
}

interface Map$<K extends Schema.Any, V extends Schema.Any> extends transform<
  Array$<Tuple2<K, V>>,
  MapFromSelf<SchemaClass<Schema.Type<K>>, SchemaClass<Schema.Type<V>>>
> {
  constructor(_: never);
}

interface MapFromSelf<K extends Schema.Any, V extends Schema.Any> extends AnnotableDeclare<
  MapFromSelf<K, V>,
  Map<Schema.Type<K>, Schema.Type<V>>,
  ReadonlyMap<Schema.Encoded<K>, Schema.Encoded<V>>,
  [K, V]
> {
  constructor(_: never);
}

interface mutable<S extends Schema.Any> extends AnnotableClass<
  mutable<S>,
  SimplifyMutable<Schema.Type<S>>,
  SimplifyMutable<Schema.Encoded<S>>,
  Schema.Context<S>
> {
  constructor(_: never);
}

interface NonEmptyArray<Value extends Schema.Any> extends AnnotableClass<
  NonEmptyArray<Value>,
  array_.NonEmptyReadonlyArray<Schema.Type<Value>>,
  array_.NonEmptyReadonlyArray<Schema.Encoded<Value>>,
  Schema.Context<Value>
> {
  constructor(_: never);
  readonly elements: readonly [Value];
  readonly rest: readonly [Value];
  readonly value: Value;
}

interface NonEmptyArrayEnsure<Value extends Schema.Any> extends transform<
  Union<[Value, NonEmptyArray<Value>]>,
  NonEmptyArray<SchemaClass<Schema.Type<Value>>>
> {
  constructor(_: never);
}

interface NonEmptyChunk<Value extends Schema.Any> extends transform<
  NonEmptyArray<Value>,
  NonEmptyChunkFromSelf<SchemaClass<Schema.Type<Value>>>
> {
  constructor(_: never);
}

interface NonEmptyChunkFromSelf<Value extends Schema.Any> extends AnnotableDeclare<
  NonEmptyChunkFromSelf<Value>,
  chunk_.NonEmptyChunk<Schema.Type<Value>>,
  chunk_.NonEmptyChunk<Schema.Encoded<Value>>,
  [Value]
> {
  constructor(_: never);
}

interface NullishOr<S extends Schema.All> extends Union<[S, typeof Null, typeof Undefined]> {
  constructor(_: never);
  annotations(annotations: Schema<Type<S> | null | undefined>): NullishOr<S>;
}

interface NullOr<S extends Schema.All> extends Union<[S, typeof Null]> {
  constructor(_: never);
  annotations(annotations: Schema<Type<S> | null>): NullOr<S>;
}

interface Option<Value extends Schema.Any> extends transform<
  Union<
    [
      Struct<{
        _tag: Literal<["None"]>;
      }>,
      Struct<{
        _tag: Literal<["Some"]>;
        value: Value;
      }>,
    ]
  >,
  OptionFromSelf<SchemaClass<Schema.Type<Value>>>
> {
  constructor(_: never);
}

interface optional<S extends Schema.All> extends PropertySignature<
  "?:",
  Schema.Type<S> | undefined,
  never,
  "?:",
  Schema.Encoded<S> | undefined,
  false,
  Schema.Context<S>
> {
  readonly from: S;
  annotations(annotations: Annotations<Type<S> | undefined>): optional<S>;
}

interface optionalWith<S extends Schema.All, Options> extends PropertySignature<
  Types.Has<Options, "as" | "default"> extends true ? ":" : "?:",
  Types.Has<Options, "as"> extends true
    ? option_.Option<Schema.Type<S>>
    : Schema.Type<S> | Types.Has<Options, "as" | "default" | "exact"> extends true
      ? never
      : undefined,
  never,
  "?:",
  Schema.Encoded<S> | Types.Has<Options, "nullable"> extends true
    ? null
    : never | Types.Has<Options, "exact"> extends true
      ? never
      : undefined,
  Types.Has<Options, "default">,
  Schema.Context<S>
> {
  readonly from: S;
  annotations(
    annotations: Annotations<
      Has<Options, "as"> extends true
        ? Option<Type<S>>
        : Type<S> | Has<Options, "default" | "as" | "exact"> extends true
          ? never
          : undefined
    >,
  ): optionalWith<S, Options>;
}

interface OptionFromNullishOr<Value extends Schema.Any> extends transform<
  NullishOr<Value>,
  OptionFromSelf<SchemaClass<Schema.Type<Value>>>
> {
  constructor(_: never);
}

interface OptionFromNullOr<Value extends Schema.Any> extends transform<
  NullOr<Value>,
  OptionFromSelf<SchemaClass<Schema.Type<Value>>>
> {
  constructor(_: never);
}

interface OptionFromSelf<Value extends Schema.Any> extends AnnotableDeclare<
  OptionFromSelf<Value>,
  option_.Option<Schema.Type<Value>>,
  option_.Option<Schema.Encoded<Value>>,
  [Value]
> {
  constructor(_: never);
}

interface OptionFromUndefinedOr<Value extends Schema.Any> extends transform<
  UndefinedOr<Value>,
  OptionFromSelf<SchemaClass<Schema.Type<Value>>>
> {
  constructor(_: never);
}

interface ReadonlyMap$<K extends Schema.Any, V extends Schema.Any> extends transform<
  Array$<Tuple2<K, V>>,
  ReadonlyMapFromSelf<SchemaClass<Schema.Type<K>>, SchemaClass<Schema.Type<V>>>
> {
  constructor(_: never);
}

interface ReadonlyMapFromSelf<K extends Schema.Any, V extends Schema.Any> extends AnnotableDeclare<
  ReadonlyMapFromSelf<K, V>,
  ReadonlyMap<Schema.Type<K>, Schema.Type<V>>,
  ReadonlyMap<Schema.Encoded<K>, Schema.Encoded<V>>,
  [K, V]
> {
  constructor(_: never);
}

interface ReadonlySet$<Value extends Schema.Any> extends transform<
  Array$<Value>,
  ReadonlySetFromSelf<SchemaClass<Schema.Type<Value>>>
> {
  constructor(_: never);
}

interface ReadonlySetFromSelf<Value extends Schema.Any> extends AnnotableDeclare<
  ReadonlySetFromSelf<Value>,
  ReadonlySet<Schema.Type<Value>>,
  ReadonlySet<Schema.Encoded<Value>>,
  [Value]
> {
  constructor(_: never);
}

interface Record$<K extends Schema.All, V extends Schema.All> extends AnnotableClass<
  Record$<K, V>,
  { [P in Schema.Type<K>]: Schema.Type<V> },
  { [P in Schema.Encoded<K>]: Schema.Encoded<V> },
  Schema.Context<K> | Schema.Context<V>
> {
  constructor(_: never);
  readonly fields: {};
  readonly key: K;
  readonly records: readonly [
    {
      readonly key: K;
      readonly value: V;
    },
  ];
  readonly value: V;
  annotations(annotations: Schema<{ [P in any]: Type<V> }>): Record$<K, V>;
  make(props: void | { [P in any]: Type<V> }, options?: MakeOptions): { [P in any]: Type<V> };
}

interface Redacted<Value extends Schema.Any> extends transform<
  Value,
  RedactedFromSelf<SchemaClass<Schema.Type<Value>>>
> {
  constructor(_: never);
}

interface RedactedFromSelf<Value extends Schema.Any> extends AnnotableDeclare<
  RedactedFromSelf<Value>,
  redacted_.Redacted<Schema.Type<Value>>,
  redacted_.Redacted<Schema.Encoded<Value>>,
  [Value]
> {
  constructor(_: never);
}

interface refine<A, From extends Schema.Any> extends AnnotableClass<
  refine<A, From>,
  A,
  Schema.Encoded<From>,
  Schema.Context<From>
> {
  constructor(_: never);
  readonly [RefineSchemaId]: From;
  readonly filter: (a: Type<From>, options: ParseOptions, self: Refinement) => Option<ParseIssue>;
  readonly from: From;
  make(a: Type<From>, options?: MakeOptions): A;
}

interface Set$<Value extends Schema.Any> extends transform<
  Array$<Value>,
  SetFromSelf<SchemaClass<Schema.Type<Value>>>
> {
  constructor(_: never);
}

interface SetFromSelf<Value extends Schema.Any> extends AnnotableDeclare<
  SetFromSelf<Value>,
  Set<Schema.Type<Value>>,
  ReadonlySet<Schema.Encoded<Value>>,
  [Value]
> {
  constructor(_: never);
}

interface SortedSet<Value extends Schema.Any> extends transform<
  Array$<Value>,
  SortedSetFromSelf<SchemaClass<Schema.Type<Value>>>
> {
  constructor(_: never);
}

interface SortedSetFromSelf<Value extends Schema.Any> extends AnnotableDeclare<
  SortedSetFromSelf<Value>,
  sortedSet_.SortedSet<Schema.Type<Value>>,
  sortedSet_.SortedSet<Schema.Encoded<Value>>,
  [Value]
> {
  constructor(_: never);
}

interface Struct<Fields extends Struct.Fields> extends AnnotableClass<Struct<Fields>, Simplify<Struct.Type<Fields>>, Simplify<Struct.Encoded<Fields>>, Struct.Context<Fields>> {
  constructor(_: never);
  readonly fields: Readonly<Fields>;
  readonly records: readonly [];
  annotations(annotations: Schema<{ [K in string | number | symbol]: Type<Fields>[K] }>): Struct<Fields>;
  make(props: RequiredKeys<Constructor<Fields>> extends never ? void | { [K in string | number | symbol]: Constructor<Fields>[K] } : { [K in string | number | symbol]: Constructor<Fields>[K] }, options?: MakeOptions): { [K in string | number | symbol]: Type<Fields>[K] };
  omit<Keys extends readonly Array<keyof Fields>>(...keys: Keys): Struct<{ [K in string | number | symbol]: Omit<Fields, Keys[number]>[K] }>;
  pick<Keys extends readonly Array<keyof Fields>>(...keys: Keys): Struct<{ [K in string | number | symbol]: Pick<Fields, Keys[number]>[K] }>;
}

interface suspend<A, I, R> extends AnnotableClass<suspend<A, I, R>, A, I, R> {
  constructor(_: never);
}

interface tag<Tag extends AST.LiteralValue> extends PropertySignature<
  ":",
  Tag,
  never,
  ":",
  Tag,
  true,
  never
> {}

interface TaggedClass<Self, Tag extends string, Fields extends Struct.Fields> extends Class<
  Self,
  Fields,
  Struct.Encoded<Fields>,
  Struct.Context<Fields>,
  Struct.Constructor<Omit<Fields, "_tag">>,
  {},
  {}
> {
  constructor(
    props: RequiredKeys<Constructor<Omit<Fields, "_tag">>> extends never
      ? void | { [K in string | number | symbol]: Constructor<Omit<Fields, "_tag">>[K] }
      : { [K in string | number | symbol]: Constructor<Omit<Fields, "_tag">>[K] },
    options?: MakeOptions,
  );
  readonly _tag: Tag;
}

interface TaggedErrorClass<Self, Tag extends string, Fields extends Struct.Fields> extends Class<
  Self,
  Fields,
  Struct.Encoded<Fields>,
  Struct.Context<Fields>,
  Struct.Constructor<Omit<Fields, "_tag">>,
  {},
  cause_.YieldableError
> {
  constructor(
    props: RequiredKeys<Constructor<Omit<Fields, "_tag">>> extends never
      ? void | { [K in string | number | symbol]: Constructor<Omit<Fields, "_tag">>[K] }
      : { [K in string | number | symbol]: Constructor<Omit<Fields, "_tag">>[K] },
    options?: MakeOptions,
  );
  readonly _tag: Tag;
}

interface TaggedRequestClass<
  Self,
  Tag extends string,
  Payload extends Struct.Fields,
  Success extends Schema.All,
  Failure extends Schema.All,
> extends Class<
  Self,
  Payload,
  Struct.Encoded<Payload>,
  Struct.Context<Payload>,
  Struct.Constructor<Omit<Payload, "_tag">>,
  TaggedRequest<
    Tag,
    Self,
    Struct.Encoded<Payload>,
    Struct.Context<Payload>,
    Schema.Type<Success>,
    Schema.Encoded<Success>,
    Schema.Type<Failure>,
    Schema.Encoded<Failure>,
    Schema.Context<Success> | Schema.Context<Failure>
  >,
  {}
> {
  constructor(
    props: RequiredKeys<Constructor<Omit<Payload, "_tag">>> extends never
      ? void | { [K in string | number | symbol]: Constructor<Omit<Payload, "_tag">>[K] }
      : { [K in string | number | symbol]: Constructor<Omit<Payload, "_tag">>[K] },
    options?: MakeOptions,
  );
  readonly _tag: Tag;
  readonly failure: Failure;
  readonly success: Success;
}

type TaggedStruct<Tag extends AST.LiteralValue, Fields extends Struct.Fields> = Struct<
  {
    _tag: tag<Tag>;
  } & Fields
>;

interface transform<From extends Schema.All, To extends Schema.All> extends transformOrFail<
  From,
  To
> {
  constructor(_: never);
  annotations(annotations: Schema<Type<To>>): transform<From, To>;
}

interface transformLiteral<
  Type extends AST.LiteralValue,
  Encoded extends AST.LiteralValue,
> extends transform<Literal<[Encoded]>, Literal<[Type]>> {
  constructor(_: never);
  annotations(annotations: Schema<Type>): transformLiteral<Type, Encoded>;
}

interface transformOrFail<
  From extends Schema.All,
  To extends Schema.All,
  R = never,
> extends AnnotableClass<
  transformOrFail<From, To, R>,
  Schema.Type<To>,
  Schema.Encoded<From>,
  Schema.Context<From> | Schema.Context<To> | R
> {
  constructor(_: never);
  readonly from: From;
  readonly to: To;
}

interface Tuple<Elements extends TupleType.Elements> extends TupleType<Elements, []> {
  constructor(_: never);
  annotations(annotations: Schema<ElementsType<Elements, readonly []>>): Tuple<Elements>;
}

interface Tuple2<Fst extends Schema.Any, Snd extends Schema.Any> extends AnnotableClass<
  Tuple2<Fst, Snd>,
  readonly [Schema.Type<Fst>, Schema.Type<Snd>],
  readonly [Schema.Encoded<Fst>, Schema.Encoded<Snd>],
  Schema.Context<Fst> | Schema.Context<Snd>
> {
  constructor(_: never);
  readonly elements: readonly [Fst, Snd];
  readonly rest: readonly [];
}

interface TupleType<
  Elements extends TupleType.Elements,
  Rest extends TupleType.Rest,
> extends AnnotableClass<
  TupleType<Elements, Rest>,
  TupleType.Type<Elements, Rest>,
  TupleType.Encoded<Elements, Rest>,
  Schema.Context<Elements[number]> | Schema.Context<Rest[number]>
> {
  constructor(_: never);
  readonly elements: Readonly<Elements>;
  readonly rest: Readonly<Rest>;
}

interface TypeLiteral<
  Fields extends Struct.Fields,
  Records extends IndexSignature.Records,
> extends AnnotableClass<
  TypeLiteral<Fields, Records>,
  Simplify<TypeLiteral.Type<Fields, Records>>,
  Simplify<TypeLiteral.Encoded<Fields, Records>>,
  Struct.Context<Fields> | IndexSignature.Context<Records>
> {
  constructor(_: never);
  readonly fields: Readonly<Fields>;
  readonly records: Readonly<Records>;
  annotations(
    annotations: Schema<{ [K in string | number | symbol]: Type<Fields, Records>[K] }>,
  ): TypeLiteral<Fields, Records>;
  make(
    props: RequiredKeys<Constructor<Fields, Records>> extends never
      ? void | { [K in string | number | symbol]: Constructor<Fields, Records>[K] }
      : { [K in string | number | symbol]: Constructor<Fields, Records>[K] },
    options?: MakeOptions,
  ): { [K in string | number | symbol]: Type<Fields, Records>[K] };
}

interface UndefinedOr<S extends Schema.All> extends Union<[S, typeof Undefined]> {
  constructor(_: never);
  annotations(annotations: Schema<Type<S> | undefined>): UndefinedOr<S>;
}

interface Union<Members extends ReadonlyArray<Schema.All>> extends AnnotableClass<
  Union<Members>,
  Schema.Type<Members[number]>,
  Schema.Encoded<Members[number]>,
  Schema.Context<Members[number]>
> {
  constructor(_: never);
  readonly members: Readonly<Members>;
}

interface Element<S extends Schema.Any, Token extends Element.Token> extends Variance<
  Schema.Type<S>,
  Schema.Encoded<S>,
  Schema.Context<S>
> {
  readonly _Token: Token;
  readonly ast: OptionalType;
  readonly from: S;
  annotations(annotations: Annotations<Type<S>>): Element<S, Token>;
}