ouisys-engine 5.0.3 → 5.0.4

package/dist/types/click2smsFlow.d.ts

@@ -0,0 +1,37 @@
+import { U as LOAD_OC2SMSState, V as Click2smsFlowState, j as IHash, W as IWithMultiKeywordShortcode, X as Click2smsFlowCurrentState } from './StrategyTypes-CbOgk0N4.js';
+export { a4 as ICheckSubscriptionResult, a1 as IClick2smsConfig, a5 as IFetchResult, a0 as IKeywordShortcode, Z as ILOADOC2SMSFailure, _ as ILOADOC2SMSSuccess, $ as ILoadOc2click2smsPayload, Y as MSISDNEntryErrorTypes, a3 as MultiOperatorSubmissionResult, a2 as SingleSubmissionResult } from './StrategyTypes-CbOgk0N4.js';
+import * as redux from 'redux';
+import * as _reduxjs_toolkit from '@reduxjs/toolkit';
+import * as _reduxjs_toolkit_dist_createAsyncThunk from '@reduxjs/toolkit/dist/createAsyncThunk';
+import { useSelector } from 'react-redux';
+import { R as RemoteDataState } from './RemoteDataState-D1aFrz8W.js';
+import './CreditCardTypes-B-IT-l6I.js';
+import './MoRedirTypes-4tEJjT1g.js';
+import './MoTypes-D-UK92gs.js';
+import './OneClickTypes-DjOesaHp.js';
+import './PinTypes-BLJDBZe6.js';
+import './UssdTypes-C7QlIW11.js';
+
+interface LOAD_OC2SMSArgs {
+    window: Window;
+    extraParams?: IHash;
+}
+/**
+ * loadOc2smsAction
+ * @returns {type: '  'pinFlow/submitMSISDNAction', payload: {type: PossibleTypes, result: MSISDNEntryState}}
+ 
+ * Calls oc2sms api that returns a keyword and short code
+ *
+ */
+declare const loadOc2smsAction: _reduxjs_toolkit.AsyncThunk<LOAD_OC2SMSState, LOAD_OC2SMSArgs, _reduxjs_toolkit_dist_createAsyncThunk.AsyncThunkConfig>;
+declare const click2smsFlowReducer: redux.Reducer<Click2smsFlowState, redux.UnknownAction, Click2smsFlowState>;
+
+declare const useClick2smsFlowState: (useSelector: typeof useSelector) => LOAD_OC2SMSState;
+
+declare const useKeyWordShortCode: (useSelector: typeof useSelector) => IWithMultiKeywordShortcode;
+
+declare function click2smsFlowMatch<R>({ load }: {
+    load: (rds: RemoteDataState<string, IWithMultiKeywordShortcode>) => R;
+}): (state: Click2smsFlowCurrentState) => R;
+
+export { Click2smsFlowCurrentState, Click2smsFlowState, IWithMultiKeywordShortcode, LOAD_OC2SMSState, click2smsFlowMatch, click2smsFlowReducer, loadOc2smsAction, useClick2smsFlowState, useKeyWordShortCode };

package/dist/types/creditCardFlow.d.ts

