@mattrglobal/verifier-sdk-web 2.0.0-preview-digital-credential-api.4 → 2.0.0

package/dist/verifier-js.development.js

@@ -7,13 +7,13 @@
  * Do Not Translate or Localize
  *
  * Bundle of @mattrglobal/verifier-sdk-web
- * Generated: 2025-03-25
- * Version: 2.0.0-preview-digital-credential-api.4
+ * Generated: 2025-05-28
+ * Version: 2.0.0
  * Dependencies:
  *
  * neverthrow -- 4.3.0
  *
- * valibot -- 0.38.0
+ * valibot -- 1.1.0
  *
  * is-mobile -- 4.0.0
  */
@@ -605,9 +605,9 @@
             abortPipeEarly: config2.abortPipeEarly
         };
         var isSchema = context.kind === "schema";
-        var message = (_ref3 = (_ref4 = (_ref5 = (_ref6 = (_other$message = other === null || other === void 0 ? void 0 : other.message) !== null && _other$message !== void 0 ? _other$message : context.message) !== null && _ref6 !== void 0 ? _ref6 : getSpecificMessage(context.reference, issue.lang)) !== null && _ref5 !== void 0 ? _ref5 : isSchema ? getSchemaMessage(issue.lang) : null) !== null && _ref4 !== void 0 ? _ref4 : config2.message) !== null && _ref3 !== void 0 ? _ref3 : getGlobalMessage(issue.lang);
-        if (message) {
-            issue.message = typeof message === "function" ? message(issue) : message;
+        var message2 = (_ref3 = (_ref4 = (_ref5 = (_ref6 = (_other$message = other === null || other === void 0 ? void 0 : other.message) !== null && _other$message !== void 0 ? _other$message : context.message) !== null && _ref6 !== void 0 ? _ref6 : getSpecificMessage(context.reference, issue.lang)) !== null && _ref5 !== void 0 ? _ref5 : isSchema ? getSchemaMessage(issue.lang) : null) !== null && _ref4 !== void 0 ? _ref4 : config2.message) !== null && _ref3 !== void 0 ? _ref3 : getGlobalMessage(issue.lang);
+        if (message2 !== void 0) {
+            issue.message = typeof message2 === "function" ? message2(issue) : message2;
         }
         if (isSchema) {
             dataset.typed = false;
@@ -618,26 +618,37 @@
             dataset.issues = [ issue ];
         }
     }
+    function _getStandardProps(context) {
+        return {
+            version: 1,
+            vendor: "valibot",
+            validate: function validate(value2) {
+                return context["~run"]({
+                    value: value2
+                }, getGlobalConfig());
+            }
+        };
+    }
     function _isValidObjectKey(object2, key) {
         return Object.hasOwn(object2, key) && key !== "__proto__" && key !== "prototype" && key !== "constructor";
     }
