import { Pattern, TagUnion } from './match';
import { SimpleNominal } from './Nominal';
import { Result } from './Result';
import { TaggedUnion } from './TaggedUnion';
declare type InferType<A extends SimpleNominal<unknown>> = A['_raw'];
declare type UnknownNominal = SimpleNominal<unknown>;
declare type Match<ADT extends TagUnion> = <A>(pattern: Pattern<'tag', ADT, A>) => (adt: ADT) => A;
export declare type Refined<A extends UnknownNominal, E extends TagUnion> = {
    /**
     * **Use at own risk.**
     *
     * Favour `from` unless you are certain the data conforms to the correct structure.
     */
    unsafeFrom: (a: InferType<A>) => A;
    from: (a: InferType<A>) => Result<E, A>;
    is: (a: InferType<A>) => a is A;
    handleError: Match<E>;
};
export declare const refine: <A extends {
    _raw: unknown;
    _brand: symbol;
}, E extends TagUnion>(p: (a: InferType<A>) => Result<E, InferType<A>>) => Refined<A, E>;
export declare namespace Refined {
    namespace Boolean {
        export type And<A extends UnknownNominal, L extends Refined<A, any>, R extends Refined<A, any>> = Refined<A, ExtractError<L | R>>;
        export const And: <A extends {
            _raw: unknown;
            _brand: symbol;
        }, L extends Refined<A, any>, R extends Refined<A, any>>(l: L, r: R) => And<A, L, R>;
        export type Or<A extends UnknownNominal, L extends Refined<A, any>, R extends Refined<A, any>> = Refined<A, ExtractError<L> | ExtractError<R>>;
        export const Or: <A extends {
            _raw: unknown;
            _brand: symbol;
        }, L extends Refined<A, any>, R extends Refined<A, any>>(l: L, r: R) => Or<A, L, R>;
        type ExtractError<A> = A extends Refined<any, infer E> ? E : never;
        export {};
    }
    namespace String {
        type StringNominal = SimpleNominal<string>;
        export type MatchesRegex<A extends StringNominal> = Refined<A, MatchesRegex.E>;
        export namespace MatchesRegex {
            type E = TaggedUnion<{
                MatchesRegexError: {};
            }>;
            const E: {
                tag: "MatchesRegexError";
            };
            const refinement: <A extends StringNominal>(s: RegExp) => MatchesRegex<A>;
        }
        export {};
    }
    namespace Iterable {
        type IterableNominal = SimpleNominal<Iterable<any>>;
        export type MinLength<A extends IterableNominal> = Refined<A, MinLength.E> & {
            minLength: number;
        };
        export namespace MinLength {
            type E = TaggedUnion<{
                MinLengthError: {
                    minLength: number;
                };
            }>;
            const E: (args: import("./TaggedUnion").UntaggedMember<{
                tag: "MinLengthError";
                minLength: number;
            }, "MinLengthError">) => {
                tag: "MinLengthError";
                minLength: number;
            };
            const refinement: <A extends IterableNominal>(minLength: number) => MinLength<A>;
        }
        export type MaxLength<A extends IterableNominal> = Refined<A, MaxLength.E> & {
            maxLength: number;
        };
        export namespace MaxLength {
            type E = TaggedUnion<{
                MaxLengthError: {
                    maxLength: number;
                };
            }>;
            const E: (args: import("./TaggedUnion").UntaggedMember<{
                tag: "MaxLengthError";
                maxLength: number;
            }, "MaxLengthError">) => {
                tag: "MaxLengthError";
                maxLength: number;
            };
            const refinement: <A extends IterableNominal>(maxLength: number) => MaxLength<A>;
        }
        export type MinMaxLength<A extends IterableNominal> = Refined.Boolean.And<A, MinLength<A>, MaxLength<A>> & {
            minLength: number;
            maxLength: number;
        };
        export namespace MinMaxLength {
            const refinement: <A extends IterableNominal>(minLength: number, maxLength: number) => MinMaxLength<A>;
        }
        export {};
    }
    namespace Number {
        type NumberNominal = SimpleNominal<number>;
        export type Less<A extends NumberNominal> = Refined<A, Less.E> & {
            max: number;
        };
        export namespace Less {
            type E = TaggedUnion<{
                LessError: {};
            }>;
            const E: {
                tag: "LessError";
            };
            const refinement: <A extends NumberNominal>(max: number) => Less<A>;
        }
        export type LessEqual<A extends NumberNominal> = Refined<A, LessEqual.E> & {
            max: number;
        };
        export namespace LessEqual {
            type E = TaggedUnion<{
                LessEqualError: {};
            }>;
            const E: {
                tag: "LessEqualError";
            };
            const refinement: <A extends NumberNominal>(max: number) => LessEqual<A>;
        }
        export type Greater<A extends NumberNominal> = Refined<A, Greater.E> & {
            min: number;
        };
        export namespace Greater {
            type E = TaggedUnion<{
                GreaterError: {};
            }>;
            const E: {
                tag: "GreaterError";
            };
            const refinement: <A extends NumberNominal>(min: number) => Greater<A>;
        }
        export type GreaterEqual<A extends NumberNominal> = Refined<A, GreaterEqual.E> & {
            min: number;
        };
        export namespace GreaterEqual {
            type E = TaggedUnion<{
                GreaterEqualError: {};
            }>;
            const E: {
                tag: "GreaterEqualError";
            };
            const refinement: <A extends NumberNominal>(min: number) => GreaterEqual<A>;
        }
        export namespace Bounds {
            type Inclusive<A extends NumberNominal> = Boolean.And<A, GreaterEqual<A>, LessEqual<A>> & {
                min: number;
                max: number;
            };
            const Inclusive: <A extends NumberNominal>(min: number, max: number) => Inclusive<A>;
            type Exclusive<A extends NumberNominal> = Boolean.And<A, Greater<A>, Less<A>> & {
                min: number;
                max: number;
            };
            const Exclusive: <A extends NumberNominal>(min: number, max: number) => Exclusive<A>;
            type LowerInclusiveUpperExclusive<A extends NumberNominal> = Boolean.And<A, GreaterEqual<A>, Less<A>> & {
                min: number;
                max: number;
            };
            const LowerInclusiveUpperExclusive: <A extends NumberNominal>(min: number, max: number) => LowerInclusiveUpperExclusive<A>;
            type LowerExclusiveUpperInclusive<A extends NumberNominal> = Boolean.And<A, Greater<A>, LessEqual<A>> & {
                min: number;
                max: number;
            };
            const LowerExclusiveUpperInclusive: <A extends NumberNominal>(min: number, max: number) => LowerExclusiveUpperInclusive<A>;
        }
        export {};
    }
}
export {};