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

package/lib/typescript/credential/issuance/v1.3.3/mappers.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"mappers.d.ts","sourceRoot":"","sources":["../../../../../src/credential/issuance/v1.3.3/mappers.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,4BAA4B,EAAE,MAAM,0BAA0B,CAAC;AAI7E,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,kCAAkC,CAAC;AA8BtE,eAAO,MAAM,iBAAiB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAqC7B,CAAC;AAEF,eAAO,MAAM,kBAAkB,wDAY5B,CAAC"}

package/lib/typescript/credential/issuance/v1.3.3/types.d.ts

@@ -0,0 +1,10 @@
+import * as z from "zod";
+export type NonceResponse = z.infer<typeof NonceResponse>;
+export declare const NonceResponse: z.ZodObject<{
+    c_nonce: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    c_nonce: string;
+}, {
+    c_nonce: string;
+}>;
+//# sourceMappingURL=types.d.ts.map

package/lib/typescript/credential/issuance/v1.3.3/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../../../../src/credential/issuance/v1.3.3/types.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,CAAC,MAAM,KAAK,CAAC;AAEzB,MAAM,MAAM,aAAa,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,aAAa,CAAC,CAAC;AAC1D,eAAO,MAAM,aAAa;;;;;;EAExB,CAAC"}

package/lib/typescript/credential/offer/api/01-resolve-credential-offer.d.ts

@@ -0,0 +1,22 @@
+import type { CredentialOffer } from "./types";
+export interface ResolveCredentialOfferApi {
+    /**
+     * Resolve and validate a Credential Offer received via QR code or deep link.
+     *
+     * Handles both transmission modes defined in OpenID4VCI Section 4.1:
+     * - **by value** (`credential_offer`): the offer JSON is embedded in the URI.
+     * - **by reference** (`credential_offer_uri`): the URI points to a resource
+     *   that is fetched via HTTP GET.
+     *
+     * @param credentialOffer - The raw URI string from the QR code or deep link.
+     * @param callbacks - Optional object with a custom `fetch` implementation
+     *   used when the offer is transmitted by reference.
+     * @returns The resolved and validated {@link CredentialOffer}.
+     * @throws {InvalidQRCodeError} If the URI cannot be parsed or the offer cannot be fetched.
+     * @throws {InvalidCredentialOfferError} If the resolved offer fails validation.
+     */
+    resolveCredentialOffer(credentialOffer: string, callbacks?: {
+        fetch?: GlobalFetch["fetch"];
+    }): Promise<CredentialOffer>;
+}
+//# sourceMappingURL=01-resolve-credential-offer.d.ts.map

package/lib/typescript/credential/offer/api/01-resolve-credential-offer.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"01-resolve-credential-offer.d.ts","sourceRoot":"","sources":["../../../../../src/credential/offer/api/01-resolve-credential-offer.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,SAAS,CAAC;AAE/C,MAAM,WAAW,yBAAyB;IACxC;;;;;;;;;;;;;;OAcG;IACH,sBAAsB,CACpB,eAAe,EAAE,MAAM,EACvB,SAAS,CAAC,EAAE;QAAE,KAAK,CAAC,EAAE,WAAW,CAAC,OAAO,CAAC,CAAA;KAAE,GAC3C,OAAO,CAAC,eAAe,CAAC,CAAC;CAC7B"}

package/lib/typescript/credential/offer/api/02-extract-grant-details.d.ts

@@ -0,0 +1,13 @@
+import type { CredentialOffer, ExtractGrantDetailsResult } from "./types";
+export interface ExtractGrantDetailsApi {
+    /**
+     * Extract grant details from a resolved Credential Offer.
+     *
+     * @param offer - A previously resolved {@link CredentialOffer}.
+     * @returns The extracted {@link ExtractGrantDetailsResult} containing
+     *   the grant type and its parameters.
+     * @throws {InvalidCredentialOfferError} If no supported grant type is found.
+     */
+    extractGrantDetails(offer: CredentialOffer): ExtractGrantDetailsResult;
+}
+//# sourceMappingURL=02-extract-grant-details.d.ts.map

package/lib/typescript/credential/offer/api/02-extract-grant-details.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"02-extract-grant-details.d.ts","sourceRoot":"","sources":["../../../../../src/credential/offer/api/02-extract-grant-details.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,eAAe,EAAE,yBAAyB,EAAE,MAAM,SAAS,CAAC;AAE1E,MAAM,WAAW,sBAAsB;IACrC;;;;;;;OAOG;IACH,mBAAmB,CAAC,KAAK,EAAE,eAAe,GAAG,yBAAyB,CAAC;CACxE"}

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

