@open-tender/cloud 0.0.1

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

@@ -0,0 +1,79 @@
+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 = {
+    entity: {},
+    error: null,
+    loading: 'idle'
+};
+export var CustomerOrderActionType;
+(function (CustomerOrderActionType) {
+    CustomerOrderActionType["FetchCustomerOrder"] = "customer/fetchCustomerOrder";
+    CustomerOrderActionType["UpdateCustomerFavorite"] = "customer/updateCustomerFavorite";
+})(CustomerOrderActionType || (CustomerOrderActionType = {}));
+export const fetchCustomerOrder = createAsyncThunk(CustomerOrderActionType.FetchCustomerOrder, (orderId, { 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 order = yield api.getCustomerOrder(token, orderId);
+        return order;
+    }
+    catch (err) {
+        const error = err;
+        return checkAuth(error, dispatch, () => rejectWithValue(error));
+    }
+}));
+export const updateCustomerOrderRating = createAsyncThunk(CustomerOrderActionType.FetchCustomerOrder, (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.putCustomerOrderRating(token, requestData.orderId, requestData.data);
+        dispatch(fetchCustomerOrder(requestData.orderId));
+        dispatch(showNotification('Rating updated!'));
+        return response;
+    }
+    catch (err) {
+        const error = err;
+        return checkAuth(error, dispatch, () => rejectWithValue(error));
+    }
+}));
+const customerOrderSlice = createSlice({
+    name: ReducerType.Order,
+    initialState,
+    reducers: {
+        resetCustomerOrder: () => initialState,
+        resetCustomerOrderError: state => {
+            state.error = null;
+            state.loading = 'idle';
+        },
+        setCustomerOrder: (state, action) => {
+            state.entity = action.payload;
+            state.error = null;
+        }
+    },
+    extraReducers: builder => {
+        builder
+            .addCase(fetchCustomerOrder.fulfilled, (state, action) => {
+            state.entity = action.payload;
+            state.loading = 'idle';
+            state.error = null;
+        })
+            .addCase(fetchCustomerOrder.pending, state => {
+            state.loading = 'pending';
+        })
+            .addCase(fetchCustomerOrder.rejected, (state, action) => {
+            state.error = action.payload;
+            state.loading = 'idle';
+        });
+    }
+});
+export const { resetCustomerOrder, resetCustomerOrderError, setCustomerOrder } = customerOrderSlice.actions;
+export const selectCustomerOrder = (state) => state.customer.order;
+export const customerOrderReducer = customerOrderSlice.reducer;

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

@@ -0,0 +1,20 @@
+import { AppState } from '../../app';
+import { Orders, RequestError, RequestStatus } from '@open-tender/types';
+export interface CustomerOrdersState {
+    entities: Orders;
+    error: RequestError;
+    loading: RequestStatus;
+    lookup: {
+        [key: number]: number;
+    };
+}
+export declare enum CustomerOrdersActionType {
+    FetchCustomerOrders = "customer/fetchCustomerOrders"
+}
+export declare const fetchCustomerOrders: import("@reduxjs/toolkit").AsyncThunk<Orders, number, {
+    state: AppState;
+    rejectValue: RequestError;
+}>;
+export declare const resetCustomerOrders: import("@reduxjs/toolkit").ActionCreatorWithoutPayload<string>, resetCustomerOrdersError: import("@reduxjs/toolkit").ActionCreatorWithoutPayload<string>, setCustomerOrders: import("@reduxjs/toolkit").ActionCreatorWithPayload<any, string>;
+export declare const selectCustomerOrders: (state: AppState) => CustomerOrdersState;
+export declare const customerOrdersReducer: import("redux").Reducer<CustomerOrdersState, import("redux").AnyAction>;

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

