@pagopa/io-react-native-wallet 0.2.1 → 0.2.3

package/lib/typescript/src/pid/metadata.d.ts

@@ -0,0 +1,528 @@
+import { z } from "zod";
+export type PidDisplayMetadata = z.infer<typeof PidDisplayMetadata>;
+export declare const PidDisplayMetadata: z.ZodObject<{
+    name: z.ZodString;
+    locale: z.ZodString;
+    logo: z.ZodObject<{
+        url: z.ZodString;
+        alt_text: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        url: string;
+        alt_text: string;
+    }, {
+        url: string;
+        alt_text: string;
+    }>;
+    background_color: z.ZodString;
+    text_color: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    name: string;
+    locale: string;
+    logo: {
+        url: string;
+        alt_text: string;
+    };
+    background_color: string;
+    text_color: string;
+}, {
+    name: string;
+    locale: string;
+    logo: {
+        url: string;
+        alt_text: string;
+    };
+    background_color: string;
+    text_color: string;
+}>;
+export type PidIssuerEntityConfiguration = z.infer<typeof PidIssuerEntityConfiguration>;
+export declare const PidIssuerEntityConfiguration: z.ZodObject<{
+    jwks: z.ZodObject<{
+        keys: z.ZodArray<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, "many">>;
+            kid: z.ZodOptional<z.ZodString>;
+            kty: z.ZodUnion<[z.ZodLiteral<"RSA">, z.ZodLiteral<"EC">]>;
+            n: z.ZodOptional<z.ZodString>;
+            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>;
+            y: z.ZodOptional<z.ZodString>;
+            x5c: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+            x5t: z.ZodOptional<z.ZodString>;
+            "x5t#S256": z.ZodOptional<z.ZodString>;
+            x5u: z.ZodOptional<z.ZodString>;
+        }, "strip", z.ZodTypeAny, {
+            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;
+            y?: string | undefined;
+            x5c?: string[] | undefined;
+            x5t?: string | undefined;
+            "x5t#S256"?: string | undefined;
+            x5u?: string | undefined;
+        }, {
+            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;
+            y?: string | undefined;
+            x5c?: string[] | undefined;
+            x5t?: string | undefined;
+            "x5t#S256"?: string | undefined;
+            x5u?: string | undefined;
+        }>, "many">;
+    }, "strip", z.ZodTypeAny, {
+        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;
+            y?: string | undefined;
+            x5c?: string[] | undefined;
+            x5t?: string | undefined;
+            "x5t#S256"?: string | undefined;
+            x5u?: string | undefined;
+        }[];
+    }, {
+        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;
+            y?: string | undefined;
+            x5c?: string[] | undefined;
+            x5t?: string | undefined;
+            "x5t#S256"?: string | undefined;
+            x5u?: string | undefined;
+        }[];
+    }>;
+    metadata: z.ZodObject<{
+        openid_credential_issuer: z.ZodObject<{
+            credential_issuer: z.ZodString;
+            authorization_endpoint: z.ZodString;
+            token_endpoint: z.ZodString;
+            pushed_authorization_request_endpoint: z.ZodString;
+            dpop_signing_alg_values_supported: z.ZodArray<z.ZodString, "many">;
+            credential_endpoint: z.ZodString;
+            credentials_supported: z.ZodObject<{
+                "eu.eudiw.pid.it": z.ZodObject<{
+                    format: z.ZodLiteral<"vc+sd-jwt">;
+                    cryptographic_binding_methods_supported: z.ZodArray<z.ZodString, "many">;
+                    cryptographic_suites_supported: z.ZodArray<z.ZodString, "many">;
+                    display: z.ZodArray<z.ZodObject<{
+                        name: z.ZodString;
+                        locale: z.ZodString;
+                        logo: z.ZodObject<{
+                            url: z.ZodString;
+                            alt_text: z.ZodString;
+                        }, "strip", z.ZodTypeAny, {
+                            url: string;
+                            alt_text: string;
+                        }, {
+                            url: string;
+                            alt_text: string;
+                        }>;
+                        background_color: z.ZodString;
+                        text_color: z.ZodString;
+                    }, "strip", z.ZodTypeAny, {
+                        name: string;
+                        locale: string;
+                        logo: {
+                            url: string;
+                            alt_text: string;
+                        };
+                        background_color: string;
+                        text_color: string;
+                    }, {
+                        name: string;
+                        locale: string;
+                        logo: {
+                            url: string;
+                            alt_text: string;
+                        };
+                        background_color: string;
+                        text_color: string;
+                    }>, "many">;
+                }, "strip", z.ZodTypeAny, {
+                    format: "vc+sd-jwt";
+                    cryptographic_binding_methods_supported: string[];
+                    cryptographic_suites_supported: string[];
+                    display: {
+                        name: string;
+                        locale: string;
+                        logo: {
+                            url: string;
+                            alt_text: string;
+                        };
+                        background_color: string;
+                        text_color: string;
+                    }[];
+                }, {
+                    format: "vc+sd-jwt";
+                    cryptographic_binding_methods_supported: string[];
+                    cryptographic_suites_supported: string[];
+                    display: {
+                        name: string;
+                        locale: string;
+                        logo: {
+                            url: string;
+                            alt_text: string;
+                        };
+                        background_color: string;
+                        text_color: string;
+                    }[];
+                }>;
+            }, "strip", z.ZodTypeAny, {
+                "eu.eudiw.pid.it": {
+                    format: "vc+sd-jwt";
+                    cryptographic_binding_methods_supported: string[];
+                    cryptographic_suites_supported: string[];
+                    display: {
+                        name: string;
+                        locale: string;
+                        logo: {
+                            url: string;
+                            alt_text: string;
+                        };
+                        background_color: string;
+                        text_color: string;
+                    }[];
+                };
+            }, {
+                "eu.eudiw.pid.it": {
+                    format: "vc+sd-jwt";
+                    cryptographic_binding_methods_supported: string[];
+                    cryptographic_suites_supported: string[];
+                    display: {
+                        name: string;
+                        locale: string;
+                        logo: {
+                            url: string;
+                            alt_text: string;
+                        };
+                        background_color: string;
+                        text_color: string;
+                    }[];
+                };
+            }>;
+        }, "strip", z.ZodTypeAny, {
+            credential_issuer: string;
+            authorization_endpoint: string;
+            token_endpoint: string;
+            pushed_authorization_request_endpoint: string;
+            dpop_signing_alg_values_supported: string[];
+            credential_endpoint: string;
+            credentials_supported: {
+                "eu.eudiw.pid.it": {
+                    format: "vc+sd-jwt";
+                    cryptographic_binding_methods_supported: string[];
+                    cryptographic_suites_supported: string[];
+                    display: {
+                        name: string;
+                        locale: string;
+                        logo: {
+                            url: string;
+                            alt_text: string;
+                        };
+                        background_color: string;
+                        text_color: string;
+                    }[];
+                };
+            };
+        }, {
+            credential_issuer: string;
+            authorization_endpoint: string;
+            token_endpoint: string;
+            pushed_authorization_request_endpoint: string;
+            dpop_signing_alg_values_supported: string[];
+            credential_endpoint: string;
+            credentials_supported: {
+                "eu.eudiw.pid.it": {
+                    format: "vc+sd-jwt";
+                    cryptographic_binding_methods_supported: string[];
+                    cryptographic_suites_supported: string[];
+                    display: {
+                        name: string;
+                        locale: string;
+                        logo: {
+                            url: string;
+                            alt_text: string;
+                        };
+                        background_color: string;
+                        text_color: string;
+                    }[];
+                };
+            };
+        }>;
+        federation_entity: z.ZodObject<{
+            organization_name: z.ZodString;
+            homepage_uri: z.ZodString;
+            policy_uri: z.ZodString;
+            tos_uri: z.ZodString;
+            logo_uri: z.ZodString;
+        }, "strip", z.ZodTypeAny, {
+            organization_name: string;
+            homepage_uri: string;
+            policy_uri: string;
+            tos_uri: string;
+            logo_uri: string;
+        }, {
+            organization_name: string;
+            homepage_uri: string;
+            policy_uri: string;
+            tos_uri: string;
+            logo_uri: string;
+        }>;
+    }, "strip", z.ZodTypeAny, {
+        openid_credential_issuer: {
+            credential_issuer: string;
+            authorization_endpoint: string;
+            token_endpoint: string;
+            pushed_authorization_request_endpoint: string;
+            dpop_signing_alg_values_supported: string[];
+            credential_endpoint: string;
+            credentials_supported: {
+                "eu.eudiw.pid.it": {
+                    format: "vc+sd-jwt";
+                    cryptographic_binding_methods_supported: string[];
+                    cryptographic_suites_supported: string[];
+                    display: {
+                        name: string;
+                        locale: string;
+                        logo: {
+                            url: string;
+                            alt_text: string;
+                        };
+                        background_color: string;
+                        text_color: string;
+                    }[];
+                };
+            };
+        };
+        federation_entity: {
+            organization_name: string;
+            homepage_uri: string;
+            policy_uri: string;
+            tos_uri: string;
+            logo_uri: string;
+        };
+    }, {
+        openid_credential_issuer: {
+            credential_issuer: string;
+            authorization_endpoint: string;
+            token_endpoint: string;
+            pushed_authorization_request_endpoint: string;
+            dpop_signing_alg_values_supported: string[];
+            credential_endpoint: string;
+            credentials_supported: {
+                "eu.eudiw.pid.it": {
+                    format: "vc+sd-jwt";
+                    cryptographic_binding_methods_supported: string[];
+                    cryptographic_suites_supported: string[];
+                    display: {
+                        name: string;
+                        locale: string;
+                        logo: {
+                            url: string;
+                            alt_text: string;
+                        };
+                        background_color: string;
+                        text_color: string;
+                    }[];
+                };
+            };
+        };
+        federation_entity: {
+            organization_name: string;
+            homepage_uri: string;
+            policy_uri: string;
+            tos_uri: string;
+            logo_uri: string;
+        };
+    }>;
+}, "strip", z.ZodTypeAny, {
+    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;
+            y?: string | undefined;
+            x5c?: string[] | undefined;
+            x5t?: string | undefined;
+            "x5t#S256"?: string | undefined;
+            x5u?: string | undefined;
+        }[];
+    };
+    metadata: {
+        openid_credential_issuer: {
+            credential_issuer: string;
+            authorization_endpoint: string;
+            token_endpoint: string;
+            pushed_authorization_request_endpoint: string;
+            dpop_signing_alg_values_supported: string[];
+            credential_endpoint: string;
+            credentials_supported: {
+                "eu.eudiw.pid.it": {
+                    format: "vc+sd-jwt";
+                    cryptographic_binding_methods_supported: string[];
+                    cryptographic_suites_supported: string[];
+                    display: {
+                        name: string;
+                        locale: string;
+                        logo: {
+                            url: string;
+                            alt_text: string;
+                        };
+                        background_color: string;
+                        text_color: string;
+                    }[];
+                };
+            };
+        };
+        federation_entity: {
+            organization_name: string;
+            homepage_uri: string;
+            policy_uri: string;
+            tos_uri: string;
+            logo_uri: 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;
+            y?: string | undefined;
+            x5c?: string[] | undefined;
+            x5t?: string | undefined;
+            "x5t#S256"?: string | undefined;
+            x5u?: string | undefined;
+        }[];
+    };
+    metadata: {
+        openid_credential_issuer: {
+            credential_issuer: string;
+            authorization_endpoint: string;
+            token_endpoint: string;
+            pushed_authorization_request_endpoint: string;
+            dpop_signing_alg_values_supported: string[];
+            credential_endpoint: string;
+            credentials_supported: {
+                "eu.eudiw.pid.it": {
+                    format: "vc+sd-jwt";
+                    cryptographic_binding_methods_supported: string[];
+                    cryptographic_suites_supported: string[];
+                    display: {
+                        name: string;
+                        locale: string;
+                        logo: {
+                            url: string;
+                            alt_text: string;
+                        };
+                        background_color: string;
+                        text_color: string;
+                    }[];
+                };
+            };
+        };
+        federation_entity: {
+            organization_name: string;
+            homepage_uri: string;
+            policy_uri: string;
+            tos_uri: string;
+            logo_uri: string;
+        };
+    };
+}>;
+//# sourceMappingURL=metadata.d.ts.map

