@pagopa/io-react-native-wallet 2.5.0 → 3.0.0

package/lib/typescript/credential/issuance/api/03-complete-user-authorization.d.ts

@@ -0,0 +1,78 @@
+import type { CryptoContext } from "@pagopa/io-react-native-jwt";
+import type { AuthorizationChallengeResult, AuthorizationResult } from "../../../utils/auth";
+import type { RequestObject } from "../../../credential/presentation/api";
+import type { IssuerConfig } from "./IssuerConfig";
+export interface CompleteUserAuthorizationApi {
+    /**
+     * WARNING: This function must be called after {@link startUserAuthorization}. The next function to be called is {@link completeUserAuthorizationWithFormPostJwtMode}.
+     *
+     * The interface of the phase to complete User authorization via presentation of existing credentials when the response mode is "form_post.jwt".
+     * It is used as a first step to complete the user authorization by obtaining the requested credential to be presented from the authorization server.
+     * The information is obtained by performing a GET request to the authorization endpoint with request_uri and client_id parameters.
+     * @since 1.0.0
+     *
+     * @param issuerRequestUri the URI of the issuer where the request is sent
+     * @param clientId Identifies the current client across all the requests of the issuing flow returned by {@link startUserAuthorization}
+     * @param issuerConf The issuer configuration returned by {@link evaluateIssuerTrust}
+     * @param appFetch (optional) fetch api implementation. Default: built-in fetch
+     * @returns the request object which contains the credential to be presented in order to obtain the requested credential
+     * @throws {ValidationFailed} if an error while validating the response
+     */
+    getRequestedCredentialToBePresented(issuerRequestUri: string, clientId: string, issuerConf: IssuerConfig, appFetch?: GlobalFetch["fetch"]): Promise<RequestObject>;
+    /**
+     * WARNING: This function must be called after obtaining the authorization redirect URL from the webviews (SPID and CIE L3) or browser for CIEID.
+     *
+     * Complete User authorization via strong identification when the response mode is "query" and the request credential is a PersonIdentificationData.
+     * This function parses the authorization redirect URL to extract the authorization response.
+     * @since 1.0.0
+     *
+     * @param authRedirectUrl The URL to which the end user should be redirected to start the authentication flow
+     * @returns the authorization response which contains code, state and iss
+     */
+    completeUserAuthorizationWithQueryMode(authRedirectUrl: string): Promise<AuthorizationResult>;
+    /**
+     * WARNING: This function must be called after {@link getRequestedCredentialToBePresented}. The next function to be called is {@link authorizeAccess}.
+     *
+     * The interface of the phase to complete User authorization via presentation of existing credentials when the response mode is "form_post.jwt".
+     * The information is obtained by performing a POST request to the endpoint received in the response_uri field of the requestObject, where the Authorization Response payload is posted.
+     * Following this,the redirect_uri from the response is used to obtain the final authorization response.
+     * @since 1.0.0
+     *
+     * @param requestObject - The request object containing the necessary parameters for authorization.
+     * @param pid The `PID` that must be presented for the issuance of credentials.
+     * @param appFetch (optional) fetch api implementation. Default: built-in fetch
+     * @returns the authorization response which contains code, state and iss
+     * @throws {ValidationFailed} if an error while validating the response
+     */
+    completeUserAuthorizationWithFormPostJwtMode(requestObject: RequestObject, issuerConf: IssuerConfig, pid: string, context: {
+        wiaCryptoContext: CryptoContext;
+        pidKeyTag: string;
+        appFetch?: GlobalFetch["fetch"];
+    }): Promise<AuthorizationResult>;
+    /**
+     * WARNING: this function must be called after obtaining the authorization redirect URL from the webviews (SPID and CIE L3) or browser for CIEID, and the PID
+     * issuance requires a MRTD PoP challenge.
+     * @since 1.0.0
+     *
+     * @param authRedirectUrl The URL to which the end user should be redirected to start the MRTD PoP validation flow
+     * @returns the authorization response which contains the challenge
+     */
+    continueUserAuthorizationWithMRTDPoPChallenge(authRedirectUrl: string): Promise<AuthorizationChallengeResult>;
+    /**
+     * WARNING: This function must be called after {@link startUserAuthorization}.
+     *
+     * The generated authUrl must be used to open a browser or webview capable of catching the redirectSchema to perform a get request to the authorization endpoint.
+     * Builds the authorization URL to which the end user should be redirected to continue the authentication flow.
+     * @since 1.0.0
+     *
+     * @param issuerRequestUri the URI of the issuer where the request is sent
+     * @param clientId Identifies the current client across all the requests of the issuing flow returned by {@link startUserAuthorization}
+     * @param issuerConf The issuer configuration returned by {@link evaluateIssuerTrust}
+     * @param idpHint Unique identifier of the IDP selected by the user (optional)
+     * @returns An object containing the authorization URL
+     */
+    buildAuthorizationUrl(issuerRequestUri: string, clientId: string, issuerConf: IssuerConfig, idpHint?: string): Promise<{
+        authUrl: string;
+    }>;
+}
+//# sourceMappingURL=03-complete-user-authorization.d.ts.map

