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

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

@@ -1,34 +0,0 @@
-import { type Out } from "../../utils/misc";
-import type { EvaluateIssuerTrust } from "./02-evaluate-issuer-trust";
-import type { StartUserAuthorization } from "./03-start-user-authorization";
-import type { CryptoContext } from "@pagopa/io-react-native-jwt";
-import { TokenResponse } from "./types";
-import type { CompleteUserAuthorizationWithQueryMode } from "./04-complete-user-authorization";
-export type AuthorizeAccess = (issuerConf: Out<EvaluateIssuerTrust>["issuerConf"], code: Out<CompleteUserAuthorizationWithQueryMode>["code"], redirectUri: string, clientId: Out<StartUserAuthorization>["clientId"], codeVerifier: Out<StartUserAuthorization>["codeVerifier"], context: {
-    walletInstanceAttestation: string;
-    appFetch?: GlobalFetch["fetch"];
-    wiaCryptoContext: CryptoContext;
-    dPopCryptoContext: CryptoContext;
-}) => Promise<{
-    accessToken: TokenResponse;
-}>;
-/**
- * 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.
- * @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 clientId The client id returned by {@link startUserAuthorization}
- * @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
- * @throws {ValidationFailed} if an error occurs while parsing the token response
- * @throws {IssuerResponseError} with a specific code for more context
- * @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.
- */
-export declare const authorizeAccess: AuthorizeAccess;
-//# sourceMappingURL=05-authorize-access.d.ts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"05-authorize-access.d.ts","sourceRoot":"","sources":["../../../../src/credential/issuance/05-authorize-access.ts"],"names":[],"mappings":"AAAA,OAAO,EAAoB,KAAK,GAAG,EAAE,MAAM,kBAAkB,CAAC;AAC9D,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,4BAA4B,CAAC;AACtE,OAAO,KAAK,EAAE,sBAAsB,EAAE,MAAM,+BAA+B,CAAC;AAK5E,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,6BAA6B,CAAC;AACjE,OAAO,EAAE,aAAa,EAAE,MAAM,SAAS,CAAC;AAExC,OAAO,KAAK,EAAE,sCAAsC,EAAE,MAAM,kCAAkC,CAAC;AAG/F,MAAM,MAAM,eAAe,GAAG,CAC5B,UAAU,EAAE,GAAG,CAAC,mBAAmB,CAAC,CAAC,YAAY,CAAC,EAClD,IAAI,EAAE,GAAG,CAAC,sCAAsC,CAAC,CAAC,MAAM,CAAC,EACzD,WAAW,EAAE,MAAM,EACnB,QAAQ,EAAE,GAAG,CAAC,sBAAsB,CAAC,CAAC,UAAU,CAAC,EACjD,YAAY,EAAE,GAAG,CAAC,sBAAsB,CAAC,CAAC,cAAc,CAAC,EACzD,OAAO,EAAE;IACP,yBAAyB,EAAE,MAAM,CAAC;IAClC,QAAQ,CAAC,EAAE,WAAW,CAAC,OAAO,CAAC,CAAC;IAChC,gBAAgB,EAAE,aAAa,CAAC;IAChC,iBAAiB,EAAE,aAAa,CAAC;CAClC,KACE,OAAO,CAAC;IAAE,WAAW,EAAE,aAAa,CAAA;CAAE,CAAC,CAAC;AAE7C;;;;;;;;;;;;;;;;;GAiBG;AACH,eAAO,MAAM,eAAe,EAAE,eAmF7B,CAAC"}

package/lib/typescript/credential/issuance/06-obtain-credential.d.ts

