@regulaforensics/idv-capture-web 3.2.240-nightly → 3.2.243-nightly

package/dist/index.d.ts

@@ -1,9 +1,19 @@
+import { CSSResult } from 'lit';
+import { LitElement } from 'lit';
+import { TemplateResult } from 'lit-html';
+
 export declare type ApiKeyConnectionConfig = {
     baseUrl: string;
     apiKey: string;
     ttl?: number;
 };
 
+declare type AuthTokenStoreData = {
+    apiKey: string;
+    authToken: string;
+    tokenExpiredIn: number;
+};
+
 declare class BaseConfigureError extends BaseError {
     private static readonly MODULE;
     private static readonly ERROR_ENUM_NAME;
@@ -16,6 +26,18 @@ declare class BaseConfigureError extends BaseError {
     });
 }
 
+declare class BaseConnectionError extends BaseError {
+    private static readonly MODULE;
+    private static readonly ERROR_ENUM_NAME;
+    private static readonly SHORT_CODE;
+    constructor({ errorCode, message, underlyingError, underlyingBaseError, }: {
+        errorCode: ConnectionError;
+        message?: string;
+        underlyingError?: string;
+        underlyingBaseError?: BaseError;
+    });
+}
+
 declare class BaseDeinitializationError extends BaseError {
     private static readonly MODULE;
     private static readonly ERROR_ENUM_NAME;
@@ -120,17 +142,49 @@ declare enum ConfigureError {
     SCENARIO_IN_PROGRESS = 3
 }
 
+declare type ConnectionByApiKeyConfigCore = {
+    host: string;
+    isSecure?: boolean;
+    port?: number;
+    apiKey: string;
+    authToken?: string;
+    deviceDescriptor: {
+        ttl: number;
+    };
+};
+
+declare type ConnectionConfigCore = {
+    host: string;
+    isSecure?: boolean;
+    password: string;
+    port?: number;
+    userName: string;
+};
+
 export declare enum ConnectionError {
     HTTP_ISSUE = 0,
     PROVIDER_ERROR = 1
 }
 
+declare type ContinueSessionResults = SessionData | WorkflowResult | {
+    error?: BaseWorkflowError;
+};
+
 export declare type CredentialConnectionConfig = {
     baseUrl: string;
     password: string;
     userName: string;
 };
 
+declare type CurrentScreenConfig = {
+    templateId: string;
+    templateLayout?: Record<string, unknown>;
+    dataSource: Record<string, unknown> | null;
+    properties?: SessionPropertiesItem[];
+    sessionId?: string;
+    serviceToken?: string;
+} & Record<string, any>;
+
 export declare enum DeinitializationError {
     INITIALIZATION_REQUIRED = 0,
     SCENARIO_IN_PROGRESS = 3
@@ -140,6 +194,53 @@ export declare type DeinitializeCompletion = {
     error?: BaseDeinitializationError;
 };
 
+declare type IdvBusinessLogicControllerProps = {
+    connectByUserPass: (config: ConnectionConfigCore) => Promise<{
+        error?: BaseConnectionError;
+    }>;
+    connectByApiKey: (config: ConnectionByApiKeyConfigCore) => Promise<{
+        error?: BaseTokenInitializationError;
+        workflows?: string[];
+        authToken?: string;
+    }>;
+    connectByUrl: (urlWithToken: string) => Promise<{
+        error?: BaseTokenInitializationError;
+        workflows: string[];
+    }>;
+    workflowSessionCompletion: (data: WorkflowCompletion) => void;
+    setWorkflowSessionCompletion: (fn: (data: WorkflowCompletion) => void) => void;
+    loadModules: (modulesFromProps: any[]) => Promise<{
+        error?: BaseInitializationError;
+    }>;
+    setProcessingTemplate: (workflowSteps: any[]) => void;
+    isProcessing: boolean;
+    setIsProcessing: (isProcessing: boolean) => void;
+    _pushStep: (stepId: string, data: Record<string, any>) => Promise<{
+        error?: BaseWorkflowError;
+    }>;
+    _waitingForNextStep: () => Promise<{
+        sessionData: SessionData;
+        error?: undefined;
+    } | {
+        error: BaseWorkflowError;
+        sessionData?: undefined;
+    }>;
+    _findStepById: (stepId: string) => WorkflowStep | null;
+    pushStepWaitNextStepAndSet: (data: Record<string, any>) => void;
+    setNextStep: (workflow: Workflow, properties: SessionPropertiesItem[], nextStepId: string) => void;
+    onChangeScreen: (stepId: string | null) => void;
+    deinitializationIdv: () => Promise<{
+        error?: any;
+    }>;
+    wasmService: IdvWasmService | null;
+    setAndInitWasmService: () => Promise<void>;
+    isFinalWaitingUi: boolean;
+    setFinalWaitingUi: (isWaitingUi: boolean) => void;
+    setFinalStepAndStopProcess: (stepId?: string) => void;
+    resetSession: () => void;
+    resetWasmService: () => void;
+};
+
 export declare type IdvEventTypes = (typeof IdvEventTypesEnum)[keyof typeof IdvEventTypesEnum];
 
 export declare const IdvEventTypesEnum: {
@@ -147,6 +248,48 @@ export declare const IdvEventTypesEnum: {
     readonly ERROR: "ERROR";
 };
 
+declare type IdvIntegrationControllerProps = {
+    _isInitialized: boolean;
+    _isConnectedToPlatform: boolean;
+    _initializationInProgress: boolean;
+    _sessionIdFromUrl: null | string;
+    _ttl: number;
+    _runWasmService: () => Promise<{
+        error?: BaseWorkflowError;
+    }>;
+    _continueSession: (locale: string, forceSessionId: string | null) => Promise<ContinueSessionResults>;
+    _checkIsSessionDataValid: (sessionData: SessionData | {
+        httpCode: number;
+        method: string;
+        url: string;
+        what?: string;
+    }) => SessionData | {
+        error?: BaseWorkflowError;
+    };
+    _checkAndSetApiTokenToLs: (sessionId: string) => void;
+    _runSocketConnection: (token: string) => Promise<{
+        error?: BaseWorkflowError;
+    }>;
+    _prepareDataForWorkflow: (sessionData: SessionData) => void;
+    initialize: (config: InitConfig) => Promise<{
+        error?: BaseInitializationError;
+    }>;
+    configureByUserPass: (config: CredentialConnectionConfig) => Promise<object | {
+        error?: BaseConfigureError;
+    }>;
+    configureWithUrl: (urlWithToken: string) => Promise<object | {
+        error?: BaseConfigureError;
+    }>;
+    configureByApiKey: (config: ApiKeyConnectionConfig) => Promise<object | {
+        error?: BaseConfigureError;
+    }>;
+    getWorkflows: (params?: WorkflowListRequest) => Promise<WorkflowListCompletion>;
+    prepareWorkflowAndPrepareUi: (workflowId: string) => Promise<PrepareWorkflowCompletion>;
+    startNewSession: (completion: (data: WorkflowCompletion) => void, locale: string, metadata?: Record<string, unknown>) => Promise<WorkflowCompletion>;
+    playWorkflow: () => void;
+    deinitialize: () => Promise<DeinitializeCompletion>;
+};
+
 export declare class IdvIntegrationService {
     /** main commands */
     initialize(config: InitConfig): Promise<{
@@ -196,15 +339,168 @@ export declare enum IdvServiceMessages {
     DID_CONTINUE_REMOTE_SESSION = "DID_CONTINUE_REMOTE_SESSION"
 }
 
-export declare class IdvWebComponent extends HTMLElement {
-    private _root;
-    private _mounted;
+declare type IdvStoreProps = {
+    sessionRestoreMode: boolean;
+    setSessionRestoreMode: (isEnabled: boolean) => void;
+    currentSessionData: {
+        sessionId: string;
+        workflowId: string;
+    } | null;
+    setCurrentSessionDataLsAndStore: (data: {
+        sessionId: string;
+        workflowId: string;
+    }) => void;
+    removeCurrentSessionDataLsAndStore: () => void;
+    getCurrentSessionDataLs: () => {
+        sessionId: string;
+        workflowId: string;
+        apiKey?: string;
+    } | null;
+    getCurrentSessionId: () => string | null;
+    modulesConfig: Record<string, any>;
+    layout: Record<string, any> | null;
+    sessionProperties: SessionPropertiesItem[];
+    setSessionProperties: (properties: SessionPropertiesItem[]) => void;
+    setLayout: (layout: Record<string, any>) => void;
+    workflow: Workflow | null;
+    setWorkflow: (workflow: Workflow) => void;
+    currentStepId: string | null;
+    setCurrentStepId: (stepId: string) => void;
+    listener: (message: IdvMessageEvent) => void | null;
+    setListener: (callback: (message: IdvMessageEvent) => void) => void;
+    workflowId: string | null;
+    setWorkflowId: (id: string) => void;
+    nonce?: string;
+    setNonce: (id: string) => void;
+    getNonce: () => string | undefined;
+    currentScreenConfig: CurrentScreenConfig | null;
+    externalModules: LoadedModule[] | [];
+    processingTransformedTemplate: WorkflowStepClientGui | null;
+    serviceToken?: string;
+    apiKeyAuthTokenCollection: AuthTokenStoreData | Record<string, unknown>;
+    setApiKeyAuthTokenCollection: (apiKey: string, authToken: string, tokenExpiredIn: number) => void;
+    setServiceSessionToken: (token: string) => void;
+    resetProps: () => void;
+    startConfig: StartConfig;
+    setStartConfig: (startConfig: StartConfig) => void;
+};
+
+declare class IdvWasmService {
+    _worker: Worker | null;
+    _initialized: boolean;
+    _connectedToIdv: boolean;
+    _serviceRunning: boolean;
+    private _setErrorScreen;
+    constructor(setErrorScreen?: ({ type, details }: {
+        type: string;
+        details: string;
+    }) => void);
+    init(): Promise<any>;
+    connectByUserPass(config: ConnectionConfigCore): Promise<{
+        data: Record<string, any>;
+        code: number;
+        codeKey: string;
+    }>;
+    connectByApiKey(config: ConnectionByApiKeyConfigCore): Promise<any>;
+    connectByUrl(urlWithToken: string): Promise<any>;
+    startSession(id: string, locale: string, metadata?: Record<string, unknown>): Promise<{
+        data: SessionData | {
+            httpCode: number;
+            method: string;
+            url: string;
+            what?: string;
+        };
+        code: number;
+        codeKey: string;
+    }>;
+    continueSession(sessionId: string, locale: string): Promise<{
+        data: SessionData | {
+            httpCode: number;
+            method: string;
+            url: string;
+            what?: string;
+        };
+        code: number;
+        codeKey: string;
+    }>;
+    listWorkflows(params?: {
+        limit: number;
+        skip: number;
+    }): Promise<{
+        data: {
+            count: number;
+            items: Workflow[];
+        };
+        code: number;
+        codeKey: string;
+    }>;
+    getHealth(): Promise<{
+        data: Record<string, any>;
+        code: number;
+        codeKey: string;
+    }>;
+    getServiceToken(): Promise<{
+        data: string;
+        code: number;
+        codeKey: string;
+    }>;
+    abandonSession(): Promise<{
+        data: Record<string, any>;
+        code: number;
+        codeKey: string;
+    }>;
+    getWorkflow(workflowId: string): Promise<{
+        data: Workflow;
+        code: number;
+        codeKey: string;
+    }>;
+    pushData(stepId: string, data: any): Promise<{
+        data: Record<string, any>;
+        code: number;
+        codeKey: string;
+    }>;
+    getSessionState(): Promise<{
+        data: SessionData;
+        code: number;
+        codeKey: string;
+    }>;
+    waitForSessionUpdate(): Promise<{
+        data: Record<string, any>;
+        code: number;
+        codeKey: string;
+    }>;
+    pushSessionLogs(pushSessionLogsParams: PushSessionLogsParams): Promise<any>;
+    disconnect(): Promise<{
+        code: number;
+        codeKey: string;
+    }>;
+    private sendMessage;
+    isServiceRunning(): boolean;
+    isServiceConnected(): boolean;
+    private terminateWorker;
+    shutdown(): Promise<{
+        code: number;
+    }>;
+}
+
+export declare class IdvWebComponent extends LitElement {
+    static styles: CSSResult[];
+    private orientation;
+    store: IdvStoreProps & IdvIntegrationControllerProps & IdvBusinessLogicControllerProps;
+    currentScreenConfig: CurrentScreenConfig | null;
+    processingScreenFromWorkflow: WorkflowStepClientGui | null;
+    isProcessing: boolean;
+    loadedModules: [] | LoadedModule[];
+    modulesConfig: Record<string, any>;
     constructor();
-    static get observedAttributes(): Array<string>;
-    connectedCallback(): void;
+    _listenerFromModule: (module: string, data: any) => void;
+    _isProcessingCallback: (isProcessing: boolean) => void;
+    _performFromModule: (data: any) => void;
+    _processingScreen(): HTMLElement | TemplateResult<1>;
+    _currentScreen(): HTMLElement | null;
     get version(): string;
-    private render;
     disconnectedCallback(): void;
+    render(): TemplateResult<1> | null;
 }
 
 export declare type InitConfig = {
@@ -227,6 +523,12 @@ export declare enum InitializeError {
     INITIALIZATION_IN_PROGRESS = 2
 }
 
+declare type LoadedModule = {
+    id: string;
+    supportedTemplates: string[];
+    component: any;
+};
+
 export declare type ModuleClass<TModuleProps = unknown, TModulesConfig = unknown> = IdvModuleStaticMethods & (new (...args: any[]) => BaseModule<TModuleProps, TModulesConfig>);
 
 export declare type PrepareWorkflowCompletion = {
@@ -242,8 +544,25 @@ export declare enum PrepareWorkflowError {
     SCENARIO_IN_PROGRESS = 4
 }
 
+declare type PushSessionLogsParams = {
+    sessionId: string;
+    body: {
+        log: string;
+        errorCode?: string;
+        deviceInfo?: Record<string, string>;
+    };
+};
+
 export declare function registerModule<TModuleProps = unknown, TModulesConfig = unknown>(name: string, ModuleClass: ModuleClass<TModuleProps, TModulesConfig>): void;
 
+declare type SessionData = {
+    id: string;
+    currentStep: string;
+    workflow: Workflow;
+    properties: SessionPropertiesItem[];
+    isProcessingFiles: boolean;
+};
+
 export declare enum SessionError {
     HTTP_ISSUE = 0,
     PROVIDER_ERROR = 1,
@@ -253,6 +572,31 @@ export declare enum SessionError {
     NOT_DATA_TYPE = 5
 }
 
+/** sync with gui module */
+declare type SessionPropertiesItem = {
+    id: string;
+    createdAt: string;
+    updatedAt: string;
+    createdBy: unknown;
+    updatedBy: unknown;
+    action: unknown;
+    step: string;
+    name: string;
+    path: unknown;
+    string: string;
+    array?: string[];
+    integer: unknown;
+    decimal: unknown;
+    object: unknown;
+};
+
+declare type StartConfig = {
+    host?: string;
+    isSecure?: boolean;
+    apiKey?: string;
+    port?: number;
+};
+
 export declare enum StartSessionError {
     HTTP_ISSUE = 0,
     PROVIDER_ERROR = 1,