@open-tender/cloud 0.0.1

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

@@ -0,0 +1,45 @@
+import { AppState } from '../../app';
+import { Favorite, Favorites, RequestError, RequestStatus } from '@open-tender/types';
+export interface CustomerFavoritesState {
+    entities: Favorites;
+    error: RequestError;
+    loading: RequestStatus;
+    lookup: {
+        [key: number]: number;
+    };
+}
+export declare enum CustomerFavoritesActionType {
+    FetchCustomerFavorites = "customer/fetchCustomerFavorites",
+    UpdateCustomerFavorite = "customer/updateCustomerFavorite",
+    RemoveCustomerFavorite = "customer/removeCustomerFavorite",
+    AddCustomerFavorite = "customer/addCustomerFavorite"
+}
+export declare const fetchCustomerFavorites: import("@reduxjs/toolkit").AsyncThunk<Favorites, void, {
+    state: AppState;
+    rejectValue: RequestError;
+}>;
+export declare const updateCustomerFavorite: import("@reduxjs/toolkit").AsyncThunk<Favorites, {
+    favoriteId: number;
+    data: Favorite;
+    callback?: (() => void) | undefined;
+}, {
+    state: AppState;
+    rejectValue: RequestError;
+}>;
+export declare const removeCustomerFavorite: import("@reduxjs/toolkit").AsyncThunk<Favorites, {
+    favoriteId: number;
+    callback?: (() => void) | undefined;
+}, {
+    state: AppState;
+    rejectValue: RequestError;
+}>;
+export declare const addCustomerFavorite: import("@reduxjs/toolkit").AsyncThunk<Favorites, {
+    data: Favorite;
+    callback?: (() => void) | undefined;
+}, {
+    state: AppState;
+    rejectValue: RequestError;
+}>;
+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 selectCustomerFavorites: (state: AppState) => CustomerFavoritesState;
+export declare const customerFavoritesReducer: import("redux").Reducer<CustomerFavoritesState, import("redux").AnyAction>;

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

