import type { Extension, GuestEmitter, NamedEvent, GuestApis } from "@adobe/uix-core";
import type { CapabilitySpec } from "./port.js";
import { Emitter } from "@adobe/uix-core";
import { Port, PortOptions } from "./port.js";
/**
 * Dictionary of {@link Port} objects by extension ID.
 * @public
 */
export type PortMap = Map<string, Port>;
/** @public */
export type HostEvent<Type extends string = string, Detail = Record<string, unknown>> = NamedEvent<Type, Detail & Record<string, unknown> & {
    host: Host;
}>;
/** @public */
type HostGuestEvent<Type extends string> = HostEvent<`guest${Type}`, {
    guest: Port;
}>;
/**
 * All guests requested by host have been loaded and connected.
 * @public
 */
export type HostEventLoadAllGuests = HostEvent<"loadallguests", {
    failed: Port[];
    loaded: Port[];
}>;
/**
 * Shared context has been set or updated; all guests receive this event too.
 * @public
 */
export type HostEventContextChange = HostEvent<"contextchange", {
    context: SharedContextValues;
}>;
/**
 * An error has occurred during loading or unloading of guests.
 * @public
 */
export type HostEventError = HostEvent<"error", {
    error: Error;
}>;
/** @public */
export type HostEvents = HostGuestEvent<"beforeload"> | HostGuestEvent<"load"> | HostGuestEvent<"beforeunload"> | HostGuestEvent<"unload"> | HostEvent<"beforeunload"> | HostEvent<"unload"> | HostEventLoadAllGuests | HostEventContextChange | HostEventError;
/** @public */
export type InstalledExtensions = Record<Extension["id"], Extension["url"] | Extension>;
/** @public */
export type ExtensionsArray = Array<[string, Extension | string]>;
/** @public */
export type ExtensionsProvider = () => Promise<InstalledExtensions>;
/**
 * Values for shared context. Must be a plain object, serializable to JSON.
 * @public
 */
export type SharedContextValues = Record<string, unknown>;
/** @public */
export interface HostConfig {
    /**
     * Human-readable "slug" name of the extensible area--often an entire app.
     * This string serves as a namespace for extension points within the area.
     */
    hostName: string;
    /**
     * A DOM element _outside_ of the React root. This is necessary to preserve
     * the lifetime of the iframes which are running extension objects; if they
     * live inside the React root, then React could unexpectedly re-render the
     * iframe tags themselves at any time, causing a reload of the frame.
     */
    runtimeContainer?: HTMLElement;
    /**
     * Copiously log lifecycle events.
     */
    debug?: boolean;
    /**
     * Default options to use for every guest Port.
     *
     * If `config.debug` is true, then the guest options will have `debug: true`
     * unless `debug: false` is explicitly passed in `guestOptions`.
     */
    guestOptions?: PortOptions;
    /**
     * A read-only dictionary of values that the host will supply to all the
     * guests.
     */
    sharedContext?: SharedContextValues;
    /**
     * Disables built-in metrics of UIX SDK
     */
    disableMetrics?: boolean;
}
/**
 * Callback to use to filter the list returned from {@link Host.(getLoadedGuests:2)}
 * @public
 */
type GuestFilter = (item: GuestEmitter) => boolean;
/**
 * Manager object for connecting to {@link @adobe/uix-guest#GuestServer |
 * GuestServers} and {@link @adobe/uix-guest#GuestUI | GuestUIs}, providing and
 * receiving their APIs, and providing them to the app for interacting with UI.
 *
 * @remarks
 * The Host object is the main connection manager for all UIX Guests.
 * Making an app extensible requires creating a Host object.
 *
 * The extensible app using the Hostis responsible for providing a list of
 * extension references to the Host object. Use {@link
 * createExtensionRegistryProvider} for that purpose. Once you have retrieved a
 * list of extensions available to the host app, pass it to {@link Host.load}.
 *
 * When a Host creates a Guest, it must create an `<iframe>` element to contain
 * the Guest's main {@link @adobe/uix-guest#GuestServer} runtime, which runs
 * invisibly in the background. To do this, the Host creates a hidden container
 * in the body of the document. It is a `<div>` element with the attribute
 * `data-uix-guest-container`. Loaded GuestServers will be injected into this
 * hidden element and removed as necessary. When {@link Host.unload} is called,
 * the Host removes the hidden container from the document after unloading.
 *
 * @public
 */