@@ -0,0 +1,6 @@
+import type { ResolveCredentialOfferApi } from "./01-resolve-credential-offer";
+import type { ExtractGrantDetailsApi } from "./02-extract-grant-details";
+export interface OfferApi extends ResolveCredentialOfferApi, ExtractGrantDetailsApi {
+}
+export * from "./types";
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/credential/offer/api/index.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,yBAAyB,EAAE,MAAM,+BAA+B,CAAC;AAC/E,OAAO,KAAK,EAAE,sBAAsB,EAAE,MAAM,4BAA4B,CAAC;AAEzE,MAAM,WAAW,QACf,SAAQ,yBAAyB,EAC/B,sBAAsB;CAAG;AAE7B,cAAc,SAAS,CAAC"}

package/lib/typescript/credential/offer/api/types.d.ts

@@ -0,0 +1,5 @@
+import type { CredentialOffer as SdkCredentialOffer } from "@pagopa/io-wallet-oid4vci";
+import type { ExtractGrantDetailsResult as SdkExtractGrantDetailsResult } from "@pagopa/io-wallet-oid4vci";
+export type CredentialOffer = SdkCredentialOffer;
+export type ExtractGrantDetailsResult = SdkExtractGrantDetailsResult;
+//# sourceMappingURL=types.d.ts.map

package/lib/typescript/credential/offer/api/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../../../../src/credential/offer/api/types.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,eAAe,IAAI,kBAAkB,EAAE,MAAM,2BAA2B,CAAC;AACvF,OAAO,KAAK,EAAE,yBAAyB,IAAI,4BAA4B,EAAE,MAAM,2BAA2B,CAAC;AAE3G,MAAM,MAAM,eAAe,GAAG,kBAAkB,CAAC;AACjD,MAAM,MAAM,yBAAyB,GAAG,4BAA4B,CAAC"}

package/lib/typescript/credential/offer/common/errors.d.ts

@@ -0,0 +1,10 @@
+import { IoWalletError } from "../../../utils/errors";
+export declare class InvalidCredentialOfferError extends IoWalletError {
+    code: string;
+    constructor(message?: string);
+}
+export declare class InvalidQRCodeError extends IoWalletError {
+    code: string;
+    constructor(message?: string);
+}
+//# sourceMappingURL=errors.d.ts.map

package/lib/typescript/credential/offer/common/errors.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"errors.d.ts","sourceRoot":"","sources":["../../../../../src/credential/offer/common/errors.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,aAAa,EAAE,MAAM,uBAAuB,CAAC;AAEtD,qBAAa,2BAA4B,SAAQ,aAAa;IAC5D,IAAI,SAAkC;gBAE1B,OAAO,CAAC,EAAE,MAAM;CAG7B;AAED,qBAAa,kBAAmB,SAAQ,aAAa;IACnD,IAAI,SAAyB;gBAEjB,OAAO,CAAC,EAAE,MAAM;CAG7B"}

package/lib/typescript/credential/offer/index.d.ts

@@ -1,7 +1,6 @@
-import { startFlowFromQR, type StartFlow } from "./01-start-flow";
-import { fetchCredentialOffer, type GetCredentialOffer } from "./02-fetch-credential-offer";
-import * as Errors from "./errors";
-export type { CredentialOffer, Grants, AuthorizationCodeGrant, PreAuthorizedCodeGrant, TransactionCode, } from "./types";
-export { Errors, fetchCredentialOffer, startFlowFromQR };
-export type { GetCredentialOffer, StartFlow };
+import * as Errors from "./common/errors";
+export { Errors };
+export type * from "./api";
+export { Offer as V1_0_0 } from "./v1.0.0";
+export { Offer as V1_3_3 } from "./v1.3.3";
 //# sourceMappingURL=index.d.ts.map

package/lib/typescript/credential/offer/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/credential/offer/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,eAAe,EAAE,KAAK,SAAS,EAAE,MAAM,iBAAiB,CAAC;AAClE,OAAO,EACL,oBAAoB,EACpB,KAAK,kBAAkB,EACxB,MAAM,6BAA6B,CAAC;AACrC,OAAO,KAAK,MAAM,MAAM,UAAU,CAAC;AACnC,YAAY,EACV,eAAe,EACf,MAAM,EACN,sBAAsB,EACtB,sBAAsB,EACtB,eAAe,GAChB,MAAM,SAAS,CAAC;AAEjB,OAAO,EAAE,MAAM,EAAE,oBAAoB,EAAE,eAAe,EAAE,CAAC;AACzD,YAAY,EAAE,kBAAkB,EAAE,SAAS,EAAE,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/credential/offer/index.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,MAAM,MAAM,iBAAiB,CAAC;AAC1C,OAAO,EAAE,MAAM,EAAE,CAAC;AAClB,mBAAmB,OAAO,CAAC;AAC3B,OAAO,EAAE,KAAK,IAAI,MAAM,EAAE,MAAM,UAAU,CAAC;AAC3C,OAAO,EAAE,KAAK,IAAI,MAAM,EAAE,MAAM,UAAU,CAAC"}

