import { Equatable } from "@fncts/base/data/Equatable";
import { AST } from "@fncts/schema/AST";
import { Vector } from "@fncts/base/collection/immutable/Vector";
import type { EqualsContext } from "@fncts/base/data/Equatable";
import type { Declaration, Refinement, Transform, Tuple, TypeLiteral, Union } from "@fncts/schema/AST";
export declare const enum ParseErrorTag {
    Declaration = 0,
    Type = 1,
    Index = 2,
    Key = 3,
    Missing = 4,
    Unexpected = 5,
    UnionMember = 6,
    Refinement = 7,
    Transformation = 8,
    TypeLiteral = 9,
    Tuple = 10,
    Union = 11,
    Iterable = 12
}
/**
 * @tsplus type fncts.schema.ParseError
 * @tsplus companion fncts.schema.ParseErrorOps
 */
export type ParseError = DeclarationError | TypeError | RefinementError | TransformationError | TypeLiteralError | TupleError | UnionError | IterableError;
/**
 * @tsplus companion fncts.schema.ParseError.DeclarationError
 */
export declare class DeclarationError implements Equatable {
    readonly ast: Declaration;
    readonly actual: unknown;
    readonly error: ParseError;
    readonly _tag = ParseErrorTag.Declaration;
    constructor(ast: Declaration, actual: unknown, error: ParseError);
    [Symbol.equals](that: unknown, context: EqualsContext): boolean;
}
/**
 * @tsplus static fncts.schema.ParseError.DeclarationError __call
 * @tsplus static fncts.schema.ParseErrorOps DeclarationError
 * @tsplus location "@fncts/schema/ParseError/ParseError"
 */
export declare function declarationError(ast: Declaration, actual: unknown, error: ParseError): DeclarationError;
/**
 * @tsplus companion fncts.schema.ParseError.TypeError
 */
export declare class TypeError implements Equatable {
    readonly ast: AST;
    readonly actual: unknown;
    readonly _tag = ParseErrorTag.Type;
    constructor(ast: AST, actual: unknown);
    [Symbol.equals](that: unknown, context: EqualsContext): boolean;
}
/**
 * @tsplus static fncts.schema.ParseError.TypeError __call
 * @tsplus static fncts.schema.ParseErrorOps TypeError
 * @tsplus location "@fncts/schema/ParseError/ParseError"
 */
export declare function typeError(expected: AST, actual: unknown): TypeError;
/**
 * @tsplus companion fncts.schema.ParseError.TypeLiteralError
 */
export declare class TypeLiteralError implements Equatable {
    readonly ast: TypeLiteral;
    readonly actual: unknown;
    readonly errors: Vector<KeyError>;
    readonly output: {
        readonly [x: string]: unknown;
    };
    readonly _tag = ParseErrorTag.TypeLiteral;
    constructor(ast: TypeLiteral, actual: unknown, errors: Vector<KeyError>, output?: {
        readonly [x: string]: unknown;
    });
    [Symbol.equals](that: unknown, context: EqualsContext): boolean;
}
/**
 * @tsplus static fncts.schema.ParseError.TypeLiteralError __call
 * @tsplus static fncts.schema.ParseErrorOps TypeLiteralError
 * @tsplus location "@fncts/schema/ParseError/ParseError"
 */
export declare function typeLiteralError(ast: TypeLiteral, actual: unknown, errors: Vector<KeyError>, output?: {
    readonly [x: string]: unknown;
}): TypeLiteralError;
/**
 * @tsplus companion fncts.schema.ParseError.TupleError
 */
export declare class TupleError implements Equatable {
    readonly ast: Tuple;
    readonly actual: unknown;
    readonly errors: Vector<IndexError>;
    readonly output: ReadonlyArray<unknown>;
    readonly _tag = ParseErrorTag.Tuple;
    constructor(ast: Tuple, actual: unknown, errors: Vector<IndexError>, output?: ReadonlyArray<unknown>);
    [Symbol.equals](that: unknown, context: EqualsContext): boolean;
}
/**
 * @tsplus static fncts.schema.ParseError.TupleError __call
 * @tsplus static fncts.schema.ParseErrorOps TupleError
 * @tsplus location "@fncts/schema/ParseError/ParseError"
 */
export declare function tupleError(ast: Tuple, actual: unknown, errors: Vector<IndexError>, output?: ReadonlyArray<unknown>): TupleError;
/**
 * @tsplus companion fncts.schema.ParseError.IndexError
 */
export declare class IndexError implements Equatable {
    readonly index: number;
    readonly error: ParseError | MissingError | UnexpectedError;
    readonly _tag = ParseErrorTag.Index;
    constructor(index: number, error: ParseError | MissingError | UnexpectedError);
    [Symbol.equals](that: unknown, context: EqualsContext): boolean;
}
/**
 * @tsplus static fncts.schema.ParseError.IndexError __call
 * @tsplus static fncts.schema.ParseErrorOps IndexError
 * @tsplus location "@fncts/schema/ParseError/ParseError"
 */
export declare function indexError(index: number, error: ParseError | MissingError | UnexpectedError): IndexError;
/**
 * @tsplus companion fncts.schema.ParseError.KeyError
 */
export declare class KeyError implements Equatable {
    readonly keyAST: AST;
    readonly key: any;
    readonly error: ParseError | MissingError | UnexpectedError;
    readonly _tag = ParseErrorTag.Key;
    constructor(keyAST: AST, key: any, error: ParseError | MissingError | UnexpectedError);
    [Symbol.equals](that: unknown, context: EqualsContext): boolean;
}
/**
 * @tsplus static fncts.schema.ParseError.KeyError __call
 * @tsplus static fncts.schema.ParseErrorOps KeyError
 * @tsplus location "@fncts/schema/ParseError/ParseError"
 */
