@os1-platform/dispatch-mobile 1.0.0

package/lib/typescript/components/executiontasks/scanner/returns/ScanList.d.ts

@@ -0,0 +1,17 @@
+/// <reference types="react" />
+import type { ScannedItemData, ScannerInput } from '../ScannerSchema';
+import { SCAN_ACTIONS } from '../ScannerUtils';
+import type { ReasonItem } from './ReasonDropDown';
+declare const ScanList: (props: ScanListProps) => JSX.Element;
+export default ScanList;
+export declare type ScanListProps = ScannerInput & {
+    reasons: ReasonItem[];
+    scanList: ScannedItemData[] | undefined;
+    filterList: (shipment: string, action: SCAN_ACTIONS) => void;
+};
+export interface StatusProps {
+    text: string;
+    color: string;
+    backgroundColor: string;
+    iconColor: string;
+}

package/lib/typescript/components/executiontasks/verifyInput/VerifyInputSchema.d.ts

@@ -0,0 +1,41 @@
+import type { BaseETRequest, BaseETResponse } from '../../../models/execTasks/ETBaseModels';
+export declare type VerifyInput = (BaseETRequest & {
+    input: Input;
+    value: Value;
+}) | (BaseETRequest & {
+    input: Input1;
+    api: API;
+});
+/**
+ * Input entered by user
+ */
+export declare type Input = string | number;
+/**
+ * Value
+ */
+export declare type Value = string | number;
+/**
+ * Input entered by user
+ */
+export declare type Input1 = string | number;
+/**
+ * Verification api URI
+ */
+export declare type HeaderKey = string;
+export declare type HeaderValue = string;
+/**
+ * Verification api headers
+ */
+export declare type Headers = {
+    key?: HeaderKey;
+    value?: HeaderValue;
+};
+/**
+ * Api
+ */
+export interface API {
+    uri: string;
+    headers?: Headers[];
+    valueJsonPath: string;
+}
+export declare type VerifyInputResponse = BaseETResponse;

package/lib/typescript/components/executiontasks/verifyLocation/GeofenceUtils.d.ts

@@ -0,0 +1,2 @@
+import type { VerifyLocationInput } from './VerifyLocSchema';
+export declare function verifyLocation(params: VerifyLocationInput): Promise<boolean>;

package/lib/typescript/components/executiontasks/verifyLocation/VerifyLocSchema.d.ts

@@ -0,0 +1,50 @@
+/**
+ * Longitude
+ */
+import type { BaseETRequest, BaseETResponse } from '../../../models/execTasks/ETBaseModels';
+export declare type Longitude = string;
+/**
+ * Latitude
+ */
+export declare type Latitude = string;
+/**
+ * Accuracy in meters of the geolocation
+ */
+export declare type Accuracy = number | null;
+/**
+ * Boolean key to enable/disable geofencing feature
+ */
+export declare type GeofencingEnabled = boolean;
+/**
+ * Radius in meters around the verifyLocation for geo-fencing
+ */
+export declare type Radius = number;
+/**
+ * Boolean key to enable manual override the geo-fencing feature
+ */
+export declare type Override = boolean;
+/**
+ * Any manual instruction to display for the Operator to work on
+ */
+export declare type Instruction = string;
+export declare type VerifyLocationInput = BaseETRequest & {
+    geolocation: GeoLocation;
+    address?: string;
+    onSubmitET: (value: VerifyLocationOutput) => void;
+};
+/**
+ * Details of geo-verifyLocation
+ */
+export interface GeoLocation {
+    longitude: Longitude;
+    latitude: Latitude;
+    accuracy?: Accuracy;
+    geofencing: Geofencing;
+}
+/**
+ * Details of geo-fencing around the verifyLocation
+ */
+export interface Geofencing {
+    radius: Radius;
+}
+export declare type VerifyLocationOutput = BaseETResponse;

package/lib/typescript/components/executiontasks/verifyLocation/VerifyLocationET.d.ts

@@ -0,0 +1,4 @@
+/// <reference types="react" />
+import type { VerifyLocationInput } from './VerifyLocSchema';
+declare const VerifyLocationET: (props: VerifyLocationInput) => JSX.Element;
+export default VerifyLocationET;

