SchemaAST

interface Annotated {
  readonly annotations: Annotations;
}

interface Annotations {
  [_: string]: unknown;
  [_: symbol]: unknown;
}

declare const ArbitraryAnnotationId: unique symbol;

type BatchingAnnotation = boolean | "inherit" | undefined;

declare const BatchingAnnotationId: unique symbol;

type BrandAnnotation = Arr.NonEmptyReadonlyArray<string | symbol>;

declare const BrandAnnotationId: unique symbol;

type ConcurrencyAnnotation = Concurrency | undefined;

declare const ConcurrencyAnnotationId: unique symbol;

type DecodingFallbackAnnotation<A> = (issue: ParseIssue) => Effect<A, ParseIssue>;

declare const DecodingFallbackAnnotationId: unique symbol;

type DefaultAnnotation<A> = A;

declare const DefaultAnnotationId: unique symbol;

type DescriptionAnnotation = string;

declare const DescriptionAnnotationId: unique symbol;

type DocumentationAnnotation = string;

declare const DocumentationAnnotationId: unique symbol;

type EquivalenceAnnotation<A, TypeParameters extends ReadonlyArray<any> = readonly []> = (
  ...equivalences: { [K in keyof TypeParameters]: Equivalence<TypeParameters[K]> }
) => Equivalence<A>;

declare const EquivalenceAnnotationId: unique symbol;

type ExamplesAnnotation<A> = Arr.NonEmptyReadonlyArray<A>;

declare const ExamplesAnnotationId: unique symbol;

declare const getAnnotation: {
  <A>(key: symbol): (annotated: Annotated) => Option<A>;
  <A>(annotated: Annotated, key: symbol): Option<A>;
};

declare const getBatchingAnnotation: (annotated: Annotated) => Option<BatchingAnnotation>;

declare const getBrandAnnotation: (
  annotated: Annotated,
) => Option<readonly [string | symbol, string | symbol]>;

declare const getConcurrencyAnnotation: (annotated: Annotated) => Option<ConcurrencyAnnotation>;

declare const getDecodingFallbackAnnotation: (
  annotated: Annotated,
) => Option<DecodingFallbackAnnotation<unknown>>;

declare const getDefaultAnnotation: (annotated: Annotated) => Option<unknown>;

declare const getDescriptionAnnotation: (annotated: Annotated) => Option<string>;

declare const getDocumentationAnnotation: (annotated: Annotated) => Option<string>;

declare const getExamplesAnnotation: (annotated: Annotated) => Option<readonly [unknown, unknown]>;

declare const getIdentifierAnnotation: (annotated: Annotated) => Option<string>;

declare function getJSONIdentifier(annotated: Annotated): Option<string>;

declare const getJSONIdentifierAnnotation: (annotated: Annotated) => Option<string>;

declare const getJSONSchemaAnnotation: (annotated: Annotated) => Option<object>;

declare const getMessageAnnotation: (annotated: Annotated) => Option<MessageAnnotation>;

declare const getMissingMessageAnnotation: (
  annotated: Annotated,
) => Option<MissingMessageAnnotation>;

declare const getParseIssueTitleAnnotation: (
  annotated: Annotated,
) => Option<ParseIssueTitleAnnotation>;

declare const getParseOptionsAnnotation: (annotated: Annotated) => Option<ParseOptions>;

declare const getSchemaIdAnnotation: (annotated: Annotated) => Option<SchemaIdAnnotation>;

declare const getSurrogateAnnotation: (annotated: Annotated) => Option<AST>;

declare const getTitleAnnotation: (annotated: Annotated) => Option<string>;

declare const getTypeConstructorAnnotation: (
  annotated: Annotated,
) => Option<TypeConstructorAnnotation>;

type IdentifierAnnotation = string;

declare const IdentifierAnnotationId: unique symbol;

declare const JSONIdentifierAnnotationId: unique symbol;

type JSONSchemaAnnotation = object;

declare const JSONSchemaAnnotationId: unique symbol;

