@os1-platform/dispatch-mobile 1.0.0

package/lib/typescript/components/executiontasks/doodle/SignatureSchema.d.ts

@@ -0,0 +1,48 @@
+/**
+ * Length (in cm)
+ */
+import type { BaseETRequest, BaseETResponse } from '../../../models/execTasks/ETBaseModels';
+export declare type Length = number;
+/**
+ * Breadth (in cm)
+ */
+export declare type Breadth = number;
+/**
+ * Maximum Size limit (in kb) of doodle image
+ */
+export declare type MaxFileSize = number;
+/**
+ * Pen colour hex code
+ */
+export declare type PenColor = string;
+/**
+ * Any manual instruction to display for the Operator
+ */
+export declare type Instruction = string;
+export declare type SignatureInput = BaseETRequest & {
+    resolution: Dimension;
+    fileSizeLimit: MaxFileSize;
+    penColor?: PenColor;
+    onSubmitET: (value: SignatureOutput) => void;
+} & {
+    jobIDs: string[];
+    objRefs: string[];
+};
+/**
+ * Dimensions of doodle image
+ */
+export interface Dimension {
+    length: Length;
+    breadth: Breadth;
+}
+export interface SignatureBaseResponse {
+    /**
+     * Url of doodle image
+     */
+    url?: string;
+    file?: {
+        folder: string;
+        name: string;
+    };
+}
+export declare type SignatureOutput = BaseETResponse & SignatureBaseResponse;

package/lib/typescript/components/executiontasks/dropCash/DropCashET.d.ts

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

package/lib/typescript/components/executiontasks/dropCash/DropCashSchema.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Amount to be collected
+ */
+import type { BaseETRequest, BaseETResponse } from '../../../models/execTasks/ETBaseModels';
+import type { ETAmount } from '../payments/init/InitPaymentSchema';
+export declare type DropCashInput = BaseETRequest & {
+    expectedAmount: ETAmount;
+    confirmAmount?: boolean;
+    onSubmitET: (etOutput: DropCashOutput) => void;
+    confirmCustodyExchange?: boolean;
+};
+export declare type DropCashOutput = BaseETResponse & {
+    /**
+     * Amount collected (ISO 4217)
+     */
+    amount?: ETAmount;
+};

package/lib/typescript/components/executiontasks/dropCash/SLDropCash.d.ts

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

package/lib/typescript/components/executiontasks/forms/FormGenerator.d.ts

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

package/lib/typescript/components/executiontasks/forms/FormSchema.d.ts

@@ -0,0 +1,24 @@
+import type { BaseETRequest, BaseETResponse } from '../../../models/execTasks/ETBaseModels';
+export declare type FormInputSchema = BaseETRequest & {
+    jsonSchema: JSONSchema;
+    uiSchema: UISchame;
+    onError: (e: any) => void;
+    onSubmitET: (result: FormOutputSchema) => void;
+};
+/**
+ * Json schema used in react-jsonschema-form
+ */
+export interface JSONSchema {
+    [k: string]: unknown;
+}
+/**
+ * UI schema used in react-jsonschema-form
+ */
+export interface UISchame {
+    [k: string]: unknown;
+}
+export declare type FormOutputSchema = BaseETResponse & {
+    data: {
+        [k: string]: unknown;
+    };
+};

package/lib/typescript/components/executiontasks/forms/widgets/DateTimeWidget.d.ts

@@ -0,0 +1,11 @@
+/// <reference types="react" />
+import type { WidgetProps } from '@rjsf/core';
+declare type DateWidgetProps = WidgetProps & {
+    minDate?: Date;
+    maxDate?: Date;
+};
+declare const DateTimeWidget: ({ id, label, value, onChange, onFocus, autofocus, options, rawErrors, maxDate, }: DateWidgetProps) => JSX.Element;
+/**
+ * max and min date has to be implemented
+ */
+export default DateTimeWidget;

package/lib/typescript/components/executiontasks/forms/widgets/QRBarcodeScannerWidget.d.ts

@@ -0,0 +1,8 @@
+/// <reference types="react" />
+import type { WidgetProps } from '@rjsf/core';
+declare const QRBarcodeScannerWidget: ({ id, label, value, onChange, onFocus, autofocus, rawErrors, }: WidgetProps) => JSX.Element;
+export interface ScannerDialogProps {
+    onSubmitDialog: (value: string) => void;
+    onModalClose: () => void;
+}
+export default QRBarcodeScannerWidget;

