@tap-payments/auth-jsconnect 2.0.48-test → 2.0.48

package/build/api/individual.js

@@ -1,12 +1,47 @@
+var __rest = (this && this.__rest) || function (s, e) {
+    var t = {};
+    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
+        t[p] = s[p];
+    if (s != null && typeof Object.getOwnPropertySymbols === "function")
+        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
+            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
+                t[p[i]] = s[p[i]];
+        }
+    return t;
+};
 import { ENDPOINT_PATHS } from '../constants';
 import { httpClient } from './axios';
 var retrieveIndividualInfo = function (id) {
     return httpClient({
         method: 'get',
-        url: "".concat(ENDPOINT_PATHS.INDIVIDUAL, "/").concat(id, "/info")
+        url: "".concat(ENDPOINT_PATHS.USER, "/").concat(id, "/info")
+    });
+};
+var retrieveIndividual = function (id, type) {
+    return httpClient({
+        method: 'get',
+        url: "".concat(ENDPOINT_PATHS.INDIVIDUAL, "/").concat(type, "/").concat(id)
+    });
+};
+var updateIndividual = function (_a) {
+    var id = _a.id, type = _a.type, data = __rest(_a, ["id", "type"]);
+    return httpClient({
+        method: 'put',
+        url: "".concat(ENDPOINT_PATHS.INDIVIDUAL, "/").concat(type, "/").concat(id),
+        data: data
+    });
+};
+var getIndividualList = function (data) {
+    return httpClient({
+        method: 'post',
+        url: "".concat(ENDPOINT_PATHS.INDIVIDUAL, "/all"),
+        data: data
     });
 };
 var individualService = {
-    retrieveIndividualInfo: retrieveIndividualInfo
+    retrieveIndividualInfo: retrieveIndividualInfo,
+    retrieveIndividual: retrieveIndividual,
+    updateIndividual: updateIndividual,
+    getIndividualList: getIndividualList
 };
 export { individualService };

package/build/api/lead.d.ts

@@ -42,7 +42,7 @@ export declare type UpdateLeadBody = {
     name?: Name;
     contact?: Contact;
     send_invite?: boolean;
-    business_name?: BusinessName;
+    business?: BusinessName;
     business_type?: string;
     country_code?: string;
     brand?: BrandInfo;
@@ -59,6 +59,10 @@ export declare type UpdateLeadBody = {
     is_acknowledged?: boolean;
     terms_conditions_accepted?: boolean;
     lang?: LanguageMode;
+    segment?: {
+        type: string;
+        team: string;
+    };
 };
 export declare type LeadVerifyBody = {
     verify_token: string;
@@ -75,19 +79,24 @@ export declare type CreateLeadBody = {
 };
 export declare type LeadIdentityUpdateBody = {
     id: string;
-    country_code: string;
-    identification_id: string;
-    identification_id_type: string;
-    date_of_birth: string;
-    step_name: string;
+    identification: {
+        id: string;
+        issued_country_code: string;
+        type: string;
+    };
+    date_of_birth?: string;
+    step_name?: string;
     encryption_contract: Array<string>;
 };
 declare const leadService: {
     createLead: (data: CreateLeadBody, config?: AxiosRequestConfig) => Promise<import("axios").AxiosResponse<any, any>>;
     updateLead: ({ id, ...data }: UpdateLeadBody) => Promise<any>;
     retrieveLead: (leadId: string) => Promise<import("axios").AxiosResponse<any, any>>;
+    getLeadById: (leadId: string) => Promise<any>;
     verifyLeadToken: (data: LeadVerifyBody, config?: AxiosRequestConfig) => Promise<import("axios").AxiosResponse<any, any>>;
     verifyLeadOTP: (data: LeadOTPVerifyBody, config?: AxiosRequestConfig) => Promise<import("axios").AxiosResponse<any, any>>;
     retrieveEntityList: (leadId: string) => Promise<import("axios").AxiosResponse<any, any>>;
+    retrieveLeadIdentity: (leadId: string) => Promise<any>;
+    updateLeadExpress: ({ id, ...data }: UpdateLeadBody) => Promise<any>;
 };
 export { leadService };

package/build/api/lead.js

@@ -22,9 +22,23 @@ var updateLead = function (_a) {
         data: data
     });
 };