package/lib/typescript/src/pid/metadata.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"metadata.d.ts","sourceRoot":"","sources":["../../../../src/pid/metadata.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB,MAAM,MAAM,kBAAkB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,kBAAkB,CAAC,CAAC;AACpE,eAAO,MAAM,kBAAkB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAS7B,CAAC;AAEH,MAAM,MAAM,4BAA4B,GAAG,CAAC,CAAC,KAAK,CAChD,OAAO,4BAA4B,CACpC,CAAC;AACF,eAAO,MAAM,4BAA4B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EA2BvC,CAAC"}

package/lib/typescript/src/pid/sd-jwt/converters.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"converters.d.ts","sourceRoot":"","sources":["../../../../../src/pid/sd-jwt/converters.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,UAAU,EAAE,QAAQ,EAAE,MAAM,oBAAoB,CAAC;AAC/D,OAAO,EAAE,GAAG,EAAE,MAAM,SAAS,CAAC;AAE9B,wBAAgB,YAAY,CAAC,KAAK,EAAE,QAAQ,EAAE,WAAW,EAAE,UAAU,EAAE,GAAG,GAAG,CAqB5E"}

package/lib/typescript/{pid → src/pid}/sd-jwt/index.d.ts

@@ -37,7 +37,7 @@ export declare function decode(token: string): PidWithToken;
  *
  */
 export declare function verify(token: string): Promise<VerifyResult>;