@@ -0,0 +1,62 @@
+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 = {
+    entities: [],
+    error: null,
+    loading: 'idle',
+    lookup: {}
+};
+export var CustomerOrdersActionType;
+(function (CustomerOrdersActionType) {
+    CustomerOrdersActionType["FetchCustomerOrders"] = "customer/fetchCustomerOrders";
+})(CustomerOrdersActionType || (CustomerOrdersActionType = {}));
+export const fetchCustomerOrders = createAsyncThunk(CustomerOrdersActionType.FetchCustomerOrders, (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: orders } = yield api.getCustomerOrders(token, limit);
+        return orders;
+    }
+    catch (err) {
+        const error = err;
+        return checkAuth(error, dispatch, () => rejectWithValue(error));
+    }
+}));
+const customerOrdersSlice = createSlice({
+    name: ReducerType.Orders,
+    initialState,
+    reducers: {
+        resetCustomerOrders: () => initialState,
+        resetCustomerOrdersError: state => {
+            state.error = null;
+            state.loading = 'idle';
+        },
+        setCustomerOrders: (state, action) => {
+            state.entities = action.payload;
+            state.error = null;
+        }
+    },
+    extraReducers: builder => {
+        builder
+            .addCase(fetchCustomerOrders.fulfilled, (state, action) => {
+            state.entities = action.payload;
+            state.loading = 'idle';
+            state.error = null;
+        })
+            .addCase(fetchCustomerOrders.pending, state => {
+            state.loading = 'pending';
+        })
+            .addCase(fetchCustomerOrders.rejected, (state, action) => {
+            state.error = action.payload;
+            state.loading = 'idle';
+        });
+    }
+});
+export const { resetCustomerOrders, resetCustomerOrdersError, setCustomerOrders } = customerOrdersSlice.actions;
+export const selectCustomerOrders = (state) => state.customer.orders;
+export const customerOrdersReducer = customerOrdersSlice.reducer;

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

@@ -0,0 +1,17 @@
+import { AppState } from '../../app';
+import { RequestError, RequestStatus } from '@open-tender/types';
+export interface CustomerQRCodeState {
+    qrcode: string | null;
+    error: RequestError;
+    loading: RequestStatus;
+}
+export declare enum CustomerQRCodeActionType {
+    FetchCustomerQRCode = "customer/fetchCustomerQRCode"
+}
+export declare const fetchCustomerQRCode: import("@reduxjs/toolkit").AsyncThunk<string, void, {
+    state: AppState;
+    rejectValue: RequestError;
+}>;
+export declare const resetCustomerQRCode: import("@reduxjs/toolkit").ActionCreatorWithoutPayload<string>;
+export declare const selectCustomerQRCode: (state: AppState) => CustomerQRCodeState;
+export declare const customerQRCodeReducer: import("redux").Reducer<CustomerQRCodeState, import("redux").AnyAction>;

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

@@ -0,0 +1,53 @@
+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 = {
+    qrcode: null,
+    error: null,
+    loading: 'idle'
+};
+export var CustomerQRCodeActionType;
+(function (CustomerQRCodeActionType) {
+    CustomerQRCodeActionType["FetchCustomerQRCode"] = "customer/fetchCustomerQRCode";
+})(CustomerQRCodeActionType || (CustomerQRCodeActionType = {}));
+export const fetchCustomerQRCode = createAsyncThunk(CustomerQRCodeActionType.FetchCustomerQRCode, (_, { 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 { qr_code_url } = yield api.getCustomerQRCode(token);
+        return qr_code_url;
+    }
+    catch (err) {
+        const error = err;
+        return checkAuth(error, dispatch, () => rejectWithValue(error));
+    }
+}));
+const customerQRCodeSlice = createSlice({
+    name: ReducerType.QRCode,
+    initialState,
+    reducers: {
+        resetCustomerQRCode: () => initialState
+    },
+    extraReducers: builder => {
+        builder
+            .addCase(fetchCustomerQRCode.fulfilled, (state, action) => {
+            state.qrcode = action.payload;
+            state.loading = 'idle';
+            state.error = null;
+        })
+            .addCase(fetchCustomerQRCode.pending, state => {
+            state.loading = 'pending';
+        })
+            .addCase(fetchCustomerQRCode.rejected, (state, action) => {
+            state.error = action.payload;
+            state.loading = 'idle';
+        });
+    }
+});
+export const { resetCustomerQRCode } = customerQRCodeSlice.actions;
+export const selectCustomerQRCode = (state) => state.customer.qrcode;
+export const customerQRCodeReducer = customerQRCodeSlice.reducer;

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