package/lib/typescript/components/executiontasks/forms/widgets/TimeRangeSelector.d.ts

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

package/lib/typescript/components/executiontasks/httpRequest/HttpEtUtils.d.ts

@@ -0,0 +1,4 @@
+import type { APIData, HttpRequestETOutput } from './HttpRequestETSchema';
+export declare function getApiResponse(apiData: APIData): Promise<import("axios").AxiosResponse<any, any>>;
+export declare function getOutputUsingJsonpath(json: object, jsonPath: string): any;
+export declare function getHttpETOutput(apiResponse: object, jsonPath: string, success: boolean): Promise<HttpRequestETOutput>;

package/lib/typescript/components/executiontasks/httpRequest/HttpRequestET.d.ts

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

package/lib/typescript/components/executiontasks/httpRequest/HttpRequestETSchema.d.ts

@@ -0,0 +1,36 @@
+import type { BaseETRequest, BaseETResponse } from '../../../models/execTasks/ETBaseModels';
+export declare type HTTPMethod = 'PUT' | 'POST' | 'GET';
+export declare type HeaderKey = string;
+export declare type HeaderValue = string;
+/**
+ * API headers
+ */
+export declare type Headers = {
+    key?: HeaderKey;
+    value?: HeaderValue;
+};
+export declare type HttpRequestETInput = BaseETRequest & {
+    api: APIData;
+    onSubmitET: (value: HttpRequestETOutput) => void;
+};
+/**
+ * API Details
+ */
+export declare type HttpRequestETOutput = BaseETResponse & {
+    apiResponse: object;
+};
+export interface APIData {
+    uri: string;
+    timeout?: number;
+    httpMethod: HTTPMethod;
+    requestBody?: HTTPRequestBody;
+    headers?: Headers[];
+    errorJsonPath: string;
+    responseJsonPath: string;
+}
+/**
+ * request body object
+ */
+export interface HTTPRequestBody {
+    [k: string]: unknown;
+}

package/lib/typescript/components/executiontasks/imageCapture/CaptureSchema.d.ts

@@ -0,0 +1,79 @@
+/**
+ * Length (in cm)
+ */
+import type { BaseETRequest, BaseETResponse } from '../../../models/execTasks/ETBaseModels';
+export interface CapturedImage {
+    /**
+     * Url of image
+     */
+    url: string;
+    file?: {
+        folder: string;
+        name: string;
+    };
+    /**
+     * Epoch timestamp for the image capture
+     */
+    timestamp: number;
+}
+export declare type CaptureOutput = BaseETResponse & {
+    /**
+     * Array of captured images
+     */
+    captures?: CapturedImage[];
+};
+export declare type ImageData = {
+    id: string;
+    path: string;
+    url: string;
+    timestamp: number;
+};
+/**
+ * Length (in cm)
+ */
+export declare type Length = number;
+/**
+ * Breadth (in cm)
+ */
+export declare type Breadth = number;
+/**
+ * Maximum Size limit (in kb) of image to be captured
+ */
+export declare type MaxFileSize = number;
+/**
+ * Mode of capturing image
+ */
+export declare type CaptureMode = 'SINGLE' | 'MULTI';
+/**
+ * Max limit of images to be captured in multi-capture mode
+ */
+export declare type MaxImageCount = number;
+/**
+ * Title of instruction
+ */
+export declare type Title = string;
+/**
+ * Message of instruction
+ */
+export declare type Message = string;
+/**
+ * Can go back
+ */
+export declare type CanGoBack = boolean;
+export declare type CaptureInput = BaseETRequest & {
+    resolution: Resolution;
+    fileSizeLimit: MaxFileSize;
+    captureMode: CaptureMode;
+    captureCountLimit?: MaxImageCount;
+    onSubmitET: (etOutput: CaptureOutput) => void;
+} & {
+    jobIds: string[];
+    objRefs: string[];
+};
+/**
+ * Resolution of image to be captured
+ */
+export interface Resolution {
+    length: Length;
+    breadth: Breadth;
+}

package/lib/typescript/components/executiontasks/imageCapture/CaptureUtils.d.ts