@@ -1,36 +0,0 @@
-import { type CryptoContext } from "@pagopa/io-react-native-jwt";
-import type { AuthorizeAccess } from "./05-authorize-access";
-import type { EvaluateIssuerTrust } from "./02-evaluate-issuer-trust";
-import { type Out } from "../../utils/misc";
-import type { StartUserAuthorization } from "./03-start-user-authorization";
-import type { SupportedCredentialFormat } from "../../trust/types";
-export type ObtainCredential = (issuerConf: Out<EvaluateIssuerTrust>["issuerConf"], accessToken: Out<AuthorizeAccess>["accessToken"], clientId: Out<StartUserAuthorization>["clientId"], credentialDefinition: {
-    credential_configuration_id: string;
-    credential_identifier?: string;
-}, context: {
-    dPopCryptoContext: CryptoContext;
-    credentialCryptoContext: CryptoContext;
-    appFetch?: GlobalFetch["fetch"];
-}, operationType?: "reissuing") => Promise<{
-    credential: string;
-    format: SupportedCredentialFormat;
-}>;
-export declare const createNonceProof: (nonce: string, issuer: string, audience: string, ctx: CryptoContext) => Promise<string>;
-/**
- * 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.
- * @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
- * @param operationType Specify the type of credential issuance (used for reissuing)
- * @returns The credential response containing the credential
- */
-export declare const obtainCredential: ObtainCredential;
-//# sourceMappingURL=06-obtain-credential.d.ts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"06-obtain-credential.d.ts","sourceRoot":"","sources":["../../../../src/credential/issuance/06-obtain-credential.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,KAAK,aAAa,EAGnB,MAAM,6BAA6B,CAAC;AACrC,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,uBAAuB,CAAC;AAC7D,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,4BAA4B,CAAC;AACtE,OAAO,EAAoB,KAAK,GAAG,EAAE,MAAM,kBAAkB,CAAC;AAC9D,OAAO,KAAK,EAAE,sBAAsB,EAAE,MAAM,+BAA+B,CAAC;AAY5E,OAAO,KAAK,EAAE,yBAAyB,EAAE,MAAM,mBAAmB,CAAC;AAEnE,MAAM,MAAM,gBAAgB,GAAG,CAC7B,UAAU,EAAE,GAAG,CAAC,mBAAmB,CAAC,CAAC,YAAY,CAAC,EAClD,WAAW,EAAE,GAAG,CAAC,eAAe,CAAC,CAAC,aAAa,CAAC,EAChD,QAAQ,EAAE,GAAG,CAAC,sBAAsB,CAAC,CAAC,UAAU,CAAC,EACjD,oBAAoB,EAAE;IACpB,2BAA2B,EAAE,MAAM,CAAC;IACpC,qBAAqB,CAAC,EAAE,MAAM,CAAC;CAChC,EACD,OAAO,EAAE;IACP,iBAAiB,EAAE,aAAa,CAAC;IACjC,uBAAuB,EAAE,aAAa,CAAC;IACvC,QAAQ,CAAC,EAAE,WAAW,CAAC,OAAO,CAAC,CAAC;CACjC,EACD,aAAa,CAAC,EAAE,WAAW,KACxB,OAAO,CAAC;IACX,UAAU,EAAE,MAAM,CAAC;IACnB,MAAM,EAAE,yBAAyB,CAAC;CACnC,CAAC,CAAC;AAEH,eAAO,MAAM,gBAAgB,UACpB,MAAM,UACL,MAAM,YACJ,MAAM,OACX,aAAa,KACjB,QAAQ,MAAM,CAehB,CAAC;AAEF;;;;;;;;;;;;;;;GAeG;AACH,eAAO,MAAM,gBAAgB,EAAE,gBA0I9B,CAAC"}

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