package/lib/typescript/credential/issuance/api/03-complete-user-authorization.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"03-complete-user-authorization.d.ts","sourceRoot":"","sources":["../../../../../src/credential/issuance/api/03-complete-user-authorization.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,6BAA6B,CAAC;AACjE,OAAO,KAAK,EACV,4BAA4B,EAC5B,mBAAmB,EACpB,MAAM,qBAAqB,CAAC;AAC7B,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,sCAAsC,CAAC;AAC1E,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,gBAAgB,CAAC;AAEnD,MAAM,WAAW,4BAA4B;IAC3C;;;;;;;;;;;;;;OAcG;IACH,mCAAmC,CACjC,gBAAgB,EAAE,MAAM,EACxB,QAAQ,EAAE,MAAM,EAChB,UAAU,EAAE,YAAY,EACxB,QAAQ,CAAC,EAAE,WAAW,CAAC,OAAO,CAAC,GAC9B,OAAO,CAAC,aAAa,CAAC,CAAC;IAE1B;;;;;;;;;OASG;IACH,sCAAsC,CACpC,eAAe,EAAE,MAAM,GACtB,OAAO,CAAC,mBAAmB,CAAC,CAAC;IAEhC;;;;;;;;;;;;;OAaG;IACH,4CAA4C,CAC1C,aAAa,EAAE,aAAa,EAC5B,UAAU,EAAE,YAAY,EACxB,GAAG,EAAE,MAAM,EACX,OAAO,EAAE;QACP,gBAAgB,EAAE,aAAa,CAAC;QAChC,SAAS,EAAE,MAAM,CAAC;QAClB,QAAQ,CAAC,EAAE,WAAW,CAAC,OAAO,CAAC,CAAC;KACjC,GACA,OAAO,CAAC,mBAAmB,CAAC,CAAC;IAEhC;;;;;;;OAOG;IACH,6CAA6C,CAC3C,eAAe,EAAE,MAAM,GACtB,OAAO,CAAC,4BAA4B,CAAC,CAAC;IAEzC;;;;;;;;;;;;OAYG;IACH,qBAAqB,CACnB,gBAAgB,EAAE,MAAM,EACxB,QAAQ,EAAE,MAAM,EAChB,UAAU,EAAE,YAAY,EACxB,OAAO,CAAC,EAAE,MAAM,GACf,OAAO,CAAC;QAAE,OAAO,EAAE,MAAM,CAAA;KAAE,CAAC,CAAC;CACjC"}

package/lib/typescript/credential/issuance/api/04-authorize-access.d.ts

