import { Chunk } from "@fp-ts/data/Chunk";
import { Case } from "@effect-ts/system/Case";
export interface Actual<A> {
    readonly actual: A;
}
export interface SingleE<E> {
    readonly error: E;
}
export interface CompoundE<E> {
    readonly errors: Chunk<E>;
}
export type SchemaError<E> = LeafE<E> | RefinementE<SchemaError<E>> | RequiredKeyE<PropertyKey, SchemaError<E>> | OptionalKeyE<PropertyKey, SchemaError<E>> | StructE<SchemaError<E>> | PrevE<SchemaError<E>> | NextE<SchemaError<E>> | CompositionE<SchemaError<E>> | MissingKeysE<PropertyKey> | OptionalIndexE<number, SchemaError<E>> | CollectionE<SchemaError<E>> | NamedE<string, SchemaError<E>> | IntersectionE<SchemaError<E>> | UnionE<SchemaError<E>> | MemberE<PropertyKey, SchemaError<E>>;
export interface LeafErrors {
    ParseStringE: ParseStringE;
    ParseNumberE: ParseNumberE;
    ParseObjectE: ParseObjectE;
    ParseDateE: ParseDateE;
    ParseDateMsE: ParseDateMsE;
    ParseBoolE: ParseBoolE;
    ParseUuidE: ParseUuidE;
    InvalidIntegerE: InvalidIntegerE;
    PositiveE: PositiveE;
    UnknownRecordE: UnknownRecordE;
    LiteralE: LiteralE<string[]>;
    NonEmptyE: NonEmptyE<unknown>;
    UnknownArrayE: UnknownArrayE;
    TaggedUnionExtractKeyE: ExtractKeyE;
}
export type LeafError = Extract<LeafErrors[keyof LeafErrors], HasDefaultLeafE>;
export declare const defaultLeafSymbol: unique symbol;
export declare const toTreeSymbol: unique symbol;
export interface HasDefaultLeafE {
    readonly [toTreeSymbol]: Tree<string>;
}
export declare abstract class DefaultLeafE<T extends object> extends Case<T> implements HasDefaultLeafE {
    readonly [defaultLeafSymbol]: symbol;
    abstract get [toTreeSymbol](): Tree<string>;
}
export declare function isDefaultLeaf<T extends object>(t: T): t is DefaultLeafE<T> & T;
export type AnyError = SchemaError<HasDefaultLeafE>;
export declare class UnionE<E> extends Case<{
    readonly errors: Chunk<E>;
}> implements CompoundE<E> {
    readonly _tag = "Union";
}
export declare function unionE<E>(errors: Chunk<E>): UnionE<E>;
export declare class ExtractKeyE extends DefaultLeafE<{
    readonly field: string;
    readonly keys: readonly string[];
    readonly actual: unknown;
}> implements Actual<unknown> {
    readonly _tag = "ExtractKey";
    get [toTreeSymbol](): Tree<string>;
}
export declare function extractKeyE(field: string, keys: readonly string[], actual: unknown): ExtractKeyE;
export declare class LeafE<E> extends Case<{
    readonly error: E;
}> implements SingleE<E> {
    readonly _tag = "Leaf";
}
export declare function leafE<E>(e: E): LeafE<E>;
export declare class PrevE<E> extends Case<{
    readonly error: E;
}> implements SingleE<E> {
    readonly _tag = "Prev";
}
export declare function prevE<E>(e: E): PrevE<E>;
export declare class NextE<E> extends Case<{
    readonly error: E;
}> implements SingleE<E> {
    readonly _tag = "Next";
}
export declare function nextE<E>(e: E): NextE<E>;
export declare class RefinementE<E> extends Case<{
    readonly error: E;
}> implements SingleE<E> {
    readonly _tag = "Refinement";
}
export declare function refinementE<E>(e: E): RefinementE<E>;
export declare class NamedE<Name extends string, E> extends Case<{
    readonly name: Name;
    readonly error: E;
}> implements SingleE<E> {
    readonly _tag = "Named";
}
export declare function namedE<N extends string, E>(name: N, error: E): NamedE<N, E>;
export declare class StructE<E> extends Case<{
    readonly errors: Chunk<E>;
}> implements CompoundE<E> {
    readonly _tag = "Struct";
}
export declare function structE<E>(errors: Chunk<E>): StructE<E>;
export declare class CollectionE<E> extends Case<{
    readonly errors: Chunk<E>;
}> implements CompoundE<E> {
    readonly _tag = "Collection";
}
export declare function chunkE<E>(errors: Chunk<E>): CollectionE<E>;
export declare class UnknownArrayE extends DefaultLeafE<{
    readonly actual: unknown;
}> implements Actual<unknown> {
    readonly _tag = "NotArray";
    get [toTreeSymbol](): Tree<string>;
}
export declare function unknownArrayE(actual: unknown): UnknownArrayE;
export declare class RequiredKeyE<K, E> extends Case<{
    readonly error: E;
    readonly key: K;
}> implements SingleE<E> {
    readonly _tag = "RequiredKey";
}
export declare function requiredKeyE<K, E>(key: K, error: E): RequiredKeyE<K, E>;
export declare class OptionalKeyE<K, E> extends Case<{
    readonly error: E;
    readonly key: K;
}> implements SingleE<E> {
    readonly _tag = "OptionalKey";
}
export declare function optionalKeyE<K, E>(key: K, error: E): OptionalKeyE<K, E>;
export declare class OptionalIndexE<I, E> extends Case<{
    readonly index: I;
    readonly error: E;
}> implements SingleE<E> {
    readonly _tag = "OptionalIndex";
}
export declare function optionalIndexE<K, E>(index: K, error: E): OptionalIndexE<K, E>;
export declare class MissingKeysE<K> extends Case<{
    readonly keys: Chunk<K>;
}> {
    readonly _tag = "Missing";
}
export declare function missingKeysE<K>(keys: Chunk<K>): MissingKeysE<K>;
export declare class CompositionE<E> extends Case<{
    readonly errors: Chunk<E>;
}> implements CompoundE<E> {
    readonly _tag = "Composition";
}
export declare function compositionE<E>(errors: Chunk<E>): CompositionE<E>;
export declare class UnknownRecordE extends DefaultLeafE<{
    readonly actual: unknown;
}> implements Actual<unknown> {
    readonly _tag = "NotRecord";
    get [toTreeSymbol](): Tree<string>;
}
export declare function unknownRecordE(actual: unknown): UnknownRecordE;
export declare class MemberE<M, E> extends Case<{
    readonly member: M;
    readonly error: E;
}> implements SingleE<E> {
    readonly _tag = "Member";
}
export declare function memberE<M, E>(member: M, error: E): MemberE<M, E>;
export declare class IntersectionE<E> extends Case<{
    readonly errors: Chunk<E>;
}> implements CompoundE<E> {
    readonly _tag = "Intersection";
}
export declare function intersectionE<E>(errors: Chunk<E>): IntersectionE<E>;
export declare class ParseDateE extends DefaultLeafE<{
    readonly actual: unknown;
}> implements Actual<unknown> {
    readonly _tag = "NotDateString";
    get [toTreeSymbol](): Tree<string>;
}
export declare function parseDateE(actual: unknown): ParseDateE;
export declare class ParseDateMsE extends DefaultLeafE<{
    readonly actual: unknown;
}> implements Actual<unknown> {
    readonly _tag = "NotDateMs";
    get [toTreeSymbol](): Tree<string>;
}
export declare function parseDateMsE(actual: unknown): ParseDateMsE;
export declare class LiteralE<KS extends readonly string[]> extends DefaultLeafE<{
    readonly actual: unknown;
    readonly literals: KS;
}> implements Actual<unknown> {
    readonly _tag = "Literal";
    get [toTreeSymbol](): Tree<string>;
}
export declare function literalE<KS extends readonly string[]>(literals: KS, actual: unknown): LiteralE<KS>;
export declare class InvalidIntegerE extends DefaultLeafE<{
    readonly actual: number;
}> implements Actual<number> {
    readonly _tag = "NotInteger";
    get [toTreeSymbol](): Tree<string>;
}
export declare function invalidIntegerE(actual: number): InvalidIntegerE;
export declare class PositiveE extends DefaultLeafE<{
    readonly actual: number;
}> implements Actual<number> {
    readonly _tag = "NotPositive";
    get [toTreeSymbol](): Tree<string>;
}
export declare function positiveE(actual: number): PositiveE;
export declare class NonEmptyE<A> extends DefaultLeafE<{
    readonly actual: A;
}> implements Actual<A> {
    readonly _tag = "NonEmpty";
    get [toTreeSymbol](): Tree<string>;
}
export declare class CustomE<A> extends DefaultLeafE<{
    readonly actual: A;
    readonly expected: string;
}> implements Actual<A> {
    readonly _tag = "Custom";
    get [toTreeSymbol](): Tree<string>;
}
export declare function nonEmptyE<A>(actual: A): NonEmptyE<A>;
export declare function customE<A>(actual: A, expected: string): CustomE<A>;
export declare class ParseNumberE extends DefaultLeafE<{
    readonly actual: unknown;
}> implements Actual<unknown> {
    readonly _tag = "NotNumber";
    get [toTreeSymbol](): Tree<string>;
}
export declare function parseNumberE(actual: unknown): ParseNumberE;
export declare class ParseObjectE extends DefaultLeafE<{
    readonly actual: unknown;
}> implements Actual<unknown> {
    readonly _tag = "NotObject";
    get [toTreeSymbol](): Tree<string>;
}
export declare function parseObjectE(actual: unknown): ParseObjectE;
export declare class ParseStringE extends DefaultLeafE<{
    readonly actual: unknown;
}> implements Actual<unknown> {
    readonly _tag = "NotString";
    get [toTreeSymbol](): Tree<string>;
}
export declare function parseStringE(actual: unknown): ParseStringE;
export declare class ParseBoolE extends DefaultLeafE<{
    readonly actual: unknown;
}> implements Actual<unknown> {
    readonly _tag = "NotBool";
    get [toTreeSymbol](): Tree<string>;
}
export declare function parseBoolE(actual: unknown): ParseBoolE;
export declare class ParseUuidE extends DefaultLeafE<{
    readonly actual: unknown;
}> implements Actual<unknown> {
    readonly _tag = "NotUUID";
    get [toTreeSymbol](): Tree<string>;
}
export type Forest<A> = Chunk<Tree<A>>;
export interface Tree<A> {
    readonly value: A;
    readonly forest: Forest<A>;
}
export declare function tree<A>(value: A, forest?: Forest<A>): Tree<A>;
export declare function toTreeWith<E>(toTree: (e: E) => Tree<string>): (de: SchemaError<E>) => Tree<string>;
export declare function drawTree(tree: Tree<string>): string;
export declare const errorToTree: (de: SchemaError<HasDefaultLeafE>) => Tree<string>;
export declare const drawError: (de: SchemaError<HasDefaultLeafE>) => string;
//# sourceMappingURL=error.d.ts.map