/**
 * Triple DES 加密模式名称枚举
 */
export declare enum TripleDesModeEnum {
    ECB = "ECB",
    CBC = "CBC",
    CFB = "CFB",
    CTR = "CTR",
    OFB = "OFB",
    CTRGladman = "CTRGladman"
}
/**
 * Triple DES 加密模式名称常量对象
 */
export declare const TripleDesModeConst: {
    readonly ECB: TripleDesModeEnum.ECB;
    readonly CBC: TripleDesModeEnum.CBC;
    readonly CFB: TripleDesModeEnum.CFB;
    readonly CTR: TripleDesModeEnum.CTR;
    readonly OFB: TripleDesModeEnum.OFB;
    readonly CTRGladman: TripleDesModeEnum.CTRGladman;
};
/**
 * Triple DES 加密填充方式名称枚举
 */
export declare enum TripleDesPaddingEnum {
    AnsiX923 = "AnsiX923",
    Iso10126 = "Iso10126",
    ZeroPadding = "ZeroPadding",
    Pkcs7 = "Pkcs7",
    NoPadding = "NoPadding",
    Iso97971 = "Iso97971"
}
/**
 * Triple DES 加密填充方式名称常量对象
 */
export declare const TripleDesPaddingConst: {
    readonly AnsiX923: TripleDesPaddingEnum.AnsiX923;
    readonly Iso10126: TripleDesPaddingEnum.Iso10126;
    readonly ZeroPadding: TripleDesPaddingEnum.ZeroPadding;
    readonly Pkcs7: TripleDesPaddingEnum.Pkcs7;
    readonly NoPadding: TripleDesPaddingEnum.NoPadding;
    readonly Iso97971: TripleDesPaddingEnum.Iso97971;
};
/**
 * Triple DES 加密工具中会使用到的常量
 */
export declare const TripleDesConst: {
    /**
     * 在后端中，DES 加密算法的密钥限制为长度 24 位的 byte 数组
     */
    KEY_LEN: number;
    /**
     * 在后端中，DES 加密算法的加密盐(也就是后面的偏移量 IV)限制为长度 8 位的 byte 数组
     */
    SALT_LEN: number;
    /**
     * 由于在后端中，DES 加密算法的默认实现为 DESede/ECB/PKCS5Padding，所以默认的加密模式为 ECB
     */
    MODE_DEFAULT: TripleDesModeEnum;
    /**
     * 在后端中，DES 加密算法的默认实现为 DESede/ECB/PKCS5Padding，但是由于 CryptoJS 中没有与之
     * 对应的最后一个分组的填充方式 padding，所以这里使用前后端都有的最后一个分组的填充方式 ZeroPadding
     */
    PADDING_DEFAULT: TripleDesPaddingEnum;
};
/**
 * Triple DES 加密算法加密模式
 */
export declare const TripleDesMode: {
    readonly ECB: any;
    readonly CBC: any;
    readonly CFB: any;
    readonly CTR: any;
    readonly OFB: any;
    readonly CTRGladman: any;
};
/**
 * Triple DES 加密算法加密模式可选模式的类型
 */
export type TripleDesModeType = keyof typeof TripleDesMode;
/**
 * Triple DES 加密算法最后一个分组的填充方式
 */
export declare const TripleDesPadding: {
    readonly AnsiX923: any;
    readonly Iso10126: any;
    readonly ZeroPadding: any;
    readonly Pkcs7: any;
    readonly NoPadding: any;
    readonly Iso97971: any;
};
/**
 * DES 加密算法最后一个分组的填充方式可选值的类型
 */
export type TripleDesPaddingType = keyof typeof TripleDesPadding;
/**
 * DES 加密算法加密解密处理函数通用形参列表类型
 */
