@pagopa/io-react-native-wallet 3.7.4 → 3.8.2

package/lib/typescript/module/credential/presentation/v1.0.0/mappers.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"mappers.d.ts","sourceRoot":"","sources":["../../../../../../src/credential/presentation/v1.0.0/mappers.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,iBAAc,CAAC;AAMlD,eAAO,MAAM,uBAAuB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAclC,CAAC;AAEH,eAAO,MAAM,kBAAkB;;;;;;;;;;;;;;;;;;;;;;mBAY9B,CAAC"}

package/lib/typescript/module/credential/presentation/v1.0.0/types.d.ts

@@ -0,0 +1,49 @@
+import * as z from "zod";
+export type RawRequestObject = z.infer<typeof RawRequestObject>;
+export declare const RawRequestObject: z.ZodObject<{
+    header: z.ZodObject<{
+        alg: z.ZodString;
+        kid: z.ZodString;
+        trust_chain: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        typ: z.ZodLiteral<"oauth-authz-req+jwt">;
+    }, z.core.$strip>;
+    payload: z.ZodObject<{
+        client_id: z.ZodString;
+        dcql_query: z.ZodRecord<z.ZodString, z.ZodAny>;
+        exp: z.ZodNumber;
+        iat: z.ZodNumber;
+        iss: z.ZodString;
+        nonce: z.ZodString;
+        request_uri_method: z.ZodOptional<z.ZodString>;
+        response_mode: z.ZodLiteral<"direct_post.jwt">;
+        response_type: z.ZodLiteral<"vp_token">;
+        response_uri: z.ZodString;
+        scope: z.ZodOptional<z.ZodString>;
+        state: z.ZodString;
+        wallet_nonce: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>;
+}, z.core.$strip>;
+/**
+ * Authorization Response payload sent to the Relying Party.
+ */
+export type DirectAuthorizationBodyPayload = z.infer<typeof DirectAuthorizationBodyPayload>;
+export declare const DirectAuthorizationBodyPayload: z.ZodUnion<readonly [z.ZodObject<{
+    vp_token: z.ZodRecord<z.ZodString, z.ZodString>;
+}, z.core.$strip>, z.ZodObject<{
+    error: z.ZodEnum<{
+        invalid_request_object: "invalid_request_object";
+        invalid_request_uri: "invalid_request_uri";
+        vp_formats_not_supported: "vp_formats_not_supported";
+        invalid_request: "invalid_request";
+        access_denied: "access_denied";
+        invalid_client: "invalid_client";
+    }>;
+    error_description: z.ZodString;
+}, z.core.$strip>]>;
+export type AuthorizationResponse = z.infer<typeof AuthorizationResponse>;
+export declare const AuthorizationResponse: z.ZodObject<{
+    redirect_uri: z.ZodOptional<z.ZodString>;
+    response_code: z.ZodOptional<z.ZodString>;
+    status: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+//# sourceMappingURL=types.d.ts.map

package/lib/typescript/module/credential/presentation/v1.0.0/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../../../../../src/credential/presentation/v1.0.0/types.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,CAAC,MAAM,KAAK,CAAC;AAKzB,MAAM,MAAM,gBAAgB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,gBAAgB,CAAC,CAAC;AAChE,eAAO,MAAM,gBAAgB;;;;;;;;;;;;;;;;;;;;;;iBAsB3B,CAAC;AAEH;;GAEG;AACH,MAAM,MAAM,8BAA8B,GAAG,CAAC,CAAC,KAAK,CAClD,OAAO,8BAA8B,CACtC,CAAC;AACF,eAAO,MAAM,8BAA8B;;;;;;;;;;;;mBAKzC,CAAC;AAEH,MAAM,MAAM,qBAAqB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,qBAAqB,CAAC,CAAC;AAC1E,eAAO,MAAM,qBAAqB;;;;iBAIhC,CAAC"}

package/lib/typescript/module/credential/presentation/v1.0.0/utils.d.ts

@@ -0,0 +1,11 @@
+import type { RelyingPartyConfig } from "../api/index.js";
+import { type JWK } from "../../../utils/jwk.js";
+/**
+ * Fetches the JSON Web Key Set (JWKS) from the Relying Party's Entity Configuration.
+ * @param rpConfig - The Relying Party's common configuration,
+ * @returns An object containing an array of JSON Web Keys (JWKs).
+ */
+export declare const getJwksFromRpConfig: (rpConfig: RelyingPartyConfig) => {
+    keys: JWK[];
+};
+//# sourceMappingURL=utils.d.ts.map

package/lib/typescript/module/credential/presentation/v1.0.0/utils.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"utils.d.ts","sourceRoot":"","sources":["../../../../../../src/credential/presentation/v1.0.0/utils.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,iBAAQ,CAAC;AAEjD,OAAO,EAAE,KAAK,GAAG,EAAQ,MAAM,uBAAoB,CAAC;AAEpD;;;;GAIG;AACH,eAAO,MAAM,mBAAmB,GAC9B,UAAU,kBAAkB,KAC3B;IAAE,IAAI,EAAE,GAAG,EAAE,CAAA;CAef,CAAC"}

package/lib/typescript/module/credential/presentation/v1.0.0/utils.jwks.d.ts

@@ -0,0 +1,11 @@
+import type { RelyingPartyConfig } from "../api/index.js";
+import { type JWK } from "../../../utils/jwk.js";
+/**
+ * Fetches the JSON Web Key Set (JWKS) from the Relying Party's Entity Configuration.
+ * @param rpConfig - The Relying Party's common configuration,
+ * @returns An object containing an array of JSON Web Keys (JWKs).
+ */
+export declare const getJwksFromRpConfig: (rpConfig: RelyingPartyConfig) => {
+    keys: JWK[];
+};
+//# sourceMappingURL=utils.jwks.d.ts.map

package/lib/typescript/module/credential/presentation/v1.0.0/utils.jwks.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"utils.jwks.d.ts","sourceRoot":"","sources":["../../../../../../src/credential/presentation/v1.0.0/utils.jwks.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,iBAAQ,CAAC;AAEjD,OAAO,EAAE,KAAK,GAAG,EAAQ,MAAM,uBAAoB,CAAC;AAEpD;;;;GAIG;AACH,eAAO,MAAM,mBAAmB,GAC9B,UAAU,kBAAkB,KAC3B;IAAE,IAAI,EAAE,GAAG,EAAE,CAAA;CAef,CAAC"}

package/lib/typescript/module/credential/presentation/v1.4.6/01-start-flow.d.ts

@@ -0,0 +1,3 @@
+import type { RemotePresentationApi } from "../api/index.js";
+export declare const startFlowFromQR: RemotePresentationApi["startFlowFromQR"];
+//# sourceMappingURL=01-start-flow.d.ts.map

package/lib/typescript/module/credential/presentation/v1.4.6/01-start-flow.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"01-start-flow.d.ts","sourceRoot":"","sources":["../../../../../../src/credential/presentation/v1.4.6/01-start-flow.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,qBAAqB,EAAE,MAAM,iBAAQ,CAAC;AAKpD,eAAO,MAAM,eAAe,EAAE,qBAAqB,CAAC,iBAAiB,CAoBpE,CAAC"}

package/lib/typescript/module/credential/presentation/v1.4.6/02-evaluate-rp-trust.d.ts

@@ -0,0 +1,3 @@
+import type { RemotePresentationApi } from "../api/index.js";
+export declare const evaluateRelyingPartyTrust: RemotePresentationApi["evaluateRelyingPartyTrust"];
+//# sourceMappingURL=02-evaluate-rp-trust.d.ts.map

package/lib/typescript/module/credential/presentation/v1.4.6/02-evaluate-rp-trust.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"02-evaluate-rp-trust.d.ts","sourceRoot":"","sources":["../../../../../../src/credential/presentation/v1.4.6/02-evaluate-rp-trust.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,qBAAqB,EAAE,MAAM,iBAAQ,CAAC;AAKpD,eAAO,MAAM,yBAAyB,EAAE,qBAAqB,CAAC,2BAA2B,CAUtF,CAAC"}

package/lib/typescript/module/credential/presentation/v1.4.6/03-get-request-object.d.ts

@@ -0,0 +1,3 @@
+import type { RemotePresentationApi } from "../api/index.js";
+export declare const getRequestObject: RemotePresentationApi["getRequestObject"];
+//# sourceMappingURL=03-get-request-object.d.ts.map

package/lib/typescript/module/credential/presentation/v1.4.6/03-get-request-object.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"03-get-request-object.d.ts","sourceRoot":"","sources":["../../../../../../src/credential/presentation/v1.4.6/03-get-request-object.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,qBAAqB,EAAE,MAAM,iBAAQ,CAAC;AAKpD,eAAO,MAAM,gBAAgB,EAAE,qBAAqB,CAAC,kBAAkB,CAsBpE,CAAC"}

package/lib/typescript/module/credential/presentation/v1.4.6/04-verify-certificate-chain.d.ts

@@ -0,0 +1,3 @@
+import type { RemotePresentationApi } from "../api/index.js";
+export declare const verifyAuthRequestCertificateChain: RemotePresentationApi["verifyAuthRequestCertificateChain"];
+//# sourceMappingURL=04-verify-certificate-chain.d.ts.map

package/lib/typescript/module/credential/presentation/v1.4.6/04-verify-certificate-chain.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"04-verify-certificate-chain.d.ts","sourceRoot":"","sources":["../../../../../../src/credential/presentation/v1.4.6/04-verify-certificate-chain.ts"],"names":[],"mappings":"AAMA,OAAO,KAAK,EAAE,qBAAqB,EAAE,MAAM,iBAAQ,CAAC;AAQpD,eAAO,MAAM,iCAAiC,EAAE,qBAAqB,CAAC,mCAAmC,CA4CtG,CAAC"}

package/lib/typescript/module/credential/presentation/v1.4.6/05-verify-request-object.d.ts

@@ -0,0 +1,3 @@
+import type { RemotePresentationApi } from "../api/index.js";
+export declare const verifyRequestObject: RemotePresentationApi["verifyRequestObject"];
+//# sourceMappingURL=05-verify-request-object.d.ts.map

package/lib/typescript/module/credential/presentation/v1.4.6/05-verify-request-object.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"05-verify-request-object.d.ts","sourceRoot":"","sources":["../../../../../../src/credential/presentation/v1.4.6/05-verify-request-object.ts"],"names":[],"mappings":"AAOA,OAAO,KAAK,EAAsB,qBAAqB,EAAE,MAAM,iBAAQ,CAAC;AAUxE,eAAO,MAAM,mBAAmB,EAAE,qBAAqB,CAAC,qBAAqB,CAiC1E,CAAC"}

