@open-tender/cloud 0.0.1

package/dist/cjs/slices/customer/giftCards.js

@@ -0,0 +1,196 @@
+"use strict";
+var _a;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.customerGiftCardsReducer = exports.selectCustomerGiftCards = exports.setCustomerGiftCards = exports.resetCustomerGiftCardsError = exports.resetCustomerGiftCards = exports.assignCustomerGiftCardOther = exports.assignCustomerGiftCard = exports.addCustomerGiftCard = exports.removeCustomerGiftCard = exports.updateCustomerGiftCard = exports.fetchCustomerGiftCards = exports.CustomerGiftCardsActionType = void 0;
+const tslib_1 = require("tslib");
+const toolkit_1 = require("@reduxjs/toolkit");
+const types_1 = require("../types");
+const types_2 = require("@open-tender/types");
+const account_1 = require("./account");
+const notifications_1 = require("../notifications");
+const initialState = {
+    entities: [],
+    error: null,
+    loading: 'idle',
+    lookup: {}
+};
+var CustomerGiftCardsActionType;
+(function (CustomerGiftCardsActionType) {
+    CustomerGiftCardsActionType["FetchCustomerGiftCards"] = "customer/fetchCustomerGiftCards";
+    CustomerGiftCardsActionType["RemoveCustomerGiftCard"] = "customer/removeCustomerGiftCard";
+    CustomerGiftCardsActionType["AddCustomerGiftCard"] = "customer/addCustomerGiftCard";
+    CustomerGiftCardsActionType["AssignCustomerGiftCard"] = "customer/assignCustomerGiftCard";
+    CustomerGiftCardsActionType["AssignCustomerGiftCardOther"] = "customer/assignCustomerGiftCardOther";
+    CustomerGiftCardsActionType["UpdateCustomerGiftCard"] = "customer/updateCustomerGiftCard";
+})(CustomerGiftCardsActionType = exports.CustomerGiftCardsActionType || (exports.CustomerGiftCardsActionType = {}));
+exports.fetchCustomerGiftCards = (0, toolkit_1.createAsyncThunk)(CustomerGiftCardsActionType.FetchCustomerGiftCards, (_, { dispatch, getState, rejectWithValue }) => tslib_1.__awaiter(void 0, void 0, void 0, function* () {
+    try {
+        const api = getState().config.api;
+        const token = (0, account_1.selectToken)(getState());
+        if (!token)
+            throw new Error(types_2.MISSING_CUSTOMER);
+        return yield api.getCustomerGiftCards(token);
+    }
+    catch (err) {
+        const error = err;
+        return (0, account_1.checkAuth)(error, dispatch, () => rejectWithValue(error));
+    }
+}));
+exports.updateCustomerGiftCard = (0, toolkit_1.createAsyncThunk)(CustomerGiftCardsActionType.UpdateCustomerGiftCard, (requestData, { dispatch, getState, rejectWithValue }) => tslib_1.__awaiter(void 0, void 0, void 0, function* () {
+    try {
+        const api = getState().config.api;
+        const token = (0, account_1.selectToken)(getState());
+        if (!token)
+            throw new Error(types_2.MISSING_CUSTOMER);
+        yield api.putCustomerGiftCard(token, requestData.giftCardId, requestData.data);
+        const giftCards = yield api.getCustomerGiftCards(token);
+        dispatch((0, notifications_1.showNotification)('Gift card balance updated!'));
+        if (requestData.callback)
+            requestData.callback();
+        return giftCards;
+    }
+    catch (err) {
+        const error = err;
+        return (0, account_1.checkAuth)(error, dispatch, () => rejectWithValue(error));
+    }
+}));
+exports.removeCustomerGiftCard = (0, toolkit_1.createAsyncThunk)(CustomerGiftCardsActionType.RemoveCustomerGiftCard, (requestData, { dispatch, getState, rejectWithValue }) => tslib_1.__awaiter(void 0, void 0, void 0, function* () {
+    try {
+        const api = getState().config.api;
+        const token = (0, account_1.selectToken)(getState());
+        if (!token)
+            throw new Error(types_2.MISSING_CUSTOMER);
+        yield api.deleteCustomerGiftCard(token, requestData.giftCardId);
+        const giftCards = yield api.getCustomerGiftCards(token);
+        dispatch((0, notifications_1.showNotification)('Gift card removed!'));
+        if (requestData.callback)
+            requestData.callback();
+        return giftCards;
+    }
+    catch (err) {
+        const error = err;
+        return (0, account_1.checkAuth)(error, dispatch, () => rejectWithValue(error));
+    }
+}));
+exports.addCustomerGiftCard = (0, toolkit_1.createAsyncThunk)(CustomerGiftCardsActionType.AddCustomerGiftCard, (requestData, { dispatch, getState, rejectWithValue }) => tslib_1.__awaiter(void 0, void 0, void 0, function* () {
+    try {
+        const api = getState().config.api;
+        const token = (0, account_1.selectToken)(getState());
+        if (!token)
+            throw new Error(types_2.MISSING_CUSTOMER);
+        yield api.postCustomerGiftCard(token, requestData.data);
+        const giftCards = yield api.getCustomerGiftCards(token);
+        dispatch((0, notifications_1.showNotification)('Gift card added!'));
+        if (requestData.callback)
+            requestData.callback();
+        return giftCards;
+    }
+    catch (err) {
+        const error = err;
+        return (0, account_1.checkAuth)(error, dispatch, () => rejectWithValue(error));
+    }
+}));
+exports.assignCustomerGiftCard = (0, toolkit_1.createAsyncThunk)(CustomerGiftCardsActionType.AssignCustomerGiftCard, (requestData, { dispatch, getState, rejectWithValue }) => tslib_1.__awaiter(void 0, void 0, void 0, function* () {
+    try {
+        const api = getState().config.api;
+        const token = (0, account_1.selectToken)(getState());
+        if (!token)
+            throw new Error(types_2.MISSING_CUSTOMER);
+        yield api.postCustomerGiftCardAssign(token, requestData.cardNumber);
+        const giftCards = yield api.getCustomerGiftCards(token);
+        dispatch((0, notifications_1.showNotification)('Gift card added to your account!'));
+        if (requestData.callback)
+            requestData.callback();
+        return giftCards;
+    }
+    catch (err) {
+        const error = err;
+        return (0, account_1.checkAuth)(error, dispatch, () => rejectWithValue(error));
+    }
+}));
+exports.assignCustomerGiftCardOther = (0, toolkit_1.createAsyncThunk)(CustomerGiftCardsActionType.AssignCustomerGiftCardOther, (requestData, { dispatch, getState, rejectWithValue }) => tslib_1.__awaiter(void 0, void 0, void 0, function* () {
+    try {
+        const api = getState().config.api;
+        const token = (0, account_1.selectToken)(getState());
+        if (!token)
+            throw new Error(types_2.MISSING_CUSTOMER);
+        yield api.postCustomerGiftCardAssignOther(token, requestData.giftCardId, requestData.email);
+        const giftCards = yield api.getCustomerGiftCards(token);
+        dispatch((0, notifications_1.showNotification)(`Gift card assigned to ${requestData.email}`));
+        if (requestData.callback)
+            requestData.callback();
+        return giftCards;
+    }
+    catch (err) {
+        const error = err;
+        return (0, account_1.checkAuth)(error, dispatch, () => rejectWithValue(error));
+    }
+}));
+const customerGiftCardsSlice = (0, toolkit_1.createSlice)({
+    name: types_1.ReducerType.GiftCards,
+    initialState,
+    reducers: {
+        resetCustomerGiftCards: () => initialState,
+        resetCustomerGiftCardsError: state => {
+            state.error = null;
+            state.loading = 'idle';
+        },
+        setCustomerGiftCards: (state, action) => {
+            state.entities = action.payload;
+            state.error = null;
+        }
+    },
+    extraReducers: builder => {
+        builder
+            .addCase(exports.fetchCustomerGiftCards.fulfilled, (state, action) => {
+            state.entities = action.payload;
+            state.loading = 'idle';
+            state.error = null;
+        })
+            .addCase(exports.fetchCustomerGiftCards.pending, state => {
+            state.loading = 'pending';
+        })
+            .addCase(exports.fetchCustomerGiftCards.rejected, (state, action) => {
+            state.error = action.payload;
+            state.loading = 'idle';
+        })
+            .addCase(exports.removeCustomerGiftCard.fulfilled, state => {
+            state.loading = 'idle';
+            state.error = null;
+        })
+            .addCase(exports.removeCustomerGiftCard.pending, state => {
+            state.loading = 'pending';
+        })
+            .addCase(exports.removeCustomerGiftCard.rejected, (state, action) => {
+            state.error = action.payload;
+            state.loading = 'idle';
+        })
+            .addCase(exports.addCustomerGiftCard.fulfilled, state => {
+            state.loading = 'idle';
+            state.error = null;
+        })
+            .addCase(exports.addCustomerGiftCard.pending, state => {
+            state.loading = 'pending';
+        })
+            .addCase(exports.addCustomerGiftCard.rejected, (state, action) => {
+            state.error = action.payload;
+            state.loading = 'idle';
+        })
+            .addCase(exports.updateCustomerGiftCard.fulfilled, (state, action) => {
+            state.entities = action.payload;
+            state.loading = 'idle';
+            state.error = null;
+        })
+            .addCase(exports.updateCustomerGiftCard.pending, state => {
+            state.loading = 'pending';
+        })
+            .addCase(exports.updateCustomerGiftCard.rejected, (state, action) => {
+            state.error = action.payload;
+            state.loading = 'idle';
+        });
+    }
+});
+_a = customerGiftCardsSlice.actions, exports.resetCustomerGiftCards = _a.resetCustomerGiftCards, exports.resetCustomerGiftCardsError = _a.resetCustomerGiftCardsError, exports.setCustomerGiftCards = _a.setCustomerGiftCards;
+const selectCustomerGiftCards = (state) => state.customer.giftCards;
+exports.selectCustomerGiftCards = selectCustomerGiftCards;
+exports.customerGiftCardsReducer = customerGiftCardsSlice.reducer;