@@ -0,0 +1,37 @@
+import { U as USERDETAILSEntryState, S as SubmitUserDetailsFailure, C as CreditCardFlowState, I as IUserDetails, a as IUserDetailsEcardon, b as SubmitUserDetailsSuccess, c as CreditCardFlowCurrentState } from './CreditCardTypes-B-IT-l6I.js';
+export { d as IEmailPasswordSubmissionResult, g as IMockCreditCardFlowStates, f as IUserDetailsSubmissionResult, e as SubmitUserDetailsErrorTypes } from './CreditCardTypes-B-IT-l6I.js';
+import * as _reduxjs_toolkit from '@reduxjs/toolkit';
+import * as redux from 'redux';
+import { useSelector } from 'react-redux';
+import { R as RemoteDataState } from './RemoteDataState-D1aFrz8W.js';
+
+interface SubmitUserDetailsArgs {
+    window: Window;
+    userDetails: IUserDetails | IUserDetailsEcardon;
+}
+/**
+ * submitUserDetailsAction
+ * @returns {type: '  'pinFlow/submitUserDetailsAction', payload: {type: PossibleTypes, result: USERDETAILSEntryState}}
+ 
+ * Calls redirect or max api and returns a url
+ *
+ */
+declare const submitUserDetailsAction: _reduxjs_toolkit.AsyncThunk<USERDETAILSEntryState, SubmitUserDetailsArgs, {
+    rejectValue: SubmitUserDetailsFailure;
+    state?: unknown;
+    dispatch?: redux.Dispatch<redux.UnknownAction>;
+    extra?: unknown;
+    serializedErrorType?: unknown;
+    pendingMeta?: unknown;
+    fulfilledMeta?: unknown;
+    rejectedMeta?: unknown;
+}>;
+declare const creditCardFlowReducer: redux.Reducer<CreditCardFlowState, redux.UnknownAction, CreditCardFlowState>;
+
+declare const useCreditCardFlowState: (useSelector: typeof useSelector) => USERDETAILSEntryState;
+
+declare function creditCardFlowMatch<R>({ userDetailsEntry }: {
+    userDetailsEntry: (rds: RemoteDataState<SubmitUserDetailsFailure, SubmitUserDetailsSuccess>) => R;
+}): (state: CreditCardFlowCurrentState) => R;
+
+export { CreditCardFlowCurrentState, CreditCardFlowState, IUserDetails, IUserDetailsEcardon, SubmitUserDetailsFailure, SubmitUserDetailsSuccess, USERDETAILSEntryState, creditCardFlowMatch, creditCardFlowReducer, submitUserDetailsAction, useCreditCardFlowState };

package/dist/types/getConfig.d.ts

@@ -0,0 +1,38 @@
+declare type ConfigDetails = {
+    host: string;
+    slug: string;
+    country: string;
+    device?: 'smart' | 'feature';
+    queryString?: Array<[string, string]>;
+    automaticallySubmitAllOperators?: boolean;
+    operators?: string[];
+    service: string;
+    offer?: string;
+};
+declare type ISupportedFlows = 'pin' | 'mo' | 'oneClick' | 'click2sms' | 'moRedir' | 'ussd' | 'tpayHe' | 'creditCard';
+declare type IFlow = {
+    flow: ISupportedFlows;
+    flowOnWifi?: ISupportedFlows;
+    operator?: string;
+    flowConfig: ConfigDetails;
+    default?: IFlow;
+    rockman_id?: string;
+};
+declare type StrategyConfig = {
+    operators: {
+        [key: string]: IFlow;
+    };
+    default: IFlow;
+    isUseMsisdnPrefix?: boolean;
+};
+declare type IStrategy = {
+    strategy: IStrategyNames;
+    country: string;
+    strategyConfigs: StrategyConfig;
+};
+declare type IStrategyNames = 'pin' | 'mo' | 'mo-redir' | 'click2sms' | 'one-click' | 'ussd' | 'tpay-he' | 'credit-card' | 'tallyman-one-click' | 'pin-mo-ask-operator' | 'pin-mo-ask-mobile-number' | 'pin-one-click-ask-operator' | 'pin-one-click-detect-operator-by-ip' | 'one-click-mo-pin-detect-operator-by-ip-or-msisdn' | 'pin-click2sms-ask-operator' | 'mo-redir-one-click-detect-operator-by-ip' | 'pin-mo-redir-ask-mobile-number' | 'pin-click2sms-ask-mobile-number' | 'mo-one-click-detect-operator-by-ip' | 'click2sms-one-click-detect-operator-by-ip' | 'pin-header-enrichment' | 'pin-msisdn-fowarding-pin-header-enrichment' | 'he-pin-mo-redir-header-enrichment' | 'he-pin-one-click-header-enrichment' | 'he-pin-one-click-ask-operator' | 'click2sms-one-click-ask-operator' | 'pin-mo-detect-operator-by-ip' | 'he-mo-redir-one-click-header-enrichment' | 'pin-combo-ask-mobile-number' | 'header-enrichment-script' | 'mo-redir-mo-click2sms-one-click-detect-operator-by-ip-or-msisdn' | 'pin-mo-mo-redir-ask-mobile-number';
+
+declare function setConfig(userConfig: IStrategy): void;
+declare function getConfig(): IStrategy;
+
+export { getConfig, setConfig };

package/dist/types/handleClickChainFlow.d.ts

