@open-tender/cloud 0.0.1

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

@@ -0,0 +1,172 @@
+"use strict";
+var _a;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.customerCreditCardsReducer = exports.selectCustomerCreditCardsForPayment = exports.selectCustomerCreditCards = exports.setCustomerCreditCards = exports.resetCustomerCreditCardsError = exports.resetCustomerCreditCards = exports.addCustomerCreditCard = exports.removeCustomerCreditCard = exports.updateCustomerCreditCard = exports.fetchCustomerCreditCards = exports.CustomerCreditCardsActionType = 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 utils_1 = require("@open-tender/utils");
+const initialState = {
+    entities: [],
+    lookup: {},
+    loading: 'idle',
+    error: null
+};
+var CustomerCreditCardsActionType;
+(function (CustomerCreditCardsActionType) {
+    CustomerCreditCardsActionType["FetchCustomerCreditCards"] = "customer/fetchCustomerCreditCards";
+    CustomerCreditCardsActionType["UpdateCustomerCreditCard"] = "customer/updateCustomerCreditCard";
+    CustomerCreditCardsActionType["RemoveCustomerCreditCard"] = "customer/removeCustomerCreditCard";
+    CustomerCreditCardsActionType["AddCustomerCreditCard"] = "customer/addCustomerCreditCard";
+})(CustomerCreditCardsActionType = exports.CustomerCreditCardsActionType || (exports.CustomerCreditCardsActionType = {}));
+exports.fetchCustomerCreditCards = (0, toolkit_1.createAsyncThunk)(CustomerCreditCardsActionType.FetchCustomerCreditCards, (includeLinked, { 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 creditCards = yield api.getCustomerCreditCards(token, includeLinked);
+        return creditCards;
+    }
+    catch (err) {
+        const error = err;
+        return (0, account_1.checkAuth)(error, dispatch, () => rejectWithValue(error));
+    }
+}));
+exports.updateCustomerCreditCard = (0, toolkit_1.createAsyncThunk)(CustomerCreditCardsActionType.UpdateCustomerCreditCard, (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.putCustomerCreditCard(token, requestData.cardId, requestData.data);
+        const includeLinked = true;
+        const creditCards = yield api.getCustomerCreditCards(token, includeLinked);
+        dispatch((0, notifications_1.showNotification)('Credit card updated!'));
+        if (requestData.callback)
+            requestData.callback();
+        return creditCards;
+    }
+    catch (err) {
+        const error = err;
+        const errors = (0, utils_1.makeFormErrors)(error);
+        return (0, account_1.checkAuth)(error, dispatch, () => rejectWithValue(errors));
+    }
+}));
+exports.removeCustomerCreditCard = (0, toolkit_1.createAsyncThunk)(CustomerCreditCardsActionType.RemoveCustomerCreditCard, (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.deleteCustomerCreditCard(token, requestData.cardId);
+        const includeLinked = true;
+        const creditCards = yield api.getCustomerCreditCards(token, includeLinked);
+        dispatch((0, notifications_1.showNotification)('Credit card removed!'));
+        if (requestData.callback)
+            requestData.callback();
+        return creditCards;
+    }
+    catch (err) {
+        const error = err;
+        return (0, account_1.checkAuth)(error, dispatch, () => rejectWithValue(error));
+    }
+}));
+exports.addCustomerCreditCard = (0, toolkit_1.createAsyncThunk)(CustomerCreditCardsActionType.AddCustomerCreditCard, (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.postCustomerCreditCard(token, requestData.data);
+        const includeLinked = true;
+        const creditCards = yield api.getCustomerCreditCards(token, includeLinked);
+        dispatch((0, notifications_1.showNotification)('Credit card added!'));
+        if (requestData.callback)
+            requestData.callback();
+        return creditCards;
+    }
+    catch (err) {
+        const error = err;
+        const errors = (0, utils_1.makeFormErrors)(error);
+        return (0, account_1.checkAuth)(error, dispatch, () => rejectWithValue(errors));
+    }
+}));
+const customerCreditCardsSlice = (0, toolkit_1.createSlice)({
+    name: types_1.ReducerType.CreditCards,
+    initialState,
+    reducers: {
+        resetCustomerCreditCards: () => initialState,
+        resetCustomerCreditCardsError: state => {
+            state.error = null;
+            state.loading = 'idle';
+        },
+        setCustomerCreditCards: (state, action) => {
+            state.entities = action.payload;
+            state.error = null;
+        }
+    },
+    extraReducers: builder => {
+        builder
+            .addCase(exports.fetchCustomerCreditCards.fulfilled, (state, action) => {
+            state.entities = action.payload;
+            state.loading = 'idle';
+            state.error = null;
+        })
+            .addCase(exports.fetchCustomerCreditCards.pending, state => {
+            state.loading = 'pending';
+        })
+            .addCase(exports.fetchCustomerCreditCards.rejected, (state, action) => {
+            state.error = action.payload;
+            state.loading = 'idle';
+        })
+            .addCase(exports.updateCustomerCreditCard.fulfilled, (state, action) => {
+            state.entities = action.payload;
+            state.loading = 'idle';
+            state.error = null;
+        })
+            .addCase(exports.updateCustomerCreditCard.pending, state => {
+            state.loading = 'pending';
+        })
+            .addCase(exports.updateCustomerCreditCard.rejected, (state, action) => {
+            state.error = action.payload;
+            state.loading = 'idle';
+        })
+            .addCase(exports.removeCustomerCreditCard.fulfilled, (state, action) => {
+            state.entities = action.payload;
+            state.loading = 'idle';
+            state.error = null;
+        })
+            .addCase(exports.removeCustomerCreditCard.pending, state => {
+            state.loading = 'pending';
+        })
+            .addCase(exports.removeCustomerCreditCard.rejected, (state, action) => {
+            state.error = action.payload;
+            state.loading = 'idle';
+        })
+            .addCase(exports.addCustomerCreditCard.fulfilled, (state, action) => {
+            state.entities = action.payload;
+            state.loading = 'idle';
+            state.error = null;
+        })
+            .addCase(exports.addCustomerCreditCard.pending, state => {
+            state.loading = 'pending';
+        })
+            .addCase(exports.addCustomerCreditCard.rejected, (state, action) => {
+            state.error = action.payload;
+            state.loading = 'idle';
+        });
+    }
+});
+_a = customerCreditCardsSlice.actions, exports.resetCustomerCreditCards = _a.resetCustomerCreditCards, exports.resetCustomerCreditCardsError = _a.resetCustomerCreditCardsError, exports.setCustomerCreditCards = _a.setCustomerCreditCards;
+const selectCustomerCreditCards = (state) => state.customer.creditCards;
+exports.selectCustomerCreditCards = selectCustomerCreditCards;
+const selectCustomerCreditCardsForPayment = (state) => {
+    const creditCards = state.customer.creditCards.entities;
+    return creditCards.filter(i => i.has_profile);
+};
+exports.selectCustomerCreditCardsForPayment = selectCustomerCreditCardsForPayment;
+exports.customerCreditCardsReducer = customerCreditCardsSlice.reducer;