+var updateLeadExpress = function (_a) {
+    var id = _a.id, data = __rest(_a, ["id"]);
+    return httpClient({
+        method: 'put',
+        url: "".concat(ENDPOINT_PATHS.EXPRESS_UPDATE_LEAD, "/").concat(id, "/info"),
+        data: data
+    });
+};
 var retrieveLead = function (leadId) {
     return instance.get("".concat(ENDPOINT_PATHS.LEAD, "/").concat(leadId));
 };
+var getLeadById = function (leadId) {
+    return httpClient({
+        method: 'get',
+        url: "".concat(ENDPOINT_PATHS.LEAD, "/").concat(leadId)
+    });
+};
 var verifyLeadToken = function (data, config) {
     return instance.put("".concat(ENDPOINT_PATHS.TOKEN_VERIFY), data, config);
 };
@@ -34,12 +48,21 @@ var verifyLeadOTP = function (data, config) {
 var retrieveEntityList = function (leadId) {
     return instance.get("".concat(ENDPOINT_PATHS.RETRIEVE_ENTITY_LIST, "/").concat(leadId));
 };
+var retrieveLeadIdentity = function (leadId) {
+    return httpClient({
+        method: 'get',
+        url: "".concat(ENDPOINT_PATHS.LEAD, "/").concat(leadId, "/identity")
+    });
+};
 var leadService = {
     createLead: createLead,
     updateLead: updateLead,
     retrieveLead: retrieveLead,
+    getLeadById: getLeadById,
     verifyLeadToken: verifyLeadToken,
     verifyLeadOTP: verifyLeadOTP,
-    retrieveEntityList: retrieveEntityList
+    retrieveEntityList: retrieveEntityList,
+    retrieveLeadIdentity: retrieveLeadIdentity,
+    updateLeadExpress: updateLeadExpress
 };
 export { leadService };

package/build/api/location.d.ts

@@ -0,0 +1,5 @@
+declare const locationService: {
+    getIP: () => Promise<any>;
+    getAddress: (countryCode: string) => Promise<any>;
+};
+export { locationService };

package/build/api/location.js

@@ -0,0 +1,19 @@
+import { ENDPOINT_PATHS } from '../constants';
+import { httpClient } from './axios';
+var getIP = function () {
+    return httpClient({
+        method: 'get',
+        url: ENDPOINT_PATHS.IP
+    });
+};
+var getAddress = function (countryCode) {
+    return httpClient({
+        method: 'get',
+        url: "".concat(ENDPOINT_PATHS.ADDRESS_PATH, "/").concat(countryCode)
+    });
+};
+var locationService = {
+    getIP: getIP,
+    getAddress: getAddress
+};
+export { locationService };

package/build/api/user.d.ts

@@ -2,7 +2,13 @@ export declare type UserCredential = {
     code: string;
     phone: string;
 };
+export declare type GetUserListBody = {
+    page: number;
+    limit: number;
+    business_id: string;
+};
 declare const userService: {
     retrieveUserInfo: (userId: string) => Promise<any>;
+    getUserList: (data: GetUserListBody) => Promise<any>;
 };
 export { userService };

package/build/api/user.js

@@ -6,7 +6,15 @@ var retrieveUserInfo = function (userId) {
         url: "".concat(ENDPOINT_PATHS.RETRIEVE_USER_INFO, "/").concat(userId)
     });
 };
+var getUserList = function (data) {
+    return httpClient({
+        method: 'post',
+        url: "".concat(ENDPOINT_PATHS.RETRIEVE_USER_INFO, "/list"),
+        data: data
+    });
+};
 var userService = {
-    retrieveUserInfo: retrieveUserInfo
+    retrieveUserInfo: retrieveUserInfo,
+    getUserList: getUserList
 };
 export { userService };

package/build/app/rootReducer.d.ts

