import { IsAny, Or as LogicalOr } from "@re-do/utils";
import { ParseConfig, ValidationErrorMessage } from "./common.js";
import { Root } from "../root.js";
export declare namespace Resolution {
    type Definition<TypeSet, Def extends keyof TypeSet & string = keyof TypeSet & string> = Def;
    type Validate<TypeName extends keyof TypeSet & string, Root, TypeSet> = TypeSet[TypeName] extends ValidationErrorMessage ? TypeSet[TypeName] : Root;
    type Parse<TypeName extends keyof TypeSet & string, TypeSet, Options extends ParseConfig> = IsAny<TypeSet> extends true ? TypeSet : TypeSet[TypeName] extends ValidationErrorMessage ? unknown : TypeName extends keyof Options["seen"] ? Options["onCycle"] extends never ? ParseResolvedNonCyclicDefinition<TypeName, TypeSet, Options> : ParseResolvedCyclicDefinition<TypeName, TypeSet, Options> : ParseResolvedNonCyclicDefinition<TypeName, TypeSet, Options>;
    type ParseResolvedCyclicDefinition<TypeName extends keyof TypeSet, TypeSet, Options extends ParseConfig> = Root.Parse<Options["onCycle"], Omit<TypeSet, "cyclic"> & {
        cyclic: TypeSet[TypeName];
    }, {
        onCycle: Options["deepOnCycle"] extends true ? Options["onCycle"] : never;
        seen: {};
        onResolve: Options["onResolve"];
        deepOnCycle: Options["deepOnCycle"];
    }>;
    type ParseResolvedNonCyclicDefinition<TypeName extends keyof TypeSet, TypeSet, Options extends ParseConfig> = LogicalOr<Options["onResolve"] extends never ? true : false, TypeName extends "resolved" ? true : false> extends true ? Root.Parse<TypeSet[TypeName], TypeSet, Options & {
        seen: {
            [K in TypeName]: true;
        };
    }> : Root.Parse<Options["onResolve"], Omit<TypeSet, "resolved"> & {
        resolved: TypeSet[TypeName];
    }, Options & {
        seen: {
            [K in TypeName]: true;
        };
    }>;
    const type: string;
    const parse: {
        meta: {
            type: string;
            inherits: () => import("./common.js").GetHandledMethods<{
                type: string;
                inherits: () => import("./common.js").GetHandledMethods<{
                    type: string;
                    inherits: () => import("./common.js").GetHandledMethods<{
                        type: string | number;
                        inherits: () => import("./common.js").GetHandledMethods<{
                            type: string | number | {
                                [x: string]: any;
                            };
                            inherits: () => import("./common.js").GetHandledMethods<{
                                type: string | number | {
                                    [x: string]: any;
                                };
                                inherits: () => void;
                                handles: {};
                            }>;
                            handles: {};
                            matches: import("./common.js").DefinitionMatcher<string | number | {
                                [x: string]: any;
                            }>;
                        }>;
                        handles: {};
                        matches: import("./common.js").DefinitionMatcher<string | number>;
                    }>;
                    handles: {};
                    matches: import("./common.js").DefinitionMatcher<string>;
                }>;
                handles: {};
                matches: import("./common.js").DefinitionMatcher<string>;
            }>;
            handles: {
                allows: ({ components: { resolve } }: {
                    def: string;
                    ctx: import("./common.js").ParseContext;
                } & {
                    components: {
                        resolve: () => import("./common.js").ParseResult<string | number | {
                            [x: string]: any;
                        }>;
                    };
                }, valueType: import("./common.js").ExtractableDefinition, opts: import("./common.js").AllowsOptions) => import("./common.js").ValidationErrors;
                generate: ({ components: { resolve }, ctx, def }: {
                    def: string;
                    ctx: import("./common.js").ParseContext;
                } & {
                    components: {
                        resolve: () => import("./common.js").ParseResult<string | number | {
                            [x: string]: any;
                        }>;
                    };
                }, opts: import("./common.js").GenerateOptions) => any;
                references: ({ def }: {
                    def: string;
                    ctx: import("./common.js").ParseContext;
                } & {
                    components: {
                        resolve: () => import("./common.js").ParseResult<string | number | {
                            [x: string]: any;
                        }>;
                    };
                }, opts: import("./common.js").ReferencesOptions) => string[];
            };
            matches: import("./common.js").DefinitionMatcher<string>;
        };
    } & import("./common.js").ParseFunction<string, {
        resolve: () => import("./common.js").ParseResult<string | number | {
            [x: string]: any;
        }>;
    }>;
    const delegate: string;
}