@@ -1,43 +0,0 @@
-import type { CryptoContext } from "@pagopa/io-react-native-jwt";
-import { type Out } from "../../utils/misc";
-import type { EvaluateIssuerTrust } from "./02-evaluate-issuer-trust";
-import type { ObtainCredential } from "./06-obtain-credential";
-type IssuerConf = Out<EvaluateIssuerTrust>["issuerConf"];
-export type VerifyAndParseCredential = (issuerConf: IssuerConf, credential: Out<ObtainCredential>["credential"], 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;
-}>;
-type ParsedCredential = {
-    /** Attribute key */
-    [claim: string]: {
-        name: /* if i18n is provided */ Record<string, string> | /* if no i18n is provided */ string | undefined;
-        value: unknown;
-    };
-};
-/**
- * Verify and parse an encoded credential.
- * @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
- */
-export declare const verifyAndParseCredential: VerifyAndParseCredential;
-export {};
-//# sourceMappingURL=07-verify-and-parse-credential.d.ts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"07-verify-and-parse-credential.d.ts","sourceRoot":"","sources":["../../../../src/credential/issuance/07-verify-and-parse-credential.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,6BAA6B,CAAC;AACjE,OAAO,EAAE,KAAK,GAAG,EAAE,MAAM,kBAAkB,CAAC;AAC5C,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,4BAA4B,CAAC;AAItE,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,wBAAwB,CAAC;AAW/D,KAAK,UAAU,GAAG,GAAG,CAAC,mBAAmB,CAAC,CAAC,YAAY,CAAC,CAAC;AAQzD,MAAM,MAAM,wBAAwB,GAAG,CACrC,UAAU,EAAE,UAAU,EACtB,UAAU,EAAE,GAAG,CAAC,gBAAgB,CAAC,CAAC,YAAY,CAAC,EAC/C,yBAAyB,EAAE,MAAM,EACjC,OAAO,EAAE;IACP,uBAAuB,EAAE,aAAa,CAAC;IACvC;;OAEG;IACH,uBAAuB,CAAC,EAAE,OAAO,CAAC;IAClC;;OAEG;IACH,0BAA0B,CAAC,EAAE,OAAO,CAAC;CACtC,EACD,YAAY,CAAC,EAAE,MAAM,KAClB,OAAO,CAAC;IACX,gBAAgB,EAAE,gBAAgB,CAAC;IACnC,UAAU,EAAE,IAAI,CAAC;IACjB,QAAQ,EAAE,IAAI,GAAG,SAAS,CAAC;CAC5B,CAAC,CAAC;AAGH,KAAK,gBAAgB,GAAG;IACtB,oBAAoB;IACpB,CAAC,KAAK,EAAE,MAAM,GAAG;QACf,IAAI,EACA,yBAAyB,CAAC,MAAM,CAC9B,MAAM,EACN,MAAM,CACP,GACD,4BAA4B,CAAC,MAAM,GACnC,SAAS,CAAC;QACd,KAAK,EAAE,OAAO,CAAC;KAChB,CAAC;CACH,CAAC;AA2cF;;;;;;;;;;;;GAYG;AACH,eAAO,MAAM,wBAAwB,EAAE,wBAuCtC,CAAC"}

package/lib/typescript/credential/issuance/errors.d.ts

@@ -1,19 +0,0 @@
-import { IoWalletError } from "../../utils/errors";
-/**
- * An error subclass thrown when an error occurs during the authorization process.
- */
-export declare class AuthorizationError extends IoWalletError {
-    code: string;
-    constructor(message?: string);
-}
-/**
- * An error subclass thrown when an error occurs during the authorization process with the IDP.
- * It contains the error and error description returned by the IDP.
- */
-export declare class AuthorizationIdpError extends IoWalletError {
-    code: string;
-    error: string;
-    errorDescription?: string;
-    constructor(error: string, errorDescription?: string);
-}
-//# sourceMappingURL=errors.d.ts.map

package/lib/typescript/credential/issuance/errors.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"errors.d.ts","sourceRoot":"","sources":["../../../../src/credential/issuance/errors.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,aAAa,EAAkB,MAAM,oBAAoB,CAAC;AAEnE;;GAEG;AACH,qBAAa,kBAAmB,SAAQ,aAAa;IACnD,IAAI,SAAuC;gBAE/B,OAAO,CAAC,EAAE,MAAM;CAG7B;AAED;;;GAGG;AACH,qBAAa,qBAAsB,SAAQ,aAAa;IACtD,IAAI,SAA0D;IAE9D,KAAK,EAAE,MAAM,CAAC;IACd,gBAAgB,CAAC,EAAE,MAAM,CAAC;gBAEd,KAAK,EAAE,MAAM,EAAE,gBAAgB,CAAC,EAAE,MAAM;CAKrD"}

package/lib/typescript/credential/issuance/mrtd-pop/types.d.ts