@@ -0,0 +1,33 @@
+import type { CryptoContext } from "@pagopa/io-react-native-jwt";
+import type { IssuerConfig } from "./IssuerConfig";
+import type { TokenResponse } from "./types";
+export interface AuthorizeAccessApi {
+    /**
+     * Creates and sends the DPoP Proof JWT to be presented with the authorization code to the /token endpoint of the authorization server
+     * for requesting the issuance of an access token bound to the public key of the Wallet Instance contained within the DPoP.
+     * This enables the Wallet Instance to request a digital credential.
+     * The DPoP Proof JWT is generated according to the section 4.3 of the DPoP RFC 9449 specification.
+     * @since 1.0.0
+     *
+     * @param issuerConf The issuer configuration returned by {@link evaluateIssuerTrust}
+     * @param code The authorization code returned by {@link completeUserAuthorizationWithQueryMode} or {@link completeUserAuthorizationWithFormPost}
+     * @param redirectUri The redirect URI which is the custom URL scheme that the Wallet Instance is registered to handle
+     * @param codeVerifier The code verifier returned by {@link startUserAuthorization}
+     * @param context.walletInstanceAttestation The Wallet Instance's attestation
+     * @param context.wiaCryptoContext The Wallet Instance's crypto context
+     * @param context.dPopCryptoContext The DPoP crypto context
+     * @param context.appFetch (optional) fetch api implementation. Default: built-in fetch
+     * @return The token response containing the access token along with the token request signed with DPoP which has to be used in the {@link obtainCredential} step.
+     * @throws {ValidationFailed} if an error occurs while parsing the token response
+     * @throws {IssuerResponseError} with a specific code for more context
+     */
+    authorizeAccess(issuerConf: IssuerConfig, code: string, redirectUri: string, codeVerifier: string, context: {
+        walletInstanceAttestation: string;
+        wiaCryptoContext: CryptoContext;
+        dPopCryptoContext: CryptoContext;
+        appFetch?: GlobalFetch["fetch"];
+    }): Promise<{
+        accessToken: TokenResponse;
+    }>;
+}
+//# sourceMappingURL=04-authorize-access.d.ts.map

package/lib/typescript/credential/issuance/api/04-authorize-access.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"04-authorize-access.d.ts","sourceRoot":"","sources":["../../../../../src/credential/issuance/api/04-authorize-access.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,6BAA6B,CAAC;AACjE,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,gBAAgB,CAAC;AACnD,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,SAAS,CAAC;AAE7C,MAAM,WAAW,kBAAkB;IACjC;;;;;;;;;;;;;;;;;;OAkBG;IACH,eAAe,CACb,UAAU,EAAE,YAAY,EACxB,IAAI,EAAE,MAAM,EACZ,WAAW,EAAE,MAAM,EACnB,YAAY,EAAE,MAAM,EACpB,OAAO,EAAE;QACP,yBAAyB,EAAE,MAAM,CAAC;QAClC,gBAAgB,EAAE,aAAa,CAAC;QAChC,iBAAiB,EAAE,aAAa,CAAC;QACjC,QAAQ,CAAC,EAAE,WAAW,CAAC,OAAO,CAAC,CAAC;KACjC,GACA,OAAO,CAAC;QAAE,WAAW,EAAE,aAAa,CAAA;KAAE,CAAC,CAAC;CAC5C"}

package/lib/typescript/credential/issuance/api/05-obtain-credential.d.ts

@@ -0,0 +1,36 @@
+import type { CryptoContext } from "@pagopa/io-react-native-jwt";
+import type { Out } from "../../../utils/misc";
+import type { IssuerConfig } from "./IssuerConfig";
+import type { AuthorizeAccessApi } from "./04-authorize-access";
+import type { CredentialFormat } from "./types";
+export interface ObtainCredentialApi {
+    /**
+     * Obtains the credential from the issuer.
+     * The key pair of the credentialCryptoContext is used for Openid4vci proof JWT to be presented with the Access Token and the DPoP Proof JWT at the Credential Endpoint
+     * of the Credential Issuer to request the issuance of a credential linked to the public key contained in the JWT proof.
+     * The Openid4vci proof JWT incapsulates the nonce extracted from the token response from the {@link authorizeAccess} step.
+     * The credential request is sent to the Credential Endpoint of the Credential Issuer via HTTP POST with the type of the credential, its format, the access token and the JWT proof.
+     * @since 1.0.0
+     *
+     * @param issuerConf The issuer configuration returned by {@link evaluateIssuerTrust}
+     * @param accessToken The access token response returned by {@link authorizeAccess}
+     * @param clientId The client id returned by {@link startUserAuthorization}
+     * @param credentialDefinition The credential definition of the credential to be obtained returned by {@link authorizeAccess}
+     * @param context.credentialCryptoContext The crypto context used to obtain the credential
+     * @param context.dPopCryptoContext The DPoP crypto context
+     * @param context.appFetch (optional) fetch api implementation. Default: built-in fetch
+     * @returns The credential response containing the credential
+     */
+    obtainCredential(issuerConf: IssuerConfig, accessToken: Out<AuthorizeAccessApi["authorizeAccess"]>["accessToken"], clientId: string, credentialDefinition: {
+        credential_configuration_id: string;
+        credential_identifier?: string;
+    }, context: {
+        dPopCryptoContext: CryptoContext;
+        credentialCryptoContext: CryptoContext;
+        appFetch?: GlobalFetch["fetch"];
+    }): Promise<{
+        credential: string;
+        format: CredentialFormat;
+    }>;
+}
+//# sourceMappingURL=05-obtain-credential.d.ts.map