package/lib/typescript/module/credential/presentation/v1.4.6/06-evaluate-dcql-query.d.ts

@@ -0,0 +1,3 @@
+import type { RemotePresentationApi } from "../api/index.js";
+export declare const evaluateDcqlQuery: RemotePresentationApi["evaluateDcqlQuery"];
+//# sourceMappingURL=06-evaluate-dcql-query.d.ts.map

package/lib/typescript/module/credential/presentation/v1.4.6/06-evaluate-dcql-query.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"06-evaluate-dcql-query.d.ts","sourceRoot":"","sources":["../../../../../../src/credential/presentation/v1.4.6/06-evaluate-dcql-query.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAmB,qBAAqB,EAAE,MAAM,iBAAQ,CAAC;AAarE,eAAO,MAAM,iBAAiB,EAAE,qBAAqB,CAAC,mBAAmB,CAoHtE,CAAC"}

package/lib/typescript/module/credential/presentation/v1.4.6/07-send-authorization-response.d.ts

@@ -0,0 +1,18 @@
+import type { RemotePresentationApi } from "../api/index.js";
+/**
+ * Prepares remote presentations for a set of credentials.
+ *
+ * For each credential, this function:
+ * - Validates the credential format (currently supports 'mso_mdoc' or 'dc+sd-jwt').
+ * - Generates a verifiable presentation token (vpToken) using the appropriate method.
+ * - For ISO 18013-7, generates a special nonce with minimum entropy of 16.
+ *
+ * @param credentials - An array of credential items containing format, credential data, requested claims, and key information.
+ * @param authRequestObject - The authentication request object containing nonce, clientId, and responseUri.
+ * @returns A promise that resolves to an object containing an array of presentations and the generated nonce.
+ * @throws {CredentialNotFoundError} When the credential format is unsupported.
+ */
+export declare const prepareRemotePresentations: RemotePresentationApi["prepareRemotePresentations"];
+export declare const sendAuthorizationResponse: RemotePresentationApi["sendAuthorizationResponse"];
+export declare const sendAuthorizationErrorResponse: RemotePresentationApi["sendAuthorizationErrorResponse"];
+//# sourceMappingURL=07-send-authorization-response.d.ts.map