type MessageAnnotation = (issue: ParseIssue) =>
  | string
  | Effect<string>
  | {
      readonly message: string | Effect<string>;
      readonly override: boolean;
    };

declare const MessageAnnotationId: unique symbol;

type MissingMessageAnnotation = () => string | Effect<string>;

declare const MissingMessageAnnotationId: unique symbol;

type ParseIssueTitleAnnotation = (issue: ParseIssue) => string | undefined;

declare const ParseIssueTitleAnnotationId: unique symbol;

declare const ParseOptionsAnnotationId: unique symbol;

declare const PrettyAnnotationId: unique symbol;

type SchemaIdAnnotation = string | symbol;

declare const SchemaIdAnnotationId: unique symbol;

type SurrogateAnnotation = AST;

declare const SurrogateAnnotationId: unique symbol;

type TitleAnnotation = string;

declare const TitleAnnotationId: unique symbol;

type TypeConstructorAnnotation = {
  [key: string | number | symbol]: unknown;
  readonly _tag: string;
};

declare const TypeConstructorAnnotationId: unique symbol;

declare const anyKeyword: AnyKeyword;

declare const bigIntKeyword: BigIntKeyword;

declare const booleanKeyword: BooleanKeyword;

declare const composeTransformation: ComposeTransformation;

declare const neverKeyword: NeverKeyword;

declare const numberKeyword: NumberKeyword;

declare const objectKeyword: ObjectKeyword;

declare const stringKeyword: StringKeyword;

declare const symbolKeyword: SymbolKeyword;

declare const undefinedKeyword: UndefinedKeyword;

declare const unknownKeyword: UnknownKeyword;

declare const voidKeyword: VoidKeyword;

declare const isAnyKeyword: (ast: AST) => ast is AnyKeyword;

declare const isBigIntKeyword: (ast: AST) => ast is BigIntKeyword;

declare const isBooleanKeyword: (ast: AST) => ast is BooleanKeyword;

declare const isComposeTransformation: (ast: TransformationKind) => ast is ComposeTransformation;

declare const isDeclaration: (ast: AST) => ast is Declaration;

declare const isEnums: (ast: AST) => ast is Enums;

declare const isFinalTransformation: (ast: TransformationKind) => ast is FinalTransformation;

declare const isLiteral: (ast: AST) => ast is Literal;

declare const isNeverKeyword: (ast: AST) => ast is NeverKeyword;

declare const isNumberKeyword: (ast: AST) => ast is NumberKeyword;

declare const isObjectKeyword: (ast: AST) => ast is ObjectKeyword;

declare const isRefinement: (ast: AST) => ast is Refinement<AST>;

declare const isStringKeyword: (ast: AST) => ast is StringKeyword;

declare const isSuspend: (ast: AST) => ast is Suspend;

declare const isSymbolKeyword: (ast: AST) => ast is SymbolKeyword;

declare const isTemplateLiteral: (ast: AST) => ast is TemplateLiteral;

declare const isTransformation: (ast: AST) => ast is Transformation;

declare const isTupleType: (ast: AST) => ast is TupleType;

declare const isTypeLiteral: (ast: AST) => ast is TypeLiteral;

declare const isTypeLiteralTransformation: (
  ast: TransformationKind,
) => ast is TypeLiteralTransformation;

declare const isUndefinedKeyword: (ast: AST) => ast is UndefinedKeyword;

declare const isUnion: (ast: AST) => ast is Union;

declare const isUniqueSymbol: (ast: AST) => ast is UniqueSymbol;

declare const isUnknownKeyword: (ast: AST) => ast is UnknownKeyword;

declare const isVoidKeyword: (ast: AST) => ast is VoidKeyword;

declare class AnyKeyword implements Annotated {
  constructor(annotations: Annotations);
  readonly _tag: "AnyKeyword";
  readonly annotations: Annotations;
  toJSON(): object;
  toString(): string;
}

