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;
}