package/lib/typescript/credential/offer/v1.0.0/index.d.ts

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

package/lib/typescript/credential/offer/v1.0.0/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/credential/offer/v1.0.0/index.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,QAAQ,CAAC;AAEvC,eAAO,MAAM,KAAK,EAAE,QAOnB,CAAC"}

package/lib/typescript/credential/offer/v1.3.3/01-resolve-credential-offer.d.ts

@@ -0,0 +1,25 @@
+import type { OfferApi } from "../api";
+/**
+ * v1.3.3 implementation — first step of the User Request Flow
+ * (IT-Wallet spec, Section 12.1.2).
+ *
+ * Delegates to the SDK's {@link sdkResolveCredentialOffer} for URI parsing
+ * and by-reference fetching, then to {@link validateCredentialOffer} for
+ * IT-Wallet v1.3 structural checks:
+ * - `credential_issuer` must be an HTTPS URL
+ * - `grants` object is required
+ * - `authorization_code` grant is required
+ * - `scope` is required within `authorization_code`
+ *
+ * Supported URI schemes: `openid-credential-offer://`, `haip-vci://`, `https://`.
+ *
+ * Cross-validation against Credential Issuer metadata (e.g. matching
+ * `credential_configuration_ids` or `authorization_server`) is **not** performed
+ * here; per the spec it belongs to the Issuance Flow.
+ *
+ * Resolution errors (bad scheme, missing params, network failure) are mapped
+ * to {@link InvalidQRCodeError}; validation errors are mapped to
+ * {@link InvalidCredentialOfferError}.
+ */
+export declare const resolveCredentialOffer: OfferApi["resolveCredentialOffer"];
+//# sourceMappingURL=01-resolve-credential-offer.d.ts.map

package/lib/typescript/credential/offer/v1.3.3/01-resolve-credential-offer.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"01-resolve-credential-offer.d.ts","sourceRoot":"","sources":["../../../../../src/credential/offer/v1.3.3/01-resolve-credential-offer.ts"],"names":[],"mappings":"AASA,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,QAAQ,CAAC;AAEvC;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,eAAO,MAAM,sBAAsB,EAAE,QAAQ,CAAC,wBAAwB,CA0BnE,CAAC"}

package/lib/typescript/credential/offer/v1.3.3/02-extract-grant-details.d.ts

@@ -0,0 +1,16 @@
+import type { OfferApi } from "../api";
+/**
+ * v1.3.3 implementation — second and final step of the User Request Flow
+ * (IT-Wallet spec, Section 12.1.2).
+ *
+ * IT-Wallet v1.3 only supports the `authorization_code` grant type;
+ * the returned result always has `grantType: "authorization_code"`.
+ * The extracted `scope` is later used in the Authorization Request,
+ * and `issuerState` (when present) binds the request to the Credential
+ * Issuer session.
+ *
+ * Delegates directly to the SDK's {@link sdkExtractGrantDetails} — no local
+ * mapping is needed because the SDK already returns `ExtractGrantDetailsResult`.
+ */
+export declare const extractGrantDetails: OfferApi["extractGrantDetails"];
+//# sourceMappingURL=02-extract-grant-details.d.ts.map

package/lib/typescript/credential/offer/v1.3.3/02-extract-grant-details.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"02-extract-grant-details.d.ts","sourceRoot":"","sources":["../../../../../src/credential/offer/v1.3.3/02-extract-grant-details.ts"],"names":[],"mappings":"AAMA,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,QAAQ,CAAC;AAEvC;;;;;;;;;;;;GAYG;AACH,eAAO,MAAM,mBAAmB,EAAE,QAAQ,CAAC,qBAAqB,CAK7D,CAAC"}

package/lib/typescript/credential/offer/v1.3.3/index.d.ts

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

package/lib/typescript/credential/offer/v1.3.3/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/credential/offer/v1.3.3/index.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,QAAQ,CAAC;AAIvC,eAAO,MAAM,KAAK,EAAE,QAGnB,CAAC"}

