@ama-mfe/ng-utils 13.0.0-next.3 → 13.0.0-next.31

package/index.d.ts

@@ -1,6 +1,738 @@
+import * as i0 from '@angular/core';
+import { PipeTransform } from '@angular/core';
+import { VersionedMessage, RoutedMessage, PeerConnectionOptions } from '@amadeus-it-group/microfrontends';
+import { MessagePeerServiceType, MessagePeerConfig } from '@amadeus-it-group/microfrontends-angular';
+export { MessagePeerConfig as ConnectionConfig, MessagePeerService as ConnectionService } from '@amadeus-it-group/microfrontends-angular';
+import { ResizeMessage, ResizeV1_0, NavigationMessage, NavigationV1_0, ThemeMessage, ThemeV1_0, ThemeStructure } from '@ama-mfe/messages';
+import * as rxjs from 'rxjs';
+import { SafeResourceUrl } from '@angular/platform-browser';
+import { Logger } from '@o3r/logger';
+
+/** the error message type */
+declare const ERROR_MESSAGE_TYPE = "error";
 /**
- * Generated bundle index. Do not edit.
+ * The possible reasons for an error.
  */
-/// <amd-module name="@ama-mfe/ng-utils" />
-export * from './public_api';
-//# sourceMappingURL=ama-mfe-ng-utils.d.ts.map
+type ErrorReason = 'unknown_type' | 'version_mismatch' | 'internal_error';
+/**
+ * The content of an error message.
+ * @template S - The type of the source message.
+ */
+interface ErrorContent<S extends VersionedMessage = VersionedMessage> {
+    /** The reason for the error */
+    reason: ErrorReason;
+    /** The source message that caused the error */
+    source: S;
+}
+
+/** An error message with the version 1.0 */
+interface ErrorMessageV1_0<S extends VersionedMessage = VersionedMessage> extends VersionedMessage, ErrorContent<S> {
+    /** @inheritdoc */
+    type: 'error';
+    /** @inheritdoc */
+    version: '1.0';
+}
+
+/** The versions available for error messages */
+type ErrorMessage = ErrorMessageV1_0;
+
+/**
+ * Helper function to send an error message by the given endpoint (peer)
+ * @param peer The endpoint sending the message
+ * @param content the content of the error message to be sent
+ */
+declare const sendError: (peer: MessagePeerServiceType<any>, content: ErrorContent) => void;
+/**
+ * Check if the given message is of type error and the error reson is present too
+ * @param message the message to be checked
+ */
+declare const isErrorMessage: (message: any) => message is VersionedMessage & {
+    type: typeof ERROR_MESSAGE_TYPE;
+} & ErrorContent;
+
+/**
+ * Gets the available consumers and formats them into a {@see DeclareMessages} object.
+ * @param consumers - The list of registered message consumers.
+ * @returns The formatted DeclareMessages object.
+ */
+declare const getAvailableConsumers: (consumers: BasicMessageConsumer[]) => {
+    type: "declare_messages";
+    version: "1.0";
+    messages: {
+        type: string;
+        version: string;
+    }[];
+};
+
+/**
+ * Use the message payload to execute an action based on message type
+ * @param message message to consume
+ */
+type MessageCallback<T extends VersionedMessage> = (message: RoutedMessage<T>) => void | Promise<void>;
+/**
+ * Description of the accepted messages versions and their callbacks for a given message type
+ */
+interface MessageVersions<T extends VersionedMessage> {
+    /** The message callback coresponding to the version */
+    [version: string]: MessageCallback<T>;
+}
+/** Description for the base message consumer */
+interface BasicMessageConsumer<T extends VersionedMessage = VersionedMessage> {
+    /** Contains the message type */
+    type: T['type'];
+    /** A map of messages versions and their callbacks */
+    supportedVersions: Record<string, MessageCallback<any>>;
+}
+/** The consumer of a given message type */
+interface MessageConsumer<T extends VersionedMessage = VersionedMessage> extends BasicMessageConsumer {
+    /** The message type which will be handled */
+    type: T['type'];
+    /** The map of functions which will be executed for each supported version */
+    supportedVersions: {
+        [V in T['version']]: MessageCallback<T & {
+            version: V;
+        }>;
+    };
+    /** Prepare the registration of the consumer */
+    start(): void;
+    /** Unregister the consumer */
+    stop(): void;
+}
+/**
+ * Definition of a message producer and which types of messages are produced
+ */
+interface MessageProducer<T extends VersionedMessage = VersionedMessage> {
+    /** The types of the produced message */
+    types: T['type'] | T['type'][];
+    /**
+     * The producer should handle an error in case that it has produced a message which cannot be consumed by other peers
+     * @param message the error message received from a peer when the message sent previously has raised an error
+     */
+    handleError(message: ErrorContent<T>): void | Promise<void>;
+}
+
+declare class ConsumerManagerService {
+    private readonly messageService;
+    private readonly producerManagerService;
+    private readonly registeredConsumers;
+    private readonly logger;
+    /** The list of registered consumers */
+    readonly consumers: i0.Signal<BasicMessageConsumer<VersionedMessage>[]>;
+    constructor();
+    /**
+     * Consume a received message
+     * @param message the received message body
+     */
+    private consumeMessage;
+    /**
+     * Call the registered message callback(s) to consume the given message
+     * Handle error messages of internal communication protocol messages
+     * @param message message to consume
+     */
+    private consumeAdditionalMessage;
+    /**
+     * Register a message consumer
+     * @param consumer an instance of message consumer
+     */
+    register(consumer: BasicMessageConsumer): void;
+    /**
+     * Unregister a message consumer
+     * @param consumer an instance of message consumer
+     */
+    unregister(consumer: BasicMessageConsumer): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ConsumerManagerService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<ConsumerManagerService>;
+}
+
+declare class ProducerManagerService {
+    private readonly registeredProducers;
+    /** Get the list of registered producers of messages. The list will contain unique elements */
+    get producers(): MessageProducer<VersionedMessage>[];
+    /**
+     * Register a producer of a message
+     * @param producer The instance of the message producer
+     */
+    register(producer: MessageProducer): void;
+    /**
+     * Unregister a producer of a message
+     * @param producer The instance of the message producer
+     */
+    unregister(producer: MessageProducer): void;
+    /**
+     * Handles the received error message for the given message type by invoking the appropriate producer handlers.
+     * @template T - The type of the message, extending from Message.
+     * @param message - The error message to handle.
+     * @returns - A promise that resolves to true if the error was handled by at least one handler, false otherwise.
+     */
+    dispatchError<T extends VersionedMessage = VersionedMessage>(message: ErrorContent<T>): Promise<boolean>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ProducerManagerService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<ProducerManagerService>;
+}
+
+/**
+ * Method to call in the constructor of a producer
+ * @note should be used in injection context
+ * @param producer
+ */
+declare const registerProducer: (producer: MessageProducer) => void;
+/**
+ * Method to call in the constructor of a consumer
+ * @note should be used in injection context
+ * @param consumer
+ */
+declare const registerConsumer: (consumer: MessageConsumer) => void;
+
+/**
+ * This service listens for resize messages and updates the height of elements based on the received messages.
+ */
+declare class ResizeConsumerService implements MessageConsumer<ResizeMessage> {
+    private readonly newHeight;
+    /**
+     * A readonly signal that provides the new height information from the channel.
+     */
+    readonly newHeightFromChannel: i0.Signal<{
+        height: number;
+        channelId: string;
+    } | undefined>;
+    /**
+     * The type of messages this service handles ('resize').
+     */
+    readonly type = "resize";
+    /**
+     * The supported versions of resize messages and their handlers.
+     */
+    supportedVersions: {
+        /**
+         * Use the message paylod to compute a new height and emit it via the public signal
+         * @param message message to consume
+         */
+        '1.0': (message: RoutedMessage<ResizeV1_0>) => void;
+    };
+    private readonly consumerManagerService;
+    constructor();
+    /**
+     * Starts the resize handler service by registering it into the consumer manager service.
+     */
+    start(): void;
+    /**
+     * Stops the resize handler service by unregistering it from the consumer manager service.
+     */
+    stop(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ResizeConsumerService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<ResizeConsumerService>;
+}
+
+/**
+ * This service observe changes in the document's body height.
+ * When the height changes, it sends a resize message with the new height, to the connected peers
+ */
+declare class ResizeService implements MessageProducer<ResizeMessage> {
+    private actualHeight?;
+    private readonly messageService;
+    private resizeObserver?;
+    /**
+     * @inheritdoc
+     */
+    readonly types = "resize";
+    constructor();
+    /**
+     * @inheritdoc
+     */
+    handleError(message: ErrorContent<ResizeMessage>): void;
+    /**
+     * This method sets up a `ResizeObserver` to observe changes in the document's body height.
+     * When the height changes, it sends a resize message with the new height, to the connected peers
+     */
+    startResizeObserver(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ResizeService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<ResizeService>;
+}
+
+/**
+ * A directive that adjusts the height of an element based on resize messages from a specified channel.
+ */
+declare class ScalableDirective {
+    /**
+     * The connection ID for the element, used as channel id backup
+     */
+    connect: i0.InputSignal<string | undefined>;
+    /**
+     * The channel id
+     */
+    scalable: i0.InputSignal<string | undefined>;
+    private readonly resizeHandler;
+    /**
+     * This signal checks if the current channel requesting the resize matches the channel ID from the resize handler.
+     * If they match, it returns the new height information; otherwise, it returns undefined.
+     */
+    private readonly newHeightFromChannel;
+    constructor();
+    static ɵfac: i0.ɵɵFactoryDeclaration<ScalableDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<ScalableDirective, "[scalable]", never, { "connect": { "alias": "connect"; "required": false; "isSignal": true; }; "scalable": { "alias": "scalable"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+/**
+ * A service that handles navigation messages and routing.
+ *
+ * This service listens for navigation messages and updates the router state accordingly.
+ */
+declare class NavigationConsumerService implements MessageConsumer<NavigationMessage> {
+    private readonly router;
+    private readonly activeRoute;
+    private readonly requestedUrl;
+    /**
+     * An observable that emits the requested URL and optional channel ID.
+     */
+    readonly requestedUrl$: rxjs.Observable<{
+        url: string;
+        channelId?: string;
+    }>;
+    /**
+     * The type of messages this service handles.
+     */
+    readonly type = "navigation";
+    /**
+     * @inheritdoc
+     */
+    readonly supportedVersions: {
+        /**
+         * Use the message paylod to compute a new url and emit it via the public subject
+         * Additionally navigate to the new url
+         * @param message message to consume
+         */
+        '1.0': (message: RoutedMessage<NavigationV1_0>) => void;
+    };
+    private readonly consumerManagerService;
+    constructor();
+    /**
+     * Parses a URL and returns an object containing the paths and query parameters.
+     * @param url - The URL to parse.
+     * @returns An object containing the paths and query parameters.
+     */
+    private parseUrl;
+    /**
+     * Navigates to the specified URL.
+     * @param url - The URL to navigate to.
+     */
+    private navigate;
+    /**
+     * @inheritdoc
+     */
+    start(): void;
+    /**
+     * @inheritdoc
+     */
+    stop(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<NavigationConsumerService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<NavigationConsumerService>;
+}
+
+declare class RouteMemorizeDirective {
+    /**
+     * Whether to memorize the route.
+     * Default is true.
+     */
+    memorizeRoute: i0.InputSignal<boolean | "" | undefined>;
+    /**
+     * The ID used to memorize the route.
+     */
+    memorizeRouteId: i0.InputSignal<string | undefined>;
+    /**
+     * The maximum age for memorizing the route.
+     * Default is 0.
+     */
+    memorizeMaxAge: i0.InputSignal<number>;
+    /**
+     * The maximum age for memorizing the route, used as a fallback.
+     * Default is 0.
+     */
+    memorizeRouteMaxAge: i0.InputSignal<number>;
+    /**
+     * The connection ID for the iframe where the actual directive is applied.
+     */
+    connect: i0.InputSignal<string | undefined>;
+    private readonly maxAge;
+    constructor();
+    static ɵfac: i0.ɵɵFactoryDeclaration<RouteMemorizeDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<RouteMemorizeDirective, "iframe[memorizeRoute]", never, { "memorizeRoute": { "alias": "memorizeRoute"; "required": false; "isSignal": true; }; "memorizeRouteId": { "alias": "memorizeRouteId"; "required": false; "isSignal": true; }; "memorizeMaxAge": { "alias": "memorizeMaxAge"; "required": false; "isSignal": true; }; "memorizeRouteMaxAge": { "alias": "memorizeRouteMaxAge"; "required": false; "isSignal": true; }; "connect": { "alias": "connect"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+/**
+ * This service allows routes to be memorized with an optional lifetime and provides methods to retrieve and manage these routes.
+ */
+declare class RouteMemorizeService {
+    private readonly routeTimers;
+    /** All memorized routes */
+    readonly routeStack: {
+        [x: string]: string;
+    };
+    /**
+     * Memorizes a route for a given channel ID with an optional lifetime.
+     * @param channelId - The ID of the channel to memorize the route for.
+     * @param url - The URL of the route to memorize.
+     * @param liveTime - The optional lifetime of the memorized route in milliseconds. If provided, the route will be removed after this time.
+     */
+    memorizeRoute(channelId: string, url: string, liveTime?: number): void;
+    /**
+     * Retrieves the memorized route for a given channel ID.
+     * @param channelId - The ID of the channel to retrieve the memorized route for.
+     * @returns The memorized route URL or undefined if no route is memorized for the given channel ID.
+     */
+    getRoute(channelId: string): string | undefined;
+    static ɵfac: i0.ɵɵFactoryDeclaration<RouteMemorizeService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<RouteMemorizeService>;
+}
+
+/** Options for the routing handling in case of navigation producer message  */
+interface RoutingServiceOptions {
+    /**
+     * Whether to handle only sub-routes.
+     * If true, the routing service will handle only sub-routes.
+     * Default is false.
+     */
+    subRouteOnly?: boolean;
+}
+/**
+ * A service that keeps in sync Router navigation and navigation messages.
+ *
+ * - listens to Router events and sends navigation messages
+ * - handles incoming navigation messages and triggers Router navigation
+ */
+declare class RoutingService implements MessageProducer<NavigationMessage>, MessageConsumer<NavigationMessage> {
+    private readonly router;
+    private readonly activatedRoute;
+    private readonly messageService;
+    private readonly logger;
+    /**
+     * @inheritdoc
+     */
+    readonly types = "navigation";
+    /**
+     * @inheritdoc
+     */
+    readonly type = "navigation";
+    /**
+     * Use the message payload to navigate to the specified URL.
+     * @param message message to consume
+     */
+    readonly supportedVersions: {
+        '1.0': (message: RoutedMessage<any>) => Promise<void>;
+    };
+    constructor();
+    /**
+     * @inheritdoc
+     */
+    start(): void;
+    /**
+     * @inheritdoc
+     */
+    stop(): void;
+    /**
+     * @inheritdoc
+     */
+    handleError(message: ErrorContent<NavigationV1_0>): void;
+    /**
+     * Handles embedded routing by listening to router events and sending navigation messages to the connected endpoints.
+     * It can be a parent window or another iframe
+     * @note - This method has to be called in an injection context
+     * @param options - Optional parameters to control the routing behavior {@see RoutingServiceOptions}.
+     */
+    handleEmbeddedRouting(options?: RoutingServiceOptions): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<RoutingService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<RoutingService>;
+}
+
+/**
+ * Options for restoring a route with optional query parameters and memory channel ID.
+ */
+interface RestoreRouteOptions {
+    /**
+     * Whether to propagate query parameters from the top window to the module URL.
+     */
+    propagateQueryParams?: boolean;
+    /**
+     * Whether to override existing query parameters in the module URL with those from the top window.
+     */
+    overrideQueryParams?: boolean;
+    /**
+     * The memory channel ID used to retrieve the memorized route.
+     * If provided, the memorized route associated with this ID will be used.
+     */
+    memoryChannelId?: string;
+}
+/**
+ * A pipe that restores a route with optional query parameters and memory channel ID.
+ *
+ * This pipe is used to transform a URL or SafeResourceUrl by appending query parameters
+ * and adjusting the pathname based on the current active route and memorized route.
+ */
+declare class RestoreRoute implements PipeTransform {
+    private readonly activeRoute;
+    private readonly domSanitizer;
+    private readonly routeMemorizeService;
+    /**
+     * Transforms the given URL or SafeResourceUrl by appending query parameters and adjusting the pathname.
+     * @param url - The URL or SafeResourceUrl to be transformed.
+     * @param options - Optional parameters to control the transformation. {@see RestoreRouteOptions}
+     * @returns - The transformed SafeResourceUrl or undefined if the input URL is invalid.
+     */
+    transform(url: string, options?: Partial<RestoreRouteOptions>): string;
+    transform(url: SafeResourceUrl, options?: Partial<RestoreRouteOptions>): SafeResourceUrl;
+    transform(url: undefined, options?: Partial<RestoreRouteOptions>): undefined;
+    static ɵfac: i0.ɵɵFactoryDeclaration<RestoreRoute, never>;
+    static ɵpipe: i0.ɵɵPipeDeclaration<RestoreRoute, "restoreRoute", true>;
+}
+
+/**
+ * A pipe that applies the current theme from a theme manager service, to a given URL or SafeResourceUrl, as query param
+ */
+declare class ApplyTheme implements PipeTransform {
+    private readonly themeManagerService;
+    private readonly domSanitizer;
+    /**
+     * Transforms the given URL or SafeResourceUrl by appending the current theme value as a query parameter.
+     * @param url - The URL or SafeResourceUrl to be transformed.
+     * @returns The transformed SafeResourceUrl or undefined if the input URL is invalid.
+     */
+    transform(url: string): string;
+    transform(url: SafeResourceUrl): SafeResourceUrl;
+    transform(url: undefined): undefined;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ApplyTheme, never>;
+    static ɵpipe: i0.ɵɵPipeDeclaration<ApplyTheme, "applyTheme", true>;
+}
+
+/**
+ * A service that handles theme messages and applies the received theme.
+ */
+declare class ThemeConsumerService implements MessageConsumer<ThemeMessage> {
+    private readonly domSanitizer;
+    private readonly consumerManagerService;
+    private readonly logger;
+    /**
+     * The type of messages this service handles ('theme').
+     */
+    readonly type = "theme";
+    /**
+     * The supported versions of theme messages and their handlers.
+     */
+    readonly supportedVersions: {
+        /**
+         * Use the message paylod to get the theme and apply it
+         * @param message message to consume
+         */
+        '1.0': (message: RoutedMessage<ThemeV1_0>) => Promise<void>;
+    };
+    constructor();
+    /**
+     * Starts the theme handler service by registering it into the consumer manager service.
+     */
+    start(): void;
+    /**
+     * Stops the theme handler service by unregistering it from the consumer manager service.
+     */
+    stop(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ThemeConsumerService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<ThemeConsumerService>;
+}
+
+/** Default suffix for an url containing a theme css file */
+declare const THEME_URL_SUFFIX = "-theme.css";
+/** Default name for the query parameter containing the theme name */
+declare const THEME_QUERY_PARAM_NAME = "theme";
+/** Options and context for Style helpers */
+interface StyleHelperOptions {
+    /**
+     * Logger to reporter the logs
+     */
+    logger?: Logger;
+}
+/**
+ * Fetches a CSS document and returns the content as a string.
+ * @param cssPath - The path to download the CSS.
+ * @param options Options and context for Style helpers
+ * @returns The content of the CSS document as a string, empty string if the fetch fails.
+ */
+declare function getStyle(cssPath: string, options?: StyleHelperOptions): Promise<string>;
+/**
+ * Applies the given CSS theme as a stylesheet.
+ * @param themeValue - CSS as text containing a theme definition.
+ * @param cleanPrevious - Whether to remove previously applied stylesheets if no themeValue provided. Default is true.
+ */
+declare function applyTheme(themeValue?: string, cleanPrevious?: boolean): void;
+/**
+ * Download the application additional theme
+ * @param theme Name of the theme to download from the current application
+ * @param options Options and context for Style helpers
+ */
+declare function downloadApplicationThemeCss(theme: string, options?: StyleHelperOptions): Promise<string>;
+/**
+ * Applies the initial theme based on the URL query parameters.
+ *
+ * This function fetches the CSS theme specified in the URL query parameters and applies it as a stylesheet.
+ * If a referrer is present, it also attempts to fetch and apply the theme from the referrer's URL.
+ * @param options Options and context for Style helpers
+ */
+declare function applyInitialTheme(options?: StyleHelperOptions): Promise<PromiseSettledResult<void>[] | undefined>;
+
+/**
+ * This service exposing the current theme signal
+ */
+declare class ThemeProducerService implements MessageProducer<ThemeMessage> {
+    private readonly messageService;
+    private readonly logger;
+    private previousTheme;
+    private readonly currentThemeSelection;
+    /** Current selected theme signal */
+    readonly currentTheme: i0.Signal<ThemeStructure | undefined>;
+    /**
+     * The type of messages this service handles ('theme').
+     */
+    readonly types = "theme";
+    constructor();
+    /**
+     * Changes the current theme to the specified theme name.
+     * @param themeName - The name of the theme to change to.
+     */
+    changeTheme(themeName?: string): Promise<void>;
+    /**
+     * Reverts to the previous theme.
+     */
+    revertToPreviousTheme(): void;
+    /**
+     * @inheritdoc
+     */
+    handleError(message: ErrorContent<ThemeV1_0>): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ThemeProducerService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<ThemeProducerService>;
+}
+
+declare class ConnectDirective {
+    /**
+     * The connection ID required for the message peer service.
+     */
+    connect: i0.InputSignal<string>;
+    /**
+     * The sanitized source URL for the iframe.
+     */
+    src: i0.InputSignal<SafeResourceUrl | undefined>;
+    /**
+     * Binds the `src` attribute of the iframe to the sanitized source URL.
+     */
+    get srcAttr(): SafeResourceUrl | undefined;
+    private readonly messageService;
+    private readonly domSanitizer;
+    private readonly elRef;
+    private readonly clientOrigin;
+    constructor();
+    static ɵfac: i0.ɵɵFactoryDeclaration<ConnectDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<ConnectDirective, "iframe[connect]", never, { "connect": { "alias": "connect"; "required": true; "isSignal": true; }; "src": { "alias": "src"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+/** Options to configure the connection inside the communication protocol */
+interface ConnectionConfigOptions extends Omit<MessagePeerConfig, 'id'> {
+    /** @inheritdoc */
+    id?: string;
+    /** Logger used to gather information */
+    logger?: Logger;
+}
+/**
+ * Provide the communication protocol connection configuration
+ * @param connectionConfigOptions The identifier of the application in the communication protocol ecosystem plus the types of messages able to exchange and a logger object
+ */
+declare function provideConnection(connectionConfigOptions?: ConnectionConfigOptions): i0.EnvironmentProviders;
+
+/**
+ * A constant array of known message types and their versions.
+ */
+declare const KNOWN_MESSAGES: [{
+    readonly type: "error";
+    readonly version: "1.0";
+}];
+/**
+ * Returns the default options for starting a client endpoint peer connection.
+ * As `origin`, it will take the hostURL from {@link getHostInfo} and the `window` will be the parent window.
+ */
+declare function getDefaultClientEndpointStartOptions(): PeerConnectionOptions;
+/**
+ * Return `true` if embedded inside an iframe, `false` otherwise
+ */
+declare function isEmbedded(): boolean;
+
+/**
+ * Search parameter to add to the URL when embedding an iframe containing the URL of the host.
+ * This is needed to support Firefox (on which {@link https://developer.mozilla.org/docs/Web/API/Location/ancestorOrigins | location.ancestorOrigins} is not currently supported)
+ * in case of redirection inside the iframe.
+ */
+declare const MFE_HOST_URL_PARAM = "ama-mfe-host-url";
+/**
+ * Search parameter to add to the URL to let a module know on which application it's embedded
+ */
+declare const MFE_HOST_APPLICATION_ID_PARAM = "ama-mfe-host-app-id";
+/**
+ * Search parameter to add to the URL to identify the application in the network of peers in the communication protocol
+ */
+declare const MFE_MODULE_APPLICATION_ID_PARAM = "ama-mfe-module-app-id";
+/** The list of query parameters which can be set by the host */
+declare const hostQueryParams: string[];
+/**
+ * Information set up at host level to use in embedded context
+ */
+interface MFEHostInformation {
+    /**
+     * URL of the host application
+     */
+    hostURL?: string;
+    /**
+     * ID of the host application
+     */
+    hostApplicationId?: string;
+    /**
+     * ID of the module to embed defined at host level
+     */
+    moduleApplicationId?: string;
+}
+/**
+ * Gather the host information from the url parameters
+ * The host url will use the first found among:
+ * - look for the search parameter {@link MFE_HOST_URL_PARAM} in the URL of the iframe
+ * - use the first item in `location.ancestorOrigins` (currently not supported on Firefox)
+ * - use `document.referrer` (will only work if called before any redirection in the iframe)
+ * The host application ID is taken from the search parameter {@link MFE_HOST_APPLICATION_ID_PARAM} in the URL of the iframe
+ * The module application ID is taken from the search parameter {@link MFE_APPLICATION_ID_PARAM} in the URL of the iframe
+ */
+declare function getHostInfo(): MFEHostInformation;
+/**
+ * Gather the host information from the url parameters and handle the persistence in session storage.
+ */
+declare function persistHostInfo(): void;
+
+/**
+ * A pipe that adds the host information in the URL of an iframe,
+ */
+declare class HostInfoPipe implements PipeTransform {
+    private readonly domSanitizer;
+    /**
+     * Transforms the given URL or SafeResourceUrl by appending query parameters.
+     * @param url - The URL or SafeResourceUrl to be transformed.
+     * @param options - hostId and moduleId
+     * @returns - The transformed SafeResourceUrl or undefined if the input URL is invalid.
+     */
+    transform(url: string, options: {
+        hostId: string;
+        moduleId?: string;
+    }): string;
+    transform(url: SafeResourceUrl, options: {
+        hostId: string;
+        moduleId?: string;
+    }): SafeResourceUrl;
+    transform(url: undefined, options: {
+        hostId: string;
+        moduleId?: string;
+    }): undefined;
+    static ɵfac: i0.ɵɵFactoryDeclaration<HostInfoPipe, never>;
+    static ɵpipe: i0.ɵɵPipeDeclaration<HostInfoPipe, "hostInfo", true>;
+}
+
+export { ApplyTheme, ConnectDirective, ConsumerManagerService, ERROR_MESSAGE_TYPE, HostInfoPipe, KNOWN_MESSAGES, MFE_HOST_APPLICATION_ID_PARAM, MFE_HOST_URL_PARAM, MFE_MODULE_APPLICATION_ID_PARAM, NavigationConsumerService, ProducerManagerService, ResizeConsumerService, ResizeService, RestoreRoute, RouteMemorizeDirective, RouteMemorizeService, RoutingService, ScalableDirective, THEME_QUERY_PARAM_NAME, THEME_URL_SUFFIX, ThemeConsumerService, ThemeProducerService, applyInitialTheme, applyTheme, downloadApplicationThemeCss, getAvailableConsumers, getDefaultClientEndpointStartOptions, getHostInfo, getStyle, hostQueryParams, isEmbedded, isErrorMessage, persistHostInfo, provideConnection, registerConsumer, registerProducer, sendError };
+export type { BasicMessageConsumer, ConnectionConfigOptions, ErrorContent, ErrorMessage, ErrorMessageV1_0, ErrorReason, MFEHostInformation, MessageCallback, MessageConsumer, MessageProducer, MessageVersions, RestoreRouteOptions, RoutingServiceOptions, StyleHelperOptions };
+//# sourceMappingURL=index.d.ts.map