export interface Annotated {
  readonly annotations: Annotations
}

export interface Annotations {
  readonly [_: symbol]: unknown
}

export type BrandAnnotation = ReadonlyArray<string>

export declare const BrandAnnotationId: typeof BrandAnnotationId

export type DefaultAnnotation = unknown

export declare const DefaultAnnotationId: typeof DefaultAnnotationId

export type DescriptionAnnotation = string

export declare const DescriptionAnnotationId: typeof DescriptionAnnotationId

export type DocumentationAnnotation = string

export declare const DocumentationAnnotationId: typeof DocumentationAnnotationId

export type ExamplesAnnotation = ReadonlyArray<unknown>

export declare const ExamplesAnnotationId: typeof ExamplesAnnotationId

export type IdentifierAnnotation = string

export declare const IdentifierAnnotationId: typeof IdentifierAnnotationId

export type JSONSchemaAnnotation = object

export declare const JSONSchemaAnnotationId: typeof JSONSchemaAnnotationId

export type MessageAnnotation<A> = (a: A) => string

export declare const MessageAnnotationId: typeof MessageAnnotationId

export type TitleAnnotation = string

export declare const TitleAnnotationId: typeof TitleAnnotationId

export type TypeAnnotation = symbol

export declare const TypeAnnotationId: typeof TypeAnnotationId

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

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

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

export declare const getExamplesAnnotation: (annotated: Annotated) => Option.Option<ExamplesAnnotation>

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

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

export declare const getMessageAnnotation: (annotated: Annotated) => Option.Option<MessageAnnotation<unknown>>

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

export declare const anyKeyword: AnyKeyword

export declare const bigIntKeyword: BigIntKeyword

export declare const booleanKeyword: BooleanKeyword

export declare const composeTransformation: ComposeTransformation

export declare const createDeclaration: (
  typeParameters: ReadonlyArray<AST>,
  type: AST,
  decode: Declaration["decode"],
  annotations?: Annotated["annotations"]
) => Declaration

export declare const createEnums: (
  enums: ReadonlyArray<readonly [string, string | number]>,
  annotations?: Annotated["annotations"]
) => Enums

export declare const createFinalPropertySignatureTransformation: (
  decode: FinalPropertySignatureTransformation["decode"],
  encode: FinalPropertySignatureTransformation["encode"]
) => FinalPropertySignatureTransformation

export declare const createFinalTransformation: (
  decode: FinalTransformation["decode"],
  encode: FinalTransformation["encode"]
) => FinalTransformation

export declare const createLiteral: (literal: LiteralValue, annotations?: Annotated["annotations"]) => Literal

export declare const createPropertySignatureTransform: (
  from: PropertyKey,
  to: PropertyKey,
  propertySignatureTransformation: PropertySignatureTransformation
) => PropertySignatureTransform

export declare const createRefinement: <From extends AST>(
  from: From,
  filter: Refinement["filter"],
  annotations?: Annotated["annotations"]
) => Transform | Refinement<From>

export declare const createSuspend: (f: () => AST, annotations?: Annotated["annotations"]) => Suspend

export declare const createTemplateLiteral: (
  head: string,
  spans: ReadonlyArray<TemplateLiteralSpan>,
  annotations?: Annotated["annotations"]
) => TemplateLiteral | Literal

export declare const createTuple: (
  elements: ReadonlyArray<Element>,
  rest: Option.Option<ReadonlyArray.NonEmptyReadonlyArray<AST>>,
  isReadonly: boolean,
  annotations?: Annotated["annotations"]
) => Tuple

export declare const createTypeLiteral: (
  propertySignatures: ReadonlyArray<PropertySignature>,
  indexSignatures: ReadonlyArray<IndexSignature>,
  annotations?: Annotated["annotations"]
) => TypeLiteral

export declare const createTypeLiteralTransformation: (
  propertySignatureTransformations: TypeLiteralTransformation["propertySignatureTransformations"]
) => TypeLiteralTransformation

export declare const createUnion: (candidates: ReadonlyArray<AST>, annotations?: Annotated["annotations"]) => AST

export declare const createUniqueSymbol: (symbol: symbol, annotations?: Annotated["annotations"]) => UniqueSymbol