@@ -0,0 +1,20 @@
+import { AppState } from '../../app';
+import { Rewards, RequestError, RequestStatus } from '@open-tender/types';
+export interface CustomerRewardsState {
+    entities: Rewards;
+    error: RequestError;
+    loading: RequestStatus;
+    lookup: {
+        [key: number]: number;
+    };
+}
+export declare enum CustomerRewardsActionType {
+    FetchCustomerRewards = "customer/fetchCustomerRewards"
+}
+export declare const fetchCustomerRewards: import("@reduxjs/toolkit").AsyncThunk<Rewards, void, {
+    state: AppState;
+    rejectValue: RequestError;
+}>;
+export declare const resetCustomerRewards: import("@reduxjs/toolkit").ActionCreatorWithoutPayload<string>, resetCustomerRewardsError: import("@reduxjs/toolkit").ActionCreatorWithoutPayload<string>, setCustomerRewards: import("@reduxjs/toolkit").ActionCreatorWithPayload<any, string>;
+export declare const selectCustomerRewards: (state: AppState) => CustomerRewardsState;
+export declare const customerRewardsReducer: import("redux").Reducer<CustomerRewardsState, import("redux").AnyAction>;

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

@@ -0,0 +1,62 @@
+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 = {
+    entities: [],
+    error: null,
+    loading: 'idle',
+    lookup: {}
+};
+export var CustomerRewardsActionType;
+(function (CustomerRewardsActionType) {
+    CustomerRewardsActionType["FetchCustomerRewards"] = "customer/fetchCustomerRewards";
+})(CustomerRewardsActionType || (CustomerRewardsActionType = {}));
+export const fetchCustomerRewards = createAsyncThunk(CustomerRewardsActionType.FetchCustomerRewards, (_, { 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 rewards = yield api.getCustomerRewards(token);
+        return rewards;
+    }
+    catch (err) {
+        const error = err;
+        return checkAuth(error, dispatch, () => rejectWithValue(error));
+    }
+}));
+const customerRewardsSlice = createSlice({
+    name: ReducerType.Rewards,
+    initialState,
+    reducers: {
+        resetCustomerRewards: () => initialState,
+        resetCustomerRewardsError: state => {
+            state.error = null;
+            state.loading = 'idle';
+        },
+        setCustomerRewards: (state, action) => {
+            state.entities = action.payload;
+            state.error = null;
+        }
+    },
+    extraReducers: builder => {
+        builder
+            .addCase(fetchCustomerRewards.fulfilled, (state, action) => {
+            state.entities = action.payload;
+            state.loading = 'idle';
+            state.error = null;
+        })
+            .addCase(fetchCustomerRewards.pending, state => {
+            state.loading = 'pending';
+        })
+            .addCase(fetchCustomerRewards.rejected, (state, action) => {
+            state.error = action.payload;
+            state.loading = 'idle';
+        });
+    }
+});
+export const { resetCustomerRewards, resetCustomerRewardsError, setCustomerRewards } = customerRewardsSlice.actions;
+export const selectCustomerRewards = (state) => state.customer.rewards;
+export const customerRewardsReducer = customerRewardsSlice.reducer;

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

@@ -0,0 +1,17 @@
+import { AppState } from '../../app';
+import { Thanx, RequestError, RequestStatus } from '@open-tender/types';
+export interface CustomerThanxState {
+    thanx: Thanx | null;
+    error: RequestError;
+    loading: RequestStatus;
+}
+export declare enum CustomerThanxActionType {
+    FetchCustomerThanx = "customer/fetchCustomerThanx"
+}
+export declare const fetchCustomerThanx: import("@reduxjs/toolkit").AsyncThunk<Thanx, void, {
+    state: AppState;
+    rejectValue: RequestError;
+}>;
+export declare const resetCustomerThanx: import("@reduxjs/toolkit").ActionCreatorWithoutPayload<string>;
+export declare const selectCustomerThanx: (state: AppState) => CustomerThanxState;
+export declare const customerThanxReducer: import("redux").Reducer<CustomerThanxState, import("redux").AnyAction>;

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

