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

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

@@ -1,8 +1,15 @@
 import * as v from "valibot";
-/*** mobile-credential-framework https://github.com/mattrinternal/opencore/tree/master/packages/mobile-credential-framework/src/types ***/
 export declare enum MobileCredentialVerificationReasonType {
+    /** Credential has expired  */
     Expired = "expired",
-    Inactive = "inactive"
+    /** Credential is not yet active */
+    Inactive = "inactive",
+    /** Credential has been revoked permanently and a new credential must be issued */
+    StatusRevoked = "invalid",
+    /** Credential has been suspended and must be re-activated before use */
+    StatusSuspended = "suspended",
+    /** The Credentials status could not be resolved or verified */
+    StatusUnknown = "unknown"
 }
 export declare enum ClaimType {
     Boolean = "boolean",
@@ -28,43 +35,53 @@ export type MobileCredentialError = {
     readonly docType: string;
     readonly errorCode: MobileCredentialResponseErrorCode;
 };
-/*** mobile-credential-framework end ***/
-/*** credential-presentation https://github.com/mattrinternal/platform/tree/master/libraries/platform-api-types/src/api-types/credential-presentation ***/
 export declare enum OpenidPresentationCredentialProfileSupported {
     MOBILE = "mobile"
 }
 export type CredentialQueryClaim = {
+    /**
+     * `intentToRetain` (Optional): When set to `true`, the holder will be indicated that the verifier intends to retain this claim beyond the verification workflow. Defaults to `false` when not specified.
+     */
     intentToRetain?: boolean;
 };
 /**
  * Credential query
  * @example
- * {
- *   "format":"mso_mdoc",
- *   "docType":"org.iso.18013.5.1.mDL",
- *   "nameSpaces":{
- *     "org.iso.18013.5.1":{
- *       "birthdate":{
- *         "intentToRetain":true
- *       },
- *       "portrait":{
- *         "intentToRetain":true
+ *  // The following example credential query will request the `birthdate` and `portrait` claims from a `mobile` credential `profile` with `org.iso.18013.5.1.mDL` as a `docType`:
+ *  {
+ *   "profile": "mobile",
+ *   "docType": "org.iso.18013.5.1.mDL",
+ *   "nameSpaces": {
+ *     "org.iso.18013.5.1": {
+ *       "birthdate": {
+           "intentToRetain": false
+ *        },
+ *       "portrait": {
+ *         "intentToRetain": false
  *       },
- *       "resident_postal_code":{
- *         "intentToRetain":true
- *       }
- *     },
- *     "org.iso.18013.5.1.aamva":{
- *       "DHS_compliance":{
- *         "intentToRetain":true
- *       }
- *     }
- *   }
- * }
+ *       "resident_postal_code": {
+ *         "intentToRetain": false
+ *        }
+ *      },
+ *    }
+ *  }
  */
 export type CredentialQuery = {
+    /**
+     * Credential format of the credential that will be verified. Currently only mobile (mDocs) is supported.
+     */
     profile: OpenidPresentationCredentialProfileSupported;
+    /**
+     * the mDL’s type. Confirm with the certificate issuer for what docType they are issuing. Some common examples include:
+     *   * Mobile Driver Licence (`org.iso.18013.5.1.mDL`).
+     *   * PhotoID (`org.iso.23220.photoid.1`).
+     *   * Mobile Vehicle Registration Card (`org.iso.7367.1.mVRC`).
+     *   * Health certificate (`org.micov.vtr.1`).
+     */
     docType: string;
+    /**
+     * Each namespace corresponds to a group of claims included in the credential. These can be claims that are part of a specific standard, jurisdiction or any other reference. The namespace would usually correspond to the requested `docType`.
+     */
     nameSpaces: {
         [nameSpace: string]: {
             [claim: string]: CredentialQueryClaim;
@@ -104,8 +121,6 @@ export declare enum PresentationErrorType {
      */
     Unknown = "Unknown"
 }
-/*** credential-presentation end ***/
-/*** mobile-credential https://github.com/mattrinternal/platform/tree/master/libraries/platform-api-types/src/api-types/mobile-credential ***/
 export type ValidityInfoRequest = {
     signed: string;
     validFrom: string;
@@ -169,17 +184,15 @@ export type Claim = {
 export type MobileCredentialPresentationCredential = {
     docType: string;
     validityInfo: ValidityInfoRequest;
-    branding?: CredentialBranding;
-    claims?: Record<string, Record<string, Claim>>;
-    claimErrors?: Record<string, Record<string, MobileCredentialResponseErrorCode>>;
-    verificationResult: MobileCredentialVerificationResult;
     issuerInfo: {
         commonName: string;
         trustedIssuerId: string;
     };
+    verificationResult: MobileCredentialVerificationResult;
+    branding?: CredentialBranding;
+    claims?: Record<string, Record<string, Claim>>;
+    claimErrors?: Record<string, Record<string, MobileCredentialResponseErrorCode>>;
 };
-/*** mobile-credential end ***/
-/*** session result https://github.com/mattrinternal/platform/tree/master/libraries/platform-api-types/src/api-types/credential-presentation/sessionResult.ts ***/
 /**
  * The result of a credential presentation request, default response or set `resultAvailableInFrontChannel: true` as verifier's configuration
  */
@@ -231,8 +244,6 @@ export type ExchangeSessionResultRequest = {
     readonly responseCode: string;
 };
 export type ExchangeSessionResultResponse = PresentationSessionResult | PresentationHiddenResult;
-/*** session result end ***/
-/*** session https://github.com/mattrinternal/platform/tree/master/libraries/platform-api-types/src/api-types/credential-presentation/session.ts ***/
 export type CreateSessionRequest = v.InferOutput<typeof CreateSessionRequestValidator>;
 export declare const CreateSessionRequestValidator: v.ObjectSchema<{
     readonly credentialQuery: v.ArraySchema<v.ObjectSchema<{

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

@@ -308,12 +308,14 @@ export type HandleRedirectCallbackResponse = {
  */
 export type InitialiseOptions = {
     apiBaseUrl: string;
+    applicationId?: string;
     digitalCredentialsApiProtocol?: string;
     enableDigitalCredentialsApiSameDeviceFlow?: boolean;
     enableDigitalCredentialsApiCrossDeviceFlow?: boolean;
 };
 export declare const InitialiseOptionsValidator: v.ObjectSchema<{
     readonly apiBaseUrl: v.StringSchema<undefined>;
+    readonly applicationId: v.OptionalSchema<v.StringSchema<undefined>, never>;
     readonly enableDigitalCredentialsApiSameDeviceFlow: v.OptionalSchema<v.BooleanSchema<undefined>, never>;
     readonly enableDigitalCredentialsApiCrossDeviceFlow: v.OptionalSchema<v.BooleanSchema<undefined>, never>;
 }, undefined>;

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

@@ -1,6 +1,6 @@
 import { Result } from "neverthrow";
 import { SafeFetchValidateRespondError } from "../common/safeFetch";
-import { CreateSessionRequest, CreateSessionResponse, ExchangeSessionResultResponse, CreateDigitalCredentialsApiSessionResponse } from "./types";
+import { CreateSessionRequest, CreateSessionResponse, ExchangeSessionResultResponse, InitialiseOptions, CreateDigitalCredentialsApiSessionResponse } from "./types";
 /**
  * Generates a challenge string using the window.crypto API.
  *
@@ -22,12 +22,11 @@ export declare const getHashParamValue: (hash: string, param: string) => string
  * @param challenge - The challenge for the session.
  * @param redirectUri - The redirect URI for the session.
  * @param apiBaseUrl - The base URL of the API.
- * @param walletProviderId - The ID of the wallet provider.
+ * @param applicationId - optional, The ID of the verifier application, if not provided the default application ID will be used.
+ * @param walletProviderId - optional, The ID of the wallet provider, if not provided the default wallet provider will be used.
  * @returns A promise that resolves to a result containing either the created session response or an error.
  */
-export declare const createSession: ({ credentialQuery, challenge, redirectUri, apiBaseUrl, walletProviderId, }: CreateSessionRequest & {
-    apiBaseUrl: string;
-}) => Promise<Result<CreateSessionResponse, SafeFetchValidateRespondError>>;
+export declare const createSession: ({ credentialQuery, challenge, redirectUri, apiBaseUrl, applicationId, walletProviderId, }: CreateSessionRequest & InitialiseOptions) => Promise<Result<CreateSessionResponse, SafeFetchValidateRespondError>>;
 /**
  * Exchange the result of a session using the provided parameters.
  *
@@ -77,9 +76,10 @@ export declare const createDigitalCredentialsApiSession: ({ credentialQuery, cha
  * @param apiBaseUrl - The base URL of the API.
  * @returns A promise that resolves to a result containing either the session result response or an error.
  */
-export declare const getDigitalCredentialsApiSessionResult: ({ challenge, sessionId, response, apiBaseUrl, }: {
+export declare const getDigitalCredentialsApiSessionResult: ({ challenge, sessionId, response, apiBaseUrl, protocol, }: {
     challenge: string;
     sessionId: string;
     response: any;
     apiBaseUrl: string;
+    protocol: string;
 }) => Promise<Result<any, SafeFetchValidateRespondError>>;

package/dist/verifier-js.development.js

@@ -7,8 +7,8 @@
  * Do Not Translate or Localize
  *
  * Bundle of @mattrglobal/verifier-sdk-web
- * Generated: 2025-02-18
- * Version: 2.0.0-preview-digital-credential-api.3
+ * Generated: 2025-03-25
+ * Version: 2.0.0-preview-digital-credential-api.4
  * Dependencies:
  *
  * neverthrow -- 4.3.0
@@ -426,6 +426,73 @@
     };
     ResultAsync.fromPromise;
     ResultAsync.fromSafePromise;
+    function _arrayLikeToArray(r, a) {
+        (null == a || a > r.length) && (a = r.length);
+        for (var e = 0, n = Array(a); e < a; e++) n[e] = r[e];
+        return n;
+    }
+    function _arrayWithoutHoles(r) {
+        if (Array.isArray(r)) return _arrayLikeToArray(r);
+    }
+    function _createForOfIteratorHelper(r, e) {
+        var t = "undefined" != typeof Symbol && r[Symbol.iterator] || r["@@iterator"];
+        if (!t) {
+            if (Array.isArray(r) || (t = _unsupportedIterableToArray(r)) || e && r && "number" == typeof r.length) {
+                t && (r = t);
+                var n = 0, F = function() {};
+                return {
+                    s: F,
+                    n: function() {
+                        return n >= r.length ? {
+                            done: !0
+                        } : {
+                            done: !1,
+                            value: r[n++]
+                        };
+                    },
+                    e: function(r) {
+                        throw r;
+                    },
+                    f: F
+                };
+            }
+            throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
+        }
+        var o, a = !0, u = !1;
+        return {
+            s: function() {
+                t = t.call(r);
+            },
+            n: function() {
+                var r = t.next();
+                return a = r.done, r;
+            },
+            e: function(r) {
+                u = !0, o = r;
+            },
+            f: function() {
+                try {
+                    a || null == t.return || t.return();
+                } finally {
+                    if (u) throw o;
+                }
+            }
+        };
+    }
+    function _defineProperty(e, r, t) {
+        return (r = _toPropertyKey(r)) in e ? Object.defineProperty(e, r, {
+            value: t,
+            enumerable: !0,
+            configurable: !0,
+            writable: !0
+        }) : e[r] = t, e;
+    }
+    function _iterableToArray(r) {
+        if ("undefined" != typeof Symbol && null != r[Symbol.iterator] || null != r["@@iterator"]) return Array.from(r);
+    }
+    function _nonIterableSpread() {
+        throw new TypeError("Invalid attempt to spread non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
+    }
     function ownKeys(e, r) {
         var t = Object.keys(e);
         if (Object.getOwnPropertySymbols) {
@@ -447,6 +514,23 @@
         }
         return e;
     }
+    function _toConsumableArray(r) {
+        return _arrayWithoutHoles(r) || _iterableToArray(r) || _unsupportedIterableToArray(r) || _nonIterableSpread();
+    }
+    function _toPrimitive(t, r) {
+        if ("object" != typeof t || !t) return t;
+        var e = t[Symbol.toPrimitive];
+        if (void 0 !== e) {
+            var i = e.call(t, r || "default");
+            if ("object" != typeof i) return i;
+            throw new TypeError("@@toPrimitive must return a primitive value.");
+        }
+        return ("string" === r ? String : Number)(t);
+    }
+    function _toPropertyKey(t) {
+        var i = _toPrimitive(t, "string");
+        return "symbol" == typeof i ? i : i + "";
+    }
     function _typeof(o) {
         "@babel/helpers - typeof";
         return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function(o) {
@@ -455,107 +539,12 @@
             return o && "function" == typeof Symbol && o.constructor === Symbol && o !== Symbol.prototype ? "symbol" : typeof o;
         }, _typeof(o);
     }
-    function _defineProperty(obj, key, value) {
-        key = _toPropertyKey(key);
-        if (key in obj) {
-            Object.defineProperty(obj, key, {
-                value: value,
-                enumerable: true,
-                configurable: true,
-                writable: true
-            });
-        } else {
-            obj[key] = value;
+    function _unsupportedIterableToArray(r, a) {
+        if (r) {
+            if ("string" == typeof r) return _arrayLikeToArray(r, a);
+            var t = {}.toString.call(r).slice(8, -1);
+            return "Object" === t && r.constructor && (t = r.constructor.name), "Map" === t || "Set" === t ? Array.from(r) : "Arguments" === t || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(t) ? _arrayLikeToArray(r, a) : void 0;
         }
-        return obj;
-    }
-    function _toConsumableArray(arr) {
-        return _arrayWithoutHoles(arr) || _iterableToArray(arr) || _unsupportedIterableToArray(arr) || _nonIterableSpread();
-    }
-    function _arrayWithoutHoles(arr) {
-        if (Array.isArray(arr)) return _arrayLikeToArray(arr);
-    }
-    function _iterableToArray(iter) {
-        if (typeof Symbol !== "undefined" && iter[Symbol.iterator] != null || iter["@@iterator"] != null) return Array.from(iter);
-    }
-    function _unsupportedIterableToArray(o, minLen) {
-        if (!o) return;
-        if (typeof o === "string") return _arrayLikeToArray(o, minLen);
-        var n = Object.prototype.toString.call(o).slice(8, -1);
-        if (n === "Object" && o.constructor) n = o.constructor.name;
-        if (n === "Map" || n === "Set") return Array.from(o);
-        if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen);
-    }
-    function _arrayLikeToArray(arr, len) {
-        if (len == null || len > arr.length) len = arr.length;
-        for (var i = 0, arr2 = new Array(len); i < len; i++) arr2[i] = arr[i];
-        return arr2;
-    }
-    function _nonIterableSpread() {
-        throw new TypeError("Invalid attempt to spread non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
-    }
-    function _createForOfIteratorHelper(o, allowArrayLike) {
-        var it = typeof Symbol !== "undefined" && o[Symbol.iterator] || o["@@iterator"];
-        if (!it) {
-            if (Array.isArray(o) || (it = _unsupportedIterableToArray(o)) || allowArrayLike && o && typeof o.length === "number") {
-                if (it) o = it;
-                var i = 0;
-                var F = function() {};
-                return {
-                    s: F,
-                    n: function() {
-                        if (i >= o.length) return {
-                            done: true
-                        };
-                        return {
-                            done: false,
-                            value: o[i++]
-                        };
-                    },
-                    e: function(e) {
-                        throw e;
-                    },
-                    f: F
-                };
-            }
-            throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
-        }
-        var normalCompletion = true, didErr = false, err;
-        return {
-            s: function() {
-                it = it.call(o);
-            },
-            n: function() {
-                var step = it.next();
-                normalCompletion = step.done;
-                return step;
-            },
-            e: function(e) {
-                didErr = true;
-                err = e;
-            },
-            f: function() {
-                try {
-                    if (!normalCompletion && it.return != null) it.return();
-                } finally {
-                    if (didErr) throw err;
-                }
-            }
-        };
-    }
-    function _toPrimitive(input, hint) {
-        if (typeof input !== "object" || input === null) return input;
-        var prim = input[Symbol.toPrimitive];
-        if (prim !== undefined) {
-            var res = prim.call(input, hint || "default");
-            if (typeof res !== "object") return res;
-            throw new TypeError("@@toPrimitive must return a primitive value.");
-        }
-        return (hint === "string" ? String : Number)(input);
-    }
-    function _toPropertyKey(arg) {
-        var key = _toPrimitive(arg, "string");
-        return typeof key === "symbol" ? key : String(key);
     }
     var store;
     function getGlobalConfig(config2) {
@@ -1274,6 +1263,9 @@
     (function(MobileCredentialVerificationReasonType) {
         MobileCredentialVerificationReasonType["Expired"] = "expired";
         MobileCredentialVerificationReasonType["Inactive"] = "inactive";
+        MobileCredentialVerificationReasonType["StatusRevoked"] = "invalid";
+        MobileCredentialVerificationReasonType["StatusSuspended"] = "suspended";
+        MobileCredentialVerificationReasonType["StatusUnknown"] = "unknown";
     })(exports.MobileCredentialVerificationReasonType || (exports.MobileCredentialVerificationReasonType = {}));
     exports.ClaimType = void 0;
     (function(ClaimType) {
@@ -1387,6 +1379,7 @@
     })(exports.RequestCredentialsErrorType || (exports.RequestCredentialsErrorType = {}));
     const InitialiseOptionsValidator = object({
         apiBaseUrl: string(),
+        applicationId: optional(string()),
         enableDigitalCredentialsApiSameDeviceFlow: optional(_boolean()),
         enableDigitalCredentialsApiCrossDeviceFlow: optional(_boolean())
     });
@@ -1449,12 +1442,14 @@
         const urlParams = new URLSearchParams(hash.split("#")[1]);
         return urlParams.get(param);
     };
-    const createSession = async ({credentialQuery: credentialQuery, challenge: challenge, redirectUri: redirectUri, apiBaseUrl: apiBaseUrl, walletProviderId: walletProviderId}) => {
-        const postData = Object.assign(Object.assign({
+    const createSession = async ({credentialQuery: credentialQuery, challenge: challenge, redirectUri: redirectUri, apiBaseUrl: apiBaseUrl, applicationId: applicationId, walletProviderId: walletProviderId}) => {
+        const postData = Object.assign(Object.assign(Object.assign({
             credentialQuery: credentialQuery,
             challenge: challenge
         }, redirectUri ? {
             redirectUri: redirectUri
+        } : {}), applicationId ? {
+            applicationId: applicationId
         } : {}), walletProviderId ? {
             walletProviderId: walletProviderId
         } : {});
@@ -1527,7 +1522,7 @@
         }, protocol && {
             protocol: protocol
         });
-        const responseResult = await safeFetch(`${apiBaseUrl}/v2/presentations/sessions/browserApi/request`, {
+        const responseResult = await safeFetch(`${apiBaseUrl}/v2/presentations/sessions/web/request`, {
             method: "POST",
             headers: {
                 "Content-Type": "application/json"
@@ -1546,13 +1541,14 @@
         }
         return ok(data);
     };
-    const getDigitalCredentialsApiSessionResult = async ({challenge: challenge, sessionId: sessionId, response: response, apiBaseUrl: apiBaseUrl}) => {
+    const getDigitalCredentialsApiSessionResult = async ({challenge: challenge, sessionId: sessionId, response: response, apiBaseUrl: apiBaseUrl, protocol: protocol}) => {
         const postData = {
             challenge: challenge,
             sessionId: sessionId,
-            response: response
+            response: response,
+            protocol: protocol
         };
-        const fetchResultFn = async () => await safeFetch(`${apiBaseUrl}/v2/presentations/sessions/browserApi/response`, {
+        const fetchResultFn = async () => await safeFetch(`${apiBaseUrl}/v2/presentations/sessions/web/response`, {
             method: "POST",
             headers: {
                 "Content-Type": "application/json"
@@ -1662,16 +1658,18 @@
         modalContainer.appendChild(style);
         modalContainer.appendChild(iframe);
         document.body.appendChild(modalContainer);
-        modalContainer.setAttribute("style", "background: rgba(0, 0, 0, 0.5) !important; position: fixed !important; top: 0 !important; left: 0 !important; width: 100% !important; height: 100% !important;");
+        modalContainer.setAttribute("style", "background: rgba(0, 0, 0, 0.5) !important; position: fixed !important; top: 0 !important; left: 0 !important; width: 100% !important; height: 100% !important; z-index: 999;");
+        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} = initialiseOptions;
+        const {apiBaseUrl: apiBaseUrl, applicationId: applicationId} = initialiseOptions;
         const createSessionResult = await createSession({
             credentialQuery: credentialQuery,
             challenge: challenge,
             apiBaseUrl: apiBaseUrl,
+            applicationId: applicationId,
             walletProviderId: walletProviderId
         });
         if (createSessionResult.isErr()) {
@@ -1705,7 +1703,7 @@
     })(SameDeviceRequestCredentialsErrorMessage$1 || (SameDeviceRequestCredentialsErrorMessage$1 = {}));
     const requestCredentialsSameDevice = async options => {
         const {challenge: challenge, credentialQuery: credentialQuery, redirectUri: redirectUri, walletProviderId: walletProviderId, initialiseOptions: initialiseOptions} = options;
-        const {apiBaseUrl: apiBaseUrl} = initialiseOptions;
+        const {apiBaseUrl: apiBaseUrl, applicationId: applicationId} = initialiseOptions;
         window.localStorage.setItem(LocalStorageKey.challenge, challenge);
         const storedChallenge = window.localStorage.getItem(LocalStorageKey.challenge);
         if (!storedChallenge) {
@@ -1719,6 +1717,7 @@
             challenge: storedChallenge,
             redirectUri: redirectUri,
             apiBaseUrl: apiBaseUrl,
+            applicationId: applicationId,
             walletProviderId: walletProviderId
         });
         if (createSessionResult.isErr()) {
@@ -1785,7 +1784,8 @@
             challenge: challenge,
             sessionId: sessionId,
             response: response,
-            apiBaseUrl: apiBaseUrl
+            apiBaseUrl: apiBaseUrl,
+            protocol: digitalCredentialsApiProtocol !== null && digitalCredentialsApiProtocol !== void 0 ? digitalCredentialsApiProtocol : "preview"
         });
         if (result.isOk()) {
             return ok({