-type PidWithToken = {
+export type PidWithToken = {
     pid: PID;
     sdJwt: SdJwt4VC;
     disclosures: Disclosure[];

package/lib/typescript/src/pid/sd-jwt/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/pid/sd-jwt/index.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,GAAG,EAAE,MAAM,SAAS,CAAC;AAE9B,OAAO,EAAE,UAAU,EAAE,QAAQ,EAAE,MAAM,oBAAoB,CAAC;AAE1D;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,MAAM,CAAC,KAAK,EAAE,MAAM,GAAG,YAAY,CASlD;AAED;;;;;;;;;;;;;;;;;;;GAmBG;AACH,wBAAsB,MAAM,CAAC,KAAK,EAAE,MAAM,GAAG,OAAO,CAAC,YAAY,CAAC,CAMjE;AAED,MAAM,MAAM,YAAY,GAAG;IAEzB,GAAG,EAAE,GAAG,CAAC;IAET,KAAK,EAAE,QAAQ,CAAC;IAEhB,WAAW,EAAE,UAAU,EAAE,CAAC;CAC3B,CAAC;AAEF;;GAEG;AACH,MAAM,MAAM,YAAY,GAAG,YAAY,CAAC;AAExC,OAAO,EAAE,GAAG,EAAE,MAAM,SAAS,CAAC"}

package/lib/typescript/src/pid/sd-jwt/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../../../../src/pid/sd-jwt/types.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAoBxB;;;;;GAKG;AACH,MAAM,MAAM,GAAG,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,GAAG,CAAC,CAAC;AACtC,eAAO,MAAM,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAgBd,CAAC"}

package/lib/typescript/src/rp/__test__/index.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.test.d.ts","sourceRoot":"","sources":["../../../../../src/rp/__test__/index.test.ts"],"names":[],"mappings":""}

package/lib/typescript/src/rp/index.d.ts

@@ -0,0 +1,89 @@
+import { QRCodePayload, RequestObject, RpEntityConfiguration, type Presentation } from "./types";
+import type { JWK } from "@pagopa/io-react-native-jwt/lib/typescript/types";
+export declare class RelyingPartySolution {
+    relyingPartyBaseUrl: string;
+    walletInstanceAttestation: string;
+    appFetch: GlobalFetch["fetch"];
+    constructor(relyingPartyBaseUrl: string, walletInstanceAttestation: string, appFetch?: GlobalFetch["fetch"]);
+    /**
+     * Decode a QR code content to an authentication request url.
+     * @function
+     * @param qrcode QR code content
+     *
+     * @returns The authentication request url
+     *
+     */
+    static decodeAuthRequestQR(qrcode: string): QRCodePayload;
+    /**
+     * Obtain the unsigned wallet instance DPoP for authentication request
+     *
+     * @function
+     * @param walletInstanceAttestationJwk JWT of the Wallet Instance Attestation
+     * @param authRequestUrl authentication request url
+     *
+     * @returns The unsigned wallet instance DPoP
+     *
+     */
+    getUnsignedWalletInstanceDPoP(walletInstanceAttestationJwk: JWK, authRequestUrl: string): Promise<string>;
+    /**
+     * Obtain the Request Object for RP authentication
+     * @see https://italia.github.io/eudi-wallet-it-docs/versione-corrente/en/relying-party-solution.html
+     *
+     * @async @function
+     * @param signedWalletInstanceDPoP JWT of the Wallet Instance Attestation DPoP
+     *
+     * @returns The Request Object JWT
+     * @throws {NoSuitableKeysFoundInEntityConfiguration} When the Request Object is signed with a key not listed in RP's entity configuration
+     *
+     */
+    getRequestObject(signedWalletInstanceDPoP: string, entity: RpEntityConfiguration): Promise<RequestObject>;
+    /**
+     * Prepare the Verified Presentation token for a received request object in the context of an authorization request flow.
+     * The presentation is prepared by disclosing data from provided credentials, according to requested claims
+     * Each Verified Credential come along with the claims the user accepts to disclose from it.
+     *
+     * The returned token is unsigned (sign should be apply by the caller).
+     *
+     * @todo accept more than a Verified Credential
+     *
+     * @param requestObj The incoming request object, which the requirements for the requested authorization
+     * @param presentation The Verified Credential containing user data along with the list of claims to be disclosed.
+     * @returns The unsigned Verified Presentation token
+     * @throws {ClaimsNotFoundBetweenDislosures} If the Verified Credential does not contain one or more requested claims.
+     *
+     */
+    prepareVpToken(requestObj: RequestObject, [vc, claims]: Presentation): Promise<{
+        vp_token: string;
+        presentation_submission: Record<string, unknown>;
+    }>;
+    /**
+     * Compose and send an Authorization Response in the context of an authorization request flow.
+     *
+     * @todo MUST add presentation_submission
+     *
+     * @param requestObj The incoming request object, which the requirements for the requested authorization
+     * @param vp_token The signed Verified Presentation token with data to send.
+     * @param presentation_submission
+     * @param entity The RP entity configuration
+     * @returns The response from the RP
+     * @throws {IoWalletError} if the submission fails.
+     * @throws {NoSuitableKeysFoundInEntityConfiguration} If entity do not contain any public key
+     *
+     */
+    sendAuthorizationResponse(requestObj: RequestObject, vp_token: string, presentation_submission: Record<string, unknown>, entity: RpEntityConfiguration): Promise<string>;
+    /**
+     * Select a public key from those provided by the RP.
+     * Keys with algorithm "RSA-OAEP-256" or "RSA-OAEP" are expected, the firsts to be preferred.
+     *
+     * @param entity The RP entity configuration
+     * @returns A suitable public key with its compatible encryption algorithm
+     * @throws {NoSuitableKeysFoundInEntityConfiguration} If entity do not contain any public key suitable for encrypting
+     */
+    private choosePublicKeyToEncrypt;
+    private getEncryptionAlgByJwk;
+    /**
+     * Obtain the relying party entity configuration.
+     */
+    getEntityConfiguration(): Promise<RpEntityConfiguration>;
+}
+//# sourceMappingURL=index.d.ts.map

package/lib/typescript/src/rp/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/rp/index.ts"],"names":[],"mappings":"AAaA,OAAO,EACL,aAAa,EACb,aAAa,EACb,qBAAqB,EACrB,KAAK,YAAY,EAClB,MAAM,SAAS,CAAC;AAGjB,OAAO,KAAK,EAAE,GAAG,EAAE,MAAM,kDAAkD,CAAC;AAG5E,qBAAa,oBAAoB;IAC/B,mBAAmB,EAAE,MAAM,CAAC;IAC5B,yBAAyB,EAAE,MAAM,CAAC;IAClC,QAAQ,EAAE,WAAW,CAAC,OAAO,CAAC,CAAC;gBAG7B,mBAAmB,EAAE,MAAM,EAC3B,yBAAyB,EAAE,MAAM,EACjC,QAAQ,GAAE,WAAW,CAAC,OAAO,CAAS;IAOxC;;;;;;;OAOG;IACH,MAAM,CAAC,mBAAmB,CAAC,MAAM,EAAE,MAAM,GAAG,aAAa;IAqBzD;;;;;;;;;OASG;IACG,6BAA6B,CACjC,4BAA4B,EAAE,GAAG,EACjC,cAAc,EAAE,MAAM,GACrB,OAAO,CAAC,MAAM,CAAC;IAiBlB;;;;;;;;;;OAUG;IACG,gBAAgB,CACpB,wBAAwB,EAAE,MAAM,EAChC,MAAM,EAAE,qBAAqB,GAC5B,OAAO,CAAC,aAAa,CAAC;IA2CzB;;;;;;;;;;;;;;OAcG;IACG,cAAc,CAClB,UAAU,EAAE,aAAa,EACzB,CAAC,EAAE,EAAE,MAAM,CAAC,EAAE,YAAY,GACzB,OAAO,CAAC;QACT,QAAQ,EAAE,MAAM,CAAC;QACjB,uBAAuB,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;KAClD,CAAC;IA6BF;;;;;;;;;;;;;OAaG;IACG,yBAAyB,CAC7B,UAAU,EAAE,aAAa,EACzB,QAAQ,EAAE,MAAM,EAChB,uBAAuB,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAChD,MAAM,EAAE,qBAAqB,GAC5B,OAAO,CAAC,MAAM,CAAC;IAkClB;;;;;;;OAOG;IACH,OAAO,CAAC,wBAAwB;IA6BhC,OAAO,CAAC,qBAAqB;IAY7B;;OAEG;IACG,sBAAsB,IAAI,OAAO,CAAC,qBAAqB,CAAC;CAuB/D"}