@@ -0,0 +1,9 @@
+import type { CaptureInput, CaptureOutput, ImageData } from './CaptureSchema';
+import type { ImageResult } from 'expo-image-manipulator';
+export declare function deleteImage(imageData: ImageData, images: ImageData[]): Promise<ImageData[]>;
+export declare function getMaxImagesCount(props: CaptureInput): number;
+export declare function getImagesFileName(): string;
+export declare function getCompressionRatio(uri: string, maxSize: number): Promise<number>;
+export declare function checkCameraPermissionUtil(): Promise<boolean>;
+export declare function captureImage(imageWidth: number, imageHeight: number, fileSize: number): Promise<ImageResult | null>;
+export declare function getCaptureOutput(imageDataList: ImageData[], captureProps: CaptureInput): Promise<CaptureOutput>;

package/lib/typescript/components/executiontasks/imageCapture/ImageCapture.d.ts

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

package/lib/typescript/components/executiontasks/payments/PaymentStyles.d.ts

@@ -0,0 +1,78 @@
+import { Fonts } from '../../../styles/executionTasks/CommonStyles';
+export declare const PaymentStyles: {
+    amountStyle: {
+        fontSize: number;
+        fontWeight: "600";
+        fontStyle: "normal";
+        backgroundColor: string;
+        textAlign: "center";
+        alignItems: "center";
+        paddingTop: number;
+        paddingBottom: number;
+        fontFamily: Fonts;
+    };
+    messageStyle: {
+        fontFamily: Fonts;
+        backgroundColor: string;
+        color: string;
+        padding: number;
+        fontStyle: "normal";
+        fontWeight: "normal";
+        fontSize: number;
+    };
+    textStyle1: {
+        fontFamily: Fonts;
+        marginTop: number;
+        marginStart: number;
+        marginEnd: number;
+        color: string;
+        fontStyle: "normal";
+        fontWeight: "normal";
+        fontSize: number;
+    };
+    reasonTextStyle: {
+        flex: number;
+        flexWrap: "wrap";
+        fontFamily: Fonts;
+        fontStyle: "normal";
+        fontSize: number;
+        lineHeight: number;
+        letterSpacing: number;
+        textAlign: "justify";
+        color: string;
+    };
+    reasonItemStyle: {
+        flexDirection: "row";
+        paddingTop: number;
+        paddingStart: number;
+        paddingEnd: number;
+        backgroundColor: string;
+    };
+    heading: {
+        marginTop: number;
+        marginStart: number;
+        fontSize: number;
+        lineHeight: number;
+        letterSpacing: number;
+        fontFamily: string;
+        color: string;
+    };
+    item: {
+        margin: number;
+        padding: number;
+        borderWidth: number;
+    };
+    btn: {
+        width: number;
+        borderRadius: number;
+        backgroundColor: string;
+        paddingHorizontal: number;
+        paddingVertical: number;
+        marginVertical: number;
+    };
+    loader: {
+        flex: number;
+        justifyContent: "center";
+        alignItems: "center";
+    };
+};

package/lib/typescript/components/executiontasks/payments/PaymentUtils.d.ts

@@ -0,0 +1,2 @@
+export declare function getUniqueTransactionID(amt: number): string;
+export declare function getPaymentValue(amt: number, minorUnit?: number): number;

package/lib/typescript/components/executiontasks/payments/completePayment/CompletePaymentET.d.ts

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

package/lib/typescript/components/executiontasks/payments/completePayment/CompletePaymentSchema.d.ts

@@ -0,0 +1,18 @@
+/**
+ * Amount
+ */
+import type { BaseETRequest, BaseETResponse } from '../../../../models/execTasks/ETBaseModels';
+import type { ETAmount } from '../init/InitPaymentSchema';
+export declare type CompletePaymentInput = BaseETRequest & {
+    paymentMode: string;
+    expectedAmount: ETAmount;
+    collectedAmount: ETAmount;
+    transactionId: string;
+    tenantTransactionId: string;
+    onSubmitET: (etOut: CompletePaymentOutput) => void;
+};
+export declare type CompletePaymentOutput = BaseETResponse & {
+    tenantTransactionId: string;
+    paymentMode: string;
+    collectedAmount: ETAmount;
+};

package/lib/typescript/components/executiontasks/payments/init/InitPaymentET.d.ts

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

package/lib/typescript/components/executiontasks/payments/init/InitPaymentSchema.d.ts