export type CommonDesPropsType = {
    key: string;
    salt?: string;
    isAllType?: boolean;
    mode?: TripleDesModeType;
    padding?: TripleDesPaddingType;
};
/**
 * DES 加密算法加密函数<br/>
 *
 * @param data 需要进行加密处理的数据。<span style="color:orange;">如果需要加密处理的数据为空，
 * 或者不是字符串类型且没有开启对所有的数据类型进行加密，或者为空字符串，都将不进行加密处理，直接返回传
 * 递进来的数据；如果开启了对所有的数据类型进行加密，但是传递进来的数据不是字符串类型，将其转化为 JSON
 * 字符串，然后进行加密处理</span>
 * @param key 加密密钥。<span style="color:orange;">如果密钥长度小于 24 位，则会直接返回传递进
 * 来需要加密处理的数据；如果密钥长度大于 24 位，则会对其进行截取，只取前 24 位</span>
 * @param salt 加密盐(偏移量)。<span style="color:orange;">如果加密盐为空或长度小于 8 位，则会
 * 使用密钥的前 8 位作为盐；如果加密盐长度大于 8 位，则会对其进行截取，只取前 8 位</span>
 * @param isAllType 是否对所有的数据类型进行加密，默认为 false。<span style="color:orange;">
 * 该项开启后，对于不是字符串类型的数据，会将其转化为 JSON 字符串，然后进行加密处理；如果没有开启，对于
 * 不为字符串类型的数据，则不会进行加密处理，直接返回原数据</span>
 * @param mode 加密模式。默认为 ECB
 * @param padding 最后一个分组的填充方式。默认为 ZeroPadding
 */
export declare const encrypt: ({ data, key, salt, isAllType, mode, padding, }: {
    data: any;
    key: string;
    salt?: string;
    isAllType?: boolean;
    mode?: TripleDesModeType;
    padding?: TripleDesPaddingType;
}) => any;
/**
 * 对数组类型的数据进行加密处理<br/>
 * 该方法会循环对数组中的每项数据进行加密处理，然后返回一个由加密后的数据项组成的新数组
 *
 * @param arr 需要加密处理的数组数据。
 * @param key 加密密钥
 * @param salt 加密盐(偏移量)
 * @param isAllType 是否对所有的数据类型进行加密，默认为 false。<span style="color:orange;">
 * 该项开启后，对于数组中不是字符串类型的每一项数据，会将其转化为 JSON 字符串，然后进行加密处理；如果
 * 没有开启，对于不为字符串类型的数据项，则不会进行加密处理，仍然原数据项</span>
 * @param isRecursion 是否递归处理数组项。默认为 false。<span style="color:orange;">如果开启了
 * 递归加密处理，则对于数组类型或者对象类型的数据项，会优先进行递归，然后再对其中的子数组项进行加密处理
 * </span>
 * @param mode 加密模式。默认为 ECB
 * @param padding 最后一个分组的填充方式。默认为 ZeroPadding
 */
export declare const encryptArr: ({ arr, key, salt, isAllType, isRecursion, mode, padding, }: {
    arr: any[] | null;
    isRecursion?: boolean;
    key: string;
    salt?: string;
    isAllType?: boolean;
    mode?: TripleDesModeType;
    padding?: TripleDesPaddingType;
}) => any[] | null;
/**
 * 对对象类型的数据进行加密处理<br/>
 * 该方法会循环对对象中的每项数据进行加密处理，然后返回一个由加密后的数据项组成的新对象
 *
 * @param obj 需要加密处理的对象数据。
 * @param key 加密密钥
 * @param salt 加密盐(偏移量)
 * @param isAllType 是否对所有的数据类型进行加密，默认为 false。<span style="color:orange;">
 * 该项开启后，对于对象中不是字符串类型的每一项数据，会将其转化为 JSON 字符串，然后进行加密处理；如果
 * 没有开启，对于不为字符串类型的数据项，则不会进行加密处理，仍然原数据项</span>
 * @param isRecursion 是否递归处理对象项。默认为 false。<span style="color:orange;">如果开启了
 * 递归加密处理，则对于数组类型或者对象类型的数据项，会优先进行递归，然后再对其中的子数组项进行加密处理
 * </span>
 * @param mode 加密模式。默认为 ECB
 * @param padding 最后一个分组的填充方式。默认为 ZeroPadding
 */