@@ -1,201 +0,0 @@
-import * as z from "zod";
-export type MrtdProofChallengeInfo = z.infer<typeof MrtdProofChallengeInfo>;
-export declare const MrtdProofChallengeInfo: z.ZodObject<{
-    protectedHeader: z.ZodObject<{
-        typ: z.ZodLiteral<"mrtd-ias+jwt">;
-        alg: z.ZodString;
-        kid: z.ZodString;
-    }, "strip", z.ZodTypeAny, {
-        alg: string;
-        kid: string;
-        typ: "mrtd-ias+jwt";
-    }, {
-        alg: string;
-        kid: string;
-        typ: "mrtd-ias+jwt";
-    }>;
-    payload: z.ZodObject<{
-        iss: z.ZodString;
-        aud: z.ZodString;
-        iat: z.ZodNumber;
-        exp: z.ZodNumber;
-        status: z.ZodLiteral<"require_interaction">;
-        type: z.ZodLiteral<"mrtd+ias">;
-        mrtd_auth_session: z.ZodString;
-        state: z.ZodString;
-        mrtd_pop_jwt_nonce: z.ZodString;
-        htu: z.ZodString;
-        htm: z.ZodLiteral<"POST">;
-    }, "strip", z.ZodTypeAny, {
-        state: string;
-        iss: string;
-        type: "mrtd+ias";
-        status: "require_interaction";
-        iat: number;
-        exp: number;
-        aud: string;
-        htm: "POST";
-        htu: string;
-        mrtd_auth_session: string;
-        mrtd_pop_jwt_nonce: string;
-    }, {
-        state: string;
-        iss: string;
-        type: "mrtd+ias";
-        status: "require_interaction";
-        iat: number;
-        exp: number;
-        aud: string;
-        htm: "POST";
-        htu: string;
-        mrtd_auth_session: string;
-        mrtd_pop_jwt_nonce: string;
-    }>;
-}, "strip", z.ZodTypeAny, {
-    payload: {
-        state: string;
-        iss: string;
-        type: "mrtd+ias";
-        status: "require_interaction";
-        iat: number;
-        exp: number;
-        aud: string;
-        htm: "POST";
-        htu: string;
-        mrtd_auth_session: string;
-        mrtd_pop_jwt_nonce: string;
-    };
-    protectedHeader: {
-        alg: string;
-        kid: string;
-        typ: "mrtd-ias+jwt";
-    };
-}, {
-    payload: {
-        state: string;
-        iss: string;
-        type: "mrtd+ias";
-        status: "require_interaction";
-        iat: number;
-        exp: number;
-        aud: string;
-        htm: "POST";
-        htu: string;
-        mrtd_auth_session: string;
-        mrtd_pop_jwt_nonce: string;
-    };
-    protectedHeader: {
-        alg: string;
-        kid: string;
-        typ: "mrtd-ias+jwt";
-    };
-}>;
-export type MrtdPoPChallenge = z.infer<typeof MrtdPoPChallenge>;
-export declare const MrtdPoPChallenge: z.ZodObject<{
-    protectedHeader: z.ZodObject<{
-        typ: z.ZodLiteral<"mrtd-ias-pop+jwt">;
-        alg: z.ZodString;
-        kid: z.ZodString;
-    }, "strip", z.ZodTypeAny, {
-        alg: string;
-        kid: string;
-        typ: "mrtd-ias-pop+jwt";
-    }, {
-        alg: string;
-        kid: string;
-        typ: "mrtd-ias-pop+jwt";
-    }>;
-    payload: z.ZodObject<{
-        iss: z.ZodString;
-        aud: z.ZodString;
-        iat: z.ZodNumber;
-        exp: z.ZodNumber;
-        challenge: z.ZodString;
-        mrtd_pop_nonce: z.ZodString;
-        mrz: z.ZodOptional<z.ZodString>;
-        htu: z.ZodString;
-        htm: z.ZodLiteral<"POST">;
-    }, "strip", z.ZodTypeAny, {
-        iss: string;
-        iat: number;
-        exp: number;
-        challenge: string;
-        aud: string;
-        htm: "POST";
-        htu: string;
-        mrtd_pop_nonce: string;
-        mrz?: string | undefined;
-    }, {
-        iss: string;
-        iat: number;
-        exp: number;
-        challenge: string;
-        aud: string;
-        htm: "POST";
-        htu: string;
-        mrtd_pop_nonce: string;
-        mrz?: string | undefined;
-    }>;
-}, "strip", z.ZodTypeAny, {
-    payload: {
-        iss: string;
-        iat: number;
-        exp: number;
-        challenge: string;
-        aud: string;
-        htm: "POST";
-        htu: string;
-        mrtd_pop_nonce: string;
-        mrz?: string | undefined;
-    };
-    protectedHeader: {
-        alg: string;
-        kid: string;
-        typ: "mrtd-ias-pop+jwt";
-    };
-}, {
-    payload: {
-        iss: string;
-        iat: number;
-        exp: number;
-        challenge: string;
-        aud: string;
-        htm: "POST";
-        htu: string;
-        mrtd_pop_nonce: string;
-        mrz?: string | undefined;
-    };
-    protectedHeader: {
-        alg: string;
-        kid: string;
-        typ: "mrtd-ias-pop+jwt";
-    };
-}>;
-export type MrtdPayload = {
-    dg1: string;
-    dg11: string;
-    sod_mrtd: string;
-};
-export type IasPayload = {
-    ias_pk: string;
-    sod_ias: string;
-    challenge_signed: string;
-};
-export type MrtdPopVerificationResult = z.infer<typeof MrtdPopVerificationResult>;
-export declare const MrtdPopVerificationResult: z.ZodObject<{
-    status: z.ZodLiteral<"require_interaction">;
-    type: z.ZodLiteral<"redirect_to_web">;
-    mrtd_val_pop_nonce: z.ZodString;
-    redirect_uri: z.ZodString;
-}, "strip", z.ZodTypeAny, {
-    type: "redirect_to_web";
-    status: "require_interaction";
-    redirect_uri: string;
-    mrtd_val_pop_nonce: string;
-}, {
-    type: "redirect_to_web";
-    status: "require_interaction";
-    redirect_uri: string;
-    mrtd_val_pop_nonce: string;
-}>;
-//# sourceMappingURL=types.d.ts.map

