@openfin/fdc3-api 36.78.8

package/out/fdc3-api.d.ts

@@ -0,0 +1,1247 @@
+/// <reference types="node" />
+
+import { EventEmitter } from 'events';
+
+declare type ApiCall<Request, Response> = {
+    request: Request;
+    response: Response;
+};
+
+declare interface AuthorizationPayload {
+    token: string;
+    file: string;
+}
+
+declare class Base {
+    /**
+     * @internal
+     */
+    wire: Transport;
+    /**
+     * @internal
+     */
+    constructor(wire: Transport);
+    protected get fin(): OpenFin.Fin<OpenFin.EntityType>;
+    /**
+     * Provides access to the OpenFin representation of the current code context (usually a document
+     * such as a {@link OpenFin.View} or {@link OpenFin.Window}), as well as to the current `Interop` context.
+     *
+     * Useful for debugging in the devtools console, where this will intelligently type itself based
+     * on the context in which the devtools panel was opened.
+     */
+    get me(): Identity;
+    protected isNodeEnvironment: () => boolean;
+    protected isOpenFinEnvironment: () => boolean;
+    protected isBrowserEnvironment: () => boolean;
+}
+
+declare type BaseConfig = {
+    uuid?: string;
+    address?: string;
+    name?: string;
+    nonPersistent?: boolean;
+    runtimeClient?: boolean;
+    licenseKey?: string;
+    client?: any;
+    manifestUrl?: string;
+    startupApp?: any;
+    lrsUrl?: string;
+    assetsUrl?: string;
+    devToolsPort?: number;
+    installerUI?: boolean;
+    runtime?: RuntimeConfig;
+    services?: ServiceConfig[];
+    appAssets?: [
+        {
+        src: string;
+        alias: string;
+        target: string;
+        version: string;
+        args: string;
+    }
+    ];
+    customItems?: [any];
+    timeout?: number;
+};
+
+declare interface ChildContentOptions {
+    options: any;
+    entityType: EntityType_3;
+}
+
+declare type ConfigWithRuntime = BaseConfig & {
+    runtime: RuntimeConfig;
+};
+
+declare type ConfigWithUuid = BaseConfig & {
+    uuid: string;
+};
+
+declare type DataChannelReadyState = RTCDataChannel['readyState'];
+
+declare type EmitterAccessor = string[];
+
+declare class EmitterMap {
+    private storage;
+    constructor();
+    private hashKeys;
+    getOrCreate(keys: EmitterAccessor): EventEmitter;
+    has(keys: EmitterAccessor): boolean;
+    delete(keys: EmitterAccessor): boolean;
+}
+
+declare type EntityType = OpenFin.EntityType;
+
+declare type EntityType_2 = OpenFin.EntityType;
+
+declare type EntityType_3 = OpenFin.EntityType;
+
+declare type EntityTypeHelpers<T extends EntityType_2> = T extends 'view' ? {
+    isView: true;
+    isWindow: false;
+    isExternal: false;
+    isFrame: false;
+} : T extends 'window' ? {
+    isView: false;
+    isWindow: true;
+    isExternal: false;
+    isFrame: false;
+} : T extends 'iframe' ? {
+    isView: false;
+    isWindow: false;
+    isExternal: false;
+    isFrame: true;
+} : T extends 'external connection' ? {
+    isView: false;
+    isWindow: false;
+    isExternal: true;
+    isFrame: false;
+} : T extends 'unknown' ? {
+    isView: false;
+    isWindow: false;
+    isExternal: false;
+    isFrame: false;
+} : never;
+
+declare interface Environment {
+    initLayoutManager(fin: OpenFin.Fin<OpenFin.EntityType>, wire: Transport, options: OpenFin.InitLayoutOptions): Promise<OpenFin.LayoutManager<OpenFin.LayoutSnapshot>>;
+    createLayout(layoutManager: OpenFin.LayoutManager<OpenFin.LayoutSnapshot>, options: OpenFin.CreateLayoutOptions): Promise<void>;
+    destroyLayout(layoutManager: OpenFin.LayoutManager<OpenFin.LayoutSnapshot>, layoutIdentity: OpenFin.LayoutIdentity): Promise<void>;
+    resolveLayout(layoutManager: OpenFin.LayoutManager<OpenFin.LayoutSnapshot>, layoutIdentity: OpenFin.LayoutIdentity): Promise<any>;
+    initPlatform(fin: OpenFin.Fin<OpenFin.EntityType>, ...args: Parameters<OpenFin.Fin['Platform']['init']>): ReturnType<OpenFin.Fin['Platform']['init']>;
+    observeBounds(element: Element, onChange: (bounds: DOMRect) => Promise<void> | void): () => void;
+    writeToken(path: string, token: string): Promise<string>;
+    retrievePort(config: NewConnectConfig): Promise<number>;
+    getNextMessageId(): any;
+    getRandomId(): string;
+    createChildContent(options: ChildContentOptions): Promise<any>;
+    getWebWindow(identity: OpenFin.Identity): globalThis.Window;
+    getCurrentEntityIdentity(): OpenFin.EntityInfo;
+    getCurrentEntityType(): EntityType_3;
+    raiseEvent(eventName: string, eventArgs: any): void;
+    childViews: boolean;
+    getUrl(): string;
+    getDefaultChannelOptions(): {
+        create: OpenFin.ChannelCreateOptions;
+        connect: OpenFin.ChannelConnectOptions;
+    };
+    getRtcPeer(): RTCPeerConnection;
+    getWsConstructor(): typeof WebSocket;
+    whenReady(): Promise<void>;
+}
+
+/**
+ * This function converts JS errors into plain objects
+ */
+declare type ErrorPlainObject = {
+    stack?: string;
+    message: string;
+    name?: string;
+    toString(): string;
+};
+
+declare class EventAggregator extends EmitterMap {
+    dispatchEvent: (message: Message<any>) => boolean;
+}
+
+declare type ExistingConnectConfig = ConfigWithUuid & {
+    address: string;
+};
+
+export declare function fdc3FromFin(fin: OpenFin.Fin<OpenFin.EntityType>, version?: Fdc3Version): Promise<Fdc3Module | Fdc3Module2>;
+
+/**
+ * @version 1.2
+ * The FDC3 Client Library provides a set APIs to be used for FDC3 compliance,
+ * while using our Interop API under the hood. In order to use this set of APIs
+ * you will need to set up your own {@link InteropBroker InteropBroker} or use a Platform application, which does the setup for you. Refer to our documentation on
+ * our {@link https://developers.openfin.co/of-docs/docs/enable-color-linking Interop API}.
+ *
+ * To enable the FDC3 APIs in a {@link Window Window} or {@link View View}, add the fdc3InteropApi
+ * property to its options:
+ *
+ * ```js
+ * {
+ *     autoShow: false,
+ *     saveWindowState: true,
+ *     url: 'https://openfin.co',
+ *     fdc3InteropApi: '1.2'
+ * }
+ * ```
+ *
+ * If using a {@link Platform Platform } application, you can set this property in defaultWindowOptions and defaultViewOptions.
+ *
+ * In order to ensure that the FDC3 Api is ready before use, you can use the 'fdc3Ready' event fired on the DOM Window object:
+ *
+ * ```js
+ * function fdc3Action() {
+ *     // Make some fdc3 API calls here
+ * }
+ *
+ * if (window.fdc3) {
+ *    fdc3Action();
+ * } else {
+ *    window.addEventListener('fdc3Ready', fdc3Action);
+ * }
+ * ```
+ */
+export declare class Fdc3Module extends Base implements v1.DesktopAgent {
+    /**
+     * Add a context handler for incoming context. If an entity is part of a context group, and then sets its context handler, it will receive all of its declared contexts. If you wish to listen for all incoming contexts, pass `null` for the contextType argument.
+     * @param contextType - The type of context you wish to handle.
+     * @param handler - Handler for incoming context.
+     *
+     * @tutorial fdc3.addContextListener
+     * @static
+     */
+    addContextListener(contextType: string | null, handler: v1.ContextHandler): v1.Listener & Promise<v1.Listener>;
+    /**
+     * Broadcasts a context for the channel of the current entity.
+     * @param context - New context to set.
+     *
+     * @tutorial fdc3.broadcast
+     * @static
+     */
+    broadcast(context: v1.Context): Promise<void>;
+    /**
+     * Returns the Interop-Broker-defined context groups available for an entity to join.
+     *
+     * @tutorial fdc3.getSystemChannels
+     * @static
+     */
+    getSystemChannels(): Promise<v1.SystemChannel[]>;
+    /**
+     * Join all Interop Clients at the given identity to context group `contextGroupId`.
+     * If no target is specified, it adds the sender to the context group.
+     * Because multiple Channel connections/Interop Clients can potentially exist at a `uuid`/`name` combo, we currently join all Channel connections/Interop Clients at the given identity to the context group.
+     * If an `endpointId` is provided (which is unlikely, unless the call is coming from an external adapter), then we only join that single connection to the context group.
+     * For all intents and purposes, there will only be 1 connection present in Platform and Browser implementations, so this point is more-or-less moot.
+     * @param channelId - Id of the context group.
+     *
+     * @tutorial fdc3.joinChannel
+     * @static
+     */
+    joinChannel(channelId: string): Promise<void>;
+    /**
+     * Removes the specified target from a context group.
+     * If no target is specified, it removes the sender from their context group.
+     *
+     * @tutorial fdc3.leaveCurrentChannel
+     * @static
+     */
+    leaveCurrentChannel(): Promise<void>;
+    /**
+     * Adds a listener for incoming Intents.
+     * @param intent - Name of the Intent
+     * @param handler - Handler for incoming Intent
+     *
+     * @tutorial fdc3.addIntentListener
+     * @static
+     */
+    addIntentListener(intent: string, handler: v1.ContextHandler): v1.Listener & Promise<v1.Listener>;
+    /**
+     * Raises a specific intent.
+     * @param intent Name of the Intent.
+     * @param context Context associated with the Intent.
+     * @param  app App that will resolve the Intent. This is added as metadata to the Intent. Can be accessed by the app provider in {@link InteropBroker#handleFiredIntent InteropBroker.handleFiredIntent}.
+     *
+     * @tutorial fdc3.raiseIntent
+     * @static
+     */
+    raiseIntent(intent: string, context: v1.Context, app?: v1.TargetApp): Promise<v1.IntentResolution>;
+    /**
+     * Returns the Channel that the entity is subscribed to. Returns null if not joined to a channel.
+     *
+     * @tutorial fdc3.getCurrentChannel
+     */
+    getCurrentChannel(): Promise<v1.Channel | null>;
+    /**
+     * Find out more information about a particular intent by passing its name, and optionally its context.
+     * @param intent Name of the Intent
+     * @param context
+     *
+     * @tutorial fdc3.findIntent
+     */
+    findIntent(intent: string, context?: v1.Context): Promise<v1.AppIntent>;
+    /**
+     * Find all the available intents for a particular context.
+     * @param context
+     *
+     * @tutorial fdc3.findIntentsByContext
+     */
+    findIntentsByContext(context: v1.Context): Promise<Array<v1.AppIntent>>;
+    /**
+     * Finds and raises an intent against a target app based purely on context data.
+     * @param context
+     * @param app
+     *
+     * @tutorial fdc3.raiseIntentForContext
+     */
+    raiseIntentForContext(context: v1.Context, app?: v1.TargetApp): Promise<v1.IntentResolution>;
+    /**
+     * Returns a Channel object for the specified channel, creating it as an App Channel if it does not exist.
+     * @param channelId
+     *
+     * @tutorial fdc3.getOrCreateChannel
+     */
+    getOrCreateChannel(channelId: string): Promise<v1.Channel>;
+    /**
+     * Returns metadata relating to the FDC3 object and its provider, including the supported version of the FDC3 specification and the name of the provider of the implementation.
+     *
+     * @tutorial fdc3.getInfo
+     */
+    getInfo(): v1.ImplementationMetadata;
+    /**
+     * Launches an app with target information, which can either be a string or an AppMetadata object.
+     * @param app
+     * @param context
+     *
+     * @tutorial fdc3.open
+     */
+    open(app: v1.TargetApp, context?: v1.Context): Promise<void>;
+    private getCurrentContextGroupInfo;
+    private buildChannelObject;
+}
+
+/**
+ * @version 2.0
+ * The FDC3 Client Library provides a set APIs to be used for FDC3 compliance,
+ * while using our Interop API under the hood. In order to use this set of APIs
+ * you will need to set up your own {@link InteropBroker InteropBroker} or use a Platform application, which does the setup for you. Refer to our documentation on
+ * our {@link https://developers.openfin.co/of-docs/docs/enable-context-sharing Interop API}.
+ *
+ * To enable the FDC3 APIs in a {@link Window Window} or {@link View View}, add the fdc3InteropApi
+ * property to its options:
+ *
+ * ```js
+ * {
+ *     autoShow: false,
+ *     saveWindowState: true,
+ *     url: 'https://openfin.co',
+ *     fdc3InteropApi: '2.0'
+ * }
+ * ```
+ *
+ * If using a {@link Platform Platform } application, you can set this property in defaultWindowOptions and defaultViewOptions.
+ *
+ * In order to ensure that the FDC3 Api is ready before use, you can use the 'fdc3Ready' event fired on the DOM Window object:
+ *
+ * ```js
+ * function fdc3Action() {
+ *     // Make some fdc3 API calls here
+ * }
+ *
+ * if (window.fdc3) {
+ *    fdc3Action();
+ * } else {
+ *    window.addEventListener('fdc3Ready', fdc3Action);
+ * }
+ * ```
+ */
+export declare class Fdc3Module2 extends Base implements v2.DesktopAgent {
+    private fdc3Module;
+    constructor(wire: Transport);
+    /**
+     * Launches an app, specified via an AppIdentifier object.
+     * @param app
+     * @param context
+     *
+     * @tutorial fdc3.open
+     */
+    open(app: v2.AppIdentifier | v1.TargetApp, context?: v2.Context): Promise<v2.AppIdentifier>;
+    /**
+     * Find all the available instances for a particular application.
+     * @param app
+     *
+     * @tutorial fdc3v2.findInstances
+     */
+    findInstances(app: v2.AppIdentifier): Promise<Array<v2.AppIdentifier>>;
+    /**
+     * Retrieves the AppMetadata for an AppIdentifier, which provides additional metadata (such as icons, a title and description) from the App Directory record for the application, that may be used for display purposes.
+     * @param app
+     *
+     * @tutorial fdc3v2.getAppMetadata
+     */
+    getAppMetadata(app: v2.AppIdentifier): Promise<v2.AppMetadata>;
+    /**
+     * Broadcasts a context for the channel of the current entity.
+     * @param context - New context to set.
+     *
+     * @tutorial fdc3.broadcast
+     */
+    broadcast(context: v2.Context): Promise<void>;
+    /**
+     * Add a context handler for incoming context. If an entity is part of a context group, and then sets its context handler, it will receive all of its declared contexts. If you wish to listen for all incoming contexts, pass `null` for the contextType argument.
+     * @param contextType
+     * @param handler
+     *
+     * @tutorial fdc3.addContextListener
+     */
+    addContextListener(contextType: string | null, handler: v2.ContextHandler): Promise<v2.Listener>;
+    /**
+     * Find out more information about a particular intent by passing its name, and optionally its context and resultType.
+     * @param intent Name of the Intent
+     * @param context Context
+     * @param resultType The type of result returned for any intent specified during resolution.
+     *
+     * @tutorial fdc3.findIntent
+     */
+    findIntent(intent: string, context?: v2.Context, resultType?: string): Promise<v2.AppIntent>;
+    /**
+     * Find all the available intents for a particular context.
+     * @param context
+     * @param resultType The type of result returned for any intent specified during resolution.
+     *
+     * @tutorial fdc3v2.findIntentsByContext
+     */
+    findIntentsByContext(context: v2.Context, resultType?: string): Promise<Array<v2.AppIntent>>;
+    /**
+     * Raises a specific intent for resolution against apps registered with the desktop agent.
+     * @param intent Name of the Intent
+     * @param context Context associated with the Intent
+     * @param app
+     *
+     * @tutorial fdc3v2.raiseIntent
+     */
+    raiseIntent(intent: string, context: v2.Context, app?: v2.AppIdentifier | v1.TargetApp): Promise<v2.IntentResolution>;
+    /**
+     * Finds and raises an intent against apps registered with the desktop agent based purely on the type of the context data.
+     * @param context Context associated with the Intent
+     * @param app
+     *
+     * @tutorial fdc3v2.raiseIntentForContext
+     */
+    raiseIntentForContext(context: v2.Context, app?: v2.AppIdentifier | v1.TargetApp): Promise<v2.IntentResolution>;
+    /**
+     * Adds a listener for incoming intents.
+     * @param intent  Name of the Intent
+     * @param handler A callback that handles a context event and may return a promise of a Context or Channel object to be returned to the application that raised the intent.
+     *
+     * @tutorial fdc3.addIntentListener
+     */
+    addIntentListener(intent: string, handler: v2.IntentHandler): Promise<v1.Listener>;
+    /**
+     * Returns a Channel object for the specified channel, creating it as an App Channel if it does not exist.
+     * @param channelId
+     *
+     * @tutorial fdc3.getOrCreateChannel
+     */
+    getOrCreateChannel(channelId: string): Promise<v2.Channel>;
+    /**
+     * Returns a Channel with an auto-generated identity that is intended for private communication between applications. Primarily used to create channels that will be returned to other applications via an IntentResolution for a raised intent.
+     *
+     * @tutorial fdc3v2.createPrivateChannel
+     */
+    createPrivateChannel(): Promise<v2.PrivateChannel>;
+    /**
+     * Retrieves a list of the User Channels available for the app to join.
+     *
+     * @tutorial fdc3v2.getUserChannels
+     */
+    getUserChannels(): Promise<Array<v1.SystemChannel>>;
+    /**
+     * Retrieves a list of the User Channels available for the app to join.
+     *
+     * @deprecated Please use {@link fdc3.getUserChannels fdc3.getUserChannels} instead
+     * @tutorial fdc3.getSystemChannels
+     */
+    getSystemChannels(): Promise<Array<v1.SystemChannel>>;
+    /**
+     * Join an app to a specified User channel.
+     * @param channelId Channel name
+     *
+     * @tutorial fdc3v2.joinUserChannel
+     */
+    joinUserChannel(channelId: string): Promise<void>;
+    /**
+     * Join an app to a specified User channel.
+     * @param channelId Channel name
+     * @deprecated Please use {@link fdc3.joinUserChannel fdc3.joinUserChannel} instead
+     *
+     * @tutorial fdc3.joinChannel
+     */
+    joinChannel(channelId: string): Promise<void>;
+    /**
+     * Returns the Channel object for the current User channel membership
+     *
+     * @tutorial fdc3.getCurrentChannel
+     */
+    getCurrentChannel(): Promise<v2.Channel | null>;
+    /**
+     * Removes the app from any User channel membership.
+     *
+     * @tutorial fdc3.leaveCurrentChannel
+     */
+    leaveCurrentChannel(): Promise<void>;
+    /**
+     * Retrieves information about the FDC3 implementation, including the supported version of the FDC3 specification, the name of the provider of the implementation, its own version number, details of whether optional API features are implemented and the metadata of the calling application according to the desktop agent.
+     * fdc3HandleGetInfo must be overridden in the InteropBroker so that the ImplementationMetadata will have the appMetadata info.
+     *
+     * @tutorial fdc3v2.getInfo
+     */
+    getInfo(): Promise<v2.ImplementationMetadata>;
+}
+
+export declare type Fdc3Version = '1.2' | '2.0';
+
+declare type FlexReadyState = WebSocketReadyState | DataChannelReadyState;
+
+declare type GetterCall<T> = ApiCall<void, T>;
+
+declare type Identity = OpenFin.Identity;
+
+declare type IdentityCall<AdditionalPayload = {}, Response = void> = ApiCall<AdditionalPayload & OpenFin.Identity, Response>;
+
+declare type InternalConnectConfig = ExistingConnectConfig | NewConnectConfig;
+
+declare interface Message<T> {
+    action: string;
+    payload: T;
+    correlationId?: number;
+}
+
+declare type MessageHandler = (data: any) => boolean;
+
+declare interface MessageReceiver {
+    addEventListener(e: 'open', listener: (ev: Event) => void): void;
+    addEventListener(e: 'error', listener: (ev: Event) => void): void;
+    addEventListener(e: 'message', listener: (ev: MessageEvent) => void): void;
+    addEventListener(e: 'close', listener: (ev: Event) => void): void;
+    send(data: unknown): void;
+    close(): void;
+    readyState: FlexReadyState;
+}
+
+declare type NackHandler = (payloadOrMessage: RuntimeErrorPayload | string) => void;
+
+declare type NewConnectConfig = ConfigWithUuid & ConfigWithRuntime;
+
+declare namespace OpenFin {
+        {
+        FinApi,
+        Fin,
+        Application,
+        ApplicationModule,
+        ExternalApplication,
+        ExternalApplicationModule,
+        _Frame as Frame,
+        _FrameModule,
+        GlobalHotkey,
+        Channel,
+        ChannelClient,
+        ChannelProvider,
+        Platform,
+        PlatformModule,
+        Layout,
+        LayoutModule,
+        View_2 as View,
+        ViewModule,
+        ColumnOrRow,
+        TabStack,
+        _Window as Window,
+        _WindowModule,
+        InteropClient,
+        InteropBroker,
+        InteropModule,
+        SnapshotSource,
+        SnapshotSourceModule,
+        System,
+        LayoutEntityDefinition,
+        LayoutEntityTypes,
+        LayoutPosition,
+        WebContent,
+        PlatformProvider,
+        ApplicationIdentity_2 as ApplicationIdentity,
+        Identity_5 as Identity,
+        ClientIdentity,
+        ClientInfo,
+        ClientIdentityMultiRuntime,
+        ClientConnectionPayload,
+        EntityInfo_2 as EntityInfo,
+        EntityType_4 as EntityType,
+        Bounds,
+        WindowBounds,
+        Rectangle,
+        ApplicationCreationOptions,
+        ApplicationOptions,
+        CustomProtocolMissingState,
+        CustomProtocolMalformedState,
+        CustomProtocolRegisteredState,
+        CustomProtocolState,
+        CustomProtocolOptions,
+        InteropBrokerOptions,
+        ContextGroupInfo,
+        DisplayMetadata_3 as DisplayMetadata,
+        LegacyWinOptionsInAppOptions,
+        Snapshot,
+        ContextGroupStates,
+        Context_3 as Context,
+        MonitorInfo,
+        Point,
+        PointTopLeft,
+        RectangleByEdgePositions,
+        MonitorDetails,
+        DipRect,
+        DipScaleRects,
+        TaskBar,
+        WindowCreationOptions,
+        UpdatableWindowOptions,
+        WindowOptions,
+        ViewVisibilityOption,
+        ShowViewOnWindowResizeOptions,
+        ViewVisibilityOptions,
+        WindowState,
+        AutoplayPolicyOptions,
+        ConstWindowOptions,
+        MutableWindowOptions,
+        WorkspacePlatformOptions,
+        WebRequestHeader,
+        CustomRequestHeaders,
+        WindowOptionDiff,
+        ResizeRegion,
+        Accelerator,
+        Api,
+        InjectionType,
+        NavigationRules,
+        ContentNavigation,
+        ContentRedirect,
+        CornerRounding,
+        DownloadPreloadOption,
+        DownloadPreloadInfo,
+        RGB,
+        ContextMenuSettings,
+        Hotkey,
+        ShortcutOverride,
+        PreloadScript,
+        AutoResizeOptions,
+        InteropConfig,
+        ViewInfo,
+        UpdatableViewOptions,
+        ViewCreationOptions,
+        MutableViewOptions,
+        ViewOptions,
+        ConstViewOptions,
+        ViewState,
+        Certificate,
+        HostContextChangedPayload,
+        ApplySnapshotOptions,
+        ApplySnapshotPayload,
+        AddViewToStackOptions,
+        CreateViewTarget,
+        CreateViewPayload,
+        AddViewOptions,
+        ReplaceViewPayload,
+        ReplaceViewOptions,
+        CloseViewPayload,
+        CloseViewOptions,
+        FetchManifestPayload,
+        ReplaceLayoutOpts,
+        ReplaceLayoutPayload,
+        ReplaceLayoutOptions,
+        SetWindowContextPayload,
+        LaunchIntoPlatformPayload,
+        GetWindowContextPayload,
+        ApplicationPermissions,
+        LaunchExternalProcessRule,
+        SystemPermissions,
+        WebPermission,
+        VerboseWebPermission,
+        OpenExternalPermission,
+        DeviceInfo,
+        Permissions_2 as Permissions,
+        PlatformWindowCreationOptions,
+        PlatformWindowOptions,
+        PlatformViewCreationOptions,
+        ProcessAffinityStrategy,
+        PlatformOptions,
+        Manifest,
+        LayoutContent,
+        LayoutItemConfig,
+        LayoutRow,
+        LayoutColumn,
+        LayoutComponent,
+        LayoutOptions,
+        OverrideCallback,
+        ConstructorOverride,
+        Constructor,
+        HostContextChangedReasons,
+        WindowCreationReason,
+        InitPlatformOptions,
+        ProcessDetails,
+        FrameProcessDetails,
+        EntityProcessDetails,
+        AppProcessInfo,
+        NonAppProcessDetails,
+        SystemProcessInfo,
+        ClearCacheOption,
+        CookieInfo,
+        CookieOption,
+        CrashReporterOptions,
+        CrashReporterState,
+        Time,
+        CpuInfo,
+        GpuInfo,
+        HostSpecs,
+        PrinterInfo_2 as PrinterInfo,
+        Dpi,
+        Margins,
+        PrintOptions,
+        ScreenshotPrintOptions,
+        WindowViewsPrintOptions,
+        WindowPrintOptions,
+        ImageFormatOptions,
+        ClipboardSelectionType,
+        BaseClipboardRequest,
+        WriteClipboardRequest,
+        ReadImageClipboardRequest,
+        WriteImageClipboardRequest,
+        WriteAnyClipboardRequest,
+        WriteRequestType,
+        WriteAnyRequestType,
+        SubscriptionOptions,
+        SharedWorkerInfo,
+        ServiceIdentifier,
+        ServiceConfiguration,
+        RVMInfo,
+        AppVersionProgress,
+        AppVersionError,
+        AppVersionRuntimeInfo,
+        LaunchEmitter,
+        RvmLaunchOptions,
+        ShortCutConfig,
+        TerminateExternalRequestType,
+        TrayInfo,
+        Transition,
+        Size,
+        Opacity,
+        TransitionBase,
+        Position,
+        AnchorType,
+        TransitionOptions,
+        tween,
+        FindInPageOptions,
+        FindInPageResult,
+        FrameInfo,
+        ExternalApplicationInfo,
+        ExternalConnection,
+        ExternalProcessRequestType,
+        CertificationInfo,
+        ExitCode,
+        LaunchExternalProcessListener,
+        ExternalProcessInfo,
+        AppAssetInfo,
+        RuntimeDownloadOptions,
+        AppAssetRequest,
+        RuntimeDownloadProgress,
+        CertifiedAppInfo,
+        JumpListCategory,
+        JumpListItem,
+        JumpListTask,
+        JumpListSeparator,
+        ApplicationInfo,
+        ManifestInfo,
+        ClickedMenuResult,
+        ClosedMenuResult,
+        MenuResult,
+        ShowPopupMenuOptions,
+        ShowTrayIconPopupMenuOptions,
+        MenuItemTemplate,
+        NativeWindowIntegrationProviderAuthorization,
+        RuntimeInfo,
+        DefaultDomainSettings,
+        DefaultDomainSettingsRule,
+        DomainSettings,
+        ApiInjection,
+        DomainSettingsRule,
+        FileDownloadBehaviorNames,
+        FileDownloadSettings,
+        DownloadRule,
+        ContextHandler_3 as ContextHandler,
+        Intent_2 as Intent,
+        IntentMetadata_3 as IntentMetadata,
+        IntentHandler_2 as IntentHandler,
+        ContentCreationBehaviorNames,
+        MatchPattern,
+        BaseContentCreationRule,
+        WindowContentCreationRule,
+        ViewContentCreationRule,
+        BrowserContentCreationRule,
+        BlockedContentCreationRule,
+        ContentCreationRule,
+        ContentCreationOptions,
+        SnapshotProvider,
+        QueryPermissionResult,
+        SessionContextGroup,
+        MessagingProtocols,
+        ChannelCreateOptions,
+        ChannelConnectOptions,
+        ContextForIntent,
+        InfoForIntentOptions,
+        FindIntentsByContextOptions,
+        ProviderIdentity_7 as ProviderIdentity,
+        RegisterUsageData,
+        ViewsPreventingUnloadPayload,
+        BeforeUnloadUserDecision,
+        ViewStatuses,
+        CloseWindowPayload,
+        ProxyInfo_2 as ProxyInfo,
+        ProxyConfig_2 as ProxyConfig,
+        ProxySystemInfo,
+        ChannelAction_2 as ChannelAction,
+        ChannelMiddleware_2 as ChannelMiddleware,
+        ErrorMiddleware_2 as ErrorMiddleware,
+        ApplicationState_2 as ApplicationState,
+        InstalledApps_2 as InstalledApps,
+        InstallationInfo,
+        GetLogRequestType_2 as GetLogRequestType,
+        LogInfo_2 as LogInfo,
+        SendApplicationLogResponse,
+        LogLevel_2 as LogLevel,
+        PermissionState_2 as PermissionState,
+        RegistryInfo_2 as RegistryInfo,
+        ApplicationType,
+        WindowInfo,
+        ApplicationWindowInfo_2 as ApplicationWindowInfo,
+        WindowDetail,
+        LayoutPresetType,
+        LayoutIdentity,
+        LayoutSnapshot,
+        InitLayoutOptions,
+        LayoutManagerConstructor,
+        LayoutManagerOverride,
+        LayoutManager,
+        CreateLayoutOptions,
+        PresetLayoutOptions_2 as PresetLayoutOptions,
+        ResultBehavior,
+        PopupBaseBehavior,
+        PopupResultBehavior,
+        PopupBlurBehavior,
+        Optional,
+        PopupOptions,
+        PopupInteraction,
+        PopupResult,
+        SystemShutdownHandler,
+        AppVersionProgressEvent,
+        AppVersionErrorEvent,
+        AppVersionCompleteEvent,
+        AppVersionRuntimeStatusEvent,
+        Events,
+        BaseEvent_9 as BaseEvent,
+        WebContentsEvent_2 as WebContentsEvent,
+        SystemEvent_2 as SystemEvent,
+        ApplicationEvent_2 as ApplicationEvent,
+        WindowEvent_2 as WindowEvent,
+        ViewEvent_2 as ViewEvent,
+        GlobalHotkeyEvent_2 as GlobalHotkeyEvent,
+        FrameEvent_2 as FrameEvent,
+        PlatformEvent_2 as PlatformEvent,
+        ExternalApplicationEvent_2 as ExternalApplicationEvent,
+        ContextMenuOptions,
+        PrebuiltContextMenuItem,
+        InteropBrokerDisconnectionEvent,
+        InteropClientOnDisconnectionListener,
+        InteropActionLoggingOption,
+        InteropLoggingActions,
+        InteropLoggingOptions,
+        Me,
+        CapturePageOptions,
+        ProcessLoggingOptions,
+        PositioningOptions,
+        ChannelClientConnectionListener,
+        ChannelClientDisconnectionListener,
+        ChannelProviderDisconnectionListener,
+        RoutingInfo,
+        DownloadShelfOptions,
+        ApplicationEvents,
+        BaseEvents,
+        ExternalApplicationEvents,
+        FrameEvents,
+        GlobalHotkeyEvents,
+        PlatformEvents,
+        SystemEvents,
+        ViewEvents,
+        WebContentsEvents,
+        WindowEvents
+    }
+}
+
+declare type Payload<Success extends boolean = boolean, Data = any> = {
+    success: Success;
+    data: Success extends true ? Data : never;
+    reason: Success extends false ? string : never;
+    error?: Success extends false ? ErrorPlainObject | undefined : never;
+};
+
+declare interface ProtocolMap extends ProtocolMapBase {
+    'request-external-authorization': {
+        request: any;
+        response: void;
+        specialResponse: AuthorizationPayload;
+    };
+    'application-get-views': {
+        request: OpenFin.ApplicationIdentity;
+        response: OpenFin.Identity[];
+    };
+    'set-jump-list': {
+        request: {
+            config: OpenFin.JumpListCategory[] | null;
+        } & OpenFin.ApplicationIdentity;
+        response: void;
+    };
+    'clipboard-read-formats': {
+        request: {
+            type?: OpenFin.ClipboardSelectionType;
+        };
+        response: Array<string>;
+    };
+    'clipboard-read-image': {
+        request: OpenFin.ReadImageClipboardRequest;
+        response: string;
+    };
+    'clipboard-write-image': {
+        request: OpenFin.WriteImageClipboardRequest;
+        response: void;
+    };
+    'clipboard-write': {
+        request: OpenFin.WriteAnyRequestType;
+        response: void;
+    };
+    'get-view-window': IdentityCall<{}, OpenFin.Identity>;
+    'create-view': IdentityCall<OpenFin.ViewCreationOptions & {
+        uuid: string;
+    }>;
+    'destroy-view': IdentityCall;
+    'attach-view': IdentityCall<{
+        target: OpenFin.Identity;
+    }>;
+    'set-view-bounds': IdentityCall<{
+        bounds: OpenFin.Bounds;
+    }>;
+    'get-view-bounds': IdentityCall<{}, OpenFin.Bounds>;
+    'get-view-info': IdentityCall<{}, OpenFin.ViewInfo>;
+    'get-view-options': IdentityCall<{}, OpenFin.ViewOptions>;
+    'hide-view': IdentityCall;
+    'show-view': IdentityCall;
+    'update-view-options': IdentityCall<{
+        options: OpenFin.UpdatableViewOptions;
+    }>;
+    'trigger-before-unload': IdentityCall<{}, boolean>;
+    'window-get-views': IdentityCall<{}, OpenFin.Identity[]>;
+    'print': {
+        request: OpenFin.Identity & {
+            options: OpenFin.PrintOptions;
+        };
+        response: void;
+    };
+    'print-screenshot': {
+        request: OpenFin.Identity;
+        response: void;
+    };
+    'print-views': {
+        request: OpenFin.Identity & {
+            options: OpenFin.WindowViewsPrintOptions;
+        };
+        response: void;
+    };
+    'launch-manifest': {
+        request: {
+            manifestUrl: string;
+            opts?: Omit<OpenFin.RvmLaunchOptions, 'subscribe'> & {
+                appVersionId?: string;
+            };
+        };
+        response: {
+            manifest: OpenFin.Manifest;
+        };
+    };
+    'get-system-app-configuration': {
+        request: {
+            name: string;
+        };
+        response: any;
+    };
+    'show-popup-menu': {
+        request: OpenFin.Identity & {
+            options: OpenFin.ShowPopupMenuOptions;
+        };
+        response: OpenFin.MenuResult;
+    };
+    'enable-native-window-integration-provider': {
+        request: {
+            permissions: any;
+        };
+        response: OpenFin.NativeWindowIntegrationProviderAuthorization;
+    };
+    'get-permissions': GetterCall<any>;
+    'get-all-channels': GetterCall<OpenFin.ProviderIdentity[]>;
+    'set-file-download-location': {
+        request: OpenFin.Identity & {
+            downloadLocation: string;
+        };
+        response: void;
+    };
+    'get-file-download-location': {
+        request: OpenFin.ApplicationIdentity;
+        response: string;
+    };
+    'close-popup-menu': IdentityCall;
+    'fdc3-add-context-listener': VoidCall;
+    'fdc3-broadcast': VoidCall;
+    'fdc3-get-system-channels': VoidCall;
+    'fdc3-join-channel': VoidCall;
+    'fdc3-leave-current-channel': VoidCall;
+    'interop-connect-sync': VoidCall;
+    'interop-client-set-context': VoidCall;
+    'interop-client-add-context-handler': VoidCall;
+    'interop-client-get-context-groups': VoidCall;
+    'interop-client-join-context-group': VoidCall;
+    'interop-client-remove-from-context-group': VoidCall;
+    'interop-client-get-all-clients-in-context-group': VoidCall;
+    'interop-client-get-info-for-context-group': VoidCall;
+    'interop-broker-add-client-to-context-group': VoidCall;
+    'interop-broker-get-all-clients-in-context-group': VoidCall;
+    'interop-broker-get-context-groups': VoidCall;
+    'interop-broker-get-info-for-context-group': VoidCall;
+    'interop-broker-is-action-authorized': VoidCall;
+    'interop-broker-is-connection-authorized': VoidCall;
+    'interop-broker-join-context-group': VoidCall;
+    'interop-broker-remove-client-from-context-group': VoidCall;
+    'interop-broker-remove-from-context-group': VoidCall;
+    'interop-broker-set-context': VoidCall;
+    'query-permission-for-current-context': {
+        request: {
+            apiName: string;
+            identity: OpenFin.Identity;
+        };
+        response: OpenFin.QueryPermissionResult;
+    };
+    'try-create-popup-window': {
+        request: OpenFin.Identity & {
+            options: OpenFin.PopupOptions;
+        };
+        response: {
+            willOpen: boolean;
+            options: OpenFin.PopupOptions;
+        };
+    };
+    'show-popup-window': {
+        request: OpenFin.Identity & {
+            options: OpenFin.PopupOptions;
+        };
+        response: OpenFin.PopupResult;
+    };
+    'dispatch-popup-result': IdentityCall<{
+        data: any;
+    }>;
+    'render-overlay': {
+        request: {
+            bounds: OpenFin.Bounds;
+        };
+        response: void;
+    };
+    'set-overlay-style': {
+        request: {
+            style: Partial<CSSStyleDeclaration>;
+        };
+        response: void;
+    };
+    'detach-overlay': VoidCall;
+    'set-ignore-all-view-mouse-events': {
+        request: {
+            enabled: boolean;
+        };
+        response: void;
+    };
+    'system-get-printers': GetterCall<OpenFin.PrinterInfo[]>;
+    'system-register-shutdown-handler': VoidCall;
+    'get-domain-settings': ApiCall<OpenFin.ApplicationIdentity, OpenFin.DefaultDomainSettings>;
+    'set-domain-settings': ApiCall<OpenFin.ApplicationIdentity & {
+        domainSettings: OpenFin.DefaultDomainSettings;
+    }, void>;
+    'move-window-by': IdentityCall<WithPositioningOptions<{
+        deltaLeft: number;
+        deltaTop: number;
+    }>>;
+    'move-window': IdentityCall<WithPositioningOptions<{
+        left: number;
+        top: number;
+    }>>;
+    'resize-window-by': IdentityCall<WithPositioningOptions<{
+        deltaWidth: number;
+        deltaHeight: number;
+        anchor: OpenFin.AnchorType;
+    }>>;
+    'resize-window': IdentityCall<WithPositioningOptions<{
+        width: number;
+        height: number;
+        anchor: OpenFin.AnchorType;
+    }>>;
+    'set-window-bounds': IdentityCall<WithPositioningOptions<Partial<OpenFin.Bounds>>>;
+    'register-custom-protocol': ApiCall<OpenFin.CustomProtocolOptions, void>;
+    'unregister-custom-protocol': ApiCall<{
+        protocolName: string;
+    }, void>;
+    'get-custom-protocol-state': ApiCall<{
+        protocolName: string;
+    }, OpenFin.CustomProtocolState>;
+}
+
+declare interface ProtocolMapBase {
+    [action: string]: {
+        request: any;
+        response: any;
+        specialResponse?: any;
+    };
+}
+
+declare interface ReceiverConfig extends Omit<RemoteConfig, 'address'> {
+    receiver: MessageReceiver;
+}
+
+declare interface RemoteConfig extends ExistingConnectConfig {
+    token: string;
+}
+
+declare type RuntimeConfig = {
+    version: string;
+    fallbackVersion?: string;
+    securityRealm?: string;
+    verboseLogging?: boolean;
+    arguments?: string;
+    rvmDir?: string;
+};
+
+declare type RuntimeErrorPayload = {
+    reason: string;
+    error?: ErrorPlainObject;
+};
+
+declare type SendActionResponse<T extends keyof ProtocolMap> = Message<{
+    data: ProtocolMap[T]['response'];
+} & ProtocolMap[T]['specialResponse']>;
+
+declare type SentMessage<Value> = Promise<Value> & {
+    cancel: (reason?: any) => void;
+    messageId: ReturnType<Environment['getNextMessageId']>;
+};
+
+declare type ServiceConfig = {
+    name: string;
+    manifestUrl: string;
+};
+
+declare class Transport<MeType extends EntityType = EntityType> extends EventEmitter {
+    #private;
+    protected wireListeners: Map<number, {
+        resolve: Function;
+        handleNack: (payload: RuntimeErrorPayload) => void;
+    }>;
+    protected uncorrelatedListener: Function;
+    me: OpenFin.EntityInfo & EntityTypeHelpers<MeType>;
+    environment: Environment;
+    topicRefMap: Map<string, number>;
+    sendRaw: Wire['send'];
+    eventAggregator: EventAggregator;
+    protected messageHandlers: MessageHandler[];
+    constructor(WireType: WireConstructor, environment: Environment, config: OpenFin.Identity);
+    getFin(): OpenFin.Fin<MeType>;
+    registerFin(_fin: OpenFin.Fin<MeType>): void;
+    connectSync: () => void;
+    getPort: () => string;
+    shutdown(): Promise<void>;
+    connect(config: InternalConnectConfig | RemoteConfig | ReceiverConfig): Promise<string | void>;
+    private connectRemote;
+    connectByPort(config: ExistingConnectConfig): Promise<void>;
+    private authorize;
+    sendAction<T extends keyof ProtocolMap = string>(action: T, payload?: ProtocolMap[T]['request'], uncorrelated?: boolean): SentMessage<SendActionResponse<T>>;
+    protected nackHandler(payloadOrMessage: RuntimeErrorPayload | string, reject: Function, callSites?: NodeJS.CallSite[]): void;
+    ferryAction(origData: any): Promise<Message<any>>;
+    registerMessageHandler(handler: MessageHandler): void;
+    protected addWireListener(id: number, resolve: Function, handleNack: NackHandler, uncorrelated: boolean): void;
+    protected onmessage(data: Message<Payload>): void;
+    protected handleMessage(data: Message<Payload>): boolean;
+}
+
+declare namespace v1 {
+        {
+        Listener,
+        AppMetadata,
+        IntentMetadata,
+        AppIntent,
+        DisplayMetadata,
+        ImplementationMetadata,
+        ContextHandler,
+        TargetApp,
+        Context,
+        IntentResolution,
+        Channel_3 as Channel,
+        SystemChannel,
+        DesktopAgent
+    }
+}
+
+declare namespace v2 {
+        {
+        IntentMetadata_2 as IntentMetadata,
+        AppIdentifier,
+        Listener_2 as Listener,
+        AppIntent_2 as AppIntent,
+        ImplementationMetadata_2 as ImplementationMetadata,
+        ContextMetadata,
+        Icon,
+        Image_2 as Image,
+        AppMetadata_2 as AppMetadata,
+        DisplayMetadata_2 as DisplayMetadata,
+        ContextHandler_2 as ContextHandler,
+        IntentHandler,
+        IntentResult,
+        Context_2 as Context,
+        Intent,
+        IntentResolution_2 as IntentResolution,
+        Channel_4 as Channel,
+        PrivateChannel,
+        DesktopAgent_2 as DesktopAgent
+    }
+}
+
+declare type VoidCall = ApiCall<void, void>;
+
+declare type WebSocketReadyState = WebSocket['readyState'];
+
+declare type Wire = EventEmitter & {
+    connect(messageReciever: MessageReceiver): Promise<any>;
+    connectSync(): any;
+    send(data: any): Promise<any>;
+    shutdown(): Promise<void>;
+    getPort(): string;
+};
+
+declare type WireConstructor = {
+    new (onmessage: (data: any) => void): Wire;
+};
+
+declare type WithPositioningOptions<T extends {} = {}> = T & {
+    positioningOptions?: OpenFin.PositioningOptions;
+};
+
+export { }