import { Evaluate } from "@re-do/utils";
import { ParseConfig, ValidationErrors, ParseResult } from "./internal.js";
import { Root } from "../root.js";
import { Recursible } from "./recursible.js";
import { Optional } from "../shallow";
export declare namespace Obj {
    type Definition<Def extends Recursible.Definition = Recursible.Definition> = Recursible.Definition<Def> extends any[] ? never : Def;
    type Validate<Def, TypeSet> = Evaluate<{
        [PropName in keyof Def]: Root.Validate<Def[PropName], TypeSet>;
    }>;
    type Parse<Def, TypeSet, Options extends ParseConfig, OptionalKey extends keyof Def = {
        [K in keyof Def]: Def[K] extends Optional.Definition ? K : never;
    }[keyof Def], RequiredKey extends keyof Def = Exclude<keyof Def, OptionalKey>> = {
        [PropName in OptionalKey]?: Def[PropName] extends Optional.Definition<infer OptionalType> ? Root.Parse<OptionalType, TypeSet, Options> : unknown;
    } & {
        [PropName in RequiredKey]: Root.Parse<Def[PropName], TypeSet, Options>;
    };
    const type: {
        [x: string]: any;
    };
    const parse: {
        meta: {
            type: {
                [x: string]: any;
            };
            inherits: () => import("./internal.js").GetHandledMethods<{
                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;
                }>;
            }>;
            handles: {
                allows: ({ components, def, ctx }: {
                    def: {
                        [x: string]: any;
                    };
                    ctx: import("./internal.js").ParseContext;
                } & {
                    components: Record<string, ParseResult<any>>;
                }, valueType: import("./internal.js").ExtractableDefinition, opts: import("./internal.js").AllowsOptions) => ValidationErrors;
                references: ({ components }: {
                    def: {
                        [x: string]: any;
                    };
                    ctx: import("./internal.js").ParseContext;
                } & {
                    components: Record<string, ParseResult<any>>;
                }, opts: import("./internal.js").ReferencesOptions) => import("@re-do/utils").TreeOf<string[], true>;
                generate: ({ components, def, ctx }: {
                    def: {
                        [x: string]: any;
                    };
                    ctx: import("./internal.js").ParseContext;
                } & {
                    components: Record<string, ParseResult<any>>;
                }, opts: import("./internal.js").GenerateOptions) => any;
            };
            matches: import("./internal.js").DefinitionMatcher<{
                [x: string]: any;
            }>;
        };
    } & import("./internal.js").ParseFunction<{
        [x: string]: any;
    }, Record<string, ParseResult<any>>>;
    const delegate: {
        [x: string]: any;
    };
}