@@ -0,0 +1,6 @@
+declare const handleClickChainFlow: ({ window, trackState }: {
+    window: Window;
+    trackState: string;
+}) => void;
+
+export { handleClickChainFlow };

package/dist/types/handleSubmitNumber.d.ts

@@ -0,0 +1,26 @@
+import { Dispatch } from '@reduxjs/toolkit';
+
+declare const handleAutoSubmitMsisdn: ({ msisdnValue, dispatch, submitMSISDNAction, isHeaderEnrichmentSuccess, isHeaderEnrichmentAutoSubmit }: {
+    window: Window;
+    msisdnValue: string;
+    dispatch: Dispatch;
+    submitMSISDNAction: ({ window, msisdn }: {
+        window: Window;
+        msisdn: string;
+    }) => any;
+    isHeaderEnrichmentSuccess: boolean;
+    isHeaderEnrichmentAutoSubmit?: boolean;
+}) => void;
+declare const handleFormSubmit: ({ window, isHeaderEnrichmentSuccess, onEnd, internationalNumber, isValid }: {
+    window: Window;
+    isHeaderEnrichmentSuccess: boolean;
+    country: string;
+    setInternationalNumber: React.Dispatch<React.SetStateAction<string>>;
+    onEnd: (msisdn: string, extraParams?: {
+        [key: string]: string;
+    }) => void;
+    internationalNumber: string;
+    isValid: boolean;
+}) => void;
+
+export { handleAutoSubmitMsisdn, handleFormSubmit };

package/dist/types/moFlow.d.ts

@@ -0,0 +1,70 @@
+import { M as MSISDNEntryState, a as MSISDNEntryFailure, b as MSISDNEntrySuccess, c as MoFlowCurrentState } from './MoTypes-D-UK92gs.js';
+export { h as IGoogleReCaptcha, I as IKeywordShortcode, f as IMSISDNSubmissionResult, g as IMockMoFlowStates, e as MSISDNEntryErrorTypes, d as MoFlowState } from './MoTypes-D-UK92gs.js';
+import { useSelector } from 'react-redux';
+import { R as RemoteDataState } from './RemoteDataState-D1aFrz8W.js';
+import * as _reduxjs_toolkit from '@reduxjs/toolkit';
+import * as redux from 'redux';
+import { I as IHash } from './IHash-0OgZ_1ij.js';
+
+declare const useMoFlowState: (useSelector: typeof useSelector) => MSISDNEntryState;
+
+declare function moFlowMatch<R>({ msisdnEntry }: {
+    msisdnEntry: (rds: RemoteDataState<MSISDNEntryFailure, MSISDNEntrySuccess>) => R;
+}): (state: MoFlowCurrentState) => R;
+
+interface SubmitMSISDNArgs {
+    window: Window;
+    msisdn: string;
+    extraParams?: IHash;
+}
+/**
+ * submitMSISDNAction
+ * @returns {type: '  'pinFlow/submitMSISDNAction', payload: {type: PossibleTypes, result: MSISDNEntryState}}
+ 
+ * Calls trigger-message api that returns a short code and key word
+ * Sets completed stated
+ */
+declare const submitMSISDNAction: _reduxjs_toolkit.AsyncThunk<MSISDNEntryState, SubmitMSISDNArgs, {
+    rejectValue: MSISDNEntryFailure;
+    state?: unknown;
+    dispatch?: redux.Dispatch<redux.UnknownAction>;
+    extra?: unknown;
+    serializedErrorType?: unknown;
+    pendingMeta?: unknown;
+    fulfilledMeta?: unknown;
+    rejectedMeta?: unknown;
+}>;
+declare const moFlowReducer: redux.Reducer<{
+    currentState: {
+        type: 'MSISDNEntry';
+        result: {
+            type: "NothingYet";
+        } | {
+            type: "Loading";
+        } | {
+            type: "Failure";
+            error: any;
+        } | {
+            type: "Success";
+            data: any;
+        };
+    };
+}, redux.UnknownAction, {
+    currentState: {
+        type: 'MSISDNEntry';
+        result: {
+            type: "NothingYet";
+        } | {
+            type: "Loading";
+        } | {
+            type: "Failure";
+            error: any;
+        } | {
+            type: "Success";
+            data: any;
+        };
+    };
+}>;
+declare const backToStartAction: _reduxjs_toolkit.ActionCreatorWithoutPayload<"moFlow/backToStartAction">;
+
+export { MSISDNEntryFailure, MSISDNEntryState, MSISDNEntrySuccess, MoFlowCurrentState, backToStartAction, moFlowMatch, moFlowReducer, submitMSISDNAction, useMoFlowState };