package/dist/cjs/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/cjs/slices/customer/favorites.js

@@ -0,0 +1,176 @@
+"use strict";
+var _a;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.customerFavoritesReducer = exports.selectCustomerFavorites = exports.setCustomerFavoritesLookup = exports.setCustomerFavorites = exports.resetCustomerFavoritesError = exports.resetCustomerFavorites = exports.addCustomerFavorite = exports.removeCustomerFavorite = exports.updateCustomerFavorite = exports.fetchCustomerFavorites = exports.CustomerFavoritesActionType = 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 utils_1 = require("@open-tender/utils");
+const initialState = {
+    entities: [],
+    error: null,
+    loading: 'idle',
+    lookup: {}
+};
+var CustomerFavoritesActionType;
+(function (CustomerFavoritesActionType) {
+    CustomerFavoritesActionType["FetchCustomerFavorites"] = "customer/fetchCustomerFavorites";
+    CustomerFavoritesActionType["UpdateCustomerFavorite"] = "customer/updateCustomerFavorite";
+    CustomerFavoritesActionType["RemoveCustomerFavorite"] = "customer/removeCustomerFavorite";
+    CustomerFavoritesActionType["AddCustomerFavorite"] = "customer/addCustomerFavorite";
+})(CustomerFavoritesActionType = exports.CustomerFavoritesActionType || (exports.CustomerFavoritesActionType = {}));
+exports.fetchCustomerFavorites = (0, toolkit_1.createAsyncThunk)(CustomerFavoritesActionType.FetchCustomerFavorites, (_, { 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 { data: favorites } = yield api.getCustomerFavorites(token);
+        const lookup = (0, utils_1.makeFavoritesLookup)(favorites);
+        dispatch((0, exports.setCustomerFavoritesLookup)(lookup));
+        return favorites;
+    }
+    catch (err) {
+        const error = err;
+        return (0, account_1.checkAuth)(error, dispatch, () => rejectWithValue(error));
+    }
+}));
+exports.updateCustomerFavorite = (0, toolkit_1.createAsyncThunk)(CustomerFavoritesActionType.UpdateCustomerFavorite, (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.putCustomerFavorite(token, requestData.favoriteId, requestData.data);
+        const { data: favorites } = yield api.getCustomerFavorites(token);
+        const lookup = (0, utils_1.makeFavoritesLookup)(favorites);
+        dispatch((0, exports.setCustomerFavoritesLookup)(lookup));
+        dispatch((0, notifications_1.showNotification)('Favorite updated!'));
+        if (requestData.callback)
+            requestData.callback();
+        return favorites;
+    }
+    catch (err) {
+        const error = err;
+        const errors = (0, utils_1.makeFormErrors)(error);
+        return (0, account_1.checkAuth)(error, dispatch, () => rejectWithValue(errors));
+    }
+}));
+exports.removeCustomerFavorite = (0, toolkit_1.createAsyncThunk)(CustomerFavoritesActionType.RemoveCustomerFavorite, (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.deleteCustomerFavorite(token, requestData.favoriteId);
+        const { data: favorites } = yield api.getCustomerFavorites(token);
+        const lookup = (0, utils_1.makeFavoritesLookup)(favorites);
+        dispatch((0, exports.setCustomerFavoritesLookup)(lookup));
+        if (requestData.callback)
+            requestData.callback();
+        return favorites;
+    }
+    catch (err) {
+        const error = err;
+        return (0, account_1.checkAuth)(error, dispatch, () => rejectWithValue(error));
+    }
+}));
+exports.addCustomerFavorite = (0, toolkit_1.createAsyncThunk)(CustomerFavoritesActionType.AddCustomerFavorite, (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);
+        if (!requestData.data.name)
+            requestData.data.name = '';
+        yield api.postCustomerFavorite(token, requestData.data);
+        const { data: favorites } = yield api.getCustomerFavorites(token);
+        const lookup = (0, utils_1.makeFavoritesLookup)(favorites);
+        dispatch((0, exports.setCustomerFavoritesLookup)(lookup));
+        if (requestData.callback)
+            requestData.callback();
+        return favorites;
+    }
+    catch (err) {
+        const error = err;
+        const errors = (0, utils_1.makeFormErrors)(error);
+        return (0, account_1.checkAuth)(error, dispatch, () => rejectWithValue(errors));
+    }
+}));
+const customerFavoritesSlice = (0, toolkit_1.createSlice)({
+    name: types_1.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(exports.fetchCustomerFavorites.fulfilled, (state, action) => {
+            state.entities = action.payload;
+            state.loading = 'idle';
+            state.error = null;
+        })
+            .addCase(exports.fetchCustomerFavorites.pending, state => {
+            state.loading = 'pending';
+        })
+            .addCase(exports.fetchCustomerFavorites.rejected, (state, action) => {
+            state.error = action.payload;
+            state.loading = 'idle';
+        })
+            .addCase(exports.updateCustomerFavorite.fulfilled, (state, action) => {
+            state.entities = action.payload;
+            state.loading = 'idle';
+            state.error = null;
+        })
+            .addCase(exports.updateCustomerFavorite.pending, state => {
+            state.loading = 'pending';
+        })
+            .addCase(exports.updateCustomerFavorite.rejected, (state, action) => {
+            state.error = action.payload;
+            state.loading = 'idle';
+        })
+            .addCase(exports.removeCustomerFavorite.fulfilled, (state, action) => {
+            state.entities = action.payload;
+            state.loading = 'idle';
+            state.error = null;
+        })
+            .addCase(exports.removeCustomerFavorite.pending, state => {
+            state.loading = 'pending';
+        })
+            .addCase(exports.removeCustomerFavorite.rejected, (state, action) => {
+            state.error = action.payload;
+            state.loading = 'idle';
+        })
+            .addCase(exports.addCustomerFavorite.fulfilled, (state, action) => {
+            state.entities = action.payload;
+            state.loading = 'idle';
+            state.error = null;
+        })
+            .addCase(exports.addCustomerFavorite.pending, state => {
+            state.loading = 'pending';
+        })
+            .addCase(exports.addCustomerFavorite.rejected, (state, action) => {
+            state.error = action.payload;
+            state.loading = 'idle';
+        });
+    }
+});
+_a = customerFavoritesSlice.actions, exports.resetCustomerFavorites = _a.resetCustomerFavorites, exports.resetCustomerFavoritesError = _a.resetCustomerFavoritesError, exports.setCustomerFavorites = _a.setCustomerFavorites, exports.setCustomerFavoritesLookup = _a.setCustomerFavoritesLookup;
+const selectCustomerFavorites = (state) => state.customer.favorites;
+exports.selectCustomerFavorites = selectCustomerFavorites;
+exports.customerFavoritesReducer = customerFavoritesSlice.reducer;

