export declare class ValidatorAssertError extends Error {
    protected vName: string;
    protected lastValidator: string;
    constructor(vName: string, lastValidator: string);
    readonly validatorName: string;
    readonly valueName: string;
}
export interface ArgumentFilter {
    (object: any, valueName?: string): boolean;
}
export interface ArgumentFilterAssert {
    /** @throws */
    (object: any, valueName?: string): void;
}
export interface ArgumentWorker<T> {
    (object: T, valueName?: string): T;
}
export interface SanitizerConfig {
    argument?: any[] | IArguments;
    debugTitle: string;
    sanitize: (value: any, ...args: any[]) => any;
}
export interface ValidateConfig {
    argument?: any[] | IArguments;
    debugTitle: string;
    validate: (value: any, ...args: any[]) => boolean;
}
export interface ValueValidatorObject {
    getAssert(): ArgumentFilterAssert;
    getFunction(): ArgumentFilter;
}
export interface ValueSanitizerObject {
    getFunction(): ArgumentWorker<any>;
}
export declare abstract class ValueAbstract {
    protected list: (ValidateConfig | SanitizerConfig)[];
    constructor(ref?: ValueAbstract);
}
export declare abstract class ValueCheckerAbstract extends ValueAbstract implements ValueValidatorObject {
    protected list: ValidateConfig[];
    getAssert(valueName?: string): ArgumentFilterAssert;
    /**
     * will not throw if check fail
     * but will throw internal error (eg. null.xxx)
     */
    getFunction(valueName?: string): ArgumentFilter;
    byCallback(fn: (...arg: any[]) => boolean, ...args: any[]): this;
}
export declare abstract class ValueSanitizerAbstract extends ValueAbstract implements ValueSanitizerObject {
    protected list: SanitizerConfig[];
    getFunction(): ArgumentWorker<any>;
    byCallback(fn: (...arg: any[]) => any, ...args: any[]): this;
}