package/lib/typescript/credential/issuance/mrtd-pop/types.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../../../../src/credential/issuance/mrtd-pop/types.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,CAAC,MAAM,KAAK,CAAC;AAEzB,MAAM,MAAM,sBAAsB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,sBAAsB,CAAC,CAAC;AAC5E,eAAO,MAAM,sBAAsB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAmBjC,CAAC;AAEH,MAAM,MAAM,gBAAgB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,gBAAgB,CAAC,CAAC;AAChE,eAAO,MAAM,gBAAgB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAiB3B,CAAC;AAEH,MAAM,MAAM,WAAW,GAAG;IACxB,GAAG,EAAE,MAAM,CAAC;IACZ,IAAI,EAAE,MAAM,CAAC;IACb,QAAQ,EAAE,MAAM,CAAC;CAClB,CAAC;AAEF,MAAM,MAAM,UAAU,GAAG;IACvB,MAAM,EAAE,MAAM,CAAC;IACf,OAAO,EAAE,MAAM,CAAC;IAChB,gBAAgB,EAAE,MAAM,CAAC;CAC1B,CAAC;AAEF,MAAM,MAAM,yBAAyB,GAAG,CAAC,CAAC,KAAK,CAC7C,OAAO,yBAAyB,CACjC,CAAC;AACF,eAAO,MAAM,yBAAyB;;;;;;;;;;;;;;;EAKpC,CAAC"}

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