package/lib/typescript/module/credential/presentation/v1.4.6/07-send-authorization-response.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"07-send-authorization-response.d.ts","sourceRoot":"","sources":["../../../../../../src/credential/presentation/v1.4.6/07-send-authorization-response.ts"],"names":[],"mappings":"AAKA,OAAO,KAAK,EAAE,qBAAqB,EAAE,MAAM,iBAAQ,CAAC;AAmBpD;;;;;;;;;;;;GAYG;AACH,eAAO,MAAM,0BAA0B,EAAE,qBAAqB,CAAC,4BAA4B,CA2DxF,CAAC;AAEJ,eAAO,MAAM,yBAAyB,EAAE,qBAAqB,CAAC,2BAA2B,CAyDtF,CAAC;AAEJ,eAAO,MAAM,8BAA8B,EAAE,qBAAqB,CAAC,gCAAgC,CAqBhG,CAAC"}

package/lib/typescript/module/credential/presentation/v1.4.6/index.d.ts

@@ -0,0 +1,3 @@
+import type { RemotePresentationApi } from "../api/index.js";
+export declare const RemotePresentation: RemotePresentationApi;
+//# sourceMappingURL=index.d.ts.map

package/lib/typescript/module/credential/presentation/v1.4.6/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../../src/credential/presentation/v1.4.6/index.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,qBAAqB,EAAE,MAAM,iBAAQ,CAAC;AAcpD,eAAO,MAAM,kBAAkB,EAAE,qBAUhC,CAAC"}