@@ -0,0 +1,31 @@
+/**
+ * Amount to be collected
+ */
+import type { BaseETRequest, BaseETResponse } from '../../../../models/execTasks/ETBaseModels';
+/**
+ * List of allowed Modes
+ */
+export declare type AllowedModes = 'CASH' | 'UPI' | 'PAYMENT_LINK';
+export declare type InitPaymentInput = BaseETRequest & {
+    amount: ETAmount;
+    allowedModes: string[];
+    onSubmitET: (output: InitPaymentOutput) => void;
+};
+/**
+ * Amount to be collected (ISO 4217)
+ */
+export interface ETAmount {
+    value: number;
+    currencyCode: string;
+    minorUnit?: number;
+}
+export declare type InitPaymentOutput = BaseETResponse & {
+    /**
+     * Unique transaction id
+     */
+    transactionId?: string;
+    /**
+     * Payment mode selected by user
+     */
+    paymentMode?: string;
+};

package/lib/typescript/components/executiontasks/payments/processPayment/ProcessPaymentET.d.ts

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

package/lib/typescript/components/executiontasks/payments/processPayment/ProcessPaymentSchema.d.ts

@@ -0,0 +1,33 @@
+/**
+ * Amount to be collected
+ */
+import type { BaseETRequest, BaseETResponse } from '../../../../models/execTasks/ETBaseModels';
+import type { ETAmount } from '../init/InitPaymentSchema';
+/**
+ * Payment mode
+ */
+export declare type ProcessPaymentInput = BaseETRequest & {
+    amount: ETAmount;
+    paymentMode: string;
+    transactionId: string;
+    onSubmitET: (output: ProcessPaymentOutput) => void;
+};
+/**
+ * Amount to be collected (ISO 4217)
+ */
+export declare type ProcessPaymentOutput = BaseETResponse & {
+    /**
+     * Unique transaction id
+     */
+    transactionId: string;
+    tenantTransactionId: string;
+    /**
+     * Amount collected (ISO 4217)
+     */
+    collectedAmount: ETAmount;
+    /**
+     * Payment meta data
+     */
+    paymentMeta?: {};
+    paymentMode: string;
+};

package/lib/typescript/components/executiontasks/pickup/PickpSchema.d.ts

@@ -0,0 +1,25 @@
+/**
+ * Unique identifier for the item
+ */
+import type { BaseETResponse, LineItem } from '../ExecutionTasksIndex';
+import type { BaseETRequest } from '../../../models/execTasks/ETBaseModels';
+/**
+ * Any manual instruction to display for the Operator to work on
+ */
+export declare type Instruction = string;
+export interface PickupRemarks {
+    pickupRemark: string;
+    success: boolean;
+}
+export declare type PickupETInput = BaseETRequest & {
+    items: LineItem[];
+    pickupCount?: number;
+    confirmCustodyExchange?: boolean;
+    onSubmitET(pickupRemark: PickupETOutput): void;
+};
+export declare type PickupETOutput = BaseETResponse & {
+    /**
+     * Remark captured at time of delivery
+     */
+    remark?: string;
+};

package/lib/typescript/components/executiontasks/pickup/PickupET.d.ts

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

package/lib/typescript/components/executiontasks/pickup/SLPickupET.d.ts

@@ -0,0 +1,8 @@
+/// <reference types="react" />
+import type { PickupETInput } from './PickpSchema';
+import type { LineItem } from '../deliver/DeliverETInput';
+export declare const renderItem: ({ item }: {
+    item: LineItem;
+}) => JSX.Element;
+declare const SLPickupET: (props: PickupETInput) => JSX.Element;
+export default SLPickupET;

package/lib/typescript/components/executiontasks/scanner/CScanner.d.ts

@@ -0,0 +1,7 @@
+import React from 'react';
+declare const _default: React.MemoExoticComponent<(props: CScannerProps) => JSX.Element>;
+export default _default;
+export interface CScannerProps {
+    barCodeTypes: any[];
+    onScanned: (value: string) => void;
+}

package/lib/typescript/components/executiontasks/scanner/ScannerSchema.d.ts