package/dist/types/moRedirFlow.d.ts

@@ -0,0 +1,82 @@
+import { M as MSISDNEntryState, a as MSISDNEntryFailure, b as MSISDNEntrySuccess, c as MoRedirFlowCurrentState, d as MSISDNEntryErrorTypes } from './MoRedirTypes-4tEJjT1g.js';
+export { I as IMSISDNSubmissionResult, f as IMockMoRedirFlowStates, e as MoRedirFlowState } from './MoRedirTypes-4tEJjT1g.js';
+import { useSelector } from 'react-redux';
+import { R as RemoteDataState } from './RemoteDataState-D1aFrz8W.js';
+import * as _reduxjs_toolkit from '@reduxjs/toolkit';
+import * as redux from 'redux';
+import { I as IHash } from './IHash-0OgZ_1ij.js';
+
+declare const useMoRedirFlowState: (useSelector: typeof useSelector) => MSISDNEntryState;
+
+declare function moRedirFlowMatch<R>({ msisdnEntry }: {
+    msisdnEntry: (rds: RemoteDataState<MSISDNEntryFailure, MSISDNEntrySuccess>) => R;
+}): (state: MoRedirFlowCurrentState) => R;
+
+interface SubmitMSISDNArgs {
+    window: Window;
+    msisdn: string;
+    extraParams?: IHash;
+}
+/**
+ * submitMSISDNAction
+ * @returns {type: '  'pinFlow/submitMSISDNAction', payload: {type: PossibleTypes, result: MSISDNEntryState}}
+ 
+ * Calls redirec api that returns a redirect url
+ * Sets completed stated
+ */
+declare const submitMSISDNAction: _reduxjs_toolkit.AsyncThunk<MSISDNEntryState, SubmitMSISDNArgs, {
+    rejectValue: MSISDNEntryFailure;
+    state?: unknown;
+    dispatch?: redux.Dispatch<redux.UnknownAction>;
+    extra?: unknown;
+    serializedErrorType?: unknown;
+    pendingMeta?: unknown;
+    fulfilledMeta?: unknown;
+    rejectedMeta?: unknown;
+}>;
+declare const moRedirFlowReducer: redux.Reducer<{
+    currentState: {
+        type: "MSISDNEntry";
+        result: {
+            type: "NothingYet";
+        } | {
+            type: "Loading";
+        } | {
+            type: "Failure";
+            error: {
+                errorType: MSISDNEntryErrorTypes;
+                error?: any;
+                productUrl?: string;
+            };
+        } | {
+            type: "Success";
+            data: {
+                href: string;
+            };
+        };
+    };
+}, redux.UnknownAction, {
+    currentState: {
+        type: "MSISDNEntry";
+        result: {
+            type: "NothingYet";
+        } | {
+            type: "Loading";
+        } | {
+            type: "Failure";
+            error: {
+                errorType: MSISDNEntryErrorTypes;
+                error?: any;
+                productUrl?: string;
+            };
+        } | {
+            type: "Success";
+            data: {
+                href: string;
+            };
+        };
+    };
+}>;
+declare const backToStartAction: _reduxjs_toolkit.ActionCreatorWithoutPayload<"moRedirFlow/backToStartAction">;
+
+export { MSISDNEntryErrorTypes, MSISDNEntryFailure, MSISDNEntryState, MSISDNEntrySuccess, MoRedirFlowCurrentState, backToStartAction, moRedirFlowMatch, moRedirFlowReducer, submitMSISDNAction, useMoRedirFlowState };

package/dist/types/oneClickFlow.d.ts