package/dist/cjs/slices/customer/groupOrders.d.ts

@@ -0,0 +1,33 @@
+import { AppState } from '../../app';
+import { GroupOrder, GroupOrders, RequestError, RequestStatus } from '@open-tender/types';
+export interface CustomerGroupOrdersState {
+    entities: GroupOrders;
+    error: RequestError;
+    loading: RequestStatus;
+    lookup: {
+        [key: number]: number;
+    };
+}
+export declare enum CustomerGroupOrdersActionType {
+    FetchCustomerGroupOrders = "customer/fetchCustomerGroupOrders",
+    FetchCustomerGroupOrder = "customer/fetchCustomerGroupOrder",
+    AddCustomerGroupOrder = "customer/addCustomerGroupOrder"
+}
+export declare const fetchCustomerGroupOrders: import("@reduxjs/toolkit").AsyncThunk<GroupOrders, void, {
+    state: AppState;
+    rejectValue: RequestError;
+}>;
+export declare const fetchCustomerGroupOrder: import("@reduxjs/toolkit").AsyncThunk<GroupOrders, number, {
+    state: AppState;
+    rejectValue: RequestError;
+}>;
+export declare const addCustomerGroupOrder: import("@reduxjs/toolkit").AsyncThunk<GroupOrders, {
+    data: Partial<GroupOrder>;
+    callback?: (() => void) | undefined;
+}, {
+    state: AppState;
+    rejectValue: RequestError;
+}>;
+export declare const resetCustomerGroupOrders: import("@reduxjs/toolkit").ActionCreatorWithoutPayload<string>, resetCustomerGroupOrdersError: import("@reduxjs/toolkit").ActionCreatorWithoutPayload<string>, setCustomerGroupOrders: import("@reduxjs/toolkit").ActionCreatorWithPayload<any, string>;
+export declare const selectCustomerGroupOrders: (state: AppState) => CustomerGroupOrdersState;
+export declare const customerGroupOrdersReducer: import("redux").Reducer<CustomerGroupOrdersState, import("redux").AnyAction>;