package/dist/cjs/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/cjs/slices/customer/fcmToken.js

@@ -0,0 +1,110 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.customerFcmTokenReducer = exports.selectCustomerFcmToken = exports.resetCustomerFcmToken = exports.addCustomerFcmToken = exports.removeCustomerFcmTokens = exports.fetchCustomerFcmTokens = exports.CustomerFcmTokenActionType = 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 = {
+    error: null,
+    loading: 'idle'
+};
+var CustomerFcmTokenActionType;
+(function (CustomerFcmTokenActionType) {
+    CustomerFcmTokenActionType["FetchCustomerFcmTokens"] = "customer/fetchCustomerFcmTokens";
+    CustomerFcmTokenActionType["RemoveCustomerFcmTokens"] = "customer/removeCustomerFcmTokens";
+    CustomerFcmTokenActionType["AddCustomerFcmToken"] = "customer/addCustomerFcmToken";
+})(CustomerFcmTokenActionType = exports.CustomerFcmTokenActionType || (exports.CustomerFcmTokenActionType = {}));
+exports.fetchCustomerFcmTokens = (0, toolkit_1.createAsyncThunk)(CustomerFcmTokenActionType.FetchCustomerFcmTokens, (_, { 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.getCustomerFcmToken(token);
+    }
+    catch (err) {
+        const error = err;
+        return (0, account_1.checkAuth)(error, dispatch, () => rejectWithValue(error));
+    }
+}));
+exports.removeCustomerFcmTokens = (0, toolkit_1.createAsyncThunk)(CustomerFcmTokenActionType.RemoveCustomerFcmTokens, (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 response = yield api.deleteCustomerFcmToken(token);
+        if (requestData.callback)
+            requestData.callback();
+        return response;
+    }
+    catch (err) {
+        const error = err;
+        return (0, account_1.checkAuth)(error, dispatch, () => rejectWithValue(error));
+    }
+}));
+exports.addCustomerFcmToken = (0, toolkit_1.createAsyncThunk)(CustomerFcmTokenActionType.AddCustomerFcmToken, (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 response = yield api.postCustomerFcmToken(token, requestData.fcmToken);
+        if (requestData.callback)
+            requestData.callback();
+        return response;
+    }
+    catch (err) {
+        const error = err;
+        return (0, account_1.checkAuth)(error, dispatch, () => rejectWithValue(error));
+    }
+}));
+const customerFcmTokenSlice = (0, toolkit_1.createSlice)({
+    name: types_1.ReducerType.FcmToken,
+    initialState,
+    reducers: {
+        resetCustomerFcmToken: () => initialState
+    },
+    extraReducers: builder => {
+        builder
+            .addCase(exports.fetchCustomerFcmTokens.fulfilled, state => {
+            state.loading = 'idle';
+            state.error = null;
+        })
+            .addCase(exports.fetchCustomerFcmTokens.pending, state => {
+            state.loading = 'pending';
+        })
+            .addCase(exports.fetchCustomerFcmTokens.rejected, (state, action) => {
+            state.error = action.payload;
+            state.loading = 'idle';
+        })
+            .addCase(exports.removeCustomerFcmTokens.fulfilled, state => {
+            state.loading = 'idle';
+            state.error = null;
+        })
+            .addCase(exports.removeCustomerFcmTokens.pending, state => {
+            state.loading = 'pending';
+        })
+            .addCase(exports.removeCustomerFcmTokens.rejected, (state, action) => {
+            state.error = action.payload;
+            state.loading = 'idle';
+        })
+            .addCase(exports.addCustomerFcmToken.fulfilled, state => {
+            state.loading = 'idle';
+            state.error = null;
+        })
+            .addCase(exports.addCustomerFcmToken.pending, state => {
+            state.loading = 'pending';
+        })
+            .addCase(exports.addCustomerFcmToken.rejected, (state, action) => {
+            state.error = action.payload;
+            state.loading = 'idle';
+        });
+    }
+});
+exports.resetCustomerFcmToken = customerFcmTokenSlice.actions.resetCustomerFcmToken;
+const selectCustomerFcmToken = (state) => state.customer.fcmToken;
+exports.selectCustomerFcmToken = selectCustomerFcmToken;
+exports.customerFcmTokenReducer = customerFcmTokenSlice.reducer;

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