package/lib/typescript/module/credential/presentation/v1.4.6/mappers.d.ts

@@ -0,0 +1,239 @@
+import type { RequestObject } from "../api/types.js";
+export declare const mapToRelyingPartyConfig: (input: {
+    header: {
+        alg: string;
+        kid: string;
+        typ: "entity-statement+jwt";
+    };
+    payload: {
+        [x: string]: unknown;
+        exp: number;
+        iat: number;
+        iss: string;
+        jwks: {
+            keys: {
+                kty: "RSA" | "EC";
+                alg?: string | undefined;
+                crv?: string | undefined;
+                d?: string | undefined;
+                dp?: string | undefined;
+                dq?: string | undefined;
+                e?: string | undefined;
+                ext?: boolean | undefined;
+                k?: string | undefined;
+                key_ops?: string[] | undefined;
+                kid?: string | undefined;
+                n?: string | undefined;
+                p?: string | undefined;
+                q?: string | undefined;
+                qi?: string | undefined;
+                use?: string | undefined;
+                x?: string | undefined;
+                x5c?: string[] | undefined;
+                x5t?: string | undefined;
+                "x5t#S256"?: string | undefined;
+                x5u?: string | undefined;
+                y?: string | undefined;
+            }[];
+        };
+        metadata: {
+            [x: string]: unknown;
+            federation_entity: {
+                [x: string]: unknown;
+                contacts?: string[] | undefined;
+                endpoint_auth_signing_alg_values_supported?: string | undefined;
+                federation_fetch_endpoint?: string | undefined;
+                federation_historical_keys_endpoint?: string | undefined;
+                federation_list_endpoint?: string | undefined;
+                federation_resolve_endpoint?: string | undefined;
+                federation_trust_mark_endpoint?: string | undefined;
+                federation_trust_mark_list_endpoint?: string | undefined;
+                federation_trust_mark_status_endpoint?: string | undefined;
+                homepage_uri?: string | undefined;
+                logo_uri?: string | undefined;
+                organization_name?: string | undefined;
+                policy_uri?: string | undefined;
+            };
+        };
+        sub: string;
+        authority_hints?: string[] | undefined;
+    };
+} & {
+    payload: {
+        metadata: {
+            openid_credential_verifier: {
+                [x: string]: unknown;
+                application_type: "web";
+                client_id: string;
+                client_name: string;
+                encrypted_response_enc_values_supported: string[];
+                jwks: {
+                    keys: {
+                        [x: string]: unknown;
+                        kid: string;
+                        kty: string;
+                        alg?: string | undefined;
+                        key_ops?: string[] | undefined;
+                        use?: string | undefined;
+                        x5c?: string[] | undefined;
+                        x5t?: string | undefined;
+                        "x5t#S256"?: string | undefined;
+                        x5u?: string | undefined;
+                    }[];
+                };
+                logo_uri: string;
+                request_uris: string[];
+                response_uris: string[];
+                vp_formats_supported: Record<string, {
+                    alg?: string[] | undefined;
+                    deviceauth_alg_values?: number[] | undefined;
+                    issuerauth_alg_values?: number[] | undefined;
+                    "kb-jwt_alg_values"?: string[] | undefined;
+                    "sd-jwt_alg_values"?: string[] | undefined;
+                }>;
+                erasure_endpoint?: string | undefined;
+                redirect_uris?: string[] | undefined;
+            };
+        };
+    };
+}) => {
+    federation_entity: {
+        [x: string]: unknown;
+        contacts?: string[] | undefined;
+        endpoint_auth_signing_alg_values_supported?: string | undefined;
+        federation_fetch_endpoint?: string | undefined;
+        federation_historical_keys_endpoint?: string | undefined;
+        federation_list_endpoint?: string | undefined;
+        federation_resolve_endpoint?: string | undefined;
+        federation_trust_mark_endpoint?: string | undefined;
+        federation_trust_mark_list_endpoint?: string | undefined;
+        federation_trust_mark_status_endpoint?: string | undefined;
+        homepage_uri?: string | undefined;
+        logo_uri?: string | undefined;
+        organization_name?: string | undefined;
+        policy_uri?: string | undefined;
+    };
+    jwks: {
+        keys: {
+            [x: string]: unknown;
+            kid: string;
+            kty: string;
+            alg?: string | undefined;
+            key_ops?: string[] | undefined;
+            use?: string | undefined;
+            x5c?: string[] | undefined;
+            x5t?: string | undefined;
+            "x5t#S256"?: string | undefined;
+            x5u?: string | undefined;
+        }[];
+    };
+    authorization_encrypted_response_alg?: string | undefined;
+    authorization_encrypted_response_enc?: string | undefined;
+    encrypted_response_enc_values_supported?: string[] | undefined;
+    subject?: string | undefined;
+};
+export declare const mapToRequestObject: (input: {
+    header: {
+        [x: string]: unknown;
+        alg: string;
+        typ: "oauth-authz-req+jwt";
+        kid?: string | undefined;
+        trust_chain?: [string, ...string[]] | undefined;
+        x5c?: string[] | undefined;
+    };
+    payload: {
+        [x: string]: unknown;
+        client_id: string;
+        dcql_query: Record<string, any>;
+        nonce: string;
+        response_mode: "direct_post.jwt";
+        response_type: "vp_token";
+        response_uri: string;
+        client_metadata?: {
+            [x: string]: unknown;
+            encrypted_response_enc_values_supported: string[];
+            jwks: {
+                keys: {
+                    [x: string]: unknown;
+                    kid: string;
+                    kty: string;
+                    alg?: string | undefined;
+                    key_ops?: string[] | undefined;
+                    use?: string | undefined;
+                    x5c?: string[] | undefined;
+                    x5t?: string | undefined;
+                    "x5t#S256"?: string | undefined;
+                    x5u?: string | undefined;
+                }[];
+            };
+            vp_formats_supported: Record<string, {
+                alg?: string[] | undefined;
+                deviceauth_alg_values?: number[] | undefined;
+                issuerauth_alg_values?: number[] | undefined;
+                "kb-jwt_alg_values"?: string[] | undefined;
+                "sd-jwt_alg_values"?: string[] | undefined;
+            }>;
+            application_type?: "web" | undefined;
+            client_id?: string | undefined;
+            client_name?: string | undefined;
+            erasure_endpoint?: string | undefined;
+            logo_uri?: string | undefined;
+            redirect_uris?: string[] | undefined;
+            request_uris?: string[] | undefined;
+            response_uris?: string[] | undefined;
+        } | undefined;
+        request_uri?: string | undefined;
+        request_uri_method?: string | undefined;
+        scope?: string | undefined;
+        state?: string | undefined;
+        transaction_data?: string[] | undefined;
+        transaction_data_hashes_alg?: string[] | undefined;
+        wallet_nonce?: string | undefined;
+    } & {
+        aud?: string | undefined;
+        cnf?: {
+            [x: string]: unknown;
+            jkt?: string | undefined;
+            jwk?: {
+                [x: string]: unknown;
+                kty: string;
+                alg?: string | undefined;
+                crv?: string | undefined;
+                d?: string | undefined;
+                dp?: string | undefined;
+                dq?: string | undefined;
+                e?: string | undefined;
+                ext?: boolean | undefined;
+                k?: string | undefined;
+                key_ops?: string[] | undefined;
+                kid?: string | undefined;
+                n?: string | undefined;
+                oth?: {
+                    [x: string]: unknown;
+                    d?: string | undefined;
+                    r?: string | undefined;
+                    t?: string | undefined;
+                }[] | undefined;
+                p?: string | undefined;
+                q?: string | undefined;
+                qi?: string | undefined;
+                use?: string | undefined;
+                x?: string | undefined;
+                x5c?: string[] | undefined;
+                x5t?: string | undefined;
+                "x5t#S256"?: string | undefined;
+                x5u?: string | undefined;
+                y?: string | undefined;
+            } | undefined;
+        } | undefined;
+        exp?: number | undefined;
+        iat?: number | undefined;
+        iss?: string | undefined;
+        jti?: string | undefined;
+        nbf?: number | undefined;
+        nonce?: string | undefined;
+        status?: Record<string, any> | undefined;
+        trust_chain?: [string, ...string[]] | undefined;
+    };
+}) => RequestObject;
+//# sourceMappingURL=mappers.d.ts.map

