@pagopa/io-wallet-oid4vci 2.0.0-apt → 2.0.0-launchpad

package/dist/index.js

@@ -30,7 +30,6 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 // src/index.ts
 var index_exports = {};
 __export(index_exports, {
-  CREDENTIAL_OFFER_GRANTS: () => CREDENTIAL_OFFER_GRANTS,
   CreateCredentialResponseError: () => CreateCredentialResponseError,
   CredentialAuthorizationHeaderError: () => CredentialAuthorizationHeaderError,
   CredentialOfferError: () => CredentialOfferError,
@@ -286,91 +285,6 @@ async function sendAuthorizationResponseAndExtractCode(options) {
   }
 }
 
-// src/credential-offer/APTITUDE/z-credential-offer.ts
-var import_zod2 = require("zod");
-var zTxCodePreAuthorizedCodeGrantAPTITUDE = import_zod2.z.object({
-  /**
-   * OPTIONAL. String containing guidance for the Holder
-   * of the Wallet on how to obtain the Transaction Code.
-   */
-  description: import_zod2.z.string().max(300).optional(),
-  /**
-   * OPTIONAL. String specifying the input character set.
-   * Possible values are numeric (only digits) and text (any characters).
-   * The default is numeric.
-   */
-  input_mode: import_zod2.z.enum(["numeric", "digit"]).optional(),
-  /**
-   * OPTIONAL. Integer specifying the length of the Transaction Code.
-   */
-  length: import_zod2.z.number().optional()
-});
-var zAuthorizationCodeGrantAPTITUDE = import_zod2.z.object({
-  /**
-   * CONDITIONALLY REQUIRED. HTTPS URL of the Authorization Server.
-   * REQUIRED only when the Credential Issuer uses multiple Authorization Servers.
-   * If present, MUST match one of the authorization_servers in the Credential Issuer metadata.
-   */
-  authorization_server: import_zod2.z.url().optional(),
-  /**
-   * OPTIONAL. String value representing the issuer state.
-   * Used to correlate the authorization request with the credential offer.
-   */
-  issuer_state: import_zod2.z.string().optional()
-});
-var zPreAuthorizedCodeGrantAPTITUDE = import_zod2.z.object({
-  /**
-   * CONDITIONALLY REQUIRED. HTTPS URL of the Authorization Server.
-   * REQUIRED only when the Credential Issuer uses multiple Authorization Servers.
-   * If present, MUST match one of the authorization_servers in the Credential Issuer metadata.
-   */
-  authorization_server: import_zod2.z.url().optional(),
-  /**
-   * REQUIRED. The code representing the Credential Issuer's authorization for
-   * the Wallet to obtain Credentials of a certain type
-   */
-  "pre-authorized_code": import_zod2.z.string(),
-  /**
-   * OPTIONAL. Object indicating that a Transaction Code is required if present, even if empty.
-   * It describes the requirements for a Transaction Code, which the Authorization Server expects
-   * the End-User to present along with the Token Request in a Pre-Authorized Code Flow.
-   * If the Authorization Server does not expect a Transaction Code, this object is absent;
-   */
-  tx_code: zTxCodePreAuthorizedCodeGrantAPTITUDE.optional()
-});
-var zCredentialOfferGrantsAPTITUDE = import_zod2.z.object({
-  /**
-   * OPTIONAL. Authorization Code grant details.
-   */
-  authorization_code: zAuthorizationCodeGrantAPTITUDE.optional(),
-  /**
-   * OPTIONAL. Pre-Authorized Code grant details.
-   */
-  "urn:ietf:params:oauth:grant-type:pre-authorized_code": zPreAuthorizedCodeGrantAPTITUDE.optional()
-});
-var zCredentialOfferAPTITUDE = import_zod2.z.object({
-  /**
-   * REQUIRED. Array of credential configuration identifiers.
-   * References the types of credentials offered as defined in the Credential Issuer metadata.
-   */
-  credential_configuration_ids: import_zod2.z.array(import_zod2.z.string()).min(1),
-  /**
-   * REQUIRED. HTTPS URL of the Credential Issuer.
-   * The Credential Issuer from which the wallet will request credentials.
-   */
-  credential_issuer: import_zod2.z.url(),
-  /**
-   * REQUIRED. Grant information for the credential offer.
-   * IT-Wallet v1.4 requires authorization_code or pre-auhorized code grant.
-   */
-  grants: zCredentialOfferGrantsAPTITUDE
-});
-var CREDENTIAL_OFFER_GRANTS = /* @__PURE__ */ ((CREDENTIAL_OFFER_GRANTS2) => {
-  CREDENTIAL_OFFER_GRANTS2["AUTHORIZATION_CODE"] = "authorization_code";
-  CREDENTIAL_OFFER_GRANTS2["PREAUTHORIZED_CODE"] = "urn:ietf:params:oauth:grant-type:pre-authorized_code";
-  return CREDENTIAL_OFFER_GRANTS2;
-})(CREDENTIAL_OFFER_GRANTS || {});
-
 // src/credential-offer/extract-grant-details.ts
 var import_io_wallet_utils3 = require("@pagopa/io-wallet-utils");
 function requireAuthorizationCodeGrant(credentialOffer) {
@@ -383,70 +297,33 @@ function requireAuthorizationCodeGrant(credentialOffer) {
   }
   return authCodeGrant;
 }
-function requireAuthorizationCodeOrPreAuthorizedCodeGrant(credentialOffer) {
-  if (!credentialOffer.grants) {
-    throw new CredentialOfferError("No grants found in credential offer");
-  }
-  const grants = credentialOffer.grants;
-  if (!grants["authorization_code" /* AUTHORIZATION_CODE */] && !grants["urn:ietf:params:oauth:grant-type:pre-authorized_code" /* PREAUTHORIZED_CODE */]) {
-    throw new CredentialOfferError(
-      "either one of authorization_code or pre-authorized code grant is required"
-    );
-  }
-  return grants;
-}
 function extractGrantDetailsV1_3(options) {
   const authCodeGrant = requireAuthorizationCodeGrant(options.credentialOffer);
   return {
-    ["authorization_code" /* AUTHORIZATION_CODE */]: {
+    authorizationCodeGrant: {
       authorizationServer: authCodeGrant.authorization_server,
       issuerState: authCodeGrant.issuer_state,
       scope: authCodeGrant.scope
-    }
+    },
+    grantType: "authorization_code"
   };
 }
 function extractGrantDetailsV1_4(options) {
   const authCodeGrant = requireAuthorizationCodeGrant(options.credentialOffer);
   return {
-    ["authorization_code" /* AUTHORIZATION_CODE */]: {
+    authorizationCodeGrant: {
       authorizationServer: authCodeGrant.authorization_server,
       issuerState: authCodeGrant.issuer_state
-    }
-  };
-}
-function extractGrantDetailsAPTITUDE(options) {
-  const grants = requireAuthorizationCodeOrPreAuthorizedCodeGrant(
-    options.credentialOffer
-  );
-  const authorizationCodeGrant = grants["authorization_code" /* AUTHORIZATION_CODE */];
-  const preAuthorizedCodeGrant = grants["urn:ietf:params:oauth:grant-type:pre-authorized_code" /* PREAUTHORIZED_CODE */];
-  return {
-    ...authorizationCodeGrant && {
-      ["authorization_code" /* AUTHORIZATION_CODE */]: {
-        authorizationServer: authorizationCodeGrant.authorization_server,
-        issuerState: authorizationCodeGrant.issuer_state
-      }
     },
-    ...preAuthorizedCodeGrant && {
-      ["urn:ietf:params:oauth:grant-type:pre-authorized_code" /* PREAUTHORIZED_CODE */]: {
-        authorizationServer: preAuthorizedCodeGrant.authorization_server,
-        preAuthorizedCode: preAuthorizedCodeGrant["pre-authorized_code"],
-        txCode: preAuthorizedCodeGrant.tx_code
-      }
-    }
+    grantType: "authorization_code"
   };
 }
 var dispatchExtractGrantDetails = (0, import_io_wallet_utils3.createVersionDispatcher)({
-  [import_io_wallet_utils3.ItWalletSpecsVersion.APTITUDE]: (o) => extractGrantDetailsAPTITUDE(o),
   [import_io_wallet_utils3.ItWalletSpecsVersion.V1_0]: () => {
     throw new import_io_wallet_utils3.ItWalletSpecsVersionError(
       "extractGrantDetails",
       import_io_wallet_utils3.ItWalletSpecsVersion.V1_0,
-      [
-        import_io_wallet_utils3.ItWalletSpecsVersion.V1_3,
-        import_io_wallet_utils3.ItWalletSpecsVersion.V1_4,
-        import_io_wallet_utils3.ItWalletSpecsVersion.APTITUDE
-      ]
+      [import_io_wallet_utils3.ItWalletSpecsVersion.V1_3, import_io_wallet_utils3.ItWalletSpecsVersion.V1_4]
     );
   },
   [import_io_wallet_utils3.ItWalletSpecsVersion.V1_3]: (o) => extractGrantDetailsV1_3(o),
@@ -457,46 +334,46 @@ function extractGrantDetails(options) {
 }
 
 // src/credential-offer/z-credential-offer.ts
-var import_zod5 = require("zod");
+var import_zod4 = require("zod");
 
 // src/credential-offer/v1.3/z-credential-offer.ts
-var import_zod3 = require("zod");
-var zAuthorizationCodeGrantV1_3 = import_zod3.z.object({
+var import_zod2 = require("zod");
+var zAuthorizationCodeGrantV1_3 = import_zod2.z.object({
   /**
    * CONDITIONALLY REQUIRED. HTTPS URL of the Authorization Server.
    * REQUIRED only when the Credential Issuer uses multiple Authorization Servers.
    * If present, MUST match one of the authorization_servers in the Credential Issuer metadata.
    */
-  authorization_server: import_zod3.z.url().optional(),
+  authorization_server: import_zod2.z.url().optional(),
   /**
    * OPTIONAL. String value representing the issuer state.
    * Used to correlate the authorization request with the credential offer.
    */
-  issuer_state: import_zod3.z.string().optional(),
+  issuer_state: import_zod2.z.string().optional(),
   /**
    * REQUIRED. OAuth 2.0 scope value.
    * Defines the scope of access requested by the credential offer.
    */
-  scope: import_zod3.z.string()
+  scope: import_zod2.z.string()
 });
-var zCredentialOfferGrantsV1_3 = import_zod3.z.object({
+var zCredentialOfferGrantsV1_3 = import_zod2.z.object({
   /**
    * REQUIRED. Authorization Code grant details.
    * IT-Wallet v1.3 only supports authorization_code grant.
    */
   authorization_code: zAuthorizationCodeGrantV1_3
 });
-var zCredentialOfferV1_3 = import_zod3.z.object({
+var zCredentialOfferV1_3 = import_zod2.z.object({
   /**
    * REQUIRED. Array of credential configuration identifiers.
    * References the types of credentials offered as defined in the Credential Issuer metadata.
    */
-  credential_configuration_ids: import_zod3.z.array(import_zod3.z.string()).min(1),
+  credential_configuration_ids: import_zod2.z.array(import_zod2.z.string()).min(1),
   /**
    * REQUIRED. HTTPS URL of the Credential Issuer.
    * The Credential Issuer from which the wallet will request credentials.
    */
-  credential_issuer: import_zod3.z.url(),
+  credential_issuer: import_zod2.z.url(),
   /**
    * REQUIRED. Grant information for the credential offer.
    * IT-Wallet v1.3 requires authorization_code grant.
@@ -505,38 +382,38 @@ var zCredentialOfferV1_3 = import_zod3.z.object({
 });
 
 // src/credential-offer/v1.4/z-credential-offer.ts
-var import_zod4 = require("zod");
-var zAuthorizationCodeGrantV1_4 = import_zod4.z.object({
+var import_zod3 = require("zod");
+var zAuthorizationCodeGrantV1_4 = import_zod3.z.object({
   /**
    * CONDITIONALLY REQUIRED. HTTPS URL of the Authorization Server.
    * REQUIRED only when the Credential Issuer uses multiple Authorization Servers.
    * If present, MUST match one of the authorization_servers in the Credential Issuer metadata.
    */
-  authorization_server: import_zod4.z.url().optional(),
+  authorization_server: import_zod3.z.url().optional(),
   /**
    * OPTIONAL. String value representing the issuer state.
    * Used to correlate the authorization request with the credential offer.
    */
-  issuer_state: import_zod4.z.string().optional()
+  issuer_state: import_zod3.z.string().optional()
 });
-var zCredentialOfferGrantsV1_4 = import_zod4.z.object({
+var zCredentialOfferGrantsV1_4 = import_zod3.z.object({
   /**
    * REQUIRED. Authorization Code grant details.
    * IT-Wallet v1.4 only supports authorization_code grant.
    */
   authorization_code: zAuthorizationCodeGrantV1_4
 });
-var zCredentialOfferV1_4 = import_zod4.z.object({
+var zCredentialOfferV1_4 = import_zod3.z.object({
   /**
    * REQUIRED. Array of credential configuration identifiers.
    * References the types of credentials offered as defined in the Credential Issuer metadata.
    */
-  credential_configuration_ids: import_zod4.z.array(import_zod4.z.string()).min(1),
+  credential_configuration_ids: import_zod3.z.array(import_zod3.z.string()).min(1),
   /**
    * REQUIRED. HTTPS URL of the Credential Issuer.
    * The Credential Issuer from which the wallet will request credentials.
    */
-  credential_issuer: import_zod4.z.url(),
+  credential_issuer: import_zod3.z.url(),
   /**
    * REQUIRED. Grant information for the credential offer.
    * IT-Wallet v1.4 requires authorization_code grant.
@@ -545,22 +422,22 @@ var zCredentialOfferV1_4 = import_zod4.z.object({
 });
 
 // src/credential-offer/z-credential-offer.ts
-var zCredentialOfferUri = import_zod5.z.object({
+var zCredentialOfferUri = import_zod4.z.object({
   /**
    * OPTIONAL. Inline credential offer JSON (by value).
    * URL-encoded JSON string containing the credential offer.
    */
-  credential_offer: import_zod5.z.string().optional(),
+  credential_offer: import_zod4.z.string().optional(),
   /**
    * OPTIONAL. URL pointing to the credential offer JSON (by reference).
    * HTTPS URL where the credential offer can be fetched.
    */
-  credential_offer_uri: import_zod5.z.url().optional(),
+  credential_offer_uri: import_zod4.z.url().optional(),
   /**
    * URL scheme used for the credential offer.
    * Determines the invocation method.
    */
-  scheme: import_zod5.z.enum(["openid-credential-offer", "haip-vci", "https"])
+  scheme: import_zod4.z.enum(["openid-credential-offer", "haip-vci", "https"])
 }).refine((data) => data.credential_offer || data.credential_offer_uri, {
   message: "Either credential_offer or credential_offer_uri must be present"
 });
@@ -605,17 +482,11 @@ function parseCredentialOfferForVersion(config, data) {
       return zCredentialOfferV1_3.parse(data);
     case import_io_wallet_utils4.ItWalletSpecsVersion.V1_4:
       return zCredentialOfferV1_4.parse(data);
-    case import_io_wallet_utils4.ItWalletSpecsVersion.APTITUDE:
-      return zCredentialOfferAPTITUDE.parse(data);
     default:
       throw new import_io_wallet_utils4.ItWalletSpecsVersionError(
         "resolveCredentialOffer",
         config.itWalletSpecsVersion,
-        [
-          import_io_wallet_utils4.ItWalletSpecsVersion.V1_3,
-          import_io_wallet_utils4.ItWalletSpecsVersion.V1_4,
-          import_io_wallet_utils4.ItWalletSpecsVersion.APTITUDE
-        ]
+        [import_io_wallet_utils4.ItWalletSpecsVersion.V1_3, import_io_wallet_utils4.ItWalletSpecsVersion.V1_4]
       );
   }
 }
@@ -682,7 +553,7 @@ function assertAuthorizationServerAllowed(authorizationServer, authorizationServ
   }
 }
 function validateBaseCredentialOffer(options) {
-  const { credentialOffer, versionLabel } = options;
+  const { credentialIssuerMetadata, credentialOffer, versionLabel } = options;
   if (!credentialOffer.credential_issuer.startsWith("https://")) {
     throw new CredentialOfferError("credential_issuer must be an HTTPS URL");
   }
@@ -696,11 +567,6 @@ function validateBaseCredentialOffer(options) {
       `grants is REQUIRED for IT-Wallet ${versionLabel}`
     );
   }
-}
-async function validateCredentialOfferV1_3(options) {
-  const versionLabel = "v1.3";
-  const { credentialIssuerMetadata, credentialOffer } = options;
-  validateBaseCredentialOffer({ credentialOffer, versionLabel });
   const authCodeGrant = credentialOffer.grants.authorization_code;
   if (!authCodeGrant) {
     throw new CredentialOfferError(
@@ -711,57 +577,30 @@ async function validateCredentialOfferV1_3(options) {
     authCodeGrant.authorization_server,
     credentialIssuerMetadata?.authorization_servers
   );
+}
+async function validateCredentialOfferV1_3(options) {
+  validateBaseCredentialOffer({
+    credentialIssuerMetadata: options.credentialIssuerMetadata,
+    credentialOffer: options.credentialOffer,
+    versionLabel: "v1.3"
+  });
   if (!options.credentialOffer.grants.authorization_code.scope) {
     throw new CredentialOfferError("authorization_code.scope is REQUIRED");
   }
 }
 async function validateCredentialOfferV1_4(options) {
-  const versionLabel = "v1.4";
-  const { credentialIssuerMetadata, credentialOffer } = options;
-  validateBaseCredentialOffer({ credentialOffer, versionLabel });
-  const authCodeGrant = credentialOffer.grants.authorization_code;
-  if (!authCodeGrant) {
-    throw new CredentialOfferError(
-      `authorization_code grant is REQUIRED for IT-Wallet ${versionLabel}`
-    );
-  }
-  assertAuthorizationServerAllowed(
-    authCodeGrant.authorization_server,
-    credentialIssuerMetadata?.authorization_servers
-  );
-}
-async function validateCredentialOfferAPTITUDE(options) {
-  const versionLabel = "APTITUDE";
-  const {
-    credentialIssuerMetadata,
-    credentialOffer,
-    grantType = "authorization_code" /* AUTHORIZATION_CODE */
-  } = options;
-  validateBaseCredentialOffer({ credentialOffer, versionLabel });
-  const grant = credentialOffer.grants[grantType];
-  if (!grant) {
-    throw new CredentialOfferError(
-      `${grantType} grant as specified is REQUIRED for IT-Wallet ${versionLabel}`
-    );
-  }
-  assertAuthorizationServerAllowed(
-    grant.authorization_server,
-    credentialIssuerMetadata?.authorization_servers
-  );
+  validateBaseCredentialOffer({
+    credentialIssuerMetadata: options.credentialIssuerMetadata,
+    credentialOffer: options.credentialOffer,
+    versionLabel: "v1.4"
+  });
 }
 var dispatchValidateCredentialOffer = (0, import_io_wallet_utils5.createVersionDispatcher)({
-  [import_io_wallet_utils5.ItWalletSpecsVersion.APTITUDE]: (o) => validateCredentialOfferAPTITUDE(
-    o
-  ),
   [import_io_wallet_utils5.ItWalletSpecsVersion.V1_0]: () => {
     throw new import_io_wallet_utils5.ItWalletSpecsVersionError(
       "validateCredentialOffer",
       import_io_wallet_utils5.ItWalletSpecsVersion.V1_0,
-      [
-        import_io_wallet_utils5.ItWalletSpecsVersion.V1_3,
-        import_io_wallet_utils5.ItWalletSpecsVersion.V1_4,
-        import_io_wallet_utils5.ItWalletSpecsVersion.APTITUDE
-      ]
+      [import_io_wallet_utils5.ItWalletSpecsVersion.V1_3, import_io_wallet_utils5.ItWalletSpecsVersion.V1_4]
     );
   },
   [import_io_wallet_utils5.ItWalletSpecsVersion.V1_3]: (o) => validateCredentialOfferV1_3(o),
@@ -778,18 +617,18 @@ var import_io_wallet_utils8 = require("@pagopa/io-wallet-utils");
 var import_io_wallet_utils6 = require("@pagopa/io-wallet-utils");
 
 // src/credential-request/v1.0/z-credential.ts
-var import_zod7 = require("zod");
+var import_zod6 = require("zod");
 
 // src/credential-request/z-base-credential-request.ts
-var import_zod6 = require("zod");
-var zBaseCredentialRequest = import_zod6.z.object({
-  credential_configuration_id: import_zod6.z.string().optional().describe(
+var import_zod5 = require("zod");
+var zBaseCredentialRequest = import_zod5.z.object({
+  credential_configuration_id: import_zod5.z.string().optional().describe(
     "REQUIRED if credential_identifier param is absent. MUST NOT be used otherwise."
   ),
-  credential_identifier: import_zod6.z.string().optional().describe(
+  credential_identifier: import_zod5.z.string().optional().describe(
     "REQUIRED when Authorization Details of type openid_credential was returned. MUST NOT be used if credential_configuration_id is present."
   ),
-  transaction_id: import_zod6.z.string().optional().describe(
+  transaction_id: import_zod5.z.string().optional().describe(
     "REQUIRED only in case of deferred flow. MUST NOT be present in immediate flow."
   )
 });
@@ -811,9 +650,9 @@ function credentialRequestRefiner(data, ctx) {
 }
 
 // src/credential-request/v1.0/z-credential.ts
-var zCredentialRequestProof = import_zod7.z.object({
-  jwt: import_zod7.z.string().min(1, "JWT must not be empty"),
-  proof_type: import_zod7.z.literal("jwt")
+var zCredentialRequestProof = import_zod6.z.object({
+  jwt: import_zod6.z.string().min(1, "JWT must not be empty"),
+  proof_type: import_zod6.z.literal("jwt")
   // MUST be "jwt"
 });
 var zCredentialRequestV1_0 = zBaseCredentialRequest.extend({
@@ -862,10 +701,10 @@ var createCredentialRequest = async (options) => {
 var import_io_wallet_utils7 = require("@pagopa/io-wallet-utils");
 
 // src/credential-request/v1.3/z-credential.ts
-var import_zod8 = require("zod");
-var zCredentialRequestProofJwt = import_zod8.z.string().min(1, "JWT must not be empty in credential request proofs array");
-var zCredentialRequestProofs = import_zod8.z.object({
-  jwt: import_zod8.z.tuple([zCredentialRequestProofJwt], zCredentialRequestProofJwt)
+var import_zod7 = require("zod");
+var zCredentialRequestProofJwt = import_zod7.z.string().min(1, "JWT must not be empty in credential request proofs array");
+var zCredentialRequestProofs = import_zod7.z.object({
+  jwt: import_zod7.z.tuple([zCredentialRequestProofJwt], zCredentialRequestProofJwt)
 });
 var zCredentialRequestV1_3 = zBaseCredentialRequest.extend({
   proofs: zCredentialRequestProofs.describe(
@@ -949,7 +788,6 @@ var createCredentialRequest2 = async (options) => {
 
 // src/credential-request/create-credential-request.ts
 var dispatchCreateCredentialRequest = (0, import_io_wallet_utils8.createVersionDispatcher)({
-  [import_io_wallet_utils8.ItWalletSpecsVersion.APTITUDE]: (o) => createCredentialRequest2(o),
   [import_io_wallet_utils8.ItWalletSpecsVersion.V1_0]: (o) => createCredentialRequest(o),
   [import_io_wallet_utils8.ItWalletSpecsVersion.V1_3]: (o) => createCredentialRequest2(o),
   [import_io_wallet_utils8.ItWalletSpecsVersion.V1_4]: (o) => (
@@ -968,21 +806,21 @@ var import_io_wallet_utils10 = require("@pagopa/io-wallet-utils");
 
 // src/credential-request/z-proof-jwt.ts
 var import_io_wallet_utils9 = require("@pagopa/io-wallet-utils");
-var import_zod9 = require("zod");
-var zBaseProofJwtHeader = import_zod9.z.object({
-  alg: import_zod9.z.string().min(1),
+var import_zod8 = require("zod");
+var zBaseProofJwtHeader = import_zod8.z.object({
+  alg: import_zod8.z.string().min(1),
   jwk: import_io_wallet_utils9.zJwk,
-  typ: import_zod9.z.literal("openid4vci-proof+jwt")
+  typ: import_zod8.z.literal("openid4vci-proof+jwt")
 });
 var zProofJwtHeaderV1_0 = zBaseProofJwtHeader.loose();
 var zProofJwtHeaderV1_3 = zBaseProofJwtHeader.extend({
-  key_attestation: import_zod9.z.string().min(1)
+  key_attestation: import_zod8.z.string().min(1)
 }).loose();
-var zProofJwtPayload = import_zod9.z.looseObject({
-  aud: import_zod9.z.string().min(1),
-  iat: import_zod9.z.number(),
-  iss: import_zod9.z.string().min(1).optional(),
-  nonce: import_zod9.z.string().min(1)
+var zProofJwtPayload = import_zod8.z.looseObject({
+  aud: import_zod8.z.string().min(1),
+  iat: import_zod8.z.number(),
+  iss: import_zod8.z.string().min(1).optional(),
+  nonce: import_zod8.z.string().min(1)
 });
 
 // src/credential-request/parse-credential-request.ts
@@ -1225,25 +1063,7 @@ function parseCredentialRequestV1_4(options) {
     // V1_4 reuses V1_3 proof schema
   });
 }
-function parseCredentialRequestAPTITUDE(options) {
-  const credentialRequest = (0, import_io_wallet_utils10.parseWithErrorHandling)(
-    zCredentialRequestV1_3,
-    options.credentialRequest,
-    "Invalid credential request format for ItWalletSpecsVersion APTITUDE"
-  );
-  return toResult({
-    accessToken: options.accessToken,
-    callbacks: options.callbacks,
-    credentialRequest,
-    dpopProof: options.dpopProof,
-    expected: options.expected,
-    grantType: options.grantType,
-    isDeferredFlow: options.isDeferredFlow,
-    itWalletSpecsVersion: import_io_wallet_utils10.ItWalletSpecsVersion.APTITUDE
-  });
-}
 var dispatchParseCredentialRequest = (0, import_io_wallet_utils10.createVersionDispatcher)({
-  [import_io_wallet_utils10.ItWalletSpecsVersion.APTITUDE]: parseCredentialRequestAPTITUDE,
   [import_io_wallet_utils10.ItWalletSpecsVersion.V1_0]: parseCredentialRequestV1_0,
   [import_io_wallet_utils10.ItWalletSpecsVersion.V1_3]: parseCredentialRequestV1_3,
   [import_io_wallet_utils10.ItWalletSpecsVersion.V1_4]: parseCredentialRequestV1_4
@@ -1281,33 +1101,33 @@ var import_io_wallet_utils12 = require("@pagopa/io-wallet-utils");
 // src/wallet-provider/z-key-attestation.ts
 var import_io_wallet_oid_federation = require("@pagopa/io-wallet-oid-federation");
 var import_io_wallet_utils11 = require("@pagopa/io-wallet-utils");
-var import_zod10 = require("zod");
-var zStatusList = import_zod10.z.object({
-  idx: import_zod10.z.number(),
-  uri: import_zod10.z.url()
+var import_zod9 = require("zod");
+var zStatusList = import_zod9.z.object({
+  idx: import_zod9.z.number(),
+  uri: import_zod9.z.url()
 });
-var zKeyAttestationStatus = import_zod10.z.object({
+var zKeyAttestationStatus = import_zod9.z.object({
   status_list: zStatusList
 });
 var zKeyAttestationAlg = import_io_wallet_utils11.zItwSupportedSignatureAlg;
-var zKeyAttestationHeader = import_zod10.z.object({
+var zKeyAttestationHeader = import_zod9.z.object({
   alg: zKeyAttestationAlg,
-  kid: import_zod10.z.string(),
+  kid: import_zod9.z.string(),
   trust_chain: import_io_wallet_utils11.zTrustChain.optional(),
-  typ: import_zod10.z.literal("key-attestation+jwt"),
+  typ: import_zod9.z.literal("key-attestation+jwt"),
   x5c: import_io_wallet_utils11.zCertificateChain
 });
-var zKeyAttestationPayload = import_zod10.z.object({
-  attested_keys: import_zod10.z.array(import_io_wallet_utils11.zJwk).nonempty(),
-  certification: import_zod10.z.string().optional(),
-  exp: import_zod10.z.number(),
-  iat: import_zod10.z.number(),
-  iss: import_zod10.z.string(),
-  key_storage: import_zod10.z.array(import_io_wallet_oid_federation.zKeyStorageLevelV1_3).nonempty(),
+var zKeyAttestationPayload = import_zod9.z.object({
+  attested_keys: import_zod9.z.array(import_io_wallet_utils11.zJwk).nonempty(),
+  certification: import_zod9.z.string().optional(),
+  exp: import_zod9.z.number(),
+  iat: import_zod9.z.number(),
+  iss: import_zod9.z.string(),
+  key_storage: import_zod9.z.array(import_io_wallet_oid_federation.zKeyStorageLevelV1_3).nonempty(),
   status: zKeyAttestationStatus,
-  user_authentication: import_zod10.z.array(import_io_wallet_oid_federation.zKeyStorageLevelV1_3).nonempty()
+  user_authentication: import_zod9.z.array(import_io_wallet_oid_federation.zKeyStorageLevelV1_3).nonempty()
 });
-var zKeyAttestationTypeHeader = import_zod10.z.literal("key-attestation+jwt");
+var zKeyAttestationTypeHeader = import_zod9.z.literal("key-attestation+jwt");
 var keyAttestationTypeHeader = zKeyAttestationTypeHeader.value;
 
 // src/credential-request/verify-key-attestation-jwt.ts
@@ -1458,7 +1278,6 @@ async function verifyProofV1_3(options) {
   return { header, keyAttestation: keyAttestationResult, payload, signer };
 }
 var dispatchVerifyProof = (0, import_io_wallet_utils13.createVersionDispatcher)({
-  [import_io_wallet_utils13.ItWalletSpecsVersion.APTITUDE]: (o) => verifyProofV1_3(o),
   [import_io_wallet_utils13.ItWalletSpecsVersion.V1_0]: (o) => verifyProofV1_0(o),
   [import_io_wallet_utils13.ItWalletSpecsVersion.V1_3]: (o) => verifyProofV1_3(o),
   [import_io_wallet_utils13.ItWalletSpecsVersion.V1_4]: (o) => verifyProofV1_3(o)
@@ -1490,30 +1309,30 @@ var import_io_wallet_utils16 = require("@pagopa/io-wallet-utils");
 var import_io_wallet_utils14 = require("@pagopa/io-wallet-utils");
 
 // src/credential-response/v1.0/z-credential-response.ts
-var import_zod12 = require("zod");
+var import_zod11 = require("zod");
 
 // src/credential-response/z-immediate-credential-response.ts
-var import_zod11 = require("zod");
-var zCredentialObject = import_zod11.z.object({
-  credential: import_zod11.z.string()
+var import_zod10 = require("zod");
+var zCredentialObject = import_zod10.z.object({
+  credential: import_zod10.z.string()
 });
-var zImmediateCredentialResponse = import_zod11.z.strictObject({
-  credentials: import_zod11.z.array(zCredentialObject).nonempty().describe(
+var zImmediateCredentialResponse = import_zod10.z.strictObject({
+  credentials: import_zod10.z.array(zCredentialObject).nonempty().describe(
     "Conditional. Array of issued Digital Credentials as JSON objects with `credential` member containing encoded credential string. Present for immediate issuance (HTTP 200)."
   ),
-  notification_id: import_zod11.z.string().optional().describe(
+  notification_id: import_zod10.z.string().optional().describe(
     "OPTIONAL. Identifier for notification requests. Only present with credentials parameter."
   )
 });
 
 // src/credential-response/v1.0/z-credential-response.ts
-var zDeferredCredentialResponseV1_0 = import_zod12.z.strictObject({
-  lead_time: import_zod12.z.number().int().positive().describe(
+var zDeferredCredentialResponseV1_0 = import_zod11.z.strictObject({
+  lead_time: import_zod11.z.number().int().positive().describe(
     "REQUIRED if credentials is not present, otherwise it MUST NOT be present. The amount of time (in seconds) required before making a Deferred Credential Request."
   ),
-  transaction_id: import_zod12.z.string().nonempty()
+  transaction_id: import_zod11.z.string().nonempty()
 });
-var zCredentialResponseV1_0 = import_zod12.z.union([
+var zCredentialResponseV1_0 = import_zod11.z.union([
   zImmediateCredentialResponse,
   zDeferredCredentialResponseV1_0
 ]);
@@ -1546,14 +1365,14 @@ function createCredentialResponseV1_0(flow) {
 var import_io_wallet_utils15 = require("@pagopa/io-wallet-utils");
 
 // src/credential-response/v1.3/z-credential-response.ts
-var import_zod13 = require("zod");
-var zDeferredCredentialResponseV1_3 = import_zod13.z.strictObject({
-  interval: import_zod13.z.number().int().positive().describe(
+var import_zod12 = require("zod");
+var zDeferredCredentialResponseV1_3 = import_zod12.z.strictObject({
+  interval: import_zod12.z.number().int().positive().describe(
     "REQUIRED if transaction_id is present, otherwise it MUST NOT be present. The amount of time (in seconds) required before making a Deferred Credential Request"
   ),
-  transaction_id: import_zod13.z.string().nonempty()
+  transaction_id: import_zod12.z.string().nonempty()
 });
-var zCredentialResponseV1_3 = import_zod13.z.union([
+var zCredentialResponseV1_3 = import_zod12.z.union([
   zImmediateCredentialResponse,
   zDeferredCredentialResponseV1_3
 ]);
@@ -1584,9 +1403,6 @@ function createCredentialResponseV1_3(flow) {
 
 // src/credential-response/create-credential-response.ts
 var dispatchBuildVersionedResponse = (0, import_io_wallet_utils16.createVersionDispatcher)({
-  [import_io_wallet_utils16.ItWalletSpecsVersion.APTITUDE]: (o) => createCredentialResponseV1_3(
-    o.flow
-  ),
   [import_io_wallet_utils16.ItWalletSpecsVersion.V1_0]: (o) => createCredentialResponseV1_0(
     o.flow
   ),
@@ -1646,10 +1462,10 @@ var import_io_wallet_utils18 = require("@pagopa/io-wallet-utils");
 
 // src/credential-response/z-credential-response.ts
 var import_io_wallet_utils17 = require("@pagopa/io-wallet-utils");
-var import_zod14 = require("zod");
-var zCredentialResponseEncryption = import_zod14.z.looseObject({
+var import_zod13 = require("zod");
+var zCredentialResponseEncryption = import_zod13.z.looseObject({
   alg: import_io_wallet_utils17.zAlgValueNotNone,
-  enc: import_zod14.z.string(),
+  enc: import_zod13.z.string(),
   jwk: import_io_wallet_utils17.zJwk
 });
 
@@ -1696,37 +1512,37 @@ async function fetchCredentialResponse(options) {
 // src/metadata/fetch-metadata.ts
 var import_io_wallet_oid_federation3 = require("@pagopa/io-wallet-oid-federation");
 var import_io_wallet_utils19 = require("@pagopa/io-wallet-utils");
-var import_zod16 = __toESM(require("zod"));
+var import_zod15 = __toESM(require("zod"));
 
 // src/metadata/z-metadata-response.ts
 var import_io_wallet_oid_federation2 = require("@pagopa/io-wallet-oid-federation");
-var import_zod15 = require("zod");
-var zMetadataResponseV1_0 = import_zod15.z.object({
-  discoveredVia: import_zod15.z.enum(["federation"]),
+var import_zod14 = require("zod");
+var zMetadataResponseV1_0 = import_zod14.z.object({
+  discoveredVia: import_zod14.z.enum(["federation"]),
   metadata: import_io_wallet_oid_federation2.itWalletMetadataV1_0,
   openid_federation_claims: import_io_wallet_oid_federation2.itWalletEntityStatementClaimsSchema
 });
-var zMetadataResponseV1_3 = import_zod15.z.object({
+var zMetadataResponseV1_3 = import_zod14.z.object({
   /**
    * Entity statement claims of the Authorization Server, present only when the
    * selected authorization server was resolved through a federation entity
    * distinct from the Credential Issuer.
    */
   authorization_server_federation_claims: import_io_wallet_oid_federation2.itWalletEntityStatementClaimsSchema.optional(),
-  discoveredVia: import_zod15.z.enum(["federation", "oid4vci"]),
+  discoveredVia: import_zod14.z.enum(["federation", "oid4vci"]),
   metadata: import_io_wallet_oid_federation2.itWalletMetadataV1_3,
   openid_federation_claims: import_io_wallet_oid_federation2.itWalletEntityStatementClaimsSchema.optional()
 });
 var zMetadataResponseV1_4 = zMetadataResponseV1_3.extend({
   metadata: import_io_wallet_oid_federation2.itWalletMetadataV1_4
 });
-var zMetadataResponse = import_zod15.z.union([
+var zMetadataResponse = import_zod14.z.union([
   zMetadataResponseV1_0,
   zMetadataResponseV1_3,
   zMetadataResponseV1_4
 ]);
-var zPartialIssuerMetadata = import_zod15.z.looseObject({
-  authorization_servers: import_zod15.z.tuple([import_zod15.z.url()], import_zod15.z.url()).optional()
+var zPartialIssuerMetadata = import_zod14.z.looseObject({
+  authorization_servers: import_zod14.z.tuple([import_zod14.z.url()], import_zod14.z.url()).optional()
 });
 
 // src/metadata/fetch-metadata.ts
@@ -1793,7 +1609,7 @@ async function applyFederationAuthorizationServerSelection(fetch, federationResu
   if (!selectedAuthorizationServer || selectedAuthorizationServer === credentialIssuer) {
     return federationResult;
   }
-  const parsedSelectedAuthorizationServer = import_zod16.default.url().safeParse(selectedAuthorizationServer);
+  const parsedSelectedAuthorizationServer = import_zod15.default.url().safeParse(selectedAuthorizationServer);
   if (!parsedSelectedAuthorizationServer.success || !parsedSelectedAuthorizationServer.data.startsWith("https://")) {
     throw new import_io_wallet_utils19.ValidationError(
       "selected authorization server is not a valid HTTPS URL"
@@ -1831,7 +1647,7 @@ async function fallbackDiscovery(fetch, baseUrl, authorizationServer) {
   let oauthAuthorizationServer;
   if (authorizationServers && authorizationServers.length > 0) {
     const selectedAuthorizationServer = authorizationServer ?? authorizationServers[0];
-    const parsedUrl = import_zod16.default.url().safeParse(selectedAuthorizationServer);
+    const parsedUrl = import_zod15.default.url().safeParse(selectedAuthorizationServer);
     if (!parsedUrl.success || !parsedUrl.data.startsWith("https://")) {
       throw new import_io_wallet_utils19.ValidationError(
         "selected authorization server is not a valid HTTPS URL"
@@ -1909,14 +1725,13 @@ async function fetchMetadataV1_4(options) {
   );
 }
 var dispatchFetchMetadata = (0, import_io_wallet_utils19.createVersionDispatcher)({
-  [import_io_wallet_utils19.ItWalletSpecsVersion.APTITUDE]: (o) => fetchMetadataV1_4(o),
   [import_io_wallet_utils19.ItWalletSpecsVersion.V1_0]: (o) => fetchMetadataV1_0(o),
   [import_io_wallet_utils19.ItWalletSpecsVersion.V1_3]: (o) => fetchMetadataV1_3(o),
   [import_io_wallet_utils19.ItWalletSpecsVersion.V1_4]: (o) => fetchMetadataV1_4(o)
 });
 async function fetchMetadata(options) {
   try {
-    const urlValidation = import_zod16.default.url().safeParse(options.credentialIssuerUrl);
+    const urlValidation = import_zod15.default.url().safeParse(options.credentialIssuerUrl);
     if (!urlValidation.success || !urlValidation.data.startsWith("https://")) {
       throw new import_io_wallet_utils19.ValidationError(
         "credentialIssuerUrl must be a valid HTTPS URL"
@@ -2068,7 +1883,7 @@ var WalletProvider = class {
    *   status: { status_list: { idx: 2, uri: "https://status.example.com" } } // Optional
    * });
    *
-   * @example v1.4, APTITUDE - Wallet attestation with required wallet_link and wallet_name
+   * @example v1.4 - Wallet attestation with required wallet_link and wallet_name
    * const jwt = await provider.createItWalletAttestationJwt({
    *   callbacks: { hash: myHashCallback, signJwt: mySignJwtCallback },
    *   dpopJwkPublic: myJwk,
@@ -2087,18 +1902,6 @@ var WalletProvider = class {
    */
   async createItWalletAttestationJwt(options) {
     return (0, import_io_wallet_utils20.dispatchByVersion)(this.specVersion, {
-      [import_io_wallet_utils20.ItWalletSpecsVersion.APTITUDE]: () => {
-        assertV1_4Options(options);
-        return (0, import_io_wallet_oauth23.createWalletAttestationJwtV1_4)({
-          callbacks: options.callbacks,
-          dpopJwkPublic: options.dpopJwkPublic,
-          expiresAt: options.expiresAt,
-          issuer: options.issuer,
-          signer: options.signer,
-          walletLink: options.walletLink,
-          walletName: options.walletName
-        });
-      },
       [import_io_wallet_utils20.ItWalletSpecsVersion.V1_0]: () => {
         assertV1_0Options(options);
         return (0, import_io_wallet_oauth23.createWalletAttestationJwtV1_0)({
@@ -2143,7 +1946,6 @@ var WalletProvider = class {
 };
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
-  CREDENTIAL_OFFER_GRANTS,
   CreateCredentialResponseError,
   CredentialAuthorizationHeaderError,
   CredentialOfferError,