export declare class Host extends Emitter<HostEvents> {
    /**
     * {@inheritDoc HostEventLoadAllGuests}
     * @eventProperty
     */
    loadallguests: HostEventLoadAllGuests;
    /**
     * One guest has loaded.
     * @eventProperty
     */
    guestload: HostGuestEvent<"load">;
    /**
     * About to attempt to load and connect to a Guest.
     * @eventProperty
     */
    guestbeforeload: HostGuestEvent<"beforeload">;
    /**
     * About to unload a guest and remove its {@link @adobe/uix-guest#GuestServer}
     * instance as well as all its {@link @adobe/uix-guest#GuestUI} instances.
     * @eventProperty
     */
    guestbeforeunload: HostGuestEvent<"beforeunload">;
    /**
     * Unloaded a guest and removed its {@link @adobe/uix-guest#GuestServer}
     * instance as well as all its {@link @adobe/uix-guest#GuestUI} instances.
     * @eventProperty
     */
    guestunload: HostGuestEvent<"unload">;
    /**
     * {@inheritDoc HostEventContextChange}
     * @eventProperty
     */
    contextchange: HostEventContextChange;
    /**
     * {@inheritDoc HostEventError}
     * @eventProperty
     */
    error: HostEventError;
    private static containerStyle;
    private lastExtenstionList;
    /**
     * Unique string identifying the Host object.
     */
    hostName: string;
    /**
     * `true` if any extension in {@link Host.guests} has created a {@link
     * @adobe/uix-guest#GuestServer}, but the Guest has not yet loaded.
     */
    loading: boolean;
    /**
     * A Map of of the loaded guests.
     */
    guests: PortMap;
    private cachedCapabilityLists;
    private runtimeContainer;
    private guestOptions;
    private logger;
    private sharedContext;
    constructor(config: HostConfig);
    /**
     * Return all loaded guests.
     */
    getLoadedGuests<T = unknown>(): Port<T>[];
    /**
     * Return loaded guests which satisfy the passed test function.
     */
    getLoadedGuests<T = unknown>(filter: GuestFilter): Port<T>[];
    /**
     * Return loaded guests which expose the provided {@link CapabilitySpec}.
     */
    getLoadedGuests<Apis extends GuestApis>(capabilities: CapabilitySpec<Apis>): Port<GuestApis>[];
    /**
     * Set the object of shared values that all Guests can access via {@link @adobe/uix-guest#GuestServer.sharedContext}.
     * This overwrites any previous object.
     *
     * @example Exposes `authToken` to all Guests. Guests can call `this.sharedContext.get('authToken')` to retrieve this value.
     * ```javascript
     * host.shareContext({
     *   authToken: '82ba19b'
     * });
     * ```
     *
     * @example Overwrites the previous sharedContext, deleting `authToken` and providing `secret` and `auth` instead.
     * ```javascript
     * host.shareContext({
     *   secret: 'squirrel',
     *   auth: false
     * });
     * ```
     */
    shareContext(context: SharedContextValues): void;
    /**
     * Update the object of shared values that all Guests can access via {@link
     * @adobe/uix-guest#GuestServer.sharedContext}. This method takes a callback
     * which receives the previous context and may return an entirely new context,
     * or new values merged with the old context.
     *
     * @remarks This callback pattern allows the shared context values to be
     * mutable while the internal context object references are immutable, which
     * is important for synchronizing. with guests.
     *
     * @example Overwrites a context object based on the previous one.
     * ```javascript
     * host.shareContext(oldContext => ({
     *   counter: oldContext.counter + 1
     * }))
     * ```
     *
     * @example Updates a context while preserving other existing values.
     * ```javascript
     * host.shareContext(oldContext => ({
     *   ...oldContext,
     *   counter: oldContext.counter + 1
     * }))
     * ```
     */
    shareContext(setter: (context: SharedContextValues) => SharedContextValues): void;
    shareContext(setter: (context: SharedContextValues) => SharedContextValues): void;
    /**
     * Load extension into host application from provided extension description.
     * Returned promise resolves when all extensions are loaded and registered.
     *
     * @param extensions - List of extension descriptors. Normally, the Host should receive this value from an {@link ExtensionsProvider}.
     * @param options - Custom options to be used as defaults for each {@link Port} object created for each guest.
     * @returns Promise which resolves when all guests have been loaded.
     */
    load(extensions: InstalledExtensions, options?: PortOptions): Promise<void>;
    addLoadsNewGuests(extensions: InstalledExtensions, options?: PortOptions): Promise<void>;
    /**
     * Unload and remove a specific extension by its ID.
     */
    removeGuest(id: string, extension: Extension): Promise<void>;
    /**
     * Unload all extensions and remove their frames/workers. Use this to unmount
     * a UI or when switching to a different extensible UI.
     */
    unload(): Promise<void>;
    private createRuntimeContainer;
    private loadOneGuest;
    private getLoadedGuestsWith;
}
export {};
//# sourceMappingURL=host.d.ts.map