package/lib/typescript/module/credential/presentation/v1.4.6/mappers.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"mappers.d.ts","sourceRoot":"","sources":["../../../../../../src/credential/presentation/v1.4.6/mappers.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,iBAAc,CAAC;AAMlD,eAAO,MAAM,uBAAuB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAalC,CAAC;AAEH,eAAO,MAAM,kBAAkB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;mBAc9B,CAAC"}

package/lib/typescript/module/credential/presentation/v1.4.6/sdkErrorMapper.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Mapping Sdk errors during Request Object retrieval (Fetch/QR)
+ */
+export declare const mapSdkFetchAuthRequestError: (err: unknown) => never;
+/**
+ * Mapping Sdk errors during JWT parsing and verification
+ */
+export declare const mapSdkRequestObjectError: (err: unknown) => never;
+/**
+ * Mapping Sdk errors during Authorization Response submission (JARM / Post)
+ */
+export declare const mapSdkAuthorizationResponseError: (err: unknown) => never;
+//# sourceMappingURL=sdkErrorMapper.d.ts.map

package/lib/typescript/module/credential/presentation/v1.4.6/sdkErrorMapper.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sdkErrorMapper.d.ts","sourceRoot":"","sources":["../../../../../../src/credential/presentation/v1.4.6/sdkErrorMapper.ts"],"names":[],"mappings":"AAkCA;;GAEG;AACH,eAAO,MAAM,2BAA2B,GAAI,KAAK,OAAO,UAMvD,CAAC;AAEF;;GAEG;AACH,eAAO,MAAM,wBAAwB,GAAI,KAAK,OAAO,UAgBpD,CAAC;AAEF;;GAEG;AACH,eAAO,MAAM,gCAAgC,GAAI,KAAK,OAAO,UA2B5D,CAAC"}

