Oberthur Cosmo One v7.3

export interface AbstractOberthur73 {
    allCertFilters(): string[];
    allKeyRefs(): string[];
    allCerts(parseCerts?: boolean, filters?: string[] | Options, callback?: (error: T1CLibException, data: TokenAllCertsResponse) => void): Promise<TokenAllCertsResponse>;
    tokenData(callback?: (error: T1CLibException, data: TokenDataResponse) => void): Promise<TokenDataResponse>;
    rootCertificate(parseCerts?: boolean, callback?: (error: T1CLibException, data: TokenCertificateResponse) => void): Promise<TokenCertificateResponse>;
    authenticationCertificate(parseCerts?: boolean, callback?: (error: T1CLibException, data: TokenCertificateResponse) => void): Promise<TokenCertificateResponse>;
    nonRepudiationCertificate(parseCerts?: boolean, callback?: (error: T1CLibException, data: TokenCertificateResponse) => void): Promise<TokenCertificateResponse>;
    encryptionCertificate(parseCerts?: boolean, callback?: (error: T1CLibException, data: TokenCertificateResponse) => void): Promise<TokenCertificateResponse>;
    issuerCertificate(parseCerts?: boolean, callback?: (error: T1CLibException, data: TokenCertificateResponse) => void): Promise<TokenCertificateResponse>
    verifyPin(body: TokenVerifyPinData, callback?: (error: T1CLibException, data: TokenVerifyPinResponse) => void): Promise<TokenVerifyPinResponse>;
    authenticate(body: TokenAuthenticateOrSignData, callback?: (error: T1CLibException, data: TokenAuthenticateResponse) => void): Promise<TokenAuthenticateResponse>;
    sign(body: TokenAuthenticateOrSignData, bulk?: boolean, callback?: (error: T1CLibException, data: TokenSignResponse) => void): Promise<TokenSignResponse>;
    allAlgoRefs(callback?: (error: T1CLibException, data: TokenAlgorithmReferencesResponse) => void): Promise<TokenAlgorithmReferencesResponse>
    resetBulkPin(callback?: (error: T1CLibException, data: BoolDataResponse) => void): Promise<BoolDataResponse>;
}

T1cSdk.initialize(config).then(res => {
    const oberthur = res.client.oberthur(readerId);
}, err => {
    console.error(error)
});

oberthur.allCertFilters().then(res => {
}, err => {
    console.error(err)
})

{
    success: true,
    data: ['rootCertificate', 'authenticationCertificate', 'encryptionCertificate', 'nonRepudiationCertificate', 'issuerCertificate']
}

oberthur.allKeyRefs().then(res => {
}, err => {
    console.error(err)
})

{
    success: true,
    data: ['authenticate', 'sign', 'encrypt']
}

const filter = ['rootCertificate', 'authenticationCertificate', 'encryptionCertificate'];
oberthur.allCerts(filter).then(res => {
}, err => {
    console.error(err)
})

{
    success: true,
    data: {
       authenticationCertificate?: {
            certificate?: TokenCertificateObject,
            certificates?: Array<TokenCertificateObject>
       },
       citizenCertificate?: {
            certificate?: TokenCertificateObject,
            certificates?: Array<TokenCertificateObject>
       },
       nonRepudiationCertificate?: {
            certificate?: TokenCertificateObject,
            certificates?: Array<TokenCertificateObject>
       },,
       rootCertificate?: {
            certificate?: TokenCertificateObject,
            certificates?: Array<TokenCertificateObject>
       },,
       encryptionCertificate?: {
            certificate?: TokenCertificateObject,
            certificates?: Array<TokenCertificateObject>
       },
    }
}

oberthur.tokenData().then(res => {
}, err => {
    console.error(err)
})

{
    success: true,
    data: {
       version?: string,
       serialNumber?: string,
       label?: string,
       changeCounter?: number,
    }
}

oberthur.rootCertificate(parseCertsBoolean).then(res => {
}, err => {
    console.error(err)
})

oberthur.authenticationCertificate(parseCertsBoolean).then(res => {
}, err => {
    console.error(err)
})

oberthur.nonRepudiationCertificate(parseCertsBoolean).then(res => {
}, err => {
    console.error(err)
})

oberthur.issuerCertificate(parseCertsBoolean).then(res => {
}, err => {
    console.error(err)
})

aventra.encryptionCertificate(parseCertsBoolean).then(res => {
}, err => {
    console.error(err)
})

{
    success: true,
    data: {
        certificate?: string,
        certificates?: Array<string>,
        certificateType?: string,
        id?: string,
        parsedCertificate?: Certificate,
        parsedCertificates?: Array<Certificate>
    }    
}

const data = {
    pin: "1234", // optional
    osDialog: true // optional
}
oberthur.verifyPin(data).then(res => {
}, err => {
    console.error(err)
})

{
    success: true,
    data: {
        "verfied": true
    }
}

const data = {
    algorithm: "sha256",
    data: "E1uHACbPvhLew0gGmBH83lvtKIAKxU2/RezfBOsT6Vs=",
    id: "123"
}
const bulk = false;
oberthur.sign(data, bulk).then(res => {
}, err => {
    console.error(err)
})

{
    success: true,
    data: {
        data: string
    }
}

diplad.resetBulkPin().then(res => {
}, err => {
    console.error(err)
})

{
    "success": true,
    "data": true
}

const data = {
    algorithm: "sha256",
    data: "E1uHACbPvhLew0gGmBH83lvtKIAKxU2/RezfBOsT6Vs="
    id: "123"
}
oberthur.authenticate(data).then(res => {
}, err => {
    console.error(err)
})

{
    success: true,
    data: {
        data: string
    }
}

oberthur.allAlgoRefs(data).then(res => {
}, err => {
    console.error(err)
})

{
    success: true,
    data: {
        ref: ['sha256', 'md5']
    }
}