@open-tender/store 0.1.9 → 0.1.280

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

@@ -1,4 +1,4 @@
-import { Employees, RequestError, RequestStatus } from '../types';
+import { Employees, RequestError, RequestStatus } from '@open-tender/types';
 import { AppState } from '../app';
 export interface PunchesState {
     businessDate: string | null;
@@ -12,8 +12,14 @@ export declare enum PunchesActionType {
 export declare const fetchPunches: import("@reduxjs/toolkit").AsyncThunk<Employees, string, {
     state: AppState;
     rejectValue: RequestError;
+    dispatch?: import("redux").Dispatch<import("redux").UnknownAction> | undefined;
+    extra?: unknown;
+    serializedErrorType?: unknown;
+    pendingMeta?: unknown;
+    fulfilledMeta?: unknown;
+    rejectedMeta?: unknown;
 }>;
-export declare const resetPunches: import("@reduxjs/toolkit").ActionCreatorWithoutPayload<string>, setPunchesBusinessDate: import("@reduxjs/toolkit").ActionCreatorWithPayload<any, string>;
+export declare const resetPunches: import("@reduxjs/toolkit").ActionCreatorWithoutPayload<"punches/resetPunches">, setPunchesBusinessDate: import("@reduxjs/toolkit").ActionCreatorWithPayload<any, "punches/setPunchesBusinessDate">;
 export declare const selectPunches: (state: AppState) => PunchesState;
 export declare const selectPunchesBusinessDate: (state: AppState) => string | null;
-export declare const punchesReducer: import("redux").Reducer<PunchesState, import("redux").AnyAction>;
+export declare const punchesReducer: import("redux").Reducer<PunchesState>;

package/dist/cjs/slices/punches.js

@@ -14,26 +14,24 @@ var initialState = {
 var PunchesActionType;
 (function (PunchesActionType) {
     PunchesActionType["FetchPunches"] = "punches/getPunches";
-})(PunchesActionType = exports.PunchesActionType || (exports.PunchesActionType = {}));
-exports.fetchPunches = (0, toolkit_1.createAsyncThunk)(PunchesActionType.FetchPunches, function (businessDate, _a) {
-    var getState = _a.getState, rejectWithValue = _a.rejectWithValue;
-    return tslib_1.__awaiter(void 0, void 0, void 0, function () {
-        var api, err_1;
-        return tslib_1.__generator(this, function (_b) {
-            switch (_b.label) {
-                case 0:
-                    _b.trys.push([0, 2, , 3]);
-                    api = getState().config.api;
-                    return [4 /*yield*/, api.getTimePunchesReport(businessDate)];
-                case 1: return [2 /*return*/, _b.sent()];
-                case 2:
-                    err_1 = _b.sent();
-                    return [2 /*return*/, rejectWithValue(err_1)];
-                case 3: return [2 /*return*/];
-            }
-        });
+})(PunchesActionType || (exports.PunchesActionType = PunchesActionType = {}));
+exports.fetchPunches = (0, toolkit_1.createAsyncThunk)(PunchesActionType.FetchPunches, function (businessDate_1, _a) { return tslib_1.__awaiter(void 0, [businessDate_1, _a], void 0, function (businessDate, _b) {
+    var api, err_1;
+    var getState = _b.getState, rejectWithValue = _b.rejectWithValue;
+    return tslib_1.__generator(this, function (_c) {
+        switch (_c.label) {
+            case 0:
+                _c.trys.push([0, 2, , 3]);
+                api = getState().config.api;
+                return [4 /*yield*/, api.getTimePunchesReport(businessDate)];
+            case 1: return [2 /*return*/, _c.sent()];
+            case 2:
+                err_1 = _c.sent();
+                return [2 /*return*/, rejectWithValue(err_1)];
+            case 3: return [2 /*return*/];
+        }
     });
-});
+}); });
 var punchesSlice = (0, toolkit_1.createSlice)({
     name: types_1.ReducerType.Punches,
     initialState: initialState,

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

@@ -1,8 +1,8 @@
-import { Order, Orders, Refund, RefundArgs, RequestError, RequestStatus } from '../types';
+import { Order, Orders, RefundArgs, RequestError, RequestStatus } from '@open-tender/types';
 import { AppState } from '../app';
 export interface RefundState {
     previous: Orders | null;
-    refund: Order | Refund | null;
+    refund: Order | null;
     loading: RequestStatus;
     error: RequestError;
     compeleted: boolean;
@@ -15,15 +15,33 @@ export declare enum RefundActionType {
 export declare const fetchPreviousRefunds: import("@reduxjs/toolkit").AsyncThunk<Orders, string, {
     state: AppState;
     rejectValue: RequestError;
+    dispatch?: import("redux").Dispatch<import("redux").UnknownAction> | undefined;
+    extra?: unknown;
+    serializedErrorType?: unknown;
+    pendingMeta?: unknown;
+    fulfilledMeta?: unknown;
+    rejectedMeta?: unknown;
 }>;
 export declare const validateRefund: import("@reduxjs/toolkit").AsyncThunk<Order, RefundArgs, {
     state: AppState;
     rejectValue: RequestError;
+    dispatch?: import("redux").Dispatch<import("redux").UnknownAction> | undefined;
+    extra?: unknown;
+    serializedErrorType?: unknown;
+    pendingMeta?: unknown;
+    fulfilledMeta?: unknown;
+    rejectedMeta?: unknown;
 }>;
 export declare const submitRefund: import("@reduxjs/toolkit").AsyncThunk<Order, RefundArgs, {
     state: AppState;
     rejectValue: RequestError;
+    dispatch?: import("redux").Dispatch<import("redux").UnknownAction> | undefined;
+    extra?: unknown;
+    serializedErrorType?: unknown;
+    pendingMeta?: unknown;
+    fulfilledMeta?: unknown;
+    rejectedMeta?: unknown;
 }>;
-export declare const resetRefund: import("@reduxjs/toolkit").ActionCreatorWithoutPayload<string>;
+export declare const resetRefund: import("@reduxjs/toolkit").ActionCreatorWithoutPayload<"refund/resetRefund">;
 export declare const selectRefund: (state: AppState) => RefundState;
-export declare const refundReducer: import("redux").Reducer<RefundState, import("redux").AnyAction>;
+export declare const refundReducer: import("redux").Reducer<RefundState>;

package/dist/cjs/slices/refund.js

@@ -16,67 +16,64 @@ var RefundActionType;
     RefundActionType["FetchPreviousRefunds"] = "refund/getPreviousRefunds";
     RefundActionType["ValidateRefund"] = "refund/validateRefund";
     RefundActionType["SubmitRefund"] = "refund/submitRefund";
-})(RefundActionType = exports.RefundActionType || (exports.RefundActionType = {}));
-exports.fetchPreviousRefunds = (0, toolkit_1.createAsyncThunk)(RefundActionType.FetchPreviousRefunds, function (orderId, _a) {
-    var getState = _a.getState, rejectWithValue = _a.rejectWithValue;
-    return tslib_1.__awaiter(void 0, void 0, void 0, function () {
-        var api, args, err_1;
-        return tslib_1.__generator(this, function (_b) {
-            switch (_b.label) {
-                case 0:
-                    _b.trys.push([0, 2, , 3]);
-                    api = getState().config.api;
-                    args = { receipt_type: 'REFUND', parent_receipt_uuid: orderId };
-                    return [4 /*yield*/, api.getOrders(args)];
-                case 1: return [2 /*return*/, _b.sent()];
-                case 2:
-                    err_1 = _b.sent();
-                    return [2 /*return*/, rejectWithValue(err_1)];
-                case 3: return [2 /*return*/];
-            }
-        });
-    });
-});
-exports.validateRefund = (0, toolkit_1.createAsyncThunk)(RefundActionType.ValidateRefund, function (_a, _b) {
-    var orderId = _a.orderId, refund = _a.refund;
+})(RefundActionType || (exports.RefundActionType = RefundActionType = {}));
+exports.fetchPreviousRefunds = (0, toolkit_1.createAsyncThunk)(RefundActionType.FetchPreviousRefunds, function (orderId_1, _a) { return tslib_1.__awaiter(void 0, [orderId_1, _a], void 0, function (orderId, _b) {
+    var api, args, err_1;
     var getState = _b.getState, rejectWithValue = _b.rejectWithValue;
-    return tslib_1.__awaiter(void 0, void 0, void 0, function () {
-        var api, err_2;
-        return tslib_1.__generator(this, function (_c) {
-            switch (_c.label) {
-                case 0:
-                    _c.trys.push([0, 2, , 3]);
-                    api = getState().config.api;
-                    return [4 /*yield*/, api.postRefundValidate(orderId, refund)];
-                case 1: return [2 /*return*/, _c.sent()];
-                case 2:
-                    err_2 = _c.sent();
-                    return [2 /*return*/, rejectWithValue(err_2)];
-                case 3: return [2 /*return*/];
-            }
-        });
+    return tslib_1.__generator(this, function (_c) {
+        switch (_c.label) {
+            case 0:
+                _c.trys.push([0, 2, , 3]);
+                api = getState().config.api;
+                args = {
+                    receipt_type: 'REFUND',
+                    parent_receipt_uuid: orderId
+                };
+                return [4 /*yield*/, api.getOrders(args)];
+            case 1: return [2 /*return*/, _c.sent()];
+            case 2:
+                err_1 = _c.sent();
+                return [2 /*return*/, rejectWithValue(err_1)];
+            case 3: return [2 /*return*/];
+        }
     });
-});
-exports.submitRefund = (0, toolkit_1.createAsyncThunk)(RefundActionType.SubmitRefund, function (_a, _b) {
-    var orderId = _a.orderId, refund = _a.refund;
-    var getState = _b.getState, rejectWithValue = _b.rejectWithValue;
-    return tslib_1.__awaiter(void 0, void 0, void 0, function () {
-        var api, err_3;
-        return tslib_1.__generator(this, function (_c) {
-            switch (_c.label) {
-                case 0:
-                    _c.trys.push([0, 2, , 3]);
-                    api = getState().config.api;
-                    return [4 /*yield*/, api.postRefund(orderId, refund)];
-                case 1: return [2 /*return*/, _c.sent()];
-                case 2:
-                    err_3 = _c.sent();
-                    return [2 /*return*/, rejectWithValue(err_3)];
-                case 3: return [2 /*return*/];
-            }
-        });
+}); });
+exports.validateRefund = (0, toolkit_1.createAsyncThunk)(RefundActionType.ValidateRefund, function (_a, _b) { return tslib_1.__awaiter(void 0, [_a, _b], void 0, function (_c, _d) {
+    var api, err_2;
+    var orderId = _c.orderId, refund = _c.refund;
+    var getState = _d.getState, rejectWithValue = _d.rejectWithValue;
+    return tslib_1.__generator(this, function (_e) {
+        switch (_e.label) {
+            case 0:
+                _e.trys.push([0, 2, , 3]);
+                api = getState().config.api;
+                return [4 /*yield*/, api.postRefundValidate(orderId, refund)];
+            case 1: return [2 /*return*/, _e.sent()];
+            case 2:
+                err_2 = _e.sent();
+                return [2 /*return*/, rejectWithValue(err_2)];
+            case 3: return [2 /*return*/];
+        }
     });
-});
+}); });
+exports.submitRefund = (0, toolkit_1.createAsyncThunk)(RefundActionType.SubmitRefund, function (_a, _b) { return tslib_1.__awaiter(void 0, [_a, _b], void 0, function (_c, _d) {
+    var api, err_3;
+    var orderId = _c.orderId, refund = _c.refund;
+    var getState = _d.getState, rejectWithValue = _d.rejectWithValue;
+    return tslib_1.__generator(this, function (_e) {
+        switch (_e.label) {
+            case 0:
+                _e.trys.push([0, 2, , 3]);
+                api = getState().config.api;
+                return [4 /*yield*/, api.postRefund(orderId, refund)];
+            case 1: return [2 /*return*/, _e.sent()];
+            case 2:
+                err_3 = _e.sent();
+                return [2 /*return*/, rejectWithValue(err_3)];
+            case 3: return [2 /*return*/];
+        }
+    });
+}); });
 var refundSlice = (0, toolkit_1.createSlice)({
     name: types_1.ReducerType.Refund,
     initialState: initialState,

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

@@ -0,0 +1,27 @@
+import { RequestError, RequestStatus, RevenueCenter } from '@open-tender/types';
+import { AppState } from '../app';
+export interface RevenueCenterState {
+    data: RevenueCenter | null;
+    error: RequestError;
+    loading: RequestStatus;
+}
+export declare enum RevenueCenterActionType {
+    FetchRevenueCenter = "revenueCenter/fetchRevenueCenter"
+}
+export interface RevenueCenterPayload {
+    data: RevenueCenter;
+}
+export declare const fetchRevenueCenter: import("@reduxjs/toolkit").AsyncThunk<RevenueCenterPayload, {
+    revenueCenterId: number;
+}, {
+    state: AppState;
+    rejectValue: RequestError;
+    dispatch?: import("redux").Dispatch<import("redux").UnknownAction> | undefined;
+    extra?: unknown;
+    serializedErrorType?: unknown;
+    pendingMeta?: unknown;
+    fulfilledMeta?: unknown;
+    rejectedMeta?: unknown;
+}>;
+export declare const selectRevenueCenter: (state: AppState) => RevenueCenterState;
+export declare const revenueCenterReducer: import("redux").Reducer<RevenueCenterState>;

package/dist/cjs/slices/revenueCenter.js

@@ -0,0 +1,58 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.revenueCenterReducer = exports.selectRevenueCenter = exports.fetchRevenueCenter = exports.RevenueCenterActionType = void 0;
+var tslib_1 = require("tslib");
+var toolkit_1 = require("@reduxjs/toolkit");
+var types_1 = require("./types");
+var initialState = {
+    data: null,
+    error: null,
+    loading: 'idle'
+};
+var RevenueCenterActionType;
+(function (RevenueCenterActionType) {
+    RevenueCenterActionType["FetchRevenueCenter"] = "revenueCenter/fetchRevenueCenter";
+})(RevenueCenterActionType || (exports.RevenueCenterActionType = RevenueCenterActionType = {}));
+exports.fetchRevenueCenter = (0, toolkit_1.createAsyncThunk)(RevenueCenterActionType.FetchRevenueCenter, function (_a, _b) { return tslib_1.__awaiter(void 0, [_a, _b], void 0, function (_c, _d) {
+    var api, data, err_1;
+    var revenueCenterId = _c.revenueCenterId;
+    var getState = _d.getState, rejectWithValue = _d.rejectWithValue;
+    return tslib_1.__generator(this, function (_e) {
+        switch (_e.label) {
+            case 0:
+                _e.trys.push([0, 2, , 3]);
+                api = getState().config.api;
+                return [4 /*yield*/, api.getRevenueCenter(revenueCenterId)];
+            case 1:
+                data = _e.sent();
+                return [2 /*return*/, { data: data }];
+            case 2:
+                err_1 = _e.sent();
+                return [2 /*return*/, rejectWithValue(err_1)];
+            case 3: return [2 /*return*/];
+        }
+    });
+}); });
+var revenueCenterSlice = (0, toolkit_1.createSlice)({
+    name: types_1.ReducerType.RevenueCenter,
+    initialState: initialState,
+    reducers: {},
+    extraReducers: function (builder) {
+        builder
+            .addCase(exports.fetchRevenueCenter.fulfilled, function (state, action) {
+            state.data = action.payload.data;
+            state.loading = 'idle';
+            state.error = null;
+        })
+            .addCase(exports.fetchRevenueCenter.pending, function (state) {
+            state.loading = 'pending';
+        })
+            .addCase(exports.fetchRevenueCenter.rejected, function (state, action) {
+            state.error = action.payload;
+            state.loading = 'idle';
+        });
+    }
+});
+var selectRevenueCenter = function (state) { return state.revenueCenter; };
+exports.selectRevenueCenter = selectRevenueCenter;
+exports.revenueCenterReducer = revenueCenterSlice.reducer;

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

@@ -0,0 +1,25 @@
+import { OrderCreateSendReceipt, RequestError, RequestStatus } from '@open-tender/types';
+import { AppState } from '../app';
+export interface SendReceiptState {
+    loading: RequestStatus;
+    error: RequestError;
+}
+export declare enum SendReceiptActionType {
+    SendReceipt = "SendReceipt/sendReceipt"
+}
+export declare const sendReceipt: import("@reduxjs/toolkit").AsyncThunk<void, {
+    orderUuid: string;
+    data: OrderCreateSendReceipt;
+}, {
+    state: AppState;
+    rejectValue: RequestError;
+    dispatch?: import("redux").Dispatch<import("redux").UnknownAction> | undefined;
+    extra?: unknown;
+    serializedErrorType?: unknown;
+    pendingMeta?: unknown;
+    fulfilledMeta?: unknown;
+    rejectedMeta?: unknown;
+}>;
+export declare const resetSendReceipt: import("@reduxjs/toolkit").ActionCreatorWithoutPayload<"sendReceipt/resetSendReceipt">;
+export declare const selectSendReceipt: (state: AppState) => SendReceiptState;
+export declare const sendReceiptReducer: import("redux").Reducer<SendReceiptState>;

package/dist/cjs/slices/sendReceipt.js

@@ -0,0 +1,57 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.sendReceiptReducer = exports.selectSendReceipt = exports.resetSendReceipt = exports.sendReceipt = exports.SendReceiptActionType = void 0;
+var tslib_1 = require("tslib");
+var toolkit_1 = require("@reduxjs/toolkit");
+var types_1 = require("./types");
+var initialState = {
+    loading: 'idle',
+    error: null
+};
+var SendReceiptActionType;
+(function (SendReceiptActionType) {
+    SendReceiptActionType["SendReceipt"] = "SendReceipt/sendReceipt";
+})(SendReceiptActionType || (exports.SendReceiptActionType = SendReceiptActionType = {}));
+exports.sendReceipt = (0, toolkit_1.createAsyncThunk)(SendReceiptActionType.SendReceipt, function (_a, _b) { return tslib_1.__awaiter(void 0, [_a, _b], void 0, function (_c, _d) {
+    var api, err_1;
+    var orderUuid = _c.orderUuid, data = _c.data;
+    var getState = _d.getState, rejectWithValue = _d.rejectWithValue;
+    return tslib_1.__generator(this, function (_e) {
+        switch (_e.label) {
+            case 0:
+                _e.trys.push([0, 2, , 3]);
+                api = getState().config.api;
+                return [4 /*yield*/, api.postSendReceipt(orderUuid, data)];
+            case 1: return [2 /*return*/, _e.sent()];
+            case 2:
+                err_1 = _e.sent();
+                return [2 /*return*/, rejectWithValue(err_1)];
+            case 3: return [2 /*return*/];
+        }
+    });
+}); });
+var sendReceiptSlice = (0, toolkit_1.createSlice)({
+    name: types_1.ReducerType.SendReceipt,
+    initialState: initialState,
+    reducers: {
+        resetSendReceipt: function () { return initialState; }
+    },
+    extraReducers: function (builder) {
+        builder
+            .addCase(exports.sendReceipt.fulfilled, function (state) {
+            state.loading = 'idle';
+            state.error = null;
+        })
+            .addCase(exports.sendReceipt.pending, function (state) {
+            state.loading = 'pending';
+        })
+            .addCase(exports.sendReceipt.rejected, function (state, action) {
+            state.error = action.payload;
+            state.loading = 'idle';
+        });
+    }
+});
+exports.resetSendReceipt = sendReceiptSlice.actions.resetSendReceipt;
+var selectSendReceipt = function (state) { return state.sendReceipt; };
+exports.selectSendReceipt = selectSendReceipt;
+exports.sendReceiptReducer = sendReceiptSlice.reducer;

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

@@ -1,21 +1,45 @@
-import { EntityType, RequestError, RequestStatus, Settings } from '../types';
+import { EntityType, RequestError, RequestStatus, Settings } from '@open-tender/types';
 import { AppState } from '../app';
 export interface SettingsState {
+    data: any | null;
     loading: RequestStatus;
     error: RequestError;
 }
 export declare enum SettingsActionType {
+    FetchSetting = "settings/fetchSetting",
     UpdateSetting = "settings/updateSetting",
     UpdateSettings = "settings/updateSettings"
 }
-export declare const updateSetting: import("@reduxjs/toolkit").AsyncThunk<Settings, EntityType, {
+export declare const fetchSetting: import("@reduxjs/toolkit").AsyncThunk<any, EntityType, {
     state: AppState;
     rejectValue: RequestError;
+    dispatch?: import("redux").Dispatch<import("redux").UnknownAction> | undefined;
+    extra?: unknown;
+    serializedErrorType?: unknown;
+    pendingMeta?: unknown;
+    fulfilledMeta?: unknown;
+    rejectedMeta?: unknown;
+}>;
+export declare const updateSetting: import("@reduxjs/toolkit").AsyncThunk<Settings, EntityType | undefined, {
+    state: AppState;
+    rejectValue: RequestError;
+    dispatch?: import("redux").Dispatch<import("redux").UnknownAction> | undefined;
+    extra?: unknown;
+    serializedErrorType?: unknown;
+    pendingMeta?: unknown;
+    fulfilledMeta?: unknown;
+    rejectedMeta?: unknown;
 }>;
 export declare const updateSettings: import("@reduxjs/toolkit").AsyncThunk<Settings[], EntityType[], {
     state: AppState;
     rejectValue: RequestError;
+    dispatch?: import("redux").Dispatch<import("redux").UnknownAction> | undefined;
+    extra?: unknown;
+    serializedErrorType?: unknown;
+    pendingMeta?: unknown;
+    fulfilledMeta?: unknown;
+    rejectedMeta?: unknown;
 }>;
-export declare const resetSettings: import("@reduxjs/toolkit").ActionCreatorWithoutPayload<string>;
+export declare const resetSettings: import("@reduxjs/toolkit").ActionCreatorWithoutPayload<"settings/resetSettings">;
 export declare const selectSettings: (state: AppState) => SettingsState;
-export declare const settingsReducer: import("redux").Reducer<SettingsState, import("redux").AnyAction>;
+export declare const settingsReducer: import("redux").Reducer<SettingsState>;

package/dist/cjs/slices/settings.js

@@ -1,64 +1,79 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.settingsReducer = exports.selectSettings = exports.resetSettings = exports.updateSettings = exports.updateSetting = exports.SettingsActionType = void 0;
+exports.settingsReducer = exports.selectSettings = exports.resetSettings = exports.updateSettings = exports.updateSetting = exports.fetchSetting = exports.SettingsActionType = void 0;
 var tslib_1 = require("tslib");
 var toolkit_1 = require("@reduxjs/toolkit");
 var types_1 = require("./types");
 var initialState = {
+    data: null,
     loading: 'idle',
     error: null
 };
 var SettingsActionType;
 (function (SettingsActionType) {
+    SettingsActionType["FetchSetting"] = "settings/fetchSetting";
     SettingsActionType["UpdateSetting"] = "settings/updateSetting";
     SettingsActionType["UpdateSettings"] = "settings/updateSettings";
-})(SettingsActionType = exports.SettingsActionType || (exports.SettingsActionType = {}));
-exports.updateSetting = (0, toolkit_1.createAsyncThunk)(SettingsActionType.UpdateSetting, function (entityType, _a) {
-    var getState = _a.getState, rejectWithValue = _a.rejectWithValue;
-    return tslib_1.__awaiter(void 0, void 0, void 0, function () {
-        var api, err_1;
-        return tslib_1.__generator(this, function (_b) {
-            switch (_b.label) {
-                case 0:
-                    _b.trys.push([0, 2, , 3]);
-                    api = getState().config.api;
-                    return [4 /*yield*/, api.postSettings(entityType)];
-                case 1: return [2 /*return*/, _b.sent()];
-                case 2:
-                    err_1 = _b.sent();
-                    return [2 /*return*/, rejectWithValue(err_1)];
-                case 3: return [2 /*return*/];
-            }
-        });
+})(SettingsActionType || (exports.SettingsActionType = SettingsActionType = {}));
+exports.fetchSetting = (0, toolkit_1.createAsyncThunk)(SettingsActionType.FetchSetting, function (posSettingType_1, _a) { return tslib_1.__awaiter(void 0, [posSettingType_1, _a], void 0, function (posSettingType, _b) {
+    var api, err_1;
+    var getState = _b.getState, rejectWithValue = _b.rejectWithValue;
+    return tslib_1.__generator(this, function (_c) {
+        switch (_c.label) {
+            case 0:
+                _c.trys.push([0, 2, , 3]);
+                api = getState().config.api;
+                return [4 /*yield*/, api.getSettings(posSettingType)];
+            case 1: return [2 /*return*/, _c.sent()];
+            case 2:
+                err_1 = _c.sent();
+                return [2 /*return*/, rejectWithValue(err_1)];
+            case 3: return [2 /*return*/];
+        }
     });
-});
-exports.updateSettings = (0, toolkit_1.createAsyncThunk)(SettingsActionType.UpdateSettings, function (entityTypes, _a) {
-    var getState = _a.getState, rejectWithValue = _a.rejectWithValue;
-    return tslib_1.__awaiter(void 0, void 0, void 0, function () {
-        var api_1, requests, err_2;
-        return tslib_1.__generator(this, function (_b) {
-            switch (_b.label) {
-                case 0:
-                    _b.trys.push([0, 2, , 3]);
-                    api_1 = getState().config.api;
-                    requests = entityTypes.map(function (entityType) { return tslib_1.__awaiter(void 0, void 0, void 0, function () {
-                        return tslib_1.__generator(this, function (_a) {
-                            switch (_a.label) {
-                                case 0: return [4 /*yield*/, api_1.postSettings(entityType)];
-                                case 1: return [2 /*return*/, _a.sent()];
-                            }
-                        });
-                    }); });
-                    return [4 /*yield*/, Promise.all(requests)];
-                case 1: return [2 /*return*/, _b.sent()];
-                case 2:
-                    err_2 = _b.sent();
-                    return [2 /*return*/, rejectWithValue(err_2)];
-                case 3: return [2 /*return*/];
-            }
-        });
+}); });
+exports.updateSetting = (0, toolkit_1.createAsyncThunk)(SettingsActionType.UpdateSetting, function (posSettingType_1, _a) { return tslib_1.__awaiter(void 0, [posSettingType_1, _a], void 0, function (posSettingType, _b) {
+    var api, err_2;
+    var getState = _b.getState, rejectWithValue = _b.rejectWithValue;
+    return tslib_1.__generator(this, function (_c) {
+        switch (_c.label) {
+            case 0:
+                _c.trys.push([0, 2, , 3]);
+                api = getState().config.api;
+                return [4 /*yield*/, api.postSettings(posSettingType)];
+            case 1: return [2 /*return*/, _c.sent()];
+            case 2:
+                err_2 = _c.sent();
+                return [2 /*return*/, rejectWithValue(err_2)];
+            case 3: return [2 /*return*/];
+        }
     });
-});
+}); });
+exports.updateSettings = (0, toolkit_1.createAsyncThunk)(SettingsActionType.UpdateSettings, function (posSettingTypes_1, _a) { return tslib_1.__awaiter(void 0, [posSettingTypes_1, _a], void 0, function (posSettingTypes, _b) {
+    var api_1, requests, err_3;
+    var getState = _b.getState, rejectWithValue = _b.rejectWithValue;
+    return tslib_1.__generator(this, function (_c) {
+        switch (_c.label) {
+            case 0:
+                _c.trys.push([0, 2, , 3]);
+                api_1 = getState().config.api;
+                requests = posSettingTypes.map(function (posSettingType) { return tslib_1.__awaiter(void 0, void 0, void 0, function () {
+                    return tslib_1.__generator(this, function (_a) {
+                        switch (_a.label) {
+                            case 0: return [4 /*yield*/, api_1.postSettings(posSettingType)];
+                            case 1: return [2 /*return*/, _a.sent()];
+                        }
+                    });
+                }); });
+                return [4 /*yield*/, Promise.all(requests)];
+            case 1: return [2 /*return*/, _c.sent()];
+            case 2:
+                err_3 = _c.sent();
+                return [2 /*return*/, rejectWithValue(err_3)];
+            case 3: return [2 /*return*/];
+        }
+    });
+}); });
 var settingsSlice = (0, toolkit_1.createSlice)({
     name: types_1.ReducerType.Settings,
     initialState: initialState,
@@ -67,23 +82,35 @@ var settingsSlice = (0, toolkit_1.createSlice)({
     },
     extraReducers: function (builder) {
         builder
-            .addCase(exports.updateSetting.fulfilled, function (state) {
+            .addCase(exports.fetchSetting.pending, function (state) {
+            state.loading = 'pending';
+        })
+            .addCase(exports.fetchSetting.fulfilled, function (state, action) {
+            state.data = action.payload;
             state.loading = 'idle';
             state.error = null;
+        })
+            .addCase(exports.fetchSetting.rejected, function (state, action) {
+            state.error = action.payload;
+            state.loading = 'idle';
         })
             .addCase(exports.updateSetting.pending, function (state) {
             state.loading = 'pending';
+        })
+            .addCase(exports.updateSetting.fulfilled, function (state) {
+            state.loading = 'idle';
+            state.error = null;
         })
             .addCase(exports.updateSetting.rejected, function (state, action) {
             state.error = action.payload;
             state.loading = 'idle';
+        })
+            .addCase(exports.updateSettings.pending, function (state) {
+            state.loading = 'pending';
         })
             .addCase(exports.updateSettings.fulfilled, function (state) {
             state.loading = 'idle';
             state.error = null;
-        })
-            .addCase(exports.updateSettings.pending, function (state) {
-            state.loading = 'pending';
         })
             .addCase(exports.updateSettings.rejected, function (state, action) {
             state.error = action.payload;

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

@@ -2,6 +2,6 @@ import { AppState } from '../app';
 export interface SidebarState {
     isOpen: boolean;
 }
-export declare const toggleSidebar: import("@reduxjs/toolkit").ActionCreatorWithoutPayload<string>, openSidebar: import("@reduxjs/toolkit").ActionCreatorWithoutPayload<string>, closeSidebar: import("@reduxjs/toolkit").ActionCreatorWithoutPayload<string>;
+export declare const toggleSidebar: import("@reduxjs/toolkit").ActionCreatorWithoutPayload<"sidebar/toggleSidebar">, openSidebar: import("@reduxjs/toolkit").ActionCreatorWithoutPayload<"sidebar/openSidebar">, closeSidebar: import("@reduxjs/toolkit").ActionCreatorWithoutPayload<"sidebar/closeSidebar">;
 export declare const selectSidebar: (state: AppState) => SidebarState;
-export declare const sidebarReducer: import("redux").Reducer<SidebarState, import("redux").AnyAction>;
+export declare const sidebarReducer: import("redux").Reducer<SidebarState>;