@@ -0,0 +1,53 @@
+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 = {
+    thanx: null,
+    error: null,
+    loading: 'idle'
+};
+export var CustomerThanxActionType;
+(function (CustomerThanxActionType) {
+    CustomerThanxActionType["FetchCustomerThanx"] = "customer/fetchCustomerThanx";
+})(CustomerThanxActionType || (CustomerThanxActionType = {}));
+export const fetchCustomerThanx = createAsyncThunk(CustomerThanxActionType.FetchCustomerThanx, (_, { 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 resp = yield api.getCustomerThanx(token);
+        return resp;
+    }
+    catch (err) {
+        const error = err;
+        return checkAuth(error, dispatch, () => rejectWithValue(error));
+    }
+}));
+const customerThanxSlice = createSlice({
+    name: ReducerType.Thanx,
+    initialState,
+    reducers: {
+        resetCustomerThanx: () => initialState
+    },
+    extraReducers: builder => {
+        builder
+            .addCase(fetchCustomerThanx.fulfilled, (state, action) => {
+            state.thanx = action.payload;
+            state.loading = 'idle';
+            state.error = null;
+        })
+            .addCase(fetchCustomerThanx.pending, state => {
+            state.loading = 'pending';
+        })
+            .addCase(fetchCustomerThanx.rejected, (state, action) => {
+            state.error = action.payload;
+            state.loading = 'idle';
+        });
+    }
+});
+export const { resetCustomerThanx } = customerThanxSlice.actions;
+export const selectCustomerThanx = (state) => state.customer.thanx;
+export const customerThanxReducer = customerThanxSlice.reducer;

package/dist/esm/slices/deals.d.ts

@@ -0,0 +1,19 @@
+import { AppState } from '../app';
+import { Deals, Deal, RequestError, RequestStatus } from '@open-tender/types';
+export interface DealState {
+    entities: Deals;
+    error: RequestError;
+    loading: RequestStatus;
+    selected: Deal | null;
+}
+export declare enum DealActionType {
+    FetchDeals = "deals/fetchDeals"
+}
+export declare const fetchDeals: import("@reduxjs/toolkit").AsyncThunk<Deals, void, {
+    state: AppState;
+    rejectValue: RequestError;
+}>;
+export declare const resetDeals: import("@reduxjs/toolkit").ActionCreatorWithoutPayload<string>, setSelectedDeals: import("@reduxjs/toolkit").ActionCreatorWithPayload<any, string>;
+export declare const selectDeals: (state: AppState) => DealState;
+export declare const selectEligibleDeals: (state: AppState) => Deals;
+export declare const dealsReducer: import("redux").Reducer<DealState, import("redux").AnyAction>;

package/dist/esm/slices/deals.js

