import { TEmptyArgs, TErrorParam } from '../../types';
export declare class Empty {
    /**
     * 判断一个值是否不为空
     * @param value 要判断的值
     * @param strict 是否严格模式，默认 true
     * @returns {boolean}
     */
    static notEmpty: (value: any, strict?: boolean) => boolean;
    /**
     * 判断一个值是否为空
     * @param value 要判断的值
     * @param strict 是否严格模式，默认 true
     * @returns {boolean}
     */
    static isEmpty(value: any, strict?: boolean): boolean;
    /**
     * 判断多个参数是否都为空
     * @param args 多个参数
     * @returns {empty: boolean, list: string[]}
     */
    static isEmptyArgs(args: Object): TEmptyArgs;
    static isEmptyError(args: Object, printStack?: boolean, handle?: Function): void;
    /**
     * 包装一个值，使其成为 Optional 对象
     * @param value 要包装的值
     * @returns {Optional}
     */
    static ofNullable<T = any>(value: T | null): Optional<T>;
}
export declare class EmptyArgs {
    empty: boolean;
    list: string[];
    constructor(args: Object);
    /**
     * 调用默认 EmptyError 处理错误
     * 可重写或传入 EmptyError.handle 方法来自定义错误处理
     * @param handle
     * @param printStack
     */
    end(handle?: Function, printStack?: boolean): void;
    error<T extends Error>(ErrorType: new (params: TErrorParam) => T): void;
}
/**
 * Optional 类
 * 用于包装可能为空的值，提供链式调用的方法
 * @class Optional
 */
declare class Optional<T> {
    private readonly value;
    constructor(value: T | null);
    static empty<T>(): Optional<T>;
    isPresent(): boolean;
    ifPresent(func: (value: T) => void): void;
    filter(predicate: (value: T) => boolean): Optional<T>;
    map<U>(func: (value: T) => U): Optional<U>;
    flatMap<U>(func: (value: T) => Optional<U>): Optional<U>;
    orElse(other: T | null): T;
    orElseGet(supplier: () => T): T;
    orElseThrow(error?: Error): T;
    get(): T;
    orElseThis(): T;
    private static defaultValue;
}
export {};