ouisys-engine 4.6.3 → 4.7.0-alpha.4

package/dist/types/OneClickTypes-DF0jodl-.d.ts

@@ -0,0 +1,69 @@
+import { R as RemoteDataState } from './RemoteDataState-D1aFrz8W.js';
+
+interface GETREDIRECTUrlState {
+    type: 'GET_REDIRECT_URL';
+    result: RemoteDataState<IGETREDIRECTURLFailure, IGETREDIRECTURLSuccess>;
+}
+interface AJAXSUBSCRIBEState {
+    type: 'SUBCRIBE_AJAX';
+    result: RemoteDataState<SubscribeFailure, SubscribeSuccess>;
+}
+declare type OneClickFlowCurrentState = GETREDIRECTUrlState | AJAXSUBSCRIBEState;
+interface OneClickFlowState {
+    currentState: OneClickFlowCurrentState;
+}
+declare type IGETREDIRECTURLFailure = {
+    errorType?: string;
+    error?: any;
+};
+declare type IGETREDIRECTURLSuccess = {
+    redirectUrl: string;
+};
+declare type SubscribeUserErrorTypes = 'SubscriptionError' | 'UnknownError' | 'AlreadySubscribed';
+declare type SubscribeSuccess = {
+    productUrl: string;
+};
+declare type SubscribeFailure = {
+    errorType: SubscribeUserErrorTypes;
+    error?: any;
+    productUrl?: string;
+};
+interface ILinkExtraParams {
+    [key: string]: string;
+}
+declare type IIDentifyUserResult = {
+    success: true;
+    rockman_id: string;
+    subscription_url?: string;
+    redirect_url?: string;
+} | {
+    success: false;
+    rockman_id: string;
+    message: string;
+};
+declare type IHEResult = {
+    success: true;
+    rockman_id: string;
+    redirectUrlWithReplacedUniqid?: string;
+    source: string;
+    oldUniqid: string;
+    newUniqid: string;
+} | {
+    success: false;
+    rockman_id: string;
+    message: string;
+};
+declare type ISubscribeResult = {
+    success: true;
+    rockman_id: string;
+    product_url: string;
+    redirect_url?: string;
+} | {
+    success: false;
+    rockman_id: string;
+    message: string;
+    product_url?: string;
+};
+declare type IMockOneClickFlowStates = 'redirect-url-success-state' | 'subscribe-ajax-state';
+
+export type { AJAXSUBSCRIBEState as A, GETREDIRECTUrlState as G, IGETREDIRECTURLFailure as I, OneClickFlowState as O, SubscribeFailure as S, OneClickFlowCurrentState as a, IGETREDIRECTURLSuccess as b, SubscribeSuccess as c, SubscribeUserErrorTypes as d, ILinkExtraParams as e, IIDentifyUserResult as f, IHEResult as g, ISubscribeResult as h, IMockOneClickFlowStates as i };

package/dist/types/PinTypes-BLJDBZe6.d.ts