@@ -1,96 +0,0 @@
-import * as z from "zod";
-export type AuthorizationDetail = z.infer<typeof AuthorizationDetail>;
-export declare const AuthorizationDetail: z.ZodObject<{
-    type: z.ZodLiteral<"openid_credential">;
-    credential_configuration_id: z.ZodString;
-    credential_identifiers: z.ZodArray<z.ZodString, "many">;
-}, "strip", z.ZodTypeAny, {
-    type: "openid_credential";
-    credential_configuration_id: string;
-    credential_identifiers: string[];
-}, {
-    type: "openid_credential";
-    credential_configuration_id: string;
-    credential_identifiers: string[];
-}>;
-export type TokenResponse = z.infer<typeof TokenResponse>;
-export declare const TokenResponse: z.ZodObject<{
-    access_token: z.ZodString;
-    refresh_token: z.ZodOptional<z.ZodString>;
-    authorization_details: z.ZodArray<z.ZodObject<{
-        type: z.ZodLiteral<"openid_credential">;
-        credential_configuration_id: z.ZodString;
-        credential_identifiers: z.ZodArray<z.ZodString, "many">;
-    }, "strip", z.ZodTypeAny, {
-        type: "openid_credential";
-        credential_configuration_id: string;
-        credential_identifiers: string[];
-    }, {
-        type: "openid_credential";
-        credential_configuration_id: string;
-        credential_identifiers: string[];
-    }>, "many">;
-    expires_in: z.ZodNumber;
-    token_type: z.ZodString;
-}, "strip", z.ZodTypeAny, {
-    access_token: string;
-    authorization_details: {
-        type: "openid_credential";
-        credential_configuration_id: string;
-        credential_identifiers: string[];
-    }[];
-    expires_in: number;
-    token_type: string;
-    refresh_token?: string | undefined;
-}, {
-    access_token: string;
-    authorization_details: {
-        type: "openid_credential";
-        credential_configuration_id: string;
-        credential_identifiers: string[];
-    }[];
-    expires_in: number;
-    token_type: string;
-    refresh_token?: string | undefined;
-}>;
-export type CredentialResponse = z.infer<typeof CredentialResponse>;
-export declare const CredentialResponse: z.ZodObject<{
-    credentials: z.ZodArray<z.ZodObject<{
-        credential: z.ZodString;
-    }, "strip", z.ZodTypeAny, {
-        credential: string;
-    }, {
-        credential: string;
-    }>, "many">;
-    notification_id: z.ZodOptional<z.ZodString>;
-}, "strip", z.ZodTypeAny, {
-    credentials: {
-        credential: string;
-    }[];
-    notification_id?: string | undefined;
-}, {
-    credentials: {
-        credential: string;
-    }[];
-    notification_id?: string | undefined;
-}>;
-/**
- * Shape from parsing a response given by a request uri during the EAA credential issuance flow with response mode "form_post.jwt".
- */
-export declare const ResponseUriResultShape: z.ZodObject<{
-    redirect_uri: z.ZodString;
-}, "strip", z.ZodTypeAny, {
-    redirect_uri: string;
-}, {
-    redirect_uri: string;
-}>;
-export type ResponseMode = "query" | "form_post.jwt";
-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/types.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../../../src/credential/issuance/types.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,CAAC,MAAM,KAAK,CAAC;AAEzB,MAAM,MAAM,mBAAmB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,mBAAmB,CAAC,CAAC;AACtE,eAAO,MAAM,mBAAmB;;;;;;;;;;;;EAI9B,CAAC;AAEH,MAAM,MAAM,aAAa,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,aAAa,CAAC,CAAC;AAE1D,eAAO,MAAM,aAAa;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAMxB,CAAC;AAEH,MAAM,MAAM,kBAAkB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,kBAAkB,CAAC,CAAC;AAEpE,eAAO,MAAM,kBAAkB;;;;;;;;;;;;;;;;;;;EAO7B,CAAC;AAEH;;GAEG;AACH,eAAO,MAAM,sBAAsB;;;;;;EAEjC,CAAC;AAEH,MAAM,MAAM,YAAY,GAAG,OAAO,GAAG,eAAe,CAAC;AAErD,MAAM,MAAM,aAAa,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,aAAa,CAAC,CAAC;AAC1D,eAAO,MAAM,aAAa;;;;;;EAExB,CAAC"}

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

