@regulaforensics/idv-capture-web 0.1.217-nightly → 0.1.248-nightly

package/dist/index.d.ts

@@ -1,3 +1,43 @@
+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;
+    tokenExpiresAt: number;
+};
+
+declare class BaseConfigureError extends BaseError {
+    private static readonly MODULE;
+    private static readonly ERROR_ENUM_NAME;
+    private static readonly SHORT_CODE;
+    constructor({ errorCode, message, underlyingError, underlyingBaseError, }: {
+        errorCode: ConfigureError;
+        message?: string;
+        underlyingError?: string;
+        underlyingBaseError?: 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;
@@ -10,7 +50,7 @@ declare class BaseDeinitializationError extends BaseError {
     });
 }
 
-declare class BaseError {
+export declare class BaseError {
     errorCode: number | string;
     errorCodeKey: string;
     message?: string;
@@ -50,6 +90,11 @@ declare class BaseInitializationError extends BaseError {
     });
 }
 
+export declare abstract class BaseModule<TModuleProps = unknown, TModulesConfig = unknown> extends HTMLElement {
+    abstract props: IdvModuleProps<TModuleProps, TModulesConfig> | null;
+    abstract setProps(config: IdvModuleProps<TModuleProps, TModulesConfig>): void;
+}
+
 declare class BasePrepareWorkflowError extends BaseError {
     private static readonly MODULE;
     private static readonly ERROR_ENUM_NAME;
@@ -62,24 +107,24 @@ declare class BasePrepareWorkflowError extends BaseError {
     });
 }
 