package/lib/typescript/module/credential/presentation/v1.4.6/types.d.ts

@@ -0,0 +1,106 @@
+import * as z from "zod";
+export type RawRequestObject = z.infer<typeof RawRequestObject>;
+export declare const RawRequestObject: z.ZodObject<{
+    header: z.ZodObject<{
+        alg: z.ZodString;
+        typ: z.ZodLiteral<"oauth-authz-req+jwt">;
+        kid: z.ZodOptional<z.ZodString>;
+        trust_chain: z.ZodOptional<z.ZodTuple<[z.ZodString], z.ZodString>>;
+        x5c: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    }, z.core.$loose>;
+    payload: z.ZodIntersection<z.ZodObject<{
+        client_id: z.ZodString;
+        client_metadata: z.ZodOptional<z.ZodObject<{
+            application_type: z.ZodOptional<z.ZodLiteral<"web">>;
+            client_id: z.ZodOptional<z.ZodURL>;
+            client_name: z.ZodOptional<z.ZodString>;
+            encrypted_response_enc_values_supported: z.ZodArray<z.ZodString>;
+            erasure_endpoint: z.ZodOptional<z.ZodURL>;
+            jwks: z.ZodObject<{
+                keys: z.ZodArray<z.ZodObject<{
+                    alg: z.ZodOptional<z.ZodString>;
+                    key_ops: z.ZodOptional<z.ZodArray<z.ZodString>>;
+                    kid: z.ZodString;
+                    kty: z.ZodString;
+                    use: z.ZodOptional<z.ZodString>;
+                    x5c: z.ZodOptional<z.ZodArray<z.ZodString>>;
+                    x5t: z.ZodOptional<z.ZodString>;
+                    "x5t#S256": z.ZodOptional<z.ZodString>;
+                    x5u: z.ZodOptional<z.ZodString>;
+                }, z.core.$loose>>;
+            }, z.core.$strip>;
+            logo_uri: z.ZodOptional<z.ZodURL>;
+            redirect_uris: z.ZodOptional<z.ZodArray<z.ZodURL>>;
+            request_uris: z.ZodOptional<z.ZodArray<z.ZodURL>>;
+            response_uris: z.ZodOptional<z.ZodArray<z.ZodURL>>;
+            vp_formats_supported: z.ZodRecord<z.ZodString, z.ZodObject<{
+                alg: z.ZodOptional<z.ZodArray<z.ZodString>>;
+                deviceauth_alg_values: z.ZodOptional<z.ZodArray<z.ZodNumber>>;
+                issuerauth_alg_values: z.ZodOptional<z.ZodArray<z.ZodNumber>>;
+                "kb-jwt_alg_values": z.ZodOptional<z.ZodArray<z.ZodString>>;
+                "sd-jwt_alg_values": z.ZodOptional<z.ZodArray<z.ZodString>>;
+            }, z.core.$strip>>;
+        }, z.core.$loose>>;
+        dcql_query: z.ZodRecord<z.ZodString, z.ZodAny>;
+        nonce: z.ZodString;
+        request_uri: z.ZodOptional<z.ZodURL>;
+        request_uri_method: z.ZodOptional<z.ZodString>;
+        response_mode: z.ZodLiteral<"direct_post.jwt">;
+        response_type: z.ZodLiteral<"vp_token">;
+        response_uri: z.ZodURL;
+        scope: z.ZodOptional<z.ZodString>;
+        state: z.ZodOptional<z.ZodString>;
+        transaction_data: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        transaction_data_hashes_alg: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        wallet_nonce: z.ZodOptional<z.ZodString>;
+    }, z.core.$loose>, z.ZodObject<{
+        aud: z.ZodOptional<z.ZodString>;
+        cnf: z.ZodOptional<z.ZodObject<{
+            jkt: z.ZodOptional<z.ZodString>;
+            jwk: z.ZodOptional<z.ZodObject<{
+                alg: z.ZodOptional<z.ZodString>;
+                crv: z.ZodOptional<z.ZodString>;
+                d: z.ZodOptional<z.ZodString>;
+                dp: z.ZodOptional<z.ZodString>;
+                dq: z.ZodOptional<z.ZodString>;
+                e: z.ZodOptional<z.ZodString>;
+                ext: z.ZodOptional<z.ZodBoolean>;
+                k: z.ZodOptional<z.ZodString>;
+                key_ops: z.ZodOptional<z.ZodArray<z.ZodString>>;
+                kid: z.ZodOptional<z.ZodString>;
+                kty: z.ZodString;
+                n: z.ZodOptional<z.ZodString>;
+                oth: z.ZodOptional<z.ZodArray<z.ZodObject<{
+                    d: z.ZodOptional<z.ZodString>;
+                    r: z.ZodOptional<z.ZodString>;
+                    t: z.ZodOptional<z.ZodString>;
+                }, z.core.$loose>>>;
+                p: z.ZodOptional<z.ZodString>;
+                q: z.ZodOptional<z.ZodString>;
+                qi: z.ZodOptional<z.ZodString>;
+                use: z.ZodOptional<z.ZodString>;
+                x: z.ZodOptional<z.ZodString>;
+                x5c: z.ZodOptional<z.ZodArray<z.ZodString>>;
+                x5t: z.ZodOptional<z.ZodString>;
+                "x5t#S256": z.ZodOptional<z.ZodString>;
+                x5u: z.ZodOptional<z.ZodString>;
+                y: z.ZodOptional<z.ZodString>;
+            }, z.core.$loose>>;
+        }, z.core.$loose>>;
+        exp: z.ZodOptional<z.ZodNumber>;
+        iat: z.ZodOptional<z.ZodNumber>;
+        iss: z.ZodOptional<z.ZodString>;
+        jti: z.ZodOptional<z.ZodString>;
+        nbf: z.ZodOptional<z.ZodNumber>;
+        nonce: z.ZodOptional<z.ZodString>;
+        status: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodAny>>;
+        trust_chain: z.ZodOptional<z.ZodTuple<[z.ZodString], z.ZodString>>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+export type AuthorizationResponse = z.infer<typeof AuthorizationResponse>;
+export declare const AuthorizationResponse: z.ZodObject<{
+    redirect_uri: z.ZodOptional<z.ZodString>;
+    response_code: z.ZodOptional<z.ZodString>;
+    status: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+//# sourceMappingURL=types.d.ts.map

package/lib/typescript/module/credential/presentation/v1.4.6/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../../../../../src/credential/presentation/v1.4.6/types.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,CAAC,MAAM,KAAK,CAAC;AAEzB,MAAM,MAAM,gBAAgB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,gBAAgB,CAAC,CAAC;AAChE,eAAO,MAAM,gBAAgB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAG3B,CAAC;AAEH,MAAM,MAAM,qBAAqB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,qBAAqB,CAAC,CAAC;AAC1E,eAAO,MAAM,qBAAqB;;;;iBAIhC,CAAC"}

package/lib/typescript/module/credential/status/api/index.d.ts

@@ -0,0 +1,23 @@
+import type { StatusAssertionApi } from "./status-assertion.js";
+import type { StatusListApi } from "./status-list.js";
+/**
+ * Credential status API. It supports status assertion and status list.
+ *
+ * **Important:** before using one or the other, ensure it is supported by the selected IT-Wallet version.
+ *
+ * @example
+ * if (CredentialStatus.statusList.isSupported) {
+ *   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 {
+    statusAssertion: StatusAssertionApi | UnsupportedApi;
+    statusList: StatusListApi | UnsupportedApi;
+}
+interface UnsupportedApi {
+    isSupported: false;
+}
+export * from "./types.js";
+//# sourceMappingURL=index.d.ts.map

package/lib/typescript/module/credential/status/api/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../../src/credential/status/api/index.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,uBAAoB,CAAC;AAC7D,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,kBAAe,CAAC;AAEnD;;;;;;;;;;;GAWG;AACH,MAAM,WAAW,mBAAmB;IAClC,eAAe,EAAE,kBAAkB,GAAG,cAAc,CAAC;IACrD,UAAU,EAAE,aAAa,GAAG,cAAc,CAAC;CAC5C;AAED,UAAU,cAAc;IACtB,WAAW,EAAE,KAAK,CAAC;CACpB;AAED,cAAc,YAAS,CAAC"}

package/lib/typescript/module/credential/status/api/status-assertion.d.ts

@@ -0,0 +1,49 @@
+import type { CryptoContext } from "@pagopa/io-react-native-jwt";
+import type { SupportedSdJwtLegacyFormat } from "../../../sd-jwt/types.js";
+import type { Out } from "../../../utils/misc.js";
+import type { CredentialFormat, IssuerConfig } from "../../issuance/api/index.js";
+import type { ParsedStatusAssertion } from "./types.js";
+export interface StatusAssertionApi {
+    /**
+     * Get the status assertion of a digital credential.
+     * @since 1.0.0
+     * @deprecated since 1.3.3 - Use `statusList.get`
+     *
+     * @param issuerConf - The issuer's configuration
+     * @param credential - The credential to be verified
+     * @param format - The format of the credential, e.g. "sd-jwt"
+     * @param context.credentialCryptoContext - The credential's crypto context
+     * @param context.wiaCryptoContext - The Wallet Attestation's crypto context
+     * @param context.appFetch (optional) fetch api implementation. Default: built-in fetch
+     * @returns The credential status assertion
+     * @throws {IssuerResponseError} with a specific code for more context
+     */
+    get(issuerConf: IssuerConfig, credential: string, format: CredentialFormat | SupportedSdJwtLegacyFormat, context: {
+        appFetch?: typeof fetch;
+        credentialCryptoContext: CryptoContext;
+        wiaCryptoContext: CryptoContext;
+    }): Promise<{
+        statusAssertion: string;
+    }>;
+    isSupported: true;
+    /**
+     * Given a status assertion, verifies that:
+     * - It's in the supported format;
+     * - The assertion is correctly signed;
+     * - It's bound to the given key.
+     * @since 1.0.0
+     * @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`
+     * @param credential The encoded credential whose status is being verified
+     * @param format The credential format, e.g. "dc+sd-jwt"
+     * @returns A parsed status assertion
+     * @throws {IoWalletError} If the credential signature is not verified with the Issuer key set
+     * @throws {IssuerResponseError} If the status assertion contains an error or the credential status is invalid
+     */
+    verifyAndParse(issuerConf: IssuerConfig, statusAssertion: Out<StatusAssertionApi["get"]>, credential: string, format: CredentialFormat | SupportedSdJwtLegacyFormat): Promise<{
+        parsedStatusAssertion: ParsedStatusAssertion;
+    }>;
+}
+//# sourceMappingURL=status-assertion.d.ts.map

package/lib/typescript/module/credential/status/api/status-assertion.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"status-assertion.d.ts","sourceRoot":"","sources":["../../../../../../src/credential/status/api/status-assertion.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,6BAA6B,CAAC;AAEjE,OAAO,KAAK,EAAE,0BAA0B,EAAE,MAAM,0BAAuB,CAAC;AACxE,OAAO,KAAK,EAAE,GAAG,EAAE,MAAM,wBAAqB,CAAC;AAC/C,OAAO,KAAK,EAAE,gBAAgB,EAAE,YAAY,EAAE,MAAM,6BAAoB,CAAC;AACzE,OAAO,KAAK,EAAE,qBAAqB,EAAE,MAAM,YAAS,CAAC;AAErD,MAAM,WAAW,kBAAkB;IACjC;;;;;;;;;;;;;OAaG;IACH,GAAG,CACD,UAAU,EAAE,YAAY,EACxB,UAAU,EAAE,MAAM,EAClB,MAAM,EAAE,gBAAgB,GAAG,0BAA0B,EACrD,OAAO,EAAE;QACP,QAAQ,CAAC,EAAE,OAAO,KAAK,CAAC;QACxB,uBAAuB,EAAE,aAAa,CAAC;QACvC,gBAAgB,EAAE,aAAa,CAAC;KACjC,GACA,OAAO,CAAC;QAAE,eAAe,EAAE,MAAM,CAAA;KAAE,CAAC,CAAC;IAExC,WAAW,EAAE,IAAI,CAAC;IAElB;;;;;;;;;;;;;;;OAeG;IACH,cAAc,CACZ,UAAU,EAAE,YAAY,EACxB,eAAe,EAAE,GAAG,CAAC,kBAAkB,CAAC,KAAK,CAAC,CAAC,EAC/C,UAAU,EAAE,MAAM,EAClB,MAAM,EAAE,gBAAgB,GAAG,0BAA0B,GACpD,OAAO,CAAC;QAAE,qBAAqB,EAAE,qBAAqB,CAAA;KAAE,CAAC,CAAC;CAC9D"}