package/lib/typescript/credential/issuance/api/05-obtain-credential.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"05-obtain-credential.d.ts","sourceRoot":"","sources":["../../../../../src/credential/issuance/api/05-obtain-credential.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,6BAA6B,CAAC;AACjE,OAAO,KAAK,EAAE,GAAG,EAAE,MAAM,qBAAqB,CAAC;AAC/C,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,gBAAgB,CAAC;AACnD,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,uBAAuB,CAAC;AAChE,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,SAAS,CAAC;AAEhD,MAAM,WAAW,mBAAmB;IAClC;;;;;;;;;;;;;;;;OAgBG;IACH,gBAAgB,CACd,UAAU,EAAE,YAAY,EACxB,WAAW,EAAE,GAAG,CAAC,kBAAkB,CAAC,iBAAiB,CAAC,CAAC,CAAC,aAAa,CAAC,EACtE,QAAQ,EAAE,MAAM,EAChB,oBAAoB,EAAE;QACpB,2BAA2B,EAAE,MAAM,CAAC;QACpC,qBAAqB,CAAC,EAAE,MAAM,CAAC;KAChC,EACD,OAAO,EAAE;QACP,iBAAiB,EAAE,aAAa,CAAC;QACjC,uBAAuB,EAAE,aAAa,CAAC;QACvC,QAAQ,CAAC,EAAE,WAAW,CAAC,OAAO,CAAC,CAAC;KACjC,GACA,OAAO,CAAC;QACT,UAAU,EAAE,MAAM,CAAC;QACnB,MAAM,EAAE,gBAAgB,CAAC;KAC1B,CAAC,CAAC;CACJ"}

package/lib/typescript/credential/issuance/api/06-verify-and-parse-credential.d.ts

@@ -0,0 +1,36 @@
+import type { CryptoContext } from "@pagopa/io-react-native-jwt";
+import type { IssuerConfig } from "./IssuerConfig";
+import type { ParsedCredential } from "./types";
+export interface VerifyAndParseCredentialApi {
+    /**
+     * Verify and parse an encoded credential.
+     * @since 1.0.0
+     *
+     * @param issuerConf The Issuer configuration returned by {@link evaluateIssuerTrust}
+     * @param credential The encoded credential returned by {@link obtainCredential}
+     * @param credentialConfigurationId The credential configuration ID that defines the provided credential
+     * @param context.credentialCryptoContext The crypto context used to obtain the credential in {@link obtainCredential}
+     * @param context.ignoreMissingAttributes Skip error when attributes declared in the issuer configuration are not found within disclosures
+     * @param context.includeUndefinedAttributes Include attributes not explicitly declared in the issuer configuration
+     * @returns A parsed credential with attributes in plain value, the expiration and issuance date of the credential
+     * @throws {IoWalletError} If the credential signature is not verified with the Issuer key set
+     * @throws {IoWalletError} If the credential is not bound to the provided user key
+     * @throws {IoWalletError} If the credential data fail to parse
+     */
+    verifyAndParseCredential(issuerConf: IssuerConfig, credential: string, credentialConfigurationId: string, context: {
+        credentialCryptoContext: CryptoContext;
+        /**
+         * Do not throw an error when an attribute is not found within disclosures.
+         */
+        ignoreMissingAttributes?: boolean;
+        /**
+         * Include attributes that are not explicitly mapped in the issuer configuration.
+         */
+        includeUndefinedAttributes?: boolean;
+    }, x509CertRoot?: string): Promise<{
+        parsedCredential: ParsedCredential;
+        expiration: Date;
+        issuedAt: Date | undefined;
+    }>;
+}
+//# sourceMappingURL=06-verify-and-parse-credential.d.ts.map

