@sphereon/ssi-sdk.oid4vci-holder 0.33.1-next.3 → 0.33.1-next.68

package/dist/index.d.ts

@@ -1,12 +1,786 @@
+import { AuthorizationChallengeCodeResponse, EndpointMetadataResult, CredentialOfferRequestWithBaseUrl, AuthzFlowType, AuthorizationRequestOpts, AuthorizationServerClientOpts, CredentialConfigurationSupported, ExperimentalSubjectIssuance, CredentialResponse, AuthorizationResponse, CredentialsSupportedDisplay, IssuerCredentialSubject, MetadataDisplay, NotificationRequest, Jwt } from '@sphereon/oid4vci-common';
+import { IIdentifierResolution, ManagedIdentifierMethod, ManagedIdentifierOptsOrResult, ManagedIdentifierResult } from '@sphereon/ssi-sdk-ext.identifier-resolution';
+import { IJwtService } from '@sphereon/ssi-sdk-ext.jwt-service';
+import { IIdentifier, IPluginMethodMap, IAgentContext, ICredentialVerifier, ICredentialIssuer, IDIDManager, IResolver, IKeyManager, TKeyType, VerificationPolicies, TAgent, IAgentPlugin } from '@veramo/core';
+import { OpenID4VCIClientState, OpenID4VCIClient } from '@sphereon/oid4vci-client';
+import { DynamicRegistrationClientMetadata } from '@sphereon/oid4vc-common';
+import { SupportedDidMethodEnum, CreateOrGetIdentifierOpts, IdentifierProviderOpts } from '@sphereon/ssi-sdk-ext.did-utils';
+import { IContactManager } from '@sphereon/ssi-sdk.contact-manager';
+import { UniqueDigitalCredential, ICredentialStore } from '@sphereon/ssi-sdk.credential-store';
+import { Party, DidAuthConfig, IIssuerLocaleBranding, IBasicIssuerLocaleBranding, IBasicCredentialLocaleBranding, Identity, DigitalCredential, IBasicCredentialClaim } from '@sphereon/ssi-sdk.data-store';
+import { IIssuanceBranding } from '@sphereon/ssi-sdk.issuance-branding';
+import { ImDLMdoc } from '@sphereon/ssi-sdk.mdl-mdoc';
+import { ISDJwtPlugin } from '@sphereon/ssi-sdk.sd-jwt';
+import { ICredentialValidation, SchemaValidation } from '@sphereon/ssi-sdk.credential-validation';
+import { IDidAuthSiopOpAuthenticator, CreateConfigResult } from '@sphereon/ssi-sdk.siopv2-oid4vp-op-auth';
+import { IVerifiableCredential, W3CVerifiableCredential, WrappedVerifiableCredential, WrappedVerifiablePresentation, JoseSignatureAlgorithm, JoseSignatureAlgorithmString, HasherSync, SdJwtTypeDisplayMetadata, SdJwtClaimMetadata, OriginalVerifiableCredential } from '@sphereon/ssi-types';
+import { Interpreter, State, StatesConfig, StateMachine, BaseActionObject, ServiceMap, ResolveTypegenMeta, TypegenDisabled } from 'xstate';
+import { RPRegistrationMetadataPayload, PresentationDefinitionWithLocation } from '@sphereon/did-auth-siop';
+import { LinkHandlerAdapter, DefaultLinkPriorities } from '@sphereon/ssi-sdk.core';
+import { IMachineStatePersistence, SerializableState } from '@sphereon/ssi-sdk.xstate-machine-persistence';
+
+declare enum FirstPartyMachineStateTypes {
+    sendAuthorizationChallengeRequest = "sendAuthorizationChallengeRequest",
+    sendAuthorizationResponse = "sendAuthorizationResponse",
+    selectCredentials = "selectCredentials",
+    createConfig = "createConfig",
+    getSiopRequest = "getSiopRequest",
+    error = "error",
+    done = "done",
+    aborted = "aborted",
+    declined = "declined"
+}
+declare enum FirstPartyMachineServices {
+    sendAuthorizationChallengeRequest = "sendAuthorizationChallengeRequest",
+    sendAuthorizationResponse = "sendAuthorizationResponse",
+    createConfig = "createConfig",
+    getSiopRequest = "getSiopRequest"
+}
+type FirstPartyMachineStates = Record<FirstPartyMachineStateTypes, {}>;
+type FirstPartyMachineContext = {
+    openID4VCIClientState: OpenID4VCIClientState;
+    selectedCredentials: Array<UniqueDigitalCredential>;
+    contact: Party;
+    authSession?: string;
+    presentationUri?: string;
+    identifier?: IIdentifier;
+    didAuthConfig?: Omit<DidAuthConfig, 'identifier'>;
+    authorizationRequestData?: SiopV2AuthorizationRequestData;
+    presentationDuringIssuanceSession?: string;
+    authorizationCodeResponse?: AuthorizationChallengeCodeResponse;
+    error?: ErrorDetails;
+};
+declare enum FirstPartyMachineEvents {
+    NEXT = "NEXT",
+    PREVIOUS = "PREVIOUS",
+    DECLINE = "DECLINE",
+    SET_SELECTED_CREDENTIALS = "SET_SELECTED_CREDENTIALS"
+}
+type FirstPartyNextEvent = {
+    type: FirstPartyMachineEvents.NEXT;
+};
+type FirstPartyPreviousEvent = {
+    type: FirstPartyMachineEvents.PREVIOUS;
+};
+type FirstPartyDeclineEvent = {
+    type: FirstPartyMachineEvents.DECLINE;
+};
+type FirstPartySelectCredentialsEvent = {
+    type: FirstPartyMachineEvents.SET_SELECTED_CREDENTIALS;
+    data: Array<UniqueDigitalCredential>;
+};
+type FirstPartyMachineEventTypes = FirstPartyNextEvent | FirstPartyPreviousEvent | FirstPartyDeclineEvent | FirstPartySelectCredentialsEvent;
+type FirstPartyMachineStatesConfig = StatesConfig<FirstPartyMachineContext, {
+    states: FirstPartyMachineStates;
+}, FirstPartyMachineEventTypes, any>;
+type CreateFirstPartyMachineOpts = {
+    openID4VCIClientState: OpenID4VCIClientState;
+    contact: Party;
+    agentContext: RequiredContext;
+    machineId?: string;
+};
+type FirstPartyStateMachine = StateMachine<FirstPartyMachineContext, any, FirstPartyMachineEventTypes, {
+    value: any;
+    context: FirstPartyMachineContext;
+}, BaseActionObject, ServiceMap, ResolveTypegenMeta<TypegenDisabled, FirstPartyMachineEventTypes, BaseActionObject, ServiceMap>>;
+type FirstPartyMachineInterpreter = Interpreter<FirstPartyMachineContext, any, FirstPartyMachineEventTypes, {
+    value: any;
+    context: FirstPartyMachineContext;
+}, any>;
+type FirstPartyMachineStateNavigationListener = (firstPartyMachine: FirstPartyMachineInterpreter, state: FirstPartyMachineState, navigation?: any) => Promise<void>;
+type InstanceFirstPartyMachineOpts = {
+    services?: any;
+    guards?: any;
+    subscription?: () => void;
+    requireCustomNavigationHook?: boolean;
+    stateNavigationListener?: FirstPartyMachineStateNavigationListener;
+} & CreateFirstPartyMachineOpts;
+type FirstPartyMachineState = State<FirstPartyMachineContext, FirstPartyMachineEventTypes, any, {
+    value: any;
+    context: FirstPartyMachineContext;
+}, any>;
+type FirstPartyMachineServiceDefinitions = Record<keyof typeof FirstPartyMachineServices, (...args: Array<any>) => any>;
+type SendAuthorizationChallengeRequestArgs = Pick<FirstPartyMachineContext, 'openID4VCIClientState' | 'authSession' | 'presentationDuringIssuanceSession'>;
+type SendAuthorizationResponseArgs = Pick<FirstPartyMachineContext, 'authSession' | 'presentationUri' | 'didAuthConfig' | 'authorizationRequestData' | 'selectedCredentials'>;
+type CreateConfigArgs = Pick<FirstPartyMachineContext, 'presentationUri' | 'identifier'>;
+type GetSiopRequestArgs = Pick<FirstPartyMachineContext, 'didAuthConfig' | 'presentationUri'>;
+type SiopV2AuthorizationRequestData = {
+    correlationId: string;
+    registrationMetadataPayload: RPRegistrationMetadataPayload;
+    issuer?: string;
+    name?: string;
+    uri?: URL;
+    clientIdScheme?: string;
+    clientId?: string;
+    entityId?: string;
+    presentationDefinitions?: PresentationDefinitionWithLocation[];
+};
+type FirstPartyMachineNavigationArgs = {
+    firstPartyMachine: FirstPartyMachineInterpreter;
+    state: FirstPartyMachineState;
+    navigation: any;
+    onNext?: () => void;
+    onBack?: () => void;
+};
+
+interface IOID4VCIHolder extends IPluginMethodMap {
+    oid4vciHolderGetIssuerMetadata(args: GetIssuerMetadataArgs, context: RequiredContext): Promise<EndpointMetadataResult>;
+    oid4vciHolderGetMachineInterpreter(args: GetMachineArgs, context: RequiredContext): Promise<OID4VCIMachine>;
+    oid4vciHolderStart(args: PrepareStartArgs, context: RequiredContext): Promise<StartResult>;
+    oid4vciHolderCreateCredentialsToSelectFrom(args: CreateCredentialsToSelectFromArgs, context: RequiredContext): Promise<Array<CredentialToSelectFromResult>>;
+    oid4vciHolderGetContact(args: GetContactArgs, context: RequiredContext): Promise<Party | undefined>;
+    oid4vciHolderGetCredentials(args: GetCredentialsArgs, context: RequiredContext): Promise<Array<MappedCredentialToAccept>>;
+    oid4vciHolderGetCredential(args: GetCredentialArgs, context: RequiredContext): Promise<MappedCredentialToAccept>;
+    oid4vciHolderAddContactIdentity(args: AddContactIdentityArgs, context: RequiredContext): Promise<Identity>;
+    oid4vciHolderAssertValidCredentials(args: AssertValidCredentialsArgs, context: RequiredContext): Promise<Array<VerificationResult>>;
+    oid4vciHolderGetIssuerBranding(args: GetIssuerBrandingArgs, context: RequiredContext): Promise<Array<IIssuerLocaleBranding | IBasicIssuerLocaleBranding>>;
+    oid4vciHolderStoreIssuerBranding(args: StoreIssuerBrandingArgs, context: RequiredContext): Promise<void>;
+    oid4vciHolderStoreCredentialBranding(args: StoreCredentialBrandingArgs, context: RequiredContext): Promise<void>;
+    oid4vciHolderStoreCredentials(args: StoreCredentialsArgs, context: RequiredContext): Promise<void>;
+}
+type OID4VCIHolderOptions = {
+    onContactIdentityCreated?: (args: OnContactIdentityCreatedArgs) => Promise<void>;
+    onCredentialStored?: (args: OnCredentialStoredArgs) => Promise<void>;
+    onIdentifierCreated?: (args: OnIdentifierCreatedArgs) => Promise<void>;
+    onVerifyEBSICredentialIssuer?: (args: VerifyEBSICredentialIssuerArgs) => Promise<VerifyEBSICredentialIssuerResult>;
+    vcFormatPreferences?: Array<string>;
+    jsonldCryptographicSuitePreferences?: Array<string>;
+    defaultAuthorizationRequestOptions?: AuthorizationRequestOpts;
+    didMethodPreferences?: Array<SupportedDidMethodEnum>;
+    jwtCryptographicSuitePreferences?: Array<JoseSignatureAlgorithm | JoseSignatureAlgorithmString>;
+    hasher?: HasherSync;
+};
+type OnContactIdentityCreatedArgs = {
+    contactId: string;
+    identity: Identity;
+};
+type GetIssuerMetadataArgs = {
+    issuer: string;
+    errorOnNotFound?: boolean;
+};
+type OnCredentialStoredArgs = {
+    credential: DigitalCredential;
+    vcHash: string;
+};
+type OnIdentifierCreatedArgs = {
+    identifier: ManagedIdentifierResult;
+};
+type GetMachineArgs = {
+    requestData: RequestData;
+    trustAnchors?: Array<string>;
+    authorizationRequestOpts?: AuthorizationRequestOpts;
+    clientOpts?: AuthorizationServerClientOpts;
+    didMethodPreferences?: Array<SupportedDidMethodEnum>;
+    issuanceOpt?: Partial<IssuanceOpts>;
+    stateNavigationListener?: OID4VCIMachineStateNavigationListener;
+    firstPartyStateNavigationListener?: FirstPartyMachineStateNavigationListener;
+};
+type PrepareStartArgs = Pick<OID4VCIMachineContext, 'requestData' | 'authorizationRequestOpts' | 'didMethodPreferences' | 'issuanceOpt' | 'accessTokenOpts'>;
+type CreateCredentialsToSelectFromArgs = Pick<OID4VCIMachineContext, 'credentialsSupported' | 'credentialBranding' | 'selectedCredentials' | 'locale' | 'openID4VCIClientState'>;
+type GetContactArgs = Pick<OID4VCIMachineContext, 'serverMetadata'>;
+type GetCredentialsArgs = Pick<OID4VCIMachineContext, 'verificationCode' | 'openID4VCIClientState' | 'selectedCredentials' | 'didMethodPreferences' | 'issuanceOpt' | 'accessTokenOpts'>;
+type AddContactIdentityArgs = Pick<OID4VCIMachineContext, 'credentialsToAccept' | 'contact'>;
+type GetIssuerBrandingArgs = Pick<OID4VCIMachineContext, 'serverMetadata' | 'contact'>;
+type StoreIssuerBrandingArgs = Pick<OID4VCIMachineContext, 'issuerBranding' | 'contact'>;
+type AssertValidCredentialsArgs = Pick<OID4VCIMachineContext, 'credentialsToAccept' | 'issuanceOpt'>;
+type StoreCredentialBrandingArgs = Pick<OID4VCIMachineContext, 'serverMetadata' | 'credentialBranding' | 'selectedCredentials' | 'credentialsToAccept'>;
+type StoreCredentialsArgs = Pick<OID4VCIMachineContext, 'credentialsToAccept' | 'serverMetadata' | 'credentialsSupported' | 'openID4VCIClientState' | 'selectedCredentials' | 'issuanceOpt'>;
+type SendNotificationArgs = Pick<OID4VCIMachineContext, 'credentialsToAccept' | 'serverMetadata' | 'credentialsSupported' | 'openID4VCIClientState'> & {
+    notificationRequest?: NotificationRequest;
+    stored: boolean;
+};
+type GetFederationTrustArgs = Pick<OID4VCIMachineContext, 'requestData' | 'trustAnchors' | 'serverMetadata'>;
+type StartFirstPartApplicationMachine = Pick<OID4VCIMachineContext, 'openID4VCIClientState' | 'contact'> & {
+    stateNavigationListener?: FirstPartyMachineStateNavigationListener;
+};
+declare enum OID4VCIHolderEvent {
+    CONTACT_IDENTITY_CREATED = "contact_identity_created",
+    CREDENTIAL_STORED = "credential_stored",
+    IDENTIFIER_CREATED = "identifier_created"
+}
+type RequestData = {
+    credentialOffer?: CredentialOfferRequestWithBaseUrl;
+    code?: string;
+    uri: string;
+    existingClientState?: string;
+    createAuthorizationRequestURL?: boolean;
+    flowType?: AuthzFlowType;
+    [x: string]: any;
+};
+declare enum SupportedLanguage {
+    ENGLISH = "en",
+    DUTCH = "nl"
+}
+type VerifyCredentialToAcceptArgs = {
+    mappedCredential: MappedCredentialToAccept;
+    onVerifyEBSICredentialIssuer?: (args: VerifyEBSICredentialIssuerArgs) => Promise<VerifyEBSICredentialIssuerResult>;
+    hasher?: HasherSync;
+    schemaValidation?: SchemaValidation;
+    context: RequiredContext;
+};
+type MappedCredentialToAccept = ExperimentalSubjectIssuance & {
+    correlationId: string;
+    types: string[];
+    credentialToAccept: CredentialToAccept;
+    uniformVerifiableCredential: IVerifiableCredential;
+    rawVerifiableCredential: W3CVerifiableCredential;
+};
+type OID4VCIMachineContext = {
+    authorizationRequestOpts?: AuthorizationRequestOpts;
+    accessTokenOpts?: AccessTokenOpts;
+    didMethodPreferences?: Array<SupportedDidMethodEnum>;
+    issuanceOpt?: IssuanceOpts;
+    trustAnchors: Array<string>;
+    requestData?: RequestData;
+    locale?: string;
+    authorizationCodeURL?: string;
+    issuerBranding?: Array<IIssuerLocaleBranding | IBasicIssuerLocaleBranding>;
+    credentialBranding?: Record<string, Array<IBasicCredentialLocaleBranding>>;
+    credentialsSupported: Record<string, CredentialConfigurationSupported>;
+    serverMetadata?: EndpointMetadataResult;
+    openID4VCIClientState?: OpenID4VCIClientState;
+    credentialToSelectFrom: Array<CredentialToSelectFromResult>;
+    contactAlias: string;
+    contact?: Party;
+    selectedCredentials: Array<string>;
+    credentialsToAccept: Array<MappedCredentialToAccept>;
+    verificationCode?: string;
+    hasContactConsent: boolean;
+    trustedAnchors?: Array<string>;
+    error?: ErrorDetails;
+};
+declare enum OID4VCIMachineStates {
+    start = "start",
+    createCredentialsToSelectFrom = "createCredentialsToSelectFrom",
+    getContact = "getContact",
+    transitionFromSetup = "transitionFromSetup",
+    getFederationTrust = "getFederationTrust",
+    reviewContact = "reviewContact",
+    addContact = "addContact",
+    getIssuerBranding = "getIssuerBranding",
+    storeIssuerBranding = "storeIssuerBranding",
+    addIssuerBrandingAfterIdentity = "addIssuerBrandingAfterIdentity",
+    transitionFromContactSetup = "transitionFromContactSetup",
+    startFirstPartApplicationFlow = "startFirstPartApplicationFlow",
+    selectCredentials = "selectCredentials",
+    transitionFromSelectingCredentials = "transitionFromSelectingCredentials",
+    verifyPin = "verifyPin",
+    initiateAuthorizationRequest = "initiateAuthorizationRequest",
+    waitForAuthorizationResponse = "waitForAuthorizationResponse",
+    getCredentials = "getCredentials",
+    transitionFromWalletInput = "transitionFromWalletInput",
+    addContactIdentity = "addContactIdentity",
+    reviewCredentials = "reviewCredentials",
+    verifyCredentials = "verifyCredentials",
+    storeCredentialBranding = "storeCredentialBranding",
+    storeCredentials = "storeCredentials",
+    handleError = "handleError",
+    aborted = "aborted",
+    declined = "declined",
+    error = "error",
+    done = "done"
+}
+declare enum OID4VCIMachineAddContactStates {
+    idle = "idle",
+    next = "next"
+}
+declare enum OID4VCIMachineVerifyPinStates {
+    idle = "idle",
+    next = "next"
+}
+type OID4VCIMachineInterpreter = Interpreter<OID4VCIMachineContext, any, OID4VCIMachineEventTypes, {
+    value: any;
+    context: OID4VCIMachineContext;
+}, any>;
+type OID4VCIMachineState = State<OID4VCIMachineContext, OID4VCIMachineEventTypes, any, {
+    value: any;
+    context: OID4VCIMachineContext;
+}, any>;
+type OID4VCIStateMachine = StateMachine<OID4VCIMachineContext, any, OID4VCIMachineEventTypes, {
+    value: any;
+    context: OID4VCIMachineContext;
+}, BaseActionObject, ServiceMap, ResolveTypegenMeta<TypegenDisabled, OID4VCIMachineEventTypes, BaseActionObject, ServiceMap>>;
+type CreateOID4VCIMachineOpts = {
+    requestData: RequestData;
+    machineName?: string;
+    locale?: string;
+    trustAnchors?: Array<string>;
+    stateDefinition?: OID4VCIMachineState;
+    didMethodPreferences?: Array<SupportedDidMethodEnum>;
+    accessTokenOpts?: AccessTokenOpts;
+    issuanceOpt?: IssuanceOpts;
+};
+type OID4VCIMachineStateNavigationListener = (oid4vciMachine: OID4VCIMachineInterpreter, state: OID4VCIMachineState, navigation?: any) => Promise<void>;
+type OID4VCIMachineInstanceOpts = {
+    services?: any;
+    guards?: any;
+    subscription?: () => void;
+    requireCustomNavigationHook?: boolean;
+    authorizationRequestOpts?: AuthorizationRequestOpts;
+    didMethodPreferences?: Array<SupportedDidMethodEnum>;
+    issuanceOpt?: IssuanceOpts;
+    stateNavigationListener?: OID4VCIMachineStateNavigationListener;
+    firstPartyStateNavigationListener?: FirstPartyMachineStateNavigationListener;
+} & CreateOID4VCIMachineOpts;
+type OID4VCIProviderProps = {
+    children?: any;
+    customOID4VCIInstance?: OID4VCIMachineInterpreter;
+};
+type OID4VCIContext = {
+    oid4vciInstance?: OID4VCIMachineInterpreter;
+};
+type OID4VCIMachineNavigationArgs = {
+    oid4vciMachine: OID4VCIMachineInterpreter;
+    state: OID4VCIMachineState;
+    navigation: any;
+    onNext?: () => void;
+    onBack?: () => void;
+};
+declare enum OID4VCIMachineEvents {
+    NEXT = "NEXT",
+    PREVIOUS = "PREVIOUS",
+    DECLINE = "DECLINE",
+    CREATE_CONTACT = "CREATE_CONTACT",
+    SET_VERIFICATION_CODE = "SET_VERIFICATION_CODE",
+    SET_CONTACT_ALIAS = "SET_CONTACT_ALIAS",
+    SET_CONTACT_CONSENT = "SET_CONTACT_CONSENT",
+    SET_SELECTED_CREDENTIALS = "SET_SELECTED_CREDENTIALS",
+    SET_AUTHORIZATION_CODE_URL = "SET_AUTHORIZATION_CODE_URL",
+    INVOKED_AUTHORIZATION_CODE_REQUEST = "INVOKED_AUTHORIZATION_CODE_REQUEST",
+    PROVIDE_AUTHORIZATION_CODE_RESPONSE = "PROVIDE_AUTHORIZATION_CODE_RESPONSE"
+}
+declare enum OID4VCIMachineGuards {
+    hasContactGuard = "oid4vciHasContactGuard",
+    hasNoContactGuard = "oid4vciHasNoContactGuard",
+    credentialsToSelectRequiredGuard = "oid4vciCredentialsToSelectRequiredGuard",
+    requirePinGuard = "oid4vciRequirePinGuard",
+    requireAuthorizationGuard = "oid4vciRequireAuthorizationGuard",
+    noAuthorizationGuard = "oid4vciNoAuthorizationGuard",
+    hasAuthorizationResponse = "oid4vciHasAuthorizationResponse",
+    hasNoContactIdentityGuard = "oid4vciHasNoContactIdentityGuard",
+    verificationCodeGuard = "oid4vciVerificationCodeGuard",
+    createContactGuard = "oid4vciCreateContactGuard",
+    hasSelectedCredentialsGuard = "oid4vciHasSelectedCredentialsGuard",
+    isOIDFOriginGuard = "oid4vciIsOIDFOriginGuard",
+    contactHasLowTrustGuard = "oid4vciContactHasLowTrustGuard",
+    isFirstPartyApplication = "oid4vciIsFirstPartyApplication"
+}
+declare enum OID4VCIMachineServices {
+    start = "start",
+    getContact = "getContact",
+    getFederationTrust = "getFederationTrust",
+    addContactIdentity = "addContactIdentity",
+    createCredentialsToSelectFrom = "createCredentialsToSelectFrom",
+    getIssuerBranding = "getIssuerBranding",
+    storeIssuerBranding = "storeIssuerBranding",
+    getCredentials = "getCredentials",
+    assertValidCredentials = "assertValidCredentials",
+    storeCredentialBranding = "storeCredentialBranding",
+    sendNotification = "sendNotification",
+    storeCredentials = "storeCredentials",
+    startFirstPartApplicationFlow = "startFirstPartApplicationFlow"
+}
+type OID4VCIMachineServiceDefinitions = Record<keyof typeof OID4VCIMachineServices, (...args: Array<any>) => any>;
+type NextEvent = {
+    type: OID4VCIMachineEvents.NEXT;
+};
+type PreviousEvent = {
+    type: OID4VCIMachineEvents.PREVIOUS;
+};
+type DeclineEvent = {
+    type: OID4VCIMachineEvents.DECLINE;
+};
+type CreateContactEvent = {
+    type: OID4VCIMachineEvents.CREATE_CONTACT;
+    data: Party;
+};
+type SelectCredentialsEvent = {
+    type: OID4VCIMachineEvents.SET_SELECTED_CREDENTIALS;
+    data: Array<string>;
+};
+type VerificationCodeEvent = {
+    type: OID4VCIMachineEvents.SET_VERIFICATION_CODE;
+    data: string;
+};
+type ContactConsentEvent = {
+    type: OID4VCIMachineEvents.SET_CONTACT_CONSENT;
+    data: boolean;
+};
+type ContactAliasEvent = {
+    type: OID4VCIMachineEvents.SET_CONTACT_ALIAS;
+    data: string;
+};
+type SetAuthorizationCodeURLEvent = {
+    type: OID4VCIMachineEvents.SET_AUTHORIZATION_CODE_URL;
+    data: string;
+};
+type InvokeAuthorizationRequestEvent = {
+    type: OID4VCIMachineEvents.INVOKED_AUTHORIZATION_CODE_REQUEST;
+    data: string;
+};
+type AuthorizationResponseEvent = {
+    type: OID4VCIMachineEvents.PROVIDE_AUTHORIZATION_CODE_RESPONSE;
+    data: string | AuthorizationResponse;
+};
+type OID4VCIMachineEventTypes = NextEvent | PreviousEvent | DeclineEvent | CreateContactEvent | SelectCredentialsEvent | VerificationCodeEvent | ContactConsentEvent | ContactAliasEvent | SetAuthorizationCodeURLEvent | InvokeAuthorizationRequestEvent | AuthorizationResponseEvent;
+type ErrorDetails = {
+    title: string;
+    message: string;
+    detailsTitle?: string;
+    detailsMessage?: string;
+    stack?: string;
+};
+declare enum RequestType {
+    OPENID_INITIATE_ISSUANCE = "openid-initiate-issuance",
+    OPENID_CREDENTIAL_OFFER = "openid-credential-offer",
+    URL = "URL"
+}
+type CredentialToSelectFromResult = ExperimentalSubjectIssuance & {
+    id: string;
+    credentialId: string;
+    credentialTypes: Array<string>;
+    credentialAlias: string;
+    isSelected: boolean;
+};
+type OID4VCIMachine = {
+    interpreter: OID4VCIMachineInterpreter;
+};
+type StartResult = {
+    authorizationCodeURL?: string;
+    credentialBranding?: Record<string, Array<IBasicCredentialLocaleBranding>>;
+    credentialsSupported: Record<string, CredentialConfigurationSupported>;
+    serverMetadata: EndpointMetadataResult;
+    oid4vciClientState: OpenID4VCIClientState;
+};
+type SelectAppLocaleBrandingArgs = {
+    locale?: string;
+    localeBranding?: Array<IBasicCredentialLocaleBranding | IBasicIssuerLocaleBranding>;
+};
+type IssuanceOpts = CredentialConfigurationSupported & {
+    credentialConfigurationId?: string;
+    supportedBindingMethods: ManagedIdentifierMethod[];
+    supportedPreferredDidMethod?: SupportedDidMethodEnum;
+    schemaValidation?: SchemaValidation;
+    identifier?: ManagedIdentifierOptsOrResult;
+    keyType?: TKeyType;
+    codecName?: string;
+    kms?: string;
+};
+type VerificationResult = {
+    result: boolean;
+    source: WrappedVerifiableCredential | WrappedVerifiablePresentation;
+    subResults: Array<VerificationSubResult>;
+    error?: string | undefined;
+    errorDetails?: string;
+};
+type VerificationSubResult = {
+    result: boolean;
+    error?: string;
+    errorDetails?: string;
+};
+type CredentialToAccept = {
+    id?: string;
+    types: string[];
+    issuanceOpt: IssuanceOpts;
+    credentialResponse: CredentialResponse;
+};
+type GetCredentialConfigsSupportedArgs = {
+    client: OpenID4VCIClient;
+    vcFormatPreferences: Array<string>;
+    format?: Array<string>;
+    types?: Array<Array<string>>;
+    configurationIds?: Array<string>;
+};
 /**
- * @public
- */
-export { OID4VCIHolder, oid4vciHolderContextMethods, signCallback } from './agent/OID4VCIHolder';
-export * from './mappers/OIDC4VCIBrandingMapper';
-export * from './services/OID4VCIHolderService';
-export * from './services/FirstPartyMachineServices';
-export * from './types/IOID4VCIHolder';
-export * from './types/FirstPartyMachine';
-export * from './listeners/headlessStateNavListener';
-export * from './link-handler';
-//# sourceMappingURL=index.d.ts.map
+ * Please note that this method is restricting the results to one set of types or configurationId.
+ * It can potentially return multiple results mainly because of different formats.
+ */
+type GetCredentialConfigsSupportedBySingleTypeOrIdArgs = {
+    client: OpenID4VCIClient;
+    vcFormatPreferences: Array<string>;
+    format?: string[];
+    types?: string[];
+    configurationId?: string;
+};
+type GetCredentialBrandingArgs = {
+    credentialsSupported: Record<string, CredentialConfigurationSupported>;
+    context: RequiredContext;
+};
+type GetBasicIssuerLocaleBrandingArgs = {
+    display: MetadataDisplay[];
+    dynamicRegistrationClientMetadata?: DynamicRegistrationClientMetadataDisplay;
+    context: RequiredContext;
+};
+type GetPreferredCredentialFormatsArgs = {
+    credentials: Record<string, CredentialConfigurationSupported>;
+    vcFormatPreferences: Array<string>;
+};
+type MapCredentialToAcceptArgs = {
+    credentialToAccept: CredentialToAccept;
+    hasher?: HasherSync;
+};
+type GetDefaultIssuanceOptsArgs = {
+    credentialSupported: CredentialConfigurationSupported;
+    opts: DefaultIssuanceOpts;
+    context: RequiredContext;
+};
+type DefaultIssuanceOpts = {
+    client: OpenID4VCIClient;
+};
+type GetIdentifierArgs = {
+    issuanceOpt: IssuanceOpts;
+    context: RequiredContext;
+};
+type GetAuthenticationKeyArgs = {
+    identifier: ManagedIdentifierOptsOrResult;
+    offlineWhenNoDIDRegistered?: boolean;
+    noVerificationMethodFallback?: boolean;
+    context: IAgentContext<IResolver & IDIDManager & IKeyManager>;
+};
+type GetOrCreatePrimaryIdentifierArgs = {
+    context: RequiredContext;
+    opts?: CreateOrGetIdentifierOpts;
+};
+type CreateIdentifierArgs = {
+    context: RequiredContext;
+    opts?: CreateIdentifierOpts;
+};
+type CreateIdentifierOpts = {
+    method: SupportedDidMethodEnum;
+    createOpts?: CreateIdentifierCreateOpts;
+};
+type CreateIdentifierCreateOpts = {
+    kms?: string;
+    alias?: string;
+    options?: IdentifierProviderOpts;
+};
+type GetIssuanceOptsArgs = {
+    client: OpenID4VCIClient;
+    credentialsSupported: Record<string, CredentialConfigurationSupported>;
+    serverMetadata: EndpointMetadataResult;
+    context: RequiredContext;
+    didMethodPreferences: Array<SupportedDidMethodEnum>;
+    jwtCryptographicSuitePreferences: Array<JoseSignatureAlgorithm | JoseSignatureAlgorithmString>;
+    jsonldCryptographicSuitePreferences: Array<string>;
+    forceIssuanceOpt?: IssuanceOpts;
+};
+type GetIssuanceDidMethodArgs = {
+    credentialSupported: CredentialConfigurationSupported;
+    client: OpenID4VCIClient;
+    didMethodPreferences: Array<SupportedDidMethodEnum>;
+};
+type GetIssuanceCryptoSuiteArgs = {
+    credentialSupported: CredentialConfigurationSupported;
+    client: OpenID4VCIClient;
+    jwtCryptographicSuitePreferences: Array<JoseSignatureAlgorithm | JoseSignatureAlgorithmString>;
+    jsonldCryptographicSuitePreferences: Array<string>;
+};
+type GetCredentialArgs = {
+    pin?: string;
+    issuanceOpt: IssuanceOpts;
+    client: OpenID4VCIClient;
+    accessTokenOpts?: AccessTokenOpts;
+};
+type AccessTokenOpts = {
+    additionalRequestParams?: Record<string, any>;
+    clientOpts?: AuthorizationServerClientOpts;
+};
+declare enum IdentifierAliasEnum {
+    PRIMARY = "primary"
+}
+type CredentialVerificationError = {
+    error?: string;
+    errorDetails?: string;
+};
+type VerifyMdocArgs = {
+    credential: string;
+};
+type VerifySDJWTCredentialArgs = {
+    credential: string;
+    hasher?: HasherSync;
+};
+interface VerifyCredentialArgs {
+    credential: OriginalVerifiableCredential;
+    fetchRemoteContexts?: boolean;
+    policies?: VerificationPolicies;
+    [x: string]: any;
+}
+type IssuerType = 'RootTAO' | 'TAO' | 'TI' | 'Revoked or Undefined';
+type VerifyEBSICredentialIssuerArgs = {
+    wrappedVc: WrappedVerifiableCredential;
+    issuerType?: IssuerType[];
+};
+type Attribute = {
+    hash: string;
+    body: string;
+    issuerType: IssuerType;
+    tao: string;
+    rootTao: string;
+};
+type VerifyEBSICredentialIssuerResult = {
+    did: string;
+    attributes: Attribute[];
+};
+type Oid4vciCredentialLocaleBrandingFromArgs = {
+    credentialDisplay: CredentialsSupportedDisplay;
+};
+type SdJwtCredentialLocaleBrandingFromArgs = {
+    credentialDisplay: SdJwtTypeDisplayMetadata;
+};
+type SdJwtGetCredentialBrandingFromArgs = {
+    credentialDisplay?: Array<SdJwtTypeDisplayMetadata>;
+    claimsMetadata?: Array<SdJwtClaimMetadata>;
+};
+type SdJwtCredentialClaimLocalesFromArgs = {
+    claimsMetadata: Array<SdJwtClaimMetadata>;
+};
+type IssuerLocaleBrandingFromArgs = {
+    issuerDisplay: MetadataDisplay;
+    dynamicRegistrationClientMetadata?: DynamicRegistrationClientMetadataDisplay;
+};
+type Oid4vciGetCredentialBrandingFromArgs = {
+    credentialDisplay?: Array<CredentialsSupportedDisplay>;
+    issuerCredentialSubject?: IssuerCredentialSubject;
+};
+type Oid4vciCredentialDisplayLocalesFromArgs = {
+    credentialDisplay: Array<CredentialsSupportedDisplay>;
+};
+type SdJwtCredentialDisplayLocalesFromArgs = {
+    credentialDisplay: Array<SdJwtTypeDisplayMetadata>;
+};
+type Oid4vciIssuerCredentialSubjectLocalesFromArgs = {
+    issuerCredentialSubject: IssuerCredentialSubject;
+};
+type Oid4vciCombineDisplayLocalesFromArgs = {
+    credentialDisplayLocales?: Map<string, CredentialsSupportedDisplay>;
+    issuerCredentialSubjectLocales?: Map<string, Array<IBasicCredentialClaim>>;
+};
+type SdJwtCombineDisplayLocalesFromArgs = {
+    credentialDisplayLocales?: Map<string, SdJwtTypeDisplayMetadata>;
+    claimsMetadata?: Map<string, Array<IBasicCredentialClaim>>;
+};
+type DynamicRegistrationClientMetadataDisplay = Pick<DynamicRegistrationClientMetadata, 'client_name' | 'client_uri' | 'contacts' | 'tos_uri' | 'policy_uri' | 'logo_uri'>;
+type DidAgents = TAgent<IResolver & IDIDManager>;
+type RequiredContext = IAgentContext<IIssuanceBranding & IContactManager & ICredentialValidation & ICredentialVerifier & ICredentialIssuer & ICredentialStore & IIdentifierResolution & IJwtService & IDIDManager & IResolver & IKeyManager & ISDJwtPlugin & ImDLMdoc & IDidAuthSiopOpAuthenticator>;
+
+/**
+ * {@inheritDoc IOID4VCIHolder}
+ */
+declare const oid4vciHolderContextMethods: Array<string>;
+declare function signCallback(identifier: ManagedIdentifierOptsOrResult, context: IAgentContext<IKeyManager & IDIDManager & IResolver & IIdentifierResolution & IJwtService>, nonce?: string): (jwt: Jwt, kid?: string) => Promise<string>;
+declare class OID4VCIHolder implements IAgentPlugin {
+    private readonly hasher?;
+    readonly eventTypes: Array<OID4VCIHolderEvent>;
+    readonly methods: IOID4VCIHolder;
+    private readonly vcFormatPreferences;
+    private readonly jsonldCryptographicSuitePreferences;
+    private readonly didMethodPreferences;
+    private readonly jwtCryptographicSuitePreferences;
+    private static readonly DEFAULT_MOBILE_REDIRECT_URI;
+    private readonly defaultAuthorizationRequestOpts;
+    private readonly onContactIdentityCreated?;
+    private readonly onCredentialStored?;
+    private readonly onIdentifierCreated?;
+    private readonly onVerifyEBSICredentialIssuer?;
+    constructor(options?: OID4VCIHolderOptions);
+    onEvent(event: any, context: RequiredContext): Promise<void>;
+    /**
+     * FIXME: This method can only be used locally. Creating the interpreter should be local to where the agent is running
+     */
+    private oid4vciHolderGetMachineInterpreter;
+    /**
+     * This method is run before the machine starts! So there is no concept of the state machine context or states yet
+     *
+     * The result of this method can be directly passed into the start method of the state machine
+     * @param args
+     * @param context
+     * @private
+     */
+    private oid4vciHolderStart;
+    private oid4vciHolderCreateCredentialsToSelectFrom;
+    private oid4vciHolderGetContact;
+    private oid4vciHolderGetCredentials;
+    private oid4vciHolderGetCredential;
+    private oid4vciHolderAddContactIdentity;
+    private oid4vciHolderGetIssuerBranding;
+    private oid4vciHolderStoreIssuerBranding;
+    private oid4vciHolderAssertValidCredentials;
+    private oid4vciHolderStoreCredentialBranding;
+    private oid4vciHolderStoreCredentials;
+    private oid4vciHolderSendNotification;
+    private getFederationTrust;
+    private oid4vciHolderGetIssuerMetadata;
+    private determineSubjectCorrelation;
+    private idFromW3cCredentialSubject;
+    private getCredentialDefinition;
+}
+
+declare const oid4vciGetCredentialBrandingFrom: (args: Oid4vciGetCredentialBrandingFromArgs) => Promise<Array<IBasicCredentialLocaleBranding>>;
+declare const oid4vciCredentialDisplayLocalesFrom: (args: Oid4vciCredentialDisplayLocalesFromArgs) => Promise<Map<string, CredentialsSupportedDisplay>>;
+declare const oid4vciIssuerCredentialSubjectLocalesFrom: (args: Oid4vciIssuerCredentialSubjectLocalesFromArgs) => Promise<Map<string, Array<IBasicCredentialClaim>>>;
+declare const oid4vciCredentialLocaleBrandingFrom: (args: Oid4vciCredentialLocaleBrandingFromArgs) => Promise<IBasicCredentialLocaleBranding>;
+declare const oid4vciCombineDisplayLocalesFrom: (args: Oid4vciCombineDisplayLocalesFromArgs) => Promise<Array<IBasicCredentialLocaleBranding>>;
+declare const sdJwtGetCredentialBrandingFrom: (args: SdJwtGetCredentialBrandingFromArgs) => Promise<Array<IBasicCredentialLocaleBranding>>;
+declare const sdJwtCredentialDisplayLocalesFrom: (args: SdJwtCredentialDisplayLocalesFromArgs) => Promise<Map<string, SdJwtTypeDisplayMetadata>>;
+declare const sdJwtCredentialClaimLocalesFrom: (args: SdJwtCredentialClaimLocalesFromArgs) => Promise<Map<string, Array<IBasicCredentialClaim>>>;
+declare const sdJwtCredentialLocaleBrandingFrom: (args: SdJwtCredentialLocaleBrandingFromArgs) => Promise<IBasicCredentialLocaleBranding>;
+declare const sdJwtCombineDisplayLocalesFrom: (args: SdJwtCombineDisplayLocalesFromArgs) => Promise<Array<IBasicCredentialLocaleBranding>>;
+declare const issuerLocaleBrandingFrom: (args: IssuerLocaleBrandingFromArgs) => Promise<IBasicIssuerLocaleBranding>;
+
+declare const getCredentialBranding: (args: GetCredentialBrandingArgs) => Promise<Record<string, Array<IBasicCredentialLocaleBranding>>>;
+declare const getBasicIssuerLocaleBranding: (args: GetBasicIssuerLocaleBrandingArgs) => Promise<Array<IBasicIssuerLocaleBranding>>;
+declare const getCredentialConfigsBasedOnFormatPref: (args: GetPreferredCredentialFormatsArgs) => Promise<Record<string, CredentialConfigurationSupported>>;
+declare const selectCredentialLocaleBranding: (args: SelectAppLocaleBrandingArgs) => Promise<IBasicCredentialLocaleBranding | IBasicIssuerLocaleBranding | undefined>;
+declare const verifyCredentialToAccept: (args: VerifyCredentialToAcceptArgs) => Promise<VerificationResult>;
+declare const mapCredentialToAccept: (args: MapCredentialToAcceptArgs) => Promise<MappedCredentialToAccept>;
+declare const getIdentifierOpts: (args: GetIdentifierArgs) => Promise<ManagedIdentifierResult>;
+declare const getCredentialConfigsSupportedMerged: (args: GetCredentialConfigsSupportedArgs) => Promise<Record<string, CredentialConfigurationSupported>>;
+declare const getCredentialConfigsSupported: (args: GetCredentialConfigsSupportedArgs) => Promise<Array<Record<string, CredentialConfigurationSupported>>>;
+/**
+ * Please note that this method only returns configs supported for a single set of credential types or a single config id.
+ * If an offer contains multiple formats/types in an array or multiple config ids, you will have to call this method for all of them
+ * @param args
+ */
+declare const getCredentialConfigsSupportedBySingleTypeOrId: (args: GetCredentialConfigsSupportedBySingleTypeOrIdArgs) => Promise<Record<string, CredentialConfigurationSupported>>;
+declare const getIssuanceOpts: (args: GetIssuanceOptsArgs) => Promise<Array<IssuanceOpts>>;
+declare const getIssuanceMethod: (opts: GetIssuanceDidMethodArgs) => Promise<{
+    methods: ManagedIdentifierMethod[];
+    didMethod?: SupportedDidMethodEnum;
+}>;
+declare const getIssuanceCryptoSuite: (opts: GetIssuanceCryptoSuiteArgs) => Promise<string>;
+declare const startFirstPartApplicationMachine: (args: StartFirstPartApplicationMachine, context: RequiredContext) => Promise<AuthorizationChallengeCodeResponse | string>;
+
+declare const sendAuthorizationChallengeRequest: (args: SendAuthorizationChallengeRequestArgs) => Promise<AuthorizationChallengeCodeResponse>;
+declare const createConfig: (args: CreateConfigArgs, context: RequiredContext) => Promise<CreateConfigResult>;
+declare const getSiopRequest: (args: GetSiopRequestArgs, context: RequiredContext) => Promise<SiopV2AuthorizationRequestData>;
+declare const sendAuthorizationResponse: (args: SendAuthorizationResponseArgs, context: RequiredContext) => Promise<string>;
+
+declare const OID4VCICallbackStateListener: (callbacks?: Map<OID4VCIMachineStates, (machine: OID4VCIMachineInterpreter, state: OID4VCIMachineState, opts?: any) => Promise<void>>) => (oid4vciMachine: OID4VCIMachineInterpreter, state: OID4VCIMachineState) => Promise<void>;
+
+/**
+ * This handler only handles credential offer links (either by value or by reference)
+ */
+declare class OID4VCIHolderLinkHandler extends LinkHandlerAdapter {
+    private readonly context;
+    private readonly stateNavigationListener?;
+    private readonly firstPartyStateNavigationListener?;
+    private readonly noStateMachinePersistence;
+    private readonly authorizationRequestOpts?;
+    private readonly clientOpts?;
+    private readonly trustAnchors?;
+    constructor(args: Pick<GetMachineArgs, 'stateNavigationListener' | 'authorizationRequestOpts' | 'clientOpts' | 'trustAnchors' | 'firstPartyStateNavigationListener'> & {
+        priority?: number | DefaultLinkPriorities;
+        protocols?: Array<string | RegExp>;
+        noStateMachinePersistence?: boolean;
+        context: IAgentContext<IOID4VCIHolder & IMachineStatePersistence>;
+    });
+    handle(url: string | URL, opts?: {
+        machineState?: SerializableState;
+        authorizationRequestOpts?: AuthorizationRequestOpts;
+        createAuthorizationRequestURL?: boolean;
+        clientOpts?: AuthorizationServerClientOpts;
+        flowType?: AuthzFlowType;
+    }): Promise<void>;
+}
+
+export { type AccessTokenOpts, type AddContactIdentityArgs, type AssertValidCredentialsArgs, type Attribute, type AuthorizationResponseEvent, type ContactAliasEvent, type ContactConsentEvent, type CreateConfigArgs, type CreateContactEvent, type CreateCredentialsToSelectFromArgs, type CreateFirstPartyMachineOpts, type CreateIdentifierArgs, type CreateIdentifierCreateOpts, type CreateIdentifierOpts, type CreateOID4VCIMachineOpts, type CredentialToAccept, type CredentialToSelectFromResult, type CredentialVerificationError, type DeclineEvent, type DefaultIssuanceOpts, type DidAgents, type DynamicRegistrationClientMetadataDisplay, type ErrorDetails, type FirstPartyDeclineEvent, type FirstPartyMachineContext, type FirstPartyMachineEventTypes, FirstPartyMachineEvents, type FirstPartyMachineInterpreter, type FirstPartyMachineNavigationArgs, type FirstPartyMachineServiceDefinitions, FirstPartyMachineServices, type FirstPartyMachineState, type FirstPartyMachineStateNavigationListener, FirstPartyMachineStateTypes, type FirstPartyMachineStates, type FirstPartyMachineStatesConfig, type FirstPartyNextEvent, type FirstPartyPreviousEvent, type FirstPartySelectCredentialsEvent, type FirstPartyStateMachine, type GetAuthenticationKeyArgs, type GetBasicIssuerLocaleBrandingArgs, type GetContactArgs, type GetCredentialArgs, type GetCredentialBrandingArgs, type GetCredentialConfigsSupportedArgs, type GetCredentialConfigsSupportedBySingleTypeOrIdArgs, type GetCredentialsArgs, type GetDefaultIssuanceOptsArgs, type GetFederationTrustArgs, type GetIdentifierArgs, type GetIssuanceCryptoSuiteArgs, type GetIssuanceDidMethodArgs, type GetIssuanceOptsArgs, type GetIssuerBrandingArgs, type GetIssuerMetadataArgs, type GetMachineArgs, type GetOrCreatePrimaryIdentifierArgs, type GetPreferredCredentialFormatsArgs, type GetSiopRequestArgs, type IOID4VCIHolder, IdentifierAliasEnum, type InstanceFirstPartyMachineOpts, type InvokeAuthorizationRequestEvent, type IssuanceOpts, type IssuerLocaleBrandingFromArgs, type IssuerType, type MapCredentialToAcceptArgs, type MappedCredentialToAccept, type NextEvent, OID4VCICallbackStateListener, type OID4VCIContext, OID4VCIHolder, OID4VCIHolderEvent, OID4VCIHolderLinkHandler, type OID4VCIHolderOptions, type OID4VCIMachine, OID4VCIMachineAddContactStates, type OID4VCIMachineContext, type OID4VCIMachineEventTypes, OID4VCIMachineEvents, OID4VCIMachineGuards, type OID4VCIMachineInstanceOpts, type OID4VCIMachineInterpreter, type OID4VCIMachineNavigationArgs, type OID4VCIMachineServiceDefinitions, OID4VCIMachineServices, type OID4VCIMachineState, type OID4VCIMachineStateNavigationListener, OID4VCIMachineStates, OID4VCIMachineVerifyPinStates, type OID4VCIProviderProps, type OID4VCIStateMachine, type Oid4vciCombineDisplayLocalesFromArgs, type Oid4vciCredentialDisplayLocalesFromArgs, type Oid4vciCredentialLocaleBrandingFromArgs, type Oid4vciGetCredentialBrandingFromArgs, type Oid4vciIssuerCredentialSubjectLocalesFromArgs, type OnContactIdentityCreatedArgs, type OnCredentialStoredArgs, type OnIdentifierCreatedArgs, type PrepareStartArgs, type PreviousEvent, type RequestData, RequestType, type RequiredContext, type SdJwtCombineDisplayLocalesFromArgs, type SdJwtCredentialClaimLocalesFromArgs, type SdJwtCredentialDisplayLocalesFromArgs, type SdJwtCredentialLocaleBrandingFromArgs, type SdJwtGetCredentialBrandingFromArgs, type SelectAppLocaleBrandingArgs, type SelectCredentialsEvent, type SendAuthorizationChallengeRequestArgs, type SendAuthorizationResponseArgs, type SendNotificationArgs, type SetAuthorizationCodeURLEvent, type SiopV2AuthorizationRequestData, type StartFirstPartApplicationMachine, type StartResult, type StoreCredentialBrandingArgs, type StoreCredentialsArgs, type StoreIssuerBrandingArgs, SupportedLanguage, type VerificationCodeEvent, type VerificationResult, type VerificationSubResult, type VerifyCredentialArgs, type VerifyCredentialToAcceptArgs, type VerifyEBSICredentialIssuerArgs, type VerifyEBSICredentialIssuerResult, type VerifyMdocArgs, type VerifySDJWTCredentialArgs, createConfig, getBasicIssuerLocaleBranding, getCredentialBranding, getCredentialConfigsBasedOnFormatPref, getCredentialConfigsSupported, getCredentialConfigsSupportedBySingleTypeOrId, getCredentialConfigsSupportedMerged, getIdentifierOpts, getIssuanceCryptoSuite, getIssuanceMethod, getIssuanceOpts, getSiopRequest, issuerLocaleBrandingFrom, mapCredentialToAccept, oid4vciCombineDisplayLocalesFrom, oid4vciCredentialDisplayLocalesFrom, oid4vciCredentialLocaleBrandingFrom, oid4vciGetCredentialBrandingFrom, oid4vciHolderContextMethods, oid4vciIssuerCredentialSubjectLocalesFrom, sdJwtCombineDisplayLocalesFrom, sdJwtCredentialClaimLocalesFrom, sdJwtCredentialDisplayLocalesFrom, sdJwtCredentialLocaleBrandingFrom, sdJwtGetCredentialBrandingFrom, selectCredentialLocaleBranding, sendAuthorizationChallengeRequest, sendAuthorizationResponse, signCallback, startFirstPartApplicationMachine, verifyCredentialToAccept };