@vonq/hapi-elements-types 1.4.0 → 1.5.0

package/enums.ts

@@ -0,0 +1,41 @@
+export enum WindowHapiCoreModuleName {
+    "api" = "hapiApi",
+    auth = "hapiAuth",
+    config = "hapiConfig",
+    instances = "hapiInstances",
+    qa = "hapiQA",
+    routing = "hapiRouting",
+    sdk = "hapi",
+    service = "hapiService",
+    state = "hapiState",
+    ui = "hapiUI",
+    utils = "hapiUtils",
+    validation = "hapiValidation",
+    instance = "hapiInstance",
+}
+
+export enum WindowHapiModuleName {
+    ats = "ats",
+    basket = "basket",
+    campaign = "campaign",
+    contract = "contract",
+    product = "product",
+    "common" = "common",
+    wallet = "wallet",
+    debugging = "debugging",
+    language = "language",
+    theming = "theming",
+    orderJourney = "orderJourney",
+    userJourney = "userJourney",
+    alert = "alert",
+    modal = "modal",
+    "ui" = "ui",
+}
+
+export enum WindowHapiSDKModuleName {
+    api = "api",
+    state = "state",
+    validation = "validation",
+    service = "service",
+    utils = "utils",
+}

package/package.json

@@ -1,22 +1,20 @@
 {
   "private": false,
   "name": "@vonq/hapi-elements-types",
-  "version": "1.4.0",
+  "version": "1.5.0",
   "description": "This package contains Typescript definitions for HAPI Elements",
   "author": "VONQ HAPI Team",
   "license": "BSD-3-Clause",
   "type": "module",
   "scripts": {
-    "build:types": "tsc -d --declarationMap --emitDeclarationOnly",
     "version:minor": "npm version minor",
-    "publish:types": "npm publish --access public"
+    "publish:types": "npm publish --access public",
+    "generate:index": "cti create ./src"
   },
-  "types": "index.d.ts",
-  "files": [
-    "index.d.ts"
-  ],
+  "main": "src/index.ts",
   "devDependencies": {
     "color": "^4.2.3",
+    "create-ts-index": "^1.14.0",
     "mobx": "^6.8.0",
     "react": "^18.2.0",
     "typescript": "^4.9.5",

package/src/_window/api.types.ts

@@ -0,0 +1,59 @@
+import { Logger } from "../common/logger/Logger"
+import {
+    AxiosRequestConfig,
+    AxiosResponse,
+    RawAxiosRequestConfig,
+    RawAxiosRequestHeaders,
+} from "axios"
+import { ModuleWithConstructorArgs } from "../types"
+import { WindowHapiModuleName } from "../../enums"
+import { WindowHapiAPIATS } from "../ats/api.types"
+import { WindowHapiAPICampaign } from "../campaign/api.types"
+import { WindowHapiAPIContract } from "../contract/api.types"
+import { WindowHapiAPIProduct } from "../product/api.types"
+import { WindowHapiAPIWallet } from "../wallet/api.types"
+import { WindowHapi } from "./window"
+
+export type WindowHapiAPIModule<ModuleType, ModuleConfig> = {
+    logger: Logger
+    configs: ModuleConfig
+    setBaseURL: (url: string) => void
+    setBaseConfig: (config: Record<string, RawAxiosRequestConfig>) => void
+    setResourceConfig: (
+        resourceKey: keyof ModuleConfig,
+        config: RawAxiosRequestConfig,
+    ) => void
+} & ModuleType
+export type HapiRequestConfig<T> = Omit<AxiosRequestConfig<T>, "headers"> & {
+    headers?: any
+}
+export type WindowHapiAPI = ModuleWithConstructorArgs<
+    {
+        /* Common */
+        request: <T = any, R = AxiosResponse<T>, D = any>(
+            config: Partial<HapiRequestConfig<D>>,
+        ) => Promise<R>
+        baseURL: string
+        setBaseURL: (url: string) => void
+        setBaseConfig: (params: Record<string, Record<string, string>>) => void
+        baseTimeout: number
+        setBaseTimeout: (timeout: number) => void
+        baseHeaders: RawAxiosRequestHeaders
+        headers: RawAxiosRequestHeaders
+        setHeaders: (headers: RawAxiosRequestHeaders) => void
+        baseRequestConfig: RawAxiosRequestConfig<any>
+        [WindowHapiModuleName.contract]: WindowHapiAPIContract
+        [WindowHapiModuleName.wallet]: WindowHapiAPIWallet
+        [WindowHapiModuleName.product]: WindowHapiAPIProduct
+        [WindowHapiModuleName.campaign]: WindowHapiAPICampaign
+        [WindowHapiModuleName.ats]: WindowHapiAPIATS
+        modules: {
+            [WindowHapiModuleName.contract]: WindowHapiAPIContract
+            [WindowHapiModuleName.wallet]: WindowHapiAPIWallet
+            [WindowHapiModuleName.product]: WindowHapiAPIProduct
+            [WindowHapiModuleName.campaign]: WindowHapiAPICampaign
+            [WindowHapiModuleName.ats]: WindowHapiAPIATS
+        }
+    },
+    { readonly core: WindowHapi }
+>

package/src/_window/auth.types.ts

@@ -0,0 +1,11 @@
+import { ModuleWithConstructorArgs } from "../types"
+import { WindowHapi } from "./window"
+
+export type WindowHapiAuth = ModuleWithConstructorArgs<
+    {
+        partnerId: string | undefined
+        clientId: string | undefined
+        clientToken: string | undefined
+    },
+    { readonly core: WindowHapi }
+>

package/src/_window/config.types.ts

@@ -0,0 +1,30 @@
+import { HapiWebComponent, RecursivePartial } from "../common/types"
+
+export type DebugPanelPosition =
+    | "bottom-left"
+    | "bottom-right"
+    | "top-left"
+    | "top-right"
+export type WindowHapiConfig = {
+    apiHost: string
+    initialState: RecursivePartial<any>
+    partnerId: string
+    clientId: string
+    clientToken: string
+    loadingSpinnerDefaultFillColor: string
+    appOrigin: string
+    enableLogs: boolean
+    webComponents: HapiWebComponent[]
+    isInvalidToken: boolean
+    useJWTAuthHeaders: boolean
+    addModal: boolean
+    addAlertBar: boolean
+    addDebugPanel: boolean
+    debugPanelPosition: DebugPanelPosition
+    datadogClientToken: string
+    env: string
+    appVersion: string
+    testMode: boolean
+    debugMode: boolean
+    htmlTemplates: Record<string, string>
+}

package/src/_window/events.types.ts

@@ -0,0 +1,157 @@
+import { ModuleWithConstructorArgs } from "../types"
+import {
+    WindowHapiEventCommandNames,
+    WindowHapiEventCommandStatus,
+    WindowHapiEventCommandData,
+} from "../common/events/EventCommand/types"
+import {
+    WindowHapiEventCommandCallbackHandler,
+    WindowHapiEventMediatorGetInstancesHandler,
+    WindowHapiEventMediatorInstances,
+    WindowHapiEventCommand,
+    WindowHapiEventStrategy,
+} from "../common/events/types"
+import { WindowHapi } from "./window"
+import WindowHapiInstance from "../common/instances/Instance"
+import { WindowHapiCoreModuleName } from "../../enums"
+import EventListener from "../../../common/events/EventListener"
+import WindowHapiEventListener from "../../../common/events/EventListener"
+
+export type WindowHapiEventFactory = ModuleWithConstructorArgs<
+    {
+        findEventsPendingResolveOrReject: (
+            events: WindowHapiEventCommand[],
+            id: string,
+        ) => WindowHapiEventCommand | undefined
+        findOrCreate: (
+            events: WindowHapiEventCommand[],
+            name: WindowHapiEventCommandNames,
+            value: WindowHapiEventCommandData,
+            instances: WindowHapiEventMediatorInstances,
+            id?: string,
+        ) => WindowHapiEventCommand
+        create: (
+            name: WindowHapiEventCommandNames,
+            data: WindowHapiEventCommandData,
+            getInstances: WindowHapiEventMediatorGetInstancesHandler,
+            id?: string,
+            status?: WindowHapiEventCommandStatus,
+        ) => WindowHapiEventCommand
+    },
+    { readonly getInstances: WindowHapiEventMediatorGetInstancesHandler }
+>
+
+export type WindowHapiEventMediatorCreateAndDispatchHandler = (
+    name: WindowHapiEventCommandNames,
+    data?: WindowHapiEventCommandData,
+    id?: string,
+    status?: WindowHapiEventCommandStatus,
+) => Promise<WindowHapiEventCommand | undefined>
+
+export type WindowHapiEventMediator = ModuleWithConstructorArgs<
+    {
+        createAndDispatch: WindowHapiEventMediatorCreateAndDispatchHandler
+        createAndDispatchDebounced: (
+            leading: boolean,
+        ) => WindowHapiEventMediatorCreateAndDispatchHandler
+        removeListener: (name: WindowHapiEventCommandNames) => void
+        onMessageReceived: (
+            eventCommand: WindowHapiEventCommand,
+        ) => Promise<WindowHapiEventCommand>
+        onMessage: (messageEvent: MessageEvent) => Promise<void>
+        runCallbacks: (eventCommand: WindowHapiEventCommand) => void
+        onRequestFullfilledOrTimedOut: (
+            resolve: any,
+            reject: any,
+            request: WindowHapiEventCommand,
+        ) => void
+        dispatchEvent: (
+            eventCommand: WindowHapiEventCommand,
+        ) => Promise<WindowHapiEventCommand | undefined>
+        retryEvent: (
+            eventCommand: WindowHapiEventCommand,
+        ) => Promise<WindowHapiEventCommand | undefined>
+        acknowledgeEvent: (event: WindowHapiEventCommand) => void
+        rejectEvent: (event: WindowHapiEventCommand) => Promise<void>
+        resolveEvent: (event: WindowHapiEventCommand) => Promise<void>
+        removeMessageEventListener: (_window: Window) => void
+        addMessageEventListener: (_window: Window) => void
+        getEventListener: (
+            name: WindowHapiEventCommandNames,
+            id?: string,
+        ) => EventListener | undefined
+        addEventListener: (
+            name: WindowHapiEventCommandNames,
+            callback: WindowHapiEventCommandCallbackHandler,
+            id?: string,
+        ) => EventListener
+        removeEventListener: (eventId: string) => void
+    },
+    {
+        readonly getInstances: WindowHapiEventMediatorGetInstancesHandler
+        readonly eventStorage: WindowHapiEventStorage
+        readonly eventFactory: WindowHapiEventFactory
+        readonly eventStateStrategy?: WindowHapiEventStrategy
+        readonly eventRoutingStrategy?: WindowHapiEventStrategy
+        readonly eventDOMStrategy?: WindowHapiEventStrategy
+        readonly eventConfigStrategy?: WindowHapiEventStrategy
+        readonly eventAppStrategy?: WindowHapiEventStrategy
+        readonly eventApiStrategy?: WindowHapiEventStrategy
+        readonly eventServiceStrategy?: WindowHapiEventStrategy
+        readonly eventQAStrategy?: WindowHapiEventStrategy
+    }
+>
+
+export type WindowHapiEventStorage = ModuleWithConstructorArgs<
+    {
+        cache: (WindowHapiEventCommand | WindowHapiEventListener)[]
+        listeners: WindowHapiEventListener[]
+        getFullfilledRequest: (eventCommandId: string) => WindowHapiEventCommand
+        replaceById: (eventCommand: WindowHapiEventCommand) => void
+        getEventById: (
+            eventCommandId: string,
+        ) => WindowHapiEventCommand | WindowHapiEventListener | undefined
+        add: (
+            eventCommand: WindowHapiEventCommand | WindowHapiEventListener,
+        ) => void
+        remove: (id: string) => void
+        removeByName: (name: string) => void
+        getEventsByName: (name: string) => WindowHapiEventCommand[]
+    },
+    { readonly getInstances: WindowHapiEventMediatorGetInstancesHandler }
+>
+
+export type WindowHapiEvents = ModuleWithConstructorArgs<
+    {
+        hasAddedWindowMessageEvent: boolean
+        addInternalEventListeners: () => void
+        removeInternalEventListeners: () => void
+        createSDKEventListener: (
+            property: string,
+            callback: (data: any) => void,
+        ) => void
+        sdkEventListenerCallback: (
+            data: WindowHapiEventCommandData,
+            _property: string,
+            callback: (data: WindowHapiEventCommandData) => void,
+        ) => void
+        eventFactory: WindowHapiEventFactory
+        eventMediator: WindowHapiEventMediator
+        eventStorage: WindowHapiEventStorage
+        eventRoutingStrategy: WindowHapiEventStrategy
+        eventAppStrategy: WindowHapiEventStrategy
+        eventApiStrategy: WindowHapiEventStrategy
+        eventStateStrategy: WindowHapiEventStrategy
+        eventServiceStrategy: WindowHapiEventStrategy
+        eventQAStrategy: WindowHapiEventStrategy
+        getInstances: () => {
+            source: WindowHapiInstance
+            targets: WindowHapiInstance[]
+        }
+        handleEventWithDataRequest: (
+            event: WindowHapiEventCommand,
+            coreModuleName: WindowHapiCoreModuleName,
+        ) => Promise<void>
+    },
+    { readonly core: WindowHapi }
+>

package/src/_window/index.ts

@@ -0,0 +1,16 @@
+// created from 'create-ts-index'
+
+export * from './api.types';
+export * from './auth.types';
+export * from './config.types';
+export * from './events.types';
+export * from './instances.types';
+export * from './qa.types';
+export * from './routing.types';
+export * from './sdk.types';
+export * from './service.types';
+export * from './state.types';
+export * from './ui.types';
+export * from './utils.types';
+export * from './validation.types';
+export * from './window';

package/src/_window/instances.types.ts

@@ -0,0 +1,18 @@
+import HapiInstance from "../common/instances/Instance"
+import { ModuleWithConstructorArgs } from "../types"
+import { WindowHapi } from "./window"
+
+export type WindowHapiInstances = ModuleWithConstructorArgs<
+    {
+        instances: HapiInstance[]
+        getFrameWindowByName: (name: string) => Window | undefined
+        hasInstance: (instanceName: string) => boolean
+        getInstanceByName: (instanceName: string) => HapiInstance | undefined
+        addInstanceByName: (instanceName: string, window: Window) => void
+        addInstance: (instance: HapiInstance) => void
+        removeInstance: (instanceName: string) => void
+        onAfterAddInstance: (instance: HapiInstance) => void
+        onAfterRemoveInstance: (instance: HapiInstance) => void
+    },
+    { readonly core: WindowHapi }
+>

package/src/_window/qa.types.ts

@@ -0,0 +1,28 @@
+import { WindowHapiModuleName } from "../../enums"
+import { ModuleWithConstructorArgs } from "../types"
+import { WindowHapi } from "./window"
+import { WindowHapiQACampaign } from "../campaign/qa.types"
+import { WindowHapiQACommon } from "../common/qa.types"
+import { WindowHapiQAOrderJourney } from "../orderJourney/qa.types"
+import { WindowHapiQAContract } from "../contract/qa.types"
+import { WindowHapiQATheming } from "../theming/qa.types"
+import { WindowHapiQALanguage } from "../language/qa.types"
+import { WindowHapiQAProduct } from "../product/qa.types"
+
+export type WindowHapiQA = ModuleWithConstructorArgs<
+    {
+        [WindowHapiModuleName.campaign]: WindowHapiQACampaign
+        [WindowHapiModuleName.product]: WindowHapiQAProduct
+        [WindowHapiModuleName.contract]: WindowHapiQAContract
+        [WindowHapiModuleName.orderJourney]: WindowHapiQAOrderJourney
+        [WindowHapiModuleName.theming]: WindowHapiQATheming
+        [WindowHapiModuleName.language]: WindowHapiQALanguage
+        [WindowHapiModuleName.common]: WindowHapiQACommon
+
+        isDebugPanelOpen: boolean
+        getDebugPanelButtonEl: () => HTMLElement | null
+        addDebugPanelToDOM: () => void
+        setDebugPanelPosition: (buttonEl: HTMLElement | null) => void
+    },
+    { readonly core: WindowHapi }
+>

package/src/_window/routing.types.ts

@@ -0,0 +1,21 @@
+import { ModuleWithConstructorArgs } from "../types"
+import { WindowHapi } from "./window"
+
+export type WindowHapiRoutingQueryParams = Record<string, string | string[]>
+
+export type WindowHapiRouting = ModuleWithConstructorArgs<
+    {
+        locationChangeInterval: number | undefined
+        currentPathname: string
+        startingPathname: string
+        origin: string
+        queryParams: WindowHapiRoutingQueryParams
+        setCurrentPathname: (pathname: string) => void
+        setStartingPathname: (pathname: string) => void
+        changeHref: (href: string) => void
+        setOrigin: (origin: string) => void
+        setQueryParams: (params: WindowHapiRoutingQueryParams) => void
+        onRouteChange: () => void
+    },
+    { readonly core: WindowHapi }
+>

package/src/_window/sdk.types.ts

@@ -0,0 +1,147 @@
+import { WindowHapiModuleName } from "../../enums"
+import { ModuleWithConstructorArgs } from "../types"
+import { WindowHapiServiceAlert } from "../alert/service.types"
+import { WindowHapiStateModule } from "./state.types"
+import { AlertStoreState } from "../alert/state.types"
+import { WindowHapiServiceBasket } from "../basket/service.types"
+import { BasketStoreState } from "../basket/state.types"
+import { WindowHapiUtilsBasket } from "../basket/utils.types"
+import { WindowHapiServiceCampaign } from "../campaign/service.types"
+import { CampaignStoreState } from "../campaign/state.types"
+import { WindowHapiUtilsCampaign } from "../campaign/utils.types"
+import { WindowHapiServiceContract } from "../contract/service.types"
+import { ContractStoreState } from "../contract/state.types"
+import { WindowHapiUtilsContract } from "../contract/utils.types"
+import { DebuggingStoreState } from "../debugging/state.types"
+import { LanguageStoreState } from "../language/state.types"
+import { WindowHapiServiceModal } from "../modal/service.types"
+import { ModalStoreState } from "../modal/state.types"
+import { OrderJourneyStoreState } from "../orderJourney/state.types"
+import { WindowHapiUtilsOrderJourney } from "../orderJourney/utils.types"
+import { WindowHapiServiceProduct } from "../product/service.types"
+import { ProductStoreState } from "../product/state.types"
+import { WindowHapiUtilsProduct } from "../product/utils.types"
+import { ThemeStoreState } from "../theming/state.types"
+import { WindowHapiServiceWallet } from "../wallet/service.types"
+import { WalletStoreState } from "../wallet/state.types"
+import { WindowHapiValidationsBasket } from "../basket/validations.types"
+import { WindowHapiValidationsCampaign } from "../campaign/validations.types"
+import { WindowHapiValidationsContract } from "../contract/validations.types"
+import { WindowHapiValidationsLanguage } from "../language/validations.types"
+import { WindowHapiValidationsOrderJourney } from "../orderJourney/validations.types"
+import { WindowHapiValidationsProduct } from "../product/validations.types"
+import { WindowHapiValidationsTheming } from "../theming/validations.types"
+import { WindowHapiValidationsWallet } from "../wallet/validations.types"
+import { WindowHapiAPICampaign } from "../campaign/api.types"
+import { WindowHapiAPIContract } from "../contract/api.types"
+import { WindowHapiAPIProduct } from "../product/api.types"
+import { WindowHapiAPIWallet } from "../wallet/api.types"
+import { WindowHapi } from "./window"
+import { WindowHapiServiceUI } from "../ui/service.types"
+
+export type WindowHapiSDKModule<
+    APIModule,
+    ServiceModule,
+    ValidationModule,
+    StateModule,
+    UtilsModule = any,
+> = {
+    api?: APIModule
+    state?: StateModule
+    service?: ServiceModule
+    validation?: ValidationModule
+    utils?: UtilsModule
+}
+
+export type WindowHapiSDKAlert = WindowHapiSDKModule<
+    undefined,
+    WindowHapiServiceAlert,
+    undefined,
+    WindowHapiStateModule<AlertStoreState>
+>
+export type WindowHapiSDKBasket = WindowHapiSDKModule<
+    undefined,
+    WindowHapiServiceBasket,
+    WindowHapiValidationsBasket,
+    WindowHapiStateModule<BasketStoreState>,
+    WindowHapiUtilsBasket
+>
+export type WindowHapiSDKCampaign = WindowHapiSDKModule<
+    WindowHapiAPICampaign,
+    WindowHapiServiceCampaign,
+    WindowHapiValidationsCampaign,
+    WindowHapiStateModule<CampaignStoreState>,
+    WindowHapiUtilsCampaign
+>
+export type WindowHapiSDKContract = WindowHapiSDKModule<
+    WindowHapiAPIContract,
+    WindowHapiServiceContract,
+    WindowHapiValidationsContract,
+    WindowHapiStateModule<ContractStoreState>,
+    WindowHapiUtilsContract
+>
+export type WindowHapiSDKDebugging = WindowHapiSDKModule<
+    undefined,
+    undefined,
+    undefined,
+    WindowHapiStateModule<DebuggingStoreState>
+>
+export type WindowHapiSDKLanguage = WindowHapiSDKModule<
+    undefined,
+    undefined,
+    WindowHapiValidationsLanguage,
+    WindowHapiStateModule<LanguageStoreState>
+>
+export type WindowHapiSDKOrderJourney = WindowHapiSDKModule<
+    undefined,
+    undefined,
+    WindowHapiValidationsOrderJourney,
+    WindowHapiStateModule<OrderJourneyStoreState>,
+    WindowHapiUtilsOrderJourney
+>
+export type WindowHapiSDKProduct = WindowHapiSDKModule<
+    WindowHapiAPIProduct,
+    WindowHapiServiceProduct,
+    WindowHapiValidationsProduct,
+    WindowHapiStateModule<ProductStoreState>,
+    WindowHapiUtilsProduct
+>
+export type WindowHapiSDKTheming = WindowHapiSDKModule<
+    undefined,
+    undefined,
+    WindowHapiValidationsTheming,
+    WindowHapiStateModule<ThemeStoreState>
+>
+export type WindowHapiSDKWallet = WindowHapiSDKModule<
+    WindowHapiAPIWallet,
+    WindowHapiServiceWallet,
+    WindowHapiValidationsWallet,
+    WindowHapiStateModule<WalletStoreState>
+>
+export type WindowHapiSDKUI = WindowHapiSDKModule<
+    undefined,
+    WindowHapiServiceUI,
+    undefined,
+    undefined
+>
+export type WindowHapiSDK = ModuleWithConstructorArgs<
+    {
+        [WindowHapiModuleName.contract]: WindowHapiSDKContract
+        [WindowHapiModuleName.basket]: WindowHapiSDKBasket
+        [WindowHapiModuleName.campaign]: WindowHapiSDKCampaign
+        [WindowHapiModuleName.wallet]: WindowHapiSDKWallet
+        [WindowHapiModuleName.product]: WindowHapiSDKProduct
+        [WindowHapiModuleName.orderJourney]: WindowHapiSDKOrderJourney
+        [WindowHapiModuleName.theming]: WindowHapiSDKTheming
+        [WindowHapiModuleName.language]: WindowHapiSDKLanguage
+        [WindowHapiModuleName.debugging]: WindowHapiSDKDebugging
+        [WindowHapiModuleName.alert]: WindowHapiSDKAlert
+    },
+    { readonly core: WindowHapi }
+>
+export type WindowHapiSDKModal = WindowHapiSDKModule<
+    undefined,
+    WindowHapiServiceModal,
+    undefined,
+    WindowHapiStateModule<ModalStoreState>
+>

package/src/_window/service.types.ts

@@ -0,0 +1,67 @@
+import { WindowHapiModuleName } from "../../enums"
+import { ModuleWithConstructorArgs } from "../types"
+import { WindowHapiServiceAlert } from "../alert/service.types"
+import { WindowHapiServiceBasket } from "../basket/service.types"
+import { WindowHapiServiceCampaign } from "../campaign/service.types"
+import { WindowHapiServiceContract } from "../contract/service.types"
+import { WindowHapiServiceProduct } from "../product/service.types"
+import { WindowHapiServiceWallet } from "../wallet/service.types"
+import { WindowHapiServiceModal } from "../modal/service.types"
+import { WindowHapiServiceUI } from "../ui/service.types"
+import { WindowHapiServiceATS } from "../ats/service.types"
+import { Logger } from "../common/logger/Logger"
+import { WindowHapi } from "./window"
+
+export type HapiServiceFunctionLifecycleHookCallbackHandler = () =>
+    | void
+    | never
+    | Promise<void | never>
+
+export type HapiServiceFunctionLifecycleHookHandler = (
+    callback: HapiServiceFunctionLifecycleHookCallbackHandler,
+) => void
+
+export type HapiServiceFunctionWithLifecycleHooks<HandlerType> = {
+    run: HandlerType
+    onStart: HapiServiceFunctionLifecycleHookHandler
+    onSuccess: HapiServiceFunctionLifecycleHookHandler
+    onFailure: HapiServiceFunctionLifecycleHookHandler
+    onFinish: HapiServiceFunctionLifecycleHookHandler
+}
+
+export type HapiServiceBase = {
+    __serviceName: WindowHapiModuleName
+    logger: Logger
+    init: () => void
+}
+export type WindowHapiService = ModuleWithConstructorArgs<
+    {
+        [WindowHapiModuleName.alert]: WindowHapiServiceAlert
+        [WindowHapiModuleName.basket]: WindowHapiServiceBasket
+        [WindowHapiModuleName.campaign]: WindowHapiServiceCampaign
+        [WindowHapiModuleName.contract]: WindowHapiServiceContract
+        [WindowHapiModuleName.product]: WindowHapiServiceProduct
+        [WindowHapiModuleName.wallet]: WindowHapiServiceWallet
+        [WindowHapiModuleName.modal]: WindowHapiServiceModal
+        [WindowHapiModuleName.ui]: WindowHapiServiceUI
+        [WindowHapiModuleName.ats]: WindowHapiServiceATS
+        services: {
+            [WindowHapiModuleName.alert]: WindowHapiServiceAlert
+            [WindowHapiModuleName.basket]: WindowHapiServiceBasket
+            [WindowHapiModuleName.campaign]: WindowHapiServiceCampaign
+            [WindowHapiModuleName.contract]: WindowHapiServiceContract
+            [WindowHapiModuleName.product]: WindowHapiServiceProduct
+            [WindowHapiModuleName.wallet]: WindowHapiServiceWallet
+            [WindowHapiModuleName.modal]: WindowHapiServiceModal
+            [WindowHapiModuleName.ui]: WindowHapiServiceUI
+            [WindowHapiModuleName.ats]: WindowHapiServiceATS
+        }
+
+        decorateFunctionWithLifecycleEvents: <HandlerType extends Function>(
+            service: HapiServiceBase,
+            propertyName: string,
+            fn: HandlerType,
+        ) => HapiServiceFunctionWithLifecycleHooks<HandlerType>
+    },
+    { readonly core: WindowHapi }
+>