@@ -0,0 +1,56 @@
+import { a as OneClickFlowCurrentState, I as IGETREDIRECTURLFailure, b as IGETREDIRECTURLSuccess, S as SubscribeFailure, c as SubscribeSuccess, G as GETREDIRECTUrlState, A as AJAXSUBSCRIBEState, O as OneClickFlowState } from './OneClickTypes-DjOesaHp.js';
+export { g as IHEResult, f as IIDentifyUserResult, e as ILinkExtraParams, i as IMockOneClickFlowStates, h as ISubscribeResult, d as SubscribeUserErrorTypes } from './OneClickTypes-DjOesaHp.js';
+import { useSelector } from 'react-redux';
+import { R as RemoteDataState } from './RemoteDataState-D1aFrz8W.js';
+import * as redux from 'redux';
+import * as _reduxjs_toolkit from '@reduxjs/toolkit';
+import * as _reduxjs_toolkit_dist_createAsyncThunk from '@reduxjs/toolkit/dist/createAsyncThunk';
+import { I as IHash } from './IHash-0OgZ_1ij.js';
+
+declare const useOneClickFlowState: (useSelector: typeof useSelector) => OneClickFlowCurrentState;
+
+declare function oneClickFlowMatch<R>({ getRedirectUrl, subscribe }: {
+    getRedirectUrl: (rds: RemoteDataState<IGETREDIRECTURLFailure, IGETREDIRECTURLSuccess>) => R;
+    subscribe?: (rds: RemoteDataState<SubscribeFailure, SubscribeSuccess>) => R;
+}): (state: OneClickFlowCurrentState) => R;
+
+interface GetRedirectUrlArgs {
+    window: Window;
+    extraParams?: IHash;
+    autoRedirect?: boolean;
+    isGetRedirectBupperWay?: boolean;
+    ignoreUrlParams?: boolean;
+}
+/**
+ * getRedirectUrlAction
+ * @returns {type: '  'oneClickFlow/getRedirectUrlAction', payload: {type: PossibleTypes, result: GETREDIRECTUrlState}}
+ 
+ * Calls redirect api to get a redirect url for the user to be redirected to
+ * Can also create a bupper redirect url
+ */
+declare const getRedirectUrlAction: _reduxjs_toolkit.AsyncThunk<GETREDIRECTUrlState, GetRedirectUrlArgs, _reduxjs_toolkit_dist_createAsyncThunk.AsyncThunkConfig>;
+/**
+ * subscribeUrlAction
+ * @returns {type: '  'oneClickFlow/submitMSISDNAction', payload: {type: PossibleTypes.MO, result: PINEntryState}}
+ 
+ * Calls oneclick subscripe api to subscribe the user
+ * Returns a product url
+ */
+interface OneClickSubscribeArgs {
+    window: Window;
+    autoRedirect?: boolean;
+    extraParams?: IHash;
+}
+declare const subscribeUrlAction: _reduxjs_toolkit.AsyncThunk<AJAXSUBSCRIBEState, OneClickSubscribeArgs, {
+    rejectValue: SubscribeFailure;
+    state?: unknown;
+    dispatch?: redux.Dispatch<redux.UnknownAction>;
+    extra?: unknown;
+    serializedErrorType?: unknown;
+    pendingMeta?: unknown;
+    fulfilledMeta?: unknown;
+    rejectedMeta?: unknown;
+}>;
+declare const oneClickFlowReducer: redux.Reducer<OneClickFlowState, redux.UnknownAction, OneClickFlowState>;
+
+export { AJAXSUBSCRIBEState, GETREDIRECTUrlState, IGETREDIRECTURLFailure, IGETREDIRECTURLSuccess, OneClickFlowCurrentState, OneClickFlowState, SubscribeFailure, SubscribeSuccess, getRedirectUrlAction, oneClickFlowMatch, oneClickFlowReducer, subscribeUrlAction, useOneClickFlowState };

package/dist/types/pinFlow.d.ts

