export declare class Ok<A, B> {
    readonly value: A;
    constructor(value: A);
    chain<C>(f: (_: A) => Result<C, B>): Result<C, B>;
    recover(f: (_: B) => Result<A, B>): Result<A, B>;
}
export declare class Err<A, B> {
    readonly reason: B;
    constructor(reason: B);
    chain<C>(f: (_: A) => Result<C, B>): Result<C, B>;
    recover(f: (_: B) => Result<A, B>): Result<A, B>;
}
export declare type SpecType<T> = T extends AnySpec<infer U> ? U : never;
export declare type SpecTypes<Ts> = Ts extends [AnySpec<infer U>] ? U : Ts extends [AnySpec<infer U>, ...infer Rest] ? U | SpecTypes<Rest> : never;
export declare type RecordSpecType<R> = R extends Record<infer K, infer T> ? {
    [K0 in K]: SpecType<R[K0]>;
} : never;
declare type Result<A, B> = Ok<A, B> | Err<A, B>;
export declare class EType {
    readonly expected: string;
    constructor(expected: string);
    format(): string;
}
export declare class ENoKey {
    readonly key: string;
    constructor(key: string);
    format(): string;
}
export declare class ENotEqual {
    readonly expected: any;
    constructor(expected: any);
    format(): string;
}
export declare class EAnyOf {
    readonly errors: Errors[];
    constructor(errors: Errors[]);
    format(): string;
}
export declare class EPath {
    readonly key: string;
    readonly error: Errors;
    constructor(key: string, error: Errors);
    get_path_and_error(): [string[], Errors];
    format(): string;
}
declare type Errors = EType | ENoKey | ENotEqual | EAnyOf | EPath;
declare type Valid<A> = Result<A, Errors>;
export declare class LazySpec<A> {
    readonly thunk: () => AnySpec<A>;
    constructor(thunk: () => AnySpec<A>);
}
export declare type SpecFun<A> = (_: any) => Valid<A>;
export declare type SpecContainer<A> = {
    spec: AnySpec<A>;
};
export declare type AnySpec<A> = SpecFun<A> | SpecContainer<A> | LazySpec<A>;
export declare function lazy<A>(x: () => AnySpec<A>): LazySpec<A>;
export declare function string(x: any): Valid<string>;
export declare function bigint(x: any): Valid<bigint>;
export declare function bigint_string(x: any): Valid<bigint>;
export declare function number(x: any): Valid<number>;
export declare function boolean(x: any): Valid<boolean>;
export declare function nothing(x: any): Valid<null>;
export declare function array<A>(f0: AnySpec<A>): SpecFun<A[]>;
export declare function equal<A>(x: A): SpecFun<A>;
export declare function anyOf<T extends AnySpec<any>[]>(fs: [...T]): SpecFun<SpecTypes<T>>;
export declare function spec<A extends Record<string, AnySpec<any>>, B>(type: A, parser: (_: RecordSpecType<A>) => B): SpecFun<B>;
export declare function optional<A>(spec: AnySpec<A>, default_value: A): SpecFun<A>;
export declare function map_spec<A, B>(spec: AnySpec<A>, f: (_: A) => B): SpecFun<B>;
export declare function parse<A>(x: any, spec: AnySpec<A>): A;
export declare function try_parse<A>(x: any, spec: AnySpec<A>): Valid<A>;
export {};