export declare type CertType = {
    CN: string;
    sn: string;
    CertB64: string;
    CertType: string;
    ContainerName: string;
    DevClass: string;
    manu?: string;
    [key: string]: unknown;
};

export declare function createService(config?: ServiceConfigType): Promise<GwsService>;

export declare class GwsService {
    static instance: GwsService | null;
    private coreInstance;
    private gwsConfig;
    constructor(config?: ServiceConfigType);
    private createGwsCore;
    private appendCertBase64;
    destroy: () => void;
    restart: (config?: Record<string, any>) => void;
    getSocketReadyState: () => number | undefined;
    verifyPin: (params: {
        UserPin?: string;
    }, curCert?: CertType) => Promise<any>;
    checkCertIsLogin: (curCert?: CertType) => Promise<any>;
    ensureCertLogin: (curCert?: CertType) => Promise<void | undefined>;
    getSignatureCert: (cert?: CertType, checkLogin?: boolean) => Promise<Record<string, any> | undefined>;
    getSignatureCertList: () => Promise<CertType[] | undefined>;
    getEncryptionCert: (cert?: CertType, checkLogin?: boolean) => Promise<Record<string, any> | undefined>;
    getEncryptionCertList: () => Promise<CertType[] | undefined>;
    getClientVersion: () => Promise<any>;
    base64Encode: (params: {
        Data: string;
    }) => string;
    base64Decode: (params: {
        DataB64: string;
    }) => string;
    changeIsRememberPin: (bol: boolean) => void;
    changePinPolicy: (pinPolicy: string) => void;
    pkcs1Sign: (params: {
        Data: string;
        IsLogin?: string;
    }, curCert?: CertType) => Promise<any>;
    pkcs1VerifySignature: (params: {
        CertB64?: string;
        Data: string;
        SignData: string;
    }) => Promise<boolean>;
    pkcs1Base64Sign: (params: {
        Data?: string;
        DataB64?: string;
        IsLogin?: string;
    }, curCert?: CertType) => Promise<any>;
    batchPkcs1Base64Sign: (params: {
        Data?: string[];
        DataB64?: string[];
    }, curCert?: CertType) => Promise<string[]>;
    pkcs1Base64VerifySignature: (params: {
        CertB64?: string;
        Data?: string;
        DataB64?: string;
        SignData: string;
    }) => Promise<boolean>;
    writeSeal: (params: {
        SealId: string;
        DataB64: string;
        IsLogin?: string;
    }, curCert?: CertType) => Promise<boolean>;
    deleteSeal: (params?: {
        IsLogin?: string;
    }, curCert?: CertType) => Promise<boolean>;
    deleteSealById: (params: {
        SealId: string;
        IsLogin?: string;
    }, curCert?: CertType) => Promise<boolean>;
    getSealList: (params?: {
        IsLogin?: string;
    }, curCert?: CertType) => Promise<{
        SealId: string;
    }[]>;
    getSealInfo: (params?: {
        IsLogin?: string;
    }, curCert?: CertType) => Promise<any>;
    getTPSealList: (params?: {
        Vid?: string;
        IsLogin?: string;
    }, curCert?: CertType) => Promise<TPSeaType[]>;
    getTPSeal: (params?: {
        Vid?: string;
        IsLogin?: string;
    }, curCert?: CertType) => Promise<Record<string, any> | TPSeaType>;
    getTPSealPic: (params?: {
        Vid?: string;
        IsLogin?: string;
    }, curCert?: CertType, curSeal?: TPSeaType) => Promise<any>;
    sm2SignPreprocess1: (params: {
        CertB64?: string;
    }) => Promise<any>;
    sm2SignPreprocess2: (params: {
        CertB64?: string;
        Data: string;
    }) => Promise<any>;
    pkcs1HashSign: (params: {
        DataB64: string;
        HashAlg?: string;
        IsLogin?: string;
    }, curCert?: CertType) => Promise<any>;
    pkcs1HashVerifySignature: (params: {
        CertB64?: string;
        DataB64: string;
        SignData: string;
        HashAlg?: string;
    }) => Promise<boolean>;
    pkcs7Sign: (params: {
        Data?: string;
        IsDetached: string;
        DataB64?: string;
        IsLogin?: string;
    }, curCert?: CertType) => Promise<any>;
    pkcs7VerifySignature: (params: {
        Data?: string;
        DataB64?: string;
        SignData: string;
    }) => Promise<boolean>;
    sm3Hash: (params: {
        Data: string;
    }) => Promise<any>;
    sm3HexHash: (params: {
        DataB64: string;
    }) => Promise<any>;
    sm3FileHash: (params: {
        SrcFile: string;
    }) => Promise<any>;
    sm3HashEncryption: (params: {
        Data?: string;
        DataB64?: string;
        Key?: string;
        KeyB64?: string;
    }) => Promise<any>;
    pkcs7Encryption: (params: {
        Data?: string;
        DataB64?: string;
        CertB64List?: string;
    }) => Promise<any>;
    pkcs7Decryption: (params: {
        DataB64: string;
        shouldDecodeBase64?: boolean;
        IsLogin?: string;
    }) => Promise<any>;
    pkcs7FileEncryption: (params: {
        DstFile?: string;
        CertB64?: string;
        SrcFile: string;
    }) => Promise<any>;
    pkcs7FileDecryption: (params: {
        SrcFile: string;
        DstFile?: string;
    }) => Promise<any>;
    asymmetricEncryption: (params: {
        CertB64?: string;
        Data: string;
    }) => Promise<any>;
    asymmetricDecryption: (params: {
        Data: string;
        IsLogin?: string;
    }, curCert?: CertType) => Promise<any>;
    sm4Encryption: (params: {
        Data: string;
    }) => Promise<any>;
    sm4Decryption: (params: {
        Data: string;
        KeyB64: string;
    }) => Promise<any>;
    getCertInfo: (params: {
        CertB64: string;
    }) => Promise<any>;
    getCertInfoByOid: (params: {
        Oid: string;
        CertB64: string;
    }) => Promise<any>;
    getSealVendor: (curCert?: CertType) => Promise<any>;
    deleteAllSealByVendor: (params: {
        SealIssuer: string;
    }, curCert?: CertType) => Promise<any>;
    getUKey: (curUkey?: UkeyType) => Promise<UkeyType>;
    getUKeyList: () => Promise<any>;
    getUKeyInfo: (curUkey?: UkeyType) => Promise<any>;
    applyCert: (params: {
        type: string;
        url: string;
        dn?: string;
        isLogin?: string;
    }, curUkey?: UkeyType) => Promise<any>;
    resetPin: (params: {
        url: string;
    }, curCert?: CertType) => Promise<any>;
    lockPin: (curCert?: CertType) => Promise<any>;
    genRandom: (params: {
        Length: number;
        Encoding?: string;
    }, curCert?: CertType) => Promise<any>;
    getMachineInfo: () => Promise<any>;
}

export declare type SelectModalColItemType = {
    key?: string;
    format?: (record: Record<string, any>) => string;
};

export declare type SelectModalOptions = {
    data: Record<string, any>[];
    columns: SelectModalColItemType[];
    cancelText?: string;
    okText?: string;
    onOk?: (cert: CertType) => void;
    onCancel?: (cert: CertType) => void;
    theme?: string;
    title?: string;
};

export declare type ServiceConfigType = {
    url?: string;
    pinPolicy?: string;
    isRememberPin?: boolean;
    isCreateNew?: boolean;
    onOpen?: (event: Event) => void;
    onMessage?: (data: Record<string, unknown>) => void;
    onError?: (event: Event) => void;
    onClose?: (event: Event) => void;
    onUkeyChange?: (data: Record<string, unknown>) => void;
    theme?: string;
    scene?: number;
};

export declare type SocketResponseType = {
    data?: any;
    success?: boolean;
    msg: string;
    errCode: number;
    type?: string;
};

export declare type TPSeaType = {
    FileName: string;
    FileSize: number;
    SealId: string;
    Vid: string;
};

export declare type UkeyType = {
    isLogin: boolean;
    manu: string;
    sn: string;
};

export { }