import { Evaluate, Recursible as ExtractRecursible } from "@re-do/utils";
import { ParseConfig, DefinitionTypeError } from "./internal.js";
import { Obj } from "./obj.js";
import { Tuple } from "./tuple.js";
export declare namespace Recursible {
    type Definition<Def extends {
        [K in string]: any;
    } = {
        [K in string]: any;
    }> = Def extends ExtractRecursible<Def> ? Def : never;
    type Validate<Def, TypeSet> = Def extends Tuple.Definition ? Tuple.Validate<Def, TypeSet> : Def extends Obj.Definition ? Obj.Validate<Def, TypeSet> : DefinitionTypeError;
    type Parse<Def extends Definition, TypeSet, Options extends ParseConfig> = Def extends Tuple.Definition ? Evaluate<Tuple.Parse<Def, TypeSet, Options>> : Def extends Obj.Definition ? Evaluate<Obj.Parse<Def, TypeSet, Options>> : unknown;
    const type: {
        [x: string]: any;
    };
    const parse: {
        meta: {
            type: {
                [x: string]: any;
            };
            inherits: () => import("./internal.js").GetHandledMethods<{
                type: string | number | {
                    [x: string]: any;
                };
                inherits: () => import("./internal.js").GetHandledMethods<{
                    type: string | number | {
                        [x: string]: any;
                    };
                    inherits: () => void;
                    handles: {};
                }>;
                handles: {};
                matches: import("./internal.js").DefinitionMatcher<string | number | {
                    [x: string]: any;
                }>;
            }>;
            handles: {};
            matches: import("./internal.js").DefinitionMatcher<{
                [x: string]: any;
            }>;
        };
    } & import("./internal.js").ParseFunction<{
        [x: string]: any;
    }, unknown>;
    const delegate: {
        [x: string]: any;
    };
}