package/lib/typescript/credential/issuance/api/06-verify-and-parse-credential.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"06-verify-and-parse-credential.d.ts","sourceRoot":"","sources":["../../../../../src/credential/issuance/api/06-verify-and-parse-credential.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,6BAA6B,CAAC;AACjE,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,gBAAgB,CAAC;AACnD,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,SAAS,CAAC;AAEhD,MAAM,WAAW,2BAA2B;IAC1C;;;;;;;;;;;;;;OAcG;IACH,wBAAwB,CACtB,UAAU,EAAE,YAAY,EACxB,UAAU,EAAE,MAAM,EAClB,yBAAyB,EAAE,MAAM,EACjC,OAAO,EAAE;QACP,uBAAuB,EAAE,aAAa,CAAC;QACvC;;WAEG;QACH,uBAAuB,CAAC,EAAE,OAAO,CAAC;QAClC;;WAEG;QACH,0BAA0B,CAAC,EAAE,OAAO,CAAC;KACtC,EACD,YAAY,CAAC,EAAE,MAAM,GACpB,OAAO,CAAC;QACT,gBAAgB,EAAE,gBAAgB,CAAC;QACnC,UAAU,EAAE,IAAI,CAAC;QACjB,QAAQ,EAAE,IAAI,GAAG,SAAS,CAAC;KAC5B,CAAC,CAAC;CACJ"}

package/lib/typescript/credential/issuance/api/IssuerConfig.d.ts