@@ -1,172 +0,0 @@
-import * as z from "zod";
-declare const CredentialOfferParams: z.ZodUnion<[z.ZodObject<{
-    credential_offer: z.ZodPipeline<z.ZodEffects<z.ZodString, string | number | boolean | {
-        [key: string]: string | number | boolean | any | (string | number | boolean | any | (string | number | boolean | any | (string | number | boolean | any | (string | number | boolean | any | (string | number | boolean | any | (string | number | boolean | any | (string | number | boolean | any | (string | number | boolean | any | (string | number | boolean | any | (string | number | boolean | any | (string | number | boolean | any | any | null)[] | null)[] | null)[] | null)[] | null)[] | null)[] | null)[] | null)[] | null)[] | null)[] | null)[] | null;
-    } | (string | number | boolean | any | (string | number | boolean | any | (string | number | boolean | any | (string | number | boolean | any | (string | number | boolean | any | (string | number | boolean | any | (string | number | boolean | any | (string | number | boolean | any | (string | number | boolean | any | (string | number | boolean | any | (string | number | boolean | any | any | null)[] | null)[] | null)[] | null)[] | null)[] | null)[] | null)[] | null)[] | null)[] | null)[] | null)[] | null, string>, z.ZodObject<{
-        credential_issuer: z.ZodString;
-        credential_configuration_ids: z.ZodArray<z.ZodString, "many">;
-        grants: z.ZodOptional<z.ZodObject<{
-            authorization_code: z.ZodOptional<z.ZodObject<{
-                issuer_state: z.ZodOptional<z.ZodString>;
-                authorization_server: z.ZodOptional<z.ZodString>;
-            }, "strip", z.ZodTypeAny, {
-                issuer_state?: string | undefined;
-                authorization_server?: string | undefined;
-            }, {
-                issuer_state?: string | undefined;
-                authorization_server?: string | undefined;
-            }>>;
-            "urn:ietf:params:oauth:grant-type:pre-authorized_code": z.ZodOptional<z.ZodObject<{
-                "pre-authorized_code": z.ZodString;
-                tx_code: z.ZodOptional<z.ZodObject<{
-                    input_mode: z.ZodOptional<z.ZodEnum<["numeric", "text"]>>;
-                    length: z.ZodOptional<z.ZodNumber>;
-                    description: z.ZodOptional<z.ZodString>;
-                }, "strip", z.ZodTypeAny, {
-                    input_mode?: "numeric" | "text" | undefined;
-                    length?: number | undefined;
-                    description?: string | undefined;
-                }, {
-                    input_mode?: "numeric" | "text" | undefined;
-                    length?: number | undefined;
-                    description?: string | undefined;
-                }>>;
-                authorization_server: z.ZodOptional<z.ZodString>;
-            }, "strip", z.ZodTypeAny, {
-                "pre-authorized_code": string;
-                tx_code?: {
-                    input_mode?: "numeric" | "text" | undefined;
-                    length?: number | undefined;
-                    description?: string | undefined;
-                } | undefined;
-                authorization_server?: string | undefined;
-            }, {
-                "pre-authorized_code": string;
-                tx_code?: {
-                    input_mode?: "numeric" | "text" | undefined;
-                    length?: number | undefined;
-                    description?: string | undefined;
-                } | undefined;
-                authorization_server?: string | undefined;
-            }>>;
-        }, "strip", z.ZodTypeAny, {
-            authorization_code?: {
-                issuer_state?: string | undefined;
-                authorization_server?: string | undefined;
-            } | undefined;
-            "urn:ietf:params:oauth:grant-type:pre-authorized_code"?: {
-                "pre-authorized_code": string;
-                tx_code?: {
-                    input_mode?: "numeric" | "text" | undefined;
-                    length?: number | undefined;
-                    description?: string | undefined;
-                } | undefined;
-                authorization_server?: string | undefined;
-            } | undefined;
-        }, {
-            authorization_code?: {
-                issuer_state?: string | undefined;
-                authorization_server?: string | undefined;
-            } | undefined;
-            "urn:ietf:params:oauth:grant-type:pre-authorized_code"?: {
-                "pre-authorized_code": string;
-                tx_code?: {
-                    input_mode?: "numeric" | "text" | undefined;
-                    length?: number | undefined;
-                    description?: string | undefined;
-                } | undefined;
-                authorization_server?: string | undefined;
-            } | undefined;
-        }>>;
-    }, "strip", z.ZodTypeAny, {
-        credential_issuer: string;
-        credential_configuration_ids: string[];
-        grants?: {
-            authorization_code?: {
-                issuer_state?: string | undefined;
-                authorization_server?: string | undefined;
-            } | undefined;
-            "urn:ietf:params:oauth:grant-type:pre-authorized_code"?: {
-                "pre-authorized_code": string;
-                tx_code?: {
-                    input_mode?: "numeric" | "text" | undefined;
-                    length?: number | undefined;
-                    description?: string | undefined;
-                } | undefined;
-                authorization_server?: string | undefined;
-            } | undefined;
-        } | undefined;
-    }, {
-        credential_issuer: string;
-        credential_configuration_ids: string[];
-        grants?: {
-            authorization_code?: {
-                issuer_state?: string | undefined;
-                authorization_server?: string | undefined;
-            } | undefined;
-            "urn:ietf:params:oauth:grant-type:pre-authorized_code"?: {
-                "pre-authorized_code": string;
-                tx_code?: {
-                    input_mode?: "numeric" | "text" | undefined;
-                    length?: number | undefined;
-                    description?: string | undefined;
-                } | undefined;
-                authorization_server?: string | undefined;
-            } | undefined;
-        } | undefined;
-    }>>;
-    credential_offer_uri: z.ZodUndefined;
-}, "strip", z.ZodTypeAny, {
-    credential_offer: {
-        credential_issuer: string;
-        credential_configuration_ids: string[];
-        grants?: {
-            authorization_code?: {
-                issuer_state?: string | undefined;
-                authorization_server?: string | undefined;
-            } | undefined;
-            "urn:ietf:params:oauth:grant-type:pre-authorized_code"?: {
-                "pre-authorized_code": string;
-                tx_code?: {
-                    input_mode?: "numeric" | "text" | undefined;
-                    length?: number | undefined;
-                    description?: string | undefined;
-                } | undefined;
-                authorization_server?: string | undefined;
-            } | undefined;
-        } | undefined;
-    };
-    credential_offer_uri?: undefined;
-}, {
-    credential_offer: string;
-    credential_offer_uri?: undefined;
-}>, z.ZodObject<{
-    credential_offer: z.ZodUndefined;
-    credential_offer_uri: z.ZodString;
-}, "strip", z.ZodTypeAny, {
-    credential_offer_uri: string;
-    credential_offer?: undefined;
-}, {
-    credential_offer_uri: string;
-    credential_offer?: undefined;
-}>]>;
-type CredentialOfferParams = z.infer<typeof CredentialOfferParams>;
-/**
- * The beginning of the credential offer flow.
- * To be implemented according to the user touchpoint
- *
- * @param params Credential offer encoded url
- * @returns Object containing the credential offer by reference or by value
- */
-export type StartFlow = (encodedUrl: string) => CredentialOfferParams;
-/**
- * Start a credential offer flow by validating and parse an encoded url
- * extracted from a QR code or a deep link.
- *
- * @param params The encoded url to be validated and parsed
- * @returns Object containing the credential offer by reference or by value
- * @throws If the provided encoded url is not valid
- */
-export declare const startFlowFromQR: StartFlow;
-export {};
-//# sourceMappingURL=01-start-flow.d.ts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"01-start-flow.d.ts","sourceRoot":"","sources":["../../../../src/credential/offer/01-start-flow.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,CAAC,MAAM,KAAK,CAAC;AAUzB,QAAA,MAAM,qBAAqB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;IASzB,CAAC;AACH,KAAK,qBAAqB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,qBAAqB,CAAC,CAAC;AAEnE;;;;;;GAMG;AACH,MAAM,MAAM,SAAS,GAAG,CAAC,UAAU,EAAE,MAAM,KAAK,qBAAqB,CAAC;AAEtE;;;;;;;GAOG;AACH,eAAO,MAAM,eAAe,EAAE,SAiD7B,CAAC"}