package/lib/typescript/credential/presentation/api/01-start-flow.d.ts

@@ -0,0 +1,18 @@
+import type { PresentationParams } from "./types";
+type NullablePresentationParams = {
+    [K in keyof PresentationParams]?: PresentationParams[K] | null;
+};
+export interface StartFlowApi {
+    /**
+     * Start a presentation flow by validating the required parameters.
+     * Parameters are extracted from a url encoded in a QR code or in a deep link.
+     * @since 1.0.0
+     *
+     * @param params The QR code parameters to be validated
+     * @returns The validated presentation parameters
+     * @throws {InvalidQRCodeError} if the provided parameters are not valid
+     */
+    startFlowFromQR(params: NullablePresentationParams): PresentationParams;
+}
+export {};
+//# sourceMappingURL=01-start-flow.d.ts.map

package/lib/typescript/credential/presentation/api/01-start-flow.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"01-start-flow.d.ts","sourceRoot":"","sources":["../../../../../src/credential/presentation/api/01-start-flow.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,SAAS,CAAC;AAElD,KAAK,0BAA0B,GAAG;KAC/B,CAAC,IAAI,MAAM,kBAAkB,CAAC,CAAC,EAAE,kBAAkB,CAAC,CAAC,CAAC,GAAG,IAAI;CAC/D,CAAC;AAEF,MAAM,WAAW,YAAY;IAC3B;;;;;;;;OAQG;IACH,eAAe,CAAC,MAAM,EAAE,0BAA0B,GAAG,kBAAkB,CAAC;CACzE"}

package/lib/typescript/credential/presentation/api/02-evaluate-rp-trust.d.ts

@@ -0,0 +1,18 @@
+import type { RelyingPartyConfig } from "./RelyingPartyConfig";
+export interface EvaluateRelyingPartyTrustApi {
+    /**
+     * The Relying Party trust evaluation phase.
+     * Fetch the Relying Party's configuration and verify trust.
+     * @since 1.0.0
+     *
+     * @param rpUrl The base url of the Relying Party
+     * @param context.appFetch (optional) fetch api implementation. Default: built-in fetch
+     * @returns The Relying Party's configuration
+     */
+    evaluateRelyingPartyTrust(rpUrl: string, ctx?: {
+        appFetch?: GlobalFetch["fetch"];
+    }): Promise<{
+        rpConf: RelyingPartyConfig;
+    }>;
+}
+//# sourceMappingURL=02-evaluate-rp-trust.d.ts.map

package/lib/typescript/credential/presentation/api/02-evaluate-rp-trust.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"02-evaluate-rp-trust.d.ts","sourceRoot":"","sources":["../../../../../src/credential/presentation/api/02-evaluate-rp-trust.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,sBAAsB,CAAC;AAE/D,MAAM,WAAW,4BAA4B;IAC3C;;;;;;;;OAQG;IACH,yBAAyB,CACvB,KAAK,EAAE,MAAM,EACb,GAAG,CAAC,EAAE;QAAE,QAAQ,CAAC,EAAE,WAAW,CAAC,OAAO,CAAC,CAAA;KAAE,GACxC,OAAO,CAAC;QACT,MAAM,EAAE,kBAAkB,CAAC;KAC5B,CAAC,CAAC;CACJ"}

package/lib/typescript/credential/presentation/api/03-get-request-object.d.ts

@@ -0,0 +1,19 @@
+import type { RequestObjectWalletCapabilities } from "./types";
+export interface GetRequestObjectApi {
+    /**
+     * Obtain the Request Object for RP authentication. Both the GET and POST `request_uri_method` are supported.
+     * @since 1.0.0
+     *
+     * @param authorizationRequestUrl The authorization URL from the QR code
+     * @param context.walletCapabilities (optional) An object containing the wallet technical capabilities that will be sent with a POST request
+     * @param context.appFetch (optional) fetch api implementation. Default: built-in fetch
+     * @returns The Request Object that describes the presentation
+     */
+    getRequestObject(authorizationRequestUrl: string, context?: {
+        appFetch?: GlobalFetch["fetch"];
+        walletCapabilities?: RequestObjectWalletCapabilities;
+    }): Promise<{
+        requestObjectEncodedJwt: string;
+    }>;
+}
+//# sourceMappingURL=03-get-request-object.d.ts.map