export declare const neverKeyword: NeverKeyword

export declare const numberKeyword: NumberKeyword

export declare const objectKeyword: ObjectKeyword

export declare const stringKeyword: StringKeyword

export declare const symbolKeyword: SymbolKeyword

export declare const undefinedKeyword: UndefinedKeyword

export declare const unknownKeyword: UnknownKeyword

export declare const voidKeyword: VoidKeyword

export declare const isComposeTransformation: (ast: Transformation) => ast is ComposeTransformation

export declare const isFinalPropertySignatureTransformation: (
  ast: PropertySignatureTransformation
) => ast is FinalPropertySignatureTransformation

export declare const isFinalTransformation: (ast: Transformation) => ast is FinalTransformation

export declare const isTypeLiteralTransformation: (ast: Transformation) => ast is TypeLiteralTransformation

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

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

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

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

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

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

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

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

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

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

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

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

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

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

export declare const isTransform: (ast: AST) => ast is Transform

export declare const isTuple: (ast: AST) => ast is Tuple

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

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

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

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

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

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

export type AST =
  | Declaration
  | Literal
  | UniqueSymbol
  | UndefinedKeyword
  | VoidKeyword
  | NeverKeyword
  | UnknownKeyword
  | AnyKeyword
  | StringKeyword
  | NumberKeyword
  | BooleanKeyword
  | BigIntKeyword
  | SymbolKeyword
  | ObjectKeyword
  | Enums
  | TemplateLiteral
  // possible transformations
  | Refinement
  | Tuple
  | TypeLiteral
  | Union
  | Suspend
  // transformations
  | Transform

export interface AnyKeyword extends Annotated {
  readonly _tag: "AnyKeyword"
}

export interface BigIntKeyword extends Annotated {
  readonly _tag: "BigIntKeyword"
}

export interface BooleanKeyword extends Annotated {
  readonly _tag: "BooleanKeyword"
}

export interface ComposeTransformation {
  readonly _tag: "ComposeTransformation"
}

export interface Declaration extends Annotated {
  readonly _tag: "Declaration"
  readonly typeParameters: ReadonlyArray<AST>
  readonly type: AST
  readonly decode: (
    isDecoding: boolean,
    ...typeParameters: ReadonlyArray<AST>
  ) => (input: any, options: ParseOptions, self: AST) => ParseResult.ParseResult<any>
}

export interface Enums extends Annotated {
  readonly _tag: "Enums"
  readonly enums: ReadonlyArray<readonly [string, string | number]>
}

export interface FinalPropertySignatureTransformation {
  readonly _tag: "FinalPropertySignatureTransformation"
  readonly decode: (o: Option.Option<any>) => Option.Option<any>
  readonly encode: (o: Option.Option<any>) => Option.Option<any>
}

export interface FinalTransformation {
  readonly _tag: "FinalTransformation"
  readonly decode: (input: any, options: ParseOptions, self: AST) => ParseResult.ParseResult<any>
  readonly encode: (input: any, options: ParseOptions, self: AST) => ParseResult.ParseResult<any>
}

export interface Literal extends Annotated {
  readonly _tag: "Literal"
  readonly literal: LiteralValue
}

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

export interface NeverKeyword extends Annotated {
  readonly _tag: "NeverKeyword"
}

export interface NumberKeyword extends Annotated {
  readonly _tag: "NumberKeyword"
}

export interface ObjectKeyword extends Annotated {
  readonly _tag: "ObjectKeyword"
}

export interface ParseOptions {
  /** default "first" */
  readonly errors?: "first" | "all"
  /** default "ignore" */
  readonly onExcessProperty?: "ignore" | "error"
}

export interface PropertySignatureTransform {
  readonly from: PropertyKey
  readonly to: PropertyKey
  readonly propertySignatureTransformation: PropertySignatureTransformation
}

export type PropertySignatureTransformation = FinalPropertySignatureTransformation

export interface Refinement<From = AST> extends Annotated {
  readonly _tag: "Refinement"
  readonly from: From
  readonly filter: (input: any, options: ParseOptions, self: AST) => Option.Option<ParseResult.ParseError>
}

export interface StringKeyword extends Annotated {
  readonly _tag: "StringKeyword"
}