type AST =
  | Declaration
  | Literal
  | UniqueSymbol
  | UndefinedKeyword
  | VoidKeyword
  | NeverKeyword
  | UnknownKeyword
  | AnyKeyword
  | StringKeyword
  | NumberKeyword
  | BooleanKeyword
  | BigIntKeyword
  | SymbolKeyword
  | ObjectKeyword
  | Enums
  | TemplateLiteral
  | Refinement
  | TupleType
  | TypeLiteral
  | Union
  | Suspend
  | Transformation;

declare class BigIntKeyword implements Annotated {
  constructor(annotations: Annotations);
  readonly _tag: "BigIntKeyword";
  readonly annotations: Annotations;
  toJSON(): object;
  toString(): string;
}

declare class BooleanKeyword implements Annotated {
  constructor(annotations: Annotations);
  readonly _tag: "BooleanKeyword";
  readonly annotations: Annotations;
  toJSON(): object;
  toString(): string;
}

declare class ComposeTransformation {
  constructor();
  readonly _tag: "ComposeTransformation";
}

declare class Declaration implements Annotated {
  constructor(typeParameters: readonly Array<AST>, decodeUnknown: (...typeParameters: readonly Array<AST>) => (input: unknown, options: ParseOptions, self: Declaration) => Effect<any, ParseIssue, any>, encodeUnknown: (...typeParameters: readonly Array<AST>) => (input: unknown, options: ParseOptions, self: Declaration) => Effect<any, ParseIssue, any>, annotations: Annotations);
  readonly _tag: "Declaration";
  readonly annotations: Annotations;
  readonly decodeUnknown: (...typeParameters: readonly Array<AST>) => (input: unknown, options: ParseOptions, self: Declaration) => Effect<any, ParseIssue, any>;
  readonly encodeUnknown: (...typeParameters: readonly Array<AST>) => (input: unknown, options: ParseOptions, self: Declaration) => Effect<any, ParseIssue, any>;
  readonly typeParameters: readonly Array<AST>;
  toJSON(): object;
  toString(): string;
}

declare class Enums implements Annotated {
  constructor(enums: readonly Array<readonly [string, string | number]>, annotations: Annotations);
  readonly _tag: "Enums";
  readonly annotations: Annotations;
  readonly enums: readonly Array<readonly [string, string | number]>;
  toJSON(): object;
  toString(): string;
}

declare class FinalTransformation {
  constructor(
    decode: (
      fromA: any,
      options: ParseOptions,
      self: Transformation,
      fromI: any,
    ) => Effect<any, ParseIssue, any>,
    encode: (
      toI: any,
      options: ParseOptions,
      self: Transformation,
      toA: any,
    ) => Effect<any, ParseIssue, any>,
  );
  readonly _tag: "FinalTransformation";
  readonly decode: (
    fromA: any,
    options: ParseOptions,
    self: Transformation,
    fromI: any,
  ) => Effect<any, ParseIssue, any>;
  readonly encode: (
    toI: any,
    options: ParseOptions,
    self: Transformation,
    toA: any,
  ) => Effect<any, ParseIssue, any>;
}

declare class IndexSignature {
  constructor(parameter: AST, type: AST, isReadonly: boolean);
  readonly isReadonly: boolean;
  readonly parameter: Parameter;
  readonly type: AST;
  toJSON(): object;
  toString(): string;
}

declare class Literal implements Annotated {
  constructor(literal: LiteralValue, annotations: Annotations);
  readonly _tag: "Literal";
  readonly annotations: Annotations;
  readonly literal: LiteralValue;
  toJSON(): object;
  toString(): string;
}

type LiteralValue = string | number | boolean | null | bigint;

declare class NeverKeyword implements Annotated {
  constructor(annotations: Annotations);
  readonly _tag: "NeverKeyword";
  readonly annotations: Annotations;
  toJSON(): object;
  toString(): string;
}

declare class NumberKeyword implements Annotated {
  constructor(annotations: Annotations);
  readonly _tag: "NumberKeyword";
  readonly annotations: Annotations;
  toJSON(): object;
  toString(): string;
}

