import { Evaluate, KeyValuate, TreeOf, ValueOf, Exact } from "@re-do/utils";
import { ExtractableDefinition } from "./internal.js";
import { TypeSet } from "./typeSet";
import { ValidationErrors } from "./errors.js";
import { Recursible } from "./recursible/index.js";
export declare type MatchesArgs<DefType> = {
    definition: DefType;
    typeSet: TypeSet.Definition;
};
export declare type ParseContext = {
    typeSet: TypeSet.Definition;
    path: string[];
    seen: string[];
    shallowSeen: string[];
};
export declare type ParseArgs<DefType> = [definition: DefType, context: ParseContext];
export declare type AllowsOptions = {
    ignoreExtraneousKeys?: boolean;
};
export declare type ReferencesOptions = {
    includeBuiltIn?: boolean;
};
export declare type GenerateOptions = {
    onRequiredCycle?: any;
};
export declare type ParserInput<DefType, Parent, Children extends DefType[], Components> = {
    type: DefType;
    parent: () => {
        meta: Parent;
    };
    matches: DefinitionMatcher<Parent>;
    components?: (...args: ParseArgs<DefType>) => Components;
    children?: () => Children;
    fallback?: (...args: ParseArgs<DefType>) => any;
};
export declare type DefinitionMatcher<Parent> = (...args: ParseArgs<KeyValuate<Parent, "type">>) => boolean;
export declare type HandlesArg<Children, Handles> = Children extends never[] ? [handles: Required<Handles>] : [handles?: Handles];
export declare type HandlesContext<DefType, Components> = [
    args: {
        def: DefType;
        ctx: ParseContext;
    } & (unknown extends Components ? {} : {
        components: Components;
    })
];
export declare type HandlesMethods<DefType, Components> = {
    allows?: (...args: [
        ...args: HandlesContext<DefType, Components>,
        valueType: ExtractableDefinition,
        options: AllowsOptions
    ]) => ValidationErrors;
    references?: (...args: [
        ...args: HandlesContext<DefType, Components>,
        options: ReferencesOptions
    ]) => DefType extends Recursible.Definition<DefType> ? TreeOf<string[], true> : string[];
    generate?: (...args: [
        ...args: HandlesContext<DefType, Components>,
        options: GenerateOptions
    ]) => any;
};
export declare type UnhandledMethods<DefType, Parent, Components> = Omit<HandlesMethods<DefType, Components>, keyof GetHandledMethods<Parent>>;
export declare type ParseFunction<DefType, Components> = (...args: ParseArgs<DefType>) => ParseResult<DefType>;
export declare type ParseResult<DefType> = {
    def: DefType;
    ctx: ParseContext;
} & CoreMethods<DefType>;
export declare type CoreMethods<DefType> = {
    [MethodName in CoreMethodName]-?: TransformInputMethod<NonNullable<HandlesMethods<DefType, any>[MethodName]>>;
};
export declare type TransformInputMethod<Method extends ValueOf<HandlesMethods<any, any>>> = Method extends (...args: [infer ParseResult, ...infer Rest, infer Opts]) => infer Return ? (...args: [...rest: Rest, opts?: Opts]) => Return : Method;
export declare type GetHandledMethods<Parent> = (KeyValuate<Parent, "inherits"> extends () => infer Return ? Return : {}) & KeyValuate<Parent, "handles">;
export declare type ParserMetadata<DefType, Parent, Handles extends HandlesMethods<DefType, any>> = Evaluate<{
    meta: {
        type: DefType;
        inherits: () => GetHandledMethods<Parent>;
        handles: unknown extends Handles ? {} : Handles;
        matches: DefinitionMatcher<DefType>;
    };
}>;
export declare type Parser<DefType, Parent, Handles, Components> = Evaluate<ParserMetadata<DefType, Parent, Handles> & ParseFunction<DefType, Components>>;
export declare type CoreMethodName = keyof HandlesMethods<any, any>;
export declare const reroot: {
    meta: {
        type: string | number | {
            [x: string]: any;
        };
        inherits: () => void;
        handles: {};
    };
};
export declare const createParser: <Input, Handles, DefType, Parent, Components, Children extends DefType[] = []>(args_0: Exact<Input, ParserInput<DefType, Parent, Children, Components>>, ...args_1: HandlesArg<Children, Exact<Handles, UnhandledMethods<DefType, Parent, Components>>>) => {
    meta: {
        type: DefType;
        inherits: () => GetHandledMethods<Parent>;
        handles: unknown extends Handles ? {} : Handles;
        matches: DefinitionMatcher<DefType>;
    };
} & ParseFunction<DefType, Components>;