package/dist/cjs/slices/customer/groupOrders.js

@@ -0,0 +1,148 @@
+"use strict";
+var _a;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.customerGroupOrdersReducer = exports.selectCustomerGroupOrders = exports.setCustomerGroupOrders = exports.resetCustomerGroupOrdersError = exports.resetCustomerGroupOrders = exports.addCustomerGroupOrder = exports.fetchCustomerGroupOrder = exports.fetchCustomerGroupOrders = exports.CustomerGroupOrdersActionType = void 0;
+const tslib_1 = require("tslib");
+const toolkit_1 = require("@reduxjs/toolkit");
+const types_1 = require("../types");
+const types_2 = require("@open-tender/types");
+const account_1 = require("./account");
+const groupOrder_1 = require("../groupOrder");
+const utils_1 = require("@open-tender/utils");
+const initialState = {
+    entities: [],
+    lookup: {},
+    loading: 'idle',
+    error: null
+};
+var CustomerGroupOrdersActionType;
+(function (CustomerGroupOrdersActionType) {
+    CustomerGroupOrdersActionType["FetchCustomerGroupOrders"] = "customer/fetchCustomerGroupOrders";
+    CustomerGroupOrdersActionType["FetchCustomerGroupOrder"] = "customer/fetchCustomerGroupOrder";
+    CustomerGroupOrdersActionType["AddCustomerGroupOrder"] = "customer/addCustomerGroupOrder";
+})(CustomerGroupOrdersActionType = exports.CustomerGroupOrdersActionType || (exports.CustomerGroupOrdersActionType = {}));
+exports.fetchCustomerGroupOrders = (0, toolkit_1.createAsyncThunk)(CustomerGroupOrdersActionType.FetchCustomerGroupOrders, (_, { dispatch, getState, rejectWithValue }) => tslib_1.__awaiter(void 0, void 0, void 0, function* () {
+    try {
+        const api = getState().config.api;
+        const token = (0, account_1.selectToken)(getState());
+        if (!token)
+            throw new Error(types_2.MISSING_CUSTOMER);
+        const orders = yield api.getCustomerGroupOrders(token);
+        return orders;
+    }
+    catch (err) {
+        const error = err;
+        return (0, account_1.checkAuth)(error, dispatch, () => rejectWithValue(error));
+    }
+}));
+exports.fetchCustomerGroupOrder = (0, toolkit_1.createAsyncThunk)(CustomerGroupOrdersActionType.FetchCustomerGroupOrder, (cartId, { dispatch, getState, rejectWithValue }) => tslib_1.__awaiter(void 0, void 0, void 0, function* () {
+    try {
+        const api = getState().config.api;
+        const token = (0, account_1.selectToken)(getState());
+        if (!token)
+            throw new Error(types_2.MISSING_CUSTOMER);
+        const response = yield api.getCustomerGroupOrder(token, cartId);
+        const payload = Object.assign(Object.assign({}, (0, groupOrder_1.makeCartPayload)(response)), { isCartOwner: true });
+        return payload;
+    }
+    catch (err) {
+        const error = err;
+        return (0, account_1.checkAuth)(error, dispatch, () => rejectWithValue(error));
+    }
+}));
+const makeCartData = (order, data = {}) => {
+    const { address, revenueCenter, requestedAt, serviceType, cart } = order;
+    const orderData = {
+        address,
+        revenue_center_id: revenueCenter === null || revenueCenter === void 0 ? void 0 : revenueCenter.revenue_center_id,
+        service_type: serviceType,
+        requested_at: requestedAt,
+        cart: (0, utils_1.makeSimpleCart)(cart !== null && cart !== void 0 ? cart : []),
+        spending_limit: null
+    };
+    const { spendingLimit } = data;
+    if (spendingLimit !== undefined) {
+        delete data.spendingLimit;
+        orderData.spending_limit = isNaN(parseFloat(spendingLimit))
+            ? null
+            : parseFloat(spendingLimit).toFixed(2);
+    }
+    return Object.assign(Object.assign({}, orderData), data);
+};
+exports.addCustomerGroupOrder = (0, toolkit_1.createAsyncThunk)(CustomerGroupOrdersActionType.AddCustomerGroupOrder, (requestData, { dispatch, getState, rejectWithValue }) => tslib_1.__awaiter(void 0, void 0, void 0, function* () {
+    try {
+        const api = getState().config.api;
+        const token = (0, account_1.selectToken)(getState());
+        if (!token)
+            throw new Error(types_2.MISSING_CUSTOMER);
+        const cartData = makeCartData(getState().order, requestData.data);
+        const response = yield api.postCustomerGroupOrder(token, cartData);
+        const customer = getState().customer.account.profile;
+        const payload = Object.assign(Object.assign({}, (0, groupOrder_1.makeCartPayload)(response)), { isCartOwner: true, cartOwner: customer });
+        if (requestData.callback)
+            requestData.callback();
+        return payload;
+    }
+    catch (err) {
+        const error = err;
+        return (0, account_1.checkAuth)(error, dispatch, () => rejectWithValue(error));
+    }
+}));
+const customerGroupOrdersSlice = (0, toolkit_1.createSlice)({
+    name: types_1.ReducerType.GroupOrders,
+    initialState,
+    reducers: {
+        resetCustomerGroupOrders: () => initialState,
+        resetCustomerGroupOrdersError: state => {
+            state.error = null;
+            state.loading = 'idle';
+        },
+        setCustomerGroupOrders: (state, action) => {
+            state.entities = action.payload;
+            state.error = null;
+        }
+    },
+    extraReducers: builder => {
+        builder
+            .addCase(exports.fetchCustomerGroupOrders.fulfilled, (state, action) => {
+            state.entities = action.payload;
+            state.loading = 'idle';
+            state.error = null;
+        })
+            .addCase(exports.fetchCustomerGroupOrders.pending, state => {
+            state.loading = 'pending';
+        })
+            .addCase(exports.fetchCustomerGroupOrders.rejected, (state, action) => {
+            state.error = action.payload;
+            state.loading = 'idle';
+        })
+            .addCase(exports.fetchCustomerGroupOrder.fulfilled, (state, action) => {
+            state.entities = action.payload;
+            state.loading = 'idle';
+            state.error = null;
+        })
+            .addCase(exports.fetchCustomerGroupOrder.pending, state => {
+            state.loading = 'pending';
+        })
+            .addCase(exports.fetchCustomerGroupOrder.rejected, (state, action) => {
+            state.error = action.payload;
+            state.loading = 'idle';
+        })
+            .addCase(exports.addCustomerGroupOrder.fulfilled, (state, action) => {
+            state.entities = action.payload;
+            state.loading = 'idle';
+            state.error = null;
+        })
+            .addCase(exports.addCustomerGroupOrder.pending, state => {
+            state.loading = 'pending';
+        })
+            .addCase(exports.addCustomerGroupOrder.rejected, (state, action) => {
+            state.error = action.payload;
+            state.loading = 'idle';
+        });
+    }
+});
+_a = customerGroupOrdersSlice.actions, exports.resetCustomerGroupOrders = _a.resetCustomerGroupOrders, exports.resetCustomerGroupOrdersError = _a.resetCustomerGroupOrdersError, exports.setCustomerGroupOrders = _a.setCustomerGroupOrders;
+const selectCustomerGroupOrders = (state) => state.customer.groupOrders;
+exports.selectCustomerGroupOrders = selectCustomerGroupOrders;
+exports.customerGroupOrdersReducer = customerGroupOrdersSlice.reducer;