@@ -0,0 +1,171 @@
+import { __awaiter } from "tslib";
+import { createAsyncThunk, createSlice } from '@reduxjs/toolkit';
+import { ReducerType } from '../types';
+import { MISSING_CUSTOMER } from '@open-tender/types';
+import { checkAuth, selectToken } from './account';
+import { showNotification } from '../notifications';
+import { makeFavoritesLookup, makeFormErrors } from '@open-tender/utils';
+const initialState = {
+    entities: [],
+    error: null,
+    loading: 'idle',
+    lookup: {}
+};
+export var CustomerFavoritesActionType;
+(function (CustomerFavoritesActionType) {
+    CustomerFavoritesActionType["FetchCustomerFavorites"] = "customer/fetchCustomerFavorites";
+    CustomerFavoritesActionType["UpdateCustomerFavorite"] = "customer/updateCustomerFavorite";
+    CustomerFavoritesActionType["RemoveCustomerFavorite"] = "customer/removeCustomerFavorite";
+    CustomerFavoritesActionType["AddCustomerFavorite"] = "customer/addCustomerFavorite";
+})(CustomerFavoritesActionType || (CustomerFavoritesActionType = {}));
+export const fetchCustomerFavorites = createAsyncThunk(CustomerFavoritesActionType.FetchCustomerFavorites, (_, { 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);
+        const { data: favorites } = yield api.getCustomerFavorites(token);
+        const lookup = makeFavoritesLookup(favorites);
+        dispatch(setCustomerFavoritesLookup(lookup));
+        return favorites;
+    }
+    catch (err) {
+        const error = err;
+        return checkAuth(error, dispatch, () => rejectWithValue(error));
+    }
+}));
+export const updateCustomerFavorite = createAsyncThunk(CustomerFavoritesActionType.UpdateCustomerFavorite, (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.putCustomerFavorite(token, requestData.favoriteId, requestData.data);
+        const { data: favorites } = yield api.getCustomerFavorites(token);
+        const lookup = makeFavoritesLookup(favorites);
+        dispatch(setCustomerFavoritesLookup(lookup));
+        dispatch(showNotification('Favorite updated!'));
+        if (requestData.callback)
+            requestData.callback();
+        return favorites;
+    }
+    catch (err) {
+        const error = err;
+        const errors = makeFormErrors(error);
+        return checkAuth(error, dispatch, () => rejectWithValue(errors));
+    }
+}));
+export const removeCustomerFavorite = createAsyncThunk(CustomerFavoritesActionType.RemoveCustomerFavorite, (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.deleteCustomerFavorite(token, requestData.favoriteId);
+        const { data: favorites } = yield api.getCustomerFavorites(token);
+        const lookup = makeFavoritesLookup(favorites);
+        dispatch(setCustomerFavoritesLookup(lookup));
+        if (requestData.callback)
+            requestData.callback();
+        return favorites;
+    }
+    catch (err) {
+        const error = err;
+        return checkAuth(error, dispatch, () => rejectWithValue(error));
+    }
+}));
+export const addCustomerFavorite = createAsyncThunk(CustomerFavoritesActionType.AddCustomerFavorite, (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);
+        if (!requestData.data.name)
+            requestData.data.name = '';
+        yield api.postCustomerFavorite(token, requestData.data);
+        const { data: favorites } = yield api.getCustomerFavorites(token);
+        const lookup = makeFavoritesLookup(favorites);
+        dispatch(setCustomerFavoritesLookup(lookup));
+        if (requestData.callback)
+            requestData.callback();
+        return favorites;
+    }
+    catch (err) {
+        const error = err;
+        const errors = makeFormErrors(error);
+        return checkAuth(error, dispatch, () => rejectWithValue(errors));
+    }
+}));
+const customerFavoritesSlice = createSlice({
+    name: ReducerType.Favorites,
+    initialState,
+    reducers: {
+        resetCustomerFavorites: () => initialState,
+        resetCustomerFavoritesError: state => {
+            state.error = null;
+            state.loading = 'idle';
+        },
+        setCustomerFavorites: (state, action) => {
+            state.entities = action.payload;
+            state.error = null;
+        },
+        setCustomerFavoritesLookup: (state, action) => {
+            state.lookup = action.payload;
+            state.error = null;
+        }
+    },
+    extraReducers: builder => {
+        builder
+            .addCase(fetchCustomerFavorites.fulfilled, (state, action) => {
+            state.entities = action.payload;
+            state.loading = 'idle';
+            state.error = null;
+        })
+            .addCase(fetchCustomerFavorites.pending, state => {
+            state.loading = 'pending';
+        })
+            .addCase(fetchCustomerFavorites.rejected, (state, action) => {
+            state.error = action.payload;
+            state.loading = 'idle';
+        })
+            .addCase(updateCustomerFavorite.fulfilled, (state, action) => {
+            state.entities = action.payload;
+            state.loading = 'idle';
+            state.error = null;
+        })
+            .addCase(updateCustomerFavorite.pending, state => {
+            state.loading = 'pending';
+        })
+            .addCase(updateCustomerFavorite.rejected, (state, action) => {
+            state.error = action.payload;
+            state.loading = 'idle';
+        })
+            .addCase(removeCustomerFavorite.fulfilled, (state, action) => {
+            state.entities = action.payload;
+            state.loading = 'idle';
+            state.error = null;
+        })
+            .addCase(removeCustomerFavorite.pending, state => {
+            state.loading = 'pending';
+        })
+            .addCase(removeCustomerFavorite.rejected, (state, action) => {
+            state.error = action.payload;
+            state.loading = 'idle';
+        })
+            .addCase(addCustomerFavorite.fulfilled, (state, action) => {
+            state.entities = action.payload;
+            state.loading = 'idle';
+            state.error = null;
+        })
+            .addCase(addCustomerFavorite.pending, state => {
+            state.loading = 'pending';
+        })
+            .addCase(addCustomerFavorite.rejected, (state, action) => {
+            state.error = action.payload;
+            state.loading = 'idle';
+        });
+    }
+});
+export const { resetCustomerFavorites, resetCustomerFavoritesError, setCustomerFavorites, setCustomerFavoritesLookup } = customerFavoritesSlice.actions;
+export const selectCustomerFavorites = (state) => state.customer.favorites;
+export const customerFavoritesReducer = customerFavoritesSlice.reducer;

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

