@os1-platform/dispatch-mobile 1.0.8 → 2.0.0

package/lib/typescript/manager/dispatch/DispatchStateContainer.d.ts

@@ -1,41 +1,62 @@
-import type { Job, state } from 'mobile-execution-lib';
+import { IDispatchExecutor, IDispatch } from '@os1-platform/platform-coreos-execution-engine-sdk';
+import { ExecutionTaskID } from '../../models/execTasks/ETConfig';
 import type { ETSummary } from '../../models/execTasks/ETBaseModels';
-import type { BaseETProps, JobObjectiveType, stateWithObjRef } from '../../models/DispatchModels';
+import DispatchSdkCache from '../sdk/DispatchSdkCache';
+import type { BaseETProps, JobObjectiveType, stateParams } from '../../models/DispatchModels';
 export default class DispatchStateContainer {
+    cacheKeys: {
+        SDK_CONFIG: string;
+        DISPATCH_ID: string;
+        FMS_FOLDER: string;
+        FIREBASE_REGISTRATION_TOKEN: string;
+        REASON_FETCH_TIME: string;
+        CURRENT_WORKING_TASK_ID: string;
+    };
+    cache: DispatchSdkCache;
     get stateKeys(): string[];
     set stateKeys(value: string[]);
-    get mappedStates(): Map<string, stateWithObjRef[]>;
-    set mappedStates(value: Map<string, stateWithObjRef[]>);
+    get mappedStates(): Map<string, IDispatch.IExecutionTaskQueryResponse>;
+    set mappedStates(value: Map<string, IDispatch.IExecutionTaskQueryResponse>);
     private static instance;
-    private dispatchExecutor;
     private successRoute;
     private failureRoute;
     private _stateKeys;
     _jobObjectives: JobObjectiveType[] | null;
     private _mappedStates;
+    private _mappedStatesData;
     /**
      * Call this function when dispatch data is fetched successfully in client app
      * @param dispatchID
      * @param jobs
-     * @param logging
+     * @param dispatchWorkflows
      * @param maxTaskReattempt
      */
-    initDispatchExecutor(dispatchID: string, jobs: Job[], logging: boolean, maxTaskReattempt?: number): Promise<void>;
-    bulkQueryNextET(jobObjectiveList: JobObjectiveType[]): Promise<stateWithObjRef[] | null>;
-    queryNextTask(jobObjectiveList: JobObjectiveType[]): Promise<state[] | null>;
-    queryObjective(objRef: string, jobID: string): Promise<state>;
-    sendETOutput(etOutput: any, etState: stateWithObjRef[]): Promise<void>;
-    saveETOutput(jobId: string, objRef: string, etState: state): Promise<void>;
+    initDispatchExecutor(dispatchID: string, jobs: IDispatchExecutor.Job[], dispatchWorkflows: {
+        [id: string]: IDispatchExecutor.Workflow;
+    }, maxTaskReattempt?: number): Promise<void>;
+    /**
+     *
+     * @param mergedObjectiveId
+     * @returns IExecutionTaskQueryResponse {
+     *    mergedObjectiveId: string;
+     *    taskName: string;
+     *    taskId: string;
+     *    input: any;
+     * }
+     */
+    queryNextET(mergedObjectiveId: Array<string>, statusFilter: IDispatchExecutor.ExecutionStatus[]): Promise<IDispatch.IExecutionTaskQueryResponse[]>;
+    private updateScanETOutputSharedPreference;
+    private updatePendingSharedPreference;
+    sendETOutput(etOutput: any, states: any, isMergedObjectiveBasedOutput?: boolean): Promise<void>;
+    private findPrefixKey;
     static getInstance(): DispatchStateContainer;
-    fetchObjectiveState(objRef: string, jobID: string): string;
     setSuccessRoute(route: string): void;
     getSuccessRoute(): string | null;
     setFailureRoute(route: string): void;
     getFailureRoute(): string | null;
     getObjectiveSummary(jobObjective: JobObjectiveType): Promise<ETSummary[]>;
-    navigateToNextTask(navigation: any, route: any, etOutput: any, etSuccess: boolean, entityCode: string, eTaskID: string, baseETProps: BaseETProps, isLastTask?: boolean): Promise<void>;
-    private getJobObjectiveList;
-    moveToNextET(baseETProps: BaseETProps, etStates: stateWithObjRef[], navigation: any, isLastTask?: boolean): Promise<void>;
+    navigateToNextTask(navigation: any, route: any, etOutput: any, etSuccess: boolean, entityCode: string, eTaskID: ExecutionTaskID, baseETProps: BaseETProps, isLastTask?: boolean, isMergeObjectiveBasedOutput?: boolean): Promise<void>;
+    moveToNextET(etOutput: any, baseETProps: BaseETProps, states: stateParams, navigation: any, isLastTask?: boolean): Promise<void>;
     private saveAndProceedToNextET;
-    saveAndProceed(baseETProps: BaseETProps, etOutput: any, etStates: stateWithObjRef[], navigation: any, isLastTask?: boolean): Promise<void>;
+    saveAndProceed(baseETProps: BaseETProps, etOutput: any, states: stateParams, navigation: any, isLastTask?: boolean, isMergedObjectiveBasedOutput?: boolean): Promise<void>;
 }

