type RegistrySchemas = {
    and: typeof import('./nodes/and').default;
    any: typeof import('./nodes/any').default;
    array: typeof import('./nodes/array').default;
    bigint: typeof import('./nodes/bigint').default;
    boolean: typeof import('./nodes/boolean').default;
    nillable: typeof import('./nodes/nillable').default;
    null: typeof import('./nodes/null').default;
    nullable: typeof import('./nodes/nullable').default;
    number: typeof import('./nodes/number').default;
    object: typeof import('./nodes/object').default;
    optional: typeof import('./nodes/optional').default;
    or: typeof import('./nodes/or').default;
    record: typeof import('./nodes/record').default;
    string: typeof import('./nodes/string').default;
    symbol: typeof import('./nodes/symbol').default;
    tuple: typeof import('./nodes/tuple').default;
    undefined: typeof import('./nodes/undefined').default;
    unknown: typeof import('./nodes/unknown').default;
};
type AbstractState<BaseType, FullType> = {
    default?: FullType;
    description?: string;
    title?: string;
};
type AndState<BaseType, FullType, U> = AbstractState<BaseType, FullType> & {
    anyOf?: FunctionMaybe<BaseType[]>;
    noneOf?: FunctionMaybe<BaseType[]>;
    options: Schema<U>[];
};
type AnyState<BaseType, FullType> = AbstractState<BaseType, FullType> & {
    anyOf?: FunctionMaybe<BaseType[]>;
    noneOf?: FunctionMaybe<BaseType[]>;
};
type ArrayState<BaseType, FullType, U> = AbstractState<BaseType, FullType> & {
    anyOf?: FunctionMaybe<BaseType[]>;
    noneOf?: FunctionMaybe<BaseType[]>;
    items?: FunctionMaybe<Schema<U>>;
    max?: FunctionMaybe<number>;
    min?: FunctionMaybe<number>;
};
type BigIntState<BaseType, FullType> = AbstractState<BaseType, FullType> & {
    anyOf?: FunctionMaybe<BaseType[]>;
    noneOf?: FunctionMaybe<BaseType[]>;
    gt?: FunctionMaybe<bigint>;
    gte?: FunctionMaybe<bigint>;
    lt?: FunctionMaybe<bigint>;
    lte?: FunctionMaybe<bigint>;
    multipleOf?: FunctionMaybe<bigint>;
};
type BooleanState<BaseType, FullType> = AbstractState<BaseType, FullType> & {
    anyOf?: FunctionMaybe<BaseType[]>;
    noneOf?: FunctionMaybe<BaseType[]>;
};
type NillableState<BaseType, FullType, U> = AbstractState<BaseType, FullType> & {
    nillable: Schema<U>;
};
type NullState<BaseType, FullType> = AbstractState<BaseType, FullType>;
type NullableState<BaseType, FullType, U> = AbstractState<BaseType, FullType> & {
    nullable: Schema<U>;
};
type NumberState<BaseType, FullType> = AbstractState<BaseType, FullType> & {
    anyOf?: FunctionMaybe<BaseType[]>;
    noneOf?: FunctionMaybe<BaseType[]>;
    finite?: true;
    gt?: FunctionMaybe<number>;
    gte?: FunctionMaybe<number>;
    integer?: true;
    lt?: FunctionMaybe<number>;
    lte?: FunctionMaybe<number>;
    multipleOf?: FunctionMaybe<number>;
};
type ObjectState<BaseType, FullType, U> = AbstractState<BaseType, FullType> & {
    anyOf?: FunctionMaybe<BaseType[]>;
    noneOf?: FunctionMaybe<BaseType[]>;
    properties?: FunctionMaybe<Record<string, Schema<U>>>;
};
type OptionalState<BaseType, FullType, U> = AbstractState<BaseType, FullType> & {
    optional: Schema<U>;
};
type OrState<BaseType, FullType, U> = AbstractState<BaseType, FullType> & {
    anyOf?: FunctionMaybe<BaseType[]>;
    noneOf?: FunctionMaybe<BaseType[]>;
    options: Schema<U>[];
};
type RecordState<BaseType, FullType, U> = AbstractState<BaseType, FullType> & {
    anyOf?: FunctionMaybe<BaseType[]>;
    noneOf?: FunctionMaybe<BaseType[]>;
    keys?: FunctionMaybe<Schema<string>>;
    values?: FunctionMaybe<Schema<U>>;
};
type StringState<BaseType, FullType> = AbstractState<BaseType, FullType> & {
    anyOf?: FunctionMaybe<BaseType[]>;
    noneOf?: FunctionMaybe<BaseType[]>;
    matches?: ((value: string) => boolean) | RegExp;
    max?: FunctionMaybe<number>;
    min?: FunctionMaybe<number>;
};
type SymbolState<BaseType, FullType> = AbstractState<BaseType, FullType> & {
    anyOf?: FunctionMaybe<BaseType[]>;
    noneOf?: FunctionMaybe<BaseType[]>;
};
type TupleState<BaseType, FullType, U> = AbstractState<BaseType, FullType> & {
    anyOf?: FunctionMaybe<BaseType[]>;
    noneOf?: FunctionMaybe<BaseType[]>;
    items?: FunctionMaybe<Schema<U>[]>;
    length?: FunctionMaybe<number>;
};
type UndefinedState<BaseType, FullType> = AbstractState<BaseType, FullType>;
type UnknownState<BaseType, FullType> = AbstractState<BaseType, FullType> & {
    anyOf?: FunctionMaybe<BaseType[]>;
    noneOf?: FunctionMaybe<BaseType[]>;
};
type FunctionMaybe<T> = T | (() => T);
type Infer<T extends Schema> = T extends {
    test: (value: unknown) => value is infer U;
} ? U : never;
type Schema<T = unknown> = {
    filter(value: unknown, defaultable: false, quiet: true): boolean;
    filter(value: unknown, defaultable?: boolean, quiet?: false): T;
    filter(value: unknown, defaultable?: boolean, quiet?: boolean): T | boolean;
    get<T = unknown>(): AbstractState<T, T>;
    get<T = unknown>(key: 'default'): T | undefined;
    get(key: 'description'): string | undefined;
    get(key: 'title'): string | undefined;
    get(key?: string): unknown;
    test(value: unknown): value is T;
    traverse(traverser: Traverser, parent?: Schema, property?: string | number): void;
};
type Tests<BaseType extends unknown, State extends {}> = {
    [K in keyof State]: (value: BaseType, stateValue: NonNullable<State[K]>) => boolean;
};
type Traverser = (child: Schema, parent?: Schema, key?: string | number) => void;
export type { RegistrySchemas };
export type { AbstractState, AndState, AnyState, ArrayState, BigIntState, BooleanState, NillableState, NullState, NullableState, NumberState, ObjectState, OrState, OptionalState, RecordState, StringState, SymbolState, TupleState, UndefinedState, UnknownState };
export type { FunctionMaybe, Infer, Schema, Tests, Traverser };