@open-tender/cloud 0.0.137 → 0.1.0

package/dist/esm/slices/customer/creditCards.d.ts

@@ -17,6 +17,12 @@ export declare enum CustomerCreditCardsActionType {
 export declare const fetchCustomerCreditCards: import("@reduxjs/toolkit").AsyncThunk<CreditCards, boolean | undefined, {
     state: AppState;
     rejectValue: RequestError;
+    dispatch?: import("redux").Dispatch<import("redux").AnyAction> | undefined;
+    extra?: unknown;
+    serializedErrorType?: unknown;
+    pendingMeta?: unknown;
+    fulfilledMeta?: unknown;
+    rejectedMeta?: unknown;
 }>;
 export declare const updateCustomerCreditCard: import("@reduxjs/toolkit").AsyncThunk<CreditCards, {
     cardId: number;
@@ -25,6 +31,12 @@ export declare const updateCustomerCreditCard: import("@reduxjs/toolkit").AsyncT
 }, {
     state: AppState;
     rejectValue: RequestError;
+    dispatch?: import("redux").Dispatch<import("redux").AnyAction> | undefined;
+    extra?: unknown;
+    serializedErrorType?: unknown;
+    pendingMeta?: unknown;
+    fulfilledMeta?: unknown;
+    rejectedMeta?: unknown;
 }>;
 export declare const removeCustomerCreditCard: import("@reduxjs/toolkit").AsyncThunk<CreditCards, {
     cardId: number;
@@ -32,6 +44,12 @@ export declare const removeCustomerCreditCard: import("@reduxjs/toolkit").AsyncT
 }, {
     state: AppState;
     rejectValue: RequestError;
+    dispatch?: import("redux").Dispatch<import("redux").AnyAction> | undefined;
+    extra?: unknown;
+    serializedErrorType?: unknown;
+    pendingMeta?: unknown;
+    fulfilledMeta?: unknown;
+    rejectedMeta?: unknown;
 }>;
 export declare const addCustomerCreditCard: import("@reduxjs/toolkit").AsyncThunk<CreditCards, {
     data: CreditCard;
@@ -39,8 +57,14 @@ export declare const addCustomerCreditCard: import("@reduxjs/toolkit").AsyncThun
 }, {
     state: AppState;
     rejectValue: RequestError;
+    dispatch?: import("redux").Dispatch<import("redux").AnyAction> | undefined;
+    extra?: unknown;
+    serializedErrorType?: unknown;
+    pendingMeta?: unknown;
+    fulfilledMeta?: unknown;
+    rejectedMeta?: unknown;
 }>;
-export declare const resetCustomerCreditCards: import("@reduxjs/toolkit").ActionCreatorWithoutPayload<string>, resetCustomerCreditCardsError: import("@reduxjs/toolkit").ActionCreatorWithoutPayload<string>, setCustomerCreditCards: import("@reduxjs/toolkit").ActionCreatorWithPayload<any, string>;
+export declare const resetCustomerCreditCards: import("@reduxjs/toolkit").ActionCreatorWithoutPayload<"creditCards/resetCustomerCreditCards">, resetCustomerCreditCardsError: import("@reduxjs/toolkit").ActionCreatorWithoutPayload<"creditCards/resetCustomerCreditCardsError">, setCustomerCreditCards: import("@reduxjs/toolkit").ActionCreatorWithPayload<any, "creditCards/setCustomerCreditCards">;
 export declare const selectCustomerCreditCards: (state: AppState) => CustomerCreditCardsState;
 export declare const selectCustomerCreditCardsForPayment: (state: AppState) => CreditCard[];
 export declare const customerCreditCardsReducer: import("redux").Reducer<CustomerCreditCardsState, import("redux").AnyAction>;

package/dist/esm/slices/customer/favorites.d.ts

@@ -1,5 +1,5 @@
 import { AppState } from '../../app';
-import { Favorite, FavoriteItem, Favorites, RequestError, RequestStatus } from '@open-tender/types';
+import { Favorite, Favorites, RequestError, RequestStatus, SimpleCart } from '@open-tender/types';
 export interface CustomerFavoritesState {
     entities: Favorites;
     error: RequestError;
@@ -17,6 +17,12 @@ export declare enum CustomerFavoritesActionType {
 export declare const fetchCustomerFavorites: import("@reduxjs/toolkit").AsyncThunk<Favorites, void, {
     state: AppState;
     rejectValue: RequestError;
+    dispatch?: import("redux").Dispatch<import("redux").AnyAction> | undefined;
+    extra?: unknown;
+    serializedErrorType?: unknown;
+    pendingMeta?: unknown;
+    fulfilledMeta?: unknown;
+    rejectedMeta?: unknown;
 }>;
 export declare const updateCustomerFavorite: import("@reduxjs/toolkit").AsyncThunk<Favorites, {
     favoriteId: number;
@@ -25,6 +31,12 @@ export declare const updateCustomerFavorite: import("@reduxjs/toolkit").AsyncThu
 }, {
     state: AppState;
     rejectValue: RequestError;
+    dispatch?: import("redux").Dispatch<import("redux").AnyAction> | undefined;
+    extra?: unknown;
+    serializedErrorType?: unknown;
+    pendingMeta?: unknown;
+    fulfilledMeta?: unknown;
+    rejectedMeta?: unknown;
 }>;
 export declare const removeCustomerFavorite: import("@reduxjs/toolkit").AsyncThunk<Favorites, {
     favoriteId: number;
@@ -32,14 +44,27 @@ export declare const removeCustomerFavorite: import("@reduxjs/toolkit").AsyncThu
 }, {
     state: AppState;
     rejectValue: RequestError;
+    dispatch?: import("redux").Dispatch<import("redux").AnyAction> | undefined;
+    extra?: unknown;
+    serializedErrorType?: unknown;
+    pendingMeta?: unknown;
+    fulfilledMeta?: unknown;
+    rejectedMeta?: unknown;
 }>;
 export declare const addCustomerFavorite: import("@reduxjs/toolkit").AsyncThunk<Favorites, {
-    data: Partial<FavoriteItem>;
+    cart: SimpleCart;
+    name?: string | undefined;
     callback?: (() => void) | undefined;
 }, {
     state: AppState;
     rejectValue: RequestError;
+    dispatch?: import("redux").Dispatch<import("redux").AnyAction> | undefined;
+    extra?: unknown;
+    serializedErrorType?: unknown;
+    pendingMeta?: unknown;
+    fulfilledMeta?: unknown;
+    rejectedMeta?: unknown;
 }>;
-export declare const resetCustomerFavorites: import("@reduxjs/toolkit").ActionCreatorWithoutPayload<string>, resetCustomerFavoritesError: import("@reduxjs/toolkit").ActionCreatorWithoutPayload<string>, setCustomerFavorites: import("@reduxjs/toolkit").ActionCreatorWithPayload<any, string>, setCustomerFavoritesLookup: import("@reduxjs/toolkit").ActionCreatorWithPayload<any, string>;
+export declare const resetCustomerFavorites: import("@reduxjs/toolkit").ActionCreatorWithoutPayload<"favorites/resetCustomerFavorites">, resetCustomerFavoritesError: import("@reduxjs/toolkit").ActionCreatorWithoutPayload<"favorites/resetCustomerFavoritesError">, setCustomerFavorites: import("@reduxjs/toolkit").ActionCreatorWithPayload<any, "favorites/setCustomerFavorites">, setCustomerFavoritesLookup: import("@reduxjs/toolkit").ActionCreatorWithPayload<any, "favorites/setCustomerFavoritesLookup">;
 export declare const selectCustomerFavorites: (state: AppState) => CustomerFavoritesState;
 export declare const customerFavoritesReducer: import("redux").Reducer<CustomerFavoritesState, import("redux").AnyAction>;

package/dist/esm/slices/customer/favorites.js

@@ -74,20 +74,19 @@ export const removeCustomerFavorite = createAsyncThunk(CustomerFavoritesActionTy
         return checkAuth(error, dispatch, () => rejectWithValue(error));
     }
 }));