@@ -0,0 +1,128 @@
+import { R as RemoteDataState } from './RemoteDataState-D1aFrz8W.js';
+
+interface ExtraData {
+    actualPIN: string | null;
+    msisdn: string;
+    operator: string;
+    pinMaxLength: number | null;
+}
+interface MSISDNEntryState {
+    type: 'MSISDNEntry';
+    result: RemoteDataState<MSISDNEntryFailure, MSISDNEntrySuccess>;
+    data?: ExtraData;
+}
+interface PINEntryState {
+    type: 'PINEntry';
+    result: RemoteDataState<PINEntryFailure, PINEntrySuccess>;
+    data?: ExtraData;
+}
+declare type PinFlowCurrentState = MSISDNEntryState | PINEntryState;
+interface PinFlowState {
+    currentState: PinFlowCurrentState;
+}
+declare type MSISDNEntryErrorTypes = 'AlreadySubscribed' | 'UnknownError' | 'InvalidMSISDN' | string;
+declare type MSISDNEntryFailure = {
+    errorType: MSISDNEntryErrorTypes;
+    error?: any;
+    productUrl?: string;
+};
+declare type MSISDNEntrySuccess = Record<string, unknown>;
+declare type PINEntryFailure = {
+    errorType: PINEntryErrorTypes;
+    error?: Error;
+    productUrl?: string;
+};
+declare type PINEntrySuccess = {
+    finalUrl: string;
+    msisdn?: string;
+    isAlreadySubscribed?: boolean;
+};
+declare type PINEntryErrorTypes = 'UnknownError' | 'TooEarly' | 'InvalidPIN' | 'UnexpectedState' | 'SessionBlocked' | 'AlreadySubscribed';
+declare type IMsisdnSumbitNextData = {
+    actualPIN: string;
+    msisdn: string;
+    pinMaxLength?: number | null;
+    operator?: string;
+};
+declare type IMsisnSubmitActionPayload = {
+    type: 'MSISDNEntry';
+    result: RemoteDataState<MSISDNEntryFailure, MSISDNEntrySuccess>;
+    data: IMsisdnSumbitNextData;
+};
+declare type IMsisdnSubmitErrorPayload = {
+    type: 'MSISDNEntry';
+    result: RemoteDataState<MSISDNEntryFailure, MSISDNEntrySuccess>;
+};
+declare type IPinSubmitPayload = {
+    type: 'PINEntry';
+    result: RemoteDataState<PINEntryFailure, PINEntrySuccess>;
+    actualPIN?: string;
+};
+declare type IPinErrorPayload = {
+    type: 'PINEntry';
+    result: RemoteDataState<PINEntryFailure, PINEntrySuccess>;
+};
+declare type IBackToStartPayload = {
+    type: 'MSISDNEntry';
+    result: RemoteDataState<MSISDNEntryFailure, MSISDNEntrySuccess>;
+};
+declare type IConfig = {
+    offer?: string;
+    slug?: string;
+    country?: string;
+    host?: string;
+    device?: 'smart' | 'feature';
+    automaticallySubmitAllOperators?: boolean;
+    operators?: string[];
+};
+declare type IMSISDNSubmissionResult = {
+    success: true;
+    rockman_id: string;
+    pin: string;
+    product_url?: string;
+    operator: string;
+    redirect_to_url?: string;
+    javascript?: string;
+} | {
+    success: false;
+    rockman_id: string;
+    message: string;
+    product_url?: string;
+};
+declare type IPINSubmissionResult = {
+    success: true;
+    rockman_id: string;
+    product_url?: string;
+    async?: boolean;
+    message?: string;
+} | {
+    success: false;
+    rockman_id: string;
+    message: string;
+};
+interface IHash {
+    [key: string]: string;
+}
+declare type SingleMSISDNSubmissionResult = {
+    type: 'SingleMSISDNSubmissionResult';
+    operator: string;
+    pin?: string;
+    uniqidResult?: string;
+    redirectUrl?: string;
+};
+declare type MultiOperatorMSISDNSubmissionResult = {
+    type: 'MultiOperatorMSISDNSubmissionResult';
+};
+declare type IMcpShieldResult = {
+    success: true;
+    rockman_id: string;
+    source: string;
+    uniqid: string;
+} | {
+    success: false;
+    rockman_id: string;
+    message: string;
+};
+declare type IMockPinFlowStates = 'msisdn-state' | 'pin-state' | 'completed-state' | 'msisdn-failure-state';
+
+export type { ExtraData as E, IMsisdnSumbitNextData as I, MSISDNEntryFailure as M, PinFlowCurrentState as P, SingleMSISDNSubmissionResult as S, MSISDNEntrySuccess as a, PINEntryFailure as b, PINEntrySuccess as c, PINEntryState as d, PINEntryErrorTypes as e, IHash as f, MSISDNEntryState as g, PinFlowState as h, MSISDNEntryErrorTypes as i, IMsisnSubmitActionPayload as j, IMsisdnSubmitErrorPayload as k, IPinSubmitPayload as l, IPinErrorPayload as m, IBackToStartPayload as n, IConfig as o, IMSISDNSubmissionResult as p, IPINSubmissionResult as q, MultiOperatorMSISDNSubmissionResult as r, IMcpShieldResult as s, IMockPinFlowStates as t };

package/dist/types/RemoteDataState-D1aFrz8W.d.ts