package/lib/typescript/components/executiontasks/verifyOtp/VerifyOtpET.d.ts

@@ -0,0 +1,4 @@
+/// <reference types="react" />
+import type { OtpInputSchema } from './VerifyOtpSchema';
+declare const VerifyOtpET: (props: OtpInputSchema) => JSX.Element;
+export default VerifyOtpET;

package/lib/typescript/components/executiontasks/verifyOtp/VerifyOtpSchema.d.ts

@@ -0,0 +1,21 @@
+/**
+ * Otp entered by user
+ */
+import type { BaseETResponse } from '../../../models/execTasks/ETBaseModels';
+export declare type InputOtp = string;
+/**
+ * Otp Value
+ */
+export declare type Otp = string;
+export interface OtpInputSchema {
+    inputCount: number;
+    inputOtp: InputOtp;
+    otp: Otp;
+    onSubmit: (output: OtpOutputSchema) => void;
+}
+export declare type OtpOutputSchema = BaseETResponse & {
+    /**
+     * Boolean to represent result of verification
+     */
+    success: boolean;
+};

package/lib/typescript/components/widgets/AlertDisplay.d.ts

@@ -0,0 +1 @@
+export declare function showAlert(title: string, message: string, cancelable: boolean, btnPositive: string, positiveCall: () => void, btnNegative?: string, negCall?: () => void): void;

package/lib/typescript/components/widgets/CancelOrderDialog.d.ts

@@ -0,0 +1,13 @@
+/// <reference types="react" />
+declare const CancelOrderDialog: (props: CancelDialogProps) => JSX.Element;
+export default CancelOrderDialog;
+export interface CancelDialogProps {
+    visible: boolean;
+    onSubmit: (success: boolean) => void;
+    label?: string;
+    message?: string;
+    positiveButtonTitle?: string;
+    negativeButtonTitle?: string;
+    showIcon?: boolean;
+    iconName?: string;
+}

package/lib/typescript/components/widgets/ProgressDialog.d.ts

@@ -0,0 +1,7 @@
+/// <reference types="react" />
+declare const ProgressDialog: (props: ProgressDialogProps) => JSX.Element;
+export default ProgressDialog;
+export interface ProgressDialogProps {
+    visible: boolean;
+    label: string;
+}

package/lib/typescript/components/widgets/SnackBarCustom.d.ts

@@ -0,0 +1,20 @@
+import React from 'react';
+export interface SnackbarProps {
+    visible: boolean;
+    duration?: number;
+    /**
+     * Callback called when Snackbar is dismissed. The `visible` prop needs to be updated when this is called.
+     */
+    onDismiss: () => void;
+    /**
+     * Text content of the Snackbar.
+     */
+    message: string;
+    theme: ReactNativePaper.Theme;
+}
+declare const _default: React.ComponentType<Pick<SnackbarProps, "visible" | "onDismiss" | "duration" | "message"> & {
+    theme?: import("@callstack/react-theme-provider").$DeepPartial<ReactNativePaper.Theme> | undefined; /**
+     * Callback called when Snackbar is dismissed. The `visible` prop needs to be updated when this is called.
+     */
+}> & import("@callstack/react-theme-provider/typings/hoist-non-react-statics").NonReactStatics<React.ComponentType<SnackbarProps> & (({ visible, duration, onDismiss, message, theme, }: SnackbarProps) => JSX.Element | null), {}>;
+export default _default;

package/lib/typescript/components/widgets/Toaster.d.ts

@@ -0,0 +1 @@
+export declare function showToast(message: string): void;

package/lib/typescript/config/DispatchSDKConfig.d.ts

@@ -0,0 +1,4 @@
+export declare const enum ERROR_TAGS {
+    FCM = "FCM",
+    EXECUTION_TASK = "EXECUTION_TASK"
+}

package/lib/typescript/constants/apiConstants.d.ts

@@ -0,0 +1,3 @@
+export declare const ENDPOINTS: {
+    JOB_REMOVAL: (dispatchId: string, jobId: string) => string;
+};

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