-declare class BaseScenarioError extends BaseError {
+declare class BaseTokenInitializationError extends BaseError {
     private static readonly MODULE;
     private static readonly ERROR_ENUM_NAME;
     private static readonly SHORT_CODE;
     constructor({ errorCode, message, underlyingError, underlyingBaseError, }: {
-        errorCode: ScenarioError;
+        errorCode: TokenInitializeError;
         message?: string;
         underlyingError?: string;
         underlyingBaseError?: BaseError;
     });
 }
 
-declare class BaseTokenInitializationError extends BaseError {
+declare class BaseWorkflowError extends BaseError {
     private static readonly MODULE;
     private static readonly ERROR_ENUM_NAME;
     private static readonly SHORT_CODE;
     constructor({ errorCode, message, underlyingError, underlyingBaseError, }: {
-        errorCode: TokenInitializeError;
+        errorCode: WorkflowError;
         message?: string;
         underlyingError?: string;
         underlyingBaseError?: BaseError;
@@ -87,31 +132,34 @@ declare class BaseTokenInitializationError extends BaseError {
 }
 
 export declare type ConfigureCompletion = {
-    error?: BaseInitializationError;
+    error?: BaseConfigureError;
 };
 
-export declare type ConnectionByApiKeyConfig = {
+declare enum ConfigureError {
+    CONNECTION_ISSUE = 0,
+    CONFIG_MISSED_OR_INVALID = 1,
+    INITIALIZATION_REQUIRED = 2,
+    SCENARIO_IN_PROGRESS = 3
+}
+
+declare type ConnectionByApiKeyConfigCore = {
     host: string;
-    apiKey: string;
     isSecure?: boolean;
     port?: number;
-    deviceDescriptor?: Record<string, unknown>;
-    httpRetryCount?: number;
-    httpTimeoutMs?: number;
+    apiKey: string;
+    authToken?: string;
+    tokenExpiresAt?: number;
+    deviceDescriptor: {
+        ttl: number;
+    };
 };
 
-export declare type ConnectionConfig = {
+declare type ConnectionConfigCore = {
     host: string;
-    httpRetryCount?: number;
-    httpTimeoutMs?: number;
     isSecure?: boolean;
     password: string;
     port?: number;
-    schema?: string;
     userName: string;
-    deviceDescriptor?: {
-        ttl?: number;
-    } & Record<string, unknown>;
 };
 
 export declare enum ConnectionError {
@@ -119,6 +167,25 @@ export declare enum ConnectionError {
     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
@@ -128,6 +195,72 @@ export declare type DeinitializeCompletion = {
     error?: BaseDeinitializationError;
 };
 
+declare type FetchErrorResult = {
+    code: FetchResultCode.HTTP_ISSUE | FetchResultCode.PROVIDER_ERROR | FetchResultCode.DECODING_FAILED;
+    data: FetchState;
+};
+
+declare enum FetchResultCode {
+    SUCCESS = 0,
+    HTTP_ISSUE = 4,
+    PROVIDER_ERROR = 5,
+    DECODING_FAILED = 6
+}
+
+declare type FetchState = {
+    httpCode: number;
+    method: string;
+    url: string;
+    what?: string;
+};
+
+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;
+    }>;
+    fetchService: IdvFetchService | null;
+    setAndInitFetchService: () => Promise<void>;
+    isFinalWaitingUi: boolean;
+    setFinalWaitingUi: (isWaitingUi: boolean) => void;
+    setFinalStepAndStopProcess: (stepId?: string) => void;
+    resetSession: () => void;
+    resetFetchService: () => void;
+};
+
 export declare type IdvEventTypes = (typeof IdvEventTypesEnum)[keyof typeof IdvEventTypesEnum];
 
 export declare const IdvEventTypesEnum: {
@@ -135,12 +268,148 @@ export declare const IdvEventTypesEnum: {
     readonly ERROR: "ERROR";
 };
 
+declare class IdvFetchService {
+    private _connectionTokenExpirationBufferMs;
+    private _origin;
+    private _locale;
+    private _workflowId;
+    private _session;
+    private _apiKeyAuthToken;
+    private _connectionToken;
+    private _connect;
+    private _getErrorTextFromError;
+    private _setApiKeyAuthToken;
+    private _setConnectionToken;
+    private _getOriginFromConfig;
+    private _getOriginFromUrl;
+    private _getExpiresAtFromTtl;
+    private _getAuthorizationHeaderFromConnectionToken;
+    private _getAuthorizationHeaderFromBasicToken;
+    private _getAuthorizationHeaderFromAuthToken;
+    private _getApiKeyAuthTokenFromLs;
+    private _getApiKeyAuthTokenFromHeader;
+    _getValidApiKeyAuthToken(config: {
+        apiKey: string;
+        deviceDescriptor: {
+            ttl: number;
+        };
+    }, isFromSession: boolean): Promise<{
+        code: FetchResultCode.SUCCESS;
+        data: {
+            token: string;
+            expiresAt: number;
+        };
+    } | FetchErrorResult>;
+    private _getAuthorizationSearchParam;
+    private _getResponseTextFromBadResponse;
+    private _fetchPing;
+    private _fetchMe;
+    private _fetchConnection;
+    private _fetchEphemeral;
+    private _fetchSessionByWorkflowId;
+    private _fetchSessionState;
+    private _fetchWorkflows;
+    private _fetchWorkflow;
+    private _fetchStep;
+    private _fetchSessionLogs;
+    connectByUserPass(config: ConnectionConfigCore): Promise<{
+        code: FetchResultCode.SUCCESS;
+        data: {
+            workflows: string[];
+        };
+    } | FetchErrorResult>;
+    connectByApiKey(config: ConnectionByApiKeyConfigCore, isFromSession: boolean): Promise<{
+        code: FetchResultCode.SUCCESS;
+        data: {
+            authToken: string;
+            workflows: string[];
+        };
+    } | FetchErrorResult>;
+    connectByUrl(urlWithToken: string): Promise<{
+        code: FetchResultCode.SUCCESS;
+        data: {
+            workflows: string[];
+        };
+    } | FetchErrorResult>;
+    getConnectionToken(isFromSession: boolean): Promise<string>;
+    startSession(id: string, locale: string, metadata?: Record<string, unknown>): Promise<{
+        code: FetchResultCode.SUCCESS;
+        data: SessionData;
+    } | FetchErrorResult>;
+    continueSession(sessionId: string, locale: string): Promise<{
+        code: FetchResultCode.SUCCESS;
+        data: SessionData;
+    } | FetchErrorResult>;
+    listWorkflows(params?: {
+        limit: number;
+        skip: number;
+    }): Promise<{
+        code: FetchResultCode.SUCCESS;
+        data: {
+            count: number;
+            items: Workflow[];
+        };
+    } | FetchErrorResult>;
+    getWorkflow(workflowId: string): Promise<{
+        code: FetchResultCode.SUCCESS;
+        data: Workflow;
+    } | FetchErrorResult>;
+    pushData(stepId: string, data: any): Promise<{
+        code: FetchResultCode.SUCCESS;
+        data: SessionData;
+    } | FetchErrorResult>;
+    getSessionState(): Promise<{
+        code: FetchResultCode.SUCCESS;
+        data: SessionData;
+    } | FetchErrorResult>;
+    pushSessionLogs(pushSessionLogsParams: PushSessionLogsParams): Promise<Record<string, unknown>>;
+}
+
+declare type IdvIntegrationControllerProps = {
+    _isInitialized: boolean;
+    _isConnectedToPlatform: boolean;
+    _initializationInProgress: boolean;
+    _sessionIdFromUrl: null | string;
+    _ttl: number;
+    _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<{
         error?: BaseInitializationError;
     }>;
-    configure(config: ConnectionConfig | UrlConnectionConfig | ConnectionByApiKeyConfig): Promise<ConfigureCompletion | UrlConfigureCompletion>;
+    configure(config: CredentialConnectionConfig | TokenConnectionConfig | ApiKeyConnectionConfig): Promise<ConfigureCompletion | TokenConfigureCompletion>;
     getWorkFlows(params?: WorkflowListRequest): Promise<WorkflowListCompletion>;
     prepareWorkflow({ workflowId }: {
         workflowId: string;
@@ -160,12 +429,22 @@ export declare type IdvMessageEvent = {
     message?: IdvServiceMessages;
 };
 
-export declare const IdvModules: {
-    readonly LIVENESS: "LIVENESS";
-    readonly DOC_READER: "DOC_READER";
+export declare type IdvModuleProps<TModuleProps, TModulesConfig> = {
+    isProcessing?: (isProcessing: boolean) => void;
+    moduleProps: TModuleProps;
+    modulesConfig?: TModulesConfig;
+    perform: (data: any) => void;
+    idvEventListener: (module: string, data: any) => void;
 };
 
-export declare type IdvModulesType = (typeof IdvModules)[keyof typeof IdvModules];
+export declare interface IdvModuleStaticMethods {
+    displayName: string;
+    isReady(): boolean;
+    getSupportedTemplates(): string[];
+    initialize(modulesConfig: Record<string, unknown>): void;
+    deinitialize(): void;
+    getIdentifier(): string;
+}
 
 export declare enum IdvServiceMessages {
     DID_START_SESSION = "DID_START_SESSION",
@@ -174,15 +453,70 @@ 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, tokenExpiresAt: number) => void;
+    setServiceSessionToken: (token: string) => void;
+    resetProps: () => void;
+    startConfig: StartConfig;
+    setStartConfig: (startConfig: StartConfig) => void;
+};
+
+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 = {
@@ -205,6 +539,14 @@ 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 = {
     workflow?: Workflow;
     error?: BasePrepareWorkflowError;
@@ -218,24 +560,23 @@ export declare enum PrepareWorkflowError {
     SCENARIO_IN_PROGRESS = 4
 }
 
-export declare enum ScenarioError {
-    INITIALIZATION_REQUIRED = 0,
-    PREPARED_REQUIRED = 1,
-    START_SESSION_FAILED = 2,
-    UNKNOWN_STEP = 3,
-    MODULES_ISSUE = 4,
-    ALREADY_STARTED = 5,
-    INTERNAL_ISSUE = 6
-}
-
-declare type ScenarioResults = {
-    sessionId?: string;
-    finalStep?: {
-        id: string;
-        name: string;
-        final: boolean;
+declare type PushSessionLogsParams = {
+    body: {
+        log: string;
+        errorCode?: string;
+        deviceInfo?: Record<string, string>;
     };
-} & Record<string, any>;
+};
+
+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,
@@ -246,6 +587,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,
@@ -259,20 +625,20 @@ export declare type StartWorkflowConfig = {
     locale?: string;
 };
 
-declare enum TokenInitializeError {
-    CONNECTION_ISSUE = 0,
-    WORKFLOW_ISSUE = 1
-}
-
-export declare type UrlConfigureCompletion = {
+export declare type TokenConfigureCompletion = {
     workflows: string[];
     error?: BaseTokenInitializationError;
 };
 
-export declare type UrlConnectionConfig = {
+export declare type TokenConnectionConfig = {
     url: string;
 };
 
+declare enum TokenInitializeError {
+    CONNECTION_ISSUE = 0,
+    WORKFLOW_ISSUE = 1
+}
+
 declare type Workflow = {
     id: string;
     steps: Array<WorkflowStep>;
@@ -283,14 +649,18 @@ declare type Workflow = {
 } & Record<string, any>;
 
 export declare type WorkflowCompletion = {
-    results?: ScenarioResults;
-    error?: BaseScenarioError;
+    results?: WorkflowResult;
+    error?: BaseWorkflowError;
 };
 
 export declare enum WorkflowError {
-    HTTP_ISSUE = 0,
-    PROVIDER_ERROR = 1,
-    DECODING_FAILED = 2
+    INITIALIZATION_REQUIRED = 0,
+    PREPARED_REQUIRED = 1,
+    START_SESSION_FAILED = 2,
+    UNKNOWN_STEP = 3,
+    MODULES_ISSUE = 4,
+    ALREADY_STARTED = 5,
+    INTERNAL_ISSUE = 6
 }
 
 export declare type WorkflowListCompletion = {
@@ -303,6 +673,21 @@ export declare type WorkflowListRequest = {
     skip: number;
 };
 
+export declare enum WorkflowPlatformError {
+    HTTP_ISSUE = 0,
+    PROVIDER_ERROR = 1,
+    DECODING_FAILED = 2
+}
+
+declare type WorkflowResult = {
+    sessionId?: string;
+    finalStep?: {
+        id: string;
+        name: string;
+        final: boolean;
+    };
+} & Record<string, any>;
+
 declare type WorkflowStep = {
     id: string;
     name: string;