@@ -0,0 +1,61 @@
+declare type RemoteDataState<E, D> = {
+    type: 'NothingYet';
+} | {
+    type: 'Loading';
+} | {
+    type: 'Failure';
+    error: E;
+} | {
+    type: 'Success';
+    data: D;
+};
+interface IMatcher<E, D, R> {
+    nothingYet: (data?: D) => R;
+    loading: () => R;
+    failure: (error: E) => R;
+    success: (data: D) => R;
+}
+interface ISuccessMatcher<E, D, R> {
+    success: (data: D) => R;
+    otherwise: (rds: RemoteDataState<E, D>) => R;
+}
+declare function match<E, D, R>({ nothingYet, loading, failure, success }: IMatcher<E, D, R>): (model: RemoteDataState<E, D>) => R;
+declare const NothingYet: <E, D>() => RemoteDataState<E, D>;
+declare const Loading: <E, D>() => RemoteDataState<E, D>;
+declare const Failure: <E, D>(error: E) => RemoteDataState<E, D>;
+declare const Success: <E, D>(data: D) => RemoteDataState<E, D>;
+declare const IsNothingYet: <E, D>(s: RemoteDataState<E, D>) => boolean;
+declare const IsLoading: <E, D>(s: RemoteDataState<E, D>) => boolean;
+declare const IsFailure: <E, D>(s: RemoteDataState<E, D>) => boolean;
+declare const IsSuccess: <E, D>(s: RemoteDataState<E, D>) => boolean;
+declare const WhenFailure: <E, D, R>(d: R, r: (err: E) => R) => (s: RemoteDataState<E, D>) => R;
+declare const WhenLoading: <D, R>(d: R, r: () => R) => (s: RemoteDataState<unknown, D>) => R;
+declare const WhenSuccess: <D, R>(d: R, r: (data: D) => R) => (s: RemoteDataState<unknown, D>) => R;
+declare const MatchFailure: <E, D, R>({ failure, otherwise }: {
+    otherwise: () => R;
+    failure: (err: E) => R;
+}) => (s: RemoteDataState<E, D>) => R;
+declare const MatchSuccess: <E, D, R>({ success, otherwise }: ISuccessMatcher<E, D, R>) => (s: RemoteDataState<E, D>) => R;
+
+declare const RemoteDataState$1_Failure: typeof Failure;
+type RemoteDataState$1_IMatcher<E, D, R> = IMatcher<E, D, R>;
+type RemoteDataState$1_ISuccessMatcher<E, D, R> = ISuccessMatcher<E, D, R>;
+declare const RemoteDataState$1_IsFailure: typeof IsFailure;
+declare const RemoteDataState$1_IsLoading: typeof IsLoading;
+declare const RemoteDataState$1_IsNothingYet: typeof IsNothingYet;
+declare const RemoteDataState$1_IsSuccess: typeof IsSuccess;
+declare const RemoteDataState$1_Loading: typeof Loading;
+declare const RemoteDataState$1_MatchFailure: typeof MatchFailure;
+declare const RemoteDataState$1_MatchSuccess: typeof MatchSuccess;
+declare const RemoteDataState$1_NothingYet: typeof NothingYet;
+type RemoteDataState$1_RemoteDataState<E, D> = RemoteDataState<E, D>;
+declare const RemoteDataState$1_Success: typeof Success;
+declare const RemoteDataState$1_WhenFailure: typeof WhenFailure;
+declare const RemoteDataState$1_WhenLoading: typeof WhenLoading;
+declare const RemoteDataState$1_WhenSuccess: typeof WhenSuccess;
+declare const RemoteDataState$1_match: typeof match;
+declare namespace RemoteDataState$1 {
+  export { RemoteDataState$1_Failure as Failure, type RemoteDataState$1_IMatcher as IMatcher, type RemoteDataState$1_ISuccessMatcher as ISuccessMatcher, RemoteDataState$1_IsFailure as IsFailure, RemoteDataState$1_IsLoading as IsLoading, RemoteDataState$1_IsNothingYet as IsNothingYet, RemoteDataState$1_IsSuccess as IsSuccess, RemoteDataState$1_Loading as Loading, RemoteDataState$1_MatchFailure as MatchFailure, RemoteDataState$1_MatchSuccess as MatchSuccess, RemoteDataState$1_NothingYet as NothingYet, type RemoteDataState$1_RemoteDataState as RemoteDataState, RemoteDataState$1_Success as Success, RemoteDataState$1_WhenFailure as WhenFailure, RemoteDataState$1_WhenLoading as WhenLoading, RemoteDataState$1_WhenSuccess as WhenSuccess, RemoteDataState$1_match as match };
+}
+
+export { type RemoteDataState as R, RemoteDataState$1 as a };