@@ -0,0 +1,9 @@
+export declare const LOCAL_STORAGE_KEY_PREFIX = "@dispatch-sdk:";
+export declare const DEFAULT_NOTIFICATION_TITLE = "Dispatch Sync Manager";
+export declare const DEFAULT_NOTIFICATION_DESCRIPTION = "Syncing Events & Files";
+export declare const DEFAULT_INTERVAL = 10000;
+export declare const DEFAULT_PICKUP_TITLE = "Pickup Order";
+export declare const DEFAULT_PICKUP_MESSAGE = "Confirm pickup of $ order(s)";
+export declare const DEFAULT_DELIVER_TITLE = "Drop Order";
+export declare const DEFAULT_DELIVER_MESSAGE = "Confirm drop of $ order(s)";
+export declare const DEFAULT_SIGN_ET_MESSAGE = "Please capture a clear signature from the customer";

package/lib/typescript/constants/statuscode.d.ts

@@ -0,0 +1,7 @@
+declare enum StatusCode {
+    Unauthorized = 401,
+    Forbidden = 403,
+    TooManyRequests = 429,
+    InternalServerError = 500
+}
+export default StatusCode;

package/lib/typescript/errors/BaseError.d.ts

@@ -0,0 +1,10 @@
+/**
+ * A general error class that should be used for all errors in Expo modules.
+ * Guarantees a `code` field that can be used to differentiate between different
+ * types of errors without further subclassing Error.
+ */
+export declare class BaseError extends Error {
+    code: string;
+    info?: any;
+    constructor(code: string, message: string, info?: string);
+}

package/lib/typescript/errors/ErrorCodes.d.ts

@@ -0,0 +1,28 @@
+declare const enum BaseErrorCodes {
+    InvalidArgumentError = "100100",
+    InvalidBaseURL = "100101",
+    SyncManagerNotInitialized = "100102",
+    MissingOrInvalidProps = "100103",
+    SQLiteDBIssue = "100104",
+    AppSyncNotInitialized = "100105",
+    FMS_FOLDER_CREATION_ERROR = "100106",
+    REASON_CODE_API_ERROR = "100107",
+    MERGING_ERROR = "100108",
+    LOCATION_PERMISSION_DENIED = "100109",
+    CAMERA_PERMISSION_DENIED = "100110",
+    STORAGE_PERMISSION_DENIED = "100111",
+    GRAPHQL_CLIENT_NOT_INITIALIZED = "100112",
+    FMS_GRAPHQL_API_ERROR = "100113",
+    INTERNET_NOT_ENABLED = "100114",
+    LOCATION_OR_GPS_NOT_ENABLED = "100115",
+    EXECUTION_ENGINE_ERROR = "100116",
+    UNEXPECTED_ERROR = "100117",
+    SYSTEM_TIME_CHECK_FAILED = "100118",
+    ACCESS_TOKEN_EXPIRED = "100119"
+}
+export declare const InvalidArgumentsError = "Missing or invalid arguments";
+export declare const InvalidBaseURL = "URL is invalid";
+export declare const SyncManagerNotInitialized = "Sync Manager is not initialized.Please call init method first";
+export declare const AppSyncInitError = "App sync Manager not initialized.Please call initSyncManager() with valid BASE URLs from your app's index file";
+export declare const MissingOrInvalidProps = "One or more prop(s) is missing or invalid";
+export default BaseErrorCodes;

package/lib/typescript/index.d.ts

