export interface Annotated {
  readonly annotations: Annotations
}

export interface Annotations {
  readonly [_: string]: unknown
  readonly [_: 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 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> = (
  ...equivalences: { readonly [K in keyof TypeParameters]: Equivalence<TypeParameters[K]> }
) => Equivalence<A>

declare const EquivalenceAnnotationId: unique symbol

type readonly [A, ...A[]] = Arr.NonEmptyReadonlyArray<A>

declare const ExamplesAnnotationId: unique symbol

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

declare const anyKeyword: AnyKeyword

declare const bigIntKeyword: BigIntKeyword

declare const booleanKeyword: BooleanKeyword

declare const composeTransformation: ComposeTransformation

declare const neverKeyword: NeverKeyword

declare const null: Literal

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

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

declare class AnyKeyword { constructor(readonly annotations: Annotations = {}) }

declare const toString: () => string

declare const toJSON: () => object

readonly _tag: "AnyKeyword"

declare class BigIntKeyword { constructor(readonly annotations: Annotations = {}) }

declare const toString: () => string

declare const toJSON: () => object

readonly _tag: "BigIntKeyword"

declare class BooleanKeyword { constructor(readonly annotations: Annotations = {}) }

declare const toString: () => string

declare const toJSON: () => object

readonly _tag: "BooleanKeyword"

declare class ComposeTransformation

readonly _tag: "ComposeTransformation"

declare class Declaration { constructor(
    readonly typeParameters: ReadonlyArray<AST>,
    readonly decodeUnknown: (
      ...typeParameters: ReadonlyArray<AST>
    ) => (input: unknown, options: ParseOptions, self: Declaration) => Effect<any, ParseIssue, any>,
    readonly encodeUnknown: (
      ...typeParameters: ReadonlyArray<AST>
    ) => (input: unknown, options: ParseOptions, self: Declaration) => Effect<any, ParseIssue, any>,
    readonly annotations: Annotations = {}
  ) }

declare const toString: () => string

declare const toJSON: () => object

readonly _tag: "Declaration"

declare class Enums { constructor(
    readonly enums: ReadonlyArray<readonly [string, string | number]>,
    readonly annotations: Annotations = {}
  ) }

declare const toString: () => string

declare const toJSON: () => object

readonly _tag: "Enums"

declare class FinalTransformation { constructor(
    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>
  ) }

readonly _tag: "FinalTransformation"

declare class IndexSignature { constructor(
    parameter: AST,
    readonly type: AST,
    readonly isReadonly: boolean
  ) }

declare const toString: () => string

declare const toJSON: () => object

readonly parameter: Parameter

declare class Literal { constructor(readonly literal: LiteralValue, readonly annotations: Annotations = {}) }

declare const toString: () => string

declare const toJSON: () => object

readonly _tag: "Literal"

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

declare class NeverKeyword { constructor(readonly annotations: Annotations = {}) }

declare const toString: () => string

declare const toJSON: () => object

readonly _tag: "NeverKeyword"

declare class NumberKeyword { constructor(readonly annotations: Annotations = {}) }

declare const toString: () => string

declare const toJSON: () => object

readonly _tag: "NumberKeyword"

declare class ObjectKeyword { constructor(readonly annotations: Annotations = {}) }

declare const toString: () => string

declare const toJSON: () => object

readonly _tag: "ObjectKeyword"

declare class OptionalType { constructor(
    type: AST,
    readonly isOptional: boolean,
    annotations: Annotations = {}
  ) }

declare const toJSON: () => object

declare const toString: () => string

export interface ParseOptions {
  /**
   * The `errors` option allows you to receive all parsing errors when
   * attempting to parse a value using a schema. By default only the first error
   * is returned, but by setting the `errors` option to `"all"`, you can receive
   * all errors that occurred during the parsing process. This can be useful for
   * debugging or for providing more comprehensive error messages to the user.
   *
   * default: "first"
   *
   * @since 3.10.0
   */
  readonly errors?: "first" | "all" | undefined
  /**
   * When using a `Schema` to parse a value, by default any properties that are
   * not specified in the `Schema` will be stripped out from the output. This is
   * because the `Schema` is expecting a specific shape for the parsed value,
   * and any excess properties do not conform to that shape.
   *
   * However, you can use the `onExcessProperty` option (default value:
   * `"ignore"`) to trigger a parsing error. This can be particularly useful in
   * cases where you need to detect and handle potential errors or unexpected
   * values.
   *
   * If you want to allow excess properties to remain, you can use
   * `onExcessProperty` set to `"preserve"`.
   *
   * default: "ignore"
   *
   * @since 3.10.0
   */
  readonly onExcessProperty?: "ignore" | "error" | "preserve" | undefined
  /**
   * The `propertyOrder` option provides control over the order of object fields
   * in the output. This feature is particularly useful when the sequence of
   * keys is important for the consuming processes or when maintaining the input
   * order enhances readability and usability.
   *
   * By default, the `propertyOrder` option is set to `"none"`. This means that
   * the internal system decides the order of keys to optimize parsing speed.
   * The order of keys in this mode should not be considered stable, and it's
   * recommended not to rely on key ordering as it may change in future updates
   * without notice.
   *
   * Setting `propertyOrder` to `"original"` ensures that the keys are ordered
   * as they appear in the input during the decoding/encoding process.
   *
   * default: "none"
   *
   * @since 3.10.0
   */
  readonly propertyOrder?: "none" | "original" | undefined
  /**
   * Handles missing properties in data structures. By default, missing
   * properties are treated as if present with an `undefined` value. To treat
   * missing properties as errors, set the `exact` option to `true`. This
   * setting is already enabled by default for `is` and `asserts` functions,
   * treating absent properties strictly unless overridden.
   *
   * default: false
   *
   * @since 3.10.0
   */
  readonly exact?: boolean | undefined
}

declare class PropertySignature { constructor(
    readonly name: PropertyKey,
    type: AST,
    isOptional: boolean,
    readonly isReadonly: boolean,
    annotations?: Annotations
  ) }

declare const toString: () => string

declare const toJSON: () => object

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

declare class Refinement<From> { constructor(
    readonly from: From,
    readonly filter: (
      input: any,
      options: ParseOptions,
      self: Refinement
    ) => Option.Option<ParseIssue>,
    readonly annotations: Annotations = {}
  ) }

declare const toString: () => string

declare const toJSON: () => object

readonly _tag: "Refinement"

declare class StringKeyword { constructor(readonly annotations: Annotations = {}) }

declare const toString: () => string

declare const toJSON: () => object

readonly _tag: "StringKeyword"

declare class Suspend { constructor(readonly f: () => AST, readonly annotations: Annotations = {}) }

declare const toString: () => string

declare const toJSON: () => object

readonly _tag: "Suspend"

declare class SymbolKeyword { constructor(readonly annotations: Annotations = {}) }

declare const toString: () => string

declare const toJSON: () => object

readonly _tag: "SymbolKeyword"

declare class TemplateLiteral { constructor(
    readonly head: string,
    readonly spans: Arr.NonEmptyReadonlyArray<TemplateLiteralSpan>,
    readonly annotations: Annotations = {}
  ) }

declare const toString: () => string

declare const toJSON: () => object

readonly _tag: "TemplateLiteral"

declare class TemplateLiteralSpan { constructor(type: AST, readonly literal: string) }

declare const toString: () => string

declare const toJSON: () => object

readonly type: TemplateLiteralSpanType

declare class Transformation { constructor(
    readonly from: AST,
    readonly to: AST,
    readonly transformation: TransformationKind,
    readonly annotations: Annotations = {}
  ) }

declare const toString: () => string

declare const toJSON: () => object

readonly _tag: "Transformation"

type TransformationKind = FinalTransformation | ComposeTransformation | TypeLiteralTransformation

declare class TupleType { constructor(
    readonly elements: ReadonlyArray<OptionalType>,
    readonly rest: ReadonlyArray<Type>,
    readonly isReadonly: boolean,
    readonly annotations: Annotations = {}
  ) }

declare const toString: () => string

declare const toJSON: () => object

readonly _tag: "TupleType"

declare class Type { constructor(
    readonly type: AST,
    readonly annotations: Annotations = {}
  ) }

declare const toJSON: () => object

declare const toString: () => string

declare class TypeLiteral { constructor(
    propertySignatures: ReadonlyArray<PropertySignature>,
    indexSignatures: ReadonlyArray<IndexSignature>,
    readonly annotations: Annotations = {}
  ) }

declare const toString: () => string

declare const toJSON: () => object

readonly _tag: "TypeLiteral"

readonly propertySignatures: ReadonlyArray<PropertySignature>

readonly indexSignatures: ReadonlyArray<IndexSignature>

declare class TypeLiteralTransformation { constructor(
    readonly propertySignatureTransformations: ReadonlyArray<
      PropertySignatureTransformation
    >
  ) }

readonly _tag: "TypeLiteralTransformation"

declare class UndefinedKeyword { constructor(readonly annotations: Annotations = {}) }

declare const toString: () => string

declare const toJSON: () => object

readonly _tag: "UndefinedKeyword"

declare class Union<M> { private constructor(readonly types: Members<M>, readonly annotations: Annotations = {}) }

declare const toString: () => string

declare const toJSON: () => object

readonly _tag: "Union"

declare class UniqueSymbol { constructor(readonly symbol: symbol, readonly annotations: Annotations = {}) }

declare const toString: () => string

declare const toJSON: () => object

readonly _tag: "UniqueSymbol"

declare class UnknownKeyword { constructor(readonly annotations: Annotations = {}) }

declare const toString: () => string

declare const toJSON: () => object

readonly _tag: "UnknownKeyword"

declare class VoidKeyword { constructor(readonly annotations: Annotations = {}) }

declare const toString: () => string

declare const toJSON: () => object

readonly _tag: "VoidKeyword"

declare const ParseJsonSchemaId: unique symbol

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

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

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

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

declare const annotations: (ast: AST, overrides: Annotations) => AST

declare const defaultParseOption: ParseOptions

declare const encodedAST: (ast: AST) => AST

declare const encodedBoundAST: (ast: AST) => AST

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

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

declare const getTemplateLiteralCapturingRegExp: (ast: TemplateLiteral) => RegExp

declare const getTemplateLiteralRegExp: (ast: TemplateLiteral) => RegExp

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

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

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

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

declare const partial: (ast: AST, options?: { readonly exact: true }) => AST

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

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

declare const typeAST: (ast: AST) => AST