@open-tender/store 0.1.9 → 0.1.280

package/dist/esm/hooks/usePunch.js

@@ -0,0 +1,122 @@
+import { __awaiter, __generator } from "tslib";
+import { handleRespError } from '@open-tender/utils';
+import { useState, useEffect, useRef, useCallback, useMemo } from 'react';
+import { makePunchMessage } from '../utils';
+var codeErrMsg = 'Employee has been assigned a swipe card. Please use card to punch in / out.';
+var deptErrMsg = "This employee doesn't have any departments. Please contact HR.";
+var usePunch = function (api) {
+    var isAborted = useRef(false);
+    var _a = useState(null), error = _a[0], setError = _a[1];
+    var _b = useState(null), msg = _b[0], setMsg = _b[1];
+    var _c = useState(null), modal = _c[0], setModal = _c[1];
+    useEffect(function () {
+        return function () {
+            isAborted.current = true;
+        };
+    }, []);
+    var reset = useCallback(function () {
+        setError(null);
+        setModal(null);
+        setMsg(null);
+    }, []);
+    var print = useCallback(function (employeeId) { return __awaiter(void 0, void 0, void 0, function () {
+        var err_1, detail;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0:
+                    _a.trys.push([0, 2, , 3]);
+                    return [4 /*yield*/, api.postPrintShiftSummary(employeeId)];
+                case 1:
+                    _a.sent();
+                    return [3 /*break*/, 3];
+                case 2:
+                    err_1 = _a.sent();
+                    if (!isAborted.current) {
+                        detail = handleRespError(err_1).detail;
+                        setError(detail || 'Unknown error');
+                    }
+                    return [3 /*break*/, 3];
+                case 3: return [2 /*return*/];
+            }
+        });
+    }); }, [api]);
+    var send = useCallback(function (data, employee) { return __awaiter(void 0, void 0, void 0, function () {
+        var err_2, detail;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0:
+                    _a.trys.push([0, 2, , 3]);
+                    return [4 /*yield*/, api.postTimePunch(data)];
+                case 1:
+                    _a.sent();
+                    if (!isAborted.current) {
+                        setMsg(makePunchMessage(employee, data.punch_type));
+                    }
+                    return [3 /*break*/, 3];
+                case 2:
+                    err_2 = _a.sent();
+                    if (!isAborted.current) {
+                        detail = handleRespError(err_2).detail;
+                        setError(detail || 'Unknown error');
+                    }
+                    return [3 /*break*/, 3];
+                case 3: return [2 /*return*/];
+            }
+        });
+    }); }, [api]);
+    var submit = useCallback(function (employee, blockPin) {
+        if (employee && employee.code && blockPin) {
+            setError(codeErrMsg);
+        }
+        else if (!employee.punches) {
+            if (!employee.departments.length) {
+                setError(deptErrMsg);
+            }
+            else if (employee.departments.length > 1) {
+                setModal({ type: 'punchDept', args: { employee: employee } });
+            }
+            else {
+                var employee_id = employee.employee_id, departments = employee.departments;
+                var data = {
+                    employee_id: employee_id,
+                    department_id: departments[0].id,
+                    punch_type: 'PUNCH_IN',
+                    tips: '0.00'
+                };
+                send(data, employee);
+            }
+        }
+        else {
+            var lastPunch = employee.punches[employee.punches.length - 1];
+            var employee_id = lastPunch.employee_id, department_id = lastPunch.department_id, punch_type = lastPunch.punch_type;
+            if (punch_type === 'BREAK_OUT') {
+                var data = {
+                    employee_id: employee_id,
+                    department_id: department_id,
+                    punch_type: 'BREAK_IN',
+                    tips: '0.00'
+                };
+                send(data, employee);
+            }
+            else if (punch_type === 'PUNCH_OUT') {
+                if (employee.departments.length > 1) {
+                    setModal({ type: 'punchDept', args: { employee: employee } });
+                }
+                else {
+                    var data = {
+                        employee_id: employee_id,
+                        department_id: employee.departments[0].id,
+                        punch_type: 'PUNCH_IN',
+                        tips: '0.00'
+                    };
+                    send(data, employee);
+                }
+            }
+            else {
+                setModal({ type: 'punchType', args: { employee: employee } });
+            }
+        }
+    }, [send]);
+    return useMemo(function () { return ({ submit: submit, send: send, print: print, error: error, msg: msg, modal: modal, reset: reset }); }, [submit, send, print, error, msg, modal, reset]);
+};
+export default usePunch;

