@regulaforensics/idv-capture-web 0.1.85-nightly → 0.1.87-nightly

package/dist/index.d.ts

@@ -1,3 +1,92 @@
+declare class BaseDeinitializationError extends BaseError {
+    private static readonly MODULE;
+    private static readonly ERROR_ENUM_NAME;
+    private static readonly SHORT_CODE;
+    constructor({ errorCode, message, underlyingError, underlyingBaseError, }: {
+        errorCode: DeinitializationError;
+        message?: string;
+        underlyingError?: string;
+        underlyingBaseError?: BaseError;
+    });
+}
+
+declare class BaseError {
+    errorCode: number | string;
+    errorCodeKey: string;
+    message?: string;
+    underlyingError?: string;
+    underlyingBaseError?: BaseError;
+    domain?: string;
+    module: string;
+    errorEnumName: string;
+    shortDomainCode: string;
+    constructor({ errorCode, errorCodeKey, message, underlyingError, underlyingBaseError, domain, module, errorEnumName, shortDomainCode, }: {
+        errorCode: number | string;
+        errorCodeKey: string;
+        module: string;
+        message?: string;
+        underlyingError?: string;
+        underlyingBaseError?: BaseError;
+        domain?: string;
+        errorEnumName: string;
+        shortDomainCode: string;
+    });
+    static getErrorKey<T extends Record<string, any>>(errorCode: number | string, errorEnum: T): string;
+    get lastUnderlyingError(): string | undefined;
+    toObject(): Record<string, any>;
+    get shortChain(): string;
+    get fullChain(): string;
+}
+
+declare class BaseInitializationError extends BaseError {
+    private static readonly MODULE;
+    private static readonly ERROR_ENUM_NAME;
+    private static readonly SHORT_CODE;
+    constructor({ errorCode, message, underlyingError, underlyingBaseError, }: {
+        errorCode: InitializeError;
+        message?: string;
+        underlyingError?: string;
+        underlyingBaseError?: BaseError;
+    });
+}
+
+declare class BasePrepareWorkflowError extends BaseError {
+    private static readonly MODULE;
+    private static readonly ERROR_ENUM_NAME;
+    private static readonly SHORT_CODE;
+    constructor({ errorCode, message, underlyingError, underlyingBaseError, }: {
+        errorCode: PrepareWorkflowError;
+        message?: string;
+        underlyingError?: string;
+        underlyingBaseError?: BaseError;
+    });
+}
+
+declare class BaseScenarioError extends BaseError {
+    private static readonly MODULE;
+    private static readonly ERROR_ENUM_NAME;
+    private static readonly SHORT_CODE;
+    constructor({ errorCode, message, underlyingError, underlyingBaseError, }: {
+        errorCode: ScenarioError;
+        message?: string;
+        underlyingError?: string;
+        underlyingBaseError?: BaseError;
+    });
+}
+
+export declare enum ConnectionError {
+    HTTP_ISSUE = 0,
+    PROVIDER_ERROR = 1
+}
+
+export declare enum DeinitializationError {
+    SERVICE_NOT_CONNECTED = 0
+}
+
+export declare type DeinitializeCompletion = {
+    error?: BaseDeinitializationError;
+};
+
 export declare enum IdvEventTargets {
     WEB_COMPONENT = "WEB_COMPONENT",
     SERVICE = "SERVICE"
@@ -10,15 +99,17 @@ declare enum IdvEventTypes {
 
 export declare class IdvIntegrationService {
     initialize(config: IIdvConfig): Promise<{
-        error?: string;
+        error?: BaseInitializationError;
     }>;
     setNonce(id: string): void;
+    setSessionRestoreMode(isEnabled: boolean): void;
+    get currentSessionId(): string | null;
     getWorkFlows(params?: WorkflowListRequest): Promise<WorkflowListCompletion>;
     prepareWorkflow({ workfowId }: {
         workfowId: string;
     }): Promise<PrepareWorkflowCompletion>;
     startWorkflow(): Promise<WorkflowCompetion>;
-    deinitialize(): Promise<void>;
+    deinitialize(): Promise<DeinitializeCompletion>;
 }
 
 export declare type IdvMessageEvent = {
@@ -30,7 +121,7 @@ export declare type IdvMessageEvent = {
     details?: any;
 };
 
-declare enum IdvServiceErrors {
+export declare enum IdvServiceErrors {
     CONNECT_TO_IDV_ERROR = "CONNECT_TO_IDV_ERROR",
     PLAY_WORKFLOW_ERROR = "PLAY_WORKFLOW_ERROR",
     SERVICE_NOT_RUNNING_ERROR = "SERVICE_NOT_RUNNING_ERROR",
@@ -42,6 +133,9 @@ declare enum IdvServiceErrors {
 
 export declare enum IdvServiceMessages {
     INITIALIZED = "INITIALIZED",
+    DID_START_SESSION = "DID_START_SESSION",
+    DID_END_SESSION = "DID_END_SESSION",
+    DID_START_RESTORE_SESSION = "DID_START_RESTORE_SESSION",
     READY_TO_PLAY = "READY_TO_PLAY",
     CONNECT_TO_IDV = "CONNECT_TO_IDV",
     START_SESSION = "START_SESSION",
@@ -53,25 +147,23 @@ export declare enum IdvServiceMessages {
 export declare class IdvWebComponent extends HTMLElement {
     private _root;
     private _mounted;
-    private _nonce?;
     constructor();
     static get observedAttributes(): Array<string>;
-    private setNonce;
     connectedCallback(): void;
     get version(): string;
     private render;
     disconnectedCallback(): void;
 }
 
-declare type IIdvConfig = {
+export declare type IIdvConfig = {
     connectionConfig: IIdvOptions;
-    modulesConfig: Record<string, any>;
+    modulesConfig?: Record<string, any>;
     includedModules: any[];
     licenseConfig?: Record<string, any>;
     listener?: (message: IdvMessageEvent) => void;
 };
 
-declare type IIdvOptions = {
+export declare type IIdvOptions = {
     host: string;
     httpRetryCount?: number;
     httpTimeoutMs?: number;
@@ -82,54 +174,82 @@ declare type IIdvOptions = {
     userName: string;
 };
 
-declare type PrepareWorkflowCompletion = {
+export declare type InitializeCompletion = {
+    error?: BaseInitializationError;
+};
+
+export declare enum InitializeError {
+    CONFIG_MISSED_OR_INVALID = 0,
+    MODULES_INSTANTIATION_FAILURE = 1,
+    INITIALIZATION_IN_PROGRESS = 2
+}
+
+export declare type PrepareWorkflowCompletion = {
     workflow?: Workflow;
-    error?: PrepareWorkflowError;
+    error?: BasePrepareWorkflowError;
 };
 
-declare enum PrepareWorkflowError {
-    CONNECTION_ISSUE = "CONNECTION_ISSUE",
-    WORKFLOW_ISSUE = "WORKFLOW_ISSUE",
-    INTERNAL_ISSUE = "INTERNAL_ISSUE"
+export declare enum PrepareWorkflowError {
+    INITIALIZATION_REQUIRED = 0,
+    CONNECTION_ISSUE = 1,
+    WORKFLOW_ISSUE = 2,
+    INTERNAL_ISSUE = 3,
+    SCENARIO_IN_PROGRESS = 4
 }
 
-declare enum ScenarioError {
-    SESSION_ISSUE = "SESSION_ISSUE",
-    ALREADY_STARTED = "ALREADY_STARTED",
-    NOT_PREPARED = "NOT_PREPARED",
-    STEP_ISSUE = "STEP_ISSUE",
-    INTERNAL_ISSUE = "INTERNAL_ISSUE"
+export declare enum ScenarioError {
+    INITIALIZATION_REQUIRED = 0,
+    PREPARED_REQUIRED = 1,
+    START_SESSION_ERROR = 2,
+    UNKNOWN_STEP = 3,
+    MODULES_ISSUE = 4,
+    ALREADY_STARTED = 5,
+    INTERNAL_ISSUE = 6
 }
 
 declare type ScenarioResults = {
-    status: ScenarioStatus;
-    results?: Record<string, any>;
-};
+    sessionId?: string;
+    finalStep?: WorkflowStep;
+} & Record<string, any>;
 
-declare enum ScenarioStatus {
-    FINISHED = "FINISHED",
-    CANCELLED = "CANCELLED",
-    ERROR = "ERROR"
+export declare enum SessionError {
+    HTTP_ISSUE = 0,
+    PROVIDER_ERROR = 1,
+    DECODING_FAILED = 2,
+    SAME_STEP = 3,
+    IS_PROCESSING = 4,
+    NOT_DATA_TYPE = 5
+}
+
+export declare enum StartSessionError {
+    HTTP_ISSUE = 0,
+    PROVIDER_ERROR = 1,
+    DECODING_FAILED = 2
 }
 
 declare type Workflow = {
     id: string;
-    currentStep: string;
-    steps: Array<any>;
+    steps: Array<WorkflowStep>;
     client: {
         layout: Record<string, any>;
-        steps: Array<any>;
+        steps: Array<WorkflowStep>;
     };
 } & Record<string, any>;
 
-declare type WorkflowCompetion = {
+export declare type WorkflowCompetion = {
     results?: ScenarioResults;
-    error?: ScenarioError;
+    error?: BaseScenarioError;
 };
 
-declare type WorkflowListCompletion = {
+export declare enum WorkflowError {
+    HTTP_ISSUE = 0,
+    PROVIDER_ERROR = 1,
+    DECODING_FAILED = 2
+}
+
+export declare type WorkflowListCompletion = {
     results?: Workflow[];
-    error?: PrepareWorkflowError;
+    error?: BasePrepareWorkflowError;
 };
 
 declare type WorkflowListRequest = {
@@ -137,4 +257,10 @@ declare type WorkflowListRequest = {
     skip: number;
 };
 
+declare type WorkflowStep = {
+    id: string;
+    name: string;
+    final: boolean;
+} & Record<string, any>;
+
 export { }