@@ -0,0 +1,75 @@
+/**
+ * Type of scan
+ */
+import type { BaseETRequest, BaseETResponse } from '../../../models/execTasks/ETBaseModels';
+import type { Headers, HTTPMethod } from '../httpRequest/HttpRequestETSchema';
+export declare type ScanType = 'BARCODE' | 'QRCODE';
+/**
+ * Mode of scanning
+ */
+export declare type ScanMode = 'SINGLE' | 'MULTI';
+/**
+ * Max limit of items to be scanned in multi-scan mode
+ */
+export declare type MaxScanCount = number;
+/**
+ * Regex to validate scanned strings
+ */
+export declare type ValidationRegex = string;
+export declare type ScannerInput = BaseETRequest & {
+    scanType: ScanType;
+    scanMode: ScanMode;
+    preSelectReasonCode?: boolean;
+    scans?: string[];
+    scanCountLimit?: MaxScanCount;
+    onSubmitET: (scanETOutput: ScannerOutput | ScannedItemData[]) => void;
+    validation?: API | ValidationRegex;
+};
+export interface API {
+    uri: string;
+    timeout?: number;
+    httpMethod: HTTPMethod;
+    headers?: Headers[];
+    responseJsonLogic: object;
+}
+export interface ScanData {
+    /**
+     * Value of scanned item
+     */
+    value: string;
+    /**
+     * Boolean to denote if scan was validate successfully
+     */
+    validated?: boolean;
+    /**
+     * Epoch timestamp for the scan
+     */
+    timestamp: number;
+}
+export interface ScannedItemData {
+    /**
+     * Value of scanned item
+     */
+    value: string;
+    /**
+     * Boolean to denote if scan was validate successfully
+     */
+    validated?: boolean;
+    /**
+     * Epoch timestamp for the scan
+     */
+    timestamp?: number;
+    reasonCode?: string;
+    reasonText?: string;
+    success?: boolean;
+    scanStatus: SCAN_STATUS;
+}
+export declare enum SCAN_STATUS {
+    ACCEPTED = 0,
+    REJECTED = 1,
+    TO_BE_SCANNED = 2,
+    NONE = 3
+}
+export declare type ScannerOutput = BaseETResponse & {
+    scans: ScanData[];
+};

package/lib/typescript/components/executiontasks/scanner/ScannerUtils.d.ts

@@ -0,0 +1,15 @@
+import type { API, ScanData, ScanMode, ScannedItemData, ScannerInput, ScannerOutput } from './ScannerSchema';
+import { SCAN_STATUS } from './ScannerSchema';
+export declare function checkForValidation(data: string, validationRule: API | string | undefined, shipments: string[] | undefined): Promise<any>;
+export declare function isScannedAlready(value: string, scansMap?: Map<string, ScannedItemData>): boolean;
+export declare function getBarCodeTypes(input: ScannerInput): any[];
+export declare function getScannerETOutput(scanList: ScannedItemData[]): Promise<ScannerOutput>;
+export declare function canScanMore(scanMode: ScanMode, size: number, limit?: number): boolean;
+export declare function getScannedList(rtScans?: ScannedItemData[]): ScanData[];
+export declare function getItemsToBeScanned(scansMap?: Map<string, ScannedItemData>): ScannedItemData[];
+export declare enum SCAN_ACTIONS {
+    DELETE = 0,
+    CHANGE_STATUS = 1
+}
+export declare function getScannedItemCount(scannedList: ScannedItemData[] | undefined, status: SCAN_STATUS): number;
+export declare function getScannedItemStatus(scanStatus: SCAN_STATUS): "" | "To be Scanned" | "Completed" | "Rejected";

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

@@ -0,0 +1,3 @@
+/// <reference types="react" />
+declare const DropDownSelector: () => JSX.Element;
+export default DropDownSelector;

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

@@ -0,0 +1,3 @@
+import type { ReasonItem } from './ReasonDropDown';
+import type { ApplicableReasons } from '../../../../models/execTasks/ETBaseModels';
+export declare function getDropDownItems(reasonsList?: ApplicableReasons): Promise<ReasonItem[]>;

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

@@ -0,0 +1,7 @@
+/// <reference types="react" />
+import type { ScanListProps } from './ScanList';
+declare const RTReasonSelection: (props: RTReasonSelectionProps) => JSX.Element;
+export default RTReasonSelection;
+declare type RTReasonSelectionProps = ScanListProps & {
+    showReasonSelectionPage: (show: boolean) => void;
+};

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

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

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

@@ -0,0 +1,14 @@
+import React from 'react';
+declare const _default: React.MemoExoticComponent<(props: DropDownPickerProps) => JSX.Element>;
+export default _default;
+export interface DropDownPickerProps {
+    style: object;
+    items: ReasonItem[];
+    selectedReason?: ReasonItem;
+    onItemChange: (selectedReason: ReasonItem | null) => void;
+}
+export interface ReasonItem {
+    reasonText: string;
+    reasonCode: string;
+    success: boolean;
+}