package/dist/esm/hooks/useRefund.d.ts

@@ -0,0 +1,17 @@
+import { Money, OrderSurcharge, Refund, RefundItem } from '@open-tender/types';
+declare const useRefund: (initialState?: {}) => {
+    refund: Refund;
+    resetRefund: () => void;
+    incrementItem: (item: RefundItem) => void;
+    decrementItem: (item: RefundItem) => void;
+    removeSurcharge: (surcharge: OrderSurcharge) => void;
+    addBackSurcharge: (surcharge: OrderSurcharge) => void;
+    removeTip: (tip: Money) => void;
+    addBackTip: () => void;
+    removeShipping: (shipping: Money) => void;
+    addBackShipping: () => void;
+    removeTax: () => void;
+    addBackTax: () => void;
+    refundInFull: () => void;
+};
+export default useRefund;

package/dist/esm/hooks/useRefund.js

@@ -0,0 +1,88 @@
+import { __assign, __spreadArray } from "tslib";
+import { useState } from 'react';
+var emptyState = {
+    full_refund: false,
+    all_taxes: false,
+    items: [],
+    surcharges: [],
+    tip: '0.00',
+    shipping: '0.00'
+};
+var useRefund = function (initialState) {
+    if (initialState === void 0) { initialState = {}; }
+    var _a = useState(__assign(__assign({}, emptyState), initialState)), refund = _a[0], setRefund = _a[1];
+    var resetRefund = function () {
+        setRefund(emptyState);
+    };
+    var refundInFull = function () {
+        setRefund(__assign(__assign({}, emptyState), { full_refund: true }));
+    };
+    var updateItems = function (refundItem) {
+        var otherItems = refund.items.filter(function (i) { return i.item_no !== refundItem.item_no; });
+        var items = refundItem.quantity ? __spreadArray(__spreadArray([], otherItems, true), [refundItem], false) : otherItems;
+        setRefund(__assign(__assign({}, refund), { items: items }));
+    };
+    var incrementItem = function (item) {
+        var quantity = item.quantity, item_no = item.item_no;
+        var currentItem = refund.items.find(function (i) { return i.item_no === item_no; });
+        var newQuantity = currentItem ? currentItem.quantity + 1 : 1;
+        var updatedQuantity = Math.min(newQuantity, quantity);
+        var refundItem = { item_no: item_no, quantity: updatedQuantity };
+        updateItems(refundItem);
+    };
+    var decrementItem = function (item) {
+        var item_no = item.item_no;
+        var currentItem = refund.items.find(function (i) { return i.item_no === item_no; });
+        var newQuantity = currentItem ? currentItem.quantity - 1 : 0;
+        var updatedQuantity = Math.max(newQuantity, 0);
+        var refundItem = { item_no: item_no, quantity: updatedQuantity };
+        updateItems(refundItem);
+    };
+    var removeSurcharge = function (surcharge) {
+        var current = refund.surcharges.find(function (i) { return i.surcharge_id === surcharge.id; });
+        if (current)
+            return;
+        var surcharges = __spreadArray(__spreadArray([], (refund.surcharges || []), true), [
+            { surcharge_id: surcharge.id }
+        ], false);
+        setRefund(__assign(__assign({}, refund), { surcharges: surcharges }));
+    };
+    var addBackSurcharge = function (surcharge) {
+        var surcharges = refund.surcharges.filter(function (i) { return i.surcharge_id !== surcharge.id; });
+        setRefund(__assign(__assign({}, refund), { surcharges: surcharges }));
+    };
+    var removeTip = function (tip) {
+        setRefund(__assign(__assign({}, refund), { tip: tip }));
+    };
+    var addBackTip = function () {
+        setRefund(__assign(__assign({}, refund), { tip: '0.00' }));
+    };
+    var removeShipping = function (shipping) {
+        setRefund(__assign(__assign({}, refund), { shipping: shipping }));
+    };
+    var addBackShipping = function () {
+        setRefund(__assign(__assign({}, refund), { shipping: '0.00' }));
+    };
+    var removeTax = function () {
+        setRefund(__assign(__assign({}, refund), { all_taxes: true }));
+    };
+    var addBackTax = function () {
+        setRefund(__assign(__assign({}, refund), { all_taxes: false }));
+    };
+    return {
+        refund: refund,
+        resetRefund: resetRefund,
+        incrementItem: incrementItem,
+        decrementItem: decrementItem,
+        removeSurcharge: removeSurcharge,
+        addBackSurcharge: addBackSurcharge,
+        removeTip: removeTip,
+        addBackTip: addBackTip,
+        removeShipping: removeShipping,
+        addBackShipping: addBackShipping,
+        removeTax: removeTax,
+        addBackTax: addBackTax,
+        refundInFull: refundInFull
+    };
+};
+export default useRefund;

