@mattrglobal/verifier-sdk-web 2.0.0-preview-digital-credential-api.5 → 2.0.1-unstable.0

package/dist/typings/common/safeFetch.d.ts

@@ -1,10 +1,10 @@
 import { Result } from "neverthrow";
 import { BaseError } from "./error";
-export declare enum SafeFetchCommonRespondErrorType {
+export declare enum SafeFetchCommonResponseErrorType {
     /**
      * Unexpected response from the remote server
      */
-    UnexpectedRespond = "UnexpectedRespond"
+    UnexpectedResponse = "UnexpectedResponse"
 }
 export declare enum SafeFetchErrorType {
     /**
@@ -16,11 +16,14 @@ export declare enum SafeFetchErrorType {
      */
     UnknownError = "UnknownError"
 }
-export type SafeFetchValidateRespondError = BaseError<SafeFetchErrorType | SafeFetchCommonRespondErrorType.UnexpectedRespond>;
+export type SafeFetchValidateResponseError = BaseError<SafeFetchErrorType | SafeFetchCommonResponseErrorType.UnexpectedResponse> & {
+    status?: number;
+};
 export type SafeFetchError = BaseError<SafeFetchErrorType> & {
     status?: number;
 };
 /**
  * Safe fetch function that wraps the fetch function and returns a Result type
+ * injects the package version number into the x-mattr-sdk-version header to help support backwards compatibility
  */
 export declare const safeFetch: (input: RequestInfo, init?: RequestInit) => Promise<Result<Response, SafeFetchError>>;

package/dist/typings/common/sleep.d.ts

@@ -0,0 +1 @@
+export declare const sleep: (ms: number) => Promise<void>;

package/dist/typings/index.d.ts

@@ -1,12 +1,11 @@
-import { initialise, requestCredentials, handleRedirectCallback } from "./verifier";
+import { initialize, requestCredentials, handleRedirectCallback, abortCredentialRequest, isDigitalCredentialsApiSupported } from "./verifier";
 import { HandleRedirectCallbackError, HandleRedirectCallbackErrorType } from "./verifier/handleRedirectCallback";
-import { CrossDeviceCallbackError, CrossDeviceCallbackErrorType } from "./verifier/requestCredentialsCrossDevice";
-import { InitialiseOptions, RequestCredentialsOptions, RequestCredentialsSameDeviceOptions, RequestCredentialsCrossDeviceDeviceOptions, RequestCredentialsAutoDetectOptions, RequestCredentialsError, RequestCredentialsErrorType, CredentialQuery, CredentialQueryClaim, OpenidPresentationCredentialProfileSupported, Mode, RequestCredentialsResponse, SameDeviceRequestCredentialsResponse, CrossDeviceRequestCredentialsResponse, HandleRedirectCallbackResponse, Claim, ClaimData, ClaimType, PresentationSessionResult, PresentationSuccessResult, PresentationFailureResult, PresentationHiddenResult, PresentationErrorType, MobileCredentialPresentationCredential, MobileCredentialError, MobileCredentialResponseErrorCode, ValidityInfoRequest, CredentialBranding, CredentialBrandingImage, MobileCredentialVerificationResult, MobileCredentialVerificationReasonType, CredentialBrandingImageFormat, CrossDeviceCallback, CrossDeviceCallbackOnCompleteResponse } from "./verifier/types";
-export { Mode, OpenidPresentationCredentialProfileSupported, MobileCredentialVerificationReasonType, RequestCredentialsErrorType, CrossDeviceCallbackErrorType, HandleRedirectCallbackErrorType, CredentialBrandingImageFormat, ClaimType, MobileCredentialResponseErrorCode, };
-export type { InitialiseOptions, RequestCredentialsOptions, RequestCredentialsSameDeviceOptions, RequestCredentialsCrossDeviceDeviceOptions, RequestCredentialsAutoDetectOptions, CredentialQuery, CredentialQueryClaim, RequestCredentialsResponse, SameDeviceRequestCredentialsResponse, CrossDeviceRequestCredentialsResponse, RequestCredentialsError, CrossDeviceCallbackError, Claim, ClaimData, HandleRedirectCallbackResponse, PresentationSessionResult, PresentationSuccessResult, PresentationFailureResult, PresentationHiddenResult, PresentationErrorType, MobileCredentialPresentationCredential, MobileCredentialError, ValidityInfoRequest, CredentialBranding, CredentialBrandingImage, CrossDeviceCallback, CrossDeviceCallbackOnCompleteResponse, MobileCredentialVerificationResult, HandleRedirectCallbackError, };
+import { InitializeOptions, RequestCredentialsOptions, OpenIdvpConfiguration, OpenId4vpConfigurationSameDeviceOptions, OpenId4vpConfigurationCrossDeviceOptions, OpenId4vpConfigurationAutoDetectOptions, RequestCredentialsError, RequestCredentialsErrorType, CredentialQuery, CredentialQueryClaim, OpenidPresentationCredentialProfileSupported, Mode, RequestCredentialsResponse, AbortSessionErrorType, HandleRedirectCallbackResponse, Claim, ClaimData, ClaimType, PresentationSessionResult, PresentationSuccessResult, PresentationFailureResult, PresentationHiddenResult, PresentationErrorType, MobileCredentialPresentationCredential, MobileCredentialError, MobileCredentialResponseErrorCode, ValidityInfoRequest, CredentialBranding, CredentialBrandingImage, MobileCredentialVerificationResult, MobileCredentialVerificationReasonType, CredentialBrandingImageFormat } from "./verifier/types";
+export { Mode, OpenidPresentationCredentialProfileSupported, MobileCredentialVerificationReasonType, RequestCredentialsErrorType, AbortSessionErrorType, HandleRedirectCallbackErrorType, CredentialBrandingImageFormat, ClaimType, MobileCredentialResponseErrorCode, };
+export type { InitializeOptions, RequestCredentialsOptions, OpenIdvpConfiguration, OpenId4vpConfigurationSameDeviceOptions, OpenId4vpConfigurationCrossDeviceOptions, OpenId4vpConfigurationAutoDetectOptions, CredentialQuery, CredentialQueryClaim, RequestCredentialsResponse, RequestCredentialsError, Claim, ClaimData, HandleRedirectCallbackResponse, PresentationSessionResult, PresentationSuccessResult, PresentationFailureResult, PresentationHiddenResult, PresentationErrorType, MobileCredentialPresentationCredential, MobileCredentialError, ValidityInfoRequest, CredentialBranding, CredentialBrandingImage, MobileCredentialVerificationResult, HandleRedirectCallbackError, };
 declare const utils: {
     generateChallenge: () => string;
+    getVersion: () => string;
     unwrap: <T = unknown>(result: import("neverthrow").Result<T, unknown>, errMessage?: string) => T;
-    isDigitalCredentialsApiSupported: () => boolean;
 };
-export { initialise, requestCredentials, handleRedirectCallback, utils };
+export { initialize, requestCredentials, handleRedirectCallback, abortCredentialRequest, isDigitalCredentialsApiSupported, utils, };

package/dist/typings/verifier/abortCredentialRequest.d.ts

@@ -0,0 +1,6 @@
+import { Result } from "neverthrow";
+import { AbortSessionError } from "./types";
+/**
+ * Abort the current credential request if there is an active session.
+ */
+export declare const abortCredentialRequest: () => Promise<Result<void, AbortSessionError>>;

package/dist/typings/verifier/handleRedirectCallback.d.ts

@@ -10,7 +10,7 @@ export declare enum HandleRedirectCallbackErrorType {
 export declare enum HandleRedirectCallbackErrorMessage {
     FailedToFindResponseCode = "Failed to find response code",
     FailedToFindChallenge = "Failed to find challenge",
-    FailedToFindSessionId = "Failed to find sessionId",
+    FailedToFindActiveSession = "Failed to find active session",
     FailedToGetSessionResult = "Failed to get session result"
 }
 export type HandleRedirectCallbackError = BaseError<HandleRedirectCallbackErrorType>;

package/dist/typings/verifier/index.d.ts

@@ -1,5 +1,7 @@
-export { initialise } from "./initialise";
+export { initialize } from "./initialize";
 export { requestCredentials } from "./requestCredentials";
 export { handleRedirectCallback } from "./handleRedirectCallback";
+export { abortCredentialRequest } from "./abortCredentialRequest";
+export { isDigitalCredentialsApiSupported } from "./requestCredentialsDigitalCredentialsApi";
 export * as types from "./types";
 export * as utils from "./utils";

package/dist/typings/verifier/initialize.d.ts

@@ -0,0 +1,12 @@
+import { InitializeOptions } from "./types";
+export declare enum InitializeErrorMessage {
+    SdkNotInitialized = "SDK not initialized"
+}
+/**
+ * Initializes the SDK with the provided options.
+ *
+ * @param options - The {@link InitializeOptions | options} to initialize the SDK with.
+ */
+export declare const initialize: (options: InitializeOptions) => void;
+export declare const getInitializeOptions: () => InitializeOptions | undefined;
+export declare const clearInitializeOptions: () => void;

package/dist/typings/verifier/instanceContext.d.ts

@@ -0,0 +1,7 @@
+import { CreatePresentationSession, StoredPresentationSession } from "./types";
+/**
+ * Returns the currently active presentation session.
+ */
+export declare const getActiveSession: () => StoredPresentationSession | undefined;
+export declare const setActiveSession: (session: CreatePresentationSession) => AbortController;
+export declare const removeActiveSession: () => void;

package/dist/typings/verifier/requestCredentials.d.ts

@@ -3,7 +3,7 @@ import { RequestCredentialsError, RequestCredentialsOptions, RequestCredentialsR
 /**
  * Requests credentials based on the provided options.
  *
- * @param options - The options to request credentials with.
- * @returns A promise that resolves to a result containing either the requested credentials or an error.
+ * @param options - The options to request credentials with {@link RequestCredentialsOptions}.
+ * @returns A promise that resolves to a result containing either the {@link RequestCredentialsResponse | requested credentials} or an {@link RequestCredentialsError | error}.
  */
 export declare const requestCredentials: (options: RequestCredentialsOptions) => Promise<Result<RequestCredentialsResponse, RequestCredentialsError>>;

package/dist/typings/verifier/requestCredentialsCrossDevice.d.ts

@@ -1,48 +1,4 @@
 import { Result } from "neverthrow";
-import { BaseError } from "../common";
-import { CrossDeviceCallback, CrossDeviceRequestCredentialsOptions, CrossDeviceRequestCredentialsResponse, MessageEvent, RequestCredentialsError, RequestCredentialsErrorType } from "./types";
-/**
- * The error type for the cross device callback
- */
-export declare enum CrossDeviceCallbackErrorType {
-    Timeout = "Timeout",
-    Abort = "Abort",
-    RequestCredentialsFailed = "RequestCredentialsFailed"
-}
-export declare enum CrossDeviceRequestCredentialsErrorMessage {
-    FailedToGetSessionResult = "Failed to get session result",
-    FailedToCreateSession = "Failed to create session",
-    Abort = "User aborted the session",
-    Timeout = "User session timeout"
-}
-/**
- * Cross device callback error
- */
-export type CrossDeviceCallbackError = BaseError<CrossDeviceCallbackErrorType | RequestCredentialsErrorType>;
-type ReceiveMessageHandlerOptions = {
-    crossDeviceCallback: CrossDeviceCallback;
-    sessionId: string;
-    container: HTMLDivElement;
-    apiBaseUrl: string;
-    challenge: string;
-};
-export declare let listener: (event: MessageEvent) => Promise<void>;
-/**
- * usage from iframe:
- *       fetch("/v2/presentations/sessions/sessionId/status").then(function(response) {
- *         response.json().then(function(data) {
- *           if (data.status === "ResultReady") {
- *             const message = { type: "PresentationCompleted", responseCode: "123", sessionId: "sessionId" };
- *             const targetOrigin = "*"; // need to match front-end URL or "*"
- *             window.postMessage(message, targetOrigin);
- *
- * VII hosted session page in the iframe will notify result via window.postMessage with the following messages:
- *   PresentationCompleted = "PresentationCompleted", // { type: "PresentationCompleted", responseCode, sessionId }
- *   PresentationTimeout = "PresentationTimeout", // { type: "PresentationTimeout", sessionId }
- *   PresentationAbort = "PresentationAbort", // { type: "PresentationAbort", sessionId }
- *
- * @param options -
- */
-export declare const receiveMessageHandler: (options: ReceiveMessageHandlerOptions) => (event: MessageEvent) => Promise<void>;
-export declare const requestCredentialsCrossDevice: (options: CrossDeviceRequestCredentialsOptions) => Promise<Result<CrossDeviceRequestCredentialsResponse, RequestCredentialsError>>;
-export {};
+import { CrossDeviceRequestCredentialsOptions, MessageEvent, RequestCredentialsError, RequestCredentialsResponse } from "./types";
+export declare let listener: ((event: MessageEvent) => Promise<void>) | undefined;
+export declare const requestCredentialsWithCrossDevice: (options: CrossDeviceRequestCredentialsOptions) => Promise<Result<RequestCredentialsResponse, RequestCredentialsError>>;

package/dist/typings/verifier/requestCredentialsDigitalCredentialsApi.d.ts

@@ -0,0 +1,17 @@
+import { Result } from "neverthrow";
+import { BaseError } from "../common";
+import { RequestCredentialsErrorType, RequestCredentialsResponse, RequestCredentialsWithDcApiOptions } from "./types";
+/**
+ * Request credentials for the Digital Credentials API
+ *
+ * @param options - {@link RequestCredentialsWithDcApiOptions}
+ * @ignore - Dark release
+ */
+export declare const requestCredentialsWithDigitalCredentialsApi: (options: RequestCredentialsWithDcApiOptions) => Promise<Result<RequestCredentialsResponse, BaseError<RequestCredentialsErrorType.RequestCredentialsFailed>>>;
+/**
+ * Checks if Digital Credentials API feature is supported for the current browser.
+ * @ignore - Dark release
+ *
+ * @returns boolean.
+ */
+export declare const isDigitalCredentialsApiSupported: () => boolean;

package/dist/typings/verifier/requestCredentialsSameDevice.d.ts

@@ -1,5 +1,5 @@
 import { Result } from "neverthrow";
-import { RequestCredentialsError, RequestCredentialsResponse, SameDeviceRequestCredentialsOptions } from "./types";
+import { RequestCredentialsError, SameDeviceRequestCredentialsOptions, RequestCredentialsResponse } from "./types";
 export declare enum SameDeviceRequestCredentialsErrorMessage {
     FailedToStoreChallenge = "Failed to store challenge",
     FailedToCreateSession = "Failed to create session"

package/dist/typings/verifier/types/credential-presentation.d.ts

@@ -1,15 +1,53 @@
 import * as v from "valibot";
 export declare enum MobileCredentialVerificationReasonType {
-    /** Credential has expired  */
-    Expired = "expired",
-    /** Credential is not yet active */
-    Inactive = "inactive",
-    /** Credential has been revoked permanently and a new credential must be issued */
-    StatusRevoked = "invalid",
-    /** Credential has been suspended and must be re-activated before use */
-    StatusSuspended = "suspended",
-    /** The Credentials status could not be resolved or verified */
-    StatusUnknown = "unknown"
+    /**
+     * Trusted issuer certificate expired.
+     */
+    TrustedIssuerCertificateExpired = "TrustedIssuerCertificateExpired",
+    /**
+     * Trusted issuer certificate not yet valid.
+     */
+    TrustedIssuerCertificateNotYetValid = "TrustedIssuerCertificateNotYetValid",
+    /**
+     * Credential was issued by a certificate other than the ones on the trusted issuer list.
+     */
+    IssuerNotTrusted = "IssuerNotTrusted",
+    /**
+     * Mobile credential is not valid.
+     */
+    MobileCredentialInvalid = "MobileCredentialInvalid",
+    /**
+     * Mobile credential expired.
+     */
+    MobileCredentialExpired = "MobileCredentialExpired",
+    /**
+     * Mobile credential not yet valid.
+     */
+    MobileCredentialNotYetValid = "MobileCredentialNotYetValid",
+    /**
+     * Invalid signer certificate.
+     */
+    InvalidSignerCertificate = "InvalidSignerCertificate",
+    /**
+     * Device key is not valid.
+     */
+    DeviceKeyInvalid = "DeviceKeyInvalid",
+    /**
+     * Mobile credential object contains unsupported curve.
+     */
+    UnsupportedCurve = "UnsupportedCurve",
+    /**
+     * Mobile credential has been revoked.
+     */
+    StatusRevoked = "StatusRevoked",
+    /**
+     * Mobile credential has been suspended.
+     */
+    StatusSuspended = "StatusSuspended",
+    /**
+     * Mobile credential status is unknown and could not be determined.
+     */
+    StatusUnknown = "StatusUnknown"
 }
 export declare enum ClaimType {
     Boolean = "boolean",
@@ -38,6 +76,15 @@ export type MobileCredentialError = {
 export declare enum OpenidPresentationCredentialProfileSupported {
     MOBILE = "mobile"
 }
+/**
+ * A subset of status code for presentation session
+ */
+export declare enum PresentationStatusCode {
+    AwaitingRequestRetrieval = "AwaitingRequestRetrieval",
+    AwaitingResponse = "AwaitingResponse",
+    ResponseSubmitted = "ResponseSubmitted",
+    ResultReady = "ResultReady"
+}
 export type CredentialQueryClaim = {
     /**
      * `intentToRetain` (Optional): When set to `true`, the holder will be indicated that the verifier intends to retain this claim beyond the verification workflow. Defaults to `false` when not specified.
@@ -73,7 +120,7 @@ export type CredentialQuery = {
     profile: OpenidPresentationCredentialProfileSupported;
     /**
      * the mDL’s type. Confirm with the certificate issuer for what docType they are issuing. Some common examples include:
-     *   * Mobile Driver Licence (`org.iso.18013.5.1.mDL`).
+     *   * Mobile Driver License (`org.iso.18013.5.1.mDL`).
      *   * PhotoID (`org.iso.23220.photoid.1`).
      *   * Mobile Vehicle Registration Card (`org.iso.7367.1.mVRC`).
      *   * Health certificate (`org.micov.vtr.1`).
@@ -92,39 +139,9 @@ export declare const CredentialQueryValidator: v.ObjectSchema<{
     readonly profile: v.PicklistSchema<[OpenidPresentationCredentialProfileSupported], undefined>;
     readonly docType: v.StringSchema<undefined>;
     readonly nameSpaces: v.RecordSchema<v.StringSchema<undefined>, v.RecordSchema<v.StringSchema<undefined>, v.StrictObjectSchema<{
-        readonly intentToRetain: v.OptionalSchema<v.BooleanSchema<undefined>, never>;
+        readonly intentToRetain: v.OptionalSchema<v.BooleanSchema<undefined>, undefined>;
     }, undefined>, undefined>, undefined>;
 }, undefined>;
-export type DcqlCredentialQuery = {
-    credentials: {
-        id: string;
-        format: string;
-        meta?: unknown;
-        claims: {
-            path: string[];
-        }[];
-    }[];
-    credential_sets?: {
-        options: string[][];
-        required?: boolean;
-        purpose?: unknown;
-    }[];
-};
-export declare const DcqlCredentialQueryValidator: v.ObjectSchema<{
-    readonly credentials: v.ArraySchema<v.ObjectSchema<{
-        readonly id: v.StringSchema<undefined>;
-        readonly format: v.StringSchema<undefined>;
-        readonly meta: v.OptionalSchema<v.UnknownSchema, never>;
-        readonly claims: v.ArraySchema<v.ObjectSchema<{
-            readonly path: v.ArraySchema<v.StringSchema<undefined>, undefined>;
-        }, undefined>, undefined>;
-    }, undefined>, undefined>;
-    readonly credential_sets: v.OptionalSchema<v.ArraySchema<v.ObjectSchema<{
-        readonly options: v.ArraySchema<v.ArraySchema<v.StringSchema<undefined>, undefined>, undefined>;
-        readonly required: v.OptionalSchema<v.BooleanSchema<undefined>, never>;
-        readonly purpose: v.OptionalSchema<v.UnknownSchema, never>;
-    }, undefined>, undefined>, never>;
-}, undefined>;
 /**
  * List of error types for presentation failure result
  */
@@ -212,9 +229,9 @@ export type Claim = {
     readonly value: Array<ClaimData>;
 };
 export type MobileCredentialPresentationCredential = {
-    docType: string;
-    validityInfo: ValidityInfoRequest;
-    issuerInfo: {
+    docType?: string;
+    validityInfo?: ValidityInfoRequest;
+    issuerInfo?: {
         commonName: string;
         trustedIssuerId: string;
     };
@@ -229,7 +246,7 @@ export type MobileCredentialPresentationCredential = {
 export type PresentationSuccessResult = {
     sessionId: string;
     challenge: string;
-    credentialQuery: CredentialQuery[] | DcqlCredentialQuery;
+    credentialQuery: CredentialQuery[];
     credentials?: MobileCredentialPresentationCredential[];
     credentialErrors?: MobileCredentialError[];
 };
@@ -243,24 +260,24 @@ export type PresentationResultRelax = {
 };
 export declare const PresentationResultRelaxValidator: v.ObjectSchema<{
     readonly sessionId: v.StringSchema<undefined>;
-    readonly challenge: v.OptionalSchema<v.StringSchema<undefined>, never>;
-    /*** we not runtime validation the these types ***/
-    readonly credentialQuery: v.OptionalSchema<v.UnknownSchema, never>;
-    readonly credentials: v.OptionalSchema<v.UnknownSchema, never>;
-    readonly credentialErrors: v.OptionalSchema<v.UnknownSchema, never>;
-    readonly error: v.OptionalSchema<v.UnknownSchema, never>;
+    readonly challenge: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
+    /*** we do not validate these types at runtime ***/
+    readonly credentialQuery: v.OptionalSchema<v.UnknownSchema, undefined>;
+    readonly credentials: v.OptionalSchema<v.UnknownSchema, undefined>;
+    readonly credentialErrors: v.OptionalSchema<v.UnknownSchema, undefined>;
+    readonly error: v.OptionalSchema<v.UnknownSchema, undefined>;
 }, undefined>;
 export type PresentationFailureResult = {
     sessionId: string;
     challenge: string;
-    credentialQuery: CredentialQuery[] | DcqlCredentialQuery;
+    credentialQuery: CredentialQuery[];
     error: {
         type: PresentationErrorType;
         message: string;
     };
 };
 /**
- * The result of a hidden credential presentation request, return when use with `resultAvailableInFrontChannel: false` as verifier's configuration
+ * The result of a hidden credential presentation request, retured when `resultAvailableInFrontChannel` is set to false in verifier's configuration
  */
 export type PresentationHiddenResult = {
     sessionId: string;
@@ -273,48 +290,86 @@ export type ExchangeSessionResultRequest = {
     readonly challenge: string;
     readonly responseCode: string;
 };
+/**
+ * The mode in which the credentials are requested
+ */
+export declare enum Mode {
+    /**
+     * The credentials are requested on the same device
+     */
+    SameDevice = "sameDevice",
+    /**
+     * The credentials are requested on a different device
+     */
+    CrossDevice = "crossDevice"
+}
+/**
+ * The type of presentation flow type to proceed with, defined by MATTR VII
+ */
+export declare enum SessionType {
+    /**
+     * SDK should proceed with presentation flow via Digital Credentials API
+     */
+    DigitalCredentialsApi = "digital-credentials-api",
+    /**
+     * SDK should proceed with presentation flow via openId4vci
+     */
+    Openid4vp = "openid4vp"
+}
 export type ExchangeSessionResultResponse = PresentationSessionResult | PresentationHiddenResult;
+export type RequestCredentialsWithDcApiOptions = {
+    apiBaseUrl: string;
+    sessionId: string;
+    sessionKey: string;
+    sessionTtl: number;
+    challenge: string;
+    request: Record<string, unknown>;
+};
 export type CreateSessionRequest = v.InferOutput<typeof CreateSessionRequestValidator>;
 export declare const CreateSessionRequestValidator: v.ObjectSchema<{
-    readonly credentialQuery: v.UnionSchema<[v.ArraySchema<v.ObjectSchema<{
+    readonly credentialQuery: v.ArraySchema<v.ObjectSchema<{
         readonly profile: v.PicklistSchema<[OpenidPresentationCredentialProfileSupported], undefined>;
         readonly docType: v.StringSchema<undefined>;
         readonly nameSpaces: v.RecordSchema<v.StringSchema<undefined>, v.RecordSchema<v.StringSchema<undefined>, v.StrictObjectSchema<{
-            readonly intentToRetain: v.OptionalSchema<v.BooleanSchema<undefined>, never>;
+            readonly intentToRetain: v.OptionalSchema<v.BooleanSchema<undefined>, undefined>;
         }, undefined>, undefined>, undefined>;
-    }, undefined>, undefined>, v.ObjectSchema<{
-        readonly credentials: v.ArraySchema<v.ObjectSchema<{
-            readonly id: v.StringSchema<undefined>;
-            readonly format: v.StringSchema<undefined>;
-            readonly meta: v.OptionalSchema<v.UnknownSchema, never>;
-            readonly claims: v.ArraySchema<v.ObjectSchema<{
-                readonly path: v.ArraySchema<v.StringSchema<undefined>, undefined>;
-            }, undefined>, undefined>;
-        }, undefined>, undefined>;
-        readonly credential_sets: v.OptionalSchema<v.ArraySchema<v.ObjectSchema<{
-            readonly options: v.ArraySchema<v.ArraySchema<v.StringSchema<undefined>, undefined>, undefined>;
-            readonly required: v.OptionalSchema<v.BooleanSchema<undefined>, never>;
-            readonly purpose: v.OptionalSchema<v.UnknownSchema, never>;
-        }, undefined>, undefined>, never>;
-    }, undefined>], undefined>;
+    }, undefined>, undefined>;
     readonly challenge: v.StringSchema<undefined>;
-    readonly redirectUri: v.OptionalSchema<v.StringSchema<undefined>, never>;
-    readonly walletProviderId: v.OptionalSchema<v.StringSchema<undefined>, never>;
+    readonly redirectUri: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
+    readonly walletProviderId: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
+    readonly dcApiSupported: v.OptionalSchema<v.BooleanSchema<undefined>, undefined>;
 }, undefined>;
-export type CreateSessionResponse = {
-    sessionId: string;
-    sessionUrl: string;
-};
-export declare const CreateSessionResponseValidator: v.ObjectSchema<{
+export type CreateSessionResponse = v.InferOutput<typeof CreateSessionResponseValidator>;
+export declare const CreateSessionResponseValidator: v.UnionSchema<[v.ObjectSchema<{
+    readonly type: v.LiteralSchema<SessionType.DigitalCredentialsApi, undefined>;
     readonly sessionId: v.StringSchema<undefined>;
+    readonly sessionKey: v.StringSchema<undefined>;
+    readonly sessionTtl: v.NumberSchema<undefined>;
+    readonly request: v.RecordSchema<v.StringSchema<undefined>, v.AnySchema, undefined>;
+}, undefined>, v.ObjectSchema<{
+    readonly type: v.OptionalSchema<v.LiteralSchema<SessionType.Openid4vp, undefined>, undefined>;
+    readonly sessionId: v.StringSchema<undefined>;
+    readonly sessionKey: v.StringSchema<undefined>;
     readonly sessionUrl: v.StringSchema<undefined>;
+}, undefined>], undefined>;
+export type AbortSessionRequest = v.InferOutput<typeof AbortSessionRequestValidator>;
+export declare const AbortSessionRequestValidator: v.ObjectSchema<{
+    readonly sessionId: v.StringSchema<undefined>;
+    readonly sessionKey: v.StringSchema<undefined>;
+    readonly apiBaseUrl: v.StringSchema<undefined>;
 }, undefined>;
-/*** session end ***/
-export type CreateDigitalCredentialsApiSessionResponse = {
-    sessionId: string;
-    request: any;
-};
-export declare const CreateDigitalCredentialsApiSessionResponseValidator: v.ObjectSchema<{
+export type GetSessionStatusRequest = v.InferOutput<typeof GetSessionStatusRequestValidator>;
+export declare const GetSessionStatusRequestValidator: v.ObjectSchema<{
     readonly sessionId: v.StringSchema<undefined>;
-    readonly request: v.ObjectSchema<{}, undefined>;
+    readonly sessionKey: v.StringSchema<undefined>;
 }, undefined>;
+export type GetSessionStatusResponse = {
+    status: string;
+    responseCode?: string;
+};
+export declare const GetSessionStatusResponseValidator: v.UnionSchema<[v.ObjectSchema<{
+    readonly status: v.PicklistSchema<[PresentationStatusCode.ResultReady], undefined>;
+    readonly responseCode: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
+}, undefined>, v.ObjectSchema<{
+    readonly status: v.StringSchema<undefined>;
+}, undefined>], undefined>;