package/lib/typescript/credential/offer/02-fetch-credential-offer.d.ts

@@ -1,20 +0,0 @@
-import type { CredentialOffer } from "./types";
-export type GetCredentialOffer = (credentialOfferUri: string, context: {
-    appFetch?: GlobalFetch["fetch"];
-}) => Promise<CredentialOffer>;
-/**
- * Fetches and validates a credential offer from a given URI.
- *
- * This function performs an HTTP GET request to the specified `credentialOfferUri`,
- * expecting a JSON response that matches the `CredentialOfferSchema`. If the response
- * is invalid or does not conform to the schema, an error is logged and an
- * `InvalidCredentialOfferError` is thrown.
- *
- * @param credentialOfferUri - The URI from which to fetch the credential offer.
- * @param context - Optional context object that may provide a custom `appFetch` implementation.
- * @returns The validated credential offer data.
- * @throws {IssuerResponseError} If the HTTP response status is not 200.
- * @throws {InvalidCredentialOfferError} If the response does not match the expected schema.
- */
-export declare const fetchCredentialOffer: GetCredentialOffer;
-//# sourceMappingURL=02-fetch-credential-offer.d.ts.map

package/lib/typescript/credential/offer/02-fetch-credential-offer.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"02-fetch-credential-offer.d.ts","sourceRoot":"","sources":["../../../../src/credential/offer/02-fetch-credential-offer.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,SAAS,CAAC;AAG/C,MAAM,MAAM,kBAAkB,GAAG,CAC/B,kBAAkB,EAAE,MAAM,EAC1B,OAAO,EAAE;IACP,QAAQ,CAAC,EAAE,WAAW,CAAC,OAAO,CAAC,CAAC;CACjC,KACE,OAAO,CAAC,eAAe,CAAC,CAAC;AAE9B;;;;;;;;;;;;;GAaG;AACH,eAAO,MAAM,oBAAoB,EAAE,kBAyBlC,CAAC"}