package/lib/typescript/manager/dispatchCodes/EventCodeContainer.d.ts

@@ -1 +1,12 @@
-export declare function getEventCodeByET(_etName: string, success: boolean): string;
+import type { EventsRow } from '../syncmanager/DBConfig';
+export declare function getEventCodeByET(_etName: string, success: boolean, events?: {
+    [k: string]: string[];
+} | string[]): string;
+export default class EventCodeContainer {
+    private static instance;
+    private constructor();
+    static getInstance(): EventCodeContainer;
+    getEventCodes(applicableCodes: object): Promise<EventsRow[]>;
+    static getEventCodeFromText(eventText: string, events: EventsRow[]): string;
+    getEventByCode(code: string): Promise<EventsRow | null>;
+}

package/lib/typescript/manager/dispatchCodes/EventCodeRepo.d.ts

@@ -0,0 +1,13 @@
+import { EventsRow } from '../syncmanager/DBConfig';
+import type { EventCodes } from '../../models/ReasonCodes';
+export default class EventCodeRepo {
+    private static instance;
+    static getInstance(): EventCodeRepo;
+    saveEventCode(eventsList: EventCodes[]): Promise<void>;
+    private insertEvent;
+    private init;
+    getAllEventCodes(): Promise<EventsRow[]>;
+    deleteAll(): Promise<import("expo-sqlite").SQLResultSet>;
+    getEventsByCode(codes: string[]): Promise<EventsRow[]>;
+    getEventByCode(code: string): Promise<EventsRow[]>;
+}

package/lib/typescript/manager/sdk/DispatchSdkCache.d.ts

@@ -8,6 +8,7 @@ export default class DispatchSdkCache {
         FMS_FOLDER: string;
         FIREBASE_REGISTRATION_TOKEN: string;
         REASON_FETCH_TIME: string;
+        CURRENT_WORKING_TASK_ID: string;
     };
     setObjectInCache(keyName: string, obj: any): Promise<void>;
     getObjectFromCache(keyName: string): Promise<any>;

package/lib/typescript/manager/sdk/callbacksHandler.d.ts

@@ -0,0 +1,13 @@
+declare class CallbacksHandler {
+    private _callbackToFetchPhoneNumbers;
+    init(phoneCallback: (sdsIds: string[]) => Promise<{
+        key: string;
+        value: string[];
+    }>): void;
+    getPhoneNumbers(sdsIds: string[]): Promise<{
+        key: string;
+        value: string[];
+    } | null>;
+}
+declare const callbackHandler: CallbacksHandler;
+export default callbackHandler;

package/lib/typescript/manager/syncmanager/AppSyncManager.d.ts

@@ -1,9 +1,10 @@
 import type { SdkSyncType } from '../../models/DispatchModels';