package/dist/cjs/slices/customer/houseAccounts.d.ts

@@ -0,0 +1,20 @@
+import { AppState } from '../../app';
+import { HouseAccounts, RequestError, RequestStatus } from '@open-tender/types';
+export interface CustomerHouseAccountsState {
+    entities: HouseAccounts;
+    error: RequestError;
+    loading: RequestStatus;
+    lookup: {
+        [key: number]: number;
+    };
+}
+export declare enum CustomerHouseAccountsActionType {
+    FetchCustomerHouseAccounts = "customer/fetchCustomerHouseAccounts"
+}
+export declare const fetchCustomerHouseAccounts: import("@reduxjs/toolkit").AsyncThunk<HouseAccounts, void, {
+    state: AppState;
+    rejectValue: RequestError;
+}>;
+export declare const resetCustomerHouseAccounts: import("@reduxjs/toolkit").ActionCreatorWithoutPayload<string>, resetCustomerHouseAccountsError: import("@reduxjs/toolkit").ActionCreatorWithoutPayload<string>, setCustomerHouseAccounts: import("@reduxjs/toolkit").ActionCreatorWithPayload<any, string>;
+export declare const selectCustomerHouseAccounts: (state: AppState) => import("./orders").CustomerOrdersState;
+export declare const customerHouseAccountsReducer: import("redux").Reducer<CustomerHouseAccountsState, import("redux").AnyAction>;

