@mattrglobal/verifier-sdk-web 1.1.1-unstable.16 → 1.1.1-unstable.160

package/dist/verifier-js.development.js

@@ -7,7 +7,7 @@
  * Do Not Translate or Localize
  *
  * Bundle of @mattrglobal/verifier-sdk-web
- * Generated: 2025-01-15
+ * Generated: 2025-05-20
  * Version: 1.1.0
  * Dependencies:
  *
@@ -426,6 +426,73 @@
     };
     ResultAsync.fromPromise;
     ResultAsync.fromSafePromise;
+    function _arrayLikeToArray(r, a) {
+        (null == a || a > r.length) && (a = r.length);
+        for (var e = 0, n = Array(a); e < a; e++) n[e] = r[e];
+        return n;
+    }
+    function _arrayWithoutHoles(r) {
+        if (Array.isArray(r)) return _arrayLikeToArray(r);
+    }
+    function _createForOfIteratorHelper(r, e) {
+        var t = "undefined" != typeof Symbol && r[Symbol.iterator] || r["@@iterator"];
+        if (!t) {
+            if (Array.isArray(r) || (t = _unsupportedIterableToArray(r)) || e && r && "number" == typeof r.length) {
+                t && (r = t);
+                var n = 0, F = function() {};
+                return {
+                    s: F,
+                    n: function() {
+                        return n >= r.length ? {
+                            done: !0
+                        } : {
+                            done: !1,
+                            value: r[n++]
+                        };
+                    },
+                    e: function(r) {
+                        throw r;
+                    },
+                    f: F
+                };
+            }
+            throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
+        }
+        var o, a = !0, u = !1;
+        return {
+            s: function() {
+                t = t.call(r);
+            },
+            n: function() {
+                var r = t.next();
+                return a = r.done, r;
+            },
+            e: function(r) {
+                u = !0, o = r;
+            },
+            f: function() {
+                try {
+                    a || null == t.return || t.return();
+                } finally {
+                    if (u) throw o;
+                }
+            }
+        };
+    }
+    function _defineProperty(e, r, t) {
+        return (r = _toPropertyKey(r)) in e ? Object.defineProperty(e, r, {
+            value: t,
+            enumerable: !0,
+            configurable: !0,
+            writable: !0
+        }) : e[r] = t, e;
+    }
+    function _iterableToArray(r) {
+        if ("undefined" != typeof Symbol && null != r[Symbol.iterator] || null != r["@@iterator"]) return Array.from(r);
+    }
+    function _nonIterableSpread() {
+        throw new TypeError("Invalid attempt to spread non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
+    }
     function ownKeys(e, r) {
         var t = Object.keys(e);
         if (Object.getOwnPropertySymbols) {
@@ -447,6 +514,23 @@
         }
         return e;
     }
+    function _toConsumableArray(r) {
+        return _arrayWithoutHoles(r) || _iterableToArray(r) || _unsupportedIterableToArray(r) || _nonIterableSpread();
+    }
+    function _toPrimitive(t, r) {
+        if ("object" != typeof t || !t) return t;
+        var e = t[Symbol.toPrimitive];
+        if (void 0 !== e) {
+            var i = e.call(t, r || "default");
+            if ("object" != typeof i) return i;
+            throw new TypeError("@@toPrimitive must return a primitive value.");
+        }
+        return ("string" === r ? String : Number)(t);
+    }
+    function _toPropertyKey(t) {
+        var i = _toPrimitive(t, "string");
+        return "symbol" == typeof i ? i : i + "";
+    }
     function _typeof(o) {
         "@babel/helpers - typeof";
         return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function(o) {
@@ -455,107 +539,12 @@
             return o && "function" == typeof Symbol && o.constructor === Symbol && o !== Symbol.prototype ? "symbol" : typeof o;
         }, _typeof(o);
     }
-    function _defineProperty(obj, key, value) {
-        key = _toPropertyKey(key);
-        if (key in obj) {
-            Object.defineProperty(obj, key, {
-                value: value,
-                enumerable: true,
-                configurable: true,
-                writable: true
-            });
-        } else {
-            obj[key] = value;
+    function _unsupportedIterableToArray(r, a) {
+        if (r) {
+            if ("string" == typeof r) return _arrayLikeToArray(r, a);
+            var t = {}.toString.call(r).slice(8, -1);
+            return "Object" === t && r.constructor && (t = r.constructor.name), "Map" === t || "Set" === t ? Array.from(r) : "Arguments" === t || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(t) ? _arrayLikeToArray(r, a) : void 0;
         }
-        return obj;
-    }
-    function _toConsumableArray(arr) {
-        return _arrayWithoutHoles(arr) || _iterableToArray(arr) || _unsupportedIterableToArray(arr) || _nonIterableSpread();
-    }
-    function _arrayWithoutHoles(arr) {
-        if (Array.isArray(arr)) return _arrayLikeToArray(arr);
-    }
-    function _iterableToArray(iter) {
-        if (typeof Symbol !== "undefined" && iter[Symbol.iterator] != null || iter["@@iterator"] != null) return Array.from(iter);
-    }
-    function _unsupportedIterableToArray(o, minLen) {
-        if (!o) return;
-        if (typeof o === "string") return _arrayLikeToArray(o, minLen);
-        var n = Object.prototype.toString.call(o).slice(8, -1);
-        if (n === "Object" && o.constructor) n = o.constructor.name;
-        if (n === "Map" || n === "Set") return Array.from(o);
-        if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen);
-    }
-    function _arrayLikeToArray(arr, len) {
-        if (len == null || len > arr.length) len = arr.length;
-        for (var i = 0, arr2 = new Array(len); i < len; i++) arr2[i] = arr[i];
-        return arr2;
-    }
-    function _nonIterableSpread() {
-        throw new TypeError("Invalid attempt to spread non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
-    }
-    function _createForOfIteratorHelper(o, allowArrayLike) {
-        var it = typeof Symbol !== "undefined" && o[Symbol.iterator] || o["@@iterator"];
-        if (!it) {
-            if (Array.isArray(o) || (it = _unsupportedIterableToArray(o)) || allowArrayLike && o && typeof o.length === "number") {
-                if (it) o = it;
-                var i = 0;
-                var F = function() {};
-                return {
-                    s: F,
-                    n: function() {
-                        if (i >= o.length) return {
-                            done: true
-                        };
-                        return {
-                            done: false,
-                            value: o[i++]
-                        };
-                    },
-                    e: function(e) {
-                        throw e;
-                    },
-                    f: F
-                };
-            }
-            throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
-        }
-        var normalCompletion = true, didErr = false, err;
-        return {
-            s: function() {
-                it = it.call(o);
-            },
-            n: function() {
-                var step = it.next();
-                normalCompletion = step.done;
-                return step;
-            },
-            e: function(e) {
-                didErr = true;
-                err = e;
-            },
-            f: function() {
-                try {
-                    if (!normalCompletion && it.return != null) it.return();
-                } finally {
-                    if (didErr) throw err;
-                }
-            }
-        };
-    }
-    function _toPrimitive(input, hint) {
-        if (typeof input !== "object" || input === null) return input;
-        var prim = input[Symbol.toPrimitive];
-        if (prim !== undefined) {
-            var res = prim.call(input, hint || "default");
-            if (typeof res !== "object") return res;
-            throw new TypeError("@@toPrimitive must return a primitive value.");
-        }
-        return (hint === "string" ? String : Number)(input);
-    }
-    function _toPropertyKey(arg) {
-        var key = _toPrimitive(arg, "string");
-        return typeof key === "symbol" ? key : String(key);
     }
     var store;
     function getGlobalConfig(config2) {
@@ -661,6 +650,19 @@
     function getDefault(schema, dataset, config2) {
         return typeof schema["default"] === "function" ? schema["default"](dataset, config2) : schema["default"];
     }
+    function any() {
+        return {
+            kind: "schema",
+            type: "any",
+            reference: any,
+            expects: "any",
+            async: false,
+            _run: function _run(dataset) {
+                dataset.typed = true;
+                return dataset;
+            }
+        };
+    }
     function array(item, message) {
         return {
             kind: "schema",
@@ -744,16 +746,35 @@
             }
         };
     }
-    function function_(message) {
+    function literal(literal_, message) {
         return {
             kind: "schema",
-            type: "function",
-            reference: function_,
-            expects: "Function",
+            type: "literal",
+            reference: literal,
+            expects: _stringify(literal_),
             async: false,
+            literal: literal_,
             message: message,
             _run: function _run(dataset, config2) {
-                if (typeof dataset.value === "function") {
+                if (dataset.value === this.literal) {
+                    dataset.typed = true;
+                } else {
+                    _addIssue(this, "type", dataset, config2);
+                }
+                return dataset;
+            }
+        };
+    }
+    function number(message) {
+        return {
+            kind: "schema",
+            type: "number",
+            reference: number,
+            expects: "number",
+            async: false,
+            message: message,
+            _run: function _run(dataset, config2) {
+                if (typeof dataset.value === "number" && !isNaN(dataset.value)) {
                     dataset.typed = true;
                 } else {
                     _addIssue(this, "type", dataset, config2);
@@ -1242,41 +1263,20 @@
             });
         }
     };
-    var SafeFetchCommonRespondErrorType;
-    (function(SafeFetchCommonRespondErrorType) {
-        SafeFetchCommonRespondErrorType["UnexpectedRespond"] = "UnexpectedRespond";
-    })(SafeFetchCommonRespondErrorType || (SafeFetchCommonRespondErrorType = {}));
-    var SafeFetchErrorType;
-    (function(SafeFetchErrorType) {
-        SafeFetchErrorType["HttpError"] = "HttpError";
-        SafeFetchErrorType["UnknownError"] = "UnknownError";
-    })(SafeFetchErrorType || (SafeFetchErrorType = {}));
-    const safeFetch = async (input, init) => {
-        try {
-            const response = await fetch(input, init);
-            if (response.status > 299 || response.status < 200) {
-                return err({
-                    type: SafeFetchErrorType.HttpError,
-                    message: `HTTP error, status = ${response.status}`,
-                    status: response.status
-                });
-            }
-            return ok(response);
-        } catch (error) {
-            return err({
-                type: SafeFetchErrorType.UnknownError,
-                message: "Unknown error",
-                cause: error
-            });
-        }
-    };
     exports.MobileCredentialVerificationReasonType = void 0;
     (function(MobileCredentialVerificationReasonType) {
-        MobileCredentialVerificationReasonType["Expired"] = "expired";
-        MobileCredentialVerificationReasonType["Inactive"] = "inactive";
-        MobileCredentialVerificationReasonType["StatusRevoked"] = "invalid";
-        MobileCredentialVerificationReasonType["StatusSuspended"] = "suspended";
-        MobileCredentialVerificationReasonType["StatusUnknown"] = "unknown";
+        MobileCredentialVerificationReasonType["TrustedIssuerCertificateExpired"] = "TrustedIssuerCertificateExpired";
+        MobileCredentialVerificationReasonType["TrustedIssuerCertificateNotYetValid"] = "TrustedIssuerCertificateNotYetValid";
+        MobileCredentialVerificationReasonType["IssuerNotTrusted"] = "IssuerNotTrusted";
+        MobileCredentialVerificationReasonType["MobileCredentialInvalid"] = "MobileCredentialInvalid";
+        MobileCredentialVerificationReasonType["MobileCredentialExpired"] = "MobileCredentialExpired";
+        MobileCredentialVerificationReasonType["MobileCredentialNotYetValid"] = "MobileCredentialNotYetValid";
+        MobileCredentialVerificationReasonType["InvalidSignerCertificate"] = "InvalidSignerCertificate";
+        MobileCredentialVerificationReasonType["DeviceKeyInvalid"] = "DeviceKeyInvalid";
+        MobileCredentialVerificationReasonType["UnsupportedCurve"] = "UnsupportedCurve";
+        MobileCredentialVerificationReasonType["StatusRevoked"] = "StatusRevoked";
+        MobileCredentialVerificationReasonType["StatusSuspended"] = "StatusSuspended";
+        MobileCredentialVerificationReasonType["StatusUnknown"] = "StatusUnknown";
     })(exports.MobileCredentialVerificationReasonType || (exports.MobileCredentialVerificationReasonType = {}));
     exports.ClaimType = void 0;
     (function(ClaimType) {
@@ -1302,6 +1302,13 @@
     (function(OpenidPresentationCredentialProfileSupported) {
         OpenidPresentationCredentialProfileSupported["MOBILE"] = "mobile";
     })(exports.OpenidPresentationCredentialProfileSupported || (exports.OpenidPresentationCredentialProfileSupported = {}));
+    var PresentationStatusCode;
+    (function(PresentationStatusCode) {
+        PresentationStatusCode["AwaitingRequestRetrieval"] = "AwaitingRequestRetrieval";
+        PresentationStatusCode["AwaitingResponse"] = "AwaitingResponse";
+        PresentationStatusCode["ResponseSubmitted"] = "ResponseSubmitted";
+        PresentationStatusCode["ResultReady"] = "ResultReady";
+    })(PresentationStatusCode || (PresentationStatusCode = {}));
     const CredentialQueryValidator = object({
         profile: picklist([ exports.OpenidPresentationCredentialProfileSupported.MOBILE ]),
         docType: string(),
@@ -1317,6 +1324,13 @@
         PresentationErrorType["WalletUnavailable"] = "WalletUnavailable";
         PresentationErrorType["Unknown"] = "Unknown";
     })(PresentationErrorType || (PresentationErrorType = {}));
+    const PresentationSuccessResultValidator = object({
+        sessionId: string(),
+        challenge: string(),
+        credentialQuery: array(CredentialQueryValidator),
+        credentials: optional(array(any())),
+        credentialErrors: optional(array(any()))
+    });
     const PresentationResultRelaxValidator = object({
         sessionId: string(),
         challenge: optional(string()),
@@ -1325,79 +1339,194 @@
         credentialErrors: optional(unknown()),
         error: optional(unknown())
     });
+    const PresentationFailureResultValidator = object({
+        sessionId: string(),
+        challenge: string(),
+        credentialQuery: array(CredentialQueryValidator),
+        error: object({
+            type: picklist(Object.values(PresentationErrorType)),
+            message: string()
+        })
+    });
+    const PresentationSessionResultValidator = union([ PresentationSuccessResultValidator, PresentationFailureResultValidator ]);
+    exports.Mode = void 0;
+    (function(Mode) {
+        Mode["SameDevice"] = "sameDevice";
+        Mode["CrossDevice"] = "crossDevice";
+    })(exports.Mode || (exports.Mode = {}));
+    var SessionType;
+    (function(SessionType) {
+        SessionType["DigitalCredentialsApi"] = "digital-credentials-api";
+        SessionType["Openid4vp"] = "openid4vp";
+    })(SessionType || (SessionType = {}));
     object({
         credentialQuery: array(CredentialQueryValidator),
         challenge: string(),
         redirectUri: optional(string()),
-        walletProviderId: optional(string())
+        walletProviderId: optional(string()),
+        dcApiSupported: optional(_boolean())
+    });
+    const CreateSessionDigitalCredentialsValidator = object({
+        type: literal(SessionType.DigitalCredentialsApi),
+        sessionId: string(),
+        sessionKey: string(),
+        sessionTtl: number(),
+        request: record(string(), any())
     });
-    const CreateSessionResponseValidator = object({
+    const CreateSessionOpenId4vpResponseValidator = object({
+        type: optional(literal(SessionType.Openid4vp)),
         sessionId: string(),
+        sessionKey: string(),
         sessionUrl: string()
     });
+    const CreateSessionResponseValidator = union([ CreateSessionDigitalCredentialsValidator, CreateSessionOpenId4vpResponseValidator ]);
+    const GetSessionStatusResponseValidator = union([ object({
+        status: picklist([ PresentationStatusCode.ResultReady ]),
+        responseCode: optional(string())
+    }), object({
+        status: string()
+    }) ]);
     var LocalStorageKey;
     (function(LocalStorageKey) {
         LocalStorageKey["challenge"] = "mattr_chg";
         LocalStorageKey["sessionId"] = "mattr_sid";
     })(LocalStorageKey || (LocalStorageKey = {}));
-    exports.Mode = void 0;
-    (function(Mode) {
-        Mode["sameDevice"] = "sameDevice";
-        Mode["crossDevice"] = "crossDevice";
-    })(exports.Mode || (exports.Mode = {}));
+    const MATTR_SDK_VERSION_HEADER = "x-mattr-sdk-version";
+    const MATTR_SDK_VERSION_VALUE = "2.0.0";
     var MessageEventDataType;
     (function(MessageEventDataType) {
         MessageEventDataType["PresentationCompleted"] = "PresentationCompleted";
         MessageEventDataType["PresentationTimeout"] = "PresentationTimeout";
         MessageEventDataType["PresentationAbort"] = "PresentationAbort";
     })(MessageEventDataType || (MessageEventDataType = {}));
-    const RequestCredentialsSameDeviceOptionsValidator = object({
-        credentialQuery: pipe(array(CredentialQueryValidator), nonEmpty()),
-        redirectUri: string(),
-        challenge: optional(string()),
+    const OpenId4vpConfigSameDeviceOptionsValidator = object({
         walletProviderId: optional(string()),
-        mode: picklist([ exports.Mode.sameDevice ])
+        mode: literal(exports.Mode.SameDevice),
+        redirectUri: string()
     });
-    const RequestCredentialsCrossDeviceOptionsValidator = object({
-        credentialQuery: pipe(array(CredentialQueryValidator), nonEmpty()),
-        crossDeviceCallback: object({
-            onComplete: function_(),
-            onFailure: function_()
-        }),
-        challenge: optional(string()),
+    const OpenId4vpConfigCrossDeviceOptionsValidator = object({
         walletProviderId: optional(string()),
-        mode: picklist([ exports.Mode.crossDevice ])
+        mode: literal(exports.Mode.CrossDevice)
     });
-    const RequestCredentialsAutoDetectDeviceOptionsValidator = object({
-        credentialQuery: pipe(array(CredentialQueryValidator), nonEmpty()),
-        crossDeviceCallback: object({
-            onComplete: function_(),
-            onFailure: function_()
-        }),
+    const OpenId4vpConfigAutoDetectOptionsValidator = object({
+        walletProviderId: optional(string()),
         redirectUri: string(),
+        mode: optional(picklist([ exports.Mode.CrossDevice, exports.Mode.SameDevice ]))
+    });
+    const RequestCredentialsOptionsValidator = object({
+        credentialQuery: pipe(array(CredentialQueryValidator), nonEmpty()),
         challenge: optional(string()),
-        walletProviderId: optional(string()),
-        mode: optional(picklist([ exports.Mode.crossDevice, exports.Mode.sameDevice ]))
+        openid4vpConfiguration: optional(union([ OpenId4vpConfigSameDeviceOptionsValidator, OpenId4vpConfigCrossDeviceOptionsValidator, OpenId4vpConfigAutoDetectOptionsValidator ]))
     });
-    const RequestCredentialsOptionsValidator = union([ RequestCredentialsSameDeviceOptionsValidator, RequestCredentialsCrossDeviceOptionsValidator, RequestCredentialsAutoDetectDeviceOptionsValidator ]);
     exports.RequestCredentialsErrorType = void 0;
     (function(RequestCredentialsErrorType) {
         RequestCredentialsErrorType["RequestCredentialsFailed"] = "RequestCredentialsFailed";
+        RequestCredentialsErrorType["Timeout"] = "Timeout";
+        RequestCredentialsErrorType["Abort"] = "Abort";
     })(exports.RequestCredentialsErrorType || (exports.RequestCredentialsErrorType = {}));
-    const InitialiseOptionsValidator = object({
-        apiBaseUrl: string(),
-        applicationId: optional(string())
+    var RequestCredentialsErrorMessage;
+    (function(RequestCredentialsErrorMessage) {
+        RequestCredentialsErrorMessage["FailedToGetSessionResult"] = "Failed to get session result";
+        RequestCredentialsErrorMessage["FailedToGetSessionStatus"] = "Failed to get session status";
+        RequestCredentialsErrorMessage["FailedToCreateSession"] = "Failed to create session";
+        RequestCredentialsErrorMessage["FailedToVerifyCredentialResponse"] = "Failed to verify credential response";
+        RequestCredentialsErrorMessage["MissingOpenId4vpConfig"] = "Identified openid4vp session, but missing openId4vpConfiguration on `requestCredentials`";
+        RequestCredentialsErrorMessage["DcApiError"] = "Failed to request credentials with Digital Credentials API";
+        RequestCredentialsErrorMessage["DcApiResponseParseError"] = "Failed to parse response from Digital Credentials API";
+        RequestCredentialsErrorMessage["Abort"] = "User aborted the session";
+        RequestCredentialsErrorMessage["Timeout"] = "User session timeout";
+    })(RequestCredentialsErrorMessage || (RequestCredentialsErrorMessage = {}));
+    exports.AbortSessionErrorType = void 0;
+    (function(AbortSessionErrorType) {
+        AbortSessionErrorType["AbortSessionFailed"] = "AbortSessionFailed";
+    })(exports.AbortSessionErrorType || (exports.AbortSessionErrorType = {}));
+    var AbortSessionErrorMessage;
+    (function(AbortSessionErrorMessage) {
+        AbortSessionErrorMessage["FailedToAbortSession"] = "Failed to abort session";
+    })(AbortSessionErrorMessage || (AbortSessionErrorMessage = {}));
+    const InitializeOptionsValidator = object({
+        apiBaseUrl: pipe(string(), nonEmpty("Must not be empty")),
+        applicationId: pipe(string(), nonEmpty("Must not be empty"))
     });
-    let initialiseOptions = undefined;
-    var InitialiseErrorMessage;
-    (function(InitialiseErrorMessage) {
-        InitialiseErrorMessage["SdkNotInitialised"] = "SDK not initialised";
-    })(InitialiseErrorMessage || (InitialiseErrorMessage = {}));
-    const initialise = options => {
-        assertType(InitialiseOptionsValidator, "Invalid initialise options")(options);
-        initialiseOptions = options;
+    var SafeFetchCommonResponseErrorType;
+    (function(SafeFetchCommonResponseErrorType) {
+        SafeFetchCommonResponseErrorType["UnexpectedResponse"] = "UnexpectedResponse";
+    })(SafeFetchCommonResponseErrorType || (SafeFetchCommonResponseErrorType = {}));
+    var SafeFetchErrorType;
+    (function(SafeFetchErrorType) {
+        SafeFetchErrorType["HttpError"] = "HttpError";
+        SafeFetchErrorType["UnknownError"] = "UnknownError";
+    })(SafeFetchErrorType || (SafeFetchErrorType = {}));
+    const safeFetch = async (input, init) => {
+        try {
+            const headers = Object.assign(Object.assign({}, init === null || init === void 0 ? void 0 : init.headers), {
+                [MATTR_SDK_VERSION_HEADER]: `verifier-sdk-web/${MATTR_SDK_VERSION_VALUE}`
+            });
+            const response = await fetch(input, Object.assign(Object.assign({}, init), {
+                headers: headers
+            }));
+            if (response.status > 299 || response.status < 200) {
+                return err({
+                    type: SafeFetchErrorType.HttpError,
+                    message: `HTTP error, status = ${response.status}`,
+                    status: response.status
+                });
+            }
+            return ok(response);
+        } catch (error) {
+            return err({
+                type: SafeFetchErrorType.UnknownError,
+                message: "Unknown error",
+                cause: error
+            });
+        }
+    };
+    let initializeOptions = undefined;
+    var InitializeErrorMessage;
+    (function(InitializeErrorMessage) {
+        InitializeErrorMessage["SdkNotInitialized"] = "SDK not initialized";
+    })(InitializeErrorMessage || (InitializeErrorMessage = {}));
+    const initialize = options => {
+        assertType(InitializeOptionsValidator, "Invalid initialize options")(options);
+        initializeOptions = options;
+    };
+    const getInitializeOptions = () => initializeOptions;
+    let sessionAbortController = undefined;
+    let _sessionId = undefined;
+    let _sessionKey = undefined;
+    let _sessionTimeoutId = undefined;
+    const getActiveSession = () => {
+        const sessionId = _sessionId;
+        const sessionKey = _sessionKey;
+        const sessionTimeoutId = _sessionTimeoutId;
+        if (sessionId) {
+            return {
+                sessionId: sessionId,
+                sessionKey: sessionKey,
+                sessionTimeoutId: sessionTimeoutId
+            };
+        }
+        return undefined;
+    };
+    const setActiveSession = session => {
+        const {sessionId: sessionId, sessionKey: sessionKey, sessionTimeoutId: sessionTimeoutId} = session;
+        _sessionId = sessionId;
+        _sessionKey = sessionKey;
+        _sessionTimeoutId = sessionTimeoutId;
+        const abortController = new AbortController;
+        sessionAbortController = abortController;
+        return abortController;
+    };
+    const removeActiveSession = () => {
+        sessionAbortController === null || sessionAbortController === void 0 ? void 0 : sessionAbortController.abort();
+        if (_sessionTimeoutId) {
+            window.clearTimeout(_sessionTimeoutId);
+        }
+        sessionAbortController = undefined;
+        _sessionKey = undefined;
+        _sessionId = undefined;
+        _sessionTimeoutId = undefined;
     };
-    const getInitialiseOptions = () => initialiseOptions;
     var isMobile_1 = isMobile;
     var isMobile_2 = isMobile;
     var default_1 = isMobile;
@@ -1422,6 +1551,23 @@
     isMobile_1["default"] = default_1;
     const defaultRetryDelay = attempt => Math.pow(2, attempt) * 1e3;
     const defaultRetry = 2;
+    const withRetry = async (fn, options) => {
+        const {retries: retries = defaultRetry, retryDelay: retryDelay = defaultRetryDelay, attempt: attempt = 0} = options;
+        try {
+            return await fn();
+        } catch (err) {
+            if (retries > 0) {
+                const delay = typeof retryDelay === "function" ? retryDelay(attempt) : retryDelay;
+                await new Promise((resolve => setTimeout(resolve, delay)));
+                return await withRetry(fn, Object.assign(Object.assign({}, options), {
+                    retries: retries - 1,
+                    retryDelay: retryDelay,
+                    attempt: attempt + 1
+                }));
+            }
+            throw err;
+        }
+    };
     const withRetrySafeFetch = async (fn, options) => {
         const {retries: retries = defaultRetry, retryDelay: retryDelay = defaultRetryDelay, attempt: attempt = 0, retryHttpStatus: retryHttpStatus} = options;
         const result = await fn();
@@ -1447,17 +1593,15 @@
         const urlParams = new URLSearchParams(hash.split("#")[1]);
         return urlParams.get(param);
     };
-    const createSession = async ({credentialQuery: credentialQuery, challenge: challenge, redirectUri: redirectUri, apiBaseUrl: apiBaseUrl, applicationId: applicationId, walletProviderId: walletProviderId}) => {
-        const postData = Object.assign(Object.assign(Object.assign({
+    const createSession = async ({credentialQuery: credentialQuery, challenge: challenge, redirectUri: redirectUri, apiBaseUrl: apiBaseUrl, walletProviderId: walletProviderId, dcApiSupported: dcApiSupported, applicationId: applicationId}) => {
+        const postData = {
             credentialQuery: credentialQuery,
-            challenge: challenge
-        }, redirectUri ? {
-            redirectUri: redirectUri
-        } : {}), applicationId ? {
-            applicationId: applicationId
-        } : {}), walletProviderId ? {
-            walletProviderId: walletProviderId
-        } : {});
+            challenge: challenge,
+            applicationId: applicationId,
+            redirectUri: redirectUri,
+            walletProviderId: walletProviderId,
+            dcApiSupported: dcApiSupported
+        };
         const responseResult = await safeFetch(`${apiBaseUrl}/v2/presentations/sessions`, {
             method: "POST",
             headers: {
@@ -1471,8 +1615,40 @@
         const data = await responseResult.value.json();
         if (!isType(CreateSessionResponseValidator)(data)) {
             return err({
-                type: SafeFetchCommonRespondErrorType.UnexpectedRespond,
-                message: "Create session return unsupported response"
+                type: SafeFetchCommonResponseErrorType.UnexpectedResponse,
+                message: "Create session returned unsupported response"
+            });
+        }
+        return ok(data);
+    };
+    const abortSession = async ({apiBaseUrl: apiBaseUrl, sessionId: sessionId, sessionKey: sessionKey}) => {
+        const responseResult = await safeFetch(`${apiBaseUrl}/v2/presentations/sessions/${sessionId}/abort`, {
+            method: "POST",
+            headers: {
+                "Content-Type": "application/json",
+                Authorization: `Bearer ${sessionKey}`
+            }
+        });
+        if (responseResult.isErr()) {
+            return err(responseResult.error);
+        }
+        return ok(undefined);
+    };
+    const getSessionStatus = async ({apiBaseUrl: apiBaseUrl, sessionId: sessionId, sessionKey: sessionKey}) => {
+        const responseResult = await safeFetch(`${apiBaseUrl}/v2/presentations/sessions/${sessionId}/status`, {
+            method: "GET",
+            headers: {
+                Authorization: `Bearer ${sessionKey}`
+            }
+        });
+        if (responseResult.isErr()) {
+            return err(responseResult.error);
+        }
+        const data = await responseResult.value.json();
+        if (!isType(GetSessionStatusResponseValidator)(data)) {
+            return err({
+                type: SafeFetchCommonResponseErrorType.UnexpectedResponse,
+                message: "Get session status return unsupported response"
             });
         }
         return ok(data);
@@ -1499,7 +1675,7 @@
         const data = await responseResult.value.json();
         if (!isType(PresentationResultRelaxValidator)(data)) {
             return err({
-                type: SafeFetchCommonRespondErrorType.UnexpectedRespond,
+                type: SafeFetchCommonResponseErrorType.UnexpectedResponse,
                 message: "Exchange session result return unsupported response",
                 details: {
                     data: data
@@ -1512,26 +1688,17 @@
         ua: userAgent,
         tablet: false
     });
-    exports.CrossDeviceCallbackErrorType = void 0;
-    (function(CrossDeviceCallbackErrorType) {
-        CrossDeviceCallbackErrorType["Timeout"] = "Timeout";
-        CrossDeviceCallbackErrorType["Abort"] = "Abort";
-        CrossDeviceCallbackErrorType["RequestCredentialsFailed"] = "RequestCredentialsFailed";
-    })(exports.CrossDeviceCallbackErrorType || (exports.CrossDeviceCallbackErrorType = {}));
-    var CrossDeviceRequestCredentialsErrorMessage;
-    (function(CrossDeviceRequestCredentialsErrorMessage) {
-        CrossDeviceRequestCredentialsErrorMessage["FailedToGetSessionResult"] = "Failed to get session result";
-        CrossDeviceRequestCredentialsErrorMessage["FailedToCreateSession"] = "Failed to create session";
-        CrossDeviceRequestCredentialsErrorMessage["Abort"] = "User aborted the session";
-        CrossDeviceRequestCredentialsErrorMessage["Timeout"] = "User session timeout";
-    })(CrossDeviceRequestCredentialsErrorMessage || (CrossDeviceRequestCredentialsErrorMessage = {}));
+    const getVersion = () => MATTR_SDK_VERSION_VALUE;
     var WindowEventListenerType;
     (function(WindowEventListenerType) {
         WindowEventListenerType["message"] = "message";
     })(WindowEventListenerType || (WindowEventListenerType = {}));
-    let listener;
+    let listener = undefined;
     const removeWindowMessageEventListener = () => {
-        window.removeEventListener(WindowEventListenerType.message, listener, false);
+        if (listener) {
+            window.removeEventListener(WindowEventListenerType.message, listener, false);
+        }
+        listener = undefined;
     };
     const closeCrossDeviceModal = options => {
         const {container: container} = options;
@@ -1541,8 +1708,7 @@
         removeWindowMessageEventListener();
     };
     const receiveMessageHandler = options => async event => {
-        const {crossDeviceCallback: crossDeviceCallback, container: container, sessionId: sessionId, apiBaseUrl: apiBaseUrl, challenge: challenge} = options;
-        const {onComplete: onComplete, onFailure: onFailure} = crossDeviceCallback;
+        const {onComplete: onComplete, onFailure: onFailure, container: container, sessionId: sessionId, apiBaseUrl: apiBaseUrl, challenge: challenge} = options;
         if (event.origin !== apiBaseUrl) {
             return;
         }
@@ -1556,8 +1722,8 @@
             });
             if (result.isErr()) {
                 onFailure({
-                    type: exports.CrossDeviceCallbackErrorType.RequestCredentialsFailed,
-                    message: CrossDeviceRequestCredentialsErrorMessage.FailedToGetSessionResult
+                    type: exports.RequestCredentialsErrorType.RequestCredentialsFailed,
+                    message: RequestCredentialsErrorMessage.FailedToGetSessionResult
                 });
                 closeCrossDeviceModal({
                     container: container
@@ -1565,8 +1731,9 @@
                 return;
             }
             onComplete({
-                result: result.value,
-                sessionId: result.value.sessionId
+                result: isType(PresentationSessionResultValidator)(result.value) ? result.value : undefined,
+                sessionId: result.value.sessionId,
+                sessionCompletedInRedirect: false
             });
             closeCrossDeviceModal({
                 container: container
@@ -1575,8 +1742,8 @@
         }
         if (event.data.type === MessageEventDataType.PresentationTimeout) {
             onFailure({
-                type: exports.CrossDeviceCallbackErrorType.Timeout,
-                message: CrossDeviceRequestCredentialsErrorMessage.Timeout
+                type: exports.RequestCredentialsErrorType.Timeout,
+                message: RequestCredentialsErrorMessage.Timeout
             });
             closeCrossDeviceModal({
                 container: container
@@ -1585,8 +1752,8 @@
         }
         if (event.data.type === MessageEventDataType.PresentationAbort) {
             onFailure({
-                type: exports.CrossDeviceCallbackErrorType.Abort,
-                message: CrossDeviceRequestCredentialsErrorMessage.Abort
+                type: exports.RequestCredentialsErrorType.Abort,
+                message: RequestCredentialsErrorMessage.Abort
             });
             closeCrossDeviceModal({
                 container: container
@@ -1609,104 +1776,324 @@
         modalContainer.setAttribute("class", "mattr-verifier-modal-container");
         return modalContainer;
     };
-    const requestCredentialsCrossDevice = async options => {
-        const {challenge: challenge, walletProviderId: walletProviderId, credentialQuery: credentialQuery, crossDeviceCallback: crossDeviceCallback, initialiseOptions: initialiseOptions} = options;
-        const {apiBaseUrl: apiBaseUrl, applicationId: applicationId} = initialiseOptions;
-        const createSessionResult = await createSession({
-            credentialQuery: credentialQuery,
-            challenge: challenge,
+    const requestCredentialsWithCrossDevice = async options => {
+        const {challenge: challenge, apiBaseUrl: apiBaseUrl, sessionUrl: sessionUrl, sessionId: sessionId, sessionKey: sessionKey} = options;
+        const container = openCrossDeviceModal({
+            sessionUrl: sessionUrl
+        });
+        return await new Promise((resolve => {
+            const abortController = setActiveSession({
+                sessionId: sessionId,
+                sessionKey: sessionKey
+            });
+            abortController.signal.addEventListener("abort", (() => {
+                closeCrossDeviceModal({
+                    container: container
+                });
+                resolve(err({
+                    type: exports.RequestCredentialsErrorType.Abort,
+                    message: RequestCredentialsErrorMessage.Abort
+                }));
+            }));
+            removeWindowMessageEventListener();
+            listener = receiveMessageHandler({
+                container: container,
+                sessionId: sessionId,
+                apiBaseUrl: apiBaseUrl,
+                challenge: challenge,
+                onComplete: data => resolve(ok(data)),
+                onFailure: error => resolve(err(error))
+            });
+            window.addEventListener(WindowEventListenerType.message, listener, false);
+        }));
+    };
+    const abortCredentialRequest = async () => {
+        const initializeOptions = getInitializeOptions();
+        if (!initializeOptions) {
+            throw new Exception(InitializeErrorMessage.SdkNotInitialized);
+        }
+        const {apiBaseUrl: apiBaseUrl} = initializeOptions;
+        const session = getActiveSession();
+        if (!session || !session.sessionKey) {
+            return ok(undefined);
+        }
+        const {sessionId: sessionId, sessionKey: sessionKey} = session;
+        removeActiveSession();
+        const abortSessionResult = await abortSession({
             apiBaseUrl: apiBaseUrl,
-            applicationId: applicationId,
-            walletProviderId: walletProviderId
+            sessionId: sessionId,
+            sessionKey: sessionKey
         });
-        if (createSessionResult.isErr()) {
+        if (abortSessionResult.isErr()) {
             return err({
-                type: exports.RequestCredentialsErrorType.RequestCredentialsFailed,
-                message: CrossDeviceRequestCredentialsErrorMessage.FailedToCreateSession,
-                cause: createSessionResult.error
+                type: exports.AbortSessionErrorType.AbortSessionFailed,
+                message: AbortSessionErrorMessage.FailedToAbortSession,
+                cause: abortSessionResult.error
             });
         }
-        const {sessionUrl: sessionUrl, sessionId: sessionId} = createSessionResult.value;
-        const container = openCrossDeviceModal({
-            sessionUrl: sessionUrl,
-            crossDeviceCallback: crossDeviceCallback
-        });
-        listener = receiveMessageHandler({
-            crossDeviceCallback: crossDeviceCallback,
-            container: container,
+        return ok(undefined);
+    };
+    const requestCredentialsWithDigitalCredentialsApi = async options => {
+        const {apiBaseUrl: apiBaseUrl, sessionId: sessionId, sessionKey: sessionKey, challenge: challenge, request: request, sessionTtl: sessionTtl} = options;
+        const sessionTimeoutId = window.setTimeout((() => removeActiveSession()), sessionTtl * 1e3);
+        const abortController = setActiveSession({
             sessionId: sessionId,
+            sessionKey: sessionKey,
+            sessionTimeoutId: sessionTimeoutId
+        });
+        const credentialResponseResult = await getCredentials(request, abortController);
+        if (credentialResponseResult.isErr()) {
+            await abortCredentialRequest();
+            return err(credentialResponseResult.error);
+        }
+        const credentialResponse = credentialResponseResult.value;
+        const parsedCredentialResponseResult = parseCredentialResponse(credentialResponse);
+        if (parsedCredentialResponseResult.isErr()) {
+            await abortCredentialRequest();
+            return err(parsedCredentialResponseResult.error);
+        }
+        const parsedCredentialResponse = parsedCredentialResponseResult.value;
+        const credentialVerificationResult = await verifyCredentialResponse({
             apiBaseUrl: apiBaseUrl,
-            challenge: challenge
+            sessionId: sessionId,
+            sessionKey: sessionKey,
+            challenge: challenge,
+            protocol: parsedCredentialResponse.protocol,
+            data: parsedCredentialResponse.data
         });
-        window.addEventListener(WindowEventListenerType.message, listener, false);
+        if (credentialVerificationResult.isErr()) {
+            return err({
+                type: exports.RequestCredentialsErrorType.RequestCredentialsFailed,
+                message: RequestCredentialsErrorMessage.FailedToVerifyCredentialResponse,
+                cause: credentialVerificationResult.error
+            });
+        }
+        const verificationResult = credentialVerificationResult.value;
         return ok({
+            result: isType(PresentationSessionResultValidator)(verificationResult) ? verificationResult : undefined,
             sessionId: sessionId
         });
     };
+    const getCredentials = async (request, abortController) => {
+        try {
+            const credentialResponse = await navigator.credentials.get(Object.assign(Object.assign({}, request), {
+                signal: abortController.signal
+            }));
+            return ok(credentialResponse);
+        } catch (exception) {
+            return err({
+                type: exports.RequestCredentialsErrorType.RequestCredentialsFailed,
+                message: RequestCredentialsErrorMessage.DcApiError,
+                cause: exception
+            });
+        }
+    };
+    const parseCredentialResponse = credentialResponse => {
+        if (!credentialResponse) {
+            return err({
+                type: exports.RequestCredentialsErrorType.RequestCredentialsFailed,
+                message: RequestCredentialsErrorMessage.DcApiResponseParseError,
+                details: {
+                    response: credentialResponse
+                }
+            });
+        }
+        if (typeof credentialResponse === "object") {
+            return ok(credentialResponse);
+        }
+        if (typeof credentialResponse === "string") {
+            try {
+                const parsed = JSON.parse(credentialResponse);
+                return ok(parsed);
+            } catch (_a) {
+                return err({
+                    type: exports.RequestCredentialsErrorType.RequestCredentialsFailed,
+                    message: RequestCredentialsErrorMessage.DcApiResponseParseError,
+                    details: {
+                        response: credentialResponse
+                    }
+                });
+            }
+        }
+        return err({
+            type: exports.RequestCredentialsErrorType.RequestCredentialsFailed,
+            message: RequestCredentialsErrorMessage.DcApiResponseParseError,
+            details: {
+                response: credentialResponse
+            }
+        });
+    };
+    const verifyCredentialResponse = async options => {
+        const {apiBaseUrl: apiBaseUrl, sessionId: sessionId, sessionKey: sessionKey, challenge: challenge, protocol: protocol, data: data} = options;
+        const requestBody = {
+            protocol: protocol,
+            data: data,
+            challenge: challenge
+        };
+        const credentialVerificationResult = await safeFetch(`${apiBaseUrl}/v2/presentations/sessions/${sessionId}/dc-api/response`, {
+            method: "POST",
+            headers: {
+                "Content-Type": "application/json",
+                Authorization: `Bearer ${sessionKey}`
+            },
+            body: JSON.stringify(requestBody)
+        });
+        if (credentialVerificationResult.isErr()) {
+            return err(credentialVerificationResult.error);
+        }
+        const credentialVerificationResponse = await credentialVerificationResult.value.json();
+        if (!isType(PresentationResultRelaxValidator)(credentialVerificationResponse)) {
+            return err({
+                type: SafeFetchCommonResponseErrorType.UnexpectedResponse,
+                message: "Verify credential returned unsupported response",
+                details: {
+                    response: credentialVerificationResponse
+                }
+            });
+        }
+        return ok(credentialVerificationResponse);
+    };
+    const isDigitalCredentialsApiSupported = () => {
+        var _a;
+        return "DigitalCredential" in window && typeof window.DigitalCredential === "function" && typeof ((_a = navigator === null || navigator === void 0 ? void 0 : navigator.credentials) === null || _a === void 0 ? void 0 : _a.get) === "function";
+    };
+    const sleep = ms => new Promise((resolve => setTimeout(resolve, ms)));
+    const SESSION_STATUS_POLLING_MAX_RETRY = 1e3;
+    const SESSION_STATUS_POLLING_INTERVAL_MS = 3e3;
+    const SESSION_STATUS_POLLING_INITIAL_DELAY_MS = 3e3;
     var SameDeviceRequestCredentialsErrorMessage;
     (function(SameDeviceRequestCredentialsErrorMessage) {
         SameDeviceRequestCredentialsErrorMessage["FailedToStoreChallenge"] = "Failed to store challenge";
         SameDeviceRequestCredentialsErrorMessage["FailedToCreateSession"] = "Failed to create session";
     })(SameDeviceRequestCredentialsErrorMessage || (SameDeviceRequestCredentialsErrorMessage = {}));
     const requestCredentialsSameDevice = async options => {
-        const {challenge: challenge, credentialQuery: credentialQuery, redirectUri: redirectUri, walletProviderId: walletProviderId, initialiseOptions: initialiseOptions} = options;
-        const {apiBaseUrl: apiBaseUrl, applicationId: applicationId} = initialiseOptions;
+        const {challenge: challenge, apiBaseUrl: apiBaseUrl, applicationId: applicationId, sessionUrl: sessionUrl, sessionKey: sessionKey, sessionId: sessionId} = options;
+        const abortController = setActiveSession({
+            sessionId: sessionId,
+            sessionKey: sessionKey
+        });
+        window.localStorage.setItem(LocalStorageKey.sessionId, sessionId);
         window.localStorage.setItem(LocalStorageKey.challenge, challenge);
-        const storedChallenge = window.localStorage.getItem(LocalStorageKey.challenge);
-        if (!storedChallenge) {
-            return err({
-                type: exports.RequestCredentialsErrorType.RequestCredentialsFailed,
-                message: SameDeviceRequestCredentialsErrorMessage.FailedToStoreChallenge
+        window.location.assign(sessionUrl);
+        await sleep(SESSION_STATUS_POLLING_INITIAL_DELAY_MS);
+        const checkResult = await withRetry((async () => {
+            const statusResult = await getSessionStatus({
+                apiBaseUrl: apiBaseUrl,
+                applicationId: applicationId,
+                sessionId: sessionId,
+                sessionKey: sessionKey
             });
+            if (abortController.signal.aborted) {
+                return err({
+                    type: exports.RequestCredentialsErrorType.Abort,
+                    message: RequestCredentialsErrorMessage.Abort
+                });
+            }
+            if (statusResult.isErr()) {
+                if (statusResult.error.status === 404) {
+                    return err({
+                        type: exports.RequestCredentialsErrorType.Timeout,
+                        message: RequestCredentialsErrorMessage.Timeout
+                    });
+                }
+                throw Error("Unexpected status response. Retry");
+            }
+            if (statusResult.value.status !== PresentationStatusCode.ResultReady) {
+                throw Error("Result is not ready. Retry");
+            }
+            return ok(undefined);
+        }), {
+            retries: SESSION_STATUS_POLLING_MAX_RETRY,
+            retryDelay: SESSION_STATUS_POLLING_INTERVAL_MS
+        });
+        if (checkResult.isErr()) {
+            return err(checkResult.error);
         }
+        window.close();
+        return ok({
+            sessionId: sessionId,
+            sessionCompletedInRedirect: true
+        });
+    };
+    const requestCredentials = async options => {
+        var _a;
+        const initializeOptions = getInitializeOptions();
+        if (!initializeOptions) {
+            throw new Exception(InitializeErrorMessage.SdkNotInitialized);
+        }
+        assertType(RequestCredentialsOptionsValidator, "Invalid request credential options")(options);
+        const {apiBaseUrl: apiBaseUrl, applicationId: applicationId} = initializeOptions;
+        const {challenge: challenge = generateChallenge(), credentialQuery: credentialQuery, openid4vpConfiguration: openid4vpConfiguration} = options;
+        const dcApiSupported = isDigitalCredentialsApiSupported();
+        const openId4VpRedirectUri = deriveOpenId4vpRedirectUri(openid4vpConfiguration);
         const createSessionResult = await createSession({
             credentialQuery: credentialQuery,
-            challenge: storedChallenge,
-            redirectUri: redirectUri,
+            challenge: challenge,
+            redirectUri: openId4VpRedirectUri,
+            walletProviderId: (_a = openid4vpConfiguration === null || openid4vpConfiguration === void 0 ? void 0 : openid4vpConfiguration.walletProviderId) !== null && _a !== void 0 ? _a : undefined,
             apiBaseUrl: apiBaseUrl,
             applicationId: applicationId,
-            walletProviderId: walletProviderId
+            dcApiSupported: dcApiSupported
         });
         if (createSessionResult.isErr()) {
             return err({
                 type: exports.RequestCredentialsErrorType.RequestCredentialsFailed,
-                message: SameDeviceRequestCredentialsErrorMessage.FailedToCreateSession,
+                message: RequestCredentialsErrorMessage.FailedToCreateSession,
                 cause: createSessionResult.error
             });
         }
-        const {sessionUrl: sessionUrl, sessionId: sessionId} = createSessionResult.value;
-        window.localStorage.setItem(LocalStorageKey.sessionId, sessionId);
-        window.location.assign(sessionUrl);
-        return ok({
+        const session = createSessionResult.value;
+        const {sessionKey: sessionKey, sessionId: sessionId} = session;
+        if (session.type === SessionType.DigitalCredentialsApi) {
+            const {request: request, sessionTtl: sessionTtl} = session;
+            return await requestCredentialsWithDigitalCredentialsApi({
+                apiBaseUrl: apiBaseUrl,
+                request: request,
+                sessionId: sessionId,
+                sessionKey: sessionKey,
+                challenge: challenge,
+                sessionTtl: sessionTtl
+            });
+        }
+        if (!openid4vpConfiguration) {
+            return err({
+                type: exports.RequestCredentialsErrorType.RequestCredentialsFailed,
+                message: RequestCredentialsErrorMessage.MissingOpenId4vpConfig
+            });
+        }
+        const {sessionUrl: sessionUrl} = session;
+        if (openId4VpRedirectUri) {
+            return await requestCredentialsSameDevice({
+                challenge: challenge,
+                apiBaseUrl: apiBaseUrl,
+                applicationId: applicationId,
+                sessionUrl: sessionUrl,
+                sessionKey: sessionKey,
+                sessionId: sessionId
+            });
+        }
+        return await requestCredentialsWithCrossDevice({
+            challenge: challenge,
+            apiBaseUrl: apiBaseUrl,
+            sessionUrl: sessionUrl,
+            sessionKey: sessionKey,
             sessionId: sessionId
         });
     };
-    const requestCredentials = async options => {
-        var _a;
-        const initialiseOptions = getInitialiseOptions();
-        if (!initialiseOptions) {
-            throw new Exception(InitialiseErrorMessage.SdkNotInitialised);
+    const deriveOpenId4vpRedirectUri = openid4vpConfiguration => {
+        if (!openid4vpConfiguration) {
+            return undefined;
         }
-        assertType(RequestCredentialsOptionsValidator, "Invalid request credential options")(options);
-        const {challenge: challenge = generateChallenge()} = options;
-        const mode = (_a = options.mode) !== null && _a !== void 0 ? _a : isMobileDetect(navigator.userAgent) ? exports.Mode.sameDevice : exports.Mode.crossDevice;
-        if (mode === exports.Mode.sameDevice && "redirectUri" in options) {
-            return await requestCredentialsSameDevice(Object.assign(Object.assign({}, options), {
-                initialiseOptions: initialiseOptions,
-                challenge: challenge,
-                mode: mode
-            }));
+        let detectedMode;
+        if (openid4vpConfiguration && openid4vpConfiguration.mode) {
+            detectedMode = openid4vpConfiguration.mode;
+        } else {
+            detectedMode = isMobileDetect(navigator.userAgent) ? exports.Mode.SameDevice : exports.Mode.CrossDevice;
         }
-        if (mode === exports.Mode.crossDevice && "crossDeviceCallback" in options) {
-            return await requestCredentialsCrossDevice(Object.assign(Object.assign({}, options), {
-                initialiseOptions: initialiseOptions,
-                challenge: challenge,
-                mode: mode
-            }));
+        if (detectedMode === exports.Mode.SameDevice && !isType(OpenId4vpConfigCrossDeviceOptionsValidator)(openid4vpConfiguration) && openid4vpConfiguration.redirectUri) {
+            return openid4vpConfiguration.redirectUri;
         }
-        throw new Exception("Invalid request credential options", {
-            data: options
-        });
+        return undefined;
     };
     exports.HandleRedirectCallbackErrorType = void 0;
     (function(HandleRedirectCallbackErrorType) {
@@ -1716,15 +2103,15 @@
     (function(HandleRedirectCallbackErrorMessage) {
         HandleRedirectCallbackErrorMessage["FailedToFindResponseCode"] = "Failed to find response code";
         HandleRedirectCallbackErrorMessage["FailedToFindChallenge"] = "Failed to find challenge";
-        HandleRedirectCallbackErrorMessage["FailedToFindSessionId"] = "Failed to find sessionId";
+        HandleRedirectCallbackErrorMessage["FailedToFindActiveSession"] = "Failed to find active session";
         HandleRedirectCallbackErrorMessage["FailedToGetSessionResult"] = "Failed to get session result";
     })(HandleRedirectCallbackErrorMessage || (HandleRedirectCallbackErrorMessage = {}));
     const handleRedirectCallback = async () => {
-        const initialiseOptions = getInitialiseOptions();
-        if (!initialiseOptions) {
-            throw new Exception(InitialiseErrorMessage.SdkNotInitialised);
+        const initializeOptions = getInitializeOptions();
+        if (!initializeOptions) {
+            throw new Exception(InitializeErrorMessage.SdkNotInitialized);
         }
-        const {apiBaseUrl: apiBaseUrl} = initialiseOptions;
+        const {apiBaseUrl: apiBaseUrl} = initializeOptions;
         const responseCode = getHashParamValue(window.location.hash, "response_code");
         if (!responseCode) {
             return err({
@@ -1732,18 +2119,12 @@
                 message: HandleRedirectCallbackErrorMessage.FailedToFindResponseCode
             });
         }
-        const challenge = window.localStorage.getItem(LocalStorageKey.challenge);
-        if (!challenge) {
-            return err({
-                type: exports.HandleRedirectCallbackErrorType.HandleRedirectCallbackFailed,
-                message: HandleRedirectCallbackErrorMessage.FailedToFindChallenge
-            });
-        }
         const sessionId = window.localStorage.getItem(LocalStorageKey.sessionId);
-        if (!sessionId) {
+        const challenge = window.localStorage.getItem(LocalStorageKey.challenge);
+        if (!sessionId || !challenge) {
             return err({
                 type: exports.HandleRedirectCallbackErrorType.HandleRedirectCallbackFailed,
-                message: HandleRedirectCallbackErrorMessage.FailedToFindSessionId
+                message: HandleRedirectCallbackErrorMessage.FailedToFindActiveSession
             });
         }
         const result = await exchangeSessionResult({
@@ -1760,16 +2141,19 @@
             });
         }
         return ok({
-            result: result.value,
+            result: "challenge" in result.value ? result.value : undefined,
             sessionId: result.value.sessionId
         });
     };
     const utils = {
         generateChallenge: generateChallenge,
+        getVersion: getVersion,
         unwrap: unwrap
     };
+    exports.abortCredentialRequest = abortCredentialRequest;
     exports.handleRedirectCallback = handleRedirectCallback;
-    exports.initialise = initialise;
+    exports.initialize = initialize;
+    exports.isDigitalCredentialsApiSupported = isDigitalCredentialsApiSupported;
     exports.requestCredentials = requestCredentials;
     exports.utils = utils;
     Object.defineProperty(exports, "__esModule", {