@elliemae/pui-app-sdk 6.0.0-alpha.3 → 6.0.0-alpha.4

package/dist/types/lib/utils/auth/index.d.ts

@@ -1,4 +1,14 @@
 import type { EndSessionFn } from './types.js';
+/**
+ * Checks if the user is currently authorized/authenticated.
+ * @returns `true` if user has a valid authorization header, `false` otherwise
+ * @example
+ * ```typescript
+ * if (isUserAuthorized()) {
+ *   // User is logged in
+ * }
+ * ```
+ */
 export declare const isUserAuthorized: () => boolean;
 export declare const getIDPInfoFromUrl: () => {
     code: string;
@@ -41,24 +51,66 @@ export declare const navigateToLoginPage: ({ clientId, redirectUri, idpErrorCode
     useCompactIdpPage?: boolean;
     isSSO?: boolean;
 }) => void;
+/**
+ * Ends the current user session and redirects to logout page.
+ * Revokes tokens and clears session storage.
+ * @param params - Session end parameters
+ * @param params.clientId - OAuth client ID
+ * @param params.redirectUri - URI to redirect after logout
+ * @param params.responseType - OAuth response type
+ * @param params.scope - OAuth scopes
+ * @param params.code - Optional error code
+ * @param params.customLogoutUrl - Optional custom logout URL to redirect to instead of IDP
+ * @param params.skipRevoke - Skip token revocation if true
+ * @example
+ * ```typescript
+ * await endSession({
+ *   clientId: 'my-app',
+ *   redirectUri: window.location.origin,
+ *   scope: 'openid'
+ * });
+ * ```
+ */
 export declare const endSession: EndSessionFn;
-export declare const authorize: ({ code, redirectUri, clientId, scope, responseType, }: {
+/**
+ * Handles the OAuth authorization callback after redirect from IDP.
+ * Exchanges authorization code for access token and initializes user session.
+ * @param params - Authorization parameters
+ * @param params.code - Authorization code from IDP
+ * @param params.redirectUri - Redirect URI used in OAuth flow
+ * @param params.clientId - OAuth client ID
+ * @param params.scope - OAuth scopes
+ * @param params.responseType - OAuth response type
+ * @param params.isConsumerUser - Whether user is a consumer user
+ * @example
+ * ```typescript
+ * await authorize({
+ *   clientId: 'my-app',
+ *   code: 'auth-code-from-url',
+ *   redirectUri: window.location.origin,
+ *   scope: 'openid',
+ *   responseType: 'code',
+ *   isConsumerUser: false
+ * });
+ * ```
+ */
+export declare const authorize: ({ code, redirectUri, clientId, scope, responseType, isConsumerUser, }: {
     code: string;
     redirectUri: string;
     clientId: string;
     scope: string;
     responseType: string;
+    isConsumerUser: boolean;
 }) => Promise<void>;
 /**
- * Attempts to log in a user using the provided authentication parameters.
- *
- * If an authorization code is present in the URL, it calls the `authorize`
- * function with the login information and returns `{ authorized: true }`.
- * Otherwise, it navigates to the login page and returns `{ authorized: false }`.
- * @param params - The authentication parameters.
- * @param params.clientId - The client identifier for the authentication request.
- * @param params.scope - The scope of the authentication request.
- * @param params.responseType - The response type for the authentication request.
+ * Initiates the login flow using OAuth/OIDC authorization code flow.
+ * If authorization code is present in URL, completes the authorization.
+ * Otherwise, redirects to the identity provider's login page.
+ * @param params - Login parameters
+ * @param params.clientId - OAuth client ID
+ * @param params.scope - OAuth scopes (e.g., 'openid profile email')
+ * @param params.responseType - OAuth response type (typically 'code')
+ * @param params.isConsumerUser - Whether user is a consumer user
  * @param params.instanceId - (Optional) The instance identifier.
  * @param params.siteId - (Optional) The site identifier.
  * @param params.userId - (Optional) The user identifier.
@@ -67,12 +119,25 @@ export declare const authorize: ({ code, redirectUri, clientId, scope, responseT
  * @param params.useCompactIdpPage - (Optional). Determines whether to use a compact or
  * full IDP page.
  * @param params.isSSO - (Optional). Determines whether to use SSO or not.
- * @returns An object indicating whether the user is authorized.
+ * @returns Promise with authorization status
+ * @example
+ * ```typescript
+ * const result = await login({
+ *   clientId: 'my-app',
+ *   scope: 'openid profile',
+ *   responseType: 'code',
+ *   isConsumerUser: false
+ * });
+ * if (result.authorized) {
+ *   // User is now logged in
+ * }
+ * ```
  */
-export declare const login: ({ clientId, scope, responseType, instanceId, siteId, userId, disableRememberMe, useCompactIdpPage, isSSO, }: {
+export declare const login: ({ clientId, scope, responseType, isConsumerUser, instanceId, siteId, userId, disableRememberMe, useCompactIdpPage, isSSO, }: {
     clientId: string;
     scope: string;
     responseType: string;
+    isConsumerUser: boolean;
     instanceId?: number;
     siteId?: number;
     userId?: string;

package/dist/types/lib/utils/auth/loginParams.d.ts

@@ -1,5 +1,26 @@
 import { LoginParams } from './types';
+/**
+ * Sets login parameters for the authentication flow.
+ * Stores parameters in the global window object for use across the application.
+ * @param params - Login parameters
+ * @param params.clientId - OAuth client ID
+ * @param params.scope - OAuth scopes
+ * @param params.redirectUri - Optional redirect URI (defaults to current URL)
+ * @example
+ * ```typescript
+ * setLoginParams({
+ *   clientId: 'my-app',
+ *   scope: 'openid profile email'
+ * });
+ * ```
+ */
 export declare const setLoginParams: (params: Omit<LoginParams, "redirectUri"> & {
     redirectUri?: string;
 }) => void;
+/**
+ * Gets the stored login parameters.
+ * If not set, attempts to retrieve from session storage.
+ * @returns The login parameters object
+ * @internal
+ */
 export declare const getLoginParams: () => LoginParams;

package/dist/types/lib/utils/auth/types.d.ts

@@ -1,7 +1,7 @@
 export type EndSessionFn = (params: {
     clientId: string;
-    redirectUri: string;
-    responseType: string;
+    redirectUri?: string;
+    responseType?: string;
     scope: string;
     code?: string;
     customLogoutUrl?: string;
@@ -10,6 +10,6 @@ export type EndSessionFn = (params: {
 export type LoginParams = {
     clientId: string;
     scope: string;
-    responseType: string;
-    redirectUri: string;
+    responseType?: string;
+    redirectUri?: string;
 };

package/dist/types/lib/utils/constants.d.ts

@@ -13,3 +13,4 @@ export declare const Themes: {
 };
 export declare const HOST_WINDOW_RESIZED = "HOST_WINDOW_RESIZED";
 export declare const HOST_WINDOW_BREAKPOINT_CHANGED = "HOST_WINDOW_BREAKPOINT_CHANGED";
+export declare const SESSION_RENEWAL_INTERVAL = 60000;

package/dist/types/lib/utils/custom-hooks/use-state-selector.d.ts

@@ -16,7 +16,7 @@ export interface UseStateSelectorOptions<Selected = unknown> {
  * export selectStateFieldFunc = getSelectField(name);
  * ```
  * @param {string | Array<string>} fieldName the state's field you want to acccess, this accepts nested objects access, like so 'rootObj.childObj.field'
- * @param {useStateSelectorOptions} opts options { defaultValue, equalityFn }
+ * @param {useStateSelectorOptions} opts options (defaultValue, equalityFn)
  * @returns
  */
 export declare function useStateSelector<TState = unknown, Selected = unknown>(selectStateFieldFunc: SelectStateFieldFunction<TState, Selected>, fieldName?: string | Array<string>, { defaultValue, equalityFn, }?: UseStateSelectorOptions<Selected>): Selected;
@@ -34,7 +34,7 @@ export declare function useStateSelector<TState = unknown, Selected = unknown>(s
  * export selectStateFieldFunc = getSelectField(name);
  * ```
  * @param {string | Array<string>} fieldName the state's field you want to acccess, this accepts nested objects access, like so 'rootObj.childObj.field'
- * @param {useStateSelectorOptions} opts options { defaultValue, equalityFn = shallowEqual }
+ * @param {useStateSelectorOptions} opts options (defaultValue, equalityFn = shallowEqual)
  * @returns
  */
 export declare function useStateSelectorShallow<TState = unknown, Selected = unknown>(selectStateFieldFunc: SelectStateFieldFunction<TState, Selected>, fieldName?: string | Array<string>, { defaultValue, equalityFn, }?: UseStateSelectorOptions<Selected>): Selected;

package/dist/types/lib/utils/decorators/classDecorators.d.ts

@@ -3,6 +3,7 @@
  * @param constructors - The constructors of the classes to be mixed in.
  * @returns A class decorator that mixes the provided classes into the target class.
  * @example
+ * ```typescript
  * class A {
  *   methodA() {
  *     console.log('A');
@@ -14,12 +15,14 @@
  *     console.log('B');
  *   }
  * }
- * @Mixins(A, B)
+ * // Apply decorator
+ * // @Mixins(A, B)
  * class C {}
  *
  * const instance = new C();
  * instance.methodA(); // Outputs: 'A'
  * instance.methodB(); // Outputs: 'B'
+ * ```
  */
 export declare function Mixins(...constructors: any[]): (derivedCtor: any) => void;
 declare const SINGLETON_KEY: unique symbol;
@@ -28,7 +31,8 @@ declare const SINGLETON_KEY: unique symbol;
  * @param type - The class to be made a singleton.
  * @returns A proxy that ensures only one instance of the class is created.
  * @example
- * @Singleton
+ * ```typescript
+ * // @Singleton decorator
  * class MyClass {
  *   constructor() {
  *     console.log('Instance created');
@@ -39,6 +43,7 @@ declare const SINGLETON_KEY: unique symbol;
  * const instance2 = new MyClass(); // No output, same instance returned
  *
  * console.log(instance1 === instance2); // Outputs: true
+ * ```
  */
 export declare function Singleton<T extends new (...args: any[]) => any>(type: T): T & {
     [SINGLETON_KEY]?: InstanceType<T>;

package/dist/types/lib/utils/decorators/functionDecorators.d.ts

@@ -5,12 +5,14 @@
  * @param {PropertyDescriptor} descriptor - The property descriptor.
  * @returns {PropertyDescriptor} The modified property descriptor.
  * @example
+ * ```typescript
  * class Example {
- *   @CacheUntilResolved
+ *   // Apply decorator: CacheUntilResolved
  *   async fetchData() {
  *     // ...fetch data...
  *   }
  * }
+ * ```
  */
 export declare function CacheUntilResolved(_target: any, propertyKey: string, descriptor: PropertyDescriptor): PropertyDescriptor;
 /**
@@ -18,12 +20,14 @@ export declare function CacheUntilResolved(_target: any, propertyKey: string, de
  * @param {number} [delay=300] - The delay in milliseconds.
  * @returns {Function} A function that modifies the property descriptor.
  * @example
+ * ```typescript
  * class Example {
- *   @Debounce(500)
+ *   // Apply decorator: Debounce(500)
  *   onResize() {
  *     // ...handle resize...
  *   }
  * }
+ * ```
  */
 export declare function Debounce(delay?: number): (_target: any, _propertyKey: string, descriptor: PropertyDescriptor) => PropertyDescriptor;
 /**
@@ -33,12 +37,14 @@ export declare function Debounce(delay?: number): (_target: any, _propertyKey: s
  * @param {PropertyDescriptor} descriptor - The property descriptor.
  * @returns {PropertyDescriptor} The modified property descriptor.
  * @example
+ * ```typescript
  * class Example {
- *   @ImmutableArgs
+ *   // Apply decorator: ImmutableArgs
  *   updateData(data: any) {
  *     // ...update data...
  *   }
  * }
+ * ```
  */
 export declare function ImmutableArgs(_target: any, _propertyKey: string | symbol, descriptor: PropertyDescriptor): PropertyDescriptor;
 /**
@@ -48,12 +54,14 @@ export declare function ImmutableArgs(_target: any, _propertyKey: string | symbo
  * @param {PropertyDescriptor} descriptor - The property descriptor.
  * @returns {PropertyDescriptor} The modified property descriptor.
  * @example
+ * ```typescript
  * class Example {
- *   @Memoize
+ *   // Apply decorator: Memoize
  *   computeValue(x: number) {
  *     return x * 2;
  *   }
  * }
+ * ```
  */
 export declare function Memoize(_target: any, _key: string, descriptor: PropertyDescriptor): void;
 /**
@@ -63,12 +71,14 @@ export declare function Memoize(_target: any, _key: string, descriptor: Property
  * @param {PropertyDescriptor} descriptor - The property descriptor.
  * @returns {PropertyDescriptor} The modified property descriptor.
  * @example
+ * ```typescript
  * class Example {
- *   @MemoizeAsync
+ *   // Apply decorator: MemoizeAsync
  *   async fetchData() {
  *     // ...fetch data...
  *   }
  * }
+ * ```
  */
 export declare function MemoizeAsync(_target: any, _propertyKey: string, descriptor: PropertyDescriptor): PropertyDescriptor;
 /**
@@ -78,12 +88,14 @@ export declare function MemoizeAsync(_target: any, _propertyKey: string, descrip
  * @param {PropertyDescriptor} descriptor - The property descriptor.
  * @returns {PropertyDescriptor} The modified property descriptor.
  * @example
+ * ```typescript
  * class Example {
- *   @QueueTask
+ *   // Apply decorator: QueueTask
  *   processTask() {
  *     // ...process task...
  *   }
  * }
+ * ```
  */
 export declare function QueueTask(_target: unknown, _key: string, descriptor: PropertyDescriptor): void;
 /**
@@ -99,3 +111,111 @@ export declare function QueueTask(_target: unknown, _key: string, descriptor: Pr
  * }
  */
 export declare function Throttle(delay?: number): (_target: any, _propertyKey: string, descriptor: PropertyDescriptor) => PropertyDescriptor;
+/**
+ * AsyncSingleExecution decorator ensures that multiple concurrent calls to an async function
+ * with the same arguments will return the same promise instance until it resolves.
+ * Once resolved, subsequent calls will trigger a new execution.
+ * @param _target
+ * @param _propertyKey
+ * @param descriptor
+ * @returns {Function} A function that modifies the property descriptor.
+ * @example
+ * ```typescript
+ * import { AsyncSingleExecution } from './functionDecorators';
+ *
+ * class Example {
+ *   @AsyncSingleExecution
+ *   async fetchData(id: number) {
+ *     console.log('Fetching data for', id);
+ *     return new Promise(resolve => setTimeout(() => resolve(id), 1000));
+ *   }
+ * }
+ *
+ * const instance = new Example();
+ * const promise1 = instance.fetchData(1);
+ * const promise2 = instance.fetchData(1);
+ *
+ * console.log(promise1 === promise2); // true
+ * ```
+ *
+ * // Output:
+ * // Fetching data for 1 (only logged once)
+ * ```
+ */
+export declare function AsyncSingleExecution(_target: any, _propertyKey: string, descriptor: PropertyDescriptor): PropertyDescriptor;
+/**
+ * Retries an async method a specified number of times with a delay between attempts.
+ * @param {number} [retries=3] - The number of retry attempts.
+ * @param {number} [interval=2000] - The delay in milliseconds between retries.
+ * @param {boolean} [reThrowException=true] - Whether to rethrow the exception after all retries fail.
+ * @returns {MethodDecorator} A method decorator that modifies the property descriptor.
+ * @example
+ * class Example {
+ *   @RetryAsync(3, 1000, true)
+ *   async fetchData() {
+ *     console.log('Attempting to fetch data...');
+ *     if (Math.random() < 0.7) {
+ *       throw new Error('Fetch failed');
+ *     }
+ *     return 'Data fetched successfully';
+ *   }
+ * }
+ *
+ * const instance = new Example();
+ * instance.fetchData().then(console.log).catch(console.error);
+ *
+ * // Output (example):
+ * // Attempting to fetch data...
+ * // Attempting to fetch data...
+ * // Attempting to fetch data...
+ * // Error: Fetch failed
+ */
+export declare function RetryAsync(retries?: number, interval?: number, reThrowException?: boolean): MethodDecorator;
+/**
+ * Memoizes the result of a function with a single primitive argument or no arguments.
+ * Only caches results for functions that take exactly one primitive argument (string, number, boolean, symbol, null, or undefined)
+ * or no arguments at all. Uses a simple object as the cache.
+ * @param _target
+ * @param _propertyKey
+ * @param descriptor
+ * @example
+ * ```typescript
+ * // Single primitive argument
+ * class Example {
+ *   // Apply decorator: MemoizeSingleArgPrimitive
+ *   double(x: number) {
+ *     return x * 2;
+ *   }
+ * }
+ * const ex = new Example();
+ * ex.double(2); // Calls original, returns 4
+ * ex.double(2); // Returns cached result, 4
+ * ```
+ * @example
+ * ```typescript
+ * // No arguments
+ * class ExampleNoArg {
+ *   // Apply decorator: MemoizeSingleArgPrimitive
+ *   getRandom() {
+ *     return Math.random();
+ *   }
+ * }
+ * const ex2 = new ExampleNoArg();
+ * ex2.getRandom(); // Calls original, returns a value
+ * ex2.getRandom(); // Returns cached value
+ * ```
+ * @example
+ * ```typescript
+ * // Not cached for non-primitive or multiple arguments
+ * class ExampleObj {
+ *   // Apply decorator: MemoizeSingleArgPrimitive
+ *   sum(obj: { x: number }) {
+ *     return obj.x + 1;
+ *   }
+ * }
+ * const ex3 = new ExampleObj();
+ * ex3.sum({ x: 1 }); // Calls original
+ * ex3.sum({ x: 1 }); // Calls original again (not cached)
+ * ```
+ */
+export declare function MemoizeSingleArgPrimitive<T extends string | number | boolean | symbol | null | undefined, R>(_target: any, _propertyKey: string, descriptor: TypedPropertyDescriptor<(...args: any[]) => R>): TypedPropertyDescriptor<(...args: any[]) => R>;

package/dist/types/lib/utils/decorators/index.d.ts

@@ -1,5 +1,5 @@
 import { Mixins, Singleton } from './classDecorators.js';
-import { CacheUntilResolved, Debounce, ImmutableArgs, Memoize, MemoizeAsync, QueueTask, Throttle } from './functionDecorators.js';
+import { AsyncSingleExecution, CacheUntilResolved, Debounce, ImmutableArgs, Memoize, MemoizeAsync, QueueTask, Throttle, RetryAsync, MemoizeSingleArgPrimitive } from './functionDecorators.js';
 declare const decorators: {
     class: {
         Mixins: typeof Mixins;
@@ -11,8 +11,11 @@ declare const decorators: {
         ImmutableArgs: typeof ImmutableArgs;
         Memoize: typeof Memoize;
         MemoizeAsync: typeof MemoizeAsync;
+        MemoizeSingleArgPrimitive: typeof MemoizeSingleArgPrimitive;
         QueueTask: typeof QueueTask;
         Throttle: typeof Throttle;
+        AsyncSingleExecution: typeof AsyncSingleExecution;
+        RetryAsync: typeof RetryAsync;
     };
 };
 export { decorators };

package/dist/types/lib/utils/helpers.d.ts

@@ -12,3 +12,10 @@ export declare const getProductAppDetails: () => {
     appUrl: string;
     appPageTitle: string;
 };
+export declare const abortPromise: ({ promise, delay, retValue, throwError, errMsg, }: {
+    promise: Promise<unknown>;
+    delay: number;
+    retValue?: unknown;
+    throwError?: boolean;
+    errMsg?: string;
+}) => Promise<unknown>;

package/dist/types/lib/utils/logrocket.d.ts

@@ -0,0 +1,26 @@
+import type LogRocket from 'logrocket';
+import { resetLrIdentity } from '@elliemae/pui-analytics-so';
+export { resetLrIdentity };
+export declare const getLogRocket: () => typeof LogRocket | undefined;
+/**
+ * Send user identification events to LogRocket.
+ * Also marks analytics-so as identified so its internal
+ * {@link ensureLrIdentified} does not re-identify.
+ * @param {string} userId user identifier
+ * @param {Record<string, any>} eventEx event meta data
+ */
+export declare const lrIdentify: (userId: string, eventEx: Record<string, any>) => void;
+/**
+ * Throttled LogRocket track call. Delegates to analytics-so's
+ * {@link lrTrackGuarded} which applies sliding-window throttle and
+ * property-count warnings. Only caller-supplied fields are sent — no
+ * ambient context — to conserve LogRocket's 2,000 total-property session
+ * budget.
+ *
+ * analytics-so automatically ensures the user is identified to LogRocket
+ * (from sessionStorage) before the first track call, covering session
+ * restore, token refresh, and late-loading LogRocket scenarios.
+ * @param {string} event event name
+ * @param {Record<string, any>} eventEx caller-supplied event properties only
+ */
+export declare const lrTrack: (event: string, eventEx?: Record<string, any>) => void;

package/dist/types/lib/utils/micro-frontend/app-bridge.d.ts

@@ -0,0 +1,15 @@
+import { CAppBridge } from '@elliemae/pui-app-bridge';
+import { ScriptingObjectTypes, Events } from '@elliemae/pui-scripting-object';
+import type { ScriptingObjects, EventListeners } from '@elliemae/microfe-common';
+/**
+ * Returns (and lazily initialises) the singleton {@link CAppBridge} instance.
+ *
+ * On first call the bridge is created, initialised with the already-loaded
+ * `appConfig` to avoid a duplicate HTTP fetch, and then {@link CAppBridge.warmUp}
+ * is called for every micro-app listed in `microFrontendApps` so that their
+ * manifests are pre-fetched in the background.
+ * @template AppObjects - Scripting-object type map for the host
+ * @template AppEvents - Event-listener type map for the host
+ * @returns The initialised app-bridge singleton
+ */
+export declare const getAppBridge: <AppObjects extends ScriptingObjects = Partial<ScriptingObjectTypes>, AppEvents extends EventListeners = Events>() => Promise<CAppBridge<Partial<ScriptingObjectTypes>, Events>>;

package/dist/types/lib/utils/micro-frontend/guest.d.ts

@@ -1,8 +1,13 @@
 import { DefaultTheme } from 'styled-components';
 import { History, To } from 'history';
 import type { IMicroAppGuest, IMicroAppHost, InitOptions, MountOptions } from '@elliemae/pui-micro-frontend-base';
+import { SSFHost } from '@elliemae/ssf-host';
+import { ScriptingObjectTypes, Events, ModuleParameters } from '@elliemae/pui-scripting-object';
+import { IMicroFEHost } from '@elliemae/pui-app-bridge';
+import type { ScriptingObjects, EventListeners, SubscribeParam, UnsubscribeParam, DispatchEventParam, EventOptions, AddScriptingObjectParams } from '@elliemae/microfe-common';
+import { SSFGuest } from '@elliemae/ssf-guest';
 import { JSONValue, MicroFrontEndLogger } from '../types.js';
-export interface GuestProps extends InitOptions {
+export interface GuestProps<AppObjects extends ScriptingObjects = Partial<ScriptingObjectTypes>, AppEvents extends EventListeners = Events> extends InitOptions<AppObjects, AppEvents> {
     prevState: JSONValue | null;
     history: History;
     theme: DefaultTheme;
@@ -18,8 +23,43 @@ interface ConstructorParams {
     onUnmount?: OnUnMountCallback;
     onGetRef?: OnGetRefCallback;
     history?: History;
+    ssfHostRef?: SSFHost<ScriptingObjectTypes, Events> | null;
+    /**
+     * true if the app prefers to use SSF V2 Guest from App SDK to communicate with host(optional, default: true)
+     */
+    useV2Guest?: boolean;
+    /**
+     * When true the guest drives its own lifecycle via initialize().
+     * Skips registering init/mount/unmount on the parent window —
+     * the bridge will not call these methods.
+     */
+    selfInitialize?: boolean;
 }
-export declare class CMicroAppGuest implements IMicroAppGuest {
+/**
+ * Micro-frontend guest application class (singleton).
+ * Manages communication between a guest micro-app and its host application.
+ * Supports both SSF (Shared Service Framework) and App Bridge communication methods.
+ * @template AppObjects - Type of custom scripting objects
+ * @template AppEvents - Type of custom event listeners
+ * @example
+ * ```typescript
+ * const guest = new CMicroAppGuest({
+ *   onInit: ({ history, theme, prevState }) => {
+ *     console.log('Guest initialized');
+ *   },
+ *   onMount: ({ container }) => {
+ *     // Render your React app
+ *     ReactDOM.render(<App />, container);
+ *   },
+ *   onUnmount: ({ container }) => {
+ *     // Cleanup
+ *     ReactDOM.unmountComponentAtNode(container);
+ *     return { savedState: 'some data' };
+ *   }
+ * });
+ * ```
+ */
+export declare class CMicroAppGuest<AppObjects extends ScriptingObjects = Partial<ScriptingObjectTypes>, AppEvents extends EventListeners = Events> implements IMicroAppGuest<AppObjects, AppEvents> {
     #private;
     private static instance;
     private readonly logger;
@@ -31,19 +71,59 @@ export declare class CMicroAppGuest implements IMicroAppGuest {
     private readonly onUnmount?;
     private readonly onGetRef?;
     private constructor();
-    static getInstance(params?: ConstructorParams): CMicroAppGuest;
+    static getInstance<AppObjects extends ScriptingObjects = Partial<ScriptingObjectTypes>, AppEvents extends EventListeners = Events>(params?: ConstructorParams): CMicroAppGuest<AppObjects, AppEvents>;
     static isInitialized(): boolean;
     static isHosted(): boolean;
-    getHost(): IMicroAppHost | undefined;
+    getHost(): IMicroAppHost<Partial<ScriptingObjectTypes>, Events> | IMicroFEHost<Partial<ScriptingObjectTypes>, Events> | SSFGuest<Partial<ScriptingObjectTypes>, Events> | undefined;
     getLogger(): MicroFrontEndLogger;
-    getProps(): GuestProps;
+    getObject<ObjectId extends Extract<keyof AppObjects, string>>(objectId: ObjectId): Promise<AppObjects[ObjectId] | null>;
+    /**
+     * subscribe to the scripting object event
+     * @param {SubscribeParam<EventId, AppEvents[EventId]>} params - the parameters for the subscription
+     * @param {string} params.soName - the name of the scripting object
+     * @param {string} params.eventName - the name of the event
+     * @param {Function} params.callback - the callback function to be called when the event is triggered
+     * @returns {void}
+     */
+    subscribe<EventId extends Extract<keyof AppEvents, string>>(params: SubscribeParam<EventId, AppEvents[EventId]>): string;
+    /**
+     * unsubscribe from the scripting object event
+     * @param params - parameters for the unsubscription
+     */
+    unsubscribe<EventId extends Extract<keyof AppEvents, string>>(params: UnsubscribeParam<EventId>): void;
+    getProps(): GuestProps<Partial<ScriptingObjectTypes>, Events>;
     private getSessionStorageItem;
-    private getSSFAdapter;
+    private findHost;
     get uuid(): string;
-    init(this: CMicroAppGuest, options: InitOptions): Promise<void>;
-    mount(this: CMicroAppGuest, options?: MountOptions): Promise<void>;
-    unmount(this: CMicroAppGuest, options: MountOptions): Promise<JSONValue>;
-    getRef<T>(this: CMicroAppGuest): T | null;
-    navigate(this: CMicroAppGuest, url: To, state?: any): void;
+    /**
+     * Guest-initiated lifecycle: discovers the host, pulls module parameters,
+     * and applies them. After this resolves the guest is ready to render.
+     * Requires selfInitialize: true in the constructor so the bridge
+     * skips calling init() / mount() on this guest.
+     * @returns module parameters provided by the host
+     */
+    initialize(): Promise<ModuleParameters>;
+    init(options: InitOptions<AppObjects, AppEvents>): Promise<void>;
+    mount(options?: MountOptions): Promise<void>;
+    unmount(options: MountOptions): Promise<JSONValue>;
+    getRef<T>(): T | null;
+    navigate(url: To, state?: any): void;
+    /**
+     * add scripting object for child microapp to use
+     * @param so - The scripting object to be added.
+     * @param params - Optional parameters for adding the scripting object.
+     */
+    addScriptingObject<SO extends AppObjects[keyof AppObjects]>(so: SO, params?: AddScriptingObjectParams): void;
+    /**
+     * Dispatches an event to the child microapp.
+     * @param {DispatchEventParam<EventId, Params, Options>} params - Event parameters.
+     * @returns {Promise<any[]>} A promise that resolves with the combined results of dispatched events.
+     */
+    dispatchEvent<EventId extends Extract<keyof AppEvents, string>, Params extends Parameters<AppEvents[EventId]>[0]['eventParams'], Options extends EventOptions>(params: DispatchEventParam<EventId, Params, Options>): Promise<void | unknown[]>;
+    /**
+     * removes scripting object from child microapp use
+     * @param objectId unique id of the scripting object
+     */
+    removeScriptingObject(objectId: Extract<keyof AppObjects, string>): void;
 }
 export {};