@@ -0,0 +1,31 @@
+import { AppState } from '../../app';
+import { RequestError, RequestStatus } from '@open-tender/types';
+export interface CustomerFcmTokenState {
+    error: RequestError;
+    loading: RequestStatus;
+}
+export declare enum CustomerFcmTokenActionType {
+    FetchCustomerFcmTokens = "customer/fetchCustomerFcmTokens",
+    RemoveCustomerFcmTokens = "customer/removeCustomerFcmTokens",
+    AddCustomerFcmToken = "customer/addCustomerFcmToken"
+}
+export declare const fetchCustomerFcmTokens: import("@reduxjs/toolkit").AsyncThunk<void, void, {
+    state: AppState;
+    rejectValue: RequestError;
+}>;
+export declare const removeCustomerFcmTokens: import("@reduxjs/toolkit").AsyncThunk<void, {
+    callback?: (() => void) | undefined;
+}, {
+    state: AppState;
+    rejectValue: RequestError;
+}>;
+export declare const addCustomerFcmToken: import("@reduxjs/toolkit").AsyncThunk<void, {
+    fcmToken: string;
+    callback?: (() => void) | undefined;
+}, {
+    state: AppState;
+    rejectValue: RequestError;
+}>;
+export declare const resetCustomerFcmToken: import("@reduxjs/toolkit").ActionCreatorWithoutPayload<string>;
+export declare const selectCustomerFcmToken: (state: AppState) => CustomerFcmTokenState;
+export declare const customerFcmTokenReducer: import("redux").Reducer<CustomerFcmTokenState, import("redux").AnyAction>;

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

@@ -0,0 +1,106 @@
+import { __awaiter } from "tslib";
+import { createAsyncThunk, createSlice } from '@reduxjs/toolkit';
+import { ReducerType } from '../types';
+import { MISSING_CUSTOMER } from '@open-tender/types';
+import { checkAuth, selectToken } from './account';
+const initialState = {
+    error: null,
+    loading: 'idle'
+};
+export var CustomerFcmTokenActionType;
+(function (CustomerFcmTokenActionType) {
+    CustomerFcmTokenActionType["FetchCustomerFcmTokens"] = "customer/fetchCustomerFcmTokens";
+    CustomerFcmTokenActionType["RemoveCustomerFcmTokens"] = "customer/removeCustomerFcmTokens";
+    CustomerFcmTokenActionType["AddCustomerFcmToken"] = "customer/addCustomerFcmToken";
+})(CustomerFcmTokenActionType || (CustomerFcmTokenActionType = {}));
+export const fetchCustomerFcmTokens = createAsyncThunk(CustomerFcmTokenActionType.FetchCustomerFcmTokens, (_, { 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);
+        return yield api.getCustomerFcmToken(token);
+    }
+    catch (err) {
+        const error = err;
+        return checkAuth(error, dispatch, () => rejectWithValue(error));
+    }
+}));
+export const removeCustomerFcmTokens = createAsyncThunk(CustomerFcmTokenActionType.RemoveCustomerFcmTokens, (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);
+        const response = yield api.deleteCustomerFcmToken(token);
+        if (requestData.callback)
+            requestData.callback();
+        return response;
+    }
+    catch (err) {
+        const error = err;
+        return checkAuth(error, dispatch, () => rejectWithValue(error));
+    }
+}));
+export const addCustomerFcmToken = createAsyncThunk(CustomerFcmTokenActionType.AddCustomerFcmToken, (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);
+        const response = yield api.postCustomerFcmToken(token, requestData.fcmToken);
+        if (requestData.callback)
+            requestData.callback();
+        return response;
+    }
+    catch (err) {
+        const error = err;
+        return checkAuth(error, dispatch, () => rejectWithValue(error));
+    }
+}));
+const customerFcmTokenSlice = createSlice({
+    name: ReducerType.FcmToken,
+    initialState,
+    reducers: {
+        resetCustomerFcmToken: () => initialState
+    },
+    extraReducers: builder => {
+        builder
+            .addCase(fetchCustomerFcmTokens.fulfilled, state => {
+            state.loading = 'idle';
+            state.error = null;
+        })
+            .addCase(fetchCustomerFcmTokens.pending, state => {
+            state.loading = 'pending';
+        })
+            .addCase(fetchCustomerFcmTokens.rejected, (state, action) => {
+            state.error = action.payload;
+            state.loading = 'idle';
+        })
+            .addCase(removeCustomerFcmTokens.fulfilled, state => {
+            state.loading = 'idle';
+            state.error = null;
+        })
+            .addCase(removeCustomerFcmTokens.pending, state => {
+            state.loading = 'pending';
+        })
+            .addCase(removeCustomerFcmTokens.rejected, (state, action) => {
+            state.error = action.payload;
+            state.loading = 'idle';
+        })
+            .addCase(addCustomerFcmToken.fulfilled, state => {
+            state.loading = 'idle';
+            state.error = null;
+        })
+            .addCase(addCustomerFcmToken.pending, state => {
+            state.loading = 'pending';
+        })
+            .addCase(addCustomerFcmToken.rejected, (state, action) => {
+            state.error = action.payload;
+            state.loading = 'idle';
+        });
+    }
+});
+export const { resetCustomerFcmToken } = customerFcmTokenSlice.actions;
+export const selectCustomerFcmToken = (state) => state.customer.fcmToken;
+export const customerFcmTokenReducer = customerFcmTokenSlice.reducer;

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