declare class ObjectKeyword implements Annotated {
  constructor(annotations: Annotations);
  readonly _tag: "ObjectKeyword";
  readonly annotations: Annotations;
  toJSON(): object;
  toString(): string;
}

declare class OptionalType extends Type {
  constructor(type: AST, isOptional: boolean, annotations: Annotations);
  readonly isOptional: boolean;
  toJSON(): object;
  toString(): string;
}

interface ParseOptions {
  readonly errors?: "first" | "all";
  readonly exact?: boolean;
  readonly onExcessProperty?: "error" | "ignore" | "preserve";
  readonly propertyOrder?: "none" | "original";
}

declare class PropertySignature extends OptionalType {
  constructor(
    name: PropertyKey,
    type: AST,
    isOptional: boolean,
    isReadonly: boolean,
    annotations?: Annotations,
  );
  readonly isReadonly: boolean;
  readonly name: PropertyKey;
  toJSON(): object;
  toString(): string;
}

declare class PropertySignatureTransformation {
  constructor(
    from: PropertyKey,
    to: PropertyKey,
    decode: (o: Option<any>) => Option<any>,
    encode: (o: Option<any>) => Option<any>,
  );
  readonly decode: (o: Option<any>) => Option<any>;
  readonly encode: (o: Option<any>) => Option<any>;
  readonly from: PropertyKey;
  readonly to: PropertyKey;
}

declare class Refinement<From extends AST = AST> implements Annotated {
  constructor<From extends AST = AST>(from: From, filter: (input: any, options: ParseOptions, self: Refinement) => Option<ParseIssue>, annotations: Annotations);
  readonly _tag: "Refinement";
  readonly annotations: Annotations;
  readonly filter: (input: any, options: ParseOptions, self: Refinement) => Option<ParseIssue>;
  readonly from: From;
  toJSON(): object;
  toString(): string;
}

declare class StringKeyword implements Annotated {
  constructor(annotations: Annotations);
  readonly _tag: "StringKeyword";
  readonly annotations: Annotations;
  toJSON(): object;
  toString(): string;
}

declare class Suspend implements Annotated {
  constructor(f: () => AST, annotations: Annotations);
  readonly _tag: "Suspend";
  readonly annotations: Annotations;
  readonly f: () => AST;
  toJSON(): object;
  toString(): string;
}

declare class SymbolKeyword implements Annotated {
  constructor(annotations: Annotations);
  readonly _tag: "SymbolKeyword";
  readonly annotations: Annotations;
  toJSON(): object;
  toString(): string;
}

declare class TemplateLiteral implements Annotated {
  constructor(
    head: string,
    spans: readonly [TemplateLiteralSpan, TemplateLiteralSpan],
    annotations: Annotations,
  );
  readonly _tag: "TemplateLiteral";
  readonly annotations: Annotations;
  readonly head: string;
  readonly spans: readonly [TemplateLiteralSpan, TemplateLiteralSpan];
  toJSON(): object;
  toString(): string;
}

declare class TemplateLiteralSpan {
  constructor(type: AST, literal: string);
  readonly literal: string;
  readonly type: TemplateLiteralSpanType;
  toJSON(): object;
  toString(): string;
}

declare class Transformation implements Annotated {
  constructor(from: AST, to: AST, transformation: TransformationKind, annotations: Annotations);
  readonly _tag: "Transformation";
  readonly annotations: Annotations;
  readonly from: AST;
  readonly to: AST;
  readonly transformation: TransformationKind;
  toJSON(): object;
  toString(): string;
}

type TransformationKind = FinalTransformation | ComposeTransformation | TypeLiteralTransformation;

declare class TupleType implements Annotated {
  constructor(elements: readonly Array<OptionalType>, rest: readonly Array<Type>, isReadonly: boolean, annotations: Annotations);
  readonly _tag: "TupleType";
  readonly annotations: Annotations;
  readonly elements: readonly Array<OptionalType>;
  readonly isReadonly: boolean;
  readonly rest: readonly Array<Type>;
  toJSON(): object;
  toString(): string;
}

