@frontegg/redux-store 7.0.0-alpha.1 → 7.0.0-alpha.10

package/subscriptions/Billing/Invoices/index.js

@@ -1,40 +1,3 @@
-import _extends from "@babel/runtime/helpers/esm/extends";
-import { createModuleCaseReducers } from '../../utils';
-import { createAction, createSlice } from '@reduxjs/toolkit';
-import { subscriptionsStoreName } from '../../../constants';
-export const initialInvoicesState = {
-  loading: false,
-  error: null,
-  fetching: true,
-  invoices: [],
-  invoiceDownload: {
-    loading: false,
-    error: null
-  }
-};
-const reducers = _extends({}, createModuleCaseReducers(), {
-  setInvoiceDownloadState: {
-    prepare: payload => ({
-      payload
-    }),
-    reducer: (state, action) => _extends({}, state, {
-      invoiceDownload: _extends({}, state.invoiceDownload, action.payload)
-    })
-  }
-});
-const {
-  reducer,
-  actions: sliceActions,
-  name
-} = createSlice({
-  name: `${subscriptionsStoreName}/billing/invoices`,
-  initialState: initialInvoicesState,
-  reducers
-});
-const actions = _extends({
-  loadInvoices: createAction(`${name}/loadInvoices`),
-  downloadInvoice: createAction(`${name}/downloadInvoice`, payload => ({
-    payload
-  }))
-}, sliceActions);
-export { reducer as invoicesReducer, actions as invoicesActions };
+import createInvoicesState from './state';
+import buildInvoicesActions from './actions';
+export { createInvoicesState, buildInvoicesActions };

package/subscriptions/Billing/Invoices/interfaces.d.ts

