import { Type } from "../types/type/Type";
import { WrappedType } from "../types/wrap/WrappedType";
import { TFlatType } from "../types/type/TFlatType";
import { UnwrappedType } from "../types/wrap/UnwrappedType";
export declare class ObjectUtils {
    static clone<T>(source: T, options?: {
        excludes?: string[];
        useRefTypes?: any[];
        onlyOneDepth?: boolean;
    }): T;
    private static _clone;
    static merge<T, P>(source: T, target: P, opt?: {
        arrayProcess?: "replace" | "concat";
        useDelTargetNull?: boolean;
    }): T & P;
    static merge3<S extends Record<string, TFlatType>, O extends Record<string, TFlatType>, T extends Record<string, TFlatType>>(source: S, origin: O, target: T, optionsObj?: Record<string, {
        keys?: string[];
        excludes?: string[];
        ignoreArrayIndex?: boolean;
    }>): {
        conflict: boolean;
        result: O & S & T;
    };
    static omit<T extends Record<string, any>, K extends keyof T>(item: T, omitKeys: K[]): Omit<T, K>;
    static omitByFilter<T extends Record<string, any>>(item: T, omitKeyFn: (key: keyof T) => boolean): T;
    static pick<T extends Record<string, any>, K extends keyof T>(item: T, keys: K[]): Pick<T, K>;
    static pickByType<T extends Record<string, any>, A extends TFlatType>(item: T, type: Type<A>): {
        [K in keyof T]: WrappedType<T[K]> extends WrappedType<A> ? T[K] : never;
    };
    static equal(source: any, target: any, options?: {
        includes?: string[];
        excludes?: string[];
        ignoreArrayIndex?: boolean;
        onlyOneDepth?: boolean;
    }): boolean;
    static validate<T>(value: T, def: TValidateDef<T>): IValidateResult<T> | undefined;
    static validateObject<T>(obj: T, def: TValidateObjectDef<T>): TValidateObjectResult<T>;
    static validateObjectWithThrow<T>(displayName: string, obj: T, def: TValidateObjectDefWithName<T>): void;
    static validateArray<T>(arr: T[], def: ((item: T) => TValidateObjectDef<T>) | TValidateObjectDef<T>): IValidateArrayResult<T>[];
    static validateArrayWithThrow<T>(displayName: string, arr: T[], def: ((item: T) => TValidateObjectDefWithName<T>) | TValidateObjectDefWithName<T>): void;
    static getChainValueByDepth<T, K extends keyof T>(obj: T, key: K, depth: number, optional: true): T[K] | undefined;
    static getChainValueByDepth<T, K extends keyof T>(obj: T, key: K, depth: number): T[K];
    private static _getChainSplits;
    static getChainValue(obj: any, chain: string, optional: true): any | undefined;
    static getChainValue(obj: any, chain: string): any;
    static setChainValue(obj: any, chain: string, value: any): void;
    static deleteChainValue(obj: any, chain: string): void;
    static clearUndefined<T>(obj: T): T;
    static clear<T extends {}>(obj: T): {};
    static nullToUndefined<T>(obj: T): T | undefined;
    static optToUndef<T>(obj: TUndefToOptional<T>): T;
    static unflattenObject(flatObj: Record<string, any>): Record<string, any>;
}
export type TValidateDef<T> = Type<WrappedType<T>> | Type<WrappedType<T>>[] | IValidateDef<T>;
export interface IValidateDef<T> {
    type?: Type<WrappedType<T>> | Type<WrappedType<T>>[];
    notnull?: boolean;
    includes?: T[];
    displayValue?: boolean;
    validator?: (value: UnwrappedType<NonNullable<T>>) => boolean | string;
}
export interface IValidateResult<T> {
    value: T;
    invalidateDef: IValidateDef<T> & {
        type?: Type<WrappedType<T>>[];
    };
    message?: string;
}
type TValidateObjectDef<T> = {
    [K in keyof T]?: TValidateDef<T[K]>;
};
type TValidateObjectResult<T> = {
    [K in keyof T]?: IValidateResult<T[K]>;
};
export interface IValidateDefWithName<T> extends IValidateDef<T> {
    displayName: string;
}
export type TValidateObjectDefWithName<T> = {
    [K in keyof T]?: IValidateDefWithName<T[K]>;
};
interface IValidateArrayResult<T> {
    index: number;
    item: T;
    result: TValidateObjectResult<T>;
}
export type TUndefToOptional<T> = {
    [K in keyof T as undefined extends T[K] ? K : never]?: T[K];
} & {
    [K in keyof T as undefined extends T[K] ? never : K]: T[K];
};
export type TOptionalToUndef<T> = {
    [K in keyof T]-?: {} extends Pick<T, K> ? Exclude<T[K], undefined> | undefined : T[K];
};
export {};