@open-tender/cloud 0.5.9 → 0.5.11

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

@@ -1,55 +1,55 @@
-import { AppState } from '../../app';
-import { Address, Addresses, RequestError, RequestStatus } from '@open-tender/types';
-export interface CustomerAddressesState {
-    entities: Addresses;
-    error: RequestError;
-    loading: RequestStatus;
-    lookup: {
-        [key: number | string]: number;
-    };
-}
-export declare enum CustomerAddressesActionType {
-    FetchCustomerAddresses = "customer/fetchCustomerAddresses",
-    UpdateCustomerAddresses = "customer/updateCustomerAddresses",
-    RemoveCustomerAddress = "customer/removeCustomerAddress"
-}
-export declare const fetchCustomerAddresses: import("@reduxjs/toolkit").AsyncThunk<Addresses, 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 updateCustomerAddress: import("@reduxjs/toolkit").AsyncThunk<Addresses, {
-    addressId: number;
-    data: Address;
-    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 removeCustomerAddress: import("@reduxjs/toolkit").AsyncThunk<Addresses, {
-    addressId: 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 resetCustomerAddresses: import("@reduxjs/toolkit").ActionCreatorWithoutPayload<"addresses/resetCustomerAddresses">, setCustomerAddresses: import("@reduxjs/toolkit").ActionCreatorWithPayload<any, "addresses/setCustomerAddresses">, resetCustomerAddressesError: import("@reduxjs/toolkit").ActionCreatorWithoutPayload<"addresses/resetCustomerAddressesError">;
-export declare const selectCustomerAddresses: (state: AppState) => CustomerAddressesState;
-export declare const customerAddressesReducer: import("redux").Reducer<CustomerAddressesState, import("redux").AnyAction>;
+import { AppState } from '../../app';
+import { Address, Addresses, RequestError, RequestStatus } from '@open-tender/types';
+export interface CustomerAddressesState {
+    entities: Addresses;
+    error: RequestError;
+    loading: RequestStatus;
+    lookup: {
+        [key: number | string]: number;
+    };
+}
+export declare enum CustomerAddressesActionType {
+    FetchCustomerAddresses = "customer/fetchCustomerAddresses",
+    UpdateCustomerAddresses = "customer/updateCustomerAddresses",
+    RemoveCustomerAddress = "customer/removeCustomerAddress"
+}
+export declare const fetchCustomerAddresses: import("@reduxjs/toolkit").AsyncThunk<Addresses, 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 updateCustomerAddress: import("@reduxjs/toolkit").AsyncThunk<Addresses, {
+    addressId: number;
+    data: Address;
+    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 removeCustomerAddress: import("@reduxjs/toolkit").AsyncThunk<Addresses, {
+    addressId: 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 resetCustomerAddresses: import("@reduxjs/toolkit").ActionCreatorWithoutPayload<"addresses/resetCustomerAddresses">, setCustomerAddresses: import("@reduxjs/toolkit").ActionCreatorWithPayload<any, "addresses/setCustomerAddresses">, resetCustomerAddressesError: import("@reduxjs/toolkit").ActionCreatorWithoutPayload<"addresses/resetCustomerAddressesError">;
+export declare const selectCustomerAddresses: (state: AppState) => CustomerAddressesState;
+export declare const customerAddressesReducer: import("redux").Reducer<CustomerAddressesState, import("redux").AnyAction>;

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

@@ -1,127 +1,127 @@
-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: [],
-    lookup: {},
-    loading: 'idle',
-    error: null
-};
-export var CustomerAddressesActionType;
-(function (CustomerAddressesActionType) {
-    CustomerAddressesActionType["FetchCustomerAddresses"] = "customer/fetchCustomerAddresses";
-    CustomerAddressesActionType["UpdateCustomerAddresses"] = "customer/updateCustomerAddresses";
-    CustomerAddressesActionType["RemoveCustomerAddress"] = "customer/removeCustomerAddress";
-})(CustomerAddressesActionType || (CustomerAddressesActionType = {}));
-export const fetchCustomerAddresses = createAsyncThunk(CustomerAddressesActionType.FetchCustomerAddresses, (limit, { 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: addresses } = yield api.getCustomerAddresses(token, limit);
-        return addresses;
-    }
-    catch (err) {
-        const error = err;
-        return checkAuth(error, dispatch, () => rejectWithValue(error));
-    }
-}));
-export const updateCustomerAddress = createAsyncThunk(CustomerAddressesActionType.UpdateCustomerAddresses, (data, { 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.putCustomerAddress(token, data.addressId, data.data);
-        const limit = getState().customer.addresses.entities.length;
-        const { data: addresses } = yield api.getCustomerAddresses(token, limit);
-        dispatch(showNotification('Address updated!'));
-        if (data.callback)
-            data.callback();
-        return addresses;
-    }
-    catch (err) {
-        const error = err;
-        return checkAuth(error, dispatch, () => rejectWithValue(error));
-    }
-}));
-export const removeCustomerAddress = createAsyncThunk(CustomerAddressesActionType.RemoveCustomerAddress, (data, { 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.deleteCustomerAddress(token, data.addressId);
-        const limit = getState().customer.addresses.entities.length;
-        const { data: addresses } = yield api.getCustomerAddresses(token, limit);
-        dispatch(showNotification('Address removed!'));
-        if (data.callback)
-            data.callback();
-        return addresses;
-    }
-    catch (err) {
-        const error = err;
-        return checkAuth(error, dispatch, () => rejectWithValue(error));
-    }
-}));
-const customerAddressesSlice = createSlice({
-    name: ReducerType.CustomerAddresses,
-    initialState,
-    reducers: {
-        resetCustomerAddresses: () => initialState,
-        setCustomerAddresses: (state, action) => {
-            state.entities = action.payload;
-            state.error = null;
-        },
-        resetCustomerAddressesError: state => {
-            state.error = null;
-            state.loading = 'idle';
-        }
-    },
-    extraReducers: builder => {
-        builder
-            .addCase(fetchCustomerAddresses.fulfilled, (state, action) => {
-            state.entities = action.payload;
-            state.loading = 'idle';
-            state.error = null;
-        })
-            .addCase(fetchCustomerAddresses.pending, state => {
-            state.loading = 'pending';
-        })
-            .addCase(fetchCustomerAddresses.rejected, (state, action) => {
-            state.error = action.payload;
-            state.loading = 'idle';
-        })
-            .addCase(updateCustomerAddress.fulfilled, (state, action) => {
-            state.entities = action.payload;
-            state.loading = 'idle';
-            state.error = null;
-        })
-            .addCase(updateCustomerAddress.pending, state => {
-            state.loading = 'pending';
-        })
-            .addCase(updateCustomerAddress.rejected, (state, action) => {
-            state.error = action.payload;
-            state.loading = 'idle';
-        })
-            .addCase(removeCustomerAddress.fulfilled, (state, action) => {
-            state.entities = action.payload;
-            state.loading = 'idle';
-            state.error = null;
-        })
-            .addCase(removeCustomerAddress.pending, state => {
-            state.loading = 'pending';
-        })
-            .addCase(removeCustomerAddress.rejected, (state, action) => {
-            state.error = action.payload;
-            state.loading = 'idle';
-        });
-    }
-});
-export const { resetCustomerAddresses, setCustomerAddresses, resetCustomerAddressesError } = customerAddressesSlice.actions;
-export const selectCustomerAddresses = (state) => state.customer.addresses;
-export const customerAddressesReducer = customerAddressesSlice.reducer;
+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: [],
+    lookup: {},
+    loading: 'idle',
+    error: null
+};
+export var CustomerAddressesActionType;
+(function (CustomerAddressesActionType) {
+    CustomerAddressesActionType["FetchCustomerAddresses"] = "customer/fetchCustomerAddresses";
+    CustomerAddressesActionType["UpdateCustomerAddresses"] = "customer/updateCustomerAddresses";
+    CustomerAddressesActionType["RemoveCustomerAddress"] = "customer/removeCustomerAddress";
+})(CustomerAddressesActionType || (CustomerAddressesActionType = {}));
+export const fetchCustomerAddresses = createAsyncThunk(CustomerAddressesActionType.FetchCustomerAddresses, (limit, { 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: addresses } = yield api.getCustomerAddresses(token, limit);
+        return addresses;
+    }
+    catch (err) {
+        const error = err;
+        return checkAuth(error, dispatch, () => rejectWithValue(error));
+    }
+}));
+export const updateCustomerAddress = createAsyncThunk(CustomerAddressesActionType.UpdateCustomerAddresses, (data, { 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.putCustomerAddress(token, data.addressId, data.data);
+        const limit = getState().customer.addresses.entities.length;
+        const { data: addresses } = yield api.getCustomerAddresses(token, limit);
+        dispatch(showNotification('Address updated!'));
+        if (data.callback)
+            data.callback();
+        return addresses;
+    }
+    catch (err) {
+        const error = err;
+        return checkAuth(error, dispatch, () => rejectWithValue(error));
+    }
+}));
+export const removeCustomerAddress = createAsyncThunk(CustomerAddressesActionType.RemoveCustomerAddress, (data, { 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.deleteCustomerAddress(token, data.addressId);
+        const limit = getState().customer.addresses.entities.length;
+        const { data: addresses } = yield api.getCustomerAddresses(token, limit);
+        dispatch(showNotification('Address removed!'));
+        if (data.callback)
+            data.callback();
+        return addresses;
+    }
+    catch (err) {
+        const error = err;
+        return checkAuth(error, dispatch, () => rejectWithValue(error));
+    }
+}));
+const customerAddressesSlice = createSlice({
+    name: ReducerType.CustomerAddresses,
+    initialState,
+    reducers: {
+        resetCustomerAddresses: () => initialState,
+        setCustomerAddresses: (state, action) => {
+            state.entities = action.payload;
+            state.error = null;
+        },
+        resetCustomerAddressesError: state => {
+            state.error = null;
+            state.loading = 'idle';
+        }
+    },
+    extraReducers: builder => {
+        builder
+            .addCase(fetchCustomerAddresses.fulfilled, (state, action) => {
+            state.entities = action.payload;
+            state.loading = 'idle';
+            state.error = null;
+        })
+            .addCase(fetchCustomerAddresses.pending, state => {
+            state.loading = 'pending';
+        })
+            .addCase(fetchCustomerAddresses.rejected, (state, action) => {
+            state.error = action.payload;
+            state.loading = 'idle';
+        })
+            .addCase(updateCustomerAddress.fulfilled, (state, action) => {
+            state.entities = action.payload;
+            state.loading = 'idle';
+            state.error = null;
+        })
+            .addCase(updateCustomerAddress.pending, state => {
+            state.loading = 'pending';
+        })
+            .addCase(updateCustomerAddress.rejected, (state, action) => {
+            state.error = action.payload;
+            state.loading = 'idle';
+        })
+            .addCase(removeCustomerAddress.fulfilled, (state, action) => {
+            state.entities = action.payload;
+            state.loading = 'idle';
+            state.error = null;
+        })
+            .addCase(removeCustomerAddress.pending, state => {
+            state.loading = 'pending';
+        })
+            .addCase(removeCustomerAddress.rejected, (state, action) => {
+            state.error = action.payload;
+            state.loading = 'idle';
+        });
+    }
+});
+export const { resetCustomerAddresses, setCustomerAddresses, resetCustomerAddressesError } = customerAddressesSlice.actions;
+export const selectCustomerAddresses = (state) => state.customer.addresses;
+export const customerAddressesReducer = customerAddressesSlice.reducer;

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

