ouisys-engine 4.6.3 → 4.7.0-alpha.1

package/dist/types/handleSubmitNumber.d.ts

@@ -0,0 +1,26 @@
+import { Dispatch } from '@reduxjs/toolkit';
+
+declare const handleAutoSubmitMsisdn: ({ msisdnValue, dispatch, submitMSISDNAction, isHeaderEnrichmentSuccess, setMsisdnValue, isHeaderEnrichmentAutoSubmit }: {
+    window: Window;
+    msisdnValue: string;
+    dispatch: Dispatch;
+    submitMSISDNAction: ({ window, msisdn }: {
+        window: Window;
+        msisdn: string;
+    }) => any;
+    isHeaderEnrichmentSuccess: boolean;
+    setMsisdnValue: (msisdnValue: string) => void;
+    isHeaderEnrichmentAutoSubmit?: boolean;
+}) => void;
+declare const handleFormSubmit: ({ window, isHeaderEnrichmentSuccess, setInternationalNumber, onEnd, internationalNumber }: {
+    window: Window;
+    isHeaderEnrichmentSuccess: boolean;
+    country: string;
+    setInternationalNumber: (msisdn: string) => void;
+    onEnd: (msisdn: string, extraParams?: {
+        [key: string]: string;
+    }) => void;
+    internationalNumber: string;
+}) => 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-DF0jodl-.js';
+export { g as IHEResult, f as IIDentifyUserResult, e as ILinkExtraParams, i as IMockOneClickFlowStates, h as ISubscribeResult, d as SubscribeUserErrorTypes } from './OneClickTypes-DF0jodl-.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,86 @@
+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 StrategyState } from './StrategyTypes-BEIYqoJV.js';
+export { Q as ExtraStrategyData, d as IConfig, 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, c 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-BEIYqoJV.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-DF0jodl-.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;
+    };
+}, void, _reduxjs_toolkit_dist_createAsyncThunk.AsyncThunkConfig>;
+declare const strategyReducer: redux.Reducer<StrategyState, redux.UnknownAction, StrategyState>;
+
+export { ConfigDetails, 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 };

package/dist/types/ussdFlow.d.ts

@@ -0,0 +1,84 @@
+import { M as MSISDNEntryState, a as MSISDNEntryFailure, b as MSISDNEntrySuccess, c as UssdFlowCurrentState, d as MSISDNEntryErrorTypes } from './UssdTypes-C7QlIW11.js';
+export { I as IKeywordShortcode, e as IMSISDNSubmissionResult, f as IMockUssdFlowStates, U as UssdFlowState } from './UssdTypes-C7QlIW11.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 useUssdFlowState: (useSelector: typeof useSelector) => MSISDNEntryState;
+
+declare function ussdFlowMatch<R>({ msisdnEntry }: {
+    msisdnEntry: (rds: RemoteDataState<MSISDNEntryFailure, MSISDNEntrySuccess>) => R;
+}): (state: UssdFlowCurrentState) => R;
+
+interface SubmitMSISDNArgs {
+    window: Window;
+    msisdn: string;
+    extraParams?: IHash;
+}
+/**
+ * submitMSISDNAction
+ * @returns {type: '  'pinFlow/submitMSISDNAction', payload: {type: PossibleTypes, result: MSISDNEntryState}}
+ 
+ * Calls ussd api that open ussd prompt on mobile
+ *
+ */
+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 ussdFlowReducer: redux.Reducer<{
+    currentState: {
+        type: "MSISDNEntry";
+        result: {
+            type: "NothingYet";
+        } | {
+            type: "Loading";
+        } | {
+            type: "Failure";
+            error: {
+                errorType: MSISDNEntryErrorTypes;
+                error?: any;
+                productUrl?: string;
+            };
+        } | {
+            type: "Success";
+            data: {
+                keyword: string;
+                shortcode: string;
+            };
+        };
+    };
+}, redux.UnknownAction, {
+    currentState: {
+        type: "MSISDNEntry";
+        result: {
+            type: "NothingYet";
+        } | {
+            type: "Loading";
+        } | {
+            type: "Failure";
+            error: {
+                errorType: MSISDNEntryErrorTypes;
+                error?: any;
+                productUrl?: string;
+            };
+        } | {
+            type: "Success";
+            data: {
+                keyword: string;
+                shortcode: string;
+            };
+        };
+    };
+}>;
+declare const backToStartAction: _reduxjs_toolkit.ActionCreatorWithoutPayload<"ussdFlow/backToStartAction">;
+
+export { MSISDNEntryErrorTypes, MSISDNEntryFailure, MSISDNEntryState, MSISDNEntrySuccess, UssdFlowCurrentState, backToStartAction, submitMSISDNAction, useUssdFlowState, ussdFlowMatch, ussdFlowReducer };