package/lib/typescript/credential/presentation/api/03-get-request-object.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"03-get-request-object.d.ts","sourceRoot":"","sources":["../../../../../src/credential/presentation/api/03-get-request-object.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,+BAA+B,EAAE,MAAM,SAAS,CAAC;AAE/D,MAAM,WAAW,mBAAmB;IAClC;;;;;;;;OAQG;IACH,gBAAgB,CACd,uBAAuB,EAAE,MAAM,EAC/B,OAAO,CAAC,EAAE;QACR,QAAQ,CAAC,EAAE,WAAW,CAAC,OAAO,CAAC,CAAC;QAChC,kBAAkB,CAAC,EAAE,+BAA+B,CAAC;KACtD,GACA,OAAO,CAAC;QAAE,uBAAuB,EAAE,MAAM,CAAA;KAAE,CAAC,CAAC;CACjD"}

package/lib/typescript/credential/presentation/api/04-verify-request-object.d.ts

@@ -0,0 +1,23 @@
+import type { RelyingPartyConfig } from "./RelyingPartyConfig";
+import type { RequestObject } from "./types";
+export interface VerifyRequestObjectApi {
+    /**
+     * Function to verify the Request Object's validity, from the signature to the required properties.
+     * @since 1.0.0
+     *
+     * @param requestObjectEncodedJwt The Request Object in JWT format
+     * @param params.clientId The client ID to verify
+     * @param params.rpConf The Entity Configuration of the Relying Party
+     * @param params.state Optional state
+     * @returns The verified Request Object
+     * @throws {InvalidRequestObjectError} if the Request Object cannot be validated
+     */
+    verifyRequestObject(requestObjectEncodedJwt: string, params: {
+        clientId: string;
+        rpConf: RelyingPartyConfig;
+        state?: string;
+    }): Promise<{
+        requestObject: RequestObject;
+    }>;
+}
+//# sourceMappingURL=04-verify-request-object.d.ts.map

package/lib/typescript/credential/presentation/api/04-verify-request-object.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"04-verify-request-object.d.ts","sourceRoot":"","sources":["../../../../../src/credential/presentation/api/04-verify-request-object.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,sBAAsB,CAAC;AAC/D,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,SAAS,CAAC;AAE7C,MAAM,WAAW,sBAAsB;IACrC;;;;;;;;;;OAUG;IACH,mBAAmB,CACjB,uBAAuB,EAAE,MAAM,EAC/B,MAAM,EAAE;QACN,QAAQ,EAAE,MAAM,CAAC;QACjB,MAAM,EAAE,kBAAkB,CAAC;QAC3B,KAAK,CAAC,EAAE,MAAM,CAAC;KAChB,GACA,OAAO,CAAC;QAAE,aAAa,EAAE,aAAa,CAAA;KAAE,CAAC,CAAC;CAC9C"}

package/lib/typescript/credential/presentation/api/05-evaluate-dcql-query.d.ts

@@ -0,0 +1,41 @@
+import type { DcqlQuery } from "dcql";
+import type { Credential4Dcql, CredentialFormat, PresentationFrame } from "./types";
+/**
+ * The purpose for the credential request by the RP.
+ */
+export type CredentialPurpose = {
+    required: boolean;
+    description?: string;
+};
+export type Disclosure = [
+    string,
+    string,
+    unknown
+];
+export type EvaluatedDisclosure = {
+    namespace?: string;
+    name: string;
+    value: unknown;
+};
+export interface EvaluateDcqlQueryApi {
+    /**
+     * Evaluate a list of credentials against a DCQL query. The function returns details
+     * on the credential(s) that satisfied the query, with useful metadata to ask the user's consent.
+     * @since 1.0.0
+     *
+     * @param query The DCQL query
+     * @param credentialsSdJwt The list of SD-JWT credentials
+     * @param credentialsMdoc The list of mdoc credentials
+     * @returns Credentials that satisfy the query, with disclosure metadata.
+     * @throws {DcqlError} if the provided DCQL query is not valid
+     */
+    evaluateDcqlQuery(query: DcqlQuery.Input, credentialsSdJwt: Credential4Dcql[], credentialsMdoc?: Credential4Dcql[]): Promise<({
+        id: string;
+        credential: string;
+        keyTag: string;
+        requiredDisclosures: EvaluatedDisclosure[];
+        presentationFrame: PresentationFrame;
+        purposes: CredentialPurpose[];
+    } & CredentialFormat)[]>;
+}
+//# sourceMappingURL=05-evaluate-dcql-query.d.ts.map