@@ -0,0 +1,31 @@
+import Storage from './utils/storage';
+import type * as ETaskSchema from './components/executiontasks/ExecutionTasksIndex';
+import * as ExecutionTask from './components/executiontasks/ExecutionTasksIndex';
+import type { MTSInitRequest, MTSStartRequest } from '@os1-platform/mts-mobile';
+import * as MtsSdk from '@os1-platform/mts-mobile';
+import NativeSyncManager from './manager/syncmanager/NativeSyncManager';
+import type { DocumentRow, EventRow } from './manager/syncmanager/DBConfig';
+import { SyncMethod } from './manager/syncmanager/DBConfig';
+import CancelOrderDialog from './components/widgets/CancelOrderDialog';
+import useFCMMessage, { getFCMToken, registerBackgroundHandler, requestFirebasePermissions } from './utils/fcm/FcmUtils';
+import FCM from './utils/fcm/FCM';
+import DispatchExecNavigator from './components/dispatch/DispatchExecNavigator';
+import DispatchStateContainer from './manager/dispatch/DispatchStateContainer';
+import { objectiveExecutionStatus, ObjectiveNotFoundError } from '@foxtrotplatform/mobile-execution-lib';
+import { DispatchSDKManager } from './manager/sdk/DispatchSDKManager';
+import Logger, { LOG_TYPE } from './utils/Logger';
+import type { ETSummary, CompleteSummary } from './models/execTasks/ETBaseModels';
+import SdkUtils from './utils/SdkUtils';
+import AppSyncManager from './manager/syncmanager/AppSyncManager';
+import type { JobObjectiveType } from './models/DispatchModels';
+import { SdkSyncType } from './models/DispatchModels';
+export { Storage, DispatchExecNavigator };
+export { ETSummary, CompleteSummary };
+export { NativeSyncManager, AppSyncManager, SdkSyncType, EventRow, DocumentRow, useFCMMessage, getFCMToken, requestFirebasePermissions, FCM, registerBackgroundHandler, DispatchStateContainer, SdkUtils, Logger, LOG_TYPE, };
+export { SyncMethod, JobObjectiveType };
+export type { ETaskSchema };
+export { ExecutionTask, CancelOrderDialog };
+export { objectiveExecutionStatus, ObjectiveNotFoundError };
+export { DispatchSDKManager };
+export type { MTSStartRequest, MTSInitRequest };
+export { MtsSdk };

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

@@ -0,0 +1,41 @@
+import type { Job, state } from '@foxtrotplatform/mobile-execution-lib';
+import type { ETSummary } from '../../models/execTasks/ETBaseModels';
+import type { BaseETProps, JobObjectiveType, stateWithObjRef } from '../../models/DispatchModels';
+export default class DispatchStateContainer {
+    get stateKeys(): string[];
+    set stateKeys(value: string[]);
+    get mappedStates(): Map<string, stateWithObjRef[]>;
+    set mappedStates(value: Map<string, stateWithObjRef[]>);
+    private static instance;
+    private dispatchExecutor;
+    private successRoute;
+    private failureRoute;
+    private _stateKeys;
+    _jobObjectives: JobObjectiveType[] | null;
+    private _mappedStates;
+    /**
+     * Call this function when dispatch data is fetched successfully in client app
+     * @param dispatchID
+     * @param jobs
+     * @param logging
+     * @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>;
+    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>;
+    private saveAndProceedToNextET;
+    saveAndProceed(baseETProps: BaseETProps, etOutput: any, etStates: stateWithObjRef[], navigation: any, isLastTask?: boolean): Promise<void>;
+}

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

@@ -0,0 +1 @@
+export declare function getEventCodeByET(_etName: string, success: boolean): string;

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

@@ -0,0 +1,12 @@
+import type { ApplicableReasons } from '../../models/execTasks/ETBaseModels';
+import type { ReasonsRow } from '../syncmanager/DBConfig';
+export default class ReasonCodeContainer {
+    private static instance;
+    private cache;
+    private constructor();
+    static getInstance(): ReasonCodeContainer;
+    getReasonCodes(applicableCodes: ApplicableReasons, entityCode: string): Promise<ReasonsRow[]>;
+    static getReasonCodeFromText(reasonText: string, reasons: ReasonsRow[]): string;
+    getReasonByCode(code: string): Promise<ReasonsRow | null>;
+    fetchReasonCode(): Promise<void>;
+}

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

@@ -0,0 +1,13 @@
+import { ReasonsRow } from '../syncmanager/DBConfig';
+import type { ReasonCodes } from '../../models/ReasonCodes';
+export default class ReasonCodeRepo {
+    private static instance;
+    static getInstance(): ReasonCodeRepo;
+    saveReasonCode(reasonsList: ReasonCodes[]): Promise<void>;
+    private insertReason;
+    private init;
+    getAllReasons(): Promise<ReasonsRow[]>;
+    deleteAll(): Promise<import("expo-sqlite").SQLResultSet>;
+    getReasonsByCode(codes: string[]): Promise<ReasonsRow[]>;
+    getReasonByCode(code: string): Promise<ReasonsRow[]>;
+}

package/lib/typescript/manager/location/LocationManager.d.ts

@@ -0,0 +1,14 @@
+export default class LocationManager {
+    private static instance;
+    private lastLocation;
+    private stopUpdate;
+    checkForLocationPermissions(): Promise<boolean>;
+    static getInstance(): LocationManager;
+    startUpdates(): void;
+    getLastLocation(): DLocation;
+    stopLocationUpdates(): void;
+}
+export interface DLocation {
+    latitude: string;
+    longitude: string;
+}

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

@@ -0,0 +1,14 @@
+import type { DispatchSDKConfig } from '../../models/sdk';
+export declare class DispatchSDKManager {
+    private static instance;
+    private cache;
+    private keys;
+    private constructor();
+    static getInstance(): DispatchSDKManager;
+    /**
+     * Call this init method with username,userID & authentication tokens
+     * @param sdkConfig
+     */
+    initDispatchSDK(sdkConfig: DispatchSDKConfig): Promise<void>;
+    removeLocationUpdates(): void;
+}

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