@@ -0,0 +1,179 @@
+import { P as PinFlowCurrentState, M as MSISDNEntryFailure, a as MSISDNEntrySuccess, b as PINEntryFailure, c as PINEntrySuccess, I as IMsisdnSumbitNextData, d as PINEntryState, e as PINEntryErrorTypes, f as IHash } from './PinTypes-BLJDBZe6.js';
+export { E as ExtraData, n as IBackToStartPayload, o as IConfig, p as IMSISDNSubmissionResult, s as IMcpShieldResult, t as IMockPinFlowStates, k as IMsisdnSubmitErrorPayload, j as IMsisnSubmitActionPayload, q as IPINSubmissionResult, m as IPinErrorPayload, l as IPinSubmitPayload, i as MSISDNEntryErrorTypes, g as MSISDNEntryState, r as MultiOperatorMSISDNSubmissionResult, h as PinFlowState, S as SingleMSISDNSubmissionResult } from './PinTypes-BLJDBZe6.js';
+import { useSelector } from 'react-redux';
+import { R as RemoteDataState } from './RemoteDataState-D1aFrz8W.js';
+import * as _reduxjs_toolkit from '@reduxjs/toolkit';
+import * as redux from 'redux';
+
+declare const usePinFlowState: (useSelector: typeof useSelector) => PinFlowCurrentState;
+
+declare function pinFlowMatch<R>({ msisdnEntry, pinEntry }: {
+    msisdnEntry: (rds: RemoteDataState<MSISDNEntryFailure, MSISDNEntrySuccess>) => R;
+    pinEntry: (rds: RemoteDataState<PINEntryFailure, PINEntrySuccess>, nextData: IMsisdnSumbitNextData) => R;
+}): (state: PinFlowCurrentState) => R;
+
+/**
+ * submitMSISDNAction
+ * @returns {type: '  'pinFlow/submitMSISDNAction', payload: {type: PossibleTypes.MO, result: PINEntryState}}
+ 
+ * Calls trigger-pin api that sends a pin to the user
+ * Sets state to show pin entry
+ */
+interface SubmitMSISDNArgs {
+    window: Window;
+    msisdn: string;
+    extraParams?: IHash;
+}
+declare const submitMSISDNAction: _reduxjs_toolkit.AsyncThunk<PINEntryState, SubmitMSISDNArgs, {
+    rejectValue: MSISDNEntryFailure;
+    state?: unknown;
+    dispatch?: redux.Dispatch<redux.UnknownAction>;
+    extra?: unknown;
+    serializedErrorType?: unknown;
+    pendingMeta?: unknown;
+    fulfilledMeta?: unknown;
+    rejectedMeta?: unknown;
+}>;
+/**
+ * submitPinAction
+ * @returns {type: '  'pinFlow/submitMSISDNAction', payload: {type: 'PINEntry', result: RDS.NothingYet()}}
+ 
+ * Calls verify-pin api that check if the user enters a valid pin
+ * Sets state to show thank you page if pin is valid
+ */
+interface SubmitPINArgs {
+    window: Window;
+    msisdn: string;
+    pin: string;
+    extraParams?: IHash;
+}
+declare const submitPinAction: _reduxjs_toolkit.AsyncThunk<PINEntryState, SubmitPINArgs, {
+    rejectValue: PINEntryFailure;
+    state?: unknown;
+    dispatch?: redux.Dispatch<redux.UnknownAction>;
+    extra?: unknown;
+    serializedErrorType?: unknown;
+    pendingMeta?: unknown;
+    fulfilledMeta?: unknown;
+    rejectedMeta?: unknown;
+}>;
+declare const pinFlowReducer: redux.Reducer<{
+    currentState: {
+        type: "MSISDNEntry";
+        result: {
+            type: "NothingYet";
+        } | {
+            type: "Loading";
+        } | {
+            type: "Failure";
+            error: {
+                errorType: string;
+                error?: any;
+                productUrl?: string;
+            };
+        } | {
+            type: "Success";
+            data: {
+                [x: string]: unknown;
+            };
+        };
+        data?: {
+            actualPIN: string;
+            msisdn: string;
+            operator: string;
+            pinMaxLength: number;
+        };
+    } | {
+        type: "PINEntry";
+        result: {
+            type: "NothingYet";
+        } | {
+            type: "Loading";
+        } | {
+            type: "Failure";
+            error: {
+                errorType: PINEntryErrorTypes;
+                error?: {
+                    name: string;
+                    message: string;
+                    stack?: string;
+                };
+                productUrl?: string;
+            };
+        } | {
+            type: "Success";
+            data: {
+                finalUrl: string;
+                msisdn?: string;
+                isAlreadySubscribed?: boolean;
+            };
+        };
+        data?: {
+            actualPIN: string;
+            msisdn: string;
+            operator: string;
+            pinMaxLength: number;
+        };
+    };
+}, redux.UnknownAction, {
+    currentState: {
+        type: "MSISDNEntry";
+        result: {
+            type: "NothingYet";
+        } | {
+            type: "Loading";
+        } | {
+            type: "Failure";
+            error: {
+                errorType: string;
+                error?: any;
+                productUrl?: string;
+            };
+        } | {
+            type: "Success";
+            data: {
+                [x: string]: unknown;
+            };
+        };
+        data?: {
+            actualPIN: string;
+            msisdn: string;
+            operator: string;
+            pinMaxLength: number;
+        };
+    } | {
+        type: "PINEntry";
+        result: {
+            type: "NothingYet";
+        } | {
+            type: "Loading";
+        } | {
+            type: "Failure";
+            error: {
+                errorType: PINEntryErrorTypes;
+                error?: {
+                    name: string;
+                    message: string;
+                    stack?: string;
+                };
+                productUrl?: string;
+            };
+        } | {
+            type: "Success";
+            data: {
+                finalUrl: string;
+                msisdn?: string;
+                isAlreadySubscribed?: boolean;
+            };
+        };
+        data?: {
+            actualPIN: string;
+            msisdn: string;
+            operator: string;
+            pinMaxLength: number;
+        };
+    };
+}>;
+declare const backToStartAction: _reduxjs_toolkit.ActionCreatorWithoutPayload<"pinFlow/backToStartAction">;
+
+export { IHash, IMsisdnSumbitNextData, MSISDNEntryFailure, MSISDNEntrySuccess, PINEntryErrorTypes, PINEntryFailure, PINEntryState, PINEntrySuccess, PinFlowCurrentState, backToStartAction, pinFlowMatch, pinFlowReducer, submitMSISDNAction, submitPinAction, usePinFlowState };