export declare const encryptObj: ({ obj, key, salt, isAllType, isRecursion, mode, padding, }: {
    obj: {
        [prop: string]: any;
    } | null;
    isRecursion?: boolean;
    key: string;
    salt?: string;
    isAllType?: boolean;
    mode?: TripleDesModeType;
    padding?: TripleDesPaddingType;
}) => {
    [prop: string]: any;
} | null;
/**
 * 对任意类型的数据进行加密处理<br/>
 *
 * @param obj 需要加密处理的对象数据。
 * @param key 加密密钥
 * @param salt 加密盐(偏移量)
 * @param isAllType 是否对所有的数据类型进行加密，默认为 false。<span style="color:orange;">
 * 该项开启后，对于对象中不是字符串类型的每一项数据，会将其转化为 JSON 字符串，然后进行加密处理；如果
 * 没有开启，对于不为字符串类型的数据项，则不会进行加密处理，仍然原数据项</span>
 * @param isRecursion 是否递归处理对象项。默认为 true。<span style="color:orange;">如果开启了
 * 递归加密处理，则对于数组类型或者对象类型的数据项，会优先进行递归，然后再对其中的子数组项进行加密处理
 * </span>
 * @param mode 加密模式。默认为 ECB
 * @param padding 最后一个分组的填充方式。默认为 ZeroPadding
 * @return {any} 加密处理后的数据
 */
export declare const encryptAny: ({ data, key, salt, isAllType, isRecursion, mode, padding, }: {
    data: any;
    isRecursion?: boolean;
    key: string;
    salt?: string;
    isAllType?: boolean;
    mode?: TripleDesModeType;
    padding?: TripleDesPaddingType;
}) => any;
/**
 * DES 加密算法解密函数<br/>
 *
 * @param data 需要进行解密处理的数据。<span style="color:orange;">如果需要解密处理的数据为空，
 * 或者不是字符串类型且没有开启对所有的数据类型进行解密，或者为空字符串，都将不进行解密处理，直接返回传
 * 递进来的数据</span>
 * @param key 加密密钥。<span style="color:orange;">如果密钥长度小于 24 位，则会直接返回传递进
 * 来需要解密处理的密文；如果密钥长度大于 24 位，则会对其进行截取，只取前 24 位</span>
 * @param salt 加密盐(偏移量)。<span style="color:orange;">如果加密盐为空或长度小于 8 位，则会
 * 使用密钥的前 8 位作为盐；如果加密盐长度大于 8 位，则会对其进行截取，只取前 8 位</span>
 * @param isAllType 加密处理时，是否对所有的数据类型进行加密，默认为 false。
 * <span style="color:orange;">该项开启后，对于解密后不是字符串类型的数据，会对其进行 JSON 字符串
 * 解析；如果没有开启，对于传入的需要解密处理的数据为空，或者不是字符串类型，或者为空字符串，都将不进行解
 * 密处理，直接返回传递进来的数据</span>
 * @param mode 加密模式。默认为 ECB
 * @param padding 最后一个分组的填充方式。默认为 ZeroPadding
 */