@@ -0,0 +1,62 @@
+import { AppState } from '../../app';
+import { CustomerGiftCard, CustomerGiftCards, RequestError, RequestStatus } from '@open-tender/types';
+export interface CustomerGiftCardsState {
+    entities: CustomerGiftCards;
+    error: RequestError;
+    loading: RequestStatus;
+    lookup: {
+        [key: number]: number;
+    };
+}
+export declare enum CustomerGiftCardsActionType {
+    FetchCustomerGiftCards = "customer/fetchCustomerGiftCards",
+    RemoveCustomerGiftCard = "customer/removeCustomerGiftCard",
+    AddCustomerGiftCard = "customer/addCustomerGiftCard",
+    AssignCustomerGiftCard = "customer/assignCustomerGiftCard",
+    AssignCustomerGiftCardOther = "customer/assignCustomerGiftCardOther",
+    UpdateCustomerGiftCard = "customer/updateCustomerGiftCard"
+}
+export declare const fetchCustomerGiftCards: import("@reduxjs/toolkit").AsyncThunk<CustomerGiftCards, void, {
+    state: AppState;
+    rejectValue: RequestError;
+}>;
+export declare const updateCustomerGiftCard: import("@reduxjs/toolkit").AsyncThunk<CustomerGiftCards, {
+    giftCardId: number;
+    data: CustomerGiftCard;
+    callback?: (() => void) | undefined;
+}, {
+    state: AppState;
+    rejectValue: RequestError;
+}>;
+export declare const removeCustomerGiftCard: import("@reduxjs/toolkit").AsyncThunk<CustomerGiftCards, {
+    giftCardId: number;
+    callback?: (() => void) | undefined;
+}, {
+    state: AppState;
+    rejectValue: RequestError;
+}>;
+export declare const addCustomerGiftCard: import("@reduxjs/toolkit").AsyncThunk<CustomerGiftCards, {
+    data: CustomerGiftCard;
+    callback?: (() => void) | undefined;
+}, {
+    state: AppState;
+    rejectValue: RequestError;
+}>;
+export declare const assignCustomerGiftCard: import("@reduxjs/toolkit").AsyncThunk<CustomerGiftCards, {
+    cardNumber: string;
+    callback?: (() => void) | undefined;
+}, {
+    state: AppState;
+    rejectValue: RequestError;
+}>;
+export declare const assignCustomerGiftCardOther: import("@reduxjs/toolkit").AsyncThunk<CustomerGiftCards, {
+    giftCardId: number;
+    email: string;
+    callback?: (() => void) | undefined;
+}, {
+    state: AppState;
+    rejectValue: RequestError;
+}>;
+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 selectCustomerGiftCards: (state: AppState) => CustomerGiftCardsState;
+export declare const customerGiftCardsReducer: import("redux").Reducer<CustomerGiftCardsState, import("redux").AnyAction>;

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

