@open-tender/store 0.3.96 → 0.4.1

package/dist/esm/app/store.d.ts

@@ -14,7 +14,6 @@ export declare const appReducer: import("redux").Reducer<import("redux").Combine
     notifications: import("..").Notifications;
     offlineAuths: import("../slices").OfflineAuthsState;
     order: import("../slices").OrderState;
-    orders: import("../slices").OrdersState;
     pos: import("../slices").PosState;
     punches: import("../slices").PunchesState;
     refund: import("../slices").RefundState;
@@ -39,7 +38,6 @@ declare const store: import("@reduxjs/toolkit").EnhancedStore<import("redux").Co
     notifications: import("..").Notifications;
     offlineAuths: import("../slices").OfflineAuthsState;
     order: import("../slices").OrderState;
-    orders: import("../slices").OrdersState;
     pos: import("../slices").PosState;
     punches: import("../slices").PunchesState;
     refund: import("../slices").RefundState;
@@ -62,7 +60,6 @@ declare const store: import("@reduxjs/toolkit").EnhancedStore<import("redux").Co
     notifications: import("..").Notifications;
     offlineAuths: import("../slices").OfflineAuthsState;
     order: import("../slices").OrderState;
-    orders: import("../slices").OrdersState;
     pos: import("../slices").PosState;
     punches: import("../slices").PunchesState;
     refund: import("../slices").RefundState;

package/dist/esm/app/store.js

@@ -1,5 +1,5 @@
 import { combineReducers, configureStore } from '@reduxjs/toolkit';
-import { alertsReducer, arrivalsReducer, checkoutReducer, completedOrdersReducer, configReducer, discountsReducer, errorAlertsReducer, kdsReducer, menuReducer, menuPagesReducer, modalReducer, notificationsReducer, offlineAuthsReducer, orderReducer, ordersReducer, posReducer, punchesReducer, refundReducer, settingsReducer, sidebarReducer, surchargesReducer, taxesReducer } from '../slices';
+import { alertsReducer, arrivalsReducer, checkoutReducer, completedOrdersReducer, configReducer, discountsReducer, errorAlertsReducer, kdsReducer, menuReducer, menuPagesReducer, modalReducer, notificationsReducer, offlineAuthsReducer, orderReducer, posReducer, punchesReducer, refundReducer, settingsReducer, sidebarReducer, surchargesReducer, taxesReducer } from '../slices';
 export var appReducer = combineReducers({
     alerts: alertsReducer,
     arrivals: arrivalsReducer,
@@ -15,7 +15,6 @@ export var appReducer = combineReducers({
     notifications: notificationsReducer,
     offlineAuths: offlineAuthsReducer,
     order: orderReducer,
-    orders: ordersReducer,
     pos: posReducer,
     punches: punchesReducer,
     refund: refundReducer,

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

@@ -1,2 +1,9 @@
+import useBarcode from './useBarcode';
 import useBuilder from './useBuilder';
-export { useBuilder };
+import useCardSwipe from './useCardSwipe';
+import useEmployee from './useEmployee';
+import useGiftCardBalance from './useGiftCardBalance';
+import usePrevious from './usePrevious';
+import usePunch from './usePunch';
+import useRefund from './useRefund';
+export { useBarcode, useBuilder, useCardSwipe, useEmployee, useGiftCardBalance, usePrevious, usePunch, useRefund };

package/dist/esm/hooks/index.js

@@ -1,2 +1,9 @@
+import useBarcode from './useBarcode';
 import useBuilder from './useBuilder';
-export { useBuilder };
+import useCardSwipe from './useCardSwipe';
+import useEmployee from './useEmployee';
+import useGiftCardBalance from './useGiftCardBalance';
+import usePrevious from './usePrevious';
+import usePunch from './usePunch';
+import useRefund from './useRefund';
+export { useBarcode, useBuilder, useCardSwipe, useEmployee, useGiftCardBalance, usePrevious, usePunch, useRefund };

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

@@ -0,0 +1,7 @@
+declare const useBarcode: (api: any) => {
+    code: string | null;
+    error: string | null;
+    read: () => Promise<void>;
+    cancel: () => Promise<void>;
+};
+export default useBarcode;

package/dist/esm/hooks/useBarcode.js

@@ -0,0 +1,60 @@
+import { __awaiter, __generator } from "tslib";
+import { useCallback, useEffect, useMemo, useRef, useState } from 'react';
+import { handleRespError } from '../utils';
+var useBarcode = function (api) {
+    var isAborted = useRef(false);
+    var _a = useState(null), code = _a[0], setCode = _a[1];
+    var _b = useState(null), error = _b[0], setError = _b[1];
+    useEffect(function () {
+        return function () {
+            isAborted.current = true;
+        };
+    }, []);
+    var read = useCallback(function () { return __awaiter(void 0, void 0, void 0, function () {
+        var data, err_1, detail;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0:
+                    _a.trys.push([0, 2, , 3]);
+                    return [4 /*yield*/, api.getBarcodeRead()];
+                case 1:
+                    data = (_a.sent()).data;
+                    if (!isAborted.current) {
+                        setCode(data);
+                    }
+                    return [3 /*break*/, 3];
+                case 2:
+                    err_1 = _a.sent();
+                    if (!isAborted.current) {
+                        detail = handleRespError(err_1).detail;
+                        setError(detail);
+                    }
+                    return [3 /*break*/, 3];
+                case 3: return [2 /*return*/];
+            }
+        });
+    }); }, [api]);
+    var cancel = useCallback(function () { 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.postBarcodeCancel()];
+                case 1:
+                    _a.sent();
+                    return [3 /*break*/, 3];
+                case 2:
+                    err_2 = _a.sent();
+                    if (!isAborted.current) {
+                        detail = handleRespError(err_2).detail;
+                        setError(detail);
+                    }
+                    return [3 /*break*/, 3];
+                case 3: return [2 /*return*/];
+            }
+        });
+    }); }, [api]);
+    return useMemo(function () { return ({ code: code, error: error, read: read, cancel: cancel }); }, [code, error, read, cancel]);
+};
+export default useBarcode;

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

@@ -0,0 +1,7 @@
+declare const useCardSwipe: (api: any, parse?: boolean) => {
+    code: string | null;
+    error: string | null;
+    read: () => Promise<void>;
+    cancel: () => Promise<void>;
+};
+export default useCardSwipe;

package/dist/esm/hooks/useCardSwipe.js

@@ -0,0 +1,76 @@
+import { __awaiter, __generator } from "tslib";
+import { useState, useEffect, useCallback, useRef, useMemo } from 'react';
+import { handleRespError } from '../utils';
+var parseSwipeCard = function (data) {
+    try {
+        var parts = data.split('?');
+        var code = parts[0].slice(1);
+        return code.length > 36 ? null : code;
+    }
+    catch (err) {
+        return null;
+    }
+};
+var useCardSwipe = function (api, parse) {
+    if (parse === void 0) { parse = true; }
+    var isAborted = useRef(false);
+    var _a = useState(null), code = _a[0], setCode = _a[1];
+    var _b = useState(null), error = _b[0], setError = _b[1];
+    useEffect(function () {
+        return function () {
+            isAborted.current = true;
+        };
+    }, []);
+    var read = useCallback(function () { return __awaiter(void 0, void 0, void 0, function () {
+        var data, err_1, detail;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0:
+                    _a.trys.push([0, 2, , 3]);
+                    return [4 /*yield*/, api.getCardRead()];
+                case 1:
+                    data = (_a.sent()).data;
+                    if (parse)
+                        data = parseSwipeCard(data);
+                    data ? setCode(data) : setError('Could not read card. Please try again.');
+                    if (!isAborted.current) {
+                        data
+                            ? setCode(data)
+                            : setError('Could not read card. Please try again.');
+                    }
+                    return [3 /*break*/, 3];
+                case 2:
+                    err_1 = _a.sent();
+                    if (!isAborted.current) {
+                        detail = handleRespError(err_1).detail;
+                        setError(detail);
+                    }
+                    return [3 /*break*/, 3];
+                case 3: return [2 /*return*/];
+            }
+        });
+    }); }, [api, parse]);
+    var cancel = useCallback(function () { 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.postCardCancel()];
+                case 1:
+                    _a.sent();
+                    return [3 /*break*/, 3];
+                case 2:
+                    err_2 = _a.sent();
+                    if (!isAborted.current) {
+                        detail = handleRespError(err_2).detail;
+                        setError(detail);
+                    }
+                    return [3 /*break*/, 3];
+                case 3: return [2 /*return*/];
+            }
+        });
+    }); }, [api]);
+    return useMemo(function () { return ({ code: code, error: error, read: read, cancel: cancel }); }, [code, error, read, cancel]);
+};
+export default useCardSwipe;

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

@@ -0,0 +1,8 @@
+import { Employee } from '../types';
+declare const useEmployee: (api: any) => {
+    employee: Employee | null;
+    error: string | null;
+    fetch: (identifier: string | number, withPunches?: boolean) => Promise<void>;
+    reset: () => void;
+};
+export default useEmployee;

package/dist/esm/hooks/useEmployee.js

@@ -0,0 +1,58 @@
+import { __awaiter, __generator } from "tslib";
+import { useState, useEffect, useRef, useCallback, useMemo } from 'react';
+import { handleRespError } from '../utils';
+var useEmployee = function (api) {
+    var isAborted = useRef(false);
+    var _a = useState(null), employee = _a[0], setEmployee = _a[1];
+    var _b = useState(null), error = _b[0], setError = _b[1];
+    useEffect(function () {
+        return function () {
+            isAborted.current = true;
+        };
+    }, []);
+    var fetch = useCallback(function (identifier, withPunches) {
+        if (withPunches === void 0) { withPunches = false; }
+        return __awaiter(void 0, void 0, void 0, function () {
+            var employee_1, employee_id, response, err_1, detail;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        _a.trys.push([0, 4, , 5]);
+                        return [4 /*yield*/, api.getEmployee(identifier)];
+                    case 1:
+                        employee_1 = _a.sent();
+                        if (!withPunches) return [3 /*break*/, 3];
+                        employee_id = employee_1.employee_id;
+                        return [4 /*yield*/, api.getTimePunchesReport(null, employee_id)];
+                    case 2:
+                        response = _a.sent();
+                        if (response.length)
+                            employee_1 = response[0];
+                        _a.label = 3;
+                    case 3:
+                        if (!isAborted.current) {
+                            setEmployee(employee_1);
+                        }
+                        return [3 /*break*/, 5];
+                    case 4:
+                        err_1 = _a.sent();
+                        if (!isAborted.current) {
+                            detail = handleRespError(err_1).detail;
+                            if (detail.includes('does not exist')) {
+                                detail = 'Employee not found. Please try again.';
+                            }
+                            setError(detail);
+                        }
+                        return [3 /*break*/, 5];
+                    case 5: return [2 /*return*/];
+                }
+            });
+        });
+    }, [api]);
+    var reset = useCallback(function () {
+        setEmployee(null);
+        setError(null);
+    }, []);
+    return useMemo(function () { return ({ employee: employee, error: error, fetch: fetch, reset: reset }); }, [employee, error, fetch, reset]);
+};
+export default useEmployee;

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

@@ -0,0 +1,9 @@
+import { GiftCardBalance } from '../types';
+declare const useGiftCardBalance: (api: any) => {
+    giftCard: GiftCardBalance | null;
+    loading: string;
+    error: string | null;
+    fetch: (code: string) => Promise<void>;
+    reset: () => void;
+};
+export default useGiftCardBalance;

package/dist/esm/hooks/useGiftCardBalance.js

@@ -0,0 +1,50 @@
+import { __awaiter, __generator } from "tslib";
+import { useState, useEffect, useRef, useCallback, useMemo } from 'react';
+import { handleRespError } from '../utils';
+var useGiftCardBalance = function (api) {
+    var isAborted = useRef(false);
+    var _a = useState(null), giftCard = _a[0], setGiftCard = _a[1];
+    var _b = useState('idle'), loading = _b[0], setLoading = _b[1];
+    var _c = useState(null), error = _c[0], setError = _c[1];
+    useEffect(function () {
+        return function () {
+            isAborted.current = true;
+        };
+    }, []);
+    var fetch = useCallback(function (code) { return __awaiter(void 0, void 0, void 0, function () {
+        var giftCard_1, err_1, detail;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0:
+                    setLoading('pending');
+                    _a.label = 1;
+                case 1:
+                    _a.trys.push([1, 3, , 4]);
+                    return [4 /*yield*/, api.getGiftCardBalance(code)];
+                case 2:
+                    giftCard_1 = _a.sent();
+                    if (!isAborted.current) {
+                        setGiftCard(giftCard_1);
+                    }
+                    return [3 /*break*/, 4];
+                case 3:
+                    err_1 = _a.sent();
+                    if (!isAborted.current) {
+                        detail = handleRespError(err_1).detail;
+                        setError(detail);
+                    }
+                    return [3 /*break*/, 4];
+                case 4:
+                    setLoading('idle');
+                    return [2 /*return*/];
+            }
+        });
+    }); }, [api]);
+    var reset = useCallback(function () {
+        setGiftCard(null);
+        setLoading('idle');
+        setError(null);
+    }, []);
+    return useMemo(function () { return ({ giftCard: giftCard, loading: loading, error: error, fetch: fetch, reset: reset }); }, [giftCard, loading, error, fetch, reset]);
+};
+export default useGiftCardBalance;

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

@@ -0,0 +1,2 @@
+declare const usePrevious: (value: any) => undefined;
+export default usePrevious;

package/dist/esm/hooks/usePrevious.js

@@ -0,0 +1,9 @@
+import { useEffect, useRef } from 'react';
+var usePrevious = function (value) {
+    var ref = useRef();
+    useEffect(function () {
+        ref.current = value;
+    });
+    return ref.current;
+};
+export default usePrevious;

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

@@ -0,0 +1,12 @@
+import { ModalState } from '../slices';
+import { Employee, Punch } from '../types';
+declare const usePunch: (api: any) => {
+    submit: (employee: Employee, blockPin: boolean) => void;
+    send: (data: Punch, employee: Employee) => Promise<void>;
+    print: (employeeId: number) => Promise<void>;
+    error: string | null;
+    msg: string | null;
+    modal: ModalState | null;
+    reset: () => void;
+};
+export default usePunch;

package/dist/esm/hooks/usePunch.js

@@ -0,0 +1,121 @@
+import { __awaiter, __generator } from "tslib";
+import { useState, useEffect, useRef, useCallback, useMemo } from 'react';
+import { handleRespError, 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);
+                    }
+                    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);
+                    }
+                    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 '../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/slices/index.d.ts

@@ -12,7 +12,6 @@ export * from './modal';
 export * from './notifications';
 export * from './offlineAuths';
 export * from './order';
-export * from './orders';
 export * from './pos';
 export * from './punches';
 export * from './refund';

package/dist/esm/slices/index.js

@@ -12,7 +12,6 @@ export * from './modal';
 export * from './notifications';
 export * from './offlineAuths';
 export * from './order';
-export * from './orders';
 export * from './pos';
 export * from './punches';
 export * from './refund';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@open-tender/store",
-  "version": "0.3.96",
+  "version": "0.4.1",
   "description": "A library of hooks, reducers, utility functions, and types for use with Open Tender applications that utilize our in-store POS API",
   "main": "./dist/cjs/index.js",
   "module": "./dist/esm/index.js",

package/dist/cjs/slices/orders.d.ts

@@ -1,21 +0,0 @@
-import { FetchOrdersArgs, Orders, RequestError, RequestStatus } from '../types';
-import { AppState } from '../app';
-export interface OrdersState {
-    entities: Orders;
-    loading: RequestStatus;
-    error: RequestError;
-    current: any;
-    refund: any;
-}
-export declare enum OrdersActionType {
-    FetchOrders = "orders/fetchOrders"
-}
-export declare const fetchOrders: import("@reduxjs/toolkit").AsyncThunk<Orders, FetchOrdersArgs, {
-    state: AppState;
-    rejectValue: RequestError;
-}>;
-export declare const resetOrders: import("@reduxjs/toolkit").ActionCreatorWithoutPayload<string>, setOrdersCurrent: import("@reduxjs/toolkit").ActionCreatorWithPayload<any, string>, setOrdersRefund: import("@reduxjs/toolkit").ActionCreatorWithPayload<any, string>;
-export declare const selectOrders: (state: AppState) => OrdersState;
-export declare const selectOrdersCurrent: (state: AppState) => any;
-export declare const selectOrdersRefund: (state: AppState) => any;
-export declare const ordersReducer: import("redux").Reducer<OrdersState, import("redux").AnyAction>;