package/dist/esm/hooks/useResetOrder.d.ts

@@ -0,0 +1,2 @@
+declare const useResetOrder: (callback?: () => void) => () => void;
+export default useResetOrder;

package/dist/esm/hooks/useResetOrder.js

@@ -0,0 +1,19 @@
+import { useAppDispatch } from '../app/hooks';
+import { closeModal, resetCart, resetCustomer, resetCustomerIdentify, resetIdleState, resetMenu, resetPosCheckout, setOrderId } from '../slices';
+var useResetOrder = function (callback) {
+    var dispatch = useAppDispatch();
+    var resetOrder = function () {
+        dispatch(resetIdleState());
+        dispatch(resetPosCheckout());
+        dispatch(setOrderId(null));
+        dispatch(resetCart());
+        dispatch(resetCustomerIdentify());
+        dispatch(resetCustomer());
+        dispatch(resetMenu());
+        dispatch(closeModal());
+        if (callback)
+            callback();
+    };
+    return resetOrder;
+};
+export default useResetOrder;

package/dist/esm/hooks/useSignInQr.d.ts

@@ -0,0 +1,10 @@
+import { ScanListener } from './types';
+declare const useSignInQr: (listener: ScanListener, cameraScanner: ScanListener, type?: string, close?: () => void, callback?: () => void) => {
+    handlers: {
+        close: () => void;
+        retry: () => void;
+    };
+    errMsg: string | null;
+    scan: import("./types").BarcodeScannerMethod | undefined;
+};
+export default useSignInQr;

package/dist/esm/hooks/useSignInQr.js

@@ -0,0 +1,53 @@
+import { handleRespError } from '@open-tender/utils';
+import { useEffect, useState } from 'react';
+import { useAppDispatch, useAppSelector } from '../app/hooks';
+import { fetchCustomerIdentify, selectApi, selectCustomerIdentify } from '../slices';
+import { useBarcodeScanner } from './useBarcodeScanner';
+var useSignInQr = function (listener, cameraScanner, type, close, callback) {
+    var dispatch = useAppDispatch();
+    var _a = useState(false), submitted = _a[0], setSubmitted = _a[1];
+    var _b = useState(false), hasRead = _b[0], setHasRead = _b[1];
+    var _c = useState(null), errMsg = _c[0], setErrMsg = _c[1];
+    var api = useAppSelector(selectApi);
+    var scan = useBarcodeScanner(listener, cameraScanner, type, api, close);
+    var _d = useAppSelector(selectCustomerIdentify), customer = _d.data, loading = _d.loading, error = _d.error;
+    var isLoading = loading === 'pending';
+    var cancel = function () {
+        if (!(scan === null || scan === void 0 ? void 0 : scan.code))
+            scan === null || scan === void 0 ? void 0 : scan.cancel();
+        if (close)
+            close();
+    };
+    var retry = function () {
+        (scan === null || scan === void 0 ? void 0 : scan.reset) && scan.reset();
+        setHasRead(false);
+        setErrMsg(null);
+    };
+    useEffect(function () {
+        if (scan === null || scan === void 0 ? void 0 : scan.error) {
+            setErrMsg(scan.error);
+        }
+        else if ((scan === null || scan === void 0 ? void 0 : scan.code) && !customer) {
+            dispatch(fetchCustomerIdentify({ qr_code: scan.code }));
+            setSubmitted(true);
+        }
+        else if (!hasRead) {
+            setHasRead(true);
+            scan === null || scan === void 0 ? void 0 : scan.read();
+        }
+    }, [dispatch, scan, close, customer, hasRead]);
+    var handlers = { close: cancel, retry: retry };
+    useEffect(function () {
+        if (submitted && !isLoading) {
+            if (error) {
+                var detail = handleRespError(error).detail;
+                setErrMsg(detail || 'Something went wrong');
+            }
+            else {
+                callback ? callback() : close ? close() : null;
+            }
+        }
+    }, [submitted, isLoading, error, close, callback]);
+    return { handlers: handlers, errMsg: errMsg, scan: scan };
+};
+export default useSignInQr;