package/dist/cjs/slices/customer/houseAccounts.js

@@ -0,0 +1,67 @@
+"use strict";
+var _a;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.customerHouseAccountsReducer = exports.selectCustomerHouseAccounts = exports.setCustomerHouseAccounts = exports.resetCustomerHouseAccountsError = exports.resetCustomerHouseAccounts = exports.fetchCustomerHouseAccounts = exports.CustomerHouseAccountsActionType = void 0;
+const tslib_1 = require("tslib");
+const toolkit_1 = require("@reduxjs/toolkit");
+const types_1 = require("../types");
+const types_2 = require("@open-tender/types");
+const account_1 = require("./account");
+const initialState = {
+    entities: [],
+    error: null,
+    loading: 'idle',
+    lookup: {}
+};
+var CustomerHouseAccountsActionType;
+(function (CustomerHouseAccountsActionType) {
+    CustomerHouseAccountsActionType["FetchCustomerHouseAccounts"] = "customer/fetchCustomerHouseAccounts";
+})(CustomerHouseAccountsActionType = exports.CustomerHouseAccountsActionType || (exports.CustomerHouseAccountsActionType = {}));
+exports.fetchCustomerHouseAccounts = (0, toolkit_1.createAsyncThunk)(CustomerHouseAccountsActionType.FetchCustomerHouseAccounts, (_, { dispatch, getState, rejectWithValue }) => tslib_1.__awaiter(void 0, void 0, void 0, function* () {
+    try {
+        const api = getState().config.api;
+        const token = (0, account_1.selectToken)(getState());
+        if (!token)
+            throw new Error(types_2.MISSING_CUSTOMER);
+        const houseAccounts = yield api.getCustomerHouseAccounts(token);
+        return houseAccounts;
+    }
+    catch (err) {
+        const error = err;
+        return (0, account_1.checkAuth)(error, dispatch, () => rejectWithValue(error));
+    }
+}));
+const customerHouseAccountsSlice = (0, toolkit_1.createSlice)({
+    name: types_1.ReducerType.HouseAccounts,
+    initialState,
+    reducers: {
+        resetCustomerHouseAccounts: () => initialState,
+        resetCustomerHouseAccountsError: state => {
+            state.error = null;
+            state.loading = 'idle';
+        },
+        setCustomerHouseAccounts: (state, action) => {
+            state.entities = action.payload;
+            state.error = null;
+        }
+    },
+    extraReducers: builder => {
+        builder
+            .addCase(exports.fetchCustomerHouseAccounts.fulfilled, (state, action) => {
+            state.entities = action.payload;
+            state.loading = 'idle';
+            state.error = null;
+        })
+            .addCase(exports.fetchCustomerHouseAccounts.pending, state => {
+            state.loading = 'pending';
+        })
+            .addCase(exports.fetchCustomerHouseAccounts.rejected, (state, action) => {
+            state.error = action.payload;
+            state.loading = 'idle';
+        });
+    }
+});
+_a = customerHouseAccountsSlice.actions, exports.resetCustomerHouseAccounts = _a.resetCustomerHouseAccounts, exports.resetCustomerHouseAccountsError = _a.resetCustomerHouseAccountsError, exports.setCustomerHouseAccounts = _a.setCustomerHouseAccounts;
+const selectCustomerHouseAccounts = (state) => state.customer.orders;
+exports.selectCustomerHouseAccounts = selectCustomerHouseAccounts;
+exports.customerHouseAccountsReducer = customerHouseAccountsSlice.reducer;