export interface Suspend extends Annotated {
  readonly _tag: "Suspend"
  readonly f: () => AST
}

export interface SymbolKeyword extends Annotated {
  readonly _tag: "SymbolKeyword"
}

export interface TemplateLiteral extends Annotated {
  readonly _tag: "TemplateLiteral"
  readonly head: string
  readonly spans: ReadonlyArray.NonEmptyReadonlyArray<TemplateLiteralSpan>
}

export interface Transform extends Annotated {
  readonly _tag: "Transform"
  readonly from: AST
  readonly to: AST
  readonly transformation: Transformation
}

export type Transformation = FinalTransformation | ComposeTransformation | TypeLiteralTransformation

export interface Tuple extends Annotated {
  readonly _tag: "Tuple"
  readonly elements: ReadonlyArray<Element>
  readonly rest: Option.Option<ReadonlyArray.NonEmptyReadonlyArray<AST>>
  readonly isReadonly: boolean
}

export interface TypeLiteral extends Annotated {
  readonly _tag: "TypeLiteral"
  readonly propertySignatures: ReadonlyArray<PropertySignature>
  readonly indexSignatures: ReadonlyArray<IndexSignature>
}

export interface TypeLiteralTransformation {
  readonly _tag: "TypeLiteralTransformation"
  readonly propertySignatureTransformations: ReadonlyArray<PropertySignatureTransform>
}

export interface UndefinedKeyword extends Annotated {
  readonly _tag: "UndefinedKeyword"
}

export interface Union extends Annotated {
  readonly _tag: "Union"
  readonly types: Members<AST>
}

export interface UniqueSymbol extends Annotated {
  readonly _tag: "UniqueSymbol"
  readonly symbol: symbol
}

export interface UnknownKeyword extends Annotated {
  readonly _tag: "UnknownKeyword"
}

export interface VoidKeyword extends Annotated {
  readonly _tag: "VoidKeyword"
}

export declare const createTransform: (
  from: AST,
  to: AST,
  transformation: Transformation,
  annotations?: Annotated["annotations"]
) => Transform

export type Compiler<A> = (ast: AST) => A

export interface Element {
  readonly type: AST
  readonly isOptional: boolean
}

export interface IndexSignature {
  readonly parameter: Parameter
  readonly type: AST
  readonly isReadonly: boolean
}

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

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

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

export interface PropertySignature extends Annotated {
  readonly name: PropertyKey
  readonly type: AST
  readonly isOptional: boolean
  readonly isReadonly: boolean
}

export interface TemplateLiteralSpan {
  readonly type: StringKeyword | NumberKeyword
  readonly literal: string
}

export declare const appendElement: (ast: Tuple, newElement: Element) => Tuple

export declare const appendRestElement: (ast: Tuple, restElement: AST) => Tuple

export declare const createElement: (type: AST, isOptional: boolean) => Element

export declare const createIndexSignature: (parameter: AST, type: AST, isReadonly: boolean) => IndexSignature

export declare const createPropertySignature: (
  name: PropertyKey,
  type: AST,
  isOptional: boolean,
  isReadonly: boolean,
  annotations?: Annotated["annotations"]
) => PropertySignature

export declare const createRecord: (key: AST, value: AST, isReadonly: boolean) => TypeLiteral

export declare const from: (ast: AST) => AST

export declare const getCompiler: <A>(match: Match<A>) => Compiler<A>

export declare const getPropertySignatures: (ast: AST) => ReadonlyArray<PropertySignature>

export declare const isParameter: (ast: AST) => ast is Parameter

export declare const keyof: (ast: AST) => AST

export declare const mergeAnnotations: (ast: AST, annotations: Annotated["annotations"]) => AST

export declare const mutable: (ast: AST) => AST

export declare const omit: (ast: AST, keys: ReadonlyArray<PropertyKey>) => TypeLiteral

export declare const partial: (ast: AST) => AST

export declare const pick: (ast: AST, keys: ReadonlyArray<PropertyKey>) => TypeLiteral

export declare const required: (ast: AST) => AST

export declare const setAnnotation: (ast: AST, sym: symbol, value: unknown) => AST

export declare const to: (ast: AST) => AST