-export const addCustomerFavorite = createAsyncThunk(CustomerFavoritesActionType.AddCustomerFavorite, (requestData, { dispatch, getState, rejectWithValue }) => __awaiter(void 0, void 0, void 0, function* () {
+export const addCustomerFavorite = createAsyncThunk(CustomerFavoritesActionType.AddCustomerFavorite, ({ cart, name, callback }, { dispatch, getState, rejectWithValue }) => __awaiter(void 0, void 0, void 0, function* () {
     try {
         const api = getState().config.api;
         const token = selectToken(getState());
         if (!token)
             throw new Error(MISSING_CUSTOMER);
-        if (!requestData.data.name)
-            requestData.data.name = '';
-        yield api.postCustomerFavorite(token, requestData.data);
+        const data = { cart, name: name || '' };
+        yield api.postCustomerFavorite(token, data);
         const { data: favorites } = yield api.getCustomerFavorites(token);
         const lookup = makeFavoritesLookup(favorites);
         dispatch(setCustomerFavoritesLookup(lookup));
-        if (requestData.callback)
-            requestData.callback();
+        if (callback)
+            callback();
         return favorites;
     }
     catch (err) {

package/dist/esm/slices/customer/fcmToken.d.ts

@@ -12,12 +12,24 @@ export declare enum CustomerFcmTokenActionType {
 export declare const fetchCustomerFcmTokens: import("@reduxjs/toolkit").AsyncThunk<void, void, {
     state: AppState;
     rejectValue: RequestError;
+    dispatch?: import("redux").Dispatch<import("redux").AnyAction> | undefined;
+    extra?: unknown;
+    serializedErrorType?: unknown;
+    pendingMeta?: unknown;
+    fulfilledMeta?: unknown;
+    rejectedMeta?: unknown;
 }>;
 export declare const removeCustomerFcmTokens: import("@reduxjs/toolkit").AsyncThunk<void, {
     callback?: (() => void) | undefined;
 }, {
     state: AppState;
     rejectValue: RequestError;
+    dispatch?: import("redux").Dispatch<import("redux").AnyAction> | undefined;
+    extra?: unknown;
+    serializedErrorType?: unknown;
+    pendingMeta?: unknown;
+    fulfilledMeta?: unknown;
+    rejectedMeta?: unknown;
 }>;
 export declare const addCustomerFcmToken: import("@reduxjs/toolkit").AsyncThunk<void, {
     fcmToken: string;
@@ -25,7 +37,13 @@ export declare const addCustomerFcmToken: import("@reduxjs/toolkit").AsyncThunk<
 }, {
     state: AppState;
     rejectValue: RequestError;
+    dispatch?: import("redux").Dispatch<import("redux").AnyAction> | undefined;
+    extra?: unknown;
+    serializedErrorType?: unknown;
+    pendingMeta?: unknown;
+    fulfilledMeta?: unknown;
+    rejectedMeta?: unknown;
 }>;
-export declare const resetCustomerFcmToken: import("@reduxjs/toolkit").ActionCreatorWithoutPayload<string>;
+export declare const resetCustomerFcmToken: import("@reduxjs/toolkit").ActionCreatorWithoutPayload<"fcmToken/resetCustomerFcmToken">;
 export declare const selectCustomerFcmToken: (state: AppState) => CustomerFcmTokenState;
 export declare const customerFcmTokenReducer: import("redux").Reducer<CustomerFcmTokenState, import("redux").AnyAction>;

package/dist/esm/slices/customer/giftCards.d.ts

@@ -19,6 +19,12 @@ export declare enum CustomerGiftCardsActionType {
 export declare const fetchCustomerGiftCards: import("@reduxjs/toolkit").AsyncThunk<CustomerGiftCards, void, {
     state: AppState;
     rejectValue: RequestError;
+    dispatch?: import("redux").Dispatch<import("redux").AnyAction> | undefined;
+    extra?: unknown;
+    serializedErrorType?: unknown;
+    pendingMeta?: unknown;
+    fulfilledMeta?: unknown;
+    rejectedMeta?: unknown;
 }>;
 export declare const updateCustomerGiftCard: import("@reduxjs/toolkit").AsyncThunk<CustomerGiftCards, {
     giftCardId: number;
@@ -27,6 +33,12 @@ export declare const updateCustomerGiftCard: import("@reduxjs/toolkit").AsyncThu
 }, {
     state: AppState;
     rejectValue: RequestError;
+    dispatch?: import("redux").Dispatch<import("redux").AnyAction> | undefined;
+    extra?: unknown;
+    serializedErrorType?: unknown;
+    pendingMeta?: unknown;
+    fulfilledMeta?: unknown;
+    rejectedMeta?: unknown;
 }>;
 export declare const removeCustomerGiftCard: import("@reduxjs/toolkit").AsyncThunk<CustomerGiftCards, {
     giftCardId: number;
@@ -34,6 +46,12 @@ export declare const removeCustomerGiftCard: import("@reduxjs/toolkit").AsyncThu
 }, {
     state: AppState;
     rejectValue: RequestError;
+    dispatch?: import("redux").Dispatch<import("redux").AnyAction> | undefined;
+    extra?: unknown;
+    serializedErrorType?: unknown;
+    pendingMeta?: unknown;
+    fulfilledMeta?: unknown;
+    rejectedMeta?: unknown;
 }>;
 export declare const addCustomerGiftCard: import("@reduxjs/toolkit").AsyncThunk<CustomerGiftCards, {
     data: CustomerGiftCard;
@@ -41,6 +59,12 @@ export declare const addCustomerGiftCard: import("@reduxjs/toolkit").AsyncThunk<
 }, {
     state: AppState;
     rejectValue: RequestError;
+    dispatch?: import("redux").Dispatch<import("redux").AnyAction> | undefined;
+    extra?: unknown;
+    serializedErrorType?: unknown;
+    pendingMeta?: unknown;
+    fulfilledMeta?: unknown;
+    rejectedMeta?: unknown;
 }>;
 export declare const assignCustomerGiftCard: import("@reduxjs/toolkit").AsyncThunk<CustomerGiftCards, {
     cardNumber: number;
@@ -48,6 +72,12 @@ export declare const assignCustomerGiftCard: import("@reduxjs/toolkit").AsyncThu
 }, {
     state: AppState;
     rejectValue: RequestError;
+    dispatch?: import("redux").Dispatch<import("redux").AnyAction> | undefined;
+    extra?: unknown;
+    serializedErrorType?: unknown;
+    pendingMeta?: unknown;
+    fulfilledMeta?: unknown;
+    rejectedMeta?: unknown;
 }>;
 export declare const assignCustomerGiftCardOther: import("@reduxjs/toolkit").AsyncThunk<CustomerGiftCards, {
     giftCardId: number;
@@ -56,7 +86,13 @@ export declare const assignCustomerGiftCardOther: import("@reduxjs/toolkit").Asy
 }, {
     state: AppState;
     rejectValue: RequestError;
+    dispatch?: import("redux").Dispatch<import("redux").AnyAction> | undefined;
+    extra?: unknown;
+    serializedErrorType?: unknown;
+    pendingMeta?: unknown;
+    fulfilledMeta?: unknown;
+    rejectedMeta?: unknown;
 }>;
-export declare const resetCustomerGiftCards: import("@reduxjs/toolkit").ActionCreatorWithoutPayload<string>, resetCustomerGiftCardsError: import("@reduxjs/toolkit").ActionCreatorWithoutPayload<string>, setCustomerGiftCards: import("@reduxjs/toolkit").ActionCreatorWithPayload<any, string>;
+export declare const resetCustomerGiftCards: import("@reduxjs/toolkit").ActionCreatorWithoutPayload<"giftCards/resetCustomerGiftCards">, resetCustomerGiftCardsError: import("@reduxjs/toolkit").ActionCreatorWithoutPayload<"giftCards/resetCustomerGiftCardsError">, setCustomerGiftCards: import("@reduxjs/toolkit").ActionCreatorWithPayload<any, "giftCards/setCustomerGiftCards">;
 export declare const selectCustomerGiftCards: (state: AppState) => CustomerGiftCardsState;
 export declare const customerGiftCardsReducer: import("redux").Reducer<CustomerGiftCardsState, import("redux").AnyAction>;

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

@@ -1,5 +1,5 @@
 import { AppState } from '../../app';
-import { GroupOrder, GroupOrders, OrderItem, RequestError, RequestStatus } from '@open-tender/types';
+import { GroupOrder, GroupOrders, RequestError, RequestStatus } from '@open-tender/types';
 import { OrderState } from '../order';
 export interface CustomerGroupOrdersState {
     entities: GroupOrders;
@@ -21,74 +21,98 @@ export declare enum CustomerGroupOrdersActionType {
 export declare const fetchCustomerGroupOrders: import("@reduxjs/toolkit").AsyncThunk<GroupOrders, void, {
     state: AppState;
     rejectValue: RequestError;
+    dispatch?: import("redux").Dispatch<import("redux").AnyAction> | undefined;
+    extra?: unknown;
+    serializedErrorType?: unknown;
+    pendingMeta?: unknown;
+    fulfilledMeta?: unknown;
+    rejectedMeta?: unknown;
 }>;
 export declare const fetchCustomerGroupOrder: import("@reduxjs/toolkit").AsyncThunk<GroupOrders, number, {
     state: AppState;
     rejectValue: RequestError;
+    dispatch?: import("redux").Dispatch<import("redux").AnyAction> | undefined;
+    extra?: unknown;
+    serializedErrorType?: unknown;
+    pendingMeta?: unknown;
+    fulfilledMeta?: unknown;
+    rejectedMeta?: unknown;
 }>;
-export declare const makeCartData: (order: OrderState, data?: Partial<GroupOrder>) => {
-    order_id?: string | null | undefined;
+export declare const makeCartData: (order: OrderState, spendingLimit?: string) => {
     address: import("@open-tender/types").Address | null;
-    cart: OrderItem[] | {
+    revenue_center_id: number;
+    service_type: import("@open-tender/types").ServiceType | null;
+    requested_at: string | null;
+    cart: {
         id: number;
-        quantity: number | undefined;
-        groups: {
-            id: number | undefined;
-            options: {
-                id: number;
-                quantity: number | undefined;
-            }[];
-        }[] | undefined;
+        quantity: number;
+        groups: import("@open-tender/types").SimpleCartGroups;
         made_for: string;
         notes: string;
     }[];
-    cartGuest?: any;
-    cartGuests?: any;
-    cart_guests?: any;
-    cart_id?: number | undefined;
-    cartOwner?: import("@open-tender/types").CartOwner | undefined;
-    customer?: import("@open-tender/types").CartOwner | undefined;
-    closed?: boolean | undefined;
-    cutoff_at?: string | undefined;
-    error?: import("@open-tender/types").RequestErrorAPI | undefined;
-    guest_count?: number | undefined;
-    guest_limit?: number | undefined;
-    isCartOwner?: boolean | undefined;
-    loading?: RequestStatus | undefined;
-    requested_at: string | null;
-    revenue_center?: import("@open-tender/types").OrderRevenueCenter | undefined;
-    revenue_center_id: number | undefined;
+} | {
+    spending_limit: string;
+    address: import("@open-tender/types").Address | null;
+    revenue_center_id: number;
     service_type: import("@open-tender/types").ServiceType | null;
-    spending_limit: string | null;
-    token?: string | undefined;
-    spendingLimit?: string | undefined;
-};
-export declare const removeCustomerGroupOrder: import("@reduxjs/toolkit").AsyncThunk<GroupOrders, {
+    requested_at: string | null;
+    cart: {
+        id: number;
+        quantity: number;
+        groups: import("@open-tender/types").SimpleCartGroups;
+        made_for: string;
+        notes: string;
+    }[];
+} | null;
+export declare const updateCustomerGroupOrder: import("@reduxjs/toolkit").AsyncThunk<GroupOrders, {
     cartId: number;
     callback?: (() => void) | undefined;
 }, {
     state: AppState;
     rejectValue: RequestError;
+    dispatch?: import("redux").Dispatch<import("redux").AnyAction> | undefined;
+    extra?: unknown;
+    serializedErrorType?: unknown;
+    pendingMeta?: unknown;
+    fulfilledMeta?: unknown;
+    rejectedMeta?: unknown;
 }>;
-export declare const reopenGroupOrder: import("@reduxjs/toolkit").AsyncThunk<(GroupOrder | undefined)[], Partial<GroupOrder>, {
+export declare const closeGroupOrder: import("@reduxjs/toolkit").AsyncThunk<boolean, {
+    cartId: number;
+    closed: boolean;
+}, {
     state: AppState;
     rejectValue: RequestError;
+    dispatch?: import("redux").Dispatch<import("redux").AnyAction> | undefined;
+    extra?: unknown;
+    serializedErrorType?: unknown;
+    pendingMeta?: unknown;
+    fulfilledMeta?: unknown;
+    rejectedMeta?: unknown;
 }>;
-export declare const updateCustomerGroupOrder: import("@reduxjs/toolkit").AsyncThunk<GroupOrders, {
+export declare const removeCustomerGroupOrder: import("@reduxjs/toolkit").AsyncThunk<GroupOrders, {
     cartId: number;
-    data?: Partial<GroupOrder> | undefined;
     callback?: (() => void) | undefined;
 }, {
     state: AppState;
     rejectValue: RequestError;
+    dispatch?: import("redux").Dispatch<import("redux").AnyAction> | undefined;
+    extra?: unknown;
+    serializedErrorType?: unknown;
+    pendingMeta?: unknown;
+    fulfilledMeta?: unknown;
+    rejectedMeta?: unknown;
 }>;
-export declare const closeGroupOrder: import("@reduxjs/toolkit").AsyncThunk<boolean, {
-    cartId: number;
-    closed: boolean;
-}, {
+export declare const reopenGroupOrder: import("@reduxjs/toolkit").AsyncThunk<(GroupOrder | undefined)[], Partial<GroupOrder>, {
     state: AppState;
     rejectValue: RequestError;
+    dispatch?: import("redux").Dispatch<import("redux").AnyAction> | undefined;
+    extra?: unknown;
+    serializedErrorType?: unknown;
+    pendingMeta?: unknown;
+    fulfilledMeta?: unknown;
+    rejectedMeta?: unknown;
 }>;
-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 resetCustomerGroupOrders: import("@reduxjs/toolkit").ActionCreatorWithoutPayload<"groupOrders/resetCustomerGroupOrders">, resetCustomerGroupOrdersError: import("@reduxjs/toolkit").ActionCreatorWithoutPayload<"groupOrders/resetCustomerGroupOrdersError">, setCustomerGroupOrders: import("@reduxjs/toolkit").ActionCreatorWithPayload<any, "groupOrders/setCustomerGroupOrders">;
 export declare const selectCustomerGroupOrders: (state: AppState) => CustomerGroupOrdersState;
 export declare const customerGroupOrdersReducer: import("redux").Reducer<CustomerGroupOrdersState, import("redux").AnyAction>;

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

@@ -1,7 +1,7 @@
 import { __awaiter } from "tslib";
 import { createAsyncThunk, createSlice } from '@reduxjs/toolkit';
 import { ReducerType } from '../types';
-import { MISSING_CUSTOMER, } from '@open-tender/types';
+import { MISSING_CUSTOMER } from '@open-tender/types';
 import { checkAuth, selectToken } from './account';
 import { makeCartPayload, resetGroupOrder } from '../groupOrder';
 import { addMessage, resetAlert, setAlert, setCart, setRequestedAt, setRevenueCenter } from '../order';
@@ -51,25 +51,63 @@ export const fetchCustomerGroupOrder = createAsyncThunk(CustomerGroupOrdersActio
         return checkAuth(error, dispatch, () => rejectWithValue(error));
     }
 }));
-export const makeCartData = (order, data = {}) => {
+export const makeCartData = (order, spendingLimit) => {
     const { address, revenueCenter, requestedAt, serviceType, cart } = order;
+    if (!revenueCenter)
+        return null;
     const orderData = {
         address,
         revenue_center_id: revenueCenter === null || revenueCenter === void 0 ? void 0 : revenueCenter.revenue_center_id,
         service_type: serviceType,
         requested_at: requestedAt,
-        cart: makeSimpleCart(cart !== null && cart !== void 0 ? cart : []),
-        spending_limit: null
+        cart: cart ? makeSimpleCart(cart) : []
     };
-    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);
+    return spendingLimit
+        ? Object.assign(Object.assign({}, orderData), { spending_limit: spendingLimit }) : orderData;
 };
+export const updateCustomerGroupOrder = createAsyncThunk(CustomerGroupOrdersActionType.UpdateCustomerGroupOrder, ({ cartId, callback }, { dispatch, getState, rejectWithValue }) => __awaiter(void 0, void 0, void 0, function* () {
+    var _a;
+    try {
+        const api = getState().config.api;
+        const token = selectToken(getState());
+        if (!token)
+            throw new Error(MISSING_CUSTOMER);
+        const cartData = makeCartData(getState().order);
+        yield api.putCustomerGroupOrder(token, cartId, cartData);
+        const response = yield api.getCustomerGroupOrder(token, cartId);
+        const { requestedAt, revenueCenter } = getState().order;
+        if (response.requested_at !== requestedAt) {
+            dispatch(setRequestedAt(response.requested_at));
+            const tz = timezoneMap[(_a = revenueCenter === null || revenueCenter === void 0 ? void 0 : revenueCenter.timezone) !== null && _a !== void 0 ? _a : 'US/Central'];
+            const requestedAtText = makeRequestedAtStr(response.requested_at, tz);
+            dispatch(addMessage(`Requested time updated to ${requestedAtText}`));
+        }
+        const payload = Object.assign(Object.assign({}, makeCartPayload(response)), { isCartOwner: true });
+        if (callback)
+            callback();
+        return payload;
+    }
+    catch (err) {
+        const error = err;
+        return checkAuth(error, dispatch, () => rejectWithValue(error));
+    }
+}));
+export const closeGroupOrder = createAsyncThunk(CustomerGroupOrdersActionType.CloseCustomerGroupOrder, (requestData, { dispatch, getState, rejectWithValue }) => __awaiter(void 0, void 0, void 0, function* () {
+    try {
+        const api = getState().config.api;
+        const token = selectToken(getState());
+        if (!token)
+            throw new Error(MISSING_CUSTOMER);
+        yield api.putCustomerGroupOrderStatus(token, requestData.cartId, {
+            closed
+        });
+        return requestData.closed;
+    }
+    catch (err) {
+        const error = err;
+        return checkAuth(error, dispatch, () => rejectWithValue(error));
+    }
+}));
 export const removeCustomerGroupOrder = createAsyncThunk(CustomerGroupOrdersActionType.RemoveCustomerGroupOrder, (requestData, { dispatch, getState, rejectWithValue }) => __awaiter(void 0, void 0, void 0, function* () {
     try {
         const api = getState().config.api;
@@ -97,7 +135,10 @@ export const reopenGroupOrder = createAsyncThunk(CustomerGroupOrdersActionType.R
         const token = selectToken(getState());
         if (!token)
             throw new Error(MISSING_CUSTOMER);
-        const alert = { type: 'working', args: { text: 'Building your order...' } };
+        const alert = {
+            type: 'working',
+            args: { text: 'Building your order...' }
+        };
         dispatch(setAlert(alert));
         const { revenue_center_id, service_type, requested_at, cart_id } = cart;
         const revenueCenter = yield api.getLocation(revenue_center_id);
@@ -123,47 +164,6 @@ export const reopenGroupOrder = createAsyncThunk(CustomerGroupOrdersActionType.R
         return checkAuth(error, dispatch, () => rejectWithValue(error));
     }
 }));
-export const updateCustomerGroupOrder = createAsyncThunk(CustomerGroupOrdersActionType.UpdateCustomerGroupOrder, (requestData, { dispatch, getState, rejectWithValue }) => __awaiter(void 0, void 0, void 0, function* () {
-    var _a;
-    try {
-        const api = getState().config.api;
-        const token = selectToken(getState());
-        if (!token)
-            throw new Error(MISSING_CUSTOMER);
-        const cartData = makeCartData(getState().order, requestData.data);
-        yield api.putCustomerGroupOrder(token, requestData.cartId, cartData);
-        const response = yield api.getCustomerGroupOrder(token, requestData.cartId);
-        const { requestedAt, revenueCenter } = getState().order;
-        if (response.requested_at !== requestedAt) {
-            dispatch(setRequestedAt(response.requested_at));
-            const tz = timezoneMap[(_a = revenueCenter === null || revenueCenter === void 0 ? void 0 : revenueCenter.timezone) !== null && _a !== void 0 ? _a : 'US/Central'];
-            const requestedAtText = makeRequestedAtStr(response.requested_at, tz);
-            dispatch(addMessage(`Requested time updated to ${requestedAtText}`));
-        }
-        const payload = Object.assign(Object.assign({}, makeCartPayload(response)), { isCartOwner: true });
-        if (requestData.callback)
-            requestData.callback();
-        return payload;
-    }
-    catch (err) {
-        const error = err;
-        return checkAuth(error, dispatch, () => rejectWithValue(error));
-    }
-}));
-export const closeGroupOrder = createAsyncThunk(CustomerGroupOrdersActionType.CloseCustomerGroupOrder, (requestData, { dispatch, getState, rejectWithValue }) => __awaiter(void 0, void 0, void 0, function* () {
-    try {
-        const api = getState().config.api;
-        const token = selectToken(getState());
-        if (!token)
-            throw new Error(MISSING_CUSTOMER);
-        yield api.putCustomerGroupOrderStatus(token, requestData.cartId, { closed });
-        return requestData.closed;
-    }
-    catch (err) {
-        const error = err;
-        return checkAuth(error, dispatch, () => rejectWithValue(error));
-    }
-}));
 const customerGroupOrdersSlice = createSlice({
     name: ReducerType.GroupOrders,
     initialState,

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

@@ -14,7 +14,13 @@ export declare enum CustomerHouseAccountsActionType {
 export declare const fetchCustomerHouseAccounts: import("@reduxjs/toolkit").AsyncThunk<HouseAccounts, void, {
     state: AppState;
     rejectValue: RequestError;
+    dispatch?: import("redux").Dispatch<import("redux").AnyAction> | undefined;
+    extra?: unknown;
+    serializedErrorType?: unknown;
+    pendingMeta?: unknown;
+    fulfilledMeta?: unknown;
+    rejectedMeta?: unknown;
 }>;
-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 resetCustomerHouseAccounts: import("@reduxjs/toolkit").ActionCreatorWithoutPayload<"houseAccounts/resetCustomerHouseAccounts">, resetCustomerHouseAccountsError: import("@reduxjs/toolkit").ActionCreatorWithoutPayload<"houseAccounts/resetCustomerHouseAccountsError">, setCustomerHouseAccounts: import("@reduxjs/toolkit").ActionCreatorWithPayload<any, "houseAccounts/setCustomerHouseAccounts">;
 export declare const selectCustomerHouseAccounts: (state: AppState) => CustomerHouseAccountsState;
 export declare const customerHouseAccountsReducer: import("redux").Reducer<CustomerHouseAccountsState, import("redux").AnyAction>;

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

@@ -17,6 +17,12 @@ export declare enum CustomerLevelUpActionType {
 export declare const fetchCustomerLevelUp: import("@reduxjs/toolkit").AsyncThunk<LevelUp[], void, {
     state: AppState;
     rejectValue: RequestError;
+    dispatch?: import("redux").Dispatch<import("redux").AnyAction> | undefined;
+    extra?: unknown;
+    serializedErrorType?: unknown;
+    pendingMeta?: unknown;
+    fulfilledMeta?: unknown;
+    rejectedMeta?: unknown;
 }>;
 export declare const removeCustomerLevelUp: import("@reduxjs/toolkit").AsyncThunk<LevelUp[], {
     levelupConnectId: number;
@@ -24,6 +30,12 @@ export declare const removeCustomerLevelUp: import("@reduxjs/toolkit").AsyncThun
 }, {
     state: AppState;
     rejectValue: RequestError;
+    dispatch?: import("redux").Dispatch<import("redux").AnyAction> | undefined;
+    extra?: unknown;
+    serializedErrorType?: unknown;
+    pendingMeta?: unknown;
+    fulfilledMeta?: unknown;
+    rejectedMeta?: unknown;
 }>;
 export declare const addCustomerLevelUp: import("@reduxjs/toolkit").AsyncThunk<LevelUp[], {
     data: LevelUp;
@@ -31,8 +43,14 @@ export declare const addCustomerLevelUp: import("@reduxjs/toolkit").AsyncThunk<L
 }, {
     state: AppState;
     rejectValue: RequestError;
+    dispatch?: import("redux").Dispatch<import("redux").AnyAction> | undefined;
+    extra?: unknown;
+    serializedErrorType?: unknown;
+    pendingMeta?: unknown;
+    fulfilledMeta?: unknown;
+    rejectedMeta?: unknown;
 }>;
-export declare const resetCustomerLevelUp: import("@reduxjs/toolkit").ActionCreatorWithoutPayload<string>, setCustomerLevelUp: import("@reduxjs/toolkit").ActionCreatorWithPayload<any, string>, resetCustomerLevelUpError: import("@reduxjs/toolkit").ActionCreatorWithoutPayload<string>;
+export declare const resetCustomerLevelUp: import("@reduxjs/toolkit").ActionCreatorWithoutPayload<"levelup/resetCustomerLevelUp">, setCustomerLevelUp: import("@reduxjs/toolkit").ActionCreatorWithPayload<any, "levelup/setCustomerLevelUp">, resetCustomerLevelUpError: import("@reduxjs/toolkit").ActionCreatorWithoutPayload<"levelup/resetCustomerLevelUpError">;
 export declare const selectCustomerLevelUp: (state: AppState) => CustomerLevelUpState;
 export declare const customerLevelUpReducer: import("redux").Reducer<CustomerLevelUpState, import("redux").AnyAction>;
 export declare const makeLevelUpProgram: (user: any) => {

package/dist/esm/slices/customer/levelup.js

@@ -95,7 +95,7 @@ const customerLevelUpSlice = createSlice({
         resetCustomerLevelUpError: state => {
             state.error = null;
             state.loading = 'idle';
-        },
+        }
     },
     extraReducers: builder => {
         builder
@@ -157,7 +157,7 @@ export const makeLevelUpProgram = (user) => {
     spend = parseFloat(spend);
     threshold = parseFloat(threshold);
     const remaining = threshold - spend;
-    const progress = ((spend / threshold) * 100);
+    const progress = (spend / threshold) * 100;
     return {
         name,
         description,
@@ -167,7 +167,7 @@ export const makeLevelUpProgram = (user) => {
         threshold: threshold.toFixed(2),
         credit: credit.toFixed(2),
         towards: `$${reward} off your order`,
-        rewards: [],
+        rewards: []
     };
 };
 export const selectCustomerLevelUpProgram = (state) => {

package/dist/esm/slices/customer/loyalty.d.ts

@@ -14,8 +14,14 @@ export declare enum CustomerLoyaltyActionType {
 export declare const fetchCustomerLoyalty: import("@reduxjs/toolkit").AsyncThunk<CustomerLoyalties, void, {
     state: AppState;
     rejectValue: RequestError;
+    dispatch?: import("redux").Dispatch<import("redux").AnyAction> | undefined;
+    extra?: unknown;
+    serializedErrorType?: unknown;
+    pendingMeta?: unknown;
+    fulfilledMeta?: unknown;
+    rejectedMeta?: unknown;
 }>;
-export declare const resetCustomerLoyalty: import("@reduxjs/toolkit").ActionCreatorWithoutPayload<string>, resetCustomerLoyaltyError: import("@reduxjs/toolkit").ActionCreatorWithoutPayload<string>, setCustomerLoyalty: import("@reduxjs/toolkit").ActionCreatorWithPayload<any, string>;
+export declare const resetCustomerLoyalty: import("@reduxjs/toolkit").ActionCreatorWithoutPayload<"loyalty/resetCustomerLoyalty">, resetCustomerLoyaltyError: import("@reduxjs/toolkit").ActionCreatorWithoutPayload<"loyalty/resetCustomerLoyaltyError">, setCustomerLoyalty: import("@reduxjs/toolkit").ActionCreatorWithPayload<any, "loyalty/setCustomerLoyalty">;
 export declare const selectCustomerLoyalty: (state: AppState) => CustomerLoyaltyState;
 export declare const selectCustomerLoyaltyProgram: (state: AppState) => {
     program: import("@open-tender/types").CustomerLoyalty | null;