declare class Type implements Annotated {
  constructor(type: AST, annotations: Annotations);
  readonly annotations: Annotations;
  readonly type: AST;
  toJSON(): object;
  toString(): string;
}

declare class TypeLiteral implements Annotated {
  constructor(propertySignatures: readonly Array<PropertySignature>, indexSignatures: readonly Array<IndexSignature>, annotations: Annotations);
  readonly _tag: "TypeLiteral";
  readonly annotations: Annotations;
  readonly indexSignatures: readonly Array<IndexSignature>;
  readonly propertySignatures: readonly Array<PropertySignature>;
  toJSON(): object;
  toString(): string;
}

declare class TypeLiteralTransformation {
  constructor(propertySignatureTransformations: readonly Array<PropertySignatureTransformation>);
  readonly _tag: "TypeLiteralTransformation";
  readonly propertySignatureTransformations: readonly Array<PropertySignatureTransformation>;
}

declare class UndefinedKeyword implements Annotated {
  constructor(annotations: Annotations);
  readonly _tag: "UndefinedKeyword";
  readonly annotations: Annotations;
  toJSON(): object;
  toString(): string;
}

declare class Union<M extends AST = AST> implements Annotated {
  readonly _tag: "Union";
  readonly annotations: Annotations;
  readonly types: readonly [M, M, M];
  toJSON(): object;
  toString(): string;
  static make(types: readonly Array<AST>, annotations?: Annotations): AST;
}

declare class UniqueSymbol implements Annotated {
  constructor(symbol: symbol, annotations: Annotations);
  readonly _tag: "UniqueSymbol";
  readonly annotations: Annotations;
  readonly symbol: symbol;
  toJSON(): object;
  toString(): string;
}

declare class UnknownKeyword implements Annotated {
  constructor(annotations: Annotations);
  readonly _tag: "UnknownKeyword";
  readonly annotations: Annotations;
  toJSON(): object;
  toString(): string;
}

declare class VoidKeyword implements Annotated {
  constructor(annotations: Annotations);
  readonly _tag: "VoidKeyword";
  readonly annotations: Annotations;
  toJSON(): object;
  toString(): string;
}

declare function annotations(ast: AST, overrides: Annotations): AST;

type Compiler<A> = (ast: AST, path: ReadonlyArray<PropertyKey>) => A;

declare const defaultParseOption: ParseOptions;

declare function encodedAST(ast: AST): AST;

declare function encodedBoundAST(ast: AST): AST;

declare function getCompiler<A>(match: Match<A>): Compiler<A>;

declare function getPropertySignatures(ast: AST): Array<PropertySignature>;

declare function getTemplateLiteralCapturingRegExp(ast: TemplateLiteral): RegExp;

declare function getTemplateLiteralRegExp(ast: TemplateLiteral): RegExp;

declare function isParameter(ast: AST): ast is Parameter;

declare function keyof(ast: AST): AST;

type Match<A> = {
  [K in AST["_tag"]]: (
    ast: Extract<
      AST,
      {
        _tag: K;
      }
    >,
    compile: Compiler<A>,
    path: ReadonlyArray<PropertyKey>,
  ) => A;
};

type Members<A> = readonly [A, A, ...Array<A>];

declare function mutable(ast: AST): AST;

declare const null: Literal

declare function omit(ast: AST, keys: readonly Array<PropertyKey>): TypeLiteral | Transformation

type Parameter = StringKeyword | SymbolKeyword | TemplateLiteral | Refinement<Parameter>;

declare function partial(
  ast: AST,
  options?: {
    readonly exact: true;
  },
): AST;

declare function pick(ast: AST, keys: readonly Array<PropertyKey>): TypeLiteral | Transformation

declare function required(ast: AST): AST;

declare function typeAST(ast: AST): AST;

declare const ParseJsonSchemaId: unique symbol;