package/dist/types/searchToObject.d.ts

@@ -0,0 +1,3 @@
+declare const searchToObject: (window: Window) => {};
+
+export { searchToObject };

package/dist/types/strategy.d.ts

@@ -0,0 +1,94 @@
+import { R as RemoteDataState } from './RemoteDataState-D1aFrz8W.js';
+export { a as RDS } from './RemoteDataState-D1aFrz8W.js';
+import { S as StrategyCurrentState, I as IDENTIFYMSISDNEntryFailure, a as IDENTIFYMSISDNEntrySuccess, P as PossibleTypes, C as ConfigDetails, b as IConfig, c as StrategyState } from './StrategyTypes-CbOgk0N4.js';
+export { Q as ExtraStrategyData, t as IDENTIFYFailure, k as IDENTIFYMSISDNEntryErrorTypes, u as IDENTIFYSuccess, q as IDENTIFY_FLOW_HESuccess, p as IDENTIFY_OPERATOR_MSISDNEntrySuccess, n as IDETECTYOPERATOBYIPFailure, o as IDETECTYOPERATOBYIPSuccess, w as IDetectOperatorByIpPayload, f as IFlow, j as IHash, E as IIdentfyFlowByIPOperatorNextAction, B as IIdentfyFlowByMsisdnNextAction, D as IIdentfyFlowByOperatorNextAction, A as IIdentifyFlowByHePayload, z as IIdentifyFlowByIpOperatorPayload, d as IIdentifyResult, G as IIdenyifyFlowByMsisdnPayload, F as IIdenyifyFlowByMsisdnSumbitNextData, H as IIdenyifyStrategyPayload, M as IMockFlowParams, L as IMockFlows, R as IMockPinFlowStates, v as IOperatorSelectFlowIdentifyPayload, x as IOperatorSelectPayload, N as IScriptHeaderEnrichmentSuccess, h as IStrategy, J as IStrategyCurrentState, K as IStrategyIDentifyUserResult, i as IStrategyNames, y as ISubmitMsisdnPayload, e as ISupportedFlows, l as IdentifyFlowOptionsResult, O as OPERATORSelectFailure, r as OPERATORSelectFlowIdentifyFailure, s as OPERATORSelectFlowIdentifySuccess, m as OPERATORSelectSuccess, T as RootState, g as StrategyConfig } from './StrategyTypes-CbOgk0N4.js';
+import { useSelector } from 'react-redux';
+import * as _reduxjs_toolkit from '@reduxjs/toolkit';
+import * as _reduxjs_toolkit_dist_createAsyncThunk from '@reduxjs/toolkit/dist/createAsyncThunk';
+import * as redux from 'redux';
+import './CreditCardTypes-B-IT-l6I.js';
+import './MoRedirTypes-4tEJjT1g.js';
+import './MoTypes-D-UK92gs.js';
+import './OneClickTypes-DjOesaHp.js';
+import './PinTypes-BLJDBZe6.js';
+import './UssdTypes-C7QlIW11.js';
+
+declare const useStrategyState: (useSelector: typeof useSelector) => StrategyCurrentState;
+
+declare function strategy<R>({ identifyInitialState, identifyFlowByOperatorSelect, identifyFlowByMsisdn, pinFlow, moFlow, moRedirFlow, oneClickFlow, click2smsFlow, ussdFlow, creditCardFlow }: {
+    identifyInitialState: () => R;
+    identifyFlowByOperatorSelect?: () => R;
+    identifyFlowByMsisdn?: (rds: RemoteDataState<IDENTIFYMSISDNEntryFailure, IDENTIFYMSISDNEntrySuccess>) => R;
+    pinFlow?: () => R;
+    moFlow?: () => R;
+    moRedirFlow?: () => R;
+    oneClickFlow?: () => R;
+    click2smsFlow?: () => R;
+    ussdFlow?: () => R;
+    creditCardFlow?: () => R;
+}): (state: StrategyCurrentState) => R;
+
+declare const submitMSISDNAction: _reduxjs_toolkit.AsyncThunk<StrategyCurrentState | {
+    type: PossibleTypes;
+    result: RemoteDataState<unknown, unknown>;
+    data: {
+        operator: string;
+        config: ConfigDetails;
+    };
+}, {
+    window: Window;
+    msisdn: string;
+    isHeSuccess?: boolean;
+}, _reduxjs_toolkit_dist_createAsyncThunk.AsyncThunkConfig>;
+
+declare const selectOperatorAction: _reduxjs_toolkit.AsyncThunk<{
+    type: PossibleTypes;
+    result: {
+        config: ConfigDetails;
+        operator: string;
+        autoRedirect?: undefined;
+    };
+} | {
+    type: PossibleTypes;
+    result: {
+        config: ConfigDetails;
+        operator: string;
+        autoRedirect: boolean;
+    };
+} | {
+    type: PossibleTypes;
+    result: RemoteDataState<unknown, unknown>;
+}, {
+    operator: string;
+}, _reduxjs_toolkit_dist_createAsyncThunk.AsyncThunkConfig>;
+
+/**
+ * Identify Strategy
+ * @returns {type: 'strategy/identifyStrategy', payload: {type: PossibleTypes.MO, result: IdentifyFlowOptionsResult}}
+ * - Add type
+ * - Makes a decision on which strategy to use in order to identify the flow
+ * - Strategy could be asking user's phone number, selecting an operator etc
+ * - all with the intension of getting the flow and its configuration
+ * - Flows are usually tied to an operator in the pages config.json
+ * - But they could also be single flows
+ *
+ */
+declare const identifyStrategy: _reduxjs_toolkit.AsyncThunk<StrategyCurrentState | {
+    type: PossibleTypes;
+    result: RemoteDataState<unknown, unknown>;
+    data: {
+        config: ConfigDetails;
+        operator: string;
+    };
+} | {
+    type: PossibleTypes;
+    result: RemoteDataState<unknown, unknown>;
+    data: {
+        config: IConfig;
+        msisdn: string;
+        operator: string;
+    };
+}, void, _reduxjs_toolkit_dist_createAsyncThunk.AsyncThunkConfig>;
+declare const strategyReducer: redux.Reducer<StrategyState, redux.UnknownAction, StrategyState>;
+
+export { ConfigDetails, IConfig, IDENTIFYMSISDNEntryFailure, IDENTIFYMSISDNEntrySuccess, PossibleTypes, StrategyCurrentState, StrategyState, identifyStrategy, selectOperatorAction, strategy, strategyReducer, submitMSISDNAction, useStrategyState };

package/dist/types/tracker.d.ts

@@ -0,0 +1,5 @@
+import * as pacman_client__build_lib_Pacman_types from 'pacman-client/.build-lib/Pacman/types';
+
+declare const tracker: pacman_client__build_lib_Pacman_types.ITrackerFlowEvents;
+
+export { tracker };