@@ -0,0 +1,423 @@
+import { z } from "zod";
+/**
+ * Common Issuer configuration, decoupled from specific IT-Wallet versions.
+ */
+export type IssuerConfig = z.infer<typeof IssuerConfig>;
+export declare const IssuerConfig: z.ZodObject<{
+    credential_issuer: z.ZodString;
+    pushed_authorization_request_endpoint: z.ZodString;
+    authorization_endpoint: z.ZodString;
+    token_endpoint: z.ZodString;
+    nonce_endpoint: z.ZodString;
+    status_assertion_endpoint: z.ZodOptional<z.ZodString>;
+    credential_endpoint: z.ZodString;
+    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">;
+    credential_configurations_supported: z.ZodRecord<z.ZodString, z.ZodIntersection<z.ZodDiscriminatedUnion<"format", [z.ZodObject<{
+        format: z.ZodLiteral<"dc+sd-jwt">;
+        vct: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        format: "dc+sd-jwt";
+        vct: string;
+    }, {
+        format: "dc+sd-jwt";
+        vct: string;
+    }>, z.ZodObject<{
+        format: z.ZodLiteral<"mso_mdoc">;
+        doctype: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        format: "mso_mdoc";
+        doctype: string;
+    }, {
+        format: "mso_mdoc";
+        doctype: string;
+    }>]>, z.ZodObject<{
+        scope: z.ZodString;
+        display: z.ZodArray<z.ZodObject<{
+            name: z.ZodString;
+            locale: z.ZodString;
+        }, "strip", z.ZodTypeAny, {
+            name: string;
+            locale: string;
+        }, {
+            name: string;
+            locale: string;
+        }>, "many">;
+        claims: z.ZodArray<z.ZodObject<{
+            path: z.ZodArray<z.ZodUnion<[z.ZodString, z.ZodNumber, z.ZodNull]>, "many">;
+            display: z.ZodArray<z.ZodObject<{
+                name: z.ZodString;
+                locale: z.ZodString;
+            }, "strip", z.ZodTypeAny, {
+                name: string;
+                locale: string;
+            }, {
+                name: string;
+                locale: string;
+            }>, "many">;
+        }, "strip", z.ZodTypeAny, {
+            path: (string | number | null)[];
+            display: {
+                name: string;
+                locale: string;
+            }[];
+        }, {
+            path: (string | number | null)[];
+            display: {
+                name: string;
+                locale: string;
+            }[];
+        }>, "many">;
+        /**
+         * @deprecated Use the Credentials Catalogue to get the Auth Source
+         */
+        authentic_source: z.ZodOptional<z.ZodString>;
+        /**
+         * @deprecated Kept for backward compatibility with v0.7.1
+         */
+        issuance_errors_supported: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodObject<{
+            display: z.ZodArray<z.ZodObject<{
+                title: z.ZodString;
+                description: z.ZodString;
+                locale: z.ZodString;
+            }, "strip", z.ZodTypeAny, {
+                title: string;
+                locale: string;
+                description: string;
+            }, {
+                title: string;
+                locale: string;
+                description: string;
+            }>, "many">;
+        }, "strip", z.ZodTypeAny, {
+            display: {
+                title: string;
+                locale: string;
+                description: string;
+            }[];
+        }, {
+            display: {
+                title: string;
+                locale: string;
+                description: string;
+            }[];
+        }>>>;
+    }, "strip", z.ZodTypeAny, {
+        display: {
+            name: string;
+            locale: string;
+        }[];
+        scope: string;
+        claims: {
+            path: (string | number | null)[];
+            display: {
+                name: string;
+                locale: string;
+            }[];
+        }[];
+        authentic_source?: string | undefined;
+        issuance_errors_supported?: Record<string, {
+            display: {
+                title: string;
+                locale: string;
+                description: string;
+            }[];
+        }> | undefined;
+    }, {
+        display: {
+            name: string;
+            locale: string;
+        }[];
+        scope: string;
+        claims: {
+            path: (string | number | null)[];
+            display: {
+                name: string;
+                locale: string;
+            }[];
+        }[];
+        authentic_source?: string | undefined;
+        issuance_errors_supported?: Record<string, {
+            display: {
+                title: string;
+                locale: string;
+                description: string;
+            }[];
+        }> | undefined;
+    }>>>;
+    federation_entity: z.ZodObject<{
+        federation_fetch_endpoint: z.ZodOptional<z.ZodString>;
+        federation_list_endpoint: z.ZodOptional<z.ZodString>;
+        federation_resolve_endpoint: z.ZodOptional<z.ZodString>;
+        federation_trust_mark_status_endpoint: z.ZodOptional<z.ZodString>;
+        federation_trust_mark_list_endpoint: z.ZodOptional<z.ZodString>;
+        federation_trust_mark_endpoint: z.ZodOptional<z.ZodString>;
+        federation_historical_keys_endpoint: z.ZodOptional<z.ZodString>;
+        endpoint_auth_signing_alg_values_supported: z.ZodOptional<z.ZodString>;
+        organization_name: z.ZodOptional<z.ZodString>;
+        homepage_uri: z.ZodOptional<z.ZodString>;
+        policy_uri: z.ZodOptional<z.ZodString>;
+        logo_uri: z.ZodOptional<z.ZodString>;
+        contacts: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
+        federation_fetch_endpoint: z.ZodOptional<z.ZodString>;
+        federation_list_endpoint: z.ZodOptional<z.ZodString>;
+        federation_resolve_endpoint: z.ZodOptional<z.ZodString>;
+        federation_trust_mark_status_endpoint: z.ZodOptional<z.ZodString>;
+        federation_trust_mark_list_endpoint: z.ZodOptional<z.ZodString>;
+        federation_trust_mark_endpoint: z.ZodOptional<z.ZodString>;
+        federation_historical_keys_endpoint: z.ZodOptional<z.ZodString>;
+        endpoint_auth_signing_alg_values_supported: z.ZodOptional<z.ZodString>;
+        organization_name: z.ZodOptional<z.ZodString>;
+        homepage_uri: z.ZodOptional<z.ZodString>;
+        policy_uri: z.ZodOptional<z.ZodString>;
+        logo_uri: z.ZodOptional<z.ZodString>;
+        contacts: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
+        federation_fetch_endpoint: z.ZodOptional<z.ZodString>;
+        federation_list_endpoint: z.ZodOptional<z.ZodString>;
+        federation_resolve_endpoint: z.ZodOptional<z.ZodString>;
+        federation_trust_mark_status_endpoint: z.ZodOptional<z.ZodString>;
+        federation_trust_mark_list_endpoint: z.ZodOptional<z.ZodString>;
+        federation_trust_mark_endpoint: z.ZodOptional<z.ZodString>;
+        federation_historical_keys_endpoint: z.ZodOptional<z.ZodString>;
+        endpoint_auth_signing_alg_values_supported: z.ZodOptional<z.ZodString>;
+        organization_name: z.ZodOptional<z.ZodString>;
+        homepage_uri: z.ZodOptional<z.ZodString>;
+        policy_uri: z.ZodOptional<z.ZodString>;
+        logo_uri: z.ZodOptional<z.ZodString>;
+        contacts: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    }, z.ZodTypeAny, "passthrough">>;
+    credential_issuance_batch_size: z.ZodOptional<z.ZodNumber>;
+    /**
+     * @deprecated
+     */
+    response_modes_supported: z.ZodOptional<z.ZodArray<z.ZodString, "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;
+    }[];
+    federation_entity: {
+        federation_fetch_endpoint?: string | undefined;
+        federation_list_endpoint?: string | undefined;
+        federation_resolve_endpoint?: string | undefined;
+        federation_trust_mark_status_endpoint?: string | undefined;
+        federation_trust_mark_list_endpoint?: string | undefined;
+        federation_trust_mark_endpoint?: string | undefined;
+        federation_historical_keys_endpoint?: string | undefined;
+        endpoint_auth_signing_alg_values_supported?: string | undefined;
+        organization_name?: string | undefined;
+        homepage_uri?: string | undefined;
+        policy_uri?: string | undefined;
+        logo_uri?: string | undefined;
+        contacts?: string[] | undefined;
+    } & {
+        [k: string]: unknown;
+    };
+    credential_issuer: string;
+    pushed_authorization_request_endpoint: string;
+    authorization_endpoint: string;
+    token_endpoint: string;
+    nonce_endpoint: string;
+    credential_endpoint: string;
+    credential_configurations_supported: Record<string, ({
+        format: "dc+sd-jwt";
+        vct: string;
+    } | {
+        format: "mso_mdoc";
+        doctype: string;
+    }) & {
+        display: {
+            name: string;
+            locale: string;
+        }[];
+        scope: string;
+        claims: {
+            path: (string | number | null)[];
+            display: {
+                name: string;
+                locale: string;
+            }[];
+        }[];
+        authentic_source?: string | undefined;
+        issuance_errors_supported?: Record<string, {
+            display: {
+                title: string;
+                locale: string;
+                description: string;
+            }[];
+        }> | undefined;
+    }>;
+    status_assertion_endpoint?: string | undefined;
+    credential_issuance_batch_size?: number | undefined;
+    response_modes_supported?: 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;
+    }[];
+    federation_entity: {
+        federation_fetch_endpoint?: string | undefined;
+        federation_list_endpoint?: string | undefined;
+        federation_resolve_endpoint?: string | undefined;
+        federation_trust_mark_status_endpoint?: string | undefined;
+        federation_trust_mark_list_endpoint?: string | undefined;
+        federation_trust_mark_endpoint?: string | undefined;
+        federation_historical_keys_endpoint?: string | undefined;
+        endpoint_auth_signing_alg_values_supported?: string | undefined;
+        organization_name?: string | undefined;
+        homepage_uri?: string | undefined;
+        policy_uri?: string | undefined;
+        logo_uri?: string | undefined;
+        contacts?: string[] | undefined;
+    } & {
+        [k: string]: unknown;
+    };
+    credential_issuer: string;
+    pushed_authorization_request_endpoint: string;
+    authorization_endpoint: string;
+    token_endpoint: string;
+    nonce_endpoint: string;
+    credential_endpoint: string;
+    credential_configurations_supported: Record<string, ({
+        format: "dc+sd-jwt";
+        vct: string;
+    } | {
+        format: "mso_mdoc";
+        doctype: string;
+    }) & {
+        display: {
+            name: string;
+            locale: string;
+        }[];
+        scope: string;
+        claims: {
+            path: (string | number | null)[];
+            display: {
+                name: string;
+                locale: string;
+            }[];
+        }[];
+        authentic_source?: string | undefined;
+        issuance_errors_supported?: Record<string, {
+            display: {
+                title: string;
+                locale: string;
+                description: string;
+            }[];
+        }> | undefined;
+    }>;
+    status_assertion_endpoint?: string | undefined;
+    credential_issuance_batch_size?: number | undefined;
+    response_modes_supported?: string[] | undefined;
+}>;
+//# sourceMappingURL=IssuerConfig.d.ts.map