@@ -0,0 +1,91 @@
+import { __awaiter } from "tslib";
+import { createAsyncThunk, createSlice } from '@reduxjs/toolkit';
+import { ReducerType } from './types';
+import { getMinutesfromDate, time24ToMinutes } from '@open-tender/utils';
+const initialState = {
+    entities: [],
+    selected: null,
+    error: null,
+    loading: 'idle'
+};
+export var DealActionType;
+(function (DealActionType) {
+    DealActionType["FetchDeals"] = "deals/fetchDeals";
+})(DealActionType || (DealActionType = {}));
+export const fetchDeals = createAsyncThunk(DealActionType.FetchDeals, (_, { getState, rejectWithValue }) => __awaiter(void 0, void 0, void 0, function* () {
+    const { api } = getState().config;
+    if (!api)
+        return;
+    try {
+        const { profile } = getState().customer.account;
+        const { customer_id = null } = profile || {};
+        const deals = yield api.getDeals(customer_id);
+        return deals;
+    }
+    catch (err) {
+        return rejectWithValue(err);
+    }
+}));
+const dealsSlice = createSlice({
+    name: ReducerType.Deals,
+    initialState,
+    reducers: {
+        resetDeals: () => initialState,
+        setSelectedDeals: (state, action) => {
+            state.selected = action.payload;
+        }
+    },
+    extraReducers: builder => {
+        builder
+            .addCase(fetchDeals.fulfilled, (state, action) => {
+            state.entities = action.payload;
+            state.loading = 'idle';
+            state.error = null;
+        })
+            .addCase(fetchDeals.pending, state => {
+            state.loading = 'pending';
+        })
+            .addCase(fetchDeals.rejected, (state, action) => {
+            state.error = action.payload;
+            state.loading = 'idle';
+        });
+    }
+});
+export const { resetDeals, setSelectedDeals } = dealsSlice.actions;
+export const selectDeals = (state) => state.deals;
+export const selectEligibleDeals = (state) => {
+    const { brand } = state.config || {};
+    if (!brand || !brand.has_deals)
+        return [];
+    let { entities: deals } = state.deals;
+    const { orderType, serviceType, revenueCenter } = state.order;
+    if (orderType) {
+        deals = deals.filter(i => !i.order_type || i.order_type === orderType);
+    }
+    if (serviceType) {
+        deals = deals.filter(i => !i.service_type || i.service_type === serviceType);
+    }
+    if (revenueCenter) {
+        const { revenue_center_id } = revenueCenter;
+        deals = deals.filter(i => {
+            var _a;
+            return !((_a = i.revenue_centers) === null || _a === void 0 ? void 0 : _a.length) ||
+                i.revenue_centers
+                    .map(r => r.revenue_center_id)
+                    .includes(revenue_center_id);
+        });
+    }
+    const minutes = getMinutesfromDate(new Date());
+    deals = deals.filter(i => {
+        if (!i.dayparts.length)
+            return true;
+        const validDayparts = i.dayparts.filter(d => {
+            const start = time24ToMinutes(d.start_time);
+            const end = time24ToMinutes(d.end_time);
+            return start <= minutes && minutes <= end;
+        });
+        return validDayparts.length > 0;
+    });
+    return deals;
+};
+export const dealsReducer = dealsSlice.reducer;

package/dist/esm/slices/donations.d.ts

@@ -0,0 +1,26 @@
+import { AppState } from '../app';
+import { Donation, RequestError, RequestStatus, PurchaseDonationRequest } from '@open-tender/types';
+export interface DonationState {
+    donation: Donation | null;
+    error: RequestError | Record<string, any>;
+    loading: RequestStatus;
+    success: boolean;
+}
+export declare enum DonationActionType {
+    PurchaseDonation = "donations/purchaseDonation"
+}
+export declare const purchaseDonation: import("@reduxjs/toolkit").AsyncThunk<Donation, {
+    data: PurchaseDonationRequest;
+    callback?: (() => void) | undefined;
+}, {
+    state: AppState;
+    rejectValue: RequestError | Record<string, any>;
+}>;
+export declare const resetDonation: import("@reduxjs/toolkit").ActionCreatorWithoutPayload<string>;
+export declare const selectDonation: (state: AppState) => {
+    success: boolean;
+    loading: RequestStatus;
+    error: RequestError | Record<string, any>;
+    donation: Donation | null;
+};
+export declare const donationsReducer: import("redux").Reducer<DonationState, import("redux").AnyAction>;

package/dist/esm/slices/donations.js

@@ -0,0 +1,58 @@
+import { __awaiter } from "tslib";
+import { createAsyncThunk, createSlice } from '@reduxjs/toolkit';
+import { ReducerType } from './types';
+import { makeFormErrors } from '@open-tender/utils';
+const initialState = {
+    donation: null,
+    success: false,
+    error: null,
+    loading: 'idle'
+};
+export var DonationActionType;
+(function (DonationActionType) {
+    DonationActionType["PurchaseDonation"] = "donations/purchaseDonation";
+})(DonationActionType || (DonationActionType = {}));
+export const purchaseDonation = createAsyncThunk(DonationActionType.PurchaseDonation, (requestData, { getState, rejectWithValue }) => __awaiter(void 0, void 0, void 0, function* () {
+    const { api } = getState().config;
+    if (!api)
+        return;
+    try {
+        const donation = yield api.postPurchaseDonation(requestData.data);
+        if (requestData.callback)
+            requestData.callback();
+        return donation;
+    }
+    catch (err) {
+        const errors = makeFormErrors(err);
+        return rejectWithValue(errors);
+    }
+}));
+const donationsSlice = createSlice({
+    name: ReducerType.Donations,
+    initialState,
+    reducers: {
+        resetDonation: () => initialState
+    },
+    extraReducers: builder => {
+        builder
+            .addCase(purchaseDonation.fulfilled, (state, action) => {
+            state.donation = action.payload;
+            state.success = true;
+            state.loading = 'idle';
+            state.error = null;
+        })
+            .addCase(purchaseDonation.pending, state => {
+            state.loading = 'pending';
+        })
+            .addCase(purchaseDonation.rejected, (state, action) => {
+            state.error = action.payload;
+            state.loading = 'idle';
+        });
+    }
+});
+export const { resetDonation } = donationsSlice.actions;
+export const selectDonation = (state) => {
+    const { success, loading, error, donation } = state.donations;
+    return { success, loading, error, donation };
+};
+export const donationsReducer = donationsSlice.reducer;

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

