import { Evaluate, Narrow, Exact, TreeOf, IsAny, WithDefaults } from "@re-do/utils";
import { Root } from "./components";
import { AllowsOptions, ReferencesOptions, GenerateOptions } from "./components/parser.js";
import { ValidationErrors } from "./components/errors.js";
import { TypeSet } from "./components";
export declare type Definition = Root.Definition;
export declare type Validate<Def, TypeSet> = IsAny<Def> extends true ? Def : Root.Validate<Def, TypeSet>;
export declare type Parse<Def, Set, Options extends ParseTypeOptions = {}> = IsAny<Def> extends true ? Def : Root.Parse<Def, TypeSet.Validate<Set>, WithDefaults<ParseTypeOptions, Options, DefaultParseTypeOptions>>;
export declare type ParseTypeOptions = {
    onCycle?: Definition;
    seen?: Record<string, boolean>;
    deepOnCycle?: boolean;
    onResolve?: Definition;
};
export declare type DefaultParseTypeOptions = {
    onCycle: never;
    seen: {};
    deepOnCycle: false;
    onResolve: never;
};
export declare type InferredMethods = {
    assert: (value: unknown, options?: AllowsOptions) => void;
    check: (value: unknown, options?: AllowsOptions) => string;
};
export declare const createParseFunction: <PredefinedTypeSet>(predefinedTypeSet: import("@re-do/utils").CastWithExclusion<PredefinedTypeSet, import("@re-do/utils").NarrowRecurse<PredefinedTypeSet>, []>) => ParseFunction<PredefinedTypeSet>;
export declare const parse: ParseFunction<{}>;
export declare type ParseFunction<PredefinedTypeSet> = <Def, Options extends ParseTypeOptions, ActiveTypeSet = PredefinedTypeSet>(definition: Validate<Narrow<Def>, ActiveTypeSet>, options?: Narrow<Options & {
    typeSet?: Exact<ActiveTypeSet, TypeSet.Validate<ActiveTypeSet>>;
}>) => Evaluate<ParsedType<Def, ActiveTypeSet, Options>>;
export declare type ParsedType<Definition, TypeSet, Options, TypeOfParsed = Evaluate<Parse<Definition, TypeSet, Options>>> = Evaluate<{
    definition: Definition;
    type: TypeOfParsed;
    typeSet: Evaluate<TypeSet>;
    check: (value: unknown, options?: AllowsOptions) => string;
    assert: (value: unknown, options?: AllowsOptions) => void;
    allows: (value: unknown, options?: AllowsOptions) => ValidationErrors;
    generate: (options?: GenerateOptions) => TypeOfParsed;
    references: (options?: ReferencesOptions) => TreeOf<string[], true>;
}>;