export declare function keyError(keyAST: AST, key: any, error: ParseError | MissingError | UnexpectedError): KeyError;
/**
 * @tsplus companion fncts.schema.ParseError.MissingError
 */
export declare class MissingError implements Equatable {
    readonly _tag = ParseErrorTag.Missing;
    [Symbol.equals](that: unknown): boolean;
}
/**
 * @tsplus static fncts.schema.ParseErrorOps MissingError
 * @tsplus location "@fncts/schema/ParseError/ParseError"
 */
export declare const missingError: MissingError;
/**
 * @tsplus companion fncts.schema.ParseError.UnexpectedError
 */
export declare class UnexpectedError implements Equatable {
    readonly actual: unknown;
    readonly _tag = ParseErrorTag.Unexpected;
    constructor(actual: unknown);
    [Symbol.equals](that: unknown, context: EqualsContext): boolean;
}
/**
 * @tsplus static fncts.schema.ParseError.UnexpectedError __call
 * @tsplus static fncts.schema.ParseErrorOps UnexpectedError
 * @tsplus location "@fncts/schema/ParseError/ParseError"
 */
export declare function unexpectedError(actual: unknown): UnexpectedError;
/**
 * @tsplus companion fncts.schema.ParseError.UnionError
 */
export declare class UnionError implements Equatable {
    readonly ast: Union;
    readonly actual: unknown;
    readonly errors: Vector<TypeError | TypeLiteralError | UnionMemberError>;
    readonly _tag = ParseErrorTag.Union;
    constructor(ast: Union, actual: unknown, errors: Vector<TypeError | TypeLiteralError | UnionMemberError>);
    [Symbol.equals](that: unknown, context: EqualsContext): boolean;
}
/**
 * @tsplus static fncts.schema.ParseError.UnionError __call
 * @tsplus static fncts.schema.ParseErrorOps UnionError
 * @tsplus location "@fncts/schema/ParseError/ParseError"
 */
export declare function unionError(ast: Union, actual: unknown, errors: Vector<TypeError | TypeLiteralError | UnionMemberError>): UnionError;
/**
 * @tsplus companion fncts.schema.ParseError.UnionMemberError
 */
export declare class UnionMemberError implements Equatable {
    readonly ast: AST;
    readonly error: ParseError;
    readonly _tag = ParseErrorTag.UnionMember;
    constructor(ast: AST, error: ParseError);
    [Symbol.equals](that: unknown, context: EqualsContext): boolean;
}
/**
 * @tsplus static fncts.schema.ParseError.UnionMemberError __call
 * @tsplus static fncts.schema.ParseErrorOps UnionMemberError
 * @tsplus location "@fncts/schema/ParseError/ParseError"
 */
export declare function unionMemberError(ast: AST, error: ParseError): UnionMemberError;
/**
 * @tsplus companion fncts.schema.ParseError.RefinementError
 */
export declare class RefinementError implements Equatable {
    readonly ast: Refinement;
    readonly actual: unknown;
    readonly kind: "From" | "Predicate";
    readonly error: ParseError;
    readonly _tag = ParseErrorTag.Refinement;
    constructor(ast: Refinement, actual: unknown, kind: "From" | "Predicate", error: ParseError);
    [Symbol.equals](that: unknown, context: EqualsContext): boolean;
}
/**
 * @tsplus static fncts.schema.ParseError.RefinementError __call
 * @tsplus static fncts.schema.ParseErrorOps RefinementError
 * @tsplus location "@fncts/schema/ParseError/ParseError"
 */
export declare function refinementError(ast: Refinement, actual: unknown, kind: "From" | "Predicate", error: ParseError): ParseError;
/**
 * @tsplus companion fncts.schema.ParseError.TransformationError
 */
export declare class TransformationError implements Equatable {
    readonly ast: Transform;
    readonly actual: unknown;
    readonly kind: "Encoded" | "Transformation" | "Type";
    readonly error: ParseError;
    readonly _tag = ParseErrorTag.Transformation;
    constructor(ast: Transform, actual: unknown, kind: "Encoded" | "Transformation" | "Type", error: ParseError);
    [Symbol.equals](that: unknown, context: EqualsContext): boolean;
}
/**
 * @tsplus static fncts.schema.ParseError.TransformationError __call
 * @tsplus static fncts.schema.ParseErrorOps TransformationError
 * @tsplus location "@fncts/schema/ParseError/ParseError"
 */
export declare function transformationError(ast: Transform, actual: unknown, kind: "Encoded" | "Transformation" | "Type", error: ParseError): ParseError;
/**
 * @tsplus companion fncts.schema.ParseError.IterableError
 */
export declare class IterableError implements Equatable {
    readonly ast: AST;
    readonly actual: unknown;
    readonly errors: Vector<IndexError | KeyError>;
    readonly _tag = ParseErrorTag.Iterable;
    constructor(ast: AST, actual: unknown, errors: Vector<IndexError | KeyError>);
    [Symbol.equals](that: unknown, context: EqualsContext): boolean;
}
/**
 * @tsplus static fncts.schema.ParseError.IterableError __call
 * @tsplus static fncts.schema.ParseErrorOps IterableError
 * @tsplus location "@fncts/schema/ParseError/ParseError"
 */
export declare function iterableError(ast: AST, actual: unknown, errors: Vector<IndexError | KeyError>): IterableError;