@@ -0,0 +1,26 @@
+import { AppState } from '../app';
+import { CustomerGiftCard, CustomerGiftCards, RequestError, RequestStatus } from '@open-tender/types';
+export interface GiftCardsState {
+    loading: RequestStatus;
+    error: RequestError;
+    success: boolean;
+    giftCards: CustomerGiftCards;
+}
+export declare enum GiftCardsActionType {
+    PurchaseGiftCards = "giftCards/purchaseGiftCards"
+}
+export declare const purchaseGiftCards: import("@reduxjs/toolkit").AsyncThunk<CustomerGiftCards, {
+    data: Partial<CustomerGiftCard>;
+    callback?: (() => void) | undefined;
+}, {
+    state: AppState;
+    rejectValue: any;
+}>;
+export declare const resetGiftCards: import("@reduxjs/toolkit").ActionCreatorWithoutPayload<string>;
+export declare const selectGiftCards: (state: AppState) => {
+    success: boolean;
+    loading: RequestStatus;
+    error: RequestError;
+    giftCards: CustomerGiftCards;
+};
+export declare const giftCardsReducer: import("redux").Reducer<GiftCardsState, import("redux").AnyAction>;

package/dist/esm/slices/giftCards.js

@@ -0,0 +1,59 @@
+import { __awaiter } from "tslib";
+import { createAsyncThunk, createSlice } from '@reduxjs/toolkit';
+import { ReducerType } from './types';
+import { makeFormErrors } from '@open-tender/utils';
+const initialState = {
+    loading: 'idle',
+    error: null,
+    success: false,
+    giftCards: []
+};
+export var GiftCardsActionType;
+(function (GiftCardsActionType) {
+    GiftCardsActionType["PurchaseGiftCards"] = "giftCards/purchaseGiftCards";
+})(GiftCardsActionType || (GiftCardsActionType = {}));
+export const purchaseGiftCards = createAsyncThunk(GiftCardsActionType.PurchaseGiftCards, (requestData, { getState, rejectWithValue }) => __awaiter(void 0, void 0, void 0, function* () {
+    const { api } = getState().config;
+    if (!api)
+        return;
+    try {
+        const giftCards = yield api.postPurchaseGiftCards(requestData.data);
+        if (requestData.callback)
+            requestData.callback();
+        return giftCards;
+    }
+    catch (err) {
+        const errors = makeFormErrors(err);
+        return rejectWithValue(errors);
+    }
+}));
+const giftCardsSlice = createSlice({
+    name: ReducerType.GiftCards,
+    initialState,
+    reducers: {
+        resetGiftCards: () => initialState
+    },
+    extraReducers: builder => {
+        builder
+            .addCase(purchaseGiftCards.fulfilled, (state, action) => {
+            state.success = true;
+            state.giftCards = action.payload;
+            state.loading = 'idle';
+            state.error = null;
+        })
+            .addCase(purchaseGiftCards.pending, state => {
+            state.loading = 'pending';
+        })
+            .addCase(purchaseGiftCards.rejected, (state, action) => {
+            state.loading = 'idle';
+            state.success = false;
+            state.error = action.payload;
+        });
+    }
+});
+export const { resetGiftCards } = giftCardsSlice.actions;
+export const selectGiftCards = (state) => {
+    const { success, loading, error, giftCards } = state.giftCards;
+    return { success, loading, error, giftCards };
+};
+export const giftCardsReducer = giftCardsSlice.reducer;