Type alias WalletBase

WalletBase: {
    close: (() => Promise<Result<void, CloseWalletError>>);
    credential: {
        compact: {
            verifyCredential: ((options) => Promise<Result<VerifyCompactCredentialResult, VerifyCompactCredentialError>>);
        };
        compactSemantic: {
            verifyCredential: ((options) => Promise<Result<VerifyCompactSemanticCredentialResult, VerifyCompactSemanticCredentialError>>);
        };
        mobile: {
            addTrustedIssuerCertificates: ((certificates) => Promise<Result<string[], AddTrustedIssuerCertificatesError>>);
            addTrustedVerifierCertificates: ((certificates) => Promise<Result<string[], AddTrustedVerifierCertificatesError>>);
            createOnlinePresentationSession: ((options) => Promise<Result<OnlinePresentationSession, CreateOnlinePresentationSessionError>>);
            createProximityPresentationSession: ((options) => Promise<Result<ProximityPresentationSession, CreateProximityPresentationSessionError>>);
            deleteCredential: ((credentialId) => Promise<void>);
            deleteTrustedIssuerCertificate: ((certificateId) => Promise<Result<void, DeleteTrustedIssuerCertificateError>>);
            deleteTrustedVerifierCertificate: ((certificateId) => Promise<void>);
            getCredential: ((credentialId) => Promise<Result<MobileCredential, GetMobileCredentialError>>);
            getCredentials: (() => Promise<MobileCredentialMetadata[]>);
            getCurrentProximityPresentationSession: (() => Promise<ProximityPresentationSession | undefined>);
            getTrustedIssuerCertificates: (() => Promise<TrustedIssuerCertificate[]>);
            getTrustedVerifierCertificates: (() => Promise<TrustedVerifierCertificate[]>);
            sendProximityPresentationResponse: ((options) => Promise<Result<void, SendProximityPresentationResponseError>>);
            terminateProximityPresentationSession: (() => Promise<void>);
        };
        webSemantic: {
            createPresentation: ((options) => Promise<Result<VerifiablePresentation, CreateWebSemanticPresentationErrors>>);
            deriveCredential: ((options) => Promise<Result<VerifiableCredential, DeriveWebSemanticCredentialError>>);
            expandCredential: ((options) => Promise<Result<Record<string, unknown>, BaseError<ExpandWebSemanticCredentialErrorType | ContextCheckerErrorType>>>);
            filterCredentialsByQuery: (<T>(options) => Promise<Result<FilterWebSemanticCredentialsByQueryResponse<T>, FilterWebSemanticCredentialsByQueryError>>);
            isSelectivelyDisclosable: ((credential) => boolean);
            sendPresentationResponse: ((options) => Promise<Result<void, SendWebSemanticPresentationResponseError>>);
            verifyCredential: ((options) => Promise<Result<VerifyWebSemanticCredentialResult, VerifyWebSemanticCredentialError>>);
        };
    };
    did: {
        createDid: (() => Promise<Result<CreateDidResponse, CreateDidError>>);
        deleteDid: ((did) => Promise<Result<void, DeleteDidError>>);
        listDids: (() => Promise<Result<readonly string[], GetDidsError>>);
        messaging: {
            encrypt: ((options) => Promise<Result<JweJsonSerialization, BaseError<EncryptErrorType>>>);
            openDidCommMessage: ((message) => Promise<Result<Jwm, OpenDidCommError | VerifyError | DecryptError | NetworkError>>);
            resolveDidCommUri: ((didCommUri) => Promise<Result<unknown, BaseError<ResolveDidCommUriErrorType>>>);
            sign: ((payload, senderDid) => Promise<Result<string, SignError>>);
        };
        resolveDid: ((did) => Promise<Result<DidServiceInfoResponse, DidResolutionError>>);
        wellKnownDidConfiguration: {
            validate: ((domain, did) => Promise<boolean>);
            validateMultipleDids: ((domain, dids) => Promise<ReadonlyArray<DidConfigurationValidateResult>>);
        };
    };
    ecosystem: Omit<EcosystemService, "initialise">;
    isOpen: (() => boolean);
    linkedData: {
        cborld: {
            decode: ((byteArray) => ResultAsync<unknown, InvalidCborldDecodeError>);
            encode: ((jsonldDocument) => ResultAsync<Uint8Array, InvalidCborldEncodeError>);
        };
    };
    oidc: {
        discover: ((issuerUri) => Promise<Result<DiscoverResult, InvalidIssuerUriError | InvalidOpenIdConfigurationError>>);
        generateAuthorizeUrl: ((options) => Promise<Result<GenerateAuthorizeResult, InvalidDidError | SignError>>);
        retrieveCredential: ((options) => Promise<Result<RetrieveCredentialResult, RetrieveCredentialError | InvalidIdTokenError | CredentialNotFoundInTokenError>>);
    };
    openid: {
        issuance: {
            discover: ((uri) => Promise<Result<OpenidIssuanceDiscoverResult, BaseError<DiscoverErrorType>>>);
            generateAuthorizeUrl: ((options) => Promise<Result<OpenidIssuanceGenerateAuthorizeResult, BaseError<GenerateAuthorizeUrlErrorType>>>);
            retrieveCredentials: ((options) => Promise<OpenidIssuanceRetrieveCredentialsResult>);
            retrieveToken: ((options) => Promise<Result<OpenidIssuanceRetrieveTokenResult, BaseError<RetrieveTokenErrorType>>>);
        };
    };
}

An instance of a wallet

Type declaration

Settings

Member Visibility

Theme

Generated using TypeDoc