package/dist/esm/index.d.ts

@@ -1,5 +1,9 @@
 import { appReducer } from './app/store';
+import tempConfig from './config';
+import { PosAPI } from './services';
+export * from './components';
+export * from './hooks';
 export * from './slices';
-export * from './types';
 export * from './utils';
-export { appReducer };
+export * from './middlewares';
+export { appReducer, tempConfig, PosAPI };

package/dist/esm/index.js

@@ -1,5 +1,9 @@
 import { appReducer } from './app/store';
+import tempConfig from './config';
+import { PosAPI } from './services';
+export * from './components';
+export * from './hooks';
 export * from './slices';
-export * from './types';
 export * from './utils';
-export { appReducer };
+export * from './middlewares';
+export { appReducer, tempConfig, PosAPI };

package/dist/esm/middlewares/idleMiddleware.d.ts

@@ -0,0 +1,2 @@
+import { Middleware } from '@reduxjs/toolkit';
+export declare const idleMiddleware: Middleware;

package/dist/esm/middlewares/idleMiddleware.js

@@ -0,0 +1,22 @@
+import { setIsIdle } from '../slices';
+var DEFAULT_PAGE_TIMEOUT = 60;
+var idleTimeout = null;
+export var idleMiddleware = function (store) { return function (next) { return function (action) {
+    var _a;
+    var result = next(action);
+    if (idleTimeout) {
+        clearTimeout(idleTimeout);
+    }
+    var state = store.getState();
+    var hasOrder = state.idle.hasOrder;
+    if (hasOrder) {
+        var pageTimeout = (_a = state.kiosk.store) === null || _a === void 0 ? void 0 : _a.page_timeout;
+        if (!pageTimeout)
+            return;
+        var timeout = pageTimeout > 0 ? pageTimeout : DEFAULT_PAGE_TIMEOUT;
+        idleTimeout = setTimeout(function () {
+            store.dispatch(setIsIdle(true));
+        }, timeout * 1000);
+    }
+    return result;
+}; }; };

package/dist/esm/middlewares/index.d.ts

@@ -0,0 +1 @@
+export * from './idleMiddleware';

package/dist/esm/middlewares/index.js

@@ -0,0 +1 @@
+export * from './idleMiddleware';

package/dist/esm/services/api.d.ts

@@ -1,71 +1,86 @@
-import { Arrivals, CashEvent, CashSummary, Config, CustomerCheckout, CustomerIdentifier, DeviceRead, Discount, Discounts, Employee, Employees, EntityType, ErrorAlert, ErrorAlerts, FetchOrdersAPIArgs, GiftCardBalance, GiftCardCredit, InternalSettings, ItemTypes, LevelUp, Menu, MenuPages, OfflineAuths, OfflineAuthsResult, Order, OrderCreate, Orders, OrderTender, OrderType, OrderUpdate, Punch, Refund, RequestedAt, RevenueCenter, SelectOptions, ServiceType, Settings, Store, Surcharges, Taxes, Tender, TicketStatusUpdate, TicketUpdate } from '../types';
-interface ConfigAPI {
+import { Arrivals, CheckoutTender, CustomerEndpoints, CustomerIdentifier, CustomerIdentify, Discount, Discounts, ItemTypes, Menu, Order, Orders, OrderCreatePos, OrderTender, OrderUpdate, OrderType, RequestedAt, RevenueCenter, SelectOptions, ServiceType, TicketUpdate, TicketsUpdate, TicketStatusUpdate, EntityType, KioskConfig, Store, Settings, InternalSettings, GiftCardCredit, GiftCardBalance, Employee, Punch, Employees, CashEvent, CashSummary, ErrorAlerts, ErrorAlert, OfflineAuths, OfflineAuthsResult, MenuColors, MenuPages, Surcharges, Taxes, CheckoutTenderPos, Refund, DeviceRead, OrderCreateSendReceipt, Tags, Allergens } from '@open-tender/types';
+import { OrdersParams } from '../slices';
+export interface InitAPI {
     apiUrl: string;
+    posTerminalId?: number;
+    kdsTerminalId?: number;
 }
 declare class PosAPI {
     apiUrl: string;
-    constructor(config: ConfigAPI);
-    request: <T>(endpoint: string, method?: string, data?: any) => Promise<T | null | undefined>;
-    post(endpoint: string, data: Record<string, unknown>): Promise<Record<string, unknown> | null | undefined>;
-    getConfig(): Promise<Config | null | undefined>;
-    getStore(): Promise<Store | null | undefined>;
-    getSelectOptions(): Promise<SelectOptions | null | undefined>;
-    getItemTypes(): Promise<ItemTypes | null | undefined>;
-    getLevelUpSettings(): Promise<LevelUp | null | undefined>;
-    getCardRead(): Promise<DeviceRead | null | undefined>;
-    postCardCancel(): Promise<null | undefined>;
-    getBarcodeRead(): Promise<DeviceRead | null | undefined>;
-    postBarcodeCancel(): Promise<null | undefined>;
-    postSettings(entityType: EntityType): Promise<Settings | null | undefined>;
-    getInternalSettings(): Promise<InternalSettings | null | undefined>;
-    postInternalSettings(data: InternalSettings): Promise<InternalSettings | null | undefined>;
-    postGiftCardCredit(data: GiftCardCredit, checkOnly: boolean): Promise<GiftCardCredit | null | undefined>;
-    getGiftCardBalance(code: string | null, cardNumber?: string): Promise<GiftCardBalance | null | undefined>;
-    getEmployee(identifier: string | number): Promise<Employee | null | undefined>;
-    getCashier(): Promise<Employee | null | undefined>;
-    postCardAssign(employeeId: number, code: string): Promise<null | undefined>;
-    postCardUnassign(code: string): Promise<null | undefined>;
-    postTimePunch(data: Punch): Promise<null | undefined>;
-    getTimePunchesReport(businessDate: string, employeeId: number): Promise<Employees | null | undefined>;
-    postPrintShiftSummary(employeeId: number): Promise<null | undefined>;
-    postCashEvent(data: CashEvent): Promise<null | undefined>;
-    getCashSummary(employeeId: number): Promise<CashSummary | null | undefined>;
-    postPrintCashSummary(employeeId: number): Promise<null | undefined>;
-    getAlerts(): Promise<ErrorAlerts | null | undefined>;
-    getAlert(alertId: number): Promise<ErrorAlert | null | undefined>;
-    putAlert(alertId: number, data: ErrorAlert): Promise<ErrorAlert | null | undefined>;
-    deleteAlert(alertId: number): Promise<null | undefined>;
-    getOfflineAuths(): Promise<OfflineAuths | null | undefined>;
-    postOfflineAuths(): Promise<OfflineAuthsResult | null | undefined>;
-    getMenu(revenueCenterId: number, serviceType: ServiceType, requestedAt: RequestedAt): Promise<Menu | null | undefined>;
-    getMenuPages(): Promise<MenuPages | null | undefined>;
-    getSurcharges(serviceType: ServiceType): Promise<Surcharges | null | undefined>;
-    getDiscounts(serviceType: ServiceType, orderType: OrderType): Promise<Discounts | null | undefined>;
-    getDiscount(name: string): Promise<Discount | null | undefined>;
-    getDiscountViaQRCode(code: string): Promise<Discount | null | undefined>;
-    getTaxes(serviceType: ServiceType, orderType: OrderType): Promise<Taxes | null | undefined>;
-    getRevenueCenter(revenueCenterId: number): Promise<RevenueCenter | null | undefined>;
-    postOpenCashDrawer(): Promise<null | undefined>;
-    postTender(orderId: string, data: Tender): Promise<OrderTender | null | undefined>;
-    patchTender(orderId: string, index: number, data: Tender): Promise<OrderTender | null | undefined>;
-    postTenderVoid(orderId: string, index: number): Promise<OrderTender | null | undefined>;
-    postChipDNATender(orderId: string, data: Tender): Promise<unknown>;
-    postChipDNACancel(): Promise<null | undefined>;
-    postChipDNATmsUpdate(): Promise<null | undefined>;
-    postIdentifyCustomer(data: CustomerIdentifier): Promise<CustomerCheckout | null | undefined>;
-    postOrderValidate(order: OrderCreate): Promise<Order | null | undefined>;
-    postOrder(order: OrderCreate): Promise<Order | null | undefined>;
-    deleteOrder(order: OrderCreate): Promise<Order | null | undefined>;
-    getOrders(args: FetchOrdersAPIArgs): Promise<Orders | null | undefined>;
-    patchOrder(orderId: string, data: OrderUpdate): Promise<Order | null | undefined>;
-    postReceipt(orderId: string): Promise<Order | null | undefined>;
-    postTicketsPrint(orderId: string, data: OrderUpdate): Promise<Order | null | undefined>;
-    postTicketsReset(orderId: string): Promise<Order | null | undefined>;
-    postTicketPrint(orderId: string, ticketNo: number, data?: TicketUpdate): Promise<Order | null | undefined>;
-    postTicketStatus(orderId: string, ticketNo: number, status: TicketStatusUpdate): Promise<Order | null | undefined>;
-    getArrivals(): Promise<Arrivals | null | undefined>;
-    postAcknowledgeArrival(orderId: string): Promise<Order | null | undefined>;
-    postRefundValidate(orderId: string, refund: Refund): Promise<Order | null | undefined>;
-    postRefund(orderId: string, refund: Refund): Promise<Order | null | undefined>;
+    posTerminalId?: number;
+    kdsTerminalId?: number;
+    constructor(init: InitAPI);
+    request: <T>(endpoint: string, method?: string, data?: any) => Promise<T>;
+    post(endpoint: string, data: Record<string, unknown>): Promise<Record<string, unknown>>;
+    getKioskConfig(): Promise<KioskConfig>;
+    getStore(): Promise<Store>;
+    getSelectOptions(): Promise<SelectOptions>;
+    getItemTypes(): Promise<ItemTypes>;
+    getCardRead(): Promise<DeviceRead>;
+    postCardCancel(): Promise<null>;
+    getBarcodeRead(): Promise<DeviceRead>;
+    postBarcodeCancel(): Promise<null>;
+    getSettings<T>(posSettingType: EntityType): Promise<T>;
+    postSettings(posSettingType?: EntityType): Promise<Settings>;
+    getInternalSettings(): Promise<InternalSettings>;
+    postInternalSettings(data: InternalSettings): Promise<InternalSettings>;
+    postGiftCardCredit(data: GiftCardCredit, checkOnly?: boolean): Promise<GiftCardCredit>;
+    getGiftCardBalance(code: string | null, cardNumber?: string): Promise<GiftCardBalance>;
+    getEmployee(identifier: string | number): Promise<Employee>;
+    getCashier(): Promise<Employee>;
+    postCardAssign(employeeId: number, code: string): Promise<null>;
+    postCardUnassign(code: string): Promise<null>;
+    postTimePunch(data: Punch): Promise<null>;
+    getTimePunchesReport(businessDate?: string, employeeId?: number): Promise<Employees>;
+    postPrintShiftSummary(employeeId: number): Promise<null>;
+    postCashEvent(data: CashEvent): Promise<void>;
+    getCashSummary(employeeId: number): Promise<CashSummary>;
+    postPrintCashSummary(employeeId: number): Promise<null>;
+    getAlerts(): Promise<ErrorAlerts>;
+    getAlert(alertId: number): Promise<ErrorAlert>;
+    putAlert(alertId: number, data: ErrorAlert): Promise<ErrorAlert>;
+    deleteAlert(alertId: number): Promise<null>;
+    getOfflineAuths(): Promise<OfflineAuths>;
+    postOfflineAuths(): Promise<OfflineAuthsResult>;
+    getMenu(revenueCenterId: number, serviceType: ServiceType, requestedAt: RequestedAt): Promise<Menu>;
+    getMenuColors(): Promise<MenuColors>;
+    getMenuPages(): Promise<MenuPages>;
+    getDeals(): Promise<Discounts>;
+    getSurcharges(serviceType: ServiceType): Promise<Surcharges>;
+    getDiscounts(serviceType: ServiceType, orderType: OrderType): Promise<Discounts>;
+    getDiscount(name: string): Promise<Discount>;
+    getDiscountViaQRCode(code: string): Promise<Discount>;
+    getTaxes(serviceType: ServiceType, orderType: OrderType): Promise<Taxes>;
+    getRevenueCenter(revenueCenterId: number): Promise<RevenueCenter>;
+    postOpenCashDrawer(): Promise<null>;
+    postTender(orderId: string, data: CheckoutTenderPos): Promise<OrderTender>;
+    patchTender(orderId: string, index: number, data: CheckoutTenderPos): Promise<OrderTender>;
+    postTenderVoid(orderId: string, index: number): Promise<OrderTender>;
+    postCreditTender(orderId: string, data: CheckoutTenderPos): Promise<unknown>;
+    postChipDNATender(orderId: string, data: CheckoutTender): Promise<unknown>;
+    postChipDNACancel(): Promise<null>;
+    postChipDNATmsUpdate(): Promise<null>;
+    postIdentifyCustomer(data: CustomerIdentifier): Promise<CustomerIdentify>;
+    postSendReceipt(orderUuid: string, data: OrderCreateSendReceipt): Promise<void>;
+    getCustomer(customerId: number, endpoints: CustomerEndpoints): Promise<any>;
+    postOrderValidate(order: OrderCreatePos): Promise<Order>;
+    postOrder(order: OrderCreatePos): Promise<Order>;
+    deleteOrder(order: OrderCreatePos): Promise<Order>;
+    getOrders(args: OrdersParams): Promise<Orders>;
+    patchOrder(orderId: string, data: OrderUpdate): Promise<Order>;
+    postReceipt(orderId: string): Promise<Order>;
+    putTicketsStatus(orderId: string, data: TicketsUpdate): Promise<Order>;
+    postTicketsPrint(orderId: string, data?: TicketsUpdate): Promise<Order>;
+    postTicketsReset(orderId: string): Promise<Order>;
+    putTicketStatus(orderId: string, ticketNo: number, data?: TicketUpdate): Promise<Order>;
+    postTicketPrint(orderId: string, ticketNo: number, data?: TicketUpdate): Promise<Order>;
+    postTicketStatus(orderId: string, ticketNo: number, status: TicketStatusUpdate): Promise<Order>;
+    getArrivals(): Promise<Arrivals>;
+    postAcknowledgeArrival(orderId: string): Promise<Order>;
+    postRefundValidate(orderId: string, refund: Refund): Promise<Order>;
+    postRefund(orderId: string, refund: Refund): Promise<Order>;
+    getTags(): Promise<Tags>;
+    getAllergens(): Promise<Allergens>;
+    testPrint(): Promise<boolean>;
 }
 export default PosAPI;