@@ -0,0 +1,191 @@
+import { __awaiter } from "tslib";
+import { createAsyncThunk, createSlice } from '@reduxjs/toolkit';
+import { ReducerType } from '../types';
+import { MISSING_CUSTOMER } from '@open-tender/types';
+import { checkAuth, selectToken } from './account';
+import { showNotification } from '../notifications';
+const initialState = {
+    entities: [],
+    error: null,
+    loading: 'idle',
+    lookup: {}
+};
+export 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 || (CustomerGiftCardsActionType = {}));
+export const fetchCustomerGiftCards = createAsyncThunk(CustomerGiftCardsActionType.FetchCustomerGiftCards, (_, { 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);
+        return yield api.getCustomerGiftCards(token);
+    }
+    catch (err) {
+        const error = err;
+        return checkAuth(error, dispatch, () => rejectWithValue(error));
+    }
+}));
+export const updateCustomerGiftCard = createAsyncThunk(CustomerGiftCardsActionType.UpdateCustomerGiftCard, (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.putCustomerGiftCard(token, requestData.giftCardId, requestData.data);
+        const giftCards = yield api.getCustomerGiftCards(token);
+        dispatch(showNotification('Gift card balance updated!'));
+        if (requestData.callback)
+            requestData.callback();
+        return giftCards;
+    }
+    catch (err) {
+        const error = err;
+        return checkAuth(error, dispatch, () => rejectWithValue(error));
+    }
+}));
+export const removeCustomerGiftCard = createAsyncThunk(CustomerGiftCardsActionType.RemoveCustomerGiftCard, (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.deleteCustomerGiftCard(token, requestData.giftCardId);
+        const giftCards = yield api.getCustomerGiftCards(token);
+        dispatch(showNotification('Gift card removed!'));
+        if (requestData.callback)
+            requestData.callback();
+        return giftCards;
+    }
+    catch (err) {
+        const error = err;
+        return checkAuth(error, dispatch, () => rejectWithValue(error));
+    }
+}));
+export const addCustomerGiftCard = createAsyncThunk(CustomerGiftCardsActionType.AddCustomerGiftCard, (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.postCustomerGiftCard(token, requestData.data);
+        const giftCards = yield api.getCustomerGiftCards(token);
+        dispatch(showNotification('Gift card added!'));
+        if (requestData.callback)
+            requestData.callback();
+        return giftCards;
+    }
+    catch (err) {
+        const error = err;
+        return checkAuth(error, dispatch, () => rejectWithValue(error));
+    }
+}));
+export const assignCustomerGiftCard = createAsyncThunk(CustomerGiftCardsActionType.AssignCustomerGiftCard, (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.postCustomerGiftCardAssign(token, requestData.cardNumber);
+        const giftCards = yield api.getCustomerGiftCards(token);
+        dispatch(showNotification('Gift card added to your account!'));
+        if (requestData.callback)
+            requestData.callback();
+        return giftCards;
+    }
+    catch (err) {
+        const error = err;
+        return checkAuth(error, dispatch, () => rejectWithValue(error));
+    }
+}));
+export const assignCustomerGiftCardOther = createAsyncThunk(CustomerGiftCardsActionType.AssignCustomerGiftCardOther, (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.postCustomerGiftCardAssignOther(token, requestData.giftCardId, requestData.email);
+        const giftCards = yield api.getCustomerGiftCards(token);
+        dispatch(showNotification(`Gift card assigned to ${requestData.email}`));
+        if (requestData.callback)
+            requestData.callback();
+        return giftCards;
+    }
+    catch (err) {
+        const error = err;
+        return checkAuth(error, dispatch, () => rejectWithValue(error));
+    }
+}));
+const customerGiftCardsSlice = createSlice({
+    name: 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(fetchCustomerGiftCards.fulfilled, (state, action) => {
+            state.entities = action.payload;
+            state.loading = 'idle';
+            state.error = null;
+        })
+            .addCase(fetchCustomerGiftCards.pending, state => {
+            state.loading = 'pending';
+        })
+            .addCase(fetchCustomerGiftCards.rejected, (state, action) => {
+            state.error = action.payload;
+            state.loading = 'idle';
+        })
+            .addCase(removeCustomerGiftCard.fulfilled, state => {
+            state.loading = 'idle';
+            state.error = null;
+        })
+            .addCase(removeCustomerGiftCard.pending, state => {
+            state.loading = 'pending';
+        })
+            .addCase(removeCustomerGiftCard.rejected, (state, action) => {
+            state.error = action.payload;
+            state.loading = 'idle';
+        })
+            .addCase(addCustomerGiftCard.fulfilled, state => {
+            state.loading = 'idle';
+            state.error = null;
+        })
+            .addCase(addCustomerGiftCard.pending, state => {
+            state.loading = 'pending';
+        })
+            .addCase(addCustomerGiftCard.rejected, (state, action) => {
+            state.error = action.payload;
+            state.loading = 'idle';
+        })
+            .addCase(updateCustomerGiftCard.fulfilled, (state, action) => {
+            state.entities = action.payload;
+            state.loading = 'idle';
+            state.error = null;
+        })
+            .addCase(updateCustomerGiftCard.pending, state => {
+            state.loading = 'pending';
+        })
+            .addCase(updateCustomerGiftCard.rejected, (state, action) => {
+            state.error = action.payload;
+            state.loading = 'idle';
+        });
+    }
+});
+export const { resetCustomerGiftCards, resetCustomerGiftCardsError, setCustomerGiftCards } = customerGiftCardsSlice.actions;
+export const selectCustomerGiftCards = (state) => state.customer.giftCards;
+export const customerGiftCardsReducer = customerGiftCardsSlice.reducer;

package/dist/esm/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>;