@@ -0,0 +1,17 @@
+export default class DispatchSdkCache {
+    private storage;
+    private static instance;
+    static getInstance(): DispatchSdkCache;
+    static KEYS: {
+        SDK_CONFIG: string;
+        DISPATCH_ID: string;
+        FMS_FOLDER: string;
+        FIREBASE_REGISTRATION_TOKEN: string;
+        REASON_FETCH_TIME: string;
+    };
+    setObjectInCache(keyName: string, obj: any): Promise<void>;
+    getObjectFromCache(keyName: string): Promise<any>;
+    setKeyInCache(keyName: string, keyValue: string): Promise<void>;
+    getKeyFromCache(keyName: string): Promise<string | null>;
+    clearKeys(keys: string[]): Promise<void>;
+}

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

@@ -0,0 +1,24 @@
+import type { SdkSyncType } from '../../models/DispatchModels';
+import type { DocumentRow, EventRow } from './DBConfig';
+export default class AppSyncManager {
+    private constructor();
+    private static instance;
+    isSyncActive: boolean;
+    /**
+     *
+     * @param forceSync - true/false - if true resets the retry count key and start the sync
+     * @param syncType
+     */
+    startSyncing(forceSync: boolean, _syncType?: SdkSyncType): Promise<void>;
+    isAppSyncPending(): Promise<boolean>;
+    static initAppSync(tenantBaseURL: string, syncRetryCount: number): AppSyncManager;
+    static getInstance(): AppSyncManager;
+    static startAppSyncManager(): Promise<void>;
+    /**
+     * Call this method from index file of the app
+     */
+    static registerSyncTask(): void;
+    getAllEvents(dispatchID?: string): Promise<EventRow[]>;
+    getAllDocuments(dispatchID?: string): Promise<DocumentRow[]>;
+    startSDKSyncManager(): void;
+}

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

@@ -0,0 +1,77 @@
+export declare const DATABASE_NAME = "DISPATCH_DB";
+export declare const EVENTS_TABLE = "EVENTS_TABLE";
+export declare const REASONS_TABLE = "REASONS_TABLE";
+export declare const EVENTS_COLUMNS: {
+    ID: string;
+    SEQUENCE: string;
+    PAYLOAD: string;
+    SYNCED: string;
+    CONFIG: string;
+    SYNC_TYPE: string;
+    OBJECTIVE_REF: string;
+    SYNC_ERROR: string;
+    DISPATCH_ID: string;
+};
+export declare const DOCUMENT_TABLE = "DOCUMENTS_TABLE";
+export declare const DOCUMENT_COLUMNS: {
+    ID: string;
+    DATA: string;
+    BASE64: string;
+    FILE_PATH: string;
+    FILE_NAME: string;
+    FILE_TYPE: string;
+    SYNCED: string;
+    FMS_FOLDER_ID: string;
+    FMS_ID: string;
+    PRIORITY: string;
+    DESCRIPTION: string;
+    SYNC_ERROR: string;
+    DISPATCH_ID: string;
+    JOB_ID: string;
+    OBJECTIVE_REF: string;
+};
+export declare type DocumentRow = {
+    id: number;
+    data: string;
+    base64: boolean;
+    file_path: string;
+    file_name: string;
+    file_type: string;
+    synced: boolean;
+    fms_folder_id: string;
+    fms_id: string;
+    priority: number;
+    desc: string;
+    sync_error: string;
+    dispatch_id: string;
+    job_id: string;
+    objective_ref: string;
+};
+export declare type EventRow = {
+    id: number;
+    payload: string;
+    synced: boolean;
+    config: string;
+    sync_type: string;
+    objective_ref: string;
+    sync_error: string;
+    dispatch_id: string;
+};
+export declare enum SyncMethod {
+    POST = "POST",
+    PUT = "PUT",
+    GET = "GET",
+    DELETE = "DELETE"
+}
+export declare const ReasonColums: {
+    CODE: string;
+    DESCRIPTION: string;
+    IS_ENABLED: string;
+    SYSTEM_DEFINED: string;
+};
+export interface ReasonsRow {
+    description: string;
+    isEnabled: boolean;
+    reasonCode: string;
+    isSystemDefined: boolean;
+}

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