@@ -8,7 +8,7 @@ declare const rootReducer: {
     password: import("redux").Reducer<import("../features/app/password/passwordStore").PasswordState, import("redux").AnyAction>;
     signIn: import("redux").Reducer<import("../features/app/signIn/signInStore").SignInState, import("redux").AnyAction>;
     entity: import("redux").Reducer<import("../features/app/entity/entityStore").EntityState, import("redux").AnyAction>;
-    otp: import("redux").Reducer<import("../features/app/otp/otpStore").OtpState, import("redux").AnyAction>;
-    auth: import("redux").Reducer<import("../features/app/auth/authStore").AuthState, import("redux").AnyAction>;
+    brand: import("redux").Reducer<import("../features/app/brand/brandStore").BrandState, import("redux").AnyAction>;
+    connectExpress: import("redux").Reducer<import("../features/app/connectExpress/connectExpressStore").ConnectExpressState, import("redux").AnyAction>;
 };
 export default rootReducer;

package/build/app/rootReducer.js

@@ -7,8 +7,8 @@ import individual from '../features/app/individual/individualStore';
 import password from '../features/app/password/passwordStore';
 import signIn from '../features/app/signIn/signInStore';
 import entity from '../features/app/entity/entityStore';
-import otp from '../features/app/otp/otpStore';
-import auth from '../features/app/auth/authStore';
+import brand from '../features/app/brand/brandStore';
+import connectExpress from '../features/app/connectExpress/connectExpressStore';
 var rootReducer = {
     settings: settings,
     connect: connect,
@@ -19,7 +19,7 @@ var rootReducer = {
     password: password,
     signIn: signIn,
     entity: entity,
-    otp: otp,
-    auth: auth
+    brand: brand,
+    connectExpress: connectExpress
 };
 export default rootReducer;

package/build/app/settings.d.ts

@@ -1,11 +1,18 @@
 import { RootState } from './store';
 import { ActionState, LanguageMode, SharedState, ThemeMode, ScreenStepNavigation, DeviceInfo, LibConfig, CountryCode } from '../@types';
+interface SettingParams {
+    disableCountries?: boolean;
+    disableLocale?: boolean;
+    mdn: string;
+    maturity?: 'full' | 'express';
+}
 export declare const fetchAppSettingsSync: import("@reduxjs/toolkit").AsyncThunk<{
     countries: CountryCode[];
     businessCountry: CountryCode;
     locale: any;
     deviceInfo: DeviceInfo;
-}, void, {}>;
+    isValidOperator: boolean;
+}, SettingParams, {}>;
 export interface SettingsData {
     skin: ThemeMode;
     language: LanguageMode;
@@ -17,6 +24,7 @@ export interface SettingsData {
     isTapOrigin: boolean;
     businessCountry: CountryCode;
     countries: Array<CountryCode>;
+    isValidOperator: boolean;
 }
 export interface SettingsState extends SharedState<SettingsData> {
 }
@@ -30,8 +38,9 @@ export declare const settingsSlice: import("@reduxjs/toolkit").Slice<SettingsSta
     handlePrevScreenStep: (state: SettingsState, action: ActionState<string | undefined>) => void;
     handleActiveFlowScreens: (state: SettingsState, action: ActionState<Array<ScreenStepNavigation>>) => void;
     handleSetAppConfig: (state: SettingsState, action: ActionState<LibConfig>) => void;
+    handleSetCountryByIso2: (state: SettingsState, action: ActionState<string>) => void;
 }, "settings">;