package/dist/types/StrategyTypes-BEIYqoJV.d.ts

@@ -0,0 +1,325 @@
+import { R as RemoteDataState } from './RemoteDataState-D1aFrz8W.js';
+import { C as CreditCardFlowState } from './CreditCardTypes-B-IT-l6I.js';
+import { e as MoRedirFlowState } from './MoRedirTypes-4tEJjT1g.js';
+import { d as MoFlowState } from './MoTypes-D-UK92gs.js';
+import { O as OneClickFlowState } from './OneClickTypes-DF0jodl-.js';
+import { h as PinFlowState } from './PinTypes-BLJDBZe6.js';
+import { U as UssdFlowState } from './UssdTypes-C7QlIW11.js';
+
+declare type IWithMultiKeywordShortcode = IKeywordShortcode & {
+    type?: string;
+    data?: Array<IKeywordShortcode>;
+};
+interface LOAD_OC2SMSState {
+    type: 'LOAD_OC2SMS';
+    result: RemoteDataState<string, IWithMultiKeywordShortcode>;
+}
+interface Click2smsFlowState {
+    currentState: Click2smsFlowCurrentState;
+}
+declare type Click2smsFlowCurrentState = LOAD_OC2SMSState;
+declare type MSISDNEntryErrorTypes = 'AlreadySubscribed' | 'UnknownError' | 'InvalidMSISDN' | 'UnexpectedState';
+declare type ILOADOC2SMSFailure = {
+    errorType: MSISDNEntryErrorTypes;
+    error?: any;
+    productUrl?: string;
+};
+declare type ILOADOC2SMSSuccess = IKeywordShortcode;
+declare type ILoadOc2click2smsPayload = {
+    type: 'LOAD_OC2SMS';
+    payload: RemoteDataState<string, IWithMultiKeywordShortcode>;
+};
+declare type IKeywordShortcode = {
+    keyword: string;
+    shortcode: string;
+    operator?: string;
+};
+declare type Config = {
+    host?: string;
+    country?: string;
+    slug?: string;
+    automaticallySubmitAllOperators?: boolean;
+    operators?: string[];
+};
+declare type IClick2smsConfig = ({
+    tag: 'tallyman';
+} & Config) | ({
+    tag: 'keywordAndShortCode';
+} & IKeywordShortcode & Config) | ({
+    tag: 'keyword';
+} & Config);
+declare type SingleSubmissionResult = IKeywordShortcode & {
+    type: 'SingleSubmissionResult';
+};
+declare type MultiOperatorSubmissionResult = {
+    type: 'MultiOperatorSubmissionResult';
+    data: Array<IKeywordShortcode>;
+};
+declare type ICheckSubscriptionResult = {
+    success: false;
+    rockman_id: string;
+    message: string;
+} | {
+    success: true;
+    msisdn: string;
+    product_url?: string;
+    rockman_id: string;
+};
+declare type IFetchResult = {
+    success: boolean;
+    uid: string;
+    shortcode: string;
+    keyword: string;
+    displayKeyword: string;
+    message?: string;
+};
+
+declare type IIdentifyResult = {
+    operator: string;
+    flow?: string;
+    success: boolean;
+    rockman_id?: string;
+    message?: string;
+};
+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 IConfig = {
+    offer?: string;
+    slug?: string;
+    country?: string;
+    host?: string;
+    device?: 'smart' | 'feature';
+    automaticallySubmitAllOperators?: boolean;
+    operators?: string[];
+    service?: string;
+    serviceId?: string;
+    queryString?: any;
+    apiAction?: any;
+};
+declare type ISupportedFlows = 'pin' | 'mo' | 'oneClick' | 'click2sms' | 'moRedir' | 'ussd' | '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';
+interface IHash {
+    [key: string]: string;
+}
+declare type IDENTIFYMSISDNEntryErrorTypes = 'AlreadySubscribed' | 'UnknownError' | 'InvalidMSISDN';
+declare type IDENTIFYMSISDNEntryFailure = {
+    errorType: IDENTIFYMSISDNEntryErrorTypes;
+    error: unknown;
+};
+declare type IdentifyFlowOptionsResult = {
+    config: IConfig;
+    nextAction?: unknown;
+    msisdn?: string;
+    operator?: string;
+    subscription_url?: string;
+    redirect_url?: string;
+    rockman_id?: string;
+    isHeaderEnrichmentSuccess?: boolean;
+    autoRedirect?: boolean;
+    isUseMsisdnPrefix?: boolean;
+};
+declare type IDENTIFYMSISDNEntrySuccess = {};
+declare type OPERATORSelectFailure = {};
+declare type OPERATORSelectSuccess = IdentifyFlowOptionsResult;
+declare type IDETECTYOPERATOBYIPFailure = {};
+declare type IDETECTYOPERATOBYIPSuccess = IdentifyFlowOptionsResult;
+declare type IDENTIFY_OPERATOR_MSISDNEntrySuccess = IdentifyFlowOptionsResult;
+declare type IDENTIFY_FLOW_HESuccess = IdentifyFlowOptionsResult;
+declare type OPERATORSelectFlowIdentifyFailure = {};
+declare type OPERATORSelectFlowIdentifySuccess = {
+    operators: Array<string>;
+    msisdn?: string;
+    nextAction: 'selectOperator';
+};
+declare type IDENTIFYFailure = {};
+declare type IDENTIFYSuccess = {};
+declare type IOperatorSelectFlowIdentifyPayload = {
+    type: 'IDENTIFY_FLOW_BY_OPERATOR_SELECT';
+    result: RemoteDataState<OPERATORSelectFlowIdentifyFailure, OPERATORSelectFlowIdentifySuccess>;
+};
+declare type IDetectOperatorByIpPayload = {
+    type: 'DETECT_OPERATOR_BY_IP';
+    result: RemoteDataState<IDETECTYOPERATOBYIPFailure, IDETECTYOPERATOBYIPSuccess>;
+};
+declare enum PossibleTypes {
+    IDENTIFY_STRATEGY = "IDENTIFY_STRATEGY",
+    IDENTIFY_FLOW_BY_MSISDN = "IDENTIFY_FLOW_BY_MSISDN",
+    IDENTIFY_FLOW_BY_OPERATOR_SELECT = "IDENTIFY_FLOW_BY_OPERATOR_SELECT",
+    PIN = "PIN",
+    MO = "MO",
+    MO_REDIR = "MO_REDIR",
+    ONE_CLICK = "ONE_CLICK",
+    CLICK2SMS = "CLICK2SMS",
+    USSD = "USSD",
+    TPAY_HE = "TPAY_HE",
+    CREDIT_CARD = "CREDIT_CARD"
+}
+declare type IOperatorSelectPayload = {
+    type: PossibleTypes;
+    result: OPERATORSelectSuccess;
+};
+declare type ISubmitMsisdnPayload = {
+    type: PossibleTypes;
+    result: IDENTIFY_OPERATOR_MSISDNEntrySuccess;
+};
+declare type IIdentifyFlowByIpOperatorPayload = {
+    type: PossibleTypes;
+    result: IDENTIFY_OPERATOR_MSISDNEntrySuccess;
+};
+declare type IIdentifyFlowByHePayload = {
+    type: PossibleTypes;
+    result: IDENTIFY_FLOW_HESuccess;
+};
+declare type IIdentfyFlowByMsisdnNextAction = 'submitMSISDNAction' | 'loadOc2sms';
+declare type IIdentfyFlowByOperatorNextAction = 'submitMSISDNAction' | 'loadOc2sms';
+declare type IIdentfyFlowByIPOperatorNextAction = 'getRedirectUrlAction' | 'submitMSISDNAction';
+declare type IIdenyifyFlowByMsisdnSumbitNextData = {
+    nextAction: IIdentfyFlowByMsisdnNextAction;
+    msisdn?: string;
+    operator?: string;
+};
+declare type IIdenyifyFlowByMsisdnPayload = {
+    type: 'IDENTIFY_FLOW_BY_MSISDN';
+    result: RemoteDataState<IDENTIFYMSISDNEntryFailure, IDENTIFYMSISDNEntrySuccess>;
+    data: IIdenyifyFlowByMsisdnSumbitNextData;
+};
+declare type IIdenyifyStrategyPayload = {
+    type: 'IDENTIFY_FLOW_BY_MSISDN';
+    result: RemoteDataState<IDENTIFYMSISDNEntryFailure, IDENTIFYMSISDNEntrySuccess>;
+    data: IIdenyifyFlowByMsisdnSumbitNextData;
+};
+declare type IStrategyCurrentState = {
+    type: 'IDENTIFY_STRATEGY';
+    result: RemoteDataState<IDENTIFYFailure, IDENTIFYSuccess>;
+} | {
+    type: 'IDENTIFY_FLOW_BY_OPERATOR_SELECT';
+    result: OPERATORSelectFlowIdentifySuccess;
+} | {
+    type: 'DETECT_OPERATOR_BY_IP';
+    result: RemoteDataState<IDETECTYOPERATOBYIPFailure, IDETECTYOPERATOBYIPSuccess>;
+} | {
+    type: 'HE_IDENTIFY';
+    result: RemoteDataState<IDENTIFYFailure, IDENTIFYSuccess>;
+} | {
+    type: 'OPERATOR_SELECT';
+    result: RemoteDataState<OPERATORSelectFailure, OPERATORSelectSuccess>;
+    config: IConfig;
+} | {
+    type: 'IDENTIFY_FLOW_BY_MSISDN';
+    result: RemoteDataState<IDENTIFYMSISDNEntryFailure, IDENTIFYMSISDNEntrySuccess>;
+    nextData: IIdenyifyFlowByMsisdnSumbitNextData;
+} | {
+    type: 'PIN';
+    result: IdentifyFlowOptionsResult;
+} | {
+    type: 'MO';
+    result: IdentifyFlowOptionsResult;
+} | {
+    type: 'USSD';
+    result: IdentifyFlowOptionsResult;
+} | {
+    type: 'MO_REDIR';
+    result: IdentifyFlowOptionsResult;
+} | {
+    type: 'ONE_CLICK';
+    result: IdentifyFlowOptionsResult;
+} | {
+    type: 'CLICK2SMS';
+    result: IdentifyFlowOptionsResult;
+} | {
+    type: 'TPAY_HE';
+    result: IdentifyFlowOptionsResult;
+} | {
+    type: 'CREDIT_CARD';
+    result: IdentifyFlowOptionsResult;
+};
+declare type IStrategyIDentifyUserResult = {
+    success: 'true';
+    rockman_id: string;
+    msisdn: string;
+    operator?: string;
+    subscription_url?: string;
+    redirect_url?: string;
+    'redirect-back'?: string;
+    'msisdn-alias'?: string;
+} | {
+    success: 'false';
+    rockman_id: string;
+    message: string;
+    'redirect-back'?: string;
+};
+declare type IMockFlows = 'pin' | 'mo' | 'oneclick' | 'click2sms' | 'moredir' | 'ussd' | 'tpay' | 'creditcard';
+interface IMockFlowParams<T> {
+    'mock-flow': IMockFlows;
+    'current-state': T;
+    'show-pin-entry': '1' | '0';
+    'show-thank-you': '1' | '0';
+    operator: string;
+    msisdn?: string;
+}
+interface IScriptHeaderEnrichmentSuccess extends CustomEvent {
+    detail: {
+        msisdn: string;
+        operator_code: string;
+    };
+}
+interface ExtraStrategyData {
+    isHeaderEnrichmentSuccess?: boolean;
+    config?: ConfigDetails;
+    msisdn?: string;
+    rockman_id?: string;
+    operator?: string;
+    subscription_url?: string;
+    redirect_url?: string;
+    operators?: string[];
+}
+interface StrategyState {
+    currentState: StrategyCurrentState;
+}
+interface StrategyCurrentState {
+    type: PossibleTypes;
+    result: RemoteDataState<any, any>;
+    data?: ExtraStrategyData;
+}
+declare type IMockPinFlowStates = 'msisdn-state' | 'pin-state' | 'completed-state' | 'msisdn-failure-state';
+interface RootState {
+    strategy?: StrategyState;
+    pinFlow?: PinFlowState;
+    moFlow?: MoFlowState;
+    moRedirFlow?: MoRedirFlowState;
+    click2smsFlow?: Click2smsFlowState;
+    oneClickFlow?: OneClickFlowState;
+    ussdFlow?: UssdFlowState;
+    creditCardFlow?: CreditCardFlowState;
+}
+
+export { type ILoadOc2click2smsPayload as $, type IIdentifyFlowByHePayload as A, type IIdentfyFlowByMsisdnNextAction as B, type ConfigDetails as C, type IIdentfyFlowByOperatorNextAction as D, type IIdentfyFlowByIPOperatorNextAction as E, type IIdenyifyFlowByMsisdnSumbitNextData as F, type IIdenyifyFlowByMsisdnPayload as G, type IIdenyifyStrategyPayload as H, type IDENTIFYMSISDNEntryFailure as I, type IStrategyCurrentState as J, type IStrategyIDentifyUserResult as K, type IMockFlows as L, type IMockFlowParams as M, type IScriptHeaderEnrichmentSuccess as N, type OPERATORSelectFailure as O, PossibleTypes as P, type ExtraStrategyData as Q, type IMockPinFlowStates as R, type StrategyCurrentState as S, type RootState as T, type LOAD_OC2SMSState as U, type Click2smsFlowState as V, type IWithMultiKeywordShortcode as W, type Click2smsFlowCurrentState as X, type MSISDNEntryErrorTypes as Y, type ILOADOC2SMSFailure as Z, type ILOADOC2SMSSuccess as _, type IDENTIFYMSISDNEntrySuccess as a, type IKeywordShortcode as a0, type IClick2smsConfig as a1, type SingleSubmissionResult as a2, type MultiOperatorSubmissionResult as a3, type ICheckSubscriptionResult as a4, type IFetchResult as a5, type StrategyState as b, type IIdentifyResult as c, type IConfig as d, type ISupportedFlows as e, type IFlow as f, type StrategyConfig as g, type IStrategy as h, type IStrategyNames as i, type IHash as j, type IDENTIFYMSISDNEntryErrorTypes as k, type IdentifyFlowOptionsResult as l, type OPERATORSelectSuccess as m, type IDETECTYOPERATOBYIPFailure as n, type IDETECTYOPERATOBYIPSuccess as o, type IDENTIFY_OPERATOR_MSISDNEntrySuccess as p, type IDENTIFY_FLOW_HESuccess as q, type OPERATORSelectFlowIdentifyFailure as r, type OPERATORSelectFlowIdentifySuccess as s, type IDENTIFYFailure as t, type IDENTIFYSuccess as u, type IOperatorSelectFlowIdentifyPayload as v, type IDetectOperatorByIpPayload as w, type IOperatorSelectPayload as x, type ISubmitMsisdnPayload as y, type IIdentifyFlowByIpOperatorPayload as z };