@@ -0,0 +1,6 @@
+interface SyncManagerInterface {
+    startSyncManager(interval: number, notifTitle: string, notifText: string): void;
+    stopSyncManager(): void;
+}
+declare const _default: SyncManagerInterface;
+export default _default;

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

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

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

@@ -0,0 +1,9 @@
+import HttpClient from '../../../network/client';
+import type { DocumentRow } from '../DBConfig';
+import type { AxiosResponse } from 'axios';
+export default class DocumentHttpClient extends HttpClient {
+    constructor(baseURL: string);
+    uploadDocument(document: DocumentRow): Promise<string | null>;
+    uploadBase64File(document: DocumentRow): Promise<AxiosResponse>;
+    private uploadBinaryFile;
+}

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

@@ -0,0 +1,15 @@
+import { DocumentRow } from '../DBConfig';
+import type { SQLResultSet } from 'expo-sqlite';
+export default class DocumentManager {
+    private static instance;
+    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>;
+    getAllDocuments(dispatchID?: string): Promise<DocumentRow[]>;
+    getAllUnsyncedDocs(): Promise<DocumentRow[]>;
+    deleteAllSyncedDocuments(dispatchID: string): Promise<SQLResultSet>;
+    markDocumentSynced(id: number, fmsID: string): Promise<void>;
+    updateDocSyncError(id: number, uploadError: string): Promise<void>;
+    getUnsyncedDocument(): Promise<DocumentRow[]>;
+}

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

@@ -0,0 +1,25 @@
+import type { DocumentRow } from '../DBConfig';
+import type { SQLResultSet } from 'expo-sqlite';
+export default class DocumentSyncManager {
+    private documentHttpClient;
+    private inProgress;
+    private static instance;
+    private docManager;
+    private maxRetryCount;
+    private _retries;
+    get retries(): number;
+    set retries(value: number);
+    private constructor();
+    init(baseURL: string, retryCount: number): void;
+    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>;
+    forceDocumentSync(): Promise<void>;
+    private updateDocument;
+    private updateDocError;
+    private checkForInitialization;
+    private uploadDocToServer;
+    getAllDocuments(dispatchID?: string): Promise<DocumentRow[]>;
+    clearSyncedDocs(dspID: string): Promise<void>;
+}

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

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

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

@@ -0,0 +1,16 @@
+import { EventRow } from '../DBConfig';
+export default class ETEventsManager {
+    private static instance;
+    private constructor();
+    static getInstance(): Promise<ETEventsManager>;
+    private static init;
+    insertEvent(sequence: number, payload: string, dspID: string, syncType: string, objectiveRef: string, config?: string): Promise<void>;
+    getAllEvents(dispatchID?: string): Promise<EventRow[]>;
+    getAllUnsyncedEvents(): Promise<EventRow[]>;
+    deleteAllEvents(): Promise<import("expo-sqlite").SQLResultSet>;
+    updateError(id: number, syncError: string): Promise<void>;
+    markEventSynced(id: number): Promise<void>;
+    getWorkflowUpdateEvents(syncType: string): Promise<EventRow[]>;
+    getCustodyBatch(dispatchID: string): Promise<EventRow[]>;
+    getObjectiveDetails(objectiveRef: string): Promise<EventRow[]>;
+}