@@ -1,37 +1,37 @@
-import { AppState } from '../../app';
-import { CustomerAllergens, RequestError, RequestStatus } from '@open-tender/types';
-export interface CustomerAllergensState {
-    entities: CustomerAllergens;
-    error: RequestError;
-    loading: RequestStatus;
-    lookup: {
-        [key: number | string]: number;
-    };
-}
-export declare enum CustomerAllergensActionType {
-    FetchCustomerAllergens = "customer/fetchCustomerAllergens",
-    UpdateCustomerAllergens = "customer/updateCustomerAllergens"
-}
-export declare const fetchCustomerAllergens: import("@reduxjs/toolkit").AsyncThunk<CustomerAllergens, 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 updateCustomerAllergens: import("@reduxjs/toolkit").AsyncThunk<CustomerAllergens, CustomerAllergens, {
-    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 resetCustomerAllergens: import("@reduxjs/toolkit").ActionCreatorWithoutPayload<"allergens/resetCustomerAllergens">, setCustomerAllergens: import("@reduxjs/toolkit").ActionCreatorWithPayload<any, "allergens/setCustomerAllergens">;
-export declare const selectCustomerAllergens: (state: AppState) => CustomerAllergensState;
-export declare const customerAllergensReducer: import("redux").Reducer<CustomerAllergensState, import("redux").AnyAction>;
+import { AppState } from '../../app';
+import { CustomerAllergens, RequestError, RequestStatus } from '@open-tender/types';
+export interface CustomerAllergensState {
+    entities: CustomerAllergens;
+    error: RequestError;
+    loading: RequestStatus;
+    lookup: {
+        [key: number | string]: number;
+    };
+}
+export declare enum CustomerAllergensActionType {
+    FetchCustomerAllergens = "customer/fetchCustomerAllergens",
+    UpdateCustomerAllergens = "customer/updateCustomerAllergens"
+}
+export declare const fetchCustomerAllergens: import("@reduxjs/toolkit").AsyncThunk<CustomerAllergens, 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 updateCustomerAllergens: import("@reduxjs/toolkit").AsyncThunk<CustomerAllergens, CustomerAllergens, {
+    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 resetCustomerAllergens: import("@reduxjs/toolkit").ActionCreatorWithoutPayload<"allergens/resetCustomerAllergens">, setCustomerAllergens: import("@reduxjs/toolkit").ActionCreatorWithPayload<any, "allergens/setCustomerAllergens">;
+export declare const selectCustomerAllergens: (state: AppState) => CustomerAllergensState;
+export declare const customerAllergensReducer: import("redux").Reducer<CustomerAllergensState, import("redux").AnyAction>;

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

@@ -1,89 +1,89 @@
-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 { setSelectedAllergens } from '../allergens';
-import { showNotification } from '../notifications';
-const initialState = {
-    entities: [],
-    lookup: {},
-    loading: 'idle',
-    error: null
-};
-export var CustomerAllergensActionType;
-(function (CustomerAllergensActionType) {
-    CustomerAllergensActionType["FetchCustomerAllergens"] = "customer/fetchCustomerAllergens";
-    CustomerAllergensActionType["UpdateCustomerAllergens"] = "customer/updateCustomerAllergens";
-})(CustomerAllergensActionType || (CustomerAllergensActionType = {}));
-export const fetchCustomerAllergens = createAsyncThunk(CustomerAllergensActionType.FetchCustomerAllergens, (_, { 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 allergens = yield api.getCustomerAllergens(token);
-        return allergens;
-    }
-    catch (err) {
-        const error = err;
-        return checkAuth(error, dispatch, () => rejectWithValue(error));
-    }
-}));
-export const updateCustomerAllergens = createAsyncThunk(CustomerAllergensActionType.UpdateCustomerAllergens, (data, { 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 allergens = yield api.putCustomerAllergens(token, data);
-        dispatch(setSelectedAllergens(allergens || []));
-        dispatch(showNotification('Allergens updated!'));
-        return allergens;
-    }
-    catch (err) {
-        const error = err;
-        return checkAuth(error, dispatch, () => rejectWithValue(error));
-    }
-}));
-const customerAllergensSlice = createSlice({
-    name: ReducerType.CustomerAllergens,
-    initialState,
-    reducers: {
-        resetCustomerAllergens: () => initialState,
-        setCustomerAllergens: (state, action) => {
-            state.entities = action.payload;
-            state.error = null;
-        }
-    },
-    extraReducers: builder => {
-        builder
-            .addCase(fetchCustomerAllergens.fulfilled, (state, action) => {
-            state.entities = action.payload;
-            state.loading = 'idle';
-            state.error = null;
-        })
-            .addCase(fetchCustomerAllergens.pending, state => {
-            state.loading = 'pending';
-        })
-            .addCase(fetchCustomerAllergens.rejected, (state, action) => {
-            state.error = action.payload;
-            state.loading = 'idle';
-        })
-            .addCase(updateCustomerAllergens.fulfilled, (state, action) => {
-            state.entities = action.payload;
-            state.loading = 'idle';
-            state.error = null;
-        })
-            .addCase(updateCustomerAllergens.pending, state => {
-            state.loading = 'pending';
-        })
-            .addCase(updateCustomerAllergens.rejected, (state, action) => {
-            state.error = action.payload;
-            state.loading = 'idle';
-        });
-    }
-});
-export const { resetCustomerAllergens, setCustomerAllergens } = customerAllergensSlice.actions;
-export const selectCustomerAllergens = (state) => state.customer.allergens;
-export const customerAllergensReducer = customerAllergensSlice.reducer;
+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 { setSelectedAllergens } from '../allergens';
+import { showNotification } from '../notifications';
+const initialState = {
+    entities: [],
+    lookup: {},
+    loading: 'idle',
+    error: null
+};
+export var CustomerAllergensActionType;
+(function (CustomerAllergensActionType) {
+    CustomerAllergensActionType["FetchCustomerAllergens"] = "customer/fetchCustomerAllergens";
+    CustomerAllergensActionType["UpdateCustomerAllergens"] = "customer/updateCustomerAllergens";
+})(CustomerAllergensActionType || (CustomerAllergensActionType = {}));
+export const fetchCustomerAllergens = createAsyncThunk(CustomerAllergensActionType.FetchCustomerAllergens, (_, { 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 allergens = yield api.getCustomerAllergens(token);
+        return allergens;
+    }
+    catch (err) {
+        const error = err;
+        return checkAuth(error, dispatch, () => rejectWithValue(error));
+    }
+}));
+export const updateCustomerAllergens = createAsyncThunk(CustomerAllergensActionType.UpdateCustomerAllergens, (data, { 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 allergens = yield api.putCustomerAllergens(token, data);
+        dispatch(setSelectedAllergens(allergens || []));
+        dispatch(showNotification('Allergens updated!'));
+        return allergens;
+    }
+    catch (err) {
+        const error = err;
+        return checkAuth(error, dispatch, () => rejectWithValue(error));
+    }
+}));
+const customerAllergensSlice = createSlice({
+    name: ReducerType.CustomerAllergens,
+    initialState,
+    reducers: {
+        resetCustomerAllergens: () => initialState,
+        setCustomerAllergens: (state, action) => {
+            state.entities = action.payload;
+            state.error = null;
+        }
+    },
+    extraReducers: builder => {
+        builder
+            .addCase(fetchCustomerAllergens.fulfilled, (state, action) => {
+            state.entities = action.payload;
+            state.loading = 'idle';
+            state.error = null;
+        })
+            .addCase(fetchCustomerAllergens.pending, state => {
+            state.loading = 'pending';
+        })
+            .addCase(fetchCustomerAllergens.rejected, (state, action) => {
+            state.error = action.payload;
+            state.loading = 'idle';
+        })
+            .addCase(updateCustomerAllergens.fulfilled, (state, action) => {
+            state.entities = action.payload;
+            state.loading = 'idle';
+            state.error = null;
+        })
+            .addCase(updateCustomerAllergens.pending, state => {
+            state.loading = 'pending';
+        })
+            .addCase(updateCustomerAllergens.rejected, (state, action) => {
+            state.error = action.payload;
+            state.loading = 'idle';
+        });
+    }
+});
+export const { resetCustomerAllergens, setCustomerAllergens } = customerAllergensSlice.actions;
+export const selectCustomerAllergens = (state) => state.customer.allergens;
+export const customerAllergensReducer = customerAllergensSlice.reducer;