@openid4vc/openid4vp 0.3.0-alpha-20250224151429 → 0.3.0-alpha-20250225103926

package/dist/index.js

@@ -36,7 +36,6 @@ __export(src_exports, {
   createOpenid4vpAuthorizationResponse: () => createOpenid4vpAuthorizationResponse,
   isJarmResponseMode: () => isJarmResponseMode,
   isOpenid4vpAuthorizationRequestDcApi: () => isOpenid4vpAuthorizationRequestDcApi,
-  isOpenid4vpAuthorizationResponseDcApi: () => isOpenid4vpAuthorizationResponseDcApi,
   parseJarmAuthorizationResponse: () => parseJarmAuthorizationResponse,
   parseOpenid4vpAuthorizationRequestPayload: () => parseOpenid4vpAuthorizationRequestPayload,
   parseOpenid4vpAuthorizationResponse: () => parseOpenid4vpAuthorizationResponse,
@@ -52,7 +51,6 @@ __export(src_exports, {
   zCredentialFormat: () => zCredentialFormat,
   zJarmClientMetadata: () => zJarmClientMetadata,
   zOpenid4vpAuthorizationResponse: () => zOpenid4vpAuthorizationResponse,
-  zOpenid4vpAuthorizationResponseDcApi: () => zOpenid4vpAuthorizationResponseDcApi,
   zProofFormat: () => zProofFormat,
   zWalletMetadata: () => zWalletMetadata
 });
@@ -99,16 +97,16 @@ var zJarmAuthResponseEncryptedOnly = import_zod2.z.object({
 
 // src/jarm/jarm-auth-response/jarm-validate-auth-response.ts
 var jarmAuthResponseValidate = (options) => {
-  const { authRequest, authResponse } = options;
-  if (!zJarmAuthResponse.safeParse(authResponse).success) {
+  const { clientId, authorizationResponse } = options;
+  if (!zJarmAuthResponse.safeParse(authorizationResponse).success) {
     return;
   }
-  if (authRequest.client_id !== authResponse.aud) {
+  if (clientId !== authorizationResponse.aud) {
     throw new import_oauth22.Oauth2Error(
-      `Invalid 'aud' claim in JARM authorization response. Expected '${authRequest.client_id}' received '${JSON.stringify(authResponse.aud)}'.`
+      `Invalid 'aud' claim in JARM authorization response. Expected '${clientId}' received '${JSON.stringify(authorizationResponse.aud)}'.`
     );
   }
-  if (authResponse.exp !== void 0 && authResponse.exp < (0, import_utils.dateToSeconds)()) {
+  if (authorizationResponse.exp !== void 0 && authorizationResponse.exp < (0, import_utils.dateToSeconds)()) {
     throw new import_oauth22.Oauth2Error("Jarm auth response is expired.");
   }
 };
@@ -155,18 +153,14 @@ async function verifyJarmAuthorizationResponse(options) {
     const jsonRequestData = JSON.parse(decryptedRequestData);
     jarmAuthResponse = zJarmAuthResponseEncryptedOnly.parse(jsonRequestData);
   }
-  const { authRequest } = await callbacks.getOpenid4vpAuthorizationRequest(jarmAuthResponse);
-  jarmAuthResponseValidate({ authRequest, authResponse: jarmAuthResponse });
-  let type;
-  if (responseIsSigned && requestDataIsEncrypted) {
-    type = "signed encrypted";
-  } else if (requestDataIsEncrypted) {
-    type = "encrypted";
-  } else {
-    type = "signed";
-  }
+  const { authorizationRequest } = await callbacks.getOpenid4vpAuthorizationRequest(jarmAuthResponse);
+  jarmAuthResponseValidate({
+    clientId: authorizationRequest.client_id,
+    authorizationResponse: jarmAuthResponse
+  });
+  const type = requestDataIsEncrypted && responseIsSigned ? "SignedEncrypted" /* SignedEncrypted */ : requestDataIsEncrypted ? "Encrypted" /* Encrypted */ : "Signed" /* Signed */;
   const issuer = jarmAuthResponse.iss;
-  return { authRequest, jarmAuthResponse, type, issuer };
+  return { authorizationRequest, jarmAuthResponse, type, issuer };
 }
 
 // src/jarm/metadata/z-jarm-client-metadata.ts
@@ -243,7 +237,7 @@ var import_utils6 = require("@openid4vc/utils");
 // src/jar/create-jar-auth-request.ts
 var import_oauth25 = require("@openid4vc/oauth2");
 async function createJarAuthRequest(options) {
-  const { jwtSigner, jwtEncryptor, authRequestParams, requestUri, callbacks } = options;
+  const { jwtSigner, jweEncryptor, authRequestParams, requestUri, callbacks } = options;
   let requestObjectJwt;
   let encryptionJwk;
   const { jwt, signerJwk } = await callbacks.signJwt(jwtSigner, {
@@ -251,8 +245,8 @@ async function createJarAuthRequest(options) {
     payload: { ...options.additionalJwtPayload, ...authRequestParams }
   });
   requestObjectJwt = jwt;
-  if (jwtEncryptor) {
-    const encryptionResult = await callbacks.encryptJwe(jwtEncryptor, requestObjectJwt);
+  if (jweEncryptor) {
+    const encryptionResult = await callbacks.encryptJwe(jweEncryptor, requestObjectJwt);
     requestObjectJwt = encryptionResult.jwe;
     encryptionJwk = encryptionResult.encryptionJwk;
   }
@@ -526,36 +520,36 @@ function isJarAuthRequest(request) {
 
 // src/authorization-request/parse-authorization-request-params.ts
 function parseOpenid4vpAuthorizationRequestPayload(options) {
-  const { requestPayload } = options;
+  const { authorizationRequest } = options;
   let provided = "params";
   let params;
-  if (typeof requestPayload === "string") {
-    if (requestPayload.includes("://")) {
-      const url = new import_utils8.URL(requestPayload);
+  if (typeof authorizationRequest === "string") {
+    if (authorizationRequest.includes("://")) {
+      const url = new import_utils8.URL(authorizationRequest);
       params = Object.fromEntries(url.searchParams);
       provided = "uri";
     } else {
-      const decoded = (0, import_oauth211.decodeJwt)({ jwt: requestPayload });
+      const decoded = (0, import_oauth211.decodeJwt)({ jwt: authorizationRequest });
       params = decoded.payload;
       provided = "jwt";
     }
   } else {
-    params = requestPayload;
+    params = authorizationRequest;
   }
   const parsedRequest = (0, import_utils9.parseWithErrorHandling)(
     import_zod10.default.union([zOpenid4vpAuthorizationRequest, zJarAuthRequest, zOpenid4vpAuthorizationRequestDcApi]),
     params
   );
-  if (isOpenid4vpAuthorizationRequestDcApi(parsedRequest)) {
+  if (isJarAuthRequest(parsedRequest)) {
     return {
-      type: "openid4vp_dc_api",
+      type: "jar",
       provided,
       params: parsedRequest
     };
   }
-  if (isJarAuthRequest(parsedRequest)) {
+  if (isOpenid4vpAuthorizationRequestDcApi(parsedRequest)) {
     return {
-      type: "jar",
+      type: "openid4vp_dc_api",
       provided,
       params: parsedRequest
     };
@@ -574,35 +568,26 @@ var import_zod14 = __toESM(require("zod"));
 
 // src/client-identifier-scheme/parse-client-identifier-scheme.ts
 var import_oauth212 = require("@openid4vc/oauth2");
-function getClientId(request, origin) {
-  const isDcApiRequest = isOpenid4vpAuthorizationRequestDcApi(request);
-  if (isDcApiRequest) {
-    if (request.client_id) {
-      return request.client_id;
-    }
-    if (!origin) {
+function getClientId(options) {
+  if (isOpenid4vpAuthorizationRequestDcApi(options.request)) {
+    if (!options.origin) {
       throw new import_oauth212.Oauth2ServerErrorResponseError({
         error: import_oauth212.Oauth2ErrorCodes.InvalidRequest,
-        error_description: 'Failed to parse client identifier. Missing required "client_id" parameter.'
+        error_description: "Failed to parse client identifier. 'origin' is required for requests with response_mode 'dc_api' and 'dc_api.jwt'"
       });
     }
-    return `web-origin:${origin}`;
+    if (!options.jar || !options.request.client_id) return `web-origin:${options.origin}`;
+    return options.request.client_id;
   }
-  return request.client_id;
+  return options.request.client_id;
 }
 function parseClientIdentifier(options, parserConfig) {
   const { request, jar } = options;
   const isDcApiRequest = isOpenid4vpAuthorizationRequestDcApi(request);
-  const clientId = getClientId(request, options.origin);
+  const clientId = getClientId(options);
   const parserConfigWithDefaults = {
     supportedSchemes: parserConfig?.supportedSchemes || Object.values(zClientIdScheme.options)
   };
-  if (isDcApiRequest && !jar && request.client_id) {
-    throw new import_oauth212.Oauth2ServerErrorResponseError({
-      error: import_oauth212.Oauth2ErrorCodes.InvalidRequest,
-      error_description: `The 'client_id' parameter MUST be omitted in unsigned openid4vp dc api authorization requests.`
-    });
-  }
   const colonIndex = clientId.indexOf(":");
   if (colonIndex === -1) {
     return {
@@ -628,7 +613,7 @@ function parseClientIdentifier(options, parserConfig) {
         error_description: `The client identifier scheme 'https' is not supported when using the dc_api response mode.`
       });
     }
-    if (!clientId.startsWith("https://") && !clientId.startsWith("http://")) {
+    if (!clientId.startsWith("https://") && !((0, import_oauth212.getGlobalConfig)().allowInsecureUrls && clientId.startsWith("http://"))) {
       throw new import_oauth212.Oauth2ServerErrorResponseError({
         error: import_oauth212.Oauth2ErrorCodes.InvalidRequest,
         error_description: "Invalid client identifier. Client identifier must start with https:// or http:// if allowInsecureUrls is true."
@@ -690,7 +675,7 @@ function parseClientIdentifier(options, parserConfig) {
       scheme,
       identifier: clientId,
       originalValue: clientId,
-      kid: jar.signer.publicJwk.kid
+      didUrl: jar.signer.publicJwk.kid
     };
   }
   if (scheme === "x509_san_dns" || scheme === "x509_san_uri") {
@@ -706,7 +691,17 @@ function parseClientIdentifier(options, parserConfig) {
         error_description: "Something went wrong. The JWT signer method is not x5c but the client identifier scheme is x509_san_dns."
       });
     }
-    if (scheme === "x509_san_dns" && options.callbacks.getX509CertificateMetadata) {
+    if (scheme === "x509_san_dns") {
+      if (!options.callbacks.getX509CertificateMetadata) {
+        throw new import_oauth212.Oauth2ServerErrorResponseError(
+          {
+            error: import_oauth212.Oauth2ErrorCodes.ServerError
+          },
+          {
+            internalMessage: "Missing required 'getX509CertificateMetadata' callback for verification of 'x509_san_dns' client id scheme"
+          }
+        );
+      }
       const { sanDnsNames } = options.callbacks.getX509CertificateMetadata(jar.signer.x5c[0]);
       if (!sanDnsNames.includes(identifierPart)) {
         throw new import_oauth212.Oauth2ServerErrorResponseError({
@@ -721,7 +716,17 @@ function parseClientIdentifier(options, parserConfig) {
           error_description: "Invalid client identifier. The fully qualified domain name of the redirect_uri value MUST match the Client Identifier without the prefix x509_san_dns."
         });
       }
-    } else if (scheme === "x509_san_uri" && options.callbacks.getX509CertificateMetadata) {
+    } else if (scheme === "x509_san_uri") {
+      if (!options.callbacks.getX509CertificateMetadata) {
+        throw new import_oauth212.Oauth2ServerErrorResponseError(
+          {
+            error: import_oauth212.Oauth2ErrorCodes.ServerError
+          },
+          {
+            internalMessage: "Missing required 'getX509CertificateMetadata' callback for verification of 'x509_san_uri' client id scheme"
+          }
+        );
+      }
       const { sanUriNames } = options.callbacks.getX509CertificateMetadata(jar.signer.x5c[0]);
       if (!sanUriNames.includes(identifierPart)) {
         throw new import_oauth212.Oauth2ServerErrorResponseError({
@@ -1015,26 +1020,26 @@ function addSecondsToDate(date, seconds) {
 // src/jarm/jarm-auth-response-create.ts
 var import_oauth218 = require("@openid4vc/oauth2");
 async function createJarmAuthResponse(options) {
-  const { jarmAuthResponse, jwtEncryptor, jwtSigner, callbacks } = options;
-  if (!jwtSigner && jwtEncryptor) {
-    const { jwe } = await callbacks.encryptJwe(jwtEncryptor, JSON.stringify(jarmAuthResponse));
+  const { jarmAuthResponse, jweEncryptor, jwtSigner, callbacks } = options;
+  if (!jwtSigner && jweEncryptor) {
+    const { jwe } = await callbacks.encryptJwe(jweEncryptor, JSON.stringify(jarmAuthResponse));
     return { jarmAuthResponseJwt: jwe };
   }
-  if (jwtSigner && !jwtEncryptor) {
+  if (jwtSigner && !jweEncryptor) {
     const signed2 = await callbacks.signJwt(jwtSigner, {
       header: (0, import_oauth218.jwtHeaderFromJwtSigner)(jwtSigner),
       payload: jarmAuthResponse
     });
     return { jarmAuthResponseJwt: signed2.jwt };
   }
-  if (!jwtSigner || !jwtEncryptor) {
+  if (!jwtSigner || !jweEncryptor) {
     throw new import_oauth218.Oauth2Error("JWT signer and/or encryptor are required to create a JARM auth response.");
   }
   const signed = await callbacks.signJwt(jwtSigner, {
     header: (0, import_oauth218.jwtHeaderFromJwtSigner)(jwtSigner),
     payload: jarmAuthResponse
   });
-  const encrypted = await callbacks.encryptJwe(jwtEncryptor, signed.jwt);
+  const encrypted = await callbacks.encryptJwe(jweEncryptor, signed.jwt);
   return { jarmAuthResponseJwt: encrypted.jwe };
 }
 
@@ -1116,13 +1121,7 @@ async function createOpenid4vpAuthorizationResponse(options) {
   }
   if (!jarm) {
     return {
-      responseParams: openid4vpAuthResponseParams,
-      ...isOpenid4vpAuthorizationRequestDcApi(openid4vpAuthResponseParams) && {
-        dcApiResponseParams: {
-          protocol: "openid4vp",
-          data: openid4vpAuthResponseParams
-        }
-      }
+      responseParams: openid4vpAuthResponseParams
     };
   }
   if (!requestParams.client_metadata) {
@@ -1176,7 +1175,7 @@ async function createOpenid4vpAuthorizationResponse(options) {
   const result = await createJarmAuthResponse({
     jarmAuthResponse: jarmResponseParams,
     jwtSigner: jarm?.jwtSigner,
-    jwtEncryptor: jarm?.encryption && (supportedJarmMetadata.type === "encrypt" || supportedJarmMetadata.type === "sign_encrypt") ? {
+    jweEncryptor: jarm?.encryption && (supportedJarmMetadata.type === "encrypt" || supportedJarmMetadata.type === "sign_encrypt") ? {
       method: "jwk",
       publicJwk: clientMetaJwks.encJwk,
       apu: jarm.encryption?.nonce,
@@ -1191,13 +1190,7 @@ async function createOpenid4vpAuthorizationResponse(options) {
   });
   return {
     responseParams: jarmResponseParams,
-    jarm: { responseJwt: result.jarmAuthResponseJwt },
-    ...isOpenid4vpAuthorizationRequestDcApi(openid4vpAuthResponseParams) && {
-      dcApiResponseParams: {
-        protocol: "openid4vp",
-        data: jarmResponseParams
-      }
-    }
+    jarm: { responseJwt: result.jarmAuthResponseJwt }
   };
 }
 
@@ -1455,7 +1448,7 @@ var import_zod18 = require("zod");
 
 // src/vp-token/z-vp-token.ts
 var import_zod17 = require("zod");
-var zVpToken = import_zod17.z.union([import_zod17.z.string(), import_zod17.z.array(import_zod17.z.string()), import_zod17.z.record(import_zod17.z.string(), import_zod17.z.unknown())]);
+var zVpToken = import_zod17.z.union([import_zod17.z.string(), import_zod17.z.array(import_zod17.z.union([import_zod17.z.string(), import_zod17.z.record(import_zod17.z.any())])), import_zod17.z.record(import_zod17.z.any())]);
 
 // src/authorization-response/z-authorization-response.ts
 var zOpenid4vpAuthorizationResponse = import_zod18.z.object({
@@ -1469,25 +1462,8 @@ var zOpenid4vpAuthorizationResponse = import_zod18.z.object({
   expires_in: import_zod18.z.number().optional()
 }).passthrough();
 
-// src/authorization-response/z-authorization-response-dc-api.ts
-var import_zod19 = require("zod");
-var zOpenid4vpAuthorizationResponseDcApi = import_zod19.z.object({
-  protocol: import_zod19.z.literal("openid4vp"),
-  data: zOpenid4vpAuthorizationResponse
-}).passthrough();
-function isOpenid4vpAuthorizationResponseDcApi(response) {
-  return "protocol" in response && "data" in response;
-}
-
 // src/authorization-response/parse-authorization-response-payload.ts
 function parseOpenid4VpAuthorizationResponsePayload(payload) {
-  if (isOpenid4vpAuthorizationRequestDcApi(payload)) {
-    return (0, import_utils18.parseWithErrorHandling)(
-      zOpenid4vpAuthorizationResponseDcApi,
-      payload,
-      "Failed to to parse openid4vp dc_api authorization response."
-    );
-  }
   return (0, import_utils18.parseWithErrorHandling)(
     zOpenid4vpAuthorizationResponse,
     payload,
@@ -1498,30 +1474,30 @@ function parseOpenid4VpAuthorizationResponsePayload(payload) {
 // src/authorization-response/parse-jarm-authorization-response.ts
 var import_oauth226 = require("@openid4vc/oauth2");
 var import_utils19 = require("@openid4vc/utils");
-var import_zod20 = __toESM(require("zod"));
+var import_zod19 = __toESM(require("zod"));
 async function parseJarmAuthorizationResponse(options) {
   const { jarmResponseJwt, callbacks } = options;
   const jarmAuthorizationResponseJwt = (0, import_utils19.parseWithErrorHandling)(
-    import_zod20.default.union([import_oauth226.zCompactJwt, import_oauth226.zCompactJwe]),
+    import_zod19.default.union([import_oauth226.zCompactJwt, import_oauth226.zCompactJwe]),
     jarmResponseJwt,
     "Invalid jarm authorization response jwt."
   );
   const verifiedJarmResponse = await verifyJarmAuthorizationResponse({ jarmAuthorizationResponseJwt, callbacks });
-  const zJarmHeader = import_zod20.default.object({ ...import_oauth226.zJwtHeader.shape, apu: import_zod20.default.string().optional(), apv: import_zod20.default.string().optional() });
+  const zJarmHeader = import_zod19.default.object({ ...import_oauth226.zJwtHeader.shape, apu: import_zod19.default.string().optional(), apv: import_zod19.default.string().optional() });
   const { header: jarmHeader } = (0, import_oauth226.decodeJwtHeader)({
     jwt: jarmAuthorizationResponseJwt,
     headerSchema: zJarmHeader
   });
   const parsedAuthorizationRequest = parseOpenid4vpAuthorizationRequestPayload({
-    requestPayload: verifiedJarmResponse.authRequest
+    authorizationRequest: verifiedJarmResponse.authorizationRequest
   });
-  if (parsedAuthorizationRequest.type !== "openid4vp") {
+  if (parsedAuthorizationRequest.type !== "openid4vp" && parsedAuthorizationRequest.type !== "openid4vp_dc_api") {
     throw new import_oauth226.Oauth2Error("Invalid authorization request. Could not parse openid4vp authorization request.");
   }
   const authResponsePayload = parseOpenid4VpAuthorizationResponsePayload(verifiedJarmResponse.jarmAuthResponse);
   const validateOpenId4vpResponse = validateOpenid4vpAuthorizationResponse({
     authorizationRequest: parsedAuthorizationRequest.params,
-    authorizationResponse: isOpenid4vpAuthorizationResponseDcApi(authResponsePayload) ? authResponsePayload.data : authResponsePayload
+    authorizationResponse: authResponsePayload
   });
   const authRequestPayload = parsedAuthorizationRequest.params;
   if (!authRequestPayload.response_mode || !isJarmResponseMode(authRequestPayload.response_mode)) {
@@ -1554,15 +1530,15 @@ async function parseOpenid4vpAuthorizationResponse(options) {
     return parseJarmAuthorizationResponse({ jarmResponseJwt: responsePayload.response, callbacks });
   }
   const authResponsePayload = parseOpenid4VpAuthorizationResponsePayload(responsePayload);
-  const authRequest = await callbacks.getOpenid4vpAuthorizationRequest(authResponsePayload);
-  const parsedAuthRequest = parseOpenid4vpAuthorizationRequestPayload({ requestPayload: authRequest.authRequest });
+  const { authorizationRequest } = await callbacks.getOpenid4vpAuthorizationRequest(authResponsePayload);
+  const parsedAuthRequest = parseOpenid4vpAuthorizationRequestPayload({ authorizationRequest });
   if (parsedAuthRequest.type !== "openid4vp" && parsedAuthRequest.type !== "openid4vp_dc_api") {
     throw new import_oauth227.Oauth2Error("Invalid authorization request. Could not parse openid4vp authorization request.");
   }
   const authRequestPayload = parsedAuthRequest.params;
   const validateOpenId4vpResponse = validateOpenid4vpAuthorizationResponse({
     authorizationRequest: authRequestPayload,
-    authorizationResponse: isOpenid4vpAuthorizationResponseDcApi(authResponsePayload) ? authResponsePayload.data : authResponsePayload
+    authorizationResponse: authResponsePayload
   });
   if (authRequestPayload.response_mode && isJarmResponseMode(authRequestPayload.response_mode)) {
     throw new import_oauth227.Oauth2ServerErrorResponseError(
@@ -1628,22 +1604,22 @@ var Openid4vpVerifier = class {
 };
 
 // src/models/z-credential-formats.ts
-var import_zod21 = require("zod");
-var zCredentialFormat = import_zod21.z.enum(["jwt_vc_json", "ldp_vc", "ac_vc", "mso_mdoc", "dc+sd-jwt"]);
+var import_zod20 = require("zod");
+var zCredentialFormat = import_zod20.z.enum(["jwt_vc_json", "ldp_vc", "ac_vc", "mso_mdoc", "dc+sd-jwt"]);
 
 // src/models/z-proof-formats.ts
-var import_zod22 = require("zod");
-var zProofFormat = import_zod22.z.enum(["jwt_vp_json", "ldc_vp", "ac_vp", "dc+sd-jwt", "mso_mdoc"]);
+var import_zod21 = require("zod");
+var zProofFormat = import_zod21.z.enum(["jwt_vp_json", "ldc_vp", "ac_vp", "dc+sd-jwt", "mso_mdoc"]);
 
 // src/models/z-wallet-metadata.ts
-var import_zod23 = require("zod");
-var zWalletMetadata = import_zod23.z.object({
-  presentation_definition_uri_supported: import_zod23.z.optional(import_zod23.z.boolean()),
+var import_zod22 = require("zod");
+var zWalletMetadata = import_zod22.z.object({
+  presentation_definition_uri_supported: import_zod22.z.optional(import_zod22.z.boolean()),
   vp_formats_supported: zVpFormatsSupported,
-  client_id_schemes_supported: import_zod23.z.optional(import_zod23.z.array(zClientIdScheme)),
-  request_object_signing_alg_values_supported: import_zod23.z.optional(import_zod23.z.array(import_zod23.z.string())),
-  authorization_encryption_alg_values_supported: import_zod23.z.optional(import_zod23.z.array(import_zod23.z.string())),
-  authorization_encryption_enc_values_supported: import_zod23.z.optional(import_zod23.z.array(import_zod23.z.string()))
+  client_id_schemes_supported: import_zod22.z.optional(import_zod22.z.array(zClientIdScheme)),
+  request_object_signing_alg_values_supported: import_zod22.z.optional(import_zod22.z.array(import_zod22.z.string())),
+  authorization_encryption_alg_values_supported: import_zod22.z.optional(import_zod22.z.array(import_zod22.z.string())),
+  authorization_encryption_enc_values_supported: import_zod22.z.optional(import_zod22.z.array(import_zod22.z.string()))
 });
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
@@ -1653,7 +1629,6 @@ var zWalletMetadata = import_zod23.z.object({
   createOpenid4vpAuthorizationResponse,
   isJarmResponseMode,
   isOpenid4vpAuthorizationRequestDcApi,
-  isOpenid4vpAuthorizationResponseDcApi,
   parseJarmAuthorizationResponse,
   parseOpenid4vpAuthorizationRequestPayload,
   parseOpenid4vpAuthorizationResponse,
@@ -1669,7 +1644,6 @@ var zWalletMetadata = import_zod23.z.object({
   zCredentialFormat,
   zJarmClientMetadata,
   zOpenid4vpAuthorizationResponse,
-  zOpenid4vpAuthorizationResponseDcApi,
   zProofFormat,
   zWalletMetadata
 });