-    function _joinExpects(values, separator) {
+    function _joinExpects(values2, separator) {
         var _list$;
-        var list = _toConsumableArray(new Set(values));
+        var list = _toConsumableArray(new Set(values2));
         if (list.length > 1) {
             return "(".concat(list.join(" ".concat(separator, " ")), ")");
         }
         return (_list$ = list[0]) !== null && _list$ !== void 0 ? _list$ : "never";
     }
-    function nonEmpty(message) {
+    function nonEmpty(message2) {
         return {
             kind: "validation",
             type: "non_empty",
             reference: nonEmpty,
             async: false,
             expects: "!0",
-            message: message,
-            _run: function _run(dataset, config2) {
+            message: message2,
+            "~run": function run(dataset, config2) {
                 if (dataset.typed && dataset.value.length === 0) {
                     _addIssue(this, "length", dataset, config2, {
                         received: "0"
@@ -647,10 +658,53 @@
             }
         };
     }
+    function url(message2) {
+        return {
+            kind: "validation",
+            type: "url",
+            reference: url,
+            async: false,
+            expects: null,
+            requirement: function requirement(input) {
+                try {
+                    new URL(input);
+                    return true;
+                } catch (_unused) {
+                    return false;
+                }
+            },
+            message: message2,
+            "~run": function run(dataset, config2) {
+                if (dataset.typed && !this.requirement(dataset.value)) {
+                    _addIssue(this, "URL", dataset, config2);
+                }
+                return dataset;
+            }
+        };
+    }
+    function getFallback(schema, dataset, config2) {
+        return typeof schema.fallback === "function" ? schema.fallback(dataset, config2) : schema.fallback;
+    }
     function getDefault(schema, dataset, config2) {
         return typeof schema["default"] === "function" ? schema["default"](dataset, config2) : schema["default"];
     }
-    function array(item, message) {
+    function any() {
+        return {
+            kind: "schema",
+            type: "any",
+            reference: any,
+            expects: "any",
+            async: false,
+            get "~standard"() {
+                return _getStandardProps(this);
+            },
+            "~run": function run(dataset) {
+                dataset.typed = true;
+                return dataset;
+            }
+        };
+    }
+    function array(item, message2) {
         return {
             kind: "schema",
             type: "array",
@@ -658,16 +712,18 @@
             expects: "Array",
             async: false,
             item: item,
-            message: message,
-            _run: function _run(dataset, config2) {
+            message: message2,
+            get "~standard"() {
+                return _getStandardProps(this);
+            },
+            "~run": function run(dataset, config2) {
                 var input = dataset.value;
                 if (Array.isArray(input)) {
                     dataset.typed = true;
                     dataset.value = [];
                     for (var key = 0; key < input.length; key++) {
                         var value2 = input[key];
-                        var itemDataset = this.item._run({
-                            typed: false,
+                        var itemDataset = this.item["~run"]({
                             value: value2
                         }, config2);
                         if (itemDataset.issues) {
@@ -678,11 +734,11 @@
                                 key: key,
                                 value: value2
                             };
-                            var _iterator10 = _createForOfIteratorHelper(itemDataset.issues), _step10;
+                            var _iterator14 = _createForOfIteratorHelper(itemDataset.issues), _step14;
                             try {
-                                for (_iterator10.s(); !(_step10 = _iterator10.n()).done; ) {
+                                for (_iterator14.s(); !(_step14 = _iterator14.n()).done; ) {
                                     var _dataset$issues;
-                                    var issue = _step10.value;
+                                    var issue = _step14.value;
                                     if (issue.path) {
                                         issue.path.unshift(pathItem);
                                     } else {
@@ -691,9 +747,9 @@
                                     (_dataset$issues = dataset.issues) === null || _dataset$issues === void 0 || _dataset$issues.push(issue);
                                 }
                             } catch (err) {
-                                _iterator10.e(err);
+                                _iterator14.e(err);
                             } finally {
-                                _iterator10.f();
+                                _iterator14.f();
                             }
                             if (!dataset.issues) {
                                 dataset.issues = itemDataset.issues;
@@ -715,15 +771,18 @@
             }
         };
     }
-    function _boolean(message) {
+    function _boolean(message2) {
         return {
             kind: "schema",
             type: "boolean",
             reference: _boolean,
             expects: "boolean",
             async: false,
-            message: message,
-            _run: function _run(dataset, config2) {
+            message: message2,
+            get "~standard"() {
+                return _getStandardProps(this);
+            },
+            "~run": function run(dataset, config2) {
                 if (typeof dataset.value === "boolean") {
                     dataset.typed = true;
                 } else {
@@ -733,16 +792,41 @@
             }
         };
     }
-    function function_(message) {
+    function literal(literal_, message2) {
         return {
             kind: "schema",
-            type: "function",
-            reference: function_,
-            expects: "Function",
+            type: "literal",
+            reference: literal,
+            expects: _stringify(literal_),
             async: false,
-            message: message,
-            _run: function _run(dataset, config2) {
-                if (typeof dataset.value === "function") {
+            literal: literal_,
+            message: message2,
+            get "~standard"() {
+                return _getStandardProps(this);
+            },
+            "~run": function run(dataset, config2) {
+                if (dataset.value === this.literal) {
+                    dataset.typed = true;
+                } else {
+                    _addIssue(this, "type", dataset, config2);
+                }
+                return dataset;
+            }
+        };
+    }
+    function number(message2) {
+        return {
+            kind: "schema",
+            type: "number",
+            reference: number,
+            expects: "number",
+            async: false,
+            message: message2,
+            get "~standard"() {
+                return _getStandardProps(this);
+            },
+            "~run": function run(dataset, config2) {
+                if (typeof dataset.value === "number" && !isNaN(dataset.value)) {
                     dataset.typed = true;
                 } else {
                     _addIssue(this, "type", dataset, config2);
@@ -751,65 +835,85 @@
             }
         };
     }
-    function object(entries, message) {
+    function object(entries2, message2) {
         return {
             kind: "schema",
             type: "object",
             reference: object,
             expects: "Object",
             async: false,
-            entries: entries,
-            message: message,
-            _run: function _run(dataset, config2) {
+            entries: entries2,
+            message: message2,
+            get "~standard"() {
+                return _getStandardProps(this);
+            },
+            "~run": function run(dataset, config2) {
                 var input = dataset.value;
                 if (input && _typeof(input) === "object") {
                     dataset.typed = true;
                     dataset.value = {};
                     for (var key in this.entries) {
-                        var value2 = input[key];
-                        var valueDataset = this.entries[key]._run({
-                            typed: false,
-                            value: value2
-                        }, config2);
-                        if (valueDataset.issues) {
-                            var pathItem = {
-                                type: "object",
-                                origin: "value",
-                                input: input,
-                                key: key,
+                        var valueSchema = this.entries[key];
+                        if (key in input || (valueSchema.type === "exact_optional" || valueSchema.type === "optional" || valueSchema.type === "nullish") && valueSchema["default"] !== void 0) {
+                            var value2 = key in input ? input[key] : getDefault(valueSchema);
+                            var valueDataset = valueSchema["~run"]({
                                 value: value2
-                            };
-                            var _iterator26 = _createForOfIteratorHelper(valueDataset.issues), _step26;
-                            try {
-                                for (_iterator26.s(); !(_step26 = _iterator26.n()).done; ) {
-                                    var _dataset$issues13;
-                                    var issue = _step26.value;
-                                    if (issue.path) {
-                                        issue.path.unshift(pathItem);
-                                    } else {
-                                        issue.path = [ pathItem ];
+                            }, config2);
+                            if (valueDataset.issues) {
+                                var pathItem = {
+                                    type: "object",
+                                    origin: "value",
+                                    input: input,
+                                    key: key,
+                                    value: value2
+                                };
+                                var _iterator30 = _createForOfIteratorHelper(valueDataset.issues), _step30;
+                                try {
+                                    for (_iterator30.s(); !(_step30 = _iterator30.n()).done; ) {
+                                        var _dataset$issues13;
+                                        var issue = _step30.value;
+                                        if (issue.path) {
+                                            issue.path.unshift(pathItem);
+                                        } else {
+                                            issue.path = [ pathItem ];
+                                        }
+                                        (_dataset$issues13 = dataset.issues) === null || _dataset$issues13 === void 0 || _dataset$issues13.push(issue);
                                     }
-                                    (_dataset$issues13 = dataset.issues) === null || _dataset$issues13 === void 0 || _dataset$issues13.push(issue);
+                                } catch (err) {
+                                    _iterator30.e(err);
+                                } finally {
+                                    _iterator30.f();
+                                }
+                                if (!dataset.issues) {
+                                    dataset.issues = valueDataset.issues;
+                                }
+                                if (config2.abortEarly) {
+                                    dataset.typed = false;
+                                    break;
                                 }
-                            } catch (err) {
-                                _iterator26.e(err);
-                            } finally {
-                                _iterator26.f();
                             }
-                            if (!dataset.issues) {
-                                dataset.issues = valueDataset.issues;
+                            if (!valueDataset.typed) {
+                                dataset.typed = false;
                             }
+                            dataset.value[key] = valueDataset.value;
+                        } else if (valueSchema.fallback !== void 0) {
+                            dataset.value[key] = getFallback(valueSchema);
+                        } else if (valueSchema.type !== "exact_optional" && valueSchema.type !== "optional" && valueSchema.type !== "nullish") {
+                            _addIssue(this, "key", dataset, config2, {
+                                input: void 0,
+                                expected: '"'.concat(key, '"'),
+                                path: [ {
+                                    type: "object",
+                                    origin: "key",
+                                    input: input,
+                                    key: key,
+                                    value: input[key]
+                                } ]
+                            });
                             if (config2.abortEarly) {
-                                dataset.typed = false;
                                 break;
                             }
                         }
-                        if (!valueDataset.typed) {
-                            dataset.typed = false;
-                        }
-                        if (valueDataset.value !== void 0 || key in input) {
-                            dataset.value[key] = valueDataset.value;
-                        }
                     }
                 } else {
                     _addIssue(this, "type", dataset, config2);
@@ -818,17 +922,21 @@
             }
         };
     }
-    function optional(wrapped) {
-        var schema = {
+    function optional(wrapped, default_) {
+        return {
             kind: "schema",
             type: "optional",
             reference: optional,
             expects: "(".concat(wrapped.expects, " | undefined)"),
             async: false,
             wrapped: wrapped,
-            _run: function _run(dataset, config2) {
+            default: default_,
+            get "~standard"() {
+                return _getStandardProps(this);
+            },
+            "~run": function run(dataset, config2) {
                 if (dataset.value === void 0) {
-                    if ("default" in this) {
+                    if (this["default"] !== void 0) {
                         dataset.value = getDefault(this, dataset, config2);
                     }
                     if (dataset.value === void 0) {
@@ -836,18 +944,11 @@
                         return dataset;
                     }
                 }
-                return this.wrapped._run(dataset, config2);
+                return this.wrapped["~run"](dataset, config2);
             }
         };
-        for (var _len5 = arguments.length, args = new Array(_len5 > 1 ? _len5 - 1 : 0), _key11 = 1; _key11 < _len5; _key11++) {
-            args[_key11 - 1] = arguments[_key11];
-        }
-        if (0 in args) {
-            schema["default"] = args[0];
-        }
-        return schema;
     }
-    function picklist(options, message) {
+    function picklist(options, message2) {
         return {
             kind: "schema",
             type: "picklist",
@@ -855,8 +956,11 @@
             expects: _joinExpects(options.map(_stringify), "|"),
             async: false,
             options: options,
-            message: message,
-            _run: function _run(dataset, config2) {
+            message: message2,
+            get "~standard"() {
+                return _getStandardProps(this);
+            },
+            "~run": function run(dataset, config2) {
                 if (this.options.includes(dataset.value)) {
                     dataset.typed = true;
                 } else {
@@ -866,7 +970,7 @@
             }
         };
     }
-    function record(key, value2, message) {
+    function record(key, value2, message2) {
         return {
             kind: "schema",
             type: "record",
@@ -875,8 +979,11 @@
             async: false,
             key: key,
             value: value2,
-            message: message,
-            _run: function _run(dataset, config2) {
+            message: message2,
+            get "~standard"() {
+                return _getStandardProps(this);
+            },
+            "~run": function run(dataset, config2) {
                 var input = dataset.value;
                 if (input && _typeof(input) === "object") {
                     dataset.typed = true;
@@ -884,8 +991,7 @@
                     for (var entryKey in input) {
                         if (_isValidObjectKey(input, entryKey)) {
                             var entryValue = input[entryKey];
-                            var keyDataset = this.key._run({
-                                typed: false,
+                            var keyDataset = this.key["~run"]({
                                 value: entryKey
                             }, config2);
                             if (keyDataset.issues) {
@@ -896,18 +1002,18 @@
                                     key: entryKey,
                                     value: entryValue
                                 };
-                                var _iterator35 = _createForOfIteratorHelper(keyDataset.issues), _step35;
+                                var _iterator39 = _createForOfIteratorHelper(keyDataset.issues), _step39;
                                 try {
-                                    for (_iterator35.s(); !(_step35 = _iterator35.n()).done; ) {
+                                    for (_iterator39.s(); !(_step39 = _iterator39.n()).done; ) {
                                         var _dataset$issues19;
-                                        var issue = _step35.value;
+                                        var issue = _step39.value;
                                         issue.path = [ pathItem ];
                                         (_dataset$issues19 = dataset.issues) === null || _dataset$issues19 === void 0 || _dataset$issues19.push(issue);
                                     }
                                 } catch (err) {
-                                    _iterator35.e(err);
+                                    _iterator39.e(err);
                                 } finally {
-                                    _iterator35.f();
+                                    _iterator39.f();
                                 }
                                 if (!dataset.issues) {
                                     dataset.issues = keyDataset.issues;
@@ -917,8 +1023,7 @@
                                     break;
                                 }
                             }
-                            var valueDataset = this.value._run({
-                                typed: false,
+                            var valueDataset = this.value["~run"]({
                                 value: entryValue
                             }, config2);
                             if (valueDataset.issues) {
@@ -929,11 +1034,11 @@
                                     key: entryKey,
                                     value: entryValue
                                 };
-                                var _iterator36 = _createForOfIteratorHelper(valueDataset.issues), _step36;
+                                var _iterator40 = _createForOfIteratorHelper(valueDataset.issues), _step40;
                                 try {
-                                    for (_iterator36.s(); !(_step36 = _iterator36.n()).done; ) {
+                                    for (_iterator40.s(); !(_step40 = _iterator40.n()).done; ) {
                                         var _dataset$issues20;
-                                        var _issue5 = _step36.value;
+                                        var _issue5 = _step40.value;
                                         if (_issue5.path) {
                                             _issue5.path.unshift(_pathItem5);
                                         } else {
@@ -942,9 +1047,9 @@
                                         (_dataset$issues20 = dataset.issues) === null || _dataset$issues20 === void 0 || _dataset$issues20.push(_issue5);
                                     }
                                 } catch (err) {
-                                    _iterator36.e(err);
+                                    _iterator40.e(err);
                                 } finally {
-                                    _iterator36.f();
+                                    _iterator40.f();
                                 }
                                 if (!dataset.issues) {
                                     dataset.issues = valueDataset.issues;
@@ -969,79 +1074,98 @@
             }
         };
     }
-    function strictObject(entries, message) {
+    function strictObject(entries2, message2) {
         return {
             kind: "schema",
             type: "strict_object",
             reference: strictObject,
             expects: "Object",
             async: false,
-            entries: entries,
-            message: message,
-            _run: function _run(dataset, config2) {
+            entries: entries2,
+            message: message2,
+            get "~standard"() {
+                return _getStandardProps(this);
+            },
+            "~run": function run(dataset, config2) {
                 var input = dataset.value;
                 if (input && _typeof(input) === "object") {
                     dataset.typed = true;
                     dataset.value = {};
                     for (var key in this.entries) {
-                        var value2 = input[key];
-                        var valueDataset = this.entries[key]._run({
-                            typed: false,
-                            value: value2
-                        }, config2);
-                        if (valueDataset.issues) {
-                            var pathItem = {
-                                type: "object",
-                                origin: "value",
-                                input: input,
-                                key: key,
+                        var valueSchema = this.entries[key];
+                        if (key in input || (valueSchema.type === "exact_optional" || valueSchema.type === "optional" || valueSchema.type === "nullish") && valueSchema["default"] !== void 0) {
+                            var value2 = key in input ? input[key] : getDefault(valueSchema);
+                            var valueDataset = valueSchema["~run"]({
                                 value: value2
-                            };
-                            var _iterator44 = _createForOfIteratorHelper(valueDataset.issues), _step44;
-                            try {
-                                for (_iterator44.s(); !(_step44 = _iterator44.n()).done; ) {
-                                    var _dataset$issues25;
-                                    var issue = _step44.value;
-                                    if (issue.path) {
-                                        issue.path.unshift(pathItem);
-                                    } else {
-                                        issue.path = [ pathItem ];
+                            }, config2);
+                            if (valueDataset.issues) {
+                                var pathItem = {
+                                    type: "object",
+                                    origin: "value",
+                                    input: input,
+                                    key: key,
+                                    value: value2
+                                };
+                                var _iterator48 = _createForOfIteratorHelper(valueDataset.issues), _step48;
+                                try {
+                                    for (_iterator48.s(); !(_step48 = _iterator48.n()).done; ) {
+                                        var _dataset$issues25;
+                                        var issue = _step48.value;
+                                        if (issue.path) {
+                                            issue.path.unshift(pathItem);
+                                        } else {
+                                            issue.path = [ pathItem ];
+                                        }
+                                        (_dataset$issues25 = dataset.issues) === null || _dataset$issues25 === void 0 || _dataset$issues25.push(issue);
                                     }
-                                    (_dataset$issues25 = dataset.issues) === null || _dataset$issues25 === void 0 || _dataset$issues25.push(issue);
+                                } catch (err) {
+                                    _iterator48.e(err);
+                                } finally {
+                                    _iterator48.f();
+                                }
+                                if (!dataset.issues) {
+                                    dataset.issues = valueDataset.issues;
+                                }
+                                if (config2.abortEarly) {
+                                    dataset.typed = false;
+                                    break;
                                 }
-                            } catch (err) {
-                                _iterator44.e(err);
-                            } finally {
-                                _iterator44.f();
                             }
-                            if (!dataset.issues) {
-                                dataset.issues = valueDataset.issues;
+                            if (!valueDataset.typed) {
+                                dataset.typed = false;
                             }
+                            dataset.value[key] = valueDataset.value;
+                        } else if (valueSchema.fallback !== void 0) {
+                            dataset.value[key] = getFallback(valueSchema);
+                        } else if (valueSchema.type !== "exact_optional" && valueSchema.type !== "optional" && valueSchema.type !== "nullish") {
+                            _addIssue(this, "key", dataset, config2, {
+                                input: void 0,
+                                expected: '"'.concat(key, '"'),
+                                path: [ {
+                                    type: "object",
+                                    origin: "key",
+                                    input: input,
+                                    key: key,
+                                    value: input[key]
+                                } ]
+                            });
                             if (config2.abortEarly) {
-                                dataset.typed = false;
                                 break;
                             }
                         }
-                        if (!valueDataset.typed) {
-                            dataset.typed = false;
-                        }
-                        if (valueDataset.value !== void 0 || key in input) {
-                            dataset.value[key] = valueDataset.value;
-                        }
                     }
                     if (!dataset.issues || !config2.abortEarly) {
-                        for (var _key13 in input) {
-                            if (!(_key13 in this.entries)) {
-                                var _value3 = input[_key13];
-                                _addIssue(this, "type", dataset, config2, {
-                                    input: _value3,
+                        for (var _key9 in input) {
+                            if (!(_key9 in this.entries)) {
+                                _addIssue(this, "key", dataset, config2, {
+                                    input: _key9,
                                     expected: "never",
                                     path: [ {
                                         type: "object",
-                                        origin: "value",
+                                        origin: "key",
                                         input: input,
-                                        key: _key13,
-                                        value: _value3
+                                        key: _key9,
+                                        value: input[_key9]
                                     } ]
                                 });
                                 break;
@@ -1055,15 +1179,18 @@
             }
         };
     }
-    function string(message) {
+    function string(message2) {
         return {
             kind: "schema",
             type: "string",
             reference: string,
             expects: "string",
             async: false,
-            message: message,
-            _run: function _run(dataset, config2) {
+            message: message2,
+            get "~standard"() {
+                return _getStandardProps(this);
+            },
+            "~run": function run(dataset, config2) {
                 if (typeof dataset.value === "string") {
                     dataset.typed = true;
                 } else {
@@ -1076,10 +1203,10 @@
     function _subIssues(datasets) {
         var issues;
         if (datasets) {
-            var _iterator59 = _createForOfIteratorHelper(datasets), _step59;
+            var _iterator63 = _createForOfIteratorHelper(datasets), _step63;
             try {
-                for (_iterator59.s(); !(_step59 = _iterator59.n()).done; ) {
-                    var dataset = _step59.value;
+                for (_iterator63.s(); !(_step63 = _iterator63.n()).done; ) {
+                    var dataset = _step63.value;
                     if (issues) {
                         var _issues;
                         (_issues = issues).push.apply(_issues, _toConsumableArray(dataset.issues));
@@ -1088,14 +1215,14 @@
                     }
                 }
             } catch (err) {
-                _iterator59.e(err);
+                _iterator63.e(err);
             } finally {
-                _iterator59.f();
+                _iterator63.f();
             }
         }
         return issues;
     }
-    function union(options, message) {
+    function union(options, message2) {
         return {
             kind: "schema",
             type: "union",
@@ -1105,18 +1232,20 @@
             })), "|"),
             async: false,
             options: options,
-            message: message,
-            _run: function _run(dataset, config2) {
+            message: message2,
+            get "~standard"() {
+                return _getStandardProps(this);
+            },
+            "~run": function run(dataset, config2) {
                 var _untypedDatasets;
                 var validDataset;
                 var typedDatasets;
                 var untypedDatasets;
-                var _iterator60 = _createForOfIteratorHelper(this.options), _step60;
+                var _iterator64 = _createForOfIteratorHelper(this.options), _step64;
                 try {
-                    for (_iterator60.s(); !(_step60 = _iterator60.n()).done; ) {
-                        var schema = _step60.value;
-                        var optionDataset = schema._run({
-                            typed: false,
+                    for (_iterator64.s(); !(_step64 = _iterator64.n()).done; ) {
+                        var schema = _step64.value;
+                        var optionDataset = schema["~run"]({
                             value: dataset.value
                         }, config2);
                         if (optionDataset.typed) {
@@ -1139,9 +1268,9 @@
                         }
                     }
                 } catch (err) {
-                    _iterator60.e(err);
+                    _iterator64.e(err);
                 } finally {
-                    _iterator60.f();
+                    _iterator64.f();
                 }
                 if (validDataset) {
                     return validDataset;
@@ -1172,28 +1301,34 @@
             reference: unknown,
             expects: "unknown",
             async: false,
-            _run: function _run(dataset) {
+            get "~standard"() {
+                return _getStandardProps(this);
+            },
+            "~run": function run(dataset) {
                 dataset.typed = true;
                 return dataset;
             }
         };
     }
     function pipe() {
-        for (var _len7 = arguments.length, pipe2 = new Array(_len7), _key17 = 0; _key17 < _len7; _key17++) {
-            pipe2[_key17] = arguments[_key17];
+        for (var _len3 = arguments.length, pipe2 = new Array(_len3), _key13 = 0; _key13 < _len3; _key13++) {
+            pipe2[_key13] = arguments[_key13];
         }
         return _objectSpread2(_objectSpread2({}, pipe2[0]), {}, {
             pipe: pipe2,
-            _run: function _run(dataset, config2) {
-                for (var _i = 0, _pipe = pipe2; _i < _pipe.length; _i++) {
-                    var item = _pipe[_i];
+            get "~standard"() {
+                return _getStandardProps(this);
+            },
+            "~run": function run(dataset, config2) {
+                for (var _i2 = 0, _pipe = pipe2; _i2 < _pipe.length; _i2++) {
+                    var item = _pipe[_i2];
                     if (item.kind !== "metadata") {
                         if (dataset.issues && (item.kind === "schema" || item.kind === "transformation")) {
                             dataset.typed = false;
                             break;
                         }
                         if (!dataset.issues || !config2.abortEarly && !config2.abortPipeEarly) {
-                            dataset = item._run(dataset, config2);
+                            dataset = item["~run"](dataset, config2);
                         }
                     }
                 }
@@ -1202,8 +1337,7 @@
         });
     }
     function safeParse(schema, input, config2) {
-        var dataset = schema._run({
-            typed: false,
+        var dataset = schema["~run"]({
             value: input
         }, getGlobalConfig(config2));
         return {
@@ -1214,10 +1348,20 @@
         };
     }
     const isType = validator => value => safeParse(validator, value).success;
-    const getValidationErrors = issues => issues.map((({message: message, path: path}) => ({
-        message: message,
-        path: path === null || path === void 0 ? void 0 : path.map((path => path.key))
-    })));
+    const getValidationErrors = issues => {
+        const formatIssue = ({message: message, path: path}) => ({
+            message: message,
+            path: path === null || path === void 0 ? void 0 : path.map((p => p.key))
+        });
+        const uniqueErrors = new Map;
+        issues.flatMap((issue => issue.type === "union" && issue.issues ? issue.issues.map(formatIssue) : [ formatIssue(issue) ])).forEach((error => {
+            const key = `${error.message}-${JSON.stringify(error.path)}`;
+            if (!uniqueErrors.has(key)) {
+                uniqueErrors.set(key, error);
+            }
+        }));
+        return Array.from(uniqueErrors.values());
+    };
     const validateType = (value, validator) => {
         const result = safeParse(validator, value);
         return result.success ? ok(result.output) : err(getValidationErrors(result.issues));
@@ -1231,41 +1375,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) {
@@ -1291,6 +1414,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(),
@@ -1314,85 +1444,208 @@
         credentialErrors: optional(unknown()),
         error: optional(unknown())
     });
+    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 CreateSessionResponseValidator = object({
+    const CreateSessionDigitalCredentialsValidator = object({
+        type: literal(SessionType.DigitalCredentialsApi),
         sessionId: string(),
-        sessionUrl: string()
+        sessionKey: string(),
+        sessionTtl: number(),
+        request: record(string(), any())
     });
-    const CreateDigitalCredentialsApiSessionResponseValidator = object({
+    const CreateSessionOpenId4vpResponseValidator = object({
+        type: optional(literal(SessionType.Openid4vp)),
         sessionId: string(),
-        request: object({})
+        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: pipe(string(), nonEmpty("Must not be empty"), url())
     });
-    const RequestCredentialsCrossDeviceOptionsValidator = object({
-        credentialQuery: pipe(array(CredentialQueryValidator), nonEmpty()),
-        crossDeviceCallback: object({
-            onComplete: function_(),
-            onFailure: function_()
-        }),
-        challenge: optional(string()),
+    const OpenId4vpConfigCrossDeviceOptionsValidator = object({
+        walletProviderId: optional(string()),
+        mode: literal(exports.Mode.CrossDevice)
+    });
+    const OpenId4vpConfigAutoDetectOptionsValidator = object({
         walletProviderId: optional(string()),
-        mode: picklist([ exports.Mode.crossDevice ])
+        redirectUri: pipe(string(), nonEmpty("Must not be empty"), url()),
+        mode: optional(picklist([ exports.Mode.CrossDevice, exports.Mode.SameDevice ]))
     });
-    const RequestCredentialsAutoDetectDeviceOptionsValidator = object({
+    const RequestCredentialsOptionsValidator = object({
         credentialQuery: pipe(array(CredentialQueryValidator), nonEmpty()),
-        crossDeviceCallback: object({
-            onComplete: function_(),
-            onFailure: function_()
-        }),
-        redirectUri: string(),
         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()),
-        enableDigitalCredentialsApiSameDeviceFlow: optional(_boolean()),
-        enableDigitalCredentialsApiCrossDeviceFlow: optional(_boolean())
+    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"), url()),
+        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
+            }));
+            const defaultHttpErrorMessage = `HTTP error, status = ${response.status}`;
+            if (response.status >= 400 && response.status < 500) {
+                try {
+                    const errorBody = await response.json();
+                    if (typeof (errorBody === null || errorBody === void 0 ? void 0 : errorBody.message) === "string") {
+                        return err({
+                            type: SafeFetchErrorType.HttpError,
+                            message: errorBody.message,
+                            status: response.status
+                        });
+                    }
+                } catch (_a) {
+                    return err({
+                        type: SafeFetchErrorType.HttpError,
+                        message: defaultHttpErrorMessage,
+                        status: response.status
+                    });
+                }
+            }
+            if (response.status > 299 || response.status < 200) {
+                return err({
+                    type: SafeFetchErrorType.HttpError,
+                    message: defaultHttpErrorMessage,
+                    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);
+        const {apiBaseUrl: apiBaseUrl} = options;
+        const trimmedApiBaseUrl = apiBaseUrl.trim();
+        initializeOptions = {
+            apiBaseUrl: trimmedApiBaseUrl,
+            applicationId: options.applicationId
+        };
+    };
+    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;
@@ -1417,6 +1670,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();
@@ -1442,17 +1712,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: {
@@ -1466,89 +1734,50 @@
         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 exchangeSessionResult = async ({challenge: challenge, responseCode: responseCode, sessionId: sessionId, apiBaseUrl: apiBaseUrl}) => {
-        const postData = {
-            challenge: challenge,
-            responseCode: responseCode
-        };
-        const fetchResultFn = async () => await safeFetch(`${apiBaseUrl}/v2/presentations/sessions/${sessionId}/result`, {
+    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"
-            },
-            body: JSON.stringify(postData)
-        });
-        const responseResult = await withRetrySafeFetch(fetchResultFn, {
-            retries: 2,
-            retryHttpStatus: 404
+                "Content-Type": "application/json",
+                Authorization: `Bearer ${sessionKey}`
+            }
         });
         if (responseResult.isErr()) {
             return err(responseResult.error);
         }
-        const data = await responseResult.value.json();
-        if (!isType(PresentationResultRelaxValidator)(data)) {
-            return err({
-                type: SafeFetchCommonRespondErrorType.UnexpectedRespond,
-                message: "Exchange session result return unsupported response",
-                details: {
-                    data: data
-                }
-            });
-        }
-        return ok(data);
-    };
-    const isMobileDetect = userAgent => isMobile_2({
-        ua: userAgent,
-        tablet: false
-    });
-    const isDigitalCredentialsApiSupported = () => {
-        var _a;
-        try {
-            return typeof ((_a = navigator === null || navigator === void 0 ? void 0 : navigator.identity) === null || _a === void 0 ? void 0 : _a.get) === "function";
-        } catch (error) {
-            return false;
-        }
+        return ok(undefined);
     };
-    const createDigitalCredentialsApiSession = async ({credentialQuery: credentialQuery, challenge: challenge, apiBaseUrl: apiBaseUrl, protocol: protocol}) => {
-        const postData = Object.assign({
-            credentialQuery: credentialQuery,
-            challenge: challenge
-        }, protocol && {
-            protocol: protocol
-        });
-        const responseResult = await safeFetch(`${apiBaseUrl}/v2/presentations/sessions/web/request`, {
-            method: "POST",
+    const getSessionStatus = async ({apiBaseUrl: apiBaseUrl, sessionId: sessionId, sessionKey: sessionKey}) => {
+        const responseResult = await safeFetch(`${apiBaseUrl}/v2/presentations/sessions/${sessionId}/status`, {
+            method: "GET",
             headers: {
-                "Content-Type": "application/json"
-            },
-            body: JSON.stringify(postData)
+                Authorization: `Bearer ${sessionKey}`
+            }
         });
         if (responseResult.isErr()) {
             return err(responseResult.error);
         }
         const data = await responseResult.value.json();
-        if (!isType(CreateDigitalCredentialsApiSessionResponseValidator)(data)) {
+        if (!isType(GetSessionStatusResponseValidator)(data)) {
             return err({
-                type: SafeFetchCommonRespondErrorType.UnexpectedRespond,
-                message: "Create digital credentials api session return unsupported response"
+                type: SafeFetchCommonResponseErrorType.UnexpectedResponse,
+                message: "Get session status return unsupported response"
             });
         }
         return ok(data);
     };
-    const getDigitalCredentialsApiSessionResult = async ({challenge: challenge, sessionId: sessionId, response: response, apiBaseUrl: apiBaseUrl, protocol: protocol}) => {
+    const exchangeSessionResult = async ({challenge: challenge, responseCode: responseCode, sessionId: sessionId, apiBaseUrl: apiBaseUrl}) => {
         const postData = {
             challenge: challenge,
-            sessionId: sessionId,
-            response: response,
-            protocol: protocol
+            responseCode: responseCode
         };
-        const fetchResultFn = async () => await safeFetch(`${apiBaseUrl}/v2/presentations/sessions/web/response`, {
+        const fetchResultFn = async () => await safeFetch(`${apiBaseUrl}/v2/presentations/sessions/${sessionId}/result`, {
             method: "POST",
             headers: {
                 "Content-Type": "application/json"
@@ -1563,28 +1792,32 @@
             return err(responseResult.error);
         }
         const data = await responseResult.value.json();
+        if (!isType(PresentationResultRelaxValidator)(data)) {
+            return err({
+                type: SafeFetchCommonResponseErrorType.UnexpectedResponse,
+                message: "Exchange session result return unsupported response",
+                details: {
+                    data: data
+                }
+            });
+        }
         return ok(data);
     };
-    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 isMobileDetect = userAgent => isMobile_2({
+        ua: userAgent,
+        tablet: false
+    });
+    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;
@@ -1594,8 +1827,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;
         }
@@ -1609,8 +1841,8 @@
             });
             if (result.isErr()) {
                 onFailure({
-                    type: exports.CrossDeviceCallbackErrorType.RequestCredentialsFailed,
-                    message: CrossDeviceRequestCredentialsErrorMessage.FailedToGetSessionResult
+                    type: exports.RequestCredentialsErrorType.RequestCredentialsFailed,
+                    message: RequestCredentialsErrorMessage.FailedToGetSessionResult
                 });
                 closeCrossDeviceModal({
                     container: container
@@ -1618,8 +1850,9 @@
                 return;
             }
             onComplete({
-                result: result.value,
-                sessionId: result.value.sessionId
+                result: "challenge" in result.value ? result.value : undefined,
+                sessionId: result.value.sessionId,
+                sessionCompletedInRedirect: false
             });
             closeCrossDeviceModal({
                 container: container
@@ -1628,8 +1861,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
@@ -1638,8 +1871,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
@@ -1662,186 +1895,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: "challenge" in verificationResult ? verificationResult : undefined,
             sessionId: sessionId
         });
     };
-    var SameDeviceRequestCredentialsErrorMessage$1;
-    (function(SameDeviceRequestCredentialsErrorMessage) {
-        SameDeviceRequestCredentialsErrorMessage["FailedToStoreChallenge"] = "Failed to store challenge";
-        SameDeviceRequestCredentialsErrorMessage["FailedToCreateSession"] = "Failed to create session";
-    })(SameDeviceRequestCredentialsErrorMessage$1 || (SameDeviceRequestCredentialsErrorMessage$1 = {}));
-    const requestCredentialsSameDevice = async options => {
-        const {challenge: challenge, credentialQuery: credentialQuery, redirectUri: redirectUri, walletProviderId: walletProviderId, initialiseOptions: initialiseOptions} = options;
-        const {apiBaseUrl: apiBaseUrl, applicationId: applicationId} = initialiseOptions;
-        window.localStorage.setItem(LocalStorageKey.challenge, challenge);
-        const storedChallenge = window.localStorage.getItem(LocalStorageKey.challenge);
-        if (!storedChallenge) {
+    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: SameDeviceRequestCredentialsErrorMessage$1.FailedToStoreChallenge
+                message: RequestCredentialsErrorMessage.DcApiError,
+                cause: exception
             });
         }
-        const createSessionResult = await createSession({
-            credentialQuery: credentialQuery,
-            challenge: storedChallenge,
-            redirectUri: redirectUri,
-            apiBaseUrl: apiBaseUrl,
-            applicationId: applicationId,
-            walletProviderId: walletProviderId
-        });
-        if (createSessionResult.isErr()) {
+    };
+    const parseCredentialResponse = credentialResponse => {
+        if (!credentialResponse) {
             return err({
                 type: exports.RequestCredentialsErrorType.RequestCredentialsFailed,
-                message: SameDeviceRequestCredentialsErrorMessage$1.FailedToCreateSession,
-                cause: createSessionResult.error
+                message: RequestCredentialsErrorMessage.DcApiResponseParseError,
+                details: {
+                    response: credentialResponse
+                }
             });
         }
-        const {sessionUrl: sessionUrl, sessionId: sessionId} = createSessionResult.value;
-        window.localStorage.setItem(LocalStorageKey.sessionId, sessionId);
-        window.location.assign(sessionUrl);
-        return ok({
-            sessionId: sessionId
+        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 requestCredentialsDigitalCredentialsApi = async options => {
-        const {challenge: challenge, credentialQuery: credentialQuery, initialiseOptions: initialiseOptions} = options;
-        const {apiBaseUrl: apiBaseUrl, digitalCredentialsApiProtocol: digitalCredentialsApiProtocol} = initialiseOptions;
+    const requestCredentialsSameDevice = async options => {
+        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);
         }
-        const createSessionResult = await createDigitalCredentialsApiSession({
+        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,
+            challenge: challenge,
+            redirectUri: openId4VpRedirectUri,
+            walletProviderId: (_a = openid4vpConfiguration === null || openid4vpConfiguration === void 0 ? void 0 : openid4vpConfiguration.walletProviderId) !== null && _a !== void 0 ? _a : undefined,
             apiBaseUrl: apiBaseUrl,
-            protocol: digitalCredentialsApiProtocol
+            applicationId: applicationId,
+            dcApiSupported: dcApiSupported
         });
         if (createSessionResult.isErr()) {
             return err({
                 type: exports.RequestCredentialsErrorType.RequestCredentialsFailed,
-                message: SameDeviceRequestCredentialsErrorMessage.FailedToCreateSession,
+                message: RequestCredentialsErrorMessage.FailedToCreateSession,
                 cause: createSessionResult.error
             });
         }
-        const {request: request, sessionId: sessionId} = createSessionResult.value;
-        window.localStorage.setItem(LocalStorageKey.sessionId, sessionId);
-        let rawResponse;
-        try {
-            rawResponse = await navigator.identity.get(request);
-        } catch (_a) {
+        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: "Failed call to digital credentials api"
+                message: RequestCredentialsErrorMessage.MissingOpenId4vpConfig
             });
         }
-        let response;
-        try {
-            response = JSON.parse(rawResponse.data);
-        } catch (_b) {
-            response = rawResponse.data;
+        const {sessionUrl: sessionUrl} = session;
+        if (openId4VpRedirectUri) {
+            return await requestCredentialsSameDevice({
+                challenge: challenge,
+                apiBaseUrl: apiBaseUrl,
+                applicationId: applicationId,
+                sessionUrl: sessionUrl,
+                sessionKey: sessionKey,
+                sessionId: sessionId
+            });
         }
-        const result = await getDigitalCredentialsApiSessionResult({
+        return await requestCredentialsWithCrossDevice({
             challenge: challenge,
-            sessionId: sessionId,
-            response: response,
             apiBaseUrl: apiBaseUrl,
-            protocol: digitalCredentialsApiProtocol !== null && digitalCredentialsApiProtocol !== void 0 ? digitalCredentialsApiProtocol : "preview"
-        });
-        if (result.isOk()) {
-            return ok({
-                sessionId: sessionId,
-                result: result.value
-            });
-        }
-        return err({
-            type: exports.RequestCredentialsErrorType.RequestCredentialsFailed,
-            message: "Invalid response from digital credentials api"
+            sessionUrl: sessionUrl,
+            sessionKey: sessionKey,
+            sessionId: sessionId
         });
     };
-    const requestCredentials = async options => {
-        var _a;
-        const initialiseOptions = getInitialiseOptions();
-        if (!initialiseOptions) {
-            throw new Exception(InitialiseErrorMessage.SdkNotInitialised);
-        }
-        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 (initialiseOptions.enableDigitalCredentialsApiCrossDeviceFlow && isDigitalCredentialsApiSupported() && mode === exports.Mode.crossDevice) {
-            console.log("Digital Credentials API support found, proceeding with request using API in cross device flow");
-            return await requestCredentialsDigitalCredentialsApi(Object.assign(Object.assign({}, options), {
-                initialiseOptions: initialiseOptions,
-                challenge: challenge
-            }));
-        } else if (initialiseOptions.enableDigitalCredentialsApiCrossDeviceFlow) {
-            console.log("Digital Credentials API support not found, falling back to OpenID4VP");
-        }
-        if (initialiseOptions.enableDigitalCredentialsApiSameDeviceFlow && isDigitalCredentialsApiSupported() && mode === exports.Mode.sameDevice) {
-            console.log("Digital Credentials API support found, proceeding with request using API in same device flow");
-            return await requestCredentialsDigitalCredentialsApi(Object.assign(Object.assign({}, options), {
-                initialiseOptions: initialiseOptions,
-                challenge: challenge
-            }));
-        } else if (initialiseOptions.enableDigitalCredentialsApiSameDeviceFlow) {
-            console.log("Digital Credentials API support not found, falling back to OpenID4VP");
+    const deriveOpenId4vpRedirectUri = openid4vpConfiguration => {
+        if (!openid4vpConfiguration) {
+            return undefined;
         }
-        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.trim();
         }
-        throw new Exception("Invalid request credential options", {
-            data: options
-        });
+        return undefined;
     };
     exports.HandleRedirectCallbackErrorType = void 0;
     (function(HandleRedirectCallbackErrorType) {
@@ -1851,15 +2222,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({
@@ -1867,18 +2238,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({
@@ -1895,17 +2260,19 @@
             });
         }
         return ok({
-            result: result.value,
+            result: "challenge" in result.value ? result.value : undefined,
             sessionId: result.value.sessionId
         });
     };
     const utils = {
         generateChallenge: generateChallenge,
-        unwrap: unwrap,
-        isDigitalCredentialsApiSupported: isDigitalCredentialsApiSupported
+        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", {