@pagopa/io-react-native-wallet 3.5.0 → 3.6.0

package/lib/typescript/credentials-catalogue/api/DigitalCredentialsCatalogue.d.ts

@@ -116,6 +116,7 @@ export declare const DigitalCredential: z.ZodObject<{
         logo_uri: z.ZodOptional<z.ZodString>;
         user_information: z.ZodOptional<z.ZodString>;
     }, z.core.$strip>>;
+    parent_credentials: z.ZodOptional<z.ZodArray<z.ZodString>>;
     formats: z.ZodOptional<z.ZodArray<z.ZodObject<{
         configuration_id: z.ZodString;
         format: z.ZodEnum<{
@@ -270,6 +271,7 @@ export declare const DigitalCredentialsCatalogue: z.ZodObject<{
             logo_uri: z.ZodOptional<z.ZodString>;
             user_information: z.ZodOptional<z.ZodString>;
         }, z.core.$strip>>;
+        parent_credentials: z.ZodOptional<z.ZodArray<z.ZodString>>;
         formats: z.ZodOptional<z.ZodArray<z.ZodObject<{
             configuration_id: z.ZodString;
             format: z.ZodEnum<{

package/lib/typescript/credentials-catalogue/api/DigitalCredentialsCatalogue.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"DigitalCredentialsCatalogue.d.ts","sourceRoot":"","sources":["../../../../src/credentials-catalogue/api/DigitalCredentialsCatalogue.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,CAAC,MAAM,KAAK,CAAC;AAGzB,eAAO,MAAM,gBAAgB;;;;;iBAK3B,CAAC;AACH,MAAM,MAAM,gBAAgB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,gBAAgB,CAAC,CAAC;AAEhE;;;GAGG;AACH,MAAM,MAAM,qBAAqB,GAAG,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC,CAAC;AAO3E,eAAO,MAAM,YAAY;;;iCAKF,CAAC;AAExB,MAAM,MAAM,YAAY,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,YAAY,CAAC,CAAC;AAyBxD,QAAA,MAAM,eAAe;;;;;;;;;;;iBAWnB,CAAC;AACH,MAAM,MAAM,eAAe,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,eAAe,CAAC,CAAC;AAE9D,eAAO,MAAM,gBAAgB;;;;;;;;;;iBAO3B,CAAC;AACH,MAAM,MAAM,gBAAgB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,gBAAgB,CAAC,CAAC;AAEhE,eAAO,MAAM,KAAK;;;;iBAIhB,CAAC;AAEH;;;GAGG;AACH,eAAO,MAAM,iBAAiB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBA+B5B,CAAC;AACH,MAAM,MAAM,iBAAiB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,iBAAiB,CAAC,CAAC;AAElE,QAAA,MAAM,eAAe;;;iBAGnB,CAAC;AACH,MAAM,MAAM,eAAe,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,eAAe,CAAC,CAAC;AAE9D,QAAA,MAAM,aAAa;;;;iBAIjB,CAAC;AACH,MAAM,MAAM,aAAa,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,aAAa,CAAC,CAAC;AAE1D,QAAA,MAAM,cAAc;;;;;;;;;iBAKlB,CAAC;AACH,MAAM,MAAM,cAAc,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,cAAc,CAAC,CAAC;AAE5D,eAAO,MAAM,QAAQ;;;;;;;;;;;;;;;;;;;;;;;;iBAOnB,CAAC;AACH,MAAM,MAAM,QAAQ,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,QAAQ,CAAC,CAAC;AAEhD,eAAO,MAAM,2BAA2B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAQtC,CAAC;AACH,MAAM,MAAM,2BAA2B,GAAG,CAAC,CAAC,KAAK,CAC/C,OAAO,2BAA2B,CACnC,CAAC"}
+{"version":3,"file":"DigitalCredentialsCatalogue.d.ts","sourceRoot":"","sources":["../../../../src/credentials-catalogue/api/DigitalCredentialsCatalogue.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,CAAC,MAAM,KAAK,CAAC;AAGzB,eAAO,MAAM,gBAAgB;;;;;iBAK3B,CAAC;AACH,MAAM,MAAM,gBAAgB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,gBAAgB,CAAC,CAAC;AAEhE;;;GAGG;AACH,MAAM,MAAM,qBAAqB,GAAG,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC,CAAC;AAO3E,eAAO,MAAM,YAAY;;;iCAKF,CAAC;AAExB,MAAM,MAAM,YAAY,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,YAAY,CAAC,CAAC;AAyBxD,QAAA,MAAM,eAAe;;;;;;;;;;;iBAWnB,CAAC;AACH,MAAM,MAAM,eAAe,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,eAAe,CAAC,CAAC;AAE9D,eAAO,MAAM,gBAAgB;;;;;;;;;;iBAO3B,CAAC;AACH,MAAM,MAAM,gBAAgB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,gBAAgB,CAAC,CAAC;AAEhE,eAAO,MAAM,KAAK;;;;iBAIhB,CAAC;AAEH;;;GAGG;AACH,eAAO,MAAM,iBAAiB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAgC5B,CAAC;AACH,MAAM,MAAM,iBAAiB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,iBAAiB,CAAC,CAAC;AAElE,QAAA,MAAM,eAAe;;;iBAGnB,CAAC;AACH,MAAM,MAAM,eAAe,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,eAAe,CAAC,CAAC;AAE9D,QAAA,MAAM,aAAa;;;;iBAIjB,CAAC;AACH,MAAM,MAAM,aAAa,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,aAAa,CAAC,CAAC;AAE1D,QAAA,MAAM,cAAc;;;;;;;;;iBAKlB,CAAC;AACH,MAAM,MAAM,cAAc,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,cAAc,CAAC,CAAC;AAE5D,eAAO,MAAM,QAAQ;;;;;;;;;;;;;;;;;;;;;;;;iBAOnB,CAAC;AACH,MAAM,MAAM,QAAQ,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,QAAQ,CAAC,CAAC;AAEhD,eAAO,MAAM,2BAA2B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAQtC,CAAC;AACH,MAAM,MAAM,2BAA2B,GAAG,CAAC,CAAC,KAAK,CAC/C,OAAO,2BAA2B,CACnC,CAAC"}

package/lib/typescript/credentials-catalogue/api/index.d.ts

@@ -38,7 +38,7 @@ export interface CredentialsCatalogueApi {
      * Given a statusBit (e.g. "0x00", "0x0B") and a DigitalCredential from the
      * catalogue, returns the matching l10n IDs or undefined if not found.
      * The comparison is case-insensitive to handle uppercase statusBit values
-     * returned by verifyAndParseStatusList against lowercase keys in the catalogue.
+     * returned by getStatus against lowercase keys in the catalogue.
      *
      * @since 1.0.0
      */

package/lib/typescript/credentials-catalogue/common/get-status-l10n-ids.d.ts

@@ -3,7 +3,7 @@ import { type CredentialsCatalogueApi } from "../api";
  * Given a statusBit (e.g. "0x00", "0x0B") and a DigitalCredential from the
  * catalogue, returns the matching l10n IDs or undefined if not found.
  * The comparison is case-insensitive to handle uppercase statusBit values
- * returned by verifyAndParseStatusList against lowercase keys in the catalogue.
+ * returned by getStatus against lowercase keys in the catalogue.
  */
 export declare const getStatusL10nIds: CredentialsCatalogueApi["getStatusL10nIds"];
 //# sourceMappingURL=get-status-l10n-ids.d.ts.map

package/lib/typescript/credentials-catalogue/v1.0.0/mappers.d.ts

@@ -67,6 +67,7 @@ export declare const mapToCredentialsCatalogue: (input: unknown) => {
         } | undefined;
         domains?: string[] | undefined;
         classes?: string[] | undefined;
+        parent_credentials?: string[] | undefined;
         formats?: {
             configuration_id: string;
             format: "dc+sd-jwt" | "mso_mdoc";

package/lib/typescript/credentials-catalogue/v1.0.0/mappers.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"mappers.d.ts","sourceRoot":"","sources":["../../../../src/credentials-catalogue/v1.0.0/mappers.ts"],"names":[],"mappings":"AAUA,eAAO,MAAM,yBAAyB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAwBrC,CAAC"}
+{"version":3,"file":"mappers.d.ts","sourceRoot":"","sources":["../../../../src/credentials-catalogue/v1.0.0/mappers.ts"],"names":[],"mappings":"AAUA,eAAO,MAAM,yBAAyB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAwBrC,CAAC"}

package/lib/typescript/credentials-catalogue/v1.3.3/mappers.d.ts

@@ -72,10 +72,6 @@ export declare const mapToCredentialsCatalogue: (input: [{
                     deferred_flow: boolean;
                 } | undefined;
             }[];
-            authentic_sources: {
-                id: string;
-                dataset_id: string;
-            }[];
             restriction_policy?: {
                 presentation_flows: {
                     remote: boolean;
@@ -90,6 +86,11 @@ export declare const mapToCredentialsCatalogue: (input: [{
             } | undefined;
             domains?: string[] | undefined;
             classes?: string[] | undefined;
+            authentic_sources?: {
+                id: string;
+                dataset_id: string;
+            }[] | undefined;
+            parent_credentials?: string[] | undefined;
         }[];
         iat: number;
         exp: number;
@@ -264,6 +265,7 @@ export declare const mapToCredentialsCatalogue: (input: [{
         } | undefined;
         domains?: string[] | undefined;
         classes?: string[] | undefined;
+        parent_credentials?: string[] | undefined;
         formats?: {
             configuration_id: string;
             format: "dc+sd-jwt" | "mso_mdoc";

package/lib/typescript/credentials-catalogue/v1.3.3/mappers.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"mappers.d.ts","sourceRoot":"","sources":["../../../../src/credentials-catalogue/v1.3.3/mappers.ts"],"names":[],"mappings":"AAgBA,eAAO,MAAM,yBAAyB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAkFrC,CAAC"}
+{"version":3,"file":"mappers.d.ts","sourceRoot":"","sources":["../../../../src/credentials-catalogue/v1.3.3/mappers.ts"],"names":[],"mappings":"AAgBA,eAAO,MAAM,yBAAyB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAoFrC,CAAC"}

package/lib/typescript/credentials-catalogue/v1.3.3/types.d.ts

@@ -112,10 +112,11 @@ export declare const DigitalCredential: z.ZodObject<{
             deferred_flow: z.ZodBoolean;
         }, z.core.$strip>>;
     }, z.core.$strip>>;
-    authentic_sources: z.ZodArray<z.ZodObject<{
+    authentic_sources: z.ZodOptional<z.ZodArray<z.ZodObject<{
         id: z.ZodString;
         dataset_id: z.ZodString;
-    }, z.core.$strip>>;
+    }, z.core.$strip>>>;
+    parent_credentials: z.ZodOptional<z.ZodArray<z.ZodString>>;
 }, z.core.$strip>;
 /**
  * Schema registry, available at a dedicated endpoint.
@@ -276,10 +277,11 @@ export declare const DigitalCredentialsCatalogueJwt: z.ZodObject<{
                     deferred_flow: z.ZodBoolean;
                 }, z.core.$strip>>;
             }, z.core.$strip>>;
-            authentic_sources: z.ZodArray<z.ZodObject<{
+            authentic_sources: z.ZodOptional<z.ZodArray<z.ZodObject<{
                 id: z.ZodString;
                 dataset_id: z.ZodString;
-            }, z.core.$strip>>;
+            }, z.core.$strip>>>;
+            parent_credentials: z.ZodOptional<z.ZodArray<z.ZodString>>;
         }, z.core.$strip>>;
         iat: z.ZodNumber;
         exp: z.ZodNumber;

package/lib/typescript/credentials-catalogue/v1.3.3/types.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../../../src/credentials-catalogue/v1.3.3/types.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,CAAC,MAAM,KAAK,CAAC;AAmCzB,eAAO,MAAM,eAAe;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAuB1B,CAAC;AACH,MAAM,MAAM,eAAe,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,eAAe,CAAC,CAAC;AAE9D,eAAO,MAAM,MAAM;;;;;;;;;;;;;iBAUjB,CAAC;AACH,MAAM,MAAM,MAAM,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,MAAM,CAAC,CAAC;AA6B5C,eAAO,MAAM,iBAAiB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAuC5B,CAAC;AASH;;;GAGG;AACH,eAAO,MAAM,cAAc;;;;;;;;;;;;;;;;;;iBAKzB,CAAC;AACH,MAAM,MAAM,cAAc,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,cAAc,CAAC,CAAC;AAE5D;;;GAGG;AACH,eAAO,MAAM,uBAAuB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAalC,CAAC;AACH,MAAM,MAAM,uBAAuB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,uBAAuB,CAAC,CAAC;AAE9E;;;GAGG;AACH,eAAO,MAAM,8BAA8B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAmBzC,CAAC;AACH,MAAM,MAAM,8BAA8B,GAAG,CAAC,CAAC,KAAK,CAClD,OAAO,8BAA8B,CACtC,CAAC;AAmBF,eAAO,MAAM,oBAAoB;;;;;;;;;;;;;;;;;;;;;;iBAO/B,CAAC;AACH,MAAM,MAAM,oBAAoB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,oBAAoB,CAAC,CAAC;AA6BxE;;;;GAIG;AACH,eAAO,MAAM,gBAAgB;;;;;;;;;;;;;;;;;;;;;;;;;;iBAgB3B,CAAC;AACH,MAAM,MAAM,gBAAgB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,gBAAgB,CAAC,CAAC"}
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../../../src/credentials-catalogue/v1.3.3/types.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,CAAC,MAAM,KAAK,CAAC;AAmCzB,eAAO,MAAM,eAAe;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAuB1B,CAAC;AACH,MAAM,MAAM,eAAe,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,eAAe,CAAC,CAAC;AAE9D,eAAO,MAAM,MAAM;;;;;;;;;;;;;iBAUjB,CAAC;AACH,MAAM,MAAM,MAAM,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,MAAM,CAAC,CAAC;AA6B5C,eAAO,MAAM,iBAAiB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAqC5B,CAAC;AASH;;;GAGG;AACH,eAAO,MAAM,cAAc;;;;;;;;;;;;;;;;;;iBAKzB,CAAC;AACH,MAAM,MAAM,cAAc,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,cAAc,CAAC,CAAC;AAE5D;;;GAGG;AACH,eAAO,MAAM,uBAAuB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAalC,CAAC;AACH,MAAM,MAAM,uBAAuB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,uBAAuB,CAAC,CAAC;AAE9E;;;GAGG;AACH,eAAO,MAAM,8BAA8B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAmBzC,CAAC;AACH,MAAM,MAAM,8BAA8B,GAAG,CAAC,CAAC,KAAK,CAClD,OAAO,8BAA8B,CACtC,CAAC;AAmBF,eAAO,MAAM,oBAAoB;;;;;;;;;;;;;;;;;;;;;;iBAO/B,CAAC;AACH,MAAM,MAAM,oBAAoB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,oBAAoB,CAAC,CAAC;AA6BxE;;;;GAIG;AACH,eAAO,MAAM,gBAAgB;;;;;;;;;;;;;;;;;;;;;;;;;;iBAgB3B,CAAC;AACH,MAAM,MAAM,gBAAgB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,gBAAgB,CAAC,CAAC"}

package/lib/typescript/mdoc/const.d.ts

@@ -1,2 +1,3 @@
 export declare const MDOC_DEFAULT_NAMESPACE = "org.iso.18013.5.1";
+export declare const MDOC_VERIFICATION_IDENTIFIER = "verification";
 //# sourceMappingURL=const.d.ts.map

package/lib/typescript/mdoc/const.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"const.d.ts","sourceRoot":"","sources":["../../../src/mdoc/const.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,sBAAsB,sBAAsB,CAAC"}
+{"version":3,"file":"const.d.ts","sourceRoot":"","sources":["../../../src/mdoc/const.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,sBAAsB,sBAAsB,CAAC;AAC1D,eAAO,MAAM,4BAA4B,iBAAiB,CAAC"}

package/lib/typescript/mdoc/utils.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"utils.d.ts","sourceRoot":"","sources":["../../../src/mdoc/utils.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,wBAAwB,CAAC;AAC1D,OAAO,KAAK,EAAE,GAAG,EAAE,MAAM,eAAe,CAAC;AAGzC;;;;GAIG;AACH,eAAO,MAAM,2BAA2B,GAAI,WAAW,MAAM,EAAE,KAAK,MAAM,WACnD,CAAC;AAExB;;;;;;;GAOG;AACH,eAAO,MAAM,mCAAmC,GAC9C,kBAAkB,GAAG,CACnB,WAAW,CAAC,0BAA0B,CAAC,CACxC,CAAC,kBAAkB,CAAC;;;aAQtB,CAAC;AAEF;;;;;;;GAOG;AACH,eAAO,MAAM,eAAe,GAAU,OAAO,MAAM;;;cAQlD,CAAC"}
+{"version":3,"file":"utils.d.ts","sourceRoot":"","sources":["../../../src/mdoc/utils.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,wBAAwB,CAAC;AAC1D,OAAO,KAAK,EAAE,GAAG,EAAE,MAAM,eAAe,CAAC;AAGzC;;;;GAIG;AACH,eAAO,MAAM,2BAA2B,GAAI,WAAW,MAAM,EAAE,KAAK,MAAM,WACnD,CAAC;AAExB;;;;;;;GAOG;AACH,eAAO,MAAM,mCAAmC,GAC9C,kBAAkB,GAAG,CACnB,WAAW,CAAC,0BAA0B,CAAC,CACxC,CAAC,kBAAkB,CAAC;;;aAStB,CAAC;AAEF;;;;;;;GAOG;AACH,eAAO,MAAM,eAAe,GAAU,OAAO,MAAM;;;cAUlD,CAAC"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pagopa/io-react-native-wallet",
-  "version": "3.5.0",
+  "version": "3.6.0",
   "description": "Provide data structures, helpers and API for IO Wallet",
   "main": "lib/commonjs/index",
   "module": "lib/module/index",
@@ -140,11 +140,11 @@
     ]
   },
   "dependencies": {
-    "@pagopa/io-wallet-oauth2": "1.5.2",
-    "@pagopa/io-wallet-oid-federation": "1.5.2",
-    "@pagopa/io-wallet-oid4vci": "1.5.2",
-    "@pagopa/io-wallet-oid4vp": "1.5.2",
-    "@pagopa/io-wallet-utils": "1.5.2",
+    "@pagopa/io-wallet-oauth2": "1.5.3",
+    "@pagopa/io-wallet-oid-federation": "1.5.3",
+    "@pagopa/io-wallet-oid4vci": "1.5.3",
+    "@pagopa/io-wallet-oid4vp": "1.5.3",
+    "@pagopa/io-wallet-utils": "1.5.3",
     "@sd-jwt/core": "^0.19.0",
     "@sd-jwt/crypto-nodejs": "^0.19.0",
     "@sd-jwt/jwt-status-list": "^0.19.0",

package/src/credential/issuance/api/IssuerConfig.ts

@@ -9,7 +9,7 @@ const DisplayConfig = z.object({
 
 const ClaimConfig = z.object({
   path: z.array(z.union([z.string(), z.number(), z.null()])),
-  display: z.array(DisplayConfig),
+  display: z.array(DisplayConfig).optional(),
 });
 
 const IssuanceErrorSupported = z.object({

package/src/credential/issuance/common/06-verify-and-parse-credential.mdoc.ts

@@ -13,6 +13,12 @@ import type { IssuanceApi, IssuerConfig, ParsedCredential } from "../api";
 type CredentialConf =
   IssuerConfig["credential_configurations_supported"][string];
 
+type ClaimConfig = CredentialConf["claims"][number];
+
+type DisplayableClaim = Omit<ClaimConfig, "display"> & {
+  display: NonNullable<ClaimConfig["display"]>;
+};
+
 type DecodedMDocCredential = Out<typeof verifyMdoc> & {
   issuerSigned: CBOR.IssuerSigned;
 };
@@ -75,7 +81,13 @@ const parseCredentialMDoc = (
     throw new IoWalletError("Missing claims in the credential subject");
   }
 
-  const attrDefinitions = credentialConfig.claims.map<
+  // Claims without display property (such as `iat`, `exp`, `iss`, etc.)
+  // must be ignored as they are not meant to be displayed to the user.
+  const displayableClaims = credentialConfig.claims.filter(
+    (c) => c.display !== undefined
+  ) as DisplayableClaim[];
+
+  const attrDefinitions = displayableClaims.map<
     [string, string, { name: string; locale: string }[]]
   >(({ path: [namespace, attribute], display }) => [
     namespace as string,
@@ -183,7 +195,11 @@ export const verifyAndParseCredentialMDoc: IssuanceApi["verifyAndParseCredential
     issuerConf,
     credential,
     credentialConfigurationId,
-    { credentialCryptoContext, ignoreMissingAttributes },
+    {
+      credentialCryptoContext,
+      ignoreMissingAttributes,
+      includeUndefinedAttributes,
+    },
     x509CertRoot
   ) => {
     if (!x509CertRoot) {
@@ -204,7 +220,7 @@ export const verifyAndParseCredentialMDoc: IssuanceApi["verifyAndParseCredential
       credentialConfig,
       decoded,
       ignoreMissingAttributes,
-      ignoreMissingAttributes
+      includeUndefinedAttributes
     );
 
     const { signed, validUntil } =

package/src/credential/issuance/common/06-verify-and-parse-credential.sdjwt.ts

@@ -18,6 +18,12 @@ import type { IssuanceApi, IssuerConfig, ParsedCredential } from "../api";
 type CredentialConf =
   IssuerConfig["credential_configurations_supported"][string];
 
+type ClaimConfig = CredentialConf["claims"][number];
+
+type DisplayableClaim = Omit<ClaimConfig, "display"> & {
+  display: NonNullable<ClaimConfig["display"]>;
+};
+
 /**
  * Parse a Sd-Jwt credential according to the issuer configuration
  * @param credentialConfig - the list of supported credentials, as defined in the issuer configuration with their claims metadata
@@ -32,13 +38,17 @@ const parseCredentialSdJwt = (
   ignoreMissingAttributes: boolean = false,
   includeUndefinedAttributes: boolean = false
 ): ParsedCredential => {
-  const claimsMetadata = credentialConfig.claims || [];
+  // Claims without display property (such as `iat`, `exp`, `iss`, etc.)
+  // must be ignored as they are not meant to be displayed to the user.
+  const displayableClaims = (credentialConfig.claims || []).filter(
+    (c) => c.display !== undefined
+  ) as DisplayableClaim[];
 
   // Check that all mandatory attributes defined in the issuer configuration are present in the credential
   if (!ignoreMissingAttributes) {
     const missingPaths: string[] = [];
     const rootKeysToVerify = new Set(
-      claimsMetadata
+      displayableClaims
         .map((c) => c.path[0])
         .filter((p): p is string => typeof p === "string")
     );
@@ -64,7 +74,7 @@ const parseCredentialSdJwt = (
   const getDisplayNames = (
     path: (string | number | null)[]
   ): Record<string, string> | undefined => {
-    const match = claimsMetadata.find((c) => isPathEqual(c.path, path));
+    const match = displayableClaims.find((c) => isPathEqual(c.path, path));
     if (!match) return undefined;
 
     const nameMap: Record<string, string> = {};
@@ -99,7 +109,7 @@ const parseCredentialSdJwt = (
 
     // Identify unique keys in config at this level
     const configKeysAtThisLevel: (string | number)[] = [];
-    for (const claim of claimsMetadata) {
+    for (const claim of displayableClaims) {
       // Check if the claim path starts with the current path
       if (isPrefixOf(currentPath, claim.path)) {
         const nextPart = claim.path[currentPath.length];

package/src/credential/issuance/v1.3.3/mappers.ts

@@ -25,7 +25,7 @@ const mapCredentialConfigurationsSupported = (
         claims:
           config.credential_metadata.claims?.map((claim) => ({
             path: claim.path,
-            display: claim.display ?? [],
+            display: claim.display,
           })) ?? [],
       };
       return acc;

package/src/credential/status/README.md

@@ -31,8 +31,10 @@ graph TD;
   1[verifyAndParseStatusAssertion]
   2[getStatusList]
   3[verifyAndParseStatusList]
+  4[getStatus]
   0 --> 1
   2 --> 3
+  3 --> 4
 ```
 
 ## Mapped results
@@ -104,24 +106,24 @@ const credentialIssuerUrl = "https://issuer.example.com";
 
 const { issuerConf } = await wallet.CredentialIssuance.evaluateIssuerTrust(credentialIssuerUrl);
 
-// Get the status list
-const res = await wallet.CredentialStatus.statusList.get(
-  credential,
-  format,
+// Get the status list token and credential reference index
+const { statusList: statusListJwt, idx } =
+  await wallet.CredentialStatus.statusList.get(credential, format);
+
+// Verify and parse the status list token
+const statusList = await wallet.CredentialStatus.statusList.verifyAndParse(
+  issuerConf.keys,
+  statusListJwt,
 );
 
-// Verify and parse the status list response to get the credential status
-const { status, statusBit } =
-  await wallet.CredentialStatus.statusList.verifyAndParse(
-    issuerConf.keys,
-    res
-  );
+// Read the credential status from the decoded status list
+const { status, rawStatus } = wallet.CredentialStatus.statusList.getStatus(statusList, idx);
 
 return {
-  statusList: res.statusList,
+  statusList,
   status,
-  statusBit,
+  rawStatus,
 };
 ```
 
-</details>
+</details>

package/src/credential/status/api/index.ts

@@ -12,7 +12,9 @@ interface UnsupportedApi {
  *
  * @example
  * if (CredentialStatus.statusList.isSupported) {
- *   const statusList = await CredentialStatus.statusList.get(credential, format)
+ *   const { statusList: statusListJwt, idx } = await CredentialStatus.statusList.get(credential, format)
+ *   const statusList = await CredentialStatus.statusList.verifyAndParse(keys, statusListJwt)
+ *   const status = CredentialStatus.statusList.getStatus(statusList, idx)
  * }
  */
 export interface CredentialStatusApi {

package/src/credential/status/api/status-assertion.ts

@@ -38,7 +38,7 @@ export interface StatusAssertionApi {
    * - The assertion is correctly signed;
    * - It's bound to the given key.
    * @since 1.0.0
-   * @deprecated since 1.3.3 - Use `statusList.verifyAndParse`
+   * @deprecated since 1.3.3 - Use `statusList.get`, `statusList.verifyAndParse` and `statusList.getStatus`
    *
    * @param issuerConf The Issuer configuration returned by `evaluateIssuerTrust`
    * @param statusAssertion The encoded status assertion returned by `statusAssertion.get`

package/src/credential/status/api/status-list.ts

@@ -1,12 +1,12 @@
-import type { Out } from "../../../utils/misc";
 import type { CredentialFormat } from "../../../credential/issuance/api";
 import type { JWK } from "../../../utils/jwk";
+import type { StatusList } from "./types";
 
 export interface StatusListApi {
   isSupported: true;
 
   /**
-   * Get the status list from the credential. This function fetches the list
+   * Get the status list token referenced by a credential. This function fetches the list
    * from the uri found in the credential's `status` claim.
    * @example
    * {
@@ -21,7 +21,7 @@ export interface StatusListApi {
    * @param credential The credential to get the status list for
    * @param format The credential format
    * @param context.appFetch Optional fetch function to use for the network request
-   * @returns The raw status list, the index of the credential and other metadata
+   * @returns The encoded status list token with its credential reference metadata
    */
   get(
     credential: string,
@@ -37,17 +37,40 @@ export interface StatusListApi {
   }>;
 
   /**
-   * Verifies the signature of a status list and extract the status at the specified index.
+   * Get a status list token from its uri.
+   * @since 1.3.3
+   * @param uri The status list uri
+   * @param context.appFetch Optional fetch function to use for the network request
+   * @returns The encoded status list token
+   */
+  getByUri(
+    uri: string,
+    context?: {
+      appFetch?: GlobalFetch["fetch"];
+    }
+  ): Promise<string>;
+
+  /**
+   * Verifies the signature of a status list token and parses its payload.
    * @since 1.3.3
    * @param keys The JSON Web Key Set to verify the status list signature
-   * @param statusListParams The raw status list, the index to read and other metadata
-   * @return The status of the credential and the raw status bit in hexadecimal format (e.g. "0x01")
+   * @param statusList The encoded status list token
+   * @returns The decoded status list payload
    */
-  verifyAndParse(
-    keys: JWK[],
-    statusListParams: Out<StatusListApi["get"]>
-  ): Promise<{
-    statusBit: string;
+  verifyAndParse(keys: JWK[], statusList: string): Promise<StatusList>;
+
+  /**
+   * Extracts the status at the specified index from a decoded status list.
+   * @since 1.3.3
+   * @param statusList The decoded status list
+   * @param idx The index to read
+   * @return The status of the credential and the raw status in hexadecimal format (e.g. "0x01")
+   */
+  getStatus(
+    statusList: StatusList["status_list"],
+    idx: number
+  ): {
+    rawStatus: string;
     status: string;
-  }>;
+  };
 }

package/src/credential/status/api/types.ts

@@ -1,3 +1,6 @@
+import { z } from "zod";
+import { UnixTime } from "../../../utils/zod";
+
 /**
  * Common type for a parsed Status Assertion
  */
@@ -13,3 +16,27 @@ export type ParsedStatusAssertion = {
     description: string;
   };
 };
+
+const StatusListBits = z.union([
+  z.literal(1),
+  z.literal(2),
+  z.literal(4),
+  z.literal(8),
+]);
+
+export type StatusListContent = z.infer<typeof StatusListContent>;
+export const StatusListContent = z.object({
+  bits: StatusListBits,
+  lst: z.string().min(1),
+  aggregation_uri: z.url().optional(),
+});
+
+export type StatusList = z.infer<typeof StatusList>;
+export const StatusList = z.object({
+  sub: z.url(),
+  iat: UnixTime,
+  iss: z.url().optional(),
+  exp: UnixTime.optional(),
+  ttl: z.number().positive().optional(),
+  status_list: StatusListContent,
+});

package/src/credential/status/v1.3.3/01-status-list.ts

@@ -32,25 +32,26 @@ const getStatusListEntry = async (
   return statusListEntry;
 };
 
-export const getStatusList: StatusListApi["get"] = async (
-  credential,
-  format,
+const fetchStatusList = (
+  uri: string,
+  appFetch: GlobalFetch["fetch"],
+  options: { cacheDisabled?: boolean } = {}
+) =>
+  appFetch(uri, {
+    headers: {
+      Accept: "application/statuslist+jwt",
+      ...(options.cacheDisabled && { "Cache-Control": "no-cache" }),
+    },
+  })
+    .then(hasStatusOrThrow(200))
+    .then((response) => response.text());
+
+export const getStatusListByUri: StatusListApi["getByUri"] = async (
+  uri,
   { appFetch = fetch } = {}
 ) => {
-  const { uri, idx } = await getStatusListEntry(credential, format);
-
-  const fetchStatusList = (options: { cacheDisabled?: boolean } = {}) =>
-    appFetch(uri, {
-      headers: {
-        Accept: "application/statuslist+jwt",
-        ...(options.cacheDisabled && { "Cache-Control": "no-cache" }),
-      },
-    })
-      .then(hasStatusOrThrow(200))
-      .then((response) => response.text());
-
   // When the HTTP response includes cache headers, fetch will return a cached response and the JWT might be expired
-  let statusList = await fetchStatusList();
+  let statusList = await fetchStatusList(uri, appFetch);
   const decoded = decodeJwt(statusList);
 
   const { exp } = decoded.payload;
@@ -58,7 +59,18 @@ export const getStatusList: StatusListApi["get"] = async (
   // If the status list JWT is expired, try to fetch it again bypassing the HTTP cache.
   // If it is still expired after the refetch, `verifyAndParseStatusList` will throw.
   if (exp && exp < Math.floor(Date.now() / 1000)) {
-    statusList = await fetchStatusList({ cacheDisabled: true });
+    statusList = await fetchStatusList(uri, appFetch, { cacheDisabled: true });
   }
-  return { statusList, uri, idx, format: "jwt" };
+
+  return statusList;
+};
+
+export const getStatusList: StatusListApi["get"] = async (
+  credential,
+  format,
+  context
+) => {
+  const { uri, idx } = await getStatusListEntry(credential, format);
+  const statusList = await getStatusListByUri(uri, context);
+  return { uri, idx, statusList, format: "jwt" };
 };

package/src/credential/status/v1.3.3/02-verify-and-parse-status-list.ts

@@ -1,33 +1,11 @@
-import { verify } from "@pagopa/io-react-native-jwt";
-import { getListFromStatusListJWT } from "@sd-jwt/jwt-status-list";
+import { decode as decodeJwt, verify } from "@pagopa/io-react-native-jwt";
 import type { StatusListApi } from "../api/status-list";
-
-/**
- * Mapping of status bits to their corresponding meaning as defined in the specification.
- * @see https://italia.github.io/eid-wallet-it-docs/releases/1.3.3/en/credential-revocation.html#token-status-lists
- */
-const CredentialStatusMap = {
-  0x00: "VALID",
-  0x01: "INVALID",
-  0x02: "SUSPENDED",
-  0x03: "UPDATE",
-  0x0b: "ATTRIBUTE_UPDATE",
-} as const;
-
-type CredentialStatusBit = keyof typeof CredentialStatusMap;
+import { StatusList } from "../api/types";
 
 export const verifyAndParseStatusList: StatusListApi["verifyAndParse"] = async (
   keys,
-  { statusList: rawStatusList, idx }
+  statusList
 ) => {
-  await verify(rawStatusList, keys);
-
-  const statusList = getListFromStatusListJWT(rawStatusList);
-  const statusBit = statusList.getStatus(idx) as CredentialStatusBit;
-  const status = CredentialStatusMap[statusBit];
-
-  return {
-    status,
-    statusBit: `0x${statusBit.toString(16).padStart(2, "0").toUpperCase()}`,
-  };
+  await verify(statusList, keys);
+  return StatusList.parse(decodeJwt(statusList).payload);
 };

package/src/credential/status/v1.3.3/03-get-status.ts

@@ -0,0 +1,40 @@
+import { StatusList as JwtStatusList } from "@sd-jwt/jwt-status-list";
+import { IoWalletError } from "../../../utils/errors";
+import type { StatusListApi } from "../api/status-list";
+
+/**
+ * Mapping of status bits to their corresponding meaning as defined in the specification.
+ * @see https://italia.github.io/eid-wallet-it-docs/releases/1.3.3/en/credential-revocation.html#token-status-lists
+ */
+const CredentialStatusMap = {
+  0x00: "VALID",
+  0x01: "INVALID",
+  0x02: "SUSPENDED",
+  0x03: "UPDATE",
+  0x0b: "ATTRIBUTE_UPDATE",
+} as const;
+
+type CredentialStatusBit = keyof typeof CredentialStatusMap;
+
+const formatStatusBit = (statusBit: number) =>
+  `0x${statusBit.toString(16).padStart(2, "0").toUpperCase()}`;
+
+export const getStatus: StatusListApi["getStatus"] = (statusList, idx) => {
+  const decodedStatusList = JwtStatusList.decompressStatusList(
+    statusList.lst,
+    statusList.bits
+  );
+  const statusBit = decodedStatusList.getStatus(idx) as CredentialStatusBit;
+  const status = CredentialStatusMap[statusBit];
+
+  if (!status) {
+    throw new IoWalletError(
+      `Unsupported credential status bit: ${formatStatusBit(statusBit)}`
+    );
+  }
+
+  return {
+    status,
+    rawStatus: formatStatusBit(statusBit),
+  };
+};

package/src/credential/status/v1.3.3/index.ts

@@ -1,6 +1,7 @@
 import type { CredentialStatusApi } from "../api";
-import { getStatusList } from "./01-status-list";
+import { getStatusList, getStatusListByUri } from "./01-status-list";
 import { verifyAndParseStatusList } from "./02-verify-and-parse-status-list";
+import { getStatus } from "./03-get-status";
 
 export const CredentialStatus: CredentialStatusApi = {
   statusAssertion: {
@@ -9,6 +10,8 @@ export const CredentialStatus: CredentialStatusApi = {
   statusList: {
     isSupported: true,
     get: getStatusList,
+    getByUri: getStatusListByUri,
     verifyAndParse: verifyAndParseStatusList,
+    getStatus,
   },
 };

package/src/credentials-catalogue/api/DigitalCredentialsCatalogue.ts

@@ -115,6 +115,7 @@ export const DigitalCredential = z.object({
   purposes: z.array(z.union([z.string(), CredentialPurpose])),
   issuers: z.array(CredentialIssuer),
   authentic_sources: z.array(AuthenticSource),
+  parent_credentials: z.array(z.string()).optional(),
   formats: z.array(CredentialFormat).optional(),
   // claims: z.array(Claim), // TODO: [SIW-3978] Should we keep claims?
 });