package/dist/cjs/slices/customer/index.d.ts

@@ -0,0 +1,29 @@
+export declare const customerReducer: import("redux").Reducer<import("redux").CombinedState<{
+    account: import("./account").AccountState;
+    allergens: import("./allergens").CustomerAllergensState;
+    addresses: import("./addresses").CustomerAddressesState;
+    communicationPreferences: import("./communicationPreferences").CustomerCommunicationPrefsState;
+    creditCards: import("./creditCards").CustomerCreditCardsState;
+    favorites: import("./favorites").CustomerFavoritesState;
+    fcmToken: import("./fcmToken").CustomerFcmTokenState;
+    giftCards: import("./giftCards").CustomerGiftCardsState;
+    orders: import("./orders").CustomerOrdersState;
+    order: import("./order").CustomerOrderState;
+    loyalty: import("./loyalty").CustomerLoyaltyState;
+    groupOrders: import("./groupOrders").CustomerGroupOrdersState;
+    houseAccounts: import("./houseAccounts").CustomerHouseAccountsState;
+    rewards: import("./rewards").CustomerRewardsState;
+    qrcode: import("./qrCode").CustomerQRCodeState;
+    thanx: import("./thanx").CustomerThanxState;
+    levelup: import("./levelup").CustomerLevelUpState;
+}>, import("redux").AnyAction>;
+export * from './account';
+export * from './allergens';
+export * from './addresses';
+export * from './communicationPreferences';
+export * from './creditCards';
+export * from './favorites';
+export * from './fcmToken';
+export * from './giftCards';
+export * from './orders';
+export * from './loyalty';

