import { DiffUnions, ElementOf, Evaluate, IsAny, KeyValuate, MergeAll, StringifyPossibleTypes, StringReplace, UnionDiffResult } from "@re-do/utils";
import { ParsedType } from "../../parse.js";
import { ParseConfig } from "./internal.js";
import { TypeSetMember } from "./member.js";
import { Root } from "../root.js";
import { Obj } from "../recursible";
export declare namespace TypeSet {
    type Definition<Def extends Obj.Definition = Obj.Definition> = Obj.Definition<Def>;
    type TypeNameFromList<Definitions> = keyof MergeAll<Definitions> & string;
    type ValidateMemberList<Definitions, DeclaredTypeNames extends string[] = [], Merged = TypeSet.Validate<MergeAll<Definitions>>, DefinedTypeName extends string = keyof Merged & string, DeclaredTypeName extends string = DeclaredTypeNames extends never[] ? DefinedTypeName : ElementOf<DeclaredTypeNames>, ErrorMessage extends string = MissingTypesError<DeclaredTypeName, DefinedTypeName>> = {
        [I in keyof Definitions]: ErrorMessage & {
            [TypeName in keyof Definitions[I]]: TypeName extends DeclaredTypeName ? KeyValuate<Merged, TypeName> : `${TypeName & string} was never declared.`;
        };
    };
    type MergeMemberList<Definitions> = MergeAll<Definitions>;
    type ValidateReferences<Def, DeclaredTypeName extends string> = Root.Validate<Def, {
        [TypeName in DeclaredTypeName]: "unknown";
    }>;
    type Validate<TypeSet> = IsAny<TypeSet> extends true ? any : Evaluate<{
        [TypeName in keyof TypeSet]: TypeSetMember.Validate<TypeSet[TypeName], TypeSet>;
    }>;
    type Parse<TypeSet, Options extends ParseConfig> = {
        [TypeName in keyof TypeSet]: ParsedType<TypeSet[TypeName], Validate<TypeSet>, Options>;
    };
}
export declare const extraneousTypesErrorMessage = "Defined types @types were never declared.";
export declare const missingTypesErrorMessage = "Declared types @types were never defined.";
export declare type MissingTypesError<DeclaredTypeName, DefinedTypeName> = DiffUnions<DeclaredTypeName, DefinedTypeName> extends UnionDiffResult<infer Extraneous, infer Missing> ? Missing extends [] ? {} : StringReplace<typeof missingTypesErrorMessage, "@types", StringifyPossibleTypes<`'${ElementOf<Missing>}'`>> : never;