-export declare const handleSkin: import("@reduxjs/toolkit").ActionCreatorWithPayload<ThemeMode, string>, handleLanguage: import("@reduxjs/toolkit").ActionCreatorWithPayload<LanguageMode, string>, handleActiveFlowScreens: import("@reduxjs/toolkit").ActionCreatorWithPayload<ScreenStepNavigation[], string>, handleNextScreenStep: import("@reduxjs/toolkit").ActionCreatorWithOptionalPayload<string | undefined, string>, handlePrevScreenStep: import("@reduxjs/toolkit").ActionCreatorWithOptionalPayload<string | undefined, string>, handleCurrentActiveScreen: import("@reduxjs/toolkit").ActionCreatorWithPayload<string, string>, handleSetAppConfig: import("@reduxjs/toolkit").ActionCreatorWithPayload<LibConfig, string>, handleOpen: import("@reduxjs/toolkit").ActionCreatorWithPayload<boolean, string>, handleIsTapOrigin: import("@reduxjs/toolkit").ActionCreatorWithPayload<boolean, string>;
+export declare const handleSkin: import("@reduxjs/toolkit").ActionCreatorWithPayload<ThemeMode, string>, handleLanguage: import("@reduxjs/toolkit").ActionCreatorWithPayload<LanguageMode, string>, handleActiveFlowScreens: import("@reduxjs/toolkit").ActionCreatorWithPayload<ScreenStepNavigation[], string>, handleNextScreenStep: import("@reduxjs/toolkit").ActionCreatorWithOptionalPayload<string | undefined, string>, handlePrevScreenStep: import("@reduxjs/toolkit").ActionCreatorWithOptionalPayload<string | undefined, string>, handleCurrentActiveScreen: import("@reduxjs/toolkit").ActionCreatorWithPayload<string, string>, handleSetAppConfig: import("@reduxjs/toolkit").ActionCreatorWithPayload<LibConfig, string>, handleOpen: import("@reduxjs/toolkit").ActionCreatorWithPayload<boolean, string>, handleSetCountryByIso2: import("@reduxjs/toolkit").ActionCreatorWithPayload<string, string>, handleIsTapOrigin: import("@reduxjs/toolkit").ActionCreatorWithPayload<boolean, string>;
 declare const _default: import("redux").Reducer<SettingsState, import("redux").AnyAction>;
 export default _default;
 export declare const settingsSelector: (state: RootState) => SettingsState;

package/build/app/settings.js

@@ -47,24 +47,25 @@ var __generator = (this && this.__generator) || function (thisArg, body) {
 };
 var _a;
 import { createAsyncThunk, createSlice } from '@reduxjs/toolkit';
-import { getStoredData, storeData, isArray, findItem, getBrowserInfo, getFingerPrint, sortCountries, findCountryByIso2, getRequestHeaders, encryptString, removeElement } from '../utils';
-import { defaultCountry, DefaultDeviceInfo, LOCAL_STORAGE_KEYS, DIALOG_ID, BACKGROUND_ID } from '../constants';
+import { getStoredData, storeData, isArray, findItem, getBrowserInfo, getFingerPrint, sortCountries, findCountryByIso2, getRequestHeaders, encryptString, dangerousMessage } from '../utils';
+import { DefaultDeviceInfo, LOCAL_STORAGE_KEYS } from '../constants';
 import i18n from '../i18n';
 import { updateLocale } from '../utils/locale';
 import API, { setAxiosGlobalHeaders } from '../api';