package/dist/cjs/slices/customer/index.js

@@ -0,0 +1,52 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.customerReducer = void 0;
+const tslib_1 = require("tslib");
+const redux_1 = require("redux");
+const types_1 = require("../types");
+const account_1 = require("./account");
+const addresses_1 = require("./addresses");
+const allergens_1 = require("./allergens");
+const communicationPreferences_1 = require("./communicationPreferences");
+const creditCards_1 = require("./creditCards");
+const favorites_1 = require("./favorites");
+const fcmToken_1 = require("./fcmToken");
+const giftCards_1 = require("./giftCards");
+const groupOrders_1 = require("./groupOrders");
+const houseAccounts_1 = require("./houseAccounts");
+const levelup_1 = require("./levelup");
+const loyalty_1 = require("./loyalty");
+const order_1 = require("./order");
+const orders_1 = require("./orders");
+const qrCode_1 = require("./qrCode");
+const rewards_1 = require("./rewards");
+const thanx_1 = require("./thanx");
+exports.customerReducer = (0, redux_1.combineReducers)({
+    [types_1.ReducerType.Account]: account_1.accountReducer,
+    [types_1.ReducerType.CustomerAllergens]: allergens_1.customerAllergensReducer,
+    [types_1.ReducerType.CustomerAddresses]: addresses_1.customerAddressesReducer,
+    [types_1.ReducerType.CommunicationPrefs]: communicationPreferences_1.customerCommunicationPrefsReducer,
+    [types_1.ReducerType.CreditCards]: creditCards_1.customerCreditCardsReducer,
+    [types_1.ReducerType.Favorites]: favorites_1.customerFavoritesReducer,
+    [types_1.ReducerType.FcmToken]: fcmToken_1.customerFcmTokenReducer,
+    [types_1.ReducerType.GiftCards]: giftCards_1.customerGiftCardsReducer,
+    [types_1.ReducerType.Orders]: orders_1.customerOrdersReducer,
+    [types_1.ReducerType.Order]: order_1.customerOrderReducer,
+    [types_1.ReducerType.Loyalty]: loyalty_1.customerLoyaltyReducer,
+    [types_1.ReducerType.GroupOrders]: groupOrders_1.customerGroupOrdersReducer,
+    [types_1.ReducerType.HouseAccounts]: houseAccounts_1.customerHouseAccountsReducer,
+    [types_1.ReducerType.Rewards]: rewards_1.customerRewardsReducer,
+    [types_1.ReducerType.QRCode]: qrCode_1.customerQRCodeReducer,
+    [types_1.ReducerType.Thanx]: thanx_1.customerThanxReducer,
+    [types_1.ReducerType.Levelup]: levelup_1.customerLevelUpReducer
+});
+tslib_1.__exportStar(require("./account"), exports);
+tslib_1.__exportStar(require("./allergens"), exports);
+tslib_1.__exportStar(require("./addresses"), exports);
+tslib_1.__exportStar(require("./communicationPreferences"), exports);
+tslib_1.__exportStar(require("./creditCards"), exports);
+tslib_1.__exportStar(require("./favorites"), exports);
+tslib_1.__exportStar(require("./fcmToken"), exports);
+tslib_1.__exportStar(require("./giftCards"), exports);
+tslib_1.__exportStar(require("./orders"), exports);
+tslib_1.__exportStar(require("./loyalty"), exports);