export declare const decrypt: ({ data, key, salt, isAllType, mode, padding, }: {
    data: any;
    key: string;
    salt?: string;
    isAllType?: boolean;
    mode?: TripleDesModeType;
    padding?: TripleDesPaddingType;
}) => any;
/**
 * 对数组类型的数据进行解密处理<br/>
 * 该方法会循环对数组中的每项数据进行解密处理，然后返回一个由解密后的数据项组成的新数组
 *
 * @param arr 需要解密处理的数组数据。
 * @param key 密钥
 * @param salt 加密盐(偏移量)
 * @param isAllType 加密处理时，是否对所有的数据类型进行加密，默认为 false。
 * <span style="color:orange;">该项开启后，对于解密后不是字符串类型的数据项，会对其进行 JSON 字符
 * 串解析；如果没有开启，对于不是字符串类型的数据项，都将不进行解密处理，直接保留原数据项</span>
 * @param isRecursion 是否递归处理数组项。默认为 false。<span style="color:orange;">如果开启
 * 了递归解密处理，则对于数组类型或者对象类型的数据项，会优先进行递归，然后再对其中的子数组项进行解密处理
 * </span>
 * @param mode 加密模式。默认为 ECB
 * @param padding 最后一个分组的填充方式。默认为 ZeroPadding
 */
export declare const decryptArr: ({ arr, key, salt, isAllType, isRecursion, mode, padding, }: {
    arr: any[] | null;
    isRecursion?: boolean;
    key: string;
    salt?: string;
    isAllType?: boolean;
    mode?: TripleDesModeType;
    padding?: TripleDesPaddingType;
}) => any[] | null;
/**
 * 对对象类型的数据进行解密处理<br/>
 * 该方法会循环对对象中的每项数据进行解密处理，然后返回一个由解密后的数据项组成的新对象
 *
 * @param obj 需要解密处理的对象数据。
 * @param key 密钥
 * @param salt 加密盐(偏移量)
 * @param isAllType 加密处理时，是否对所有的数据类型进行加密，默认为 false。
 * <span style="color:orange;">该项开启后，对于解密后不是字符串类型的数据项，会对其进行 JSON 字符
 * 串解析；如果没有开启，对于不是字符串类型的数据项，都将不进行解密处理，直接保留原数据项</span>
 * @param isRecursion 是否递归处理数组项。默认为 false。<span style="color:orange;">如果开启
 * 了递归解密处理，则对于数组类型或者对象类型的数据项，会优先进行递归，然后再对其中的子数组项进行解密处理
 * </span>
 * @param mode 加密模式。默认为 ECB
 * @param padding 最后一个分组的填充方式。默认为 ZeroPadding
 */
export declare const decryptObj: ({ obj, key, salt, isAllType, isRecursion, mode, padding, }: {
    obj: {
        [prop: string]: any;
    } | null;
    isRecursion?: boolean;
    key: string;
    salt?: string;
    isAllType?: boolean;
    mode?: TripleDesModeType;
    padding?: TripleDesPaddingType;
}) => {
    [prop: string]: any;
} | null;
/**
 * 对任意类型的数据进行解密处理<br/>
 *
 * @param obj 需要解密处理的对象数据。
 * @param key 密钥
 * @param salt 加密盐(偏移量)
 * @param isAllType 加密处理时，是否对所有的数据类型进行加密，默认为 false。
 * <span style="color:orange;">该项开启后，对于解密后不是字符串类型的数据项，会对其进行 JSON 字符
 * 串解析；如果没有开启，对于不是字符串类型的数据项，都将不进行解密处理，直接保留原数据项</span>
 * @param isRecursion 是否递归处理数据项。默认为 true。<span style="color:orange;">如果开启
 * 了递归解密处理，则对于数组类型或者对象类型的数据项，会优先进行递归，然后再对其中的子数据项进行解密处理
 * </span>
 * @param mode 加密模式。默认为 ECB
 * @param padding 最后一个分组的填充方式。默认为 ZeroPadding
 * @returns {any} 解密处理后的数据
 */
export declare const decryptAny: ({ secretData, key, salt, isAllType, isRecursion, mode, padding, }: {
    secretData: any;
    isRecursion?: boolean;
    key: string;
    salt?: string;
    isAllType?: boolean;
    mode?: TripleDesModeType;
    padding?: TripleDesPaddingType;
}) => any;