package/lib/typescript/credential/issuance/api/IssuerConfig.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"IssuerConfig.d.ts","sourceRoot":"","sources":["../../../../../src/credential/issuance/api/IssuerConfig.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AA4CxB;;GAEG;AACH,MAAM,MAAM,YAAY,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,YAAY,CAAC,CAAC;AACxD,eAAO,MAAM,YAAY;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;QAfrB;;WAEG;;QAEH;;WAEG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;IAqBL;;OAEG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAEH,CAAC"}

package/lib/typescript/credential/issuance/api/index.d.ts

@@ -0,0 +1,14 @@
+import { type EvaluateIssuerTrustApi } from "./01-evaluate-issuer-trust";
+import { type StartUserAuthorizationApi } from "./02-start-user-authorization";
+import { type CompleteUserAuthorizationApi } from "./03-complete-user-authorization";
+import { type AuthorizeAccessApi } from "./04-authorize-access";
+import { type ObtainCredentialApi } from "./05-obtain-credential";
+import { type VerifyAndParseCredentialApi } from "./06-verify-and-parse-credential";
+import { type MRTDPoPApi } from "./mrtd-pop";
+export interface IssuanceApi extends EvaluateIssuerTrustApi, StartUserAuthorizationApi, CompleteUserAuthorizationApi, AuthorizeAccessApi, ObtainCredentialApi, VerifyAndParseCredentialApi {
+    MRTDPoP: MRTDPoPApi;
+}
+export type { IssuerConfig } from "./IssuerConfig";
+export type * as MRTDPoP from "./mrtd-pop";
+export type * from "./types";
+//# sourceMappingURL=index.d.ts.map