package/dist/types/UssdTypes-C7QlIW11.d.ts

@@ -0,0 +1,34 @@
+import { R as RemoteDataState } from './RemoteDataState-D1aFrz8W.js';
+
+interface MSISDNEntryState {
+    type: 'MSISDNEntry';
+    result: RemoteDataState<MSISDNEntryFailure, MSISDNEntrySuccess>;
+}
+declare type UssdFlowCurrentState = MSISDNEntryState;
+interface UssdFlowState {
+    currentState: UssdFlowCurrentState;
+}
+declare type MSISDNEntryErrorTypes = 'AlreadySubscribed' | 'UnknownError' | 'InvalidMSISDN' | 'UnexpectedState';
+declare type MSISDNEntryFailure = {
+    errorType: MSISDNEntryErrorTypes;
+    error?: any;
+    productUrl?: string;
+};
+declare type MSISDNEntrySuccess = IKeywordShortcode;
+declare type IKeywordShortcode = {
+    keyword: string;
+    shortcode: string;
+};
+declare type IMSISDNSubmissionResult = {
+    success: true;
+    rockman_id: string;
+    keyword: string;
+    shortcode: string;
+} | {
+    success: false;
+    rockman_id: string;
+    message: string;
+};
+declare type IMockUssdFlowStates = 'msisdn-entry-success-state' | 'msisdn-entry-failure-state';
+
+export type { IKeywordShortcode as I, MSISDNEntryState as M, UssdFlowState as U, MSISDNEntryFailure as a, MSISDNEntrySuccess as b, UssdFlowCurrentState as c, MSISDNEntryErrorTypes as d, IMSISDNSubmissionResult as e, IMockUssdFlowStates as f };

package/dist/types/checkSubscriptionHander.d.ts

@@ -0,0 +1,8 @@
+declare function checkSubscriptionHander({ window, flow, action, args }: {
+    window: Window;
+    flow?: string;
+    action?: string;
+    args?: any;
+}): Promise<string>;
+
+export { checkSubscriptionHander };

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-BEIYqoJV.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-BEIYqoJV.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-DF0jodl-.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 };