-import type { DocumentRow, EventRow } from './DBConfig';
+import type { BulkEvent, DocumentRow, EventRow } from './DBConfig';
 export default class AppSyncManager {
     private constructor();
     private static instance;
     isSyncActive: boolean;
+    isForceStartEnabled: boolean;
     /**
      *
      * @param forceSync - true/false - if true resets the retry count key and start the sync
@@ -21,4 +22,5 @@ export default class AppSyncManager {
     getAllEvents(dispatchID?: string): Promise<EventRow[]>;
     getAllDocuments(dispatchID?: string): Promise<DocumentRow[]>;
     startSDKSyncManager(): void;
+    pushToQueue(pushData: BulkEvent): Promise<boolean>;
 }

package/lib/typescript/manager/syncmanager/DBConfig.d.ts

@@ -1,6 +1,13 @@
+import { IDispatch } from '@os1-platform/platform-coreos-execution-engine-sdk';
+export type ExecEngineSyncType = IDispatch.SyncType;
+export declare enum DispatchSyncType {
+    DEFAULT = "DEFAULT",
+    DISPATCH_UPDATE = "DISPATCH_UPDATE"
+}
 export declare const DATABASE_NAME = "DISPATCH_DB";
 export declare const EVENTS_TABLE = "EVENTS_TABLE";
 export declare const REASONS_TABLE = "REASONS_TABLE";
+export declare const EVENT_CODES_TABLE = "EVENT_CODES_TABLE";
 export declare const EVENTS_COLUMNS: {
     ID: string;
     SEQUENCE: string;
@@ -8,9 +15,10 @@ export declare const EVENTS_COLUMNS: {
     SYNCED: string;
     CONFIG: string;
     SYNC_TYPE: string;
-    OBJECTIVE_REF: string;
+    META: string;
     SYNC_ERROR: string;
     DISPATCH_ID: string;
+    DATA_LENGTH: string;
 };
 export declare const DOCUMENT_TABLE = "DOCUMENTS_TABLE";
 export declare const DOCUMENT_COLUMNS: {
@@ -30,7 +38,7 @@ export declare const DOCUMENT_COLUMNS: {
     JOB_ID: string;
     OBJECTIVE_REF: string;
 };
-export declare type DocumentRow = {
+export type DocumentRow = {
     id: number;
     data: string;
     base64: boolean;
@@ -47,12 +55,12 @@ export declare type DocumentRow = {
     job_id: string;
     objective_ref: string;
 };
-export declare type EventRow = {
+export type EventRow = {
     id: number;
     payload: string;
     synced: boolean;
     config: string;
-    sync_type: string;
+    sync_type: ExecEngineSyncType | DispatchSyncType;
     objective_ref: string;
     sync_error: string;
     dispatch_id: string;
@@ -75,3 +83,71 @@ export interface ReasonsRow {
     reasonCode: string;
     isSystemDefined: boolean;
 }
+export interface EventsRow {
+    description: string;
+    successEvent: boolean;
+    eventCode: string;
+}
+export declare const EventColumns: {
+    CODE: string;
+    DESCRIPTION: string;
+    SUCCESS_EVENT: string;
+};
+export interface BulkEvent {
+    syncType: ExecEngineSyncType | DispatchSyncType;
+    dispatchId: string;
+    data: any;
+    meta?: any;
+}
+export interface WFUpdateBulkEventData {
+    [customETName: string]: EventETData;
+}
+export interface EventETData {
+    output: any;
+}
+export interface WIUpdateOutputPayload {
+    dispatchId: string;
+    updatedBy: any;
+    workflows: Array<WorkflowUpdatePayload>;
+}
+export interface WorkflowUpdatePayload {
+    status: string;
+    timestamp: number;
+    attemptId: 1;
+    code: string;
+    data: any;
+    meta?: any;
+    __unmerged?: Array<UnmergedData>;
+}
+export interface UnmergedData {
+    workflowInstanceId: string;
+    jobId: string;
+    data?: any;
+}
+export interface CustodyData {
+    dispatchId: string;
+    jobId: string;
+    custodyEntity: string;
+    custodyLocationId: string;
+    custodyEntityAmount: number;
+    custodyEntityId: string;
+}
+export declare const WORKFLOW_INSTANCE_TABLE = "WF_INSTANCE_TABLE";
+export declare const WORKFLOW_INSTANCE_COLUMNS: {
+    WORKFLOW_INSTANCE_ID: string;
+    MERGED_WORKFLOW_INSTANCE_ID: string;
+    JOB_ID: string;
+    SCANNABLE_ID: string;
+    INITIAL_MERGED_WORKFLOW_INSTANCE_ID: string;
+    STATUS: string;
+    JOB_WF_ID: string;
+    DISPLAY_DATA: string;
+    WORKFLOW_ID: string;
+};
+export interface SyncManagerPayload {
+    data: {
+        action: ExecEngineSyncType | DispatchSyncType;
+        payload: any;
+    };
+    length: number;
+}

package/lib/typescript/manager/syncmanager/constants.d.ts

@@ -0,0 +1,5 @@
+export declare const BULK_DATA_LIMIT = 1000;
+export declare const LAST_SYNCED_EVENT_ID = "lastSyncedEventId";
+export declare const SHARED_PREFERENCE_DISPATCH_ID = "sharedPreferenceDispatchId";
+export declare const SHARED_PREFERENCE_SCAN_OUTPUT = "scanETMappedOutput";
+export declare const SCAN_MERGED_OBJ_ID_OUTPUT = "scanMergedObjectiveIDs";

package/lib/typescript/manager/syncmanager/database.d.ts

@@ -1,2 +1,7 @@
 import type { SQLResultSet } from 'expo-sqlite';
+export interface ExecQuery {
+    query: string;
+    args: any[];
+}
 export declare function executeQuery(query: string, args: any[]): Promise<SQLResultSet>;
+export declare function executeBulkQuery(_queryData: ExecQuery[]): Promise<boolean>;

package/lib/typescript/manager/syncmanager/document/DocumentManager.d.ts

@@ -5,7 +5,7 @@ export default class DocumentManager {
     private constructor();
     static getInstance(): Promise<DocumentManager>;
     init(): Promise<void>;
-    insertDocument(fmsFolderID: string | null, desc: string, dspID: string, jobID: string, objectiveRef: string, base64: boolean, fileName: string, fileType: string, data?: string | null, filePath?: string | null, priority?: number): Promise<SQLResultSet>;
+    insertDocument(fmsFolderID: string | null, desc: string, dspID: string, base64: boolean, fileName: string, fileType: string, data?: string | null, filePath?: string | null, priority?: number): Promise<SQLResultSet>;
     getAllDocuments(dispatchID?: string): Promise<DocumentRow[]>;
     getAllUnsyncedDocs(): Promise<DocumentRow[]>;
     deleteAllSyncedDocuments(dispatchID: string): Promise<SQLResultSet>;

package/lib/typescript/manager/syncmanager/document/DocumentSyncManager.d.ts

@@ -14,7 +14,7 @@ export default class DocumentSyncManager {
     static getInstance(): DocumentSyncManager;
     startDocumentSync(): Promise<void>;
     isSyncPending(): Promise<boolean>;
-    insertDocument(fmsFolderID: string | null, data: string | null, base64: boolean, desc: string, dspID: string, jobID: string, objRef: string, filePath: string | null, fileType: string, fileName: string, priority?: number): Promise<SQLResultSet>;
+    insertDocument(fmsFolderID: string | null, data: string | null, base64: boolean, desc: string, dspID: string, filePath: string | null, fileType: string, fileName: string, priority?: number): Promise<SQLResultSet>;
     forceDocumentSync(): Promise<void>;
     private updateDocument;
     private updateDocError;

package/lib/typescript/manager/syncmanager/document/models.d.ts

@@ -1,4 +1,4 @@
-export declare type FILE_TAGS = {
+export type FILE_TAGS = {
     key: string;
     value: string;
 };

package/lib/typescript/manager/syncmanager/events/ETEventsManager.d.ts

@@ -1,16 +1,29 @@
-import { EventRow } from '../DBConfig';
+import { BulkEvent, EventRow } from '../DBConfig';
 export default class ETEventsManager {
     private static instance;
+    private maxRetryCount;
+    private _retries;
     private constructor();
     static getInstance(): Promise<ETEventsManager>;
     private static init;
     insertEvent(sequence: number, payload: string, dspID: string, syncType: string, objectiveRef: string, config?: string): Promise<void>;
+    private getWFIPayload;
+    private getCustodyPayload;
+    private getJobRemovalPayload;
+    private getDispatchUpdatePayload;
+    private _modifyEventData;
+    private splitData;
+    insertQueueEvent(_eventData: BulkEvent): Promise<void>;
+    insertBulkEvent(_eventData: BulkEvent): Promise<void>;
     getAllEvents(dispatchID?: string): Promise<EventRow[]>;
     getAllUnsyncedEvents(): Promise<EventRow[]>;
-    deleteAllEvents(): Promise<import("expo-sqlite").SQLResultSet>;
+    deleteAllEvents(): Promise<boolean>;
     updateError(id: number, syncError: string): Promise<void>;
     markEventSynced(id: number): Promise<void>;
     getWorkflowUpdateEvents(syncType: string): Promise<EventRow[]>;
+    getJobRemovalEvents(syncType: string): Promise<EventRow[]>;
     getCustodyBatch(dispatchID: string): Promise<EventRow[]>;
     getObjectiveDetails(objectiveRef: string): Promise<EventRow[]>;
+    getRowToSync(id: string, dispatchId: string): Promise<EventRow[]>;
+    getBulkRowsToSync(id: string, dispatchId: string): Promise<EventRow[]>;
 }

package/lib/typescript/manager/syncmanager/events/EventsSyncManager.d.ts

@@ -1,4 +1,4 @@
-import type { EventRow } from '../DBConfig';
+import type { BulkEvent, EventRow } from '../DBConfig';
 export default class EventsSyncManager {
     private syncHttpClient;
     private static instance;
@@ -13,7 +13,6 @@ export default class EventsSyncManager {
     initSyncManager(baseURL: string, retryCount: number): void;
     static getInstance(): EventsSyncManager;
     startSync(): Promise<void>;
-    startCustodyScans(custodyScans: EventRow[]): Promise<void>;
     private updateEventError;
     /**
      * force sync events who retry count >3 This function can be called from app UI to sync the events forcefully
@@ -22,9 +21,12 @@ export default class EventsSyncManager {
     isSyncPending(): Promise<boolean>;
     private markEventSynced;
     insertEvent(sequence: number, payload: string, dspID: string, syncType: string, objectiveRef: string, config?: string): Promise<void>;
+    insertBulkEvent(_bulkData: BulkEvent): Promise<void>;
+    insertQueueEvent(_pushData: BulkEvent): Promise<void>;
     private checkForInitialization;
     getObjectiveSummary(objectiveRef: string): Promise<any>;
     private syncEventToServer;
+    private syncBulkEventToServer;
     getAllEvents(dspID?: string): Promise<EventRow[]>;
     clearEventsDB(): Promise<void>;
 }

package/lib/typescript/manager/syncmanager/events/SyncHttpClient.d.ts

@@ -1,7 +1,10 @@
 import HttpClient from '../../../network/client';
-import type { EventRow } from '../DBConfig';
-import { SyncType } from 'mobile-execution-lib';
+import { DispatchSyncType, EventRow } from '../DBConfig';
+import NetworkClient from '../../../network/NetworkClient';
+import { ExecEngineSyncType } from '../DBConfig';
 export default class SyncHttpClient extends HttpClient {
+    protected readonly networkInstance: NetworkClient;
     constructor(baseURL: string);
-    syncEvent(eventRow: EventRow[], syncType: SyncType): Promise<boolean | null>;
+    syncEvent(eventRow: EventRow[], syncType: ExecEngineSyncType | DispatchSyncType): Promise<boolean | null>;
+    syncBulkEvent(eventRow: EventRow[]): Promise<boolean | null>;
 }

package/lib/typescript/models/DispatchModels.d.ts

@@ -1,4 +1,4 @@
-import type { state } from 'mobile-execution-lib';
+import { IDispatch, IDispatchExecutor } from '@os1-platform/platform-coreos-execution-engine-sdk';
 export interface BaseETProps {
     showProgress: (loading: boolean) => void;
 }
@@ -9,9 +9,63 @@ export declare enum SdkSyncType {
 export interface JobObjectiveType {
     objectiveId: string;
     jobId: string;
+    groupId?: string;
+    additionalData?: any;
 }
-export interface stateWithObjRef {
-    nextState: state;
-    objRef: string;
-    jobId: string;
+export interface endEvent {
+    taskId: string;
+    nextTaskId: string;
+    timestamp: number;
+    customData?: any;
+    etData: {
+        [key: string]: any;
+    };
+    meta?: any;
+}
+export interface onScanEvent {
+    taskId: string;
+    timestamp: number;
+    customData?: any;
+    etData: {
+        eventCode: string;
+        reasonCode: string;
+        success: boolean;
+        endTime: number;
+        scannedData: {
+            jobId: string;
+            scanValue: string;
+            shipmentFlow: string;
+            groupId: string;
+        }[];
+    };
+    meta?: any;
+}
+export interface onScanRemoveEvent {
+    taskId: string;
+    timestamp: number;
+    customData?: any;
+    etData: {
+        scannedData: {
+            scanValue: string;
+        }[];
+    };
+    meta?: any;
+}
+export interface startEvent {
+    timestamp: number;
+    taskId: string;
+    customData?: any;
+    etData: {
+        [key: string]: any;
+    };
+}
+export interface stateParams {
+    next_states: IDispatch.IExecutionTaskQueryResponse;
+    rootMetaData: {
+        meta: any;
+        customEventsData?: any;
+        statusFilter: IDispatchExecutor.ExecutionStatus[];
+        prefixedMergedObjectiveId: string;
+    };
+    has_multiple_ets?: boolean;
 }

package/lib/typescript/models/ReasonCodes.d.ts

@@ -4,3 +4,8 @@ export interface ReasonCodes {
     reasonCode: string;
     isSystemDefined: boolean;
 }
+export interface EventCodes {
+    description: string;
+    eventCode: string;
+    successEvent: boolean;
+}

package/lib/typescript/models/auth.d.ts

@@ -26,7 +26,7 @@ export interface RefreshTokenPayload {
     appName: string;
     applicationSecret: string;
 }
-export declare type LoginType = 'mobilePassword' | 'mobileOtp' | 'mPin' | 'usernamePassword' | 'clientCredential';
+export type LoginType = 'mobilePassword' | 'mobileOtp' | 'mPin' | 'usernamePassword' | 'clientCredential';
 export interface Headers {
     requestId: string;
 }

package/lib/typescript/models/execTasks/ETBaseModels.d.ts

@@ -1,4 +1,7 @@
-export declare type BaseETResponse = {
+import { ExecutionTaskID } from './ETConfig';
+export type BaseETResponse = {
+    id: ExecutionTaskID;
+    mergedObjectiveIds: Array<string>;
     /**
      * Success flag for the operation performed by user
      */
@@ -19,24 +22,18 @@ export declare type BaseETResponse = {
         /**
          * Epoch timestamp for the start of task
          */
-        startTime?: number;
         /**
          * Epoch timestamp for the end of task
          */
-        endTime?: number;
         /**
          * Location at start of task
          */
-        location?: {
-            /**
-             * Latitude
-             */
-            latitude?: string;
-            /**
-             * Longitude
-             */
-            longitude?: string;
-        };
+        /**
+         * Latitude
+         */
+        /**
+         * Longitude
+         */
         /**
          * Unique identifier of user performing the action
          */
@@ -50,24 +47,45 @@ export interface UserData {
 /**
  * Title of instruction
  */
-export declare type Title = string;
+export type Title = string;
 /**
  * Message of instruction
  */
-export declare type Message = string;
+export type Message = string;
 /**
  * Can go back
  */
-export declare type CanGoBack = boolean;
-export declare type BaseETRequest = {
+export type CanGoBack = boolean;
+export type BaseETRequest = {
     title: Title;
     message?: Message;
     canGoBack?: CanGoBack;
-    applicableReasons?: ApplicableReasons;
+    applicableReasons?: ApplicableReasons | NewApplicableReasons;
+    taskMeta?: {
+        [k: string]: any;
+    };
+    wfMeta?: {
+        [k: string]: any;
+    };
+    navigation?: any;
+    route?: any;
+    taskName: string;
+    mergedObjectiveId: Array<string>;
 };
-export interface ApplicableReasons {
+export type ApplicableReasons = {
     [k: string]: string[];
-}
+};
+export type NewApplicableReasons = {
+    success: {
+        [k: string]: string[];
+    };
+    failure: {
+        [k: string]: string[];
+    };
+    goBack?: {
+        [k: string]: string[];
+    };
+};
 export interface ETSummary {
     name: string;
     eventCode: string;
@@ -79,3 +97,9 @@ export interface CompleteSummary {
     objectiveRef: string;
     jobObjectiveSummary: ETSummary[];
 }
+export interface ObjectiveSummary {
+    entityCode: string;
+    eventCode: string;
+    reasonCode: string;
+    reasonCodeDesc?: string;
+}

package/lib/typescript/models/execTasks/ETConfig.d.ts

@@ -16,7 +16,8 @@ export declare enum ExecutionTaskID {
     DISPLAY = "etask:574ff9b0-c49c-5eb5-b550-8548ae0cab44",
     VERIFY_INPUT = "etask:6fc10a60-a144-5798-97f3-1f12e77f56e2",
     DELIVER_CASH = "etask:2fffdf62-62b3-5e70-bd9e-d4d2644ee2fe",
-    HTTP_REQUEST_ET = "etask:e148b862-8368-5586-b29d-1eda95ffc8c4"
+    HTTP_REQUEST_ET = "etask:e148b862-8368-5586-b29d-1eda95ffc8c4",
+    VALIDATE_OTP_ET = "etask:8d5b96f3-7342-5e25-a57f-30004f53de17"
 }
 export declare enum ExecutionTaskName {
     DELIVER = "Deliver",
@@ -36,7 +37,8 @@ export declare enum ExecutionTaskName {
     DISPLAY = "Display",
     VERIFY_INPUT = "Verifying Input",
     DELIVER_CASH = "Drop Cash",
-    HTTP_REQUEST_ET = "Network Request"
+    HTTP_REQUEST_ET = "Network Request",
+    VALIDATE_OTP_ET = "Validate OTP"
 }
 export declare enum CustomScreens {
     REMARK_SCREEN = "REMARKS_SCREEN"
@@ -59,7 +61,8 @@ export declare enum EntityCode {
     DISPLAY = "0013",
     VERIFY_INPUT = "0020",
     DELIVER_CASH = "0022",
-    HTTP_REQUEST_ET = "0023"
+    HTTP_REQUEST_ET = "0023",
+    VALIDATE_OTP_ET = "0052"
 }
 export declare enum BaseEventCodes {
     ENTITY_SUCCESS = "E-010",
@@ -82,5 +85,6 @@ export declare enum FinalETName {
     VERIFY_LOCATION = "etask:7f3897da-3a1f-5736-b8e5-5d9f131b13cd",
     DISPLAY = "etask:574ff9b0-c49c-5eb5-b550-8548ae0cab44",
     VERIFY_INPUT = "etask:6fc10a60-a144-5798-97f3-1f12e77f56e2",
-    DELIVER_CASH = "etask:2fffdf62-62b3-5e70-bd9e-d4d2644ee2fe"
+    DELIVER_CASH = "etask:2fffdf62-62b3-5e70-bd9e-d4d2644ee2fe",
+    VALIDATE_OTP_ET = "Validate OTP"
 }

package/lib/typescript/models/sdk.d.ts

@@ -1,8 +1,12 @@
+import type { EventCodes } from './ReasonCodes';
 export interface DispatchSDKConfig {
     tenantID: string;
     userID: string;
     userName: string;
     tenantBaseURL: string;
+    headers?: {
+        [key: string]: any;
+    };
     enableLogging?: boolean;
     syncRetryCount?: number;
     accessToken: string;
@@ -16,6 +20,14 @@ export interface DispatchSDKConfig {
         description: string;
         interval: number;
     };
+    eventMapping?: EventCodes[];
+    debugLevelLog?: Boolean;
+    callbacks?: {
+        fetchPhoneNumbersCallback?: (sdsIds: string[]) => Promise<{
+            key: string;
+            value: string[];
+        }>;
+    };
 }
 export declare enum ENVIRONMENT {
     DEV = "dev",