package/lib/typescript/credential/issuance/api/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/credential/issuance/api/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,sBAAsB,EAAE,MAAM,4BAA4B,CAAC;AACzE,OAAO,EAAE,KAAK,yBAAyB,EAAE,MAAM,+BAA+B,CAAC;AAC/E,OAAO,EAAE,KAAK,4BAA4B,EAAE,MAAM,kCAAkC,CAAC;AACrF,OAAO,EAAE,KAAK,kBAAkB,EAAE,MAAM,uBAAuB,CAAC;AAChE,OAAO,EAAE,KAAK,mBAAmB,EAAE,MAAM,wBAAwB,CAAC;AAClE,OAAO,EAAE,KAAK,2BAA2B,EAAE,MAAM,kCAAkC,CAAC;AACpF,OAAO,EAAE,KAAK,UAAU,EAAE,MAAM,YAAY,CAAC;AAE7C,MAAM,WAAW,WACf,SAAQ,sBAAsB,EAC5B,yBAAyB,EACzB,4BAA4B,EAC5B,kBAAkB,EAClB,mBAAmB,EACnB,2BAA2B;IAC7B,OAAO,EAAE,UAAU,CAAC;CACrB;AAED,YAAY,EAAE,YAAY,EAAE,MAAM,gBAAgB,CAAC;AACnD,YAAY,KAAK,OAAO,MAAM,YAAY,CAAC;AAC3C,mBAAmB,SAAS,CAAC"}