@@ -1,4 +1,4 @@
-import { Invoice } from '../../general.interfaces';
+import { Invoice } from '../../interfaces';
 export interface InvoicesState {
     loading: boolean;
     error: string | null;

package/subscriptions/Billing/Invoices/state.d.ts

@@ -0,0 +1,4 @@
+import { InvoicesState } from './interfaces';
+export declare const initialState: InvoicesState;
+declare const _default: (overrideState?: Partial<InvoicesState> | undefined) => InvoicesState;
+export default _default;

package/subscriptions/Billing/Invoices/state.js

@@ -0,0 +1,12 @@
+import { createProxy } from '../../../toolkit/proxy';
+export const initialState = {
+  loading: false,
+  error: null,
+  fetching: true,
+  invoices: [],
+  invoiceDownload: {
+    loading: false,
+    error: null
+  }
+};
+export default (overrideState => createProxy(initialState, overrideState));

package/subscriptions/Billing/PaymentMethod/actions.d.ts

@@ -0,0 +1,12 @@
+import { FronteggState, RestApi, SharedActions, WithCallback, WithId } from '../../../interfaces';
+import { ISubscriptionUpdatePaymentMethodBillingDetails } from '@frontegg/rest-api';
+declare const _default: (store: FronteggState, api: RestApi, sharedActions: SharedActions) => {
+    setBillingPaymentMethodState: (state: Partial<{}>) => void;
+    resetBillingPaymentMethodState: () => void;
+    loadPaymentMethod: () => Promise<void>;
+    submitPaymentMethod: () => Promise<void>;
+    submitPaymentMethodError: (error: string) => Promise<void>;
+    submitPaymentMethodSuccess: () => Promise<void>;
+    updatePaymentMethodBillingDetails: (payload: WithCallback<WithId<ISubscriptionUpdatePaymentMethodBillingDetails>>) => Promise<void>;
+};
+export default _default;

package/subscriptions/Billing/PaymentMethod/actions.js

@@ -0,0 +1,84 @@
+import _extends from "@babel/runtime/helpers/esm/extends";
+import { deepClone, errorHandler } from '../../../helpers';
+import { initialState } from './state';
+export default ((store, api, sharedActions) => {
+  const setBillingPaymentMethodState = state => {
+    Object.assign(store.subscriptions.billing.paymentMethod, state);
+  };
+  const resetBillingPaymentMethodState = () => {
+    store.subscriptions.billing.paymentMethod = deepClone(initialState);
+  };
+
+  /** @private */
+  const __setLoading = loading => {
+    setBillingPaymentMethodState({
+      loading
+    });
+  };
+
+  /** @private */
+  const __setError = error => {
+    setBillingPaymentMethodState({
+      error,
+      loading: false,
+      fetching: false
+    });
+  };
+  const loadPaymentMethod = async () => {
+    __setLoading(true);
+    try {
+      const paymentMethods = await api.subscriptions.getPaymentMethods();
+      const paymentMethod = paymentMethods[0];
+      setBillingPaymentMethodState({
+        paymentMethod,
+        loading: false,
+        fetching: false
+      });
+    } catch (e) {
+      __setError(errorHandler(e));
+    }
+  };
+  const updatePaymentMethodBillingDetails = async payload => {
+    __setLoading(true);
+    const {
+      id,
+      email,
+      address,
+      callback
+    } = payload;
+    try {
+      await api.subscriptions.updatePaymentMethodBillingDetails(id, _extends({
+        email
+      }, address));
+      await loadPaymentMethod();
+      callback == null ? void 0 : callback(true);
+    } catch (e) {
+      __setError(errorHandler(e));
+      callback == null ? void 0 : callback(false, e);
+    } finally {
+      __setLoading(false);
+    }
+  };
+
+  // TODO: refactor to remove redundant code
+  const submitPaymentMethod = async () => {
+    __setLoading(true);
+  };
+  // TODO: refactor to remove redundant code
+  const submitPaymentMethodError = async error => {
+    __setError(error);
+  };
+  // TODO: refactor to remove redundant code
+  const submitPaymentMethodSuccess = async () => {
+    return await loadPaymentMethod();
+  };
+  return {
+    setBillingPaymentMethodState,
+    resetBillingPaymentMethodState,
+    loadPaymentMethod,
+    submitPaymentMethod,
+    submitPaymentMethodError,
+    submitPaymentMethodSuccess,
+    updatePaymentMethodBillingDetails
+  };
+});

package/subscriptions/Billing/PaymentMethod/index.d.ts

@@ -1,20 +1,3 @@
-import { PaymentMethodState } from './interfaces';
-import { ISubscriptionUpdatePaymentMethodBillingDetails } from '@frontegg/rest-api';
-import { WithCallback } from '../../../interfaces';
-export declare const initialPaymentMethodState: PaymentMethodState;
-declare const reducer: import("redux").Reducer<PaymentMethodState, import("redux").AnyAction>;
-declare const actions: {
-    setState: import("@reduxjs/toolkit").ActionCreatorWithPreparedPayload<[Partial<PaymentMethodState>], Partial<PaymentMethodState>, string, never, never>;
-    setLoading: import("@reduxjs/toolkit").ActionCreatorWithPreparedPayload<[boolean], boolean, string, never, never>;
-    setError: import("@reduxjs/toolkit").ActionCreatorWithPreparedPayload<[string | null], string | null, string, never, never>;
-    loadPaymentMethod: import("@reduxjs/toolkit").ActionCreatorWithoutPayload<string>;
-    submitPaymentMethod: import("@reduxjs/toolkit").ActionCreatorWithoutPayload<string>;
-    submitPaymentMethodError: import("@reduxjs/toolkit").ActionCreatorWithPayload<string, string>;
-    submitPaymentMethodSuccess: import("@reduxjs/toolkit").ActionCreatorWithoutPayload<string>;
-    updatePaymentMethodBillingDetails: import("@reduxjs/toolkit").ActionCreatorWithPreparedPayload<[WithCallback<ISubscriptionUpdatePaymentMethodBillingDetails & {
-        id: string;
-    }, boolean>], WithCallback<ISubscriptionUpdatePaymentMethodBillingDetails & {
-        id: string;
-    }, boolean>, string, never, never>;
-};
-export { reducer as subscriptionsPaymentMethodReducer, actions as subscriptionsPaymentMethodActions };
+import createPaymentMethodState from './state';
+import buildPaymentMethodActions from './actions';
+export { createPaymentMethodState, buildPaymentMethodActions };

package/subscriptions/Billing/PaymentMethod/index.js

@@ -1,37 +1,3 @@
-import _extends from "@babel/runtime/helpers/esm/extends";
-import { createModuleCaseReducers } from '../../utils';
-import { subscriptionsStoreName } from '../../../constants';
-import { createAction, createSlice } from '@reduxjs/toolkit';
-export const initialPaymentMethodState = {
-  loading: false,
-  error: null,
-  fetching: true
-};
-const reducers = _extends({}, createModuleCaseReducers(), {
-  setState: {
-    prepare: payload => ({
-      payload
-    }),
-    reducer: (state, action) => _extends({}, state, action.payload)
-  }
-});
-const {
-  reducer,
-  actions: paymentActions,
-  name
-} = createSlice({
-  name: `${subscriptionsStoreName}/billing/payment`,
-  initialState: initialPaymentMethodState,
-  reducers
-});
-const actions = _extends({
-  loadPaymentMethod: createAction(`${name}/loadPaymentMethod`),
-  submitPaymentMethod: createAction(`${name}/submitPaymentMethod`),
-  submitPaymentMethodError: createAction(`${name}/submitPaymentMethodError`),
-  submitPaymentMethodSuccess: createAction(`${name}/submitPaymentMethodSuccess`),
-  updatePaymentMethodBillingDetails: createAction(`${name}/updateBillingDetails`, payload => ({
-    payload
-  }))
-}, paymentActions);
-//TODO: refactor to general code-style like export type ConnectivityActions = DispatchedActions;
-export { reducer as subscriptionsPaymentMethodReducer, actions as subscriptionsPaymentMethodActions };
+import createPaymentMethodState from './state';
+import buildPaymentMethodActions from './actions';
+export { createPaymentMethodState, buildPaymentMethodActions };

package/subscriptions/Billing/PaymentMethod/interfaces.d.ts

@@ -1,5 +1,5 @@
-import { WithCallback } from '../../../interfaces';
 import { ISubscriptionUpdatePaymentMethodBillingDetails } from '@frontegg/rest-api';
+import { WithCallback } from '../../../interfaces';
 export declare type PaymentMethod = {
     id: string;
     type: 'card';

package/subscriptions/Billing/PaymentMethod/interfaces.js

@@ -1,5 +1,3 @@
-//TODO: consider use types from typescript-rest-api or duplicate them.
-
 export let PaymentMethodType;
 (function (PaymentMethodType) {
   PaymentMethodType["UNKNWON"] = "unknown";

package/subscriptions/Billing/PaymentMethod/state.d.ts

@@ -0,0 +1,4 @@
+import { PaymentMethodState } from './interfaces';
+export declare const initialState: PaymentMethodState;
+declare const _default: (overrideState?: Partial<PaymentMethodState> | undefined) => PaymentMethodState;
+export default _default;

package/subscriptions/Billing/PaymentMethod/state.js

@@ -0,0 +1,7 @@
+import { createProxy } from '../../../toolkit/proxy';
+export const initialState = {
+  loading: false,
+  error: null,
+  fetching: true
+};
+export default (overrideState => createProxy(initialState, overrideState));

package/subscriptions/Billing/Subscription/actions.d.ts

@@ -0,0 +1,14 @@
+import { FronteggState, RestApi, SharedActions } from '../../../interfaces';
+declare const _default: (store: FronteggState, api: RestApi, sharedActions: SharedActions) => {
+    setBillingSubscriptionState: (state: Partial<{}>) => void;
+    resetBillingSubscriptionState: () => void;
+    setCancellationLoading: (loading: boolean) => void;
+    setCancellationError: (error: string | null) => void;
+    setRenewalLoading: (loading: boolean) => void;
+    setRenewalError: (error: string | null) => void;
+    loadSubscription: () => Promise<void>;
+    loadSubscriptionTenant: () => Promise<void>;
+    cancelSubscription: () => Promise<void>;
+    renewSubscription: () => Promise<void>;
+};
+export default _default;

package/subscriptions/Billing/Subscription/actions.js

@@ -0,0 +1,138 @@
+import { initialState } from './state';
+import { deepClone, errorHandler } from '../../../helpers';
+import { ISubscriptionCancellationPolicy, ISubscriptionStatus } from '@frontegg/rest-api';
+export default ((store, api, sharedActions) => {
+  const actions = sharedActions;
+  const setBillingSubscriptionState = state => {
+    Object.assign(store.subscriptions.billing.subscription, state);
+  };
+  const resetBillingSubscriptionState = () => {
+    store.subscriptions.billing.subscription = deepClone(initialState);
+  };
+  const __setError = error => {
+    setBillingSubscriptionState({
+      error,
+      loading: false,
+      fetching: false
+    });
+  };
+  const __setLoading = loading => {
+    setBillingSubscriptionState({
+      loading
+    });
+  };
+  const setCancellationLoading = loading => {
+    Object.assign(store.subscriptions.billing.subscription.cancellation, {
+      loading
+    });
+  };
+  const setCancellationError = error => {
+    Object.assign(store.subscriptions.billing.subscription.cancellation, {
+      error
+    });
+  };
+  const setRenewalLoading = loading => {
+    Object.assign(store.subscriptions.billing.subscription.renewal, {
+      loading
+    });
+  };
+  const setRenewalError = error => {
+    Object.assign(store.subscriptions.billing.subscription.renewal, {
+      error
+    });
+  };
+  const loadSubscription = async () => {
+    __setLoading(true);
+    try {
+      const [subscription] = await api.subscriptions.getManagedSubscriptions();
+      setBillingSubscriptionState({
+        subscription,
+        fetching: false,
+        loading: false,
+        error: null
+      });
+    } catch (e) {
+      __setError(errorHandler(e));
+    }
+  };
+  const loadSubscriptionTenant = async () => {
+    var _store$auth$user;
+    const tenantId = (_store$auth$user = store.auth.user) == null ? void 0 : _store$auth$user.tenantId;
+    if (!tenantId) {
+      __setError('TenantId is not defined');
+      return;
+    }
+    await actions.loadSummaries(tenantId);
+  };
+  const cancelSubscription = async () => {
+    const {
+      subscription
+    } = store.subscriptions.billing.subscription;
+    if (!subscription) {
+      setCancellationError('Subscription not found.');
+      return;
+    }
+    if (subscription != null && subscription.externallyManaged) {
+      setCancellationError('Billing is externally managed.');
+      return;
+    }
+    const {
+      id: subscriptionId,
+      cancellation,
+      status
+    } = subscription || {};
+    const isCancellable = !cancellation && status === ISubscriptionStatus.ACTIVE;
+    if (isCancellable) {
+      try {
+        setCancellationLoading(true);
+        await api.subscriptions.cancelManagedSubscription(subscriptionId);
+        await loadSubscription();
+        setCancellationLoading(false);
+      } catch (e) {
+        setCancellationError(errorHandler(e));
+      }
+    }
+  };
+  const renewSubscription = async () => {
+    const {
+      subscription
+    } = store.subscriptions.billing.subscription;
+    if (!subscription) {
+      setRenewalError('Subscription not found.');
+      return;
+    }
+    if (subscription != null && subscription.externallyManaged) {
+      setRenewalError('Billing is externally managed');
+      return;
+    }
+    const {
+      id: subscriptionId,
+      cancellation
+    } = subscription || {};
+    const renewable = (cancellation == null ? void 0 : cancellation.policy) === ISubscriptionCancellationPolicy.AT_PERIOD_END;
+    if (renewable) {
+      try {
+        setRenewalLoading(true);
+        await api.subscriptions.renewManagedSubscription(subscriptionId);
+        await loadSubscription();
+        setRenewalLoading(false);
+      } catch (e) {
+        setRenewalError(errorHandler(e));
+      }
+    }
+  };
+  return {
+    // reducers
+    setBillingSubscriptionState,
+    resetBillingSubscriptionState,
+    setCancellationLoading,
+    setCancellationError,
+    setRenewalLoading,
+    setRenewalError,
+    // actions
+    loadSubscription,
+    loadSubscriptionTenant,
+    cancelSubscription,
+    renewSubscription
+  };
+});

package/subscriptions/Billing/Subscription/index.d.ts

@@ -1,16 +1,3 @@
-import { SubscriptionState } from './interfaces';
-export declare const initialSubscriptionState: SubscriptionState;
-declare const reducer: import("redux").Reducer<SubscriptionState, import("redux").AnyAction>;
-declare const actions: {
-    setCancellationLoading: import("@reduxjs/toolkit").ActionCreatorWithPreparedPayload<[boolean], boolean, string, never, never>;
-    setCancellationError: import("@reduxjs/toolkit").ActionCreatorWithPreparedPayload<[string | null], string | null, string, never, never>;
-    setRenewalLoading: import("@reduxjs/toolkit").ActionCreatorWithPreparedPayload<[boolean], boolean, string, never, never>;
-    setRenewalError: import("@reduxjs/toolkit").ActionCreatorWithPreparedPayload<[string | null], string | null, string, never, never>;
-    setLoading: import("@reduxjs/toolkit").ActionCreatorWithPreparedPayload<[boolean], boolean, string, never, never>;
-    setError: import("@reduxjs/toolkit").ActionCreatorWithPreparedPayload<[string | null], string | null, string, never, never>;
-    setState: import("@reduxjs/toolkit").ActionCreatorWithPreparedPayload<[Partial<SubscriptionState>], Partial<SubscriptionState>, string, never, never>;
-    load: import("@reduxjs/toolkit").ActionCreatorWithoutPayload<string>;
-    cancelSubscription: import("@reduxjs/toolkit").ActionCreatorWithoutPayload<string>;
-    renewSubscription: import("@reduxjs/toolkit").ActionCreatorWithoutPayload<string>;
-};
-export { reducer as subscriptionReducer, actions as subscriptionActions };
+import createSubscriptionState from './state';
+import buildSubscriptionActions from './actions';
+export { createSubscriptionState, buildSubscriptionActions };

package/subscriptions/Billing/Subscription/index.js

@@ -1,38 +1,3 @@
-import _extends from "@babel/runtime/helpers/esm/extends";
-import { createAction, createSlice } from '@reduxjs/toolkit';
-import { subscriptionsStoreName } from '../../../constants';
-import { createKeyCaseErrorReducer, createKeyCaseLoadingReducer, createModuleCaseReducers } from '../../utils';
-export const initialSubscriptionState = {
-  loading: false,
-  error: null,
-  fetching: true,
-  cancellation: {
-    loading: false,
-    error: null
-  },
-  renewal: {
-    loading: false,
-    error: null
-  }
-};
-const reducers = _extends({}, createModuleCaseReducers(), {
-  setCancellationLoading: createKeyCaseLoadingReducer('cancellation'),
-  setCancellationError: createKeyCaseErrorReducer('cancellation'),
-  setRenewalLoading: createKeyCaseLoadingReducer('renewal'),
-  setRenewalError: createKeyCaseErrorReducer('renewal')
-});
-const {
-  reducer,
-  actions: overviewActions,
-  name
-} = createSlice({
-  name: `${subscriptionsStoreName}/billing/subscription`,
-  initialState: initialSubscriptionState,
-  reducers
-});
-const actions = _extends({
-  load: createAction(`${name}/loadSubscription`),
-  cancelSubscription: createAction(`${name}/cancelSubscription`),
-  renewSubscription: createAction(`${name}/renewSubscription`)
-}, overviewActions);
-export { reducer as subscriptionReducer, actions as subscriptionActions };
+import createSubscriptionState from './state';
+import buildSubscriptionActions from './actions';
+export { createSubscriptionState, buildSubscriptionActions };

package/subscriptions/Billing/Subscription/interfaces.d.ts

@@ -13,6 +13,3 @@ export interface SubscriptionState {
         error: string | null;
     };
 }
-export interface SubscriptionActions {
-    load: () => void;
-}

package/subscriptions/Billing/Subscription/state.d.ts

@@ -0,0 +1,4 @@
+import { SubscriptionState } from './interfaces';
+export declare const initialState: SubscriptionState;
+declare const _default: (overrideState?: Partial<SubscriptionState> | undefined) => SubscriptionState;
+export default _default;

package/subscriptions/Billing/Subscription/state.js

@@ -0,0 +1,15 @@
+import { createProxy } from '../../../toolkit/proxy';
+export const initialState = {
+  loading: false,
+  error: null,
+  fetching: true,
+  cancellation: {
+    loading: false,
+    error: null
+  },
+  renewal: {
+    loading: false,
+    error: null
+  }
+};
+export default (overrideState => createProxy(initialState, overrideState));

package/subscriptions/Billing/index.d.ts

@@ -1,54 +1,15 @@
-import { AnyAction } from '@reduxjs/toolkit';
+import { DeepPartial, FronteggState, RestApi, SharedActions } from '../../interfaces';
 import { BillingState } from './interfaces';
-export declare const billingInitialState: BillingState;
-export declare const billingActions: {
-    invoices: {
-        setInvoiceDownloadState: import("@reduxjs/toolkit").ActionCreatorWithPreparedPayload<[{
-            loading: boolean;
-            error: string | null;
-        }], {
-            loading: boolean;
-            error: string | null;
-        }, string, never, never>;
-        setLoading: import("@reduxjs/toolkit").ActionCreatorWithPreparedPayload<[boolean], boolean, string, never, never>;
-        setError: import("@reduxjs/toolkit").ActionCreatorWithPreparedPayload<[string | null], string | null, string, never, never>;
-        setState: import("@reduxjs/toolkit").ActionCreatorWithPreparedPayload<[Partial<import("./interfaces").InvoicesState>], Partial<import("./interfaces").InvoicesState>, string, never, never>;
-        loadInvoices: import("@reduxjs/toolkit").ActionCreatorWithoutPayload<string>;
-        downloadInvoice: import("@reduxjs/toolkit").ActionCreatorWithPreparedPayload<[import("./interfaces").DownloadInvoiceActionPayload], import("./interfaces").DownloadInvoiceActionPayload, string, never, never>;
-    };
-    information: {
-        setLoading: import("@reduxjs/toolkit").ActionCreatorWithPreparedPayload<[boolean], boolean, string, never, never>;
-        setError: import("@reduxjs/toolkit").ActionCreatorWithPreparedPayload<[string | null], string | null, string, never, never>;
-        setState: import("@reduxjs/toolkit").ActionCreatorWithPreparedPayload<[Partial<import("./interfaces").BillingInformationState>], Partial<import("./interfaces").BillingInformationState>, string, never, never>;
-        loadBillingInformation: import("@reduxjs/toolkit").ActionCreatorWithoutPayload<string>;
-        cancelSubscription: import("@reduxjs/toolkit").ActionCreatorWithoutPayload<string>;
-        renewSubscription: import("@reduxjs/toolkit").ActionCreatorWithoutPayload<string>;
-    };
-    paymentMethod: {
-        setState: import("@reduxjs/toolkit").ActionCreatorWithPreparedPayload<[Partial<import("./interfaces").PaymentMethodState>], Partial<import("./interfaces").PaymentMethodState>, string, never, never>;
-        setLoading: import("@reduxjs/toolkit").ActionCreatorWithPreparedPayload<[boolean], boolean, string, never, never>;
-        setError: import("@reduxjs/toolkit").ActionCreatorWithPreparedPayload<[string | null], string | null, string, never, never>;
-        loadPaymentMethod: import("@reduxjs/toolkit").ActionCreatorWithoutPayload<string>;
-        submitPaymentMethod: import("@reduxjs/toolkit").ActionCreatorWithoutPayload<string>;
-        submitPaymentMethodError: import("@reduxjs/toolkit").ActionCreatorWithPayload<string, string>;
-        submitPaymentMethodSuccess: import("@reduxjs/toolkit").ActionCreatorWithoutPayload<string>;
-        updatePaymentMethodBillingDetails: import("@reduxjs/toolkit").ActionCreatorWithPreparedPayload<[import("../..").WithCallback<import("@frontegg/rest-api").ISubscriptionUpdatePaymentMethodBillingDetails & {
-            id: string;
-        }, boolean>], import("../..").WithCallback<import("@frontegg/rest-api").ISubscriptionUpdatePaymentMethodBillingDetails & {
-            id: string;
-        }, boolean>, string, never, never>;
-    };
-    subscription: {
-        setCancellationLoading: import("@reduxjs/toolkit").ActionCreatorWithPreparedPayload<[boolean], boolean, string, never, never>;
-        setCancellationError: import("@reduxjs/toolkit").ActionCreatorWithPreparedPayload<[string | null], string | null, string, never, never>;
-        setRenewalLoading: import("@reduxjs/toolkit").ActionCreatorWithPreparedPayload<[boolean], boolean, string, never, never>;
-        setRenewalError: import("@reduxjs/toolkit").ActionCreatorWithPreparedPayload<[string | null], string | null, string, never, never>;
-        setLoading: import("@reduxjs/toolkit").ActionCreatorWithPreparedPayload<[boolean], boolean, string, never, never>;
-        setError: import("@reduxjs/toolkit").ActionCreatorWithPreparedPayload<[string | null], string | null, string, never, never>;
-        setState: import("@reduxjs/toolkit").ActionCreatorWithPreparedPayload<[Partial<import("./interfaces").SubscriptionState>], Partial<import("./interfaces").SubscriptionState>, string, never, never>;
-        load: import("@reduxjs/toolkit").ActionCreatorWithoutPayload<string>;
-        cancelSubscription: import("@reduxjs/toolkit").ActionCreatorWithoutPayload<string>;
-        renewSubscription: import("@reduxjs/toolkit").ActionCreatorWithoutPayload<string>;
-    };
+import { buildInformationActions } from './Information';
+import { buildInvoicesActions } from './Invoices';
+import { buildPaymentMethodActions } from './PaymentMethod';
+import { buildSubscriptionActions } from './Subscription';
+export declare const createBillingState: (overrideState?: DeepPartial<BillingState> | undefined) => BillingState;
+export declare const buildBillingActions: (store: FronteggState, api: RestApi, actions: SharedActions) => [BillingActions, BillingStateActions];
+export declare type BillingActions = ReturnType<typeof buildInformationActions> & ReturnType<typeof buildInvoicesActions> & ReturnType<typeof buildPaymentMethodActions> & ReturnType<typeof buildSubscriptionActions>;
+export declare type BillingStateActions = {
+    information: ReturnType<typeof buildInformationActions>;
+    invoices: ReturnType<typeof buildInvoicesActions>;
+    paymentMethod: ReturnType<typeof buildPaymentMethodActions>;
+    subscription: ReturnType<typeof buildSubscriptionActions>;
 };
-export declare const billingReducer: import("redux").Reducer<import("redux").CombinedState<BillingState>, AnyAction>;

package/subscriptions/Billing/index.js

@@ -1,23 +1,26 @@
-import { combineReducers } from '@reduxjs/toolkit';
-import { informationActions, informationReducer, initialBillingInformationState } from './Information';
-import { initialPaymentMethodState, subscriptionsPaymentMethodActions, subscriptionsPaymentMethodReducer } from './PaymentMethod';
-import { initialInvoicesState, invoicesActions, invoicesReducer } from './Invoices';
-import { initialSubscriptionState, subscriptionActions, subscriptionReducer } from './Subscription';
-export const billingInitialState = {
-  information: initialBillingInformationState,
-  invoices: initialInvoicesState,
-  paymentMethod: initialPaymentMethodState,
-  subscription: initialSubscriptionState
+import _extends from "@babel/runtime/helpers/esm/extends";
+import { createInformationState, buildInformationActions } from './Information';
+import { createInvoicesState, buildInvoicesActions } from './Invoices';
+import { createPaymentMethodState, buildPaymentMethodActions } from './PaymentMethod';
+import { createSubscriptionState, buildSubscriptionActions } from './Subscription';
+import { createProxy } from '../../toolkit/proxy';
+export const createBillingState = overrideState => {
+  return createProxy({
+    information: createInformationState(overrideState == null ? void 0 : overrideState.information),
+    invoices: createInvoicesState(overrideState == null ? void 0 : overrideState.invoices),
+    paymentMethod: createPaymentMethodState(overrideState == null ? void 0 : overrideState.paymentMethod),
+    subscription: createSubscriptionState(overrideState == null ? void 0 : overrideState.subscription)
+  });
 };
-export const billingActions = {
-  invoices: invoicesActions,
-  information: informationActions,
-  paymentMethod: subscriptionsPaymentMethodActions,
-  subscription: subscriptionActions
-};
-export const billingReducer = combineReducers({
-  invoices: invoicesReducer,
-  information: informationReducer,
-  paymentMethod: subscriptionsPaymentMethodReducer,
-  subscription: subscriptionReducer
-});
+export const buildBillingActions = (store, api, actions) => {
+  const informationActions = buildInformationActions(store, api, actions);
+  const paymentMethodActions = buildPaymentMethodActions(store, api, actions);
+  const invoicesActions = buildInvoicesActions(store, api, actions);
+  const subscriptionActions = buildSubscriptionActions(store, api, actions);
+  return [_extends({}, informationActions, paymentMethodActions, invoicesActions, subscriptionActions), {
+    information: informationActions,
+    invoices: invoicesActions,
+    paymentMethod: paymentMethodActions,
+    subscription: subscriptionActions
+  }];
+};