-export var fetchAppSettingsSync = createAsyncThunk('fetchAppSettingsSync', function (_, thunkApi) { return __awaiter(void 0, void 0, void 0, function () {
-    var settings, _a, appConfig, language, _b, client, device, os, _c, visitorId, _d, ip, latitude, longitude, locale, list, operatorData, deviceInfo, countries, businessCountry;
+export var fetchAppSettingsSync = createAsyncThunk('fetchAppSettingsSync', function (params, thunkApi) { return __awaiter(void 0, void 0, void 0, function () {
+    var settings, _a, appConfig, language, _b, client, device, os, disableCountries, disableLocale, maturity, _c, visitorId, _d, ip, latitude, longitude, locale, list, operatorData, deviceInfo, operatorStatus, isValidOperator, countries, businessCountry;
     return __generator(this, function (_e) {
         switch (_e.label) {
             case 0:
                 settings = thunkApi.getState().settings;
                 _a = settings.data, appConfig = _a.appConfig, language = _a.language;
                 _b = getBrowserInfo(), client = _b.client, device = _b.device, os = _b.os;
+                disableCountries = params.disableCountries, disableLocale = params.disableLocale, maturity = params.maturity;
                 return [4, Promise.all([
                         getFingerPrint(),
-                        API.ipService.getIP(),
-                        API.firebaseService.getLocale(),
-                        API.countryService.getCountries()
+                        API.locationService.getIP(),
+                        API.firebaseService.getLocale(disableLocale),
+                        API.countryService.getCountries(disableCountries)
                     ])];
             case 1:
                 _c = _e.sent(), visitorId = _c[0].visitorId, _d = _c[1], ip = _d.ip, latitude = _d.latitude, longitude = _d.longitude, locale = _c[2], list = _c[3].list;
@@ -106,13 +107,16 @@ export var fetchAppSettingsSync = createAsyncThunk('fetchAppSettingsSync', funct
                     },
                     source: 'browser'
                 };
-                setAxiosGlobalHeaders(__assign(__assign({}, getRequestHeaders(deviceInfo)), { authorization: encryptString(appConfig.publicKey), mdn: encryptString(window.location.origin) }));
+                setAxiosGlobalHeaders(__assign(__assign(__assign({}, getRequestHeaders(deviceInfo)), { authorization: encryptString(appConfig.publicKey), mdn: encryptString(params.mdn || window.location.origin), cu: window.location.href }), (maturity && { maturity: maturity })));
                 return [4, API.operatorService.validateOperator(operatorData)];
             case 2:
-                _e.sent();
+                operatorStatus = _e.sent();
+                isValidOperator = operatorStatus === 'valid';
                 countries = sortCountries(list);
-                businessCountry = findCountryByIso2(countries, appConfig.businessCountryCode) || defaultCountry;
-                return [2, { countries: countries, businessCountry: businessCountry, locale: locale, deviceInfo: deviceInfo }];
+                businessCountry = findCountryByIso2(countries, appConfig.businessCountryCode);
+                if (!businessCountry)
+                    throw new Error('Business country not found, you have to pass a valid business country code in the lib config');
+                return [2, { countries: countries, businessCountry: businessCountry, locale: locale, deviceInfo: deviceInfo, isValidOperator: isValidOperator }];
         }
     });
 }); });
@@ -128,8 +132,9 @@ var initialState = {
         activeScreen: {},
         deviceInfo: DefaultDeviceInfo,
         appConfig: {},
-        businessCountry: defaultCountry,
-        countries: []
+        businessCountry: {},
+        countries: [],
+        isValidOperator: false
     }
 };
 export var settingsSlice = createSlice({
@@ -140,61 +145,63 @@ export var settingsSlice = createSlice({
             state.data.isTapOrigin = action.payload;
         },
         handleOpen: function (state, action) {
+            var _a, _b;
             state.data.open = action.payload;
-            if (action.payload === false) {
-                setTimeout(function () {
-                    removeElement(DIALOG_ID);
-                    removeElement(BACKGROUND_ID);
-                }, 1000);
-            }
+            if (action.payload === false)
+                (_b = (_a = state.data.appConfig).onClose) === null || _b === void 0 ? void 0 : _b.call(_a);
         },
         handleSkin: function (state, action) {
             state.data.skin = action.payload;
             storeData(LOCAL_STORAGE_KEYS.themeMode, action.payload);
         },
         handleLanguage: function (state, action) {
+            if (!action.payload)
+                return;
             state.data.language = action.payload;
             i18n.changeLanguage(action.payload);
             storeData(LOCAL_STORAGE_KEYS.languageMode, action.payload);
         },
         handleNextScreenStep: function (state, action) {
             var next = state.data.activeScreen.next;
+            var appConfig = state.data.appConfig;
             if (isArray(next)) {
                 if (!action.payload)
-                    return alert('next screen is an array, but no payload was provided');
+                    return dangerousMessage('next screen is an array, but no payload was provided', appConfig.onError);
                 var nextName_1 = findItem(next, action.payload);
                 var nextScreen_1 = state.data.featureScreensNavigation.find(function (item) { return item.name === nextName_1; });
                 if (!nextScreen_1)
-                    return alert('Next screen step not found');
+                    return dangerousMessage('Next screen step not found', appConfig.onError);
                 state.data.activeScreen = nextScreen_1;
                 return;
             }
             var nextScreen = state.data.featureScreensNavigation.find(function (item) { return item.name === next; });
             if (!nextScreen)
-                return alert('Next screen step not found');
+                return dangerousMessage('Next screen step not found', appConfig.onError);
             state.data.activeScreen = nextScreen;
         },
         handleCurrentActiveScreen: function (state, action) {
+            var appConfig = state.data.appConfig;
             var activeScreen = state.data.featureScreensNavigation.find(function (item) { return item.name === action.payload; });
             if (!activeScreen)
-                return alert('Active screen not found');
+                return dangerousMessage('Active screen not found', appConfig.onError);
             state.data.activeScreen = activeScreen;
         },
         handlePrevScreenStep: function (state, action) {
+            var appConfig = state.data.appConfig;
             var prev = state.data.activeScreen.prev;
             if (isArray(prev)) {
                 if (!action.payload)
-                    return alert('Previous screen is an array, but no payload was provided');
+                    return dangerousMessage('Previous screen is an array, but no payload was provided', appConfig.onError);
                 var prevName_1 = findItem(prev, action.payload);
                 var prevScreen_1 = state.data.featureScreensNavigation.find(function (item) { return item.name === prevName_1; });
                 if (!prevScreen_1)
-                    return alert('Previous screen step not found');
+                    return dangerousMessage('Previous screen step not found', appConfig.onError);
                 state.data.activeScreen = prevScreen_1;
                 return;
             }
             var prevScreen = state.data.featureScreensNavigation.find(function (item) { return item.name === prev; });
             if (!prevScreen)
-                return alert('Previous screen step not found');
+                return dangerousMessage('Previous screen step not found', appConfig.onError);
             state.data.activeScreen = prevScreen;
         },
         handleActiveFlowScreens: function (state, action) {
@@ -202,7 +209,7 @@ export var settingsSlice = createSlice({
             state.data.activeScreen = action.payload[0];
         },
         handleSetAppConfig: function (state, action) {
-            var _a = action.payload, appInfo = _a.appInfo, businessCountryCode = _a.businessCountryCode, language = _a.language, onError = _a.onError, onFlowCompleted = _a.onFlowCompleted, publicKey = _a.publicKey, merchantDomain = _a.merchantDomain, open = _a.open;
+            var _a = action.payload, appInfo = _a.appInfo, businessCountryCode = _a.businessCountryCode, language = _a.language, onError = _a.onError, onFlowCompleted = _a.onFlowCompleted, publicKey = _a.publicKey, merchantDomain = _a.merchantDomain, open = _a.open, scope = _a.scope;
             if (!appInfo.name)
                 throw new Error('App name is required');
             if (!businessCountryCode)
@@ -211,15 +218,22 @@ export var settingsSlice = createSlice({
                 throw new Error('Language is required');
             if (!publicKey)
                 throw new Error('Public key is required');
-            if (!onError)
+            if (typeof onError !== 'function')
                 throw new Error('On error function is required');
-            if (!onFlowCompleted)
+            if (typeof onFlowCompleted !== 'function')
                 throw new Error('On flow completed function is required');
             if (!merchantDomain)
                 throw new Error('Merchant domain is required');
             if (typeof open !== 'boolean')
                 throw new Error('Open is required');
+            if (!scope)
+                throw new Error('Scope is required');
             state.data.appConfig = action.payload;
+        },
+        handleSetCountryByIso2: function (state, action) {
+            var country = findCountryByIso2(state.data.countries, action.payload);
+            if (country)
+                state.data.businessCountry = country;
         }
     },
     extraReducers: function (builder) {
@@ -228,12 +242,16 @@ export var settingsSlice = createSlice({
             state.error = null;
         });
         builder.addCase(fetchAppSettingsSync.fulfilled, function (state, action) {
-            var _a = action.payload, businessCountry = _a.businessCountry, countries = _a.countries, locale = _a.locale, deviceInfo = _a.deviceInfo;
+            var _a = action.payload, businessCountry = _a.businessCountry, countries = _a.countries, locale = _a.locale, deviceInfo = _a.deviceInfo, isValidOperator = _a.isValidOperator;
             state.data.countries = countries;
             state.data.businessCountry = businessCountry;
             state.data.deviceInfo = deviceInfo;
-            updateLocale(locale, businessCountry.iso2);
+            state.data.isValidOperator = isValidOperator;
+            if (locale)
+                updateLocale(locale, businessCountry.iso2);
             state.loading = false;
+            if (state.data.appConfig.onReady)
+                state.data.appConfig.onReady();
         });
         builder.addCase(fetchAppSettingsSync.rejected, function (state, action) {
             state.loading = false;
@@ -241,6 +259,6 @@ export var settingsSlice = createSlice({
         });
     }
 });
-export var handleSkin = (_a = settingsSlice.actions, _a.handleSkin), handleLanguage = _a.handleLanguage, handleActiveFlowScreens = _a.handleActiveFlowScreens, handleNextScreenStep = _a.handleNextScreenStep, handlePrevScreenStep = _a.handlePrevScreenStep, handleCurrentActiveScreen = _a.handleCurrentActiveScreen, handleSetAppConfig = _a.handleSetAppConfig, handleOpen = _a.handleOpen, handleIsTapOrigin = _a.handleIsTapOrigin;
+export var handleSkin = (_a = settingsSlice.actions, _a.handleSkin), handleLanguage = _a.handleLanguage, handleActiveFlowScreens = _a.handleActiveFlowScreens, handleNextScreenStep = _a.handleNextScreenStep, handlePrevScreenStep = _a.handlePrevScreenStep, handleCurrentActiveScreen = _a.handleCurrentActiveScreen, handleSetAppConfig = _a.handleSetAppConfig, handleOpen = _a.handleOpen, handleSetCountryByIso2 = _a.handleSetCountryByIso2, handleIsTapOrigin = _a.handleIsTapOrigin;
 export default settingsSlice.reducer;
 export var settingsSelector = function (state) { return state.settings; };

package/build/app/store.d.ts

@@ -9,9 +9,9 @@ export declare const store: import("@reduxjs/toolkit").EnhancedStore<{
     password: import("../features/app/password/passwordStore").PasswordState;
     signIn: import("../features/app/signIn/signInStore").SignInState;
     entity: import("../features/app/entity/entityStore").EntityState;
-    otp: import("../features/app/otp/otpStore").OtpState;
-    auth: import("../features/app/auth/authStore").AuthState;
-}, import("redux").AnyAction, import("@reduxjs/toolkit").MiddlewareArray<[import("redux-thunk").ThunkMiddleware<{
+    brand: import("../features/app/brand/brandStore").BrandState;
+    connectExpress: import("../features/app/connectExpress/connectExpressStore").ConnectExpressState;
+}, import("redux").AnyAction, import("@reduxjs/toolkit").MiddlewareArray<[import("@reduxjs/toolkit").ThunkMiddleware<{
     settings: import("./settings").SettingsState;
     connect: import("../features/app/connect/connectStore").ConnectState;
     business: import("../features/app/business/businessStore").BusinessState;
@@ -21,8 +21,8 @@ export declare const store: import("@reduxjs/toolkit").EnhancedStore<{
     password: import("../features/app/password/passwordStore").PasswordState;
     signIn: import("../features/app/signIn/signInStore").SignInState;
     entity: import("../features/app/entity/entityStore").EntityState;
-    otp: import("../features/app/otp/otpStore").OtpState;
-    auth: import("../features/app/auth/authStore").AuthState;
+    brand: import("../features/app/brand/brandStore").BrandState;
+    connectExpress: import("../features/app/connectExpress/connectExpressStore").ConnectExpressState;
 }, import("redux").AnyAction, undefined>]>>;
 export declare type AppDispatch = typeof store.dispatch;
 export declare type RootState = ReturnType<typeof store.getState>;