@mattrglobal/verifier-sdk-web 1.1.1-unstable.145 → 1.1.1-unstable.153

package/dist/typings/common/safeFetch.d.ts

@@ -1,10 +1,10 @@
 import { Result } from "neverthrow";
 import { BaseError } from "./error";
-export declare enum SafeFetchCommonRespondErrorType {
+export declare enum SafeFetchCommonResponseErrorType {
     /**
      * Unexpected response from the remote server
      */
-    UnexpectedRespond = "UnexpectedRespond"
+    UnexpectedResponse = "UnexpectedResponse"
 }
 export declare enum SafeFetchErrorType {
     /**
@@ -16,7 +16,7 @@ export declare enum SafeFetchErrorType {
      */
     UnknownError = "UnknownError"
 }
-export type SafeFetchValidateRespondError = BaseError<SafeFetchErrorType | SafeFetchCommonRespondErrorType.UnexpectedRespond> & {
+export type SafeFetchValidateResponseError = BaseError<SafeFetchErrorType | SafeFetchCommonResponseErrorType.UnexpectedResponse> & {
     status?: number;
 };
 export type SafeFetchError = BaseError<SafeFetchErrorType> & {

package/dist/typings/index.d.ts

@@ -1,11 +1,11 @@
-import { initialise, requestCredentials, handleRedirectCallback, abortCredentialRequest } from "./verifier";
+import { initialise, requestCredentials, handleRedirectCallback, abortCredentialRequest, isDigitalCredentialsApiSupported } from "./verifier";
 import { HandleRedirectCallbackError, HandleRedirectCallbackErrorType } from "./verifier/handleRedirectCallback";
-import { InitialiseOptions, RequestCredentialsOptions, RequestCredentialsSameDeviceOptions, RequestCredentialsCrossDeviceDeviceOptions, RequestCredentialsAutoDetectOptions, RequestCredentialsError, RequestCredentialsErrorType, CredentialQuery, CredentialQueryClaim, OpenidPresentationCredentialProfileSupported, Mode, RequestCredentialsResponse, AbortSessionErrorType, HandleRedirectCallbackResponse, Claim, ClaimData, ClaimType, PresentationSessionResult, PresentationSuccessResult, PresentationFailureResult, PresentationHiddenResult, PresentationErrorType, MobileCredentialPresentationCredential, MobileCredentialError, MobileCredentialResponseErrorCode, ValidityInfoRequest, CredentialBranding, CredentialBrandingImage, MobileCredentialVerificationResult, MobileCredentialVerificationReasonType, CredentialBrandingImageFormat } from "./verifier/types";
+import { InitialiseOptions, RequestCredentialsOptions, OpenId4vpConfigurationSameDeviceOptions, OpenId4vpConfigurationCrossDeviceOptions, OpenId4vpConfigurationAutoDetectOptions, RequestCredentialsError, RequestCredentialsErrorType, CredentialQuery, CredentialQueryClaim, OpenidPresentationCredentialProfileSupported, Mode, RequestCredentialsResponse, AbortSessionErrorType, HandleRedirectCallbackResponse, Claim, ClaimData, ClaimType, PresentationSessionResult, PresentationSuccessResult, PresentationFailureResult, PresentationHiddenResult, PresentationErrorType, MobileCredentialPresentationCredential, MobileCredentialError, MobileCredentialResponseErrorCode, ValidityInfoRequest, CredentialBranding, CredentialBrandingImage, MobileCredentialVerificationResult, MobileCredentialVerificationReasonType, CredentialBrandingImageFormat } from "./verifier/types";
 export { Mode, OpenidPresentationCredentialProfileSupported, MobileCredentialVerificationReasonType, RequestCredentialsErrorType, AbortSessionErrorType, HandleRedirectCallbackErrorType, CredentialBrandingImageFormat, ClaimType, MobileCredentialResponseErrorCode, };
-export type { InitialiseOptions, RequestCredentialsOptions, RequestCredentialsSameDeviceOptions, RequestCredentialsCrossDeviceDeviceOptions, RequestCredentialsAutoDetectOptions, CredentialQuery, CredentialQueryClaim, RequestCredentialsResponse, RequestCredentialsError, Claim, ClaimData, HandleRedirectCallbackResponse, PresentationSessionResult, PresentationSuccessResult, PresentationFailureResult, PresentationHiddenResult, PresentationErrorType, MobileCredentialPresentationCredential, MobileCredentialError, ValidityInfoRequest, CredentialBranding, CredentialBrandingImage, MobileCredentialVerificationResult, HandleRedirectCallbackError, };
+export type { InitialiseOptions, RequestCredentialsOptions, OpenId4vpConfigurationSameDeviceOptions, OpenId4vpConfigurationCrossDeviceOptions, OpenId4vpConfigurationAutoDetectOptions, CredentialQuery, CredentialQueryClaim, RequestCredentialsResponse, RequestCredentialsError, Claim, ClaimData, HandleRedirectCallbackResponse, PresentationSessionResult, PresentationSuccessResult, PresentationFailureResult, PresentationHiddenResult, PresentationErrorType, MobileCredentialPresentationCredential, MobileCredentialError, ValidityInfoRequest, CredentialBranding, CredentialBrandingImage, MobileCredentialVerificationResult, HandleRedirectCallbackError, };
 declare const utils: {
     generateChallenge: () => string;
     getVersion: () => string;
     unwrap: <T = unknown>(result: import("neverthrow").Result<T, unknown>, errMessage?: string) => T;
 };
-export { initialise, requestCredentials, handleRedirectCallback, abortCredentialRequest, utils };
+export { initialise, requestCredentials, handleRedirectCallback, abortCredentialRequest, isDigitalCredentialsApiSupported, utils, };

package/dist/typings/verifier/index.d.ts

@@ -2,5 +2,6 @@ export { initialise } from "./initialise";
 export { requestCredentials } from "./requestCredentials";
 export { handleRedirectCallback } from "./handleRedirectCallback";
 export { abortCredentialRequest } from "./abortCredentialRequest";
+export { isDigitalCredentialsApiSupported } from "./requestCredentialsDigitalCredentialsApi";
 export * as types from "./types";
 export * as utils from "./utils";

package/dist/typings/verifier/requestCredentialsCrossDevice.d.ts

@@ -1,4 +1,4 @@
 import { Result } from "neverthrow";
 import { CrossDeviceRequestCredentialsOptions, MessageEvent, RequestCredentialsError, RequestCredentialsResponse } from "./types";
 export declare let listener: ((event: MessageEvent) => Promise<void>) | undefined;
-export declare const requestCredentialsCrossDevice: (options: CrossDeviceRequestCredentialsOptions) => Promise<Result<RequestCredentialsResponse, RequestCredentialsError>>;
+export declare const requestCredentialsWithCrossDevice: (options: CrossDeviceRequestCredentialsOptions) => Promise<Result<RequestCredentialsResponse, RequestCredentialsError>>;

package/dist/typings/verifier/requestCredentialsDigitalCredentialsApi.d.ts

@@ -0,0 +1,16 @@
+import { Result } from "neverthrow";
+import { BaseError } from "../common";
+import { ExchangeSessionResultResponse, RequestCredentialsErrorType, RequestCredentialsWithDcApiOptions } from "./types";
+export declare const requestCredentialsWithDigitalCredentialsApi: (options: RequestCredentialsWithDcApiOptions) => Promise<Result<ExchangeSessionResultResponse, BaseError<RequestCredentialsErrorType.RequestCredentialsFailed>>>;
+/**
+ * TypeScript does not know that window.DigitalCredential is a valid property,
+ * even though it might exist at runtime, because the feature is experimental
+ *
+ * @returns boolean.
+ */
+/**
+ * Checks if Digital Credentials API feature is supported for the current browser.
+ *
+ * @returns boolean.
+ */
+export declare const isDigitalCredentialsApiSupported: () => boolean;

package/dist/typings/verifier/types/credential-presentation.d.ts

@@ -290,7 +290,40 @@ export type ExchangeSessionResultRequest = {
     readonly challenge: string;
     readonly responseCode: string;
 };
+/**
+ * The mode in which the credentials are requested
+ */
+export declare enum Mode {
+    /**
+     * The credentials are requested on the same device
+     */
+    SameDevice = "sameDevice",
+    /**
+     * The credentials are requested on a different device
+     */
+    CrossDevice = "crossDevice"
+}
+/**
+ * The type of presentation flow type to proceed with, defined by MATTR VII
+ */
+export declare enum SessionType {
+    /**
+     * SDK should proceed with presentation flow via Digital Credentials API
+     */
+    DigitalCredentialsApi = "digital-credentials-api",
+    /**
+     * SDK should proceed with presentation flow via openId4vci
+     */
+    Openid4vp = "openid4vp"
+}
 export type ExchangeSessionResultResponse = PresentationSessionResult | PresentationHiddenResult;
+export type RequestCredentialsWithDcApiOptions = {
+    apiBaseUrl: string;
+    sessionId: string;
+    sessionKey: string;
+    challenge: string;
+    request: Record<string, unknown>;
+};
 export type CreateSessionRequest = v.InferOutput<typeof CreateSessionRequestValidator>;
 export declare const CreateSessionRequestValidator: v.ObjectSchema<{
     readonly credentialQuery: v.ArraySchema<v.ObjectSchema<{
@@ -303,21 +336,26 @@ export declare const CreateSessionRequestValidator: v.ObjectSchema<{
     readonly challenge: v.StringSchema<undefined>;
     readonly redirectUri: v.OptionalSchema<v.StringSchema<undefined>, never>;
     readonly walletProviderId: v.OptionalSchema<v.StringSchema<undefined>, never>;
+    readonly dcApiSupported: v.OptionalSchema<v.BooleanSchema<undefined>, never>;
 }, undefined>;
-export type CreateSessionResponse = {
-    sessionId: string;
-    sessionKey: string;
-    sessionUrl: string;
-};
-export declare const CreateSessionResponseValidator: v.ObjectSchema<{
+export type CreateSessionResponse = v.InferOutput<typeof CreateSessionResponseValidator>;
+export declare const CreateSessionResponseValidator: v.UnionSchema<[v.ObjectSchema<{
+    readonly type: v.LiteralSchema<SessionType.DigitalCredentialsApi, undefined>;
+    readonly sessionId: v.StringSchema<undefined>;
+    readonly sessionKey: v.StringSchema<undefined>;
+    readonly sessionTtl: v.NumberSchema<undefined>;
+    readonly request: v.RecordSchema<v.StringSchema<undefined>, v.AnySchema, undefined>;
+}, undefined>, v.ObjectSchema<{
+    readonly type: v.OptionalSchema<v.LiteralSchema<SessionType.Openid4vp, undefined>, never>;
     readonly sessionId: v.StringSchema<undefined>;
     readonly sessionKey: v.StringSchema<undefined>;
     readonly sessionUrl: v.StringSchema<undefined>;
-}, undefined>;
+}, undefined>], undefined>;
 export type AbortSessionRequest = v.InferOutput<typeof AbortSessionRequestValidator>;
 export declare const AbortSessionRequestValidator: v.ObjectSchema<{
     readonly sessionId: v.StringSchema<undefined>;
     readonly sessionKey: v.StringSchema<undefined>;
+    readonly apiBaseUrl: v.StringSchema<undefined>;
 }, undefined>;
 export type GetSessionStatusRequest = v.InferOutput<typeof GetSessionStatusRequestValidator>;
 export declare const GetSessionStatusRequestValidator: v.ObjectSchema<{

package/dist/typings/verifier/types/verifier-web-sdk.d.ts

@@ -1,49 +1,37 @@
 import * as v from "valibot";
 import { BaseError } from "../../common";
-import { CredentialQuery, PresentationSessionResult } from "./credential-presentation";
+import { CredentialQuery, Mode, PresentationSessionResult } from "./credential-presentation";
 export declare enum LocalStorageKey {
     challenge = "mattr_chg",
     sessionId = "mattr_sid"
 }
 export declare const MATTR_SDK_VERSION_HEADER = "x-mattr-sdk-version";
 export declare const MATTR_SDK_VERSION_VALUE = "2.0.0";
-/**
- * The mode in which the credentials are requested
- */
-export declare enum Mode {
-    /**
-     * The credentials are requested on the same device
-     */
-    sameDevice = "sameDevice",
-    /**
-     * The credentials are requested on a different device
-     */
-    crossDevice = "crossDevice"
-}
 export declare enum MessageEventDataType {
     PresentationCompleted = "PresentationCompleted",// { type: "PresentationCompleted", responseCode, sessionId }
     PresentationTimeout = "PresentationTimeout",// { type: "PresentationTimeout", sessionId }
     PresentationAbort = "PresentationAbort"
 }
 export type SameDeviceRequestCredentialsOptions = {
-    credentialQuery: CredentialQuery[];
-    redirectUri: string;
     challenge: string;
-    mode: Mode.sameDevice;
-    walletProviderId?: string;
-    initialiseOptions: InitialiseOptions;
+    apiBaseUrl: string;
+    applicationId: string;
+    sessionUrl: string;
+    sessionKey: string;
+    sessionId: string;
 };
 export type CrossDeviceRequestCredentialsOptions = {
-    credentialQuery: CredentialQuery[];
     challenge: string;
-    walletProviderId?: string;
-    mode: Mode.crossDevice;
-    initialiseOptions: InitialiseOptions;
+    apiBaseUrl: string;
+    sessionUrl: string;
+    sessionKey: string;
+    sessionId: string;
 };
 /**
- * Options for the same device requestCredentials function
+ * Options for requestCredentials function without openId4vp configuration.
+ * Can be used for requesting credential with Digital Credentials API or with openId4vp cross-device flow
  */
-export type RequestCredentialsSameDeviceOptions = {
+export type RequestCredentialsBaseOptions = {
     /**
      * An array of CredentialQuery objects that specify the credentials to be requested.
      */
@@ -51,142 +39,83 @@ export type RequestCredentialsSameDeviceOptions = {
     /**
      *  The URI to which the user will be redirected after the credential request is completed.
      */
-    redirectUri: string;
-    /**
-     * An optional challenge string that is used to ensure the security and integrity of the credential request. If not provided, a challenge will be generated by default.
-     */
     challenge?: string;
+};
+/**
+ * Options for openid4vpConfiguration to request credentials with same device
+ */
+export type OpenId4vpConfigurationSameDeviceOptions = {
     /**
      * An optional identifier for wallet configuration. If not provided, the default wallet will be used.
      * This parameter is defined as part of your MATTR VII tenant verifier configuration
      */
     walletProviderId?: string;
     /**
-     * An optional mode in which the credentials are requested. Set to Mode.sameDevice for this type.
+     * A mode in which the credentials are requested. Set to Mode.SameDevice for this type.
+     * Can be undefined
      */
-    mode: Mode.sameDevice;
+    mode: Mode.SameDevice;
+    /**
+     * redirectUri is required if mode is same device or undefined
+     */
+    redirectUri: string;
 };
-export declare const RequestCredentialsSameDeviceOptionsValidator: v.ObjectSchema<{
-    readonly credentialQuery: v.SchemaWithPipe<[v.ArraySchema<v.ObjectSchema<{
-        readonly profile: v.PicklistSchema<[import("./credential-presentation").OpenidPresentationCredentialProfileSupported], undefined>;
-        readonly docType: v.StringSchema<undefined>;
-        readonly nameSpaces: v.RecordSchema<v.StringSchema<undefined>, v.RecordSchema<v.StringSchema<undefined>, v.StrictObjectSchema<{
-            readonly intentToRetain: v.OptionalSchema<v.BooleanSchema<undefined>, never>;
-        }, undefined>, undefined>, undefined>;
-    }, undefined>, undefined>, v.NonEmptyAction<{
-        profile: import("./credential-presentation").OpenidPresentationCredentialProfileSupported;
-        nameSpaces: {
-            [x: string]: {
-                [x: string]: {
-                    intentToRetain?: boolean | undefined;
-                };
-            };
-        };
-        docType: string;
-    }[], undefined>]>;
-    readonly redirectUri: v.StringSchema<undefined>;
-    readonly challenge: v.OptionalSchema<v.StringSchema<undefined>, never>;
+export declare const OpenId4vpConfigSameDeviceOptionsValidator: v.ObjectSchema<{
     readonly walletProviderId: v.OptionalSchema<v.StringSchema<undefined>, never>;
-    readonly mode: v.PicklistSchema<[Mode.sameDevice], undefined>;
+    readonly mode: v.LiteralSchema<Mode.SameDevice, undefined>;
+    readonly redirectUri: v.StringSchema<undefined>;
 }, undefined>;
 /**
- * Options for the cross device requestCredentials function
+ * Options for openid4vpConfiguration to request credentials with cross device
  */
-export type RequestCredentialsCrossDeviceDeviceOptions = {
-    /**
-     * An array of CredentialQuery objects that specify the credentials to be requested.
-     */
-    credentialQuery: CredentialQuery[];
-    /**
-     * An optional challenge string that is used to ensure the security and integrity of the credential request. If not provided, a challenge will be generated by default.
-     */
-    challenge?: string;
+export type OpenId4vpConfigurationCrossDeviceOptions = {
     /**
      * An optional identifier for wallet configuration. If not provided, the default wallet will be used.
      * This parameter is defined as part of your MATTR VII tenant verifier configuration
      */
     walletProviderId?: string;
     /**
-     * An optional mode in which the credentials are requested. Set to Mode.crossDevice for this type.
+     * A mode in which the credentials are requested. Set to Mode.CrossDevice for this type.
      */
-    mode: Mode.crossDevice;
+    mode: Mode.CrossDevice;
 };
-export declare const RequestCredentialsCrossDeviceOptionsValidator: v.ObjectSchema<{
-    readonly credentialQuery: v.SchemaWithPipe<[v.ArraySchema<v.ObjectSchema<{
-        readonly profile: v.PicklistSchema<[import("./credential-presentation").OpenidPresentationCredentialProfileSupported], undefined>;
-        readonly docType: v.StringSchema<undefined>;
-        readonly nameSpaces: v.RecordSchema<v.StringSchema<undefined>, v.RecordSchema<v.StringSchema<undefined>, v.StrictObjectSchema<{
-            readonly intentToRetain: v.OptionalSchema<v.BooleanSchema<undefined>, never>;
-        }, undefined>, undefined>, undefined>;
-    }, undefined>, undefined>, v.NonEmptyAction<{
-        profile: import("./credential-presentation").OpenidPresentationCredentialProfileSupported;
-        nameSpaces: {
-            [x: string]: {
-                [x: string]: {
-                    intentToRetain?: boolean | undefined;
-                };
-            };
-        };
-        docType: string;
-    }[], undefined>]>;
-    readonly challenge: v.OptionalSchema<v.StringSchema<undefined>, never>;
+export declare const OpenId4vpConfigCrossDeviceOptionsValidator: v.ObjectSchema<{
     readonly walletProviderId: v.OptionalSchema<v.StringSchema<undefined>, never>;
-    readonly mode: v.PicklistSchema<[Mode.crossDevice], undefined>;
+    readonly mode: v.LiteralSchema<Mode.CrossDevice, undefined>;
 }, undefined>;
 /**
- * Options for auto detect device requestCredentials function
+ * Options for openid4vpConfiguration which allow to auto-detect the device mode
  */
-export type RequestCredentialsAutoDetectOptions = {
-    /**
-     * An array of CredentialQuery objects that specify the credentials to be requested.
-     */
-    credentialQuery: CredentialQuery[];
-    /**
-     *  The URI to which the user will be redirected after the credential request is completed.
-     */
-    redirectUri: string;
-    /**
-     * An optional challenge string that is used to ensure the security and integrity of the credential request. If not provided, a challenge will be generated by default.
-     */
-    challenge?: string;
+export type OpenId4vpConfigurationAutoDetectOptions = {
     /**
      * An optional identifier for wallet configuration. If not provided, the default wallet will be used.
      * This parameter is defined as part of your MATTR VII tenant verifier configuration
      */
     walletProviderId?: string;
+    /**
+     * redirect uri to use for same device mode
+     */
+    redirectUri: string;
     /**
      * An optional mode in which the credentials are requested. If not provided, the mode is determined based on the device (isMobileDetect(navigator.userAgent)).
      */
     mode?: Mode;
 };
-export declare const RequestCredentialsAutoDetectDeviceOptionsValidator: v.GenericSchema<RequestCredentialsAutoDetectOptions>;
+export declare const OpenId4vpConfigAutoDetectOptionsValidator: v.ObjectSchema<{
+    readonly walletProviderId: v.OptionalSchema<v.StringSchema<undefined>, never>;
+    readonly redirectUri: v.StringSchema<undefined>;
+    readonly mode: v.OptionalSchema<v.PicklistSchema<[Mode.CrossDevice, Mode.SameDevice], undefined>, never>;
+}, undefined>;
 /**
  * Options for the requestCredentials function
  */
-export type RequestCredentialsOptions = RequestCredentialsSameDeviceOptions | RequestCredentialsCrossDeviceDeviceOptions | RequestCredentialsAutoDetectOptions;
-export declare const RequestCredentialsOptionsValidator: v.UnionSchema<[v.ObjectSchema<{
-    readonly credentialQuery: v.SchemaWithPipe<[v.ArraySchema<v.ObjectSchema<{
-        readonly profile: v.PicklistSchema<[import("./credential-presentation").OpenidPresentationCredentialProfileSupported], undefined>;
-        readonly docType: v.StringSchema<undefined>;
-        readonly nameSpaces: v.RecordSchema<v.StringSchema<undefined>, v.RecordSchema<v.StringSchema<undefined>, v.StrictObjectSchema<{
-            readonly intentToRetain: v.OptionalSchema<v.BooleanSchema<undefined>, never>;
-        }, undefined>, undefined>, undefined>;
-    }, undefined>, undefined>, v.NonEmptyAction<{
-        profile: import("./credential-presentation").OpenidPresentationCredentialProfileSupported;
-        nameSpaces: {
-            [x: string]: {
-                [x: string]: {
-                    intentToRetain?: boolean | undefined;
-                };
-            };
-        };
-        docType: string;
-    }[], undefined>]>;
-    readonly redirectUri: v.StringSchema<undefined>;
-    readonly challenge: v.OptionalSchema<v.StringSchema<undefined>, never>;
-    readonly walletProviderId: v.OptionalSchema<v.StringSchema<undefined>, never>;
-    readonly mode: v.PicklistSchema<[Mode.sameDevice], undefined>;
-}, undefined>, v.ObjectSchema<{
+export type RequestCredentialsOptions = RequestCredentialsBaseOptions & {
+    /**
+     * Optional configuration for openid4vp presentation flow
+     */
+    openid4vpConfiguration?: OpenId4vpConfigurationSameDeviceOptions | OpenId4vpConfigurationCrossDeviceOptions | OpenId4vpConfigurationAutoDetectOptions;
+};
+export declare const RequestCredentialsOptionsValidator: v.ObjectSchema<{
     readonly credentialQuery: v.SchemaWithPipe<[v.ArraySchema<v.ObjectSchema<{
         readonly profile: v.PicklistSchema<[import("./credential-presentation").OpenidPresentationCredentialProfileSupported], undefined>;
         readonly docType: v.StringSchema<undefined>;
@@ -205,9 +134,19 @@ export declare const RequestCredentialsOptionsValidator: v.UnionSchema<[v.Object
         docType: string;
     }[], undefined>]>;
     readonly challenge: v.OptionalSchema<v.StringSchema<undefined>, never>;
-    readonly walletProviderId: v.OptionalSchema<v.StringSchema<undefined>, never>;
-    readonly mode: v.PicklistSchema<[Mode.crossDevice], undefined>;
-}, undefined>, v.GenericSchema<RequestCredentialsAutoDetectOptions, RequestCredentialsAutoDetectOptions, v.BaseIssue<unknown>>], undefined>;
+    readonly openid4vpConfiguration: v.OptionalSchema<v.UnionSchema<[v.ObjectSchema<{
+        readonly walletProviderId: v.OptionalSchema<v.StringSchema<undefined>, never>;
+        readonly mode: v.LiteralSchema<Mode.SameDevice, undefined>;
+        readonly redirectUri: v.StringSchema<undefined>;
+    }, undefined>, v.ObjectSchema<{
+        readonly walletProviderId: v.OptionalSchema<v.StringSchema<undefined>, never>;
+        readonly mode: v.LiteralSchema<Mode.CrossDevice, undefined>;
+    }, undefined>, v.ObjectSchema<{
+        readonly walletProviderId: v.OptionalSchema<v.StringSchema<undefined>, never>;
+        readonly redirectUri: v.StringSchema<undefined>;
+        readonly mode: v.OptionalSchema<v.PicklistSchema<[Mode.CrossDevice, Mode.SameDevice], undefined>, never>;
+    }, undefined>], undefined>, never>;
+}, undefined>;
 export type MessageEvent = {
     data: {
         type: MessageEventDataType;
@@ -217,15 +156,21 @@ export type MessageEvent = {
     origin: string;
 };
 /**
- * The response from the requestCredentials function
+ * The response from the requestCredentials function when credentials were requested with OpenId4vp
  */
 export type RequestCredentialsResponse = {
     /**
      *  Contains the result of the presentation session if result is configured to be available in the front channel
      */
     result?: PresentationSessionResult;
+    /**
+     *  when frontChannelResultAvailable is set to true
+     */
     sessionId: string;
-    sessionCompletedInRedirect: boolean;
+    /**
+     *  Indicates that session is completed and the flow will continue on the redirected page
+     */
+    sessionCompletedInRedirect?: boolean;
 };
 /**
  * The error type for the requestCredentials function
@@ -239,6 +184,10 @@ export declare enum RequestCredentialsErrorMessage {
     FailedToGetSessionResult = "Failed to get session result",
     FailedToGetSessionStatus = "Failed to get session status",
     FailedToCreateSession = "Failed to create session",
+    FailedToVerifyCredentialResponse = "Failed to verify credential response",
+    MissingOpenId4vpConfig = "Identified openid4vp session, but missing openId4vpConfiguration on `requestCredentials`",
+    DcApiError = "Failed to request credentials with Digital Credentials API",
+    DcApiResponseParseError = "Failed to parse response from Digital Credentials API",
     Abort = "User aborted the session",
     Timeout = "User session timeout"
 }

package/dist/typings/verifier/utils.d.ts

@@ -1,6 +1,6 @@
 import { Result } from "neverthrow";
-import { SafeFetchValidateRespondError } from "../common/safeFetch";
-import { CreateSessionRequest, CreateSessionResponse, ExchangeSessionResultResponse, GetSessionStatusRequest, GetSessionStatusResponse, AbortSessionRequest, InitialiseOptions } from "./types";
+import { SafeFetchValidateResponseError } from "../common/safeFetch";
+import { CreateSessionRequest, ExchangeSessionResultResponse, GetSessionStatusRequest, GetSessionStatusResponse, AbortSessionRequest, InitialiseOptions, CreateSessionResponse } from "./types";
 /**
  * Generates a challenge string using the window.crypto API.
  *
@@ -26,7 +26,7 @@ export declare const getHashParamValue: (hash: string, param: string) => string
  * @param walletProviderId - optional, The ID of the wallet provider, if not provided the default wallet provider will be used.
  * @returns A promise that resolves to a result containing either the created session response or an error.
  */
-export declare const createSession: ({ credentialQuery, challenge, redirectUri, apiBaseUrl, applicationId, walletProviderId, }: CreateSessionRequest & InitialiseOptions) => Promise<Result<CreateSessionResponse, SafeFetchValidateRespondError>>;
+export declare const createSession: ({ credentialQuery, challenge, redirectUri, apiBaseUrl, walletProviderId, dcApiSupported, applicationId, }: CreateSessionRequest & InitialiseOptions) => Promise<Result<CreateSessionResponse, SafeFetchValidateResponseError>>;
 /**
  * Abort a session with the provided parameters.
  *
@@ -34,7 +34,7 @@ export declare const createSession: ({ credentialQuery, challenge, redirectUri,
  * @param sessionKey - The authorization key for performing operations for the session.
  * @returns A promise that resolves to a ok result when succeed or an error.
  */
-export declare const abortSession: ({ apiBaseUrl, sessionId, sessionKey, }: AbortSessionRequest & InitialiseOptions) => Promise<Result<void, SafeFetchValidateRespondError>>;
+export declare const abortSession: ({ apiBaseUrl, sessionId, sessionKey, }: AbortSessionRequest) => Promise<Result<void, SafeFetchValidateResponseError>>;
 /**
  * Retrieve the status for a session with the provided parameters.
  *
@@ -42,7 +42,7 @@ export declare const abortSession: ({ apiBaseUrl, sessionId, sessionKey, }: Abor
  * @param sessionKey - The authorization key for performing operations for the session.
  * @returns A promise that resolves to a result containing either the session status response or an error.
  */
-export declare const getSessionStatus: ({ apiBaseUrl, sessionId, sessionKey, }: GetSessionStatusRequest & InitialiseOptions) => Promise<Result<GetSessionStatusResponse, SafeFetchValidateRespondError>>;
+export declare const getSessionStatus: ({ apiBaseUrl, sessionId, sessionKey, }: GetSessionStatusRequest & InitialiseOptions) => Promise<Result<GetSessionStatusResponse, SafeFetchValidateResponseError>>;
 /**
  * Exchange the result of a session using the provided parameters.
  *
@@ -57,7 +57,7 @@ export declare const exchangeSessionResult: ({ challenge, responseCode, sessionI
     responseCode: string;
     sessionId: string;
     apiBaseUrl: string;
-}) => Promise<Result<ExchangeSessionResultResponse, SafeFetchValidateRespondError>>;
+}) => Promise<Result<ExchangeSessionResultResponse, SafeFetchValidateResponseError>>;
 /**
  * Detects if the user agent is a mobile device.
  *