package/lib/typescript/credential/presentation/api/05-evaluate-dcql-query.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"05-evaluate-dcql-query.d.ts","sourceRoot":"","sources":["../../../../../src/credential/presentation/api/05-evaluate-dcql-query.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,MAAM,CAAC;AACtC,OAAO,KAAK,EACV,eAAe,EACf,gBAAgB,EAChB,iBAAiB,EAClB,MAAM,SAAS,CAAC;AAEjB;;GAEG;AACH,MAAM,MAAM,iBAAiB,GAAG;IAC9B,QAAQ,EAAE,OAAO,CAAC;IAClB,WAAW,CAAC,EAAE,MAAM,CAAC;CACtB,CAAC;AAEF,MAAM,MAAM,UAAU,GAAG;IACvB,MAAM;IACN,MAAM;IACN,OAAO;CACR,CAAC;AAEF,MAAM,MAAM,mBAAmB,GAAG;IAChC,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,IAAI,EAAE,MAAM,CAAC;IACb,KAAK,EAAE,OAAO,CAAC;CAChB,CAAC;AAEF,MAAM,WAAW,oBAAoB;IACnC;;;;;;;;;;OAUG;IACH,iBAAiB,CACf,KAAK,EAAE,SAAS,CAAC,KAAK,EACtB,gBAAgB,EAAE,eAAe,EAAE,EACnC,eAAe,CAAC,EAAE,eAAe,EAAE,GAClC,OAAO,CACR,CAAC;QACC,EAAE,EAAE,MAAM,CAAC;QACX,UAAU,EAAE,MAAM,CAAC;QACnB,MAAM,EAAE,MAAM,CAAC;QACf,mBAAmB,EAAE,mBAAmB,EAAE,CAAC;QAC3C,iBAAiB,EAAE,iBAAiB,CAAC;QACrC,QAAQ,EAAE,iBAAiB,EAAE,CAAC;KAC/B,GAAG,gBAAgB,CAAC,EAAE,CACxB,CAAC;CACH"}

package/lib/typescript/credential/presentation/api/06-send-authorization-response.d.ts

@@ -0,0 +1,54 @@
+import type { AuthorizationResponse, ErrorResponse, RemotePresentation, RequestObject } from "./types";
+import type { RelyingPartyConfig } from "./RelyingPartyConfig";
+import type { EvaluateDcqlQueryApi } from "./05-evaluate-dcql-query";
+import type { Out } from "../../../../src/utils/misc";
+type FetchContext = {
+    appFetch?: GlobalFetch["fetch"];
+};
+export interface SendAuthorizationResponseApi {
+    /**
+     * 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.
+     */
+    prepareRemotePresentations(credentials: Out<EvaluateDcqlQueryApi["evaluateDcqlQuery"]>, authRequestObject: {
+        nonce: string;
+        clientId: string;
+        responseUri: string;
+    }): Promise<RemotePresentation>;
+    /**
+     * Sends the authorization response containing the VP Token to the Relying Party (RP).
+     * This function completes the presentation flow in an OpenID 4 Verifiable Presentations scenario.
+     * @since 1.0.0
+     *
+     * @param requestObject The request details, including presentation requirements.
+     * @param remotePresentation The presentations to send, each with their VP token
+     * @param rpConf The Relying Party common configuration
+     * @param context Contains optional custom fetch implementation.
+     * @returns Parsed and validated authorization response from the Relying Party.
+     */
+    sendAuthorizationResponse(requestObject: RequestObject, remotePresentation: RemotePresentation, rpConf: RelyingPartyConfig, context?: FetchContext): Promise<AuthorizationResponse>;
+    /**
+     * Sends the authorization error response to the Relying Party (RP).
+     * This function completes the presentation flow in an OpenID 4 Verifiable Presentations scenario.
+     * @since 1.0.0
+     *
+     * @param requestObject The request details, including presentation requirements.
+     * @param error The response error value, with description
+     * @param context Contains optional custom fetch implementation.
+     * @returns Parsed and validated authorization response from the Relying Party.
+     */
+    sendAuthorizationErrorResponse(requestObject: RequestObject, error: {
+        error: ErrorResponse;
+        errorDescription: string;
+    }, context?: FetchContext): Promise<AuthorizationResponse>;
+}
+export {};
+//# sourceMappingURL=06-send-authorization-response.d.ts.map

package/lib/typescript/credential/presentation/api/06-send-authorization-response.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"06-send-authorization-response.d.ts","sourceRoot":"","sources":["../../../../../src/credential/presentation/api/06-send-authorization-response.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,qBAAqB,EACrB,aAAa,EACb,kBAAkB,EAClB,aAAa,EACd,MAAM,SAAS,CAAC;AACjB,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,sBAAsB,CAAC;AAC/D,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,0BAA0B,CAAC;AACrE,OAAO,KAAK,EAAE,GAAG,EAAE,MAAM,4BAA4B,CAAC;AACtD,KAAK,YAAY,GAAG;IAAE,QAAQ,CAAC,EAAE,WAAW,CAAC,OAAO,CAAC,CAAA;CAAE,CAAC;AAExD,MAAM,WAAW,4BAA4B;IAC3C;;;;;;;;;;;OAWG;IACH,0BAA0B,CACxB,WAAW,EAAE,GAAG,CAAC,oBAAoB,CAAC,mBAAmB,CAAC,CAAC,EAC3D,iBAAiB,EAAE;QACjB,KAAK,EAAE,MAAM,CAAC;QACd,QAAQ,EAAE,MAAM,CAAC;QACjB,WAAW,EAAE,MAAM,CAAC;KACrB,GACA,OAAO,CAAC,kBAAkB,CAAC,CAAC;IAE/B;;;;;;;;;;OAUG;IACH,yBAAyB,CACvB,aAAa,EAAE,aAAa,EAC5B,kBAAkB,EAAE,kBAAkB,EACtC,MAAM,EAAE,kBAAkB,EAC1B,OAAO,CAAC,EAAE,YAAY,GACrB,OAAO,CAAC,qBAAqB,CAAC,CAAC;IAElC;;;;;;;;;OASG;IACH,8BAA8B,CAC5B,aAAa,EAAE,aAAa,EAC5B,KAAK,EAAE;QAAE,KAAK,EAAE,aAAa,CAAC;QAAC,gBAAgB,EAAE,MAAM,CAAA;KAAE,EACzD,OAAO,CAAC,EAAE,YAAY,GACrB,OAAO,CAAC,qBAAqB,CAAC,CAAC;CACnC"}

package/lib/typescript/credential/presentation/api/RelyingPartyConfig.d.ts

@@ -0,0 +1,185 @@
+import * as z from "zod";
+/**
+ * Common Relying Party configuration
+ */
+export type RelyingPartyConfig = z.infer<typeof RelyingPartyConfig>;
+export declare const RelyingPartyConfig: z.ZodObject<{
+    subject: z.ZodOptional<z.ZodString>;
+    jwks: z.ZodObject<{
+        keys: z.ZodArray<z.ZodObject<{
+            kty: z.ZodString;
+            kid: z.ZodString;
+            use: z.ZodOptional<z.ZodString>;
+            key_ops: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+            alg: z.ZodOptional<z.ZodString>;
+            x5u: z.ZodOptional<z.ZodString>;
+            x5c: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+            x5t: z.ZodOptional<z.ZodString>;
+            'x5t#S256': z.ZodOptional<z.ZodString>;
+        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
+            kty: z.ZodString;
+            kid: z.ZodString;
+            use: z.ZodOptional<z.ZodString>;
+            key_ops: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+            alg: z.ZodOptional<z.ZodString>;
+            x5u: z.ZodOptional<z.ZodString>;
+            x5c: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+            x5t: z.ZodOptional<z.ZodString>;
+            'x5t#S256': z.ZodOptional<z.ZodString>;
+        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
+            kty: z.ZodString;
+            kid: z.ZodString;
+            use: z.ZodOptional<z.ZodString>;
+            key_ops: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+            alg: z.ZodOptional<z.ZodString>;
+            x5u: z.ZodOptional<z.ZodString>;
+            x5c: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+            x5t: z.ZodOptional<z.ZodString>;
+            'x5t#S256': z.ZodOptional<z.ZodString>;
+        }, z.ZodTypeAny, "passthrough">>, "many">;
+    }, "strip", z.ZodTypeAny, {
+        keys: z.objectOutputType<{
+            kty: z.ZodString;
+            kid: z.ZodString;
+            use: z.ZodOptional<z.ZodString>;
+            key_ops: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+            alg: z.ZodOptional<z.ZodString>;
+            x5u: z.ZodOptional<z.ZodString>;
+            x5c: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+            x5t: z.ZodOptional<z.ZodString>;
+            'x5t#S256': z.ZodOptional<z.ZodString>;
+        }, z.ZodTypeAny, "passthrough">[];
+    }, {
+        keys: z.objectInputType<{
+            kty: z.ZodString;
+            kid: z.ZodString;
+            use: z.ZodOptional<z.ZodString>;
+            key_ops: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+            alg: z.ZodOptional<z.ZodString>;
+            x5u: z.ZodOptional<z.ZodString>;
+            x5c: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+            x5t: z.ZodOptional<z.ZodString>;
+            'x5t#S256': z.ZodOptional<z.ZodString>;
+        }, z.ZodTypeAny, "passthrough">[];
+    }>;
+    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">>;
+    /** @deprecated JARM legacy (v1.0 only) */
+    authorization_encrypted_response_alg: z.ZodOptional<z.ZodString>;
+    /** @deprecated JARM legacy (v1.0 only) */
+    authorization_encrypted_response_enc: z.ZodOptional<z.ZodString>;
+    /** @since 1.3.3 */
+    encrypted_response_enc_values_supported: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+}, "strip", z.ZodTypeAny, {
+    jwks: {
+        keys: z.objectOutputType<{
+            kty: z.ZodString;
+            kid: z.ZodString;
+            use: z.ZodOptional<z.ZodString>;
+            key_ops: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+            alg: z.ZodOptional<z.ZodString>;
+            x5u: z.ZodOptional<z.ZodString>;
+            x5c: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+            x5t: z.ZodOptional<z.ZodString>;
+            'x5t#S256': z.ZodOptional<z.ZodString>;
+        }, z.ZodTypeAny, "passthrough">[];
+    };
+    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;
+    };
+    subject?: string | undefined;
+    authorization_encrypted_response_alg?: string | undefined;
+    authorization_encrypted_response_enc?: string | undefined;
+    encrypted_response_enc_values_supported?: string[] | undefined;
+}, {
+    jwks: {
+        keys: z.objectInputType<{
+            kty: z.ZodString;
+            kid: z.ZodString;
+            use: z.ZodOptional<z.ZodString>;
+            key_ops: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+            alg: z.ZodOptional<z.ZodString>;
+            x5u: z.ZodOptional<z.ZodString>;
+            x5c: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+            x5t: z.ZodOptional<z.ZodString>;
+            'x5t#S256': z.ZodOptional<z.ZodString>;
+        }, z.ZodTypeAny, "passthrough">[];
+    };
+    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;
+    };
+    subject?: string | undefined;
+    authorization_encrypted_response_alg?: string | undefined;
+    authorization_encrypted_response_enc?: string | undefined;
+    encrypted_response_enc_values_supported?: string[] | undefined;
+}>;
+//# sourceMappingURL=RelyingPartyConfig.d.ts.map

package/lib/typescript/credential/presentation/api/RelyingPartyConfig.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"RelyingPartyConfig.d.ts","sourceRoot":"","sources":["../../../../../src/credential/presentation/api/RelyingPartyConfig.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,CAAC,MAAM,KAAK,CAAC;AAIzB;;GAEG;AACH,MAAM,MAAM,kBAAkB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,kBAAkB,CAAC,CAAC;AACpE,eAAO,MAAM,kBAAkB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;IAO7B,0CAA0C;;IAE1C,0CAA0C;;IAE1C,mBAAmB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAKnB,CAAC"}

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

@@ -0,0 +1,12 @@
+import type { StartFlowApi } from "./01-start-flow";
+import type { EvaluateRelyingPartyTrustApi } from "./02-evaluate-rp-trust";
+import type { GetRequestObjectApi } from "./03-get-request-object";
+import type { VerifyRequestObjectApi } from "./04-verify-request-object";
+import type { EvaluateDcqlQueryApi } from "./05-evaluate-dcql-query";
+import type { SendAuthorizationResponseApi } from "./06-send-authorization-response";
+import type { RelyingPartyConfig } from "./RelyingPartyConfig";
+export interface RemotePresentationApi extends StartFlowApi, EvaluateRelyingPartyTrustApi, GetRequestObjectApi, VerifyRequestObjectApi, EvaluateDcqlQueryApi, SendAuthorizationResponseApi {
+}
+export type { RelyingPartyConfig };
+export * from "./types";
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/credential/presentation/api/index.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,iBAAiB,CAAC;AACpD,OAAO,KAAK,EAAE,4BAA4B,EAAE,MAAM,wBAAwB,CAAC;AAC3E,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,yBAAyB,CAAC;AACnE,OAAO,KAAK,EAAE,sBAAsB,EAAE,MAAM,4BAA4B,CAAC;AACzE,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,0BAA0B,CAAC;AACrE,OAAO,KAAK,EAAE,4BAA4B,EAAE,MAAM,kCAAkC,CAAC;AACrF,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,sBAAsB,CAAC;AAE/D,MAAM,WAAW,qBACf,SAAQ,YAAY,EAClB,4BAA4B,EAC5B,mBAAmB,EACnB,sBAAsB,EACtB,oBAAoB,EACpB,4BAA4B;CAAG;AAEnC,YAAY,EAAE,kBAAkB,EAAE,CAAC;AACnC,cAAc,SAAS,CAAC"}