type Constructor<T> = new (...args: any[]) => T;
export type Primitive = string | number | symbol | boolean | undefined | null;
export declare let collectError: boolean;
export declare function setCollect(flag: boolean): void;
export declare abstract class Validator<T = unknown> {
    path?: string;
    errors: string[];
    abstract validate(x: unknown): x is T;
    protected fail(message: string): false;
    protected fail(options: {
        expect: string;
        actual: unknown;
    }): false;
    hasFallback: boolean;
    _fallback?: T;
    fallback(v: T): this;
    get fallbackValue(): T;
    hasDefault: boolean;
    protected _default?: T;
    default(v: T): this;
    get defaultValue(): T;
    _optional: boolean;
    optional(): Validator<T | undefined>;
}
export declare function isNumber(x: unknown): x is number;
export declare function echo(x: unknown): string;
export declare function getType(x: unknown): string;
export declare class $number extends Validator<number> {
    private _min?;
    private _max?;
    private _isInt?;
    private _greater?;
    validate(x: unknown): x is number;
    min(v: number): this;
    max(v: number): this;
    isInt(v: boolean): this;
    greater(v: number): this;
}
export declare class $boolean extends Validator<boolean> {
    validate(x: unknown): x is boolean;
}
export declare class $string extends Validator<string> {
    private _minLength?;
    private _maxLength?;
    private _pattern?;
    validate(x: unknown): x is string;
    minLength(len: number): this;
    maxLength(len: number): this;
    pattern(patten: string | RegExp): this;
}
export declare class $symbol extends Validator<symbol> {
    validate(x: unknown): x is symbol;
}
export declare class $any<T = any> extends Validator<T> {
    validate(x: unknown): x is T;
}
export declare class $undefined extends Validator<undefined> {
    validate(x: unknown): x is undefined;
}
export declare class $null extends Validator<null> {
    validate(x: unknown): x is null;
}
export declare class $function extends Validator<(...args: any[]) => any> {
    validate(x: unknown): x is (...args: any[]) => any;
}
export declare class $enum<T> extends Validator<T> {
    private readonly _items;
    constructor(..._items: (string | number | undefined)[]);
    validate(x: unknown): x is T;
}
export declare class $array<T extends unknown> extends Validator<T[]> {
    private readonly _item?;
    private _minItems?;
    private _maxItems?;
    private _uniqueItems?;
    private _length?;
    constructor(_item?: Validator | undefined);
    validate(x: unknown): x is T[];
    minItems(len: number): this;
    maxItems(len: number): this;
    uniqueItems(): this;
    length(len: number): this;
}
export declare class $record<T> extends Validator<Record<string, T>> {
    private readonly _value;
    constructor(_value: Validator);
    validate(x: unknown): x is Record<string, T>;
}
export declare class $object<T extends object> extends Validator<T> {
    private readonly _object;
    constructor(_object?: Record<string, Validator>);
    validate(x: unknown): x is T;
}
export declare class $literal<T extends Primitive> extends Validator<T> {
    private readonly value;
    constructor(value: T);
    validate(x: unknown): x is T;
}
export declare class $or<T> extends Validator<T> {
    private readonly _items;
    constructor(..._items: Validator[]);
    validate(x: unknown): x is T;
}
export declare class $tuple<T extends unknown[]> extends Validator<T> {
    private readonly _items;
    private readonly _minItems;
    constructor(..._items: Validator[]);
    validate(x: unknown): x is T;
}
export declare class $arraybuffer extends Validator<ArrayBuffer> {
    validate(x: unknown): x is ArrayBuffer;
}
export type TypedArray = Uint8Array | Int8Array | Uint8ClampedArray | Uint16Array | Int16Array | Uint32Array | Int32Array | Float32Array | Float64Array;
export declare class $typedarray<T extends TypedArray> extends Validator<T> {
    private readonly _ctor;
    constructor(ctor: Constructor<T>);
    validate(x: unknown): x is T;
}
export {};