package/dist/cjs/slices/customer/levelup.d.ts

@@ -0,0 +1,36 @@
+import { AppState } from '../../app';
+import { LevelUp, RequestError, RequestStatus } from '@open-tender/types';
+export interface CustomerLevelUpState {
+    entities: LevelUp[];
+    error: RequestError;
+    loading: RequestStatus;
+    lookup: {
+        [key: number]: number;
+    };
+}
+export declare enum CustomerLevelUpActionType {
+    FetchCustomerLevelUp = "customer/fetchCustomerLevelUp",
+    RemoveCustomerLevelUp = "customer/removeCustomerLevelUp",
+    AddCustomerLevelUp = "customer/addCustomerLevelUp"
+}
+export declare const fetchCustomerLevelUp: import("@reduxjs/toolkit").AsyncThunk<LevelUp[], void, {
+    state: AppState;
+    rejectValue: RequestError;
+}>;
+export declare const removeCustomerLevelUp: import("@reduxjs/toolkit").AsyncThunk<LevelUp[], {
+    levelupConnectId: number;
+    callback?: (() => void) | undefined;
+}, {
+    state: AppState;
+    rejectValue: RequestError;
+}>;
+export declare const addCustomerLevelUp: import("@reduxjs/toolkit").AsyncThunk<LevelUp[], {
+    data: LevelUp;
+    callback?: (() => void) | undefined;
+}, {
+    state: AppState;
+    rejectValue: RequestError;
+}>;
+export declare const resetCustomerLevelUp: import("@reduxjs/toolkit").ActionCreatorWithoutPayload<string>, setCustomerLevelUp: import("@reduxjs/toolkit").ActionCreatorWithPayload<any, string>;
+export declare const selectCustomerLevelUp: (state: AppState) => CustomerLevelUpState;
+export declare const customerLevelUpReducer: import("redux").Reducer<CustomerLevelUpState, import("redux").AnyAction>;