@openfin/core 25.68.27 → 25.68.28

package/OpenFin.d.ts

@@ -1,5 +1,8 @@
+/// <reference lib="dom"/>
+
 declare namespace OpenFin {
     // "wrappable entities"
+    import EventEmitter = NodeJS.EventEmitter;
     export type Application = import('./src/api/application/index').Application;
     export type ExternalApplication = import('./src/api/external-application/index').ExternalApplication;
     export type Frame = import('./src/api/frame/index')._Frame;
@@ -41,7 +44,8 @@ declare namespace OpenFin {
         name: string;
         entityType: EntityType;
     }
-    export type EntityType = import('./src/shapes/EntityType').EntityType;
+
+    export type EntityType = 'window' | 'iframe' | 'external connection' | 'view' | 'unknown';
 
     export interface Bounds {
         top: number;
@@ -314,7 +318,6 @@ declare namespace OpenFin {
     }
 
     export interface WorkspacePlatformOptions {
-        pages: Page[];
         /** Leaving this as any for now until we figure out what the shape should look like in Workspace */
         [key: string]: any;
     }
@@ -348,28 +351,6 @@ declare namespace OpenFin {
         machineName?: string;
     }
 
-    type PageLayout = LayoutExtended & { layoutDetails: PageLayoutDetails };
-
-    interface Page {
-        /** A UI friendly title for the page. */
-        title: string;
-
-        /** The unique ID of the page. */
-        pageId: string;
-
-        /** An optional UI friendly description of the page. */
-        description?: string;
-
-        /** A optional UI friendly tooltip for the page. */
-        tooltip?: string;
-
-        /** True if the page is read only. In this state, the page is locked and cannot be unlocked. */
-        isReadOnly?: boolean;
-
-        /** The layout of the page. */
-        layout: PageLayout;
-    }
-
     export interface WebRequestHeader {
         [key: string]: string;
     }
@@ -563,9 +544,6 @@ declare namespace OpenFin {
         state: string;
     }
 
-    export type HostContextChangedReasons = import('./src/shapes/Platform').HostContextChangedReasons;
-    export type WindowCreationReason = import('./src/shapes/Platform').WindowCreationReason;
-
     export type HostContextChangedPayload = {
         context: any;
         reason: HostContextChangedReasons;
@@ -784,7 +762,138 @@ declare namespace OpenFin {
 
     export type Constructor<T = {}> = new (...args: any[]) => T;
 
-    type PlatformProvider = import('./src/shapes/Platform').PlatformProvider;
+    export type HostContextChangedReasons = 'updated' | 'reparented';
+
+    export type WindowCreationReason =
+        | 'tearout'
+        | 'create-view-without-target'
+        | 'api-call'
+        | 'app-creation'
+        | 'restore';
+
+    // TODO: Real PlatformProvider type def
+    export interface PlatformProvider {
+        /**
+         * Handles requests to create a window in the current platform.
+         * @param { WindowOption } payload Window options for the window to be created.
+         * @param { Identity } [identity] If {@link Platform#createWindow Platform.createWindow} was called, the identity of the caller will be here.
+         * If `createWindow` was called as part of applying a snapshot or creating a view without a target window, `identity` will be undefined.
+         */
+        createWindow(
+            options: OpenFin.PlatformWindowCreationOptions,
+            identity?: OpenFin.Identity
+        ): Promise<OpenFin.Window>;
+
+        /**
+         * Gets the current state of windows and their views and returns a snapshot object containing that info.
+         * @param { undefined } payload Undefined unless you've defined a custom `getSnapshot` protocol.
+         * @param { Identity } identity Identity of the entity that called {@link Platform#getSnapshot Platform.getSnapshot}.
+         * @return { Promise<Snapshot> } Snapshot of current platform state.
+         */
+        getSnapshot(payload: undefined, identity: OpenFin.Identity): Promise<OpenFin.Snapshot>;
+
+        /**
+         * Called when a snapshot is being applied and some windows in that snapshot would be fully or partially off-screen.
+         * Returns an array of windows with modified positions, such that any off-screen windows are positioned in the top left
+         * corner of the main monitor.
+         * @param { Snapshot } snapshot The snapshot to be applied.
+         * @param { WindowOptions[] } outOfBoundsWindows An array of WindowOptions for any windows that would be off-screen.
+         * @return { Promise<WindowOptions[]> } An array of WindowOptions with their position modified to fit on screen.
+         */
+        positionOutOfBoundsWindows(
+            snapshot: OpenFin.Snapshot,
+            outOfBoundsWindows: OpenFin.WindowCreationOptions[]
+        ): Promise<OpenFin.WindowCreationOptions[]>;
+
+        /**
+         * Handles requests to apply a snapshot to the current Platform.
+         * @param { ApplySnapshotPayload } payload Payload containing the snapshot to be applied, as well as any options.
+         * @param { Identity } [identity] Identity of the entity that called {@link Platform#applySnapshot Platform.applySnapshot}.
+         * Undefined if called internally (e.g. when opening the initial snapshot).
+         * @return { Promise<void> }
+         */
+        applySnapshot(payload: OpenFin.ApplySnapshotPayload, identity?: OpenFin.Identity): Promise<void>;
+
+        /**
+         * Closes the current Platform and all child windows and views.
+         * @param { undefined } payload Undefined unless you have implemented a custom quite protocol.
+         * @param { Identity } identity Identity of the entity that called {@link Platform#quit Platform.quit}.
+         * @return { Promise<void> }
+         */
+        quit(payload: undefined, identity: OpenFin.Identity): Promise<void>;
+
+        /**
+         * Closes a view
+         * @param { CloseViewPayload } payload Specifies the `target` view to be closed.
+         * @param { Identity } identity Identity of the entity that called {@link Platform#closeView Platform.closeView}.
+         */
+        closeView(payload: OpenFin.CloseViewPayload, identity?: OpenFin.Identity): Promise<any>;
+
+        /**
+         * Creates a new view and attaches it to a specified target window.
+         * @param { CreateViewPayload } payload Creation options for the new view.
+         * @param { Identity } identity Identity of the entity that called {@link Platform#createView Platform.createView}.
+         * @return { Promise<void> }
+         */
+        createView(payload: OpenFin.CreateViewPayload, identity: OpenFin.Identity): Promise<OpenFin.View>;
+
+        /** Handles requests to fetch manifests in the current platform.
+         * @param { FetchManifestPayload } payload Payload containing the manifestUrl to be fetched.
+         * @param { Identity } callerIdentity If {@link Platform#fetchManifest Platform.fetchManifest}
+         * was called, the identity of the caller will be here.
+         * If `fetchManifest` was called internally, `callerIdentity` will be the provider's identity.
+         */
+        fetchManifest(payload: OpenFin.FetchManifestPayload, callerIdentity: OpenFin.Identity): Promise<any>;
+
+        /**
+         * Replaces a Platform window's layout with a new layout. Any views that were in the old layout but not the new layout will be destroyed.
+         * @param { ReplaceLayoutPayload } payload Contains the `target` window and an `opts` object with a `layout` property to apply.
+         * @param { Identity } [identity] Identity of the entity that called {@link Platform#replaceLayout Platform.replaceLayout}.
+         * Undefined if `replaceLayout` is called internally (e.g. while applying a snapshot).
+         * @return { Promise<void> }
+         */
+        replaceLayout(payload: OpenFin.ReplaceLayoutPayload, identity?: OpenFin.Identity): Promise<void>;
+
+        replaceView(payload: OpenFin.ReplaceViewPayload, identity?: OpenFin.Identity): Promise<void>;
+
+        launchIntoPlatform(payload: OpenFin.LaunchIntoPlatformPayload): Promise<void>;
+
+        /**
+         * Handles requests to set a window's context. `target` may be a window or a view.
+         * If it is a window, that window's `customContext` will be updated.
+         * If it is a view, the `customContext` of that view's current host window will be updated.
+         * @param { SetWindowContextPayload } payload Object containing the requested `context` update,
+         * the `target`'s identity, and the target's `entityType`.
+         * @param { Identity } [identity] Identity of the entity that called {@link Platform#setWindowContext Platform.setWindowContext}.
+         * Undefined if `setWindowContext` is called internally (e.g. while applying a snapshot).
+         * @return { Promise<any> } The new context.
+         */
+        setWindowContext(payload: OpenFin.SetWindowContextPayload, identity?: OpenFin.Identity): Promise<any>;
+
+        /**
+         * Handles requests to get a window's context. `target` may be a window or a view.
+         * If it is a window, that window's `customContext` will be returned.
+         * If it is a view, the `customContext` of that view's current host window will be returned.
+         * @param { GetWindowContextPayload } payload Object containing the requested `context` update,
+         * the `target`'s identity, and the target's `entityType`.
+         * @param { Identity } [identity] Identity of the entity that called {@link Platform#getWindowContext Platform.getWindowContext}.
+         * Undefined when `getWindowContext` is called internally
+         * (e.g. when getting a window's context for the purpose of raising a "host-context-changed" event on a reparented view).
+         * @return { Promise<any> } The new context.
+         */
+        getWindowContext(payload: OpenFin.GetWindowContextPayload, identity?: OpenFin.Identity): Promise<any>;
+
+        /**
+         * Called when a window's `customContext` is updated. Responsible for raising the `host-context-updated` event on that window's child views.
+         * @param { WindowOptionsChangedEvent<'window', 'options-changed'> } payload The event payload for the window whose context has changed.
+         * The new context will be contained as `payload.diff.customContext.newVal`.
+         * @return { Promise<HostContextChangedPayload> } The event that it raised.
+         */
+        onWindowContextUpdated(
+            payload: WindowOptionsChangedEvent<'window', 'options-changed'>
+        ): Promise<OpenFin.HostContextChangedPayload | undefined>;
+    }
+
     export interface InitPlatformOptions {
         overrideCallback?: OverrideCallback<PlatformProvider>;
         interopOverride?: OverrideCallback<InteropBroker>;
@@ -1144,6 +1253,7 @@ declare namespace OpenFin {
     export interface JumpListSeparator {
         type: 'separator';
     }
+
     export interface ApplicationInfo {
         initialOptions: OpenFin.ApplicationCreationOptions;
         launchMode: string;
@@ -1153,10 +1263,6 @@ declare namespace OpenFin {
         runtime: { version: string };
     }
 
-    export interface LogInfo {
-        logId: string;
-    }
-
     export interface ManifestInfo {
         uuid: string;
         manifestUrl: string;
@@ -1290,7 +1396,6 @@ declare namespace OpenFin {
         applySnapshot: (snapshot: T) => Promise<void>;
     }
 
-    export type PermissionState = import('./src/api/system/queryPermissionTypes').PermissionState;
     export interface QueryPermissionResult {
         permission: string;
         state: PermissionState;
@@ -1337,4 +1442,930 @@ declare namespace OpenFin {
         data: unknown;
         type: string;
     }
+
+    export interface ProxyInfo {
+        config: ProxyConfig;
+        system: ProxySystemInfo;
+    }
+
+    export interface ProxyConfig {
+        proxyAddress: string;
+        proxyPort: number;
+        type: string;
+    }
+
+    export interface ProxySystemInfo {
+        autoConfigUrl: string;
+        bypass: string;
+        enabled: boolean;
+        proxy: string;
+    }
+
+    export interface BaseEvent<Topic, Type> {
+        topic: Topic;
+        type: Type;
+    }
+
+    export interface ApplicationEvent<Topic, Type> extends BaseEvent<Topic, Type> {
+        uuid: string;
+    }
+
+    export interface WindowEvent<Topic, Type> extends ApplicationEvent<Topic, Type> {
+        name: string;
+    }
+
+    export interface BaseEventMap {
+        [name: string]: any;
+        newListener: string;
+        listenerRemoved: string;
+    }
+
+    export interface WindowResourceLoadFailedEvent<Topic, Type> extends WindowEvent<Topic, Type> {
+        errorCode: number;
+        errorDescription: string;
+        validatedURL: string;
+        isMainFrame: boolean;
+    }
+
+    export interface WindowResourceResponseReceivedEvent<Topic, Type> extends WindowEvent<Topic, Type> {
+        status: boolean;
+        newUrl: string;
+        originalUrl: string;
+        httpResponseCode: number;
+        requestMethod: string;
+        referrer: string;
+        headers: any;
+        resourceType: 'mainFrame' | 'subFrame' | 'styleSheet' | 'script' | 'image' | 'object' | 'xhr' | 'other';
+    }
+
+    export interface PageTitleUpdatedEvent<Topic, Type> extends WindowEvent<Topic, Type> {
+        title: string;
+    }
+
+    export interface CertificateErrorEvent<Topic, Type> extends WindowEvent<Topic, Type> {
+        error: string;
+        url: string;
+        certificate: OpenFin.Certificate;
+    }
+
+    export interface CertificateSelectionShownEvent<Topic, Type> extends WindowEvent<Topic, Type> {
+        url: string;
+        certificates: OpenFin.Certificate[];
+    }
+
+    export interface FaviconUpdatedEvent<Topic, Type> extends WindowEvent<Topic, Type> {
+        favicons: string[];
+    }
+
+    export interface CrashedEvent {
+        reason:
+            | 'normal-termination'
+            | 'abnormal-termination'
+            | 'killed'
+            | 'crashed'
+            | 'still-running'
+            | 'launch-failed'
+            | 'out-of-memory'
+            | 'integrity-failure';
+        exitCode: number;
+        details: {
+            reason: string;
+            exitCode: number;
+        };
+    }
+
+    export interface WindowNavigationRejectedEvent<Topic, Type> extends WindowEvent<Topic, Type> {
+        sourceName?: string; // DEPRECATED
+        url: string;
+    }
+
+    export interface FrameEvent<Type> extends WindowEvent<'frame', Type> {
+        entityType: 'iframe';
+        frameName: string;
+    }
+
+    export interface FrameEvents extends BaseEventMap {
+        connected: FrameEvent<'connected'>;
+        disconnected: FrameEvent<'disconnected'>;
+    }
+
+    // This file exports base event types to level specific events
+    // Those files map event names to event shapes and use a mapped type to specify topic and type
+    export type RuntimeEvent<Topic = string, Type = string> = Topic extends 'window' | 'view'
+        ? WindowEvent<Topic, Type>
+        : Topic extends 'frame'
+        ? FrameEvent<Type>
+        : Topic extends 'application'
+        ? ApplicationEvent<Topic, Type>
+        : BaseEvent<Topic, Type>;
+
+    export interface WebContentsEventMapping<Topic = string, Type = string> extends BaseEventMap {
+        'blurred': WindowEvent<Topic, Type>;
+        'certificate-error': CertificateErrorEvent<Topic, Type>;
+        'certificate-selection-shown': CertificateSelectionShownEvent<Topic, Type>;
+        'crashed': CrashedEvent & WindowEvent<Topic, Type>;
+        'did-change-theme-color': WindowEvent<Topic, Type>;
+        'focused': WindowEvent<Topic, Type>;
+        'found-in-page': WindowEvent<Topic, Type>;
+        'navigation-rejected': WindowNavigationRejectedEvent<Topic, Type>;
+        'page-favicon-updated': FaviconUpdatedEvent<Topic, Type>;
+        'page-title-updated': PageTitleUpdatedEvent<Topic, Type>;
+        'resource-load-failed': WindowResourceLoadFailedEvent<Topic, Type>;
+        'resource-response-received': WindowResourceResponseReceivedEvent<Topic, Type>;
+    }
+
+    export interface RunRequestedEvent<Topic, Type> extends ApplicationEvent<Topic, Type> {
+        userAppConfigArgs: any;
+        manifest: OpenFin.ManifestInfo;
+    }
+
+    export interface TrayIconClicked<Topic, Type> extends ApplicationEvent<Topic, Type> {
+        button: 0 | 1 | 2;
+        bounds: OpenFin.Rectangle;
+        x: number;
+        y: number;
+        monitorInfo: any;
+    }
+
+    export interface WindowAlertRequestedEvent<Topic, Type> extends WindowEvent<Topic, Type> {
+        message: string;
+        url: string;
+    }
+
+    export interface WindowAuthRequestedEvent<Topic, Type> extends WindowEvent<Topic, Type> {
+        authInfo: {
+            host: string;
+            isProxy: boolean;
+            port: number;
+            realm: string;
+            scheme: string;
+        };
+    }
+
+    export interface WindowEndLoadEvent<Topic, Type> extends WindowEvent<Topic, Type> {
+        documentName: string;
+        isMain: boolean;
+    }
+
+    export interface WindowReloadedEvent<Topic, Type> extends WindowEvent<Topic, Type> {
+        url: string;
+    }
+
+    export interface WindowOptionsChangedEvent<Topic, Type> extends WindowEvent<Topic, Type> {
+        options: OpenFin.WindowOptions;
+        diff: OpenFin.WindowOptionDiff;
+    }
+
+    export interface WindowExternalProcessExitedEvent<Topic, Type> extends WindowEvent<Topic, Type> {
+        processUuid: string;
+        exitCode: number;
+    }
+
+    export interface WindowExternalProcessStartedEvent<Topic, Type> extends WindowEvent<Topic, Type> {
+        processUuid: string;
+    }
+
+    export interface WindowHiddenEvent<Topic, Type> extends WindowEvent<Topic, Type> {
+        reason: 'closing' | 'hide' | 'hide-on-close';
+    }
+
+    export interface PreloadScriptInfoRunning {
+        state:
+            | 'load-started' // started loading preload script
+            | 'load-failed' // preload script failed to load
+            | 'load-succeeded' // preload script is loaded and ready to be eval'ed
+            | 'failed' // preload script failed to eval
+            | 'succeeded'; // preload script eval'ed successfully
+    }
+
+    export interface PreloadScriptInfo {
+        state:
+            | 'load-failed' // preload script failed to load
+            | 'failed' // preload script failed to eval
+            | 'succeeded'; // preload script eval'ed successfully
+    }
+    export interface WindowPreloadScriptsStateChangeEvent<Topic, Type> extends WindowEvent<Topic, Type> {
+        preloadScripts: (PreloadScriptInfoRunning & any)[];
+    }
+    export interface WindowPreloadScriptsStateChangedEvent<Topic, Type> extends WindowEvent<Topic, Type> {
+        preloadScripts: (PreloadScriptInfoRunning & any)[];
+    }
+
+    export interface WindowBeginBoundsChangingEvent<Topic, Type> extends WindowEvent<Topic, Type> {
+        height: number;
+        left: number;
+        top: number;
+        width: number;
+        windowState: 'minimized' | 'normal' | 'maximized';
+    }
+
+    export interface WindowEndBoundsChangingEvent<Topic, Type> extends WindowEvent<Topic, Type> {
+        height: number;
+        left: number;
+        top: number;
+        width: number;
+        windowState: 'minimized' | 'normal' | 'maximized';
+    }
+
+    export interface WindowBoundsChange<Topic, Type> extends WindowEvent<Topic, Type> {
+        changeType: 0 | 1 | 2;
+        deferred: boolean;
+        height: number;
+        left: number;
+        top: number;
+        width: number;
+    }
+
+    export interface WillMoveOrResize<Topic, Type> extends WindowEvent<Topic, Type> {
+        height: number;
+        left: number;
+        top: number;
+        width: number;
+        monitorScaleFactor: number;
+    }
+
+    export type WindowPerformanceReport<Topic, Type> = Performance & WindowEvent<Topic, Type>;
+
+    export interface ViewDetached<Topic, Type> extends WindowEvent<Topic, Type> {
+        previousTarget: OpenFin.Identity;
+        target: OpenFin.Identity;
+        viewIdentity: OpenFin.Identity;
+    }
+
+    export interface WindowEventMapping<Topic = string, Type = string> extends WebContentsEventMapping {
+        'auth-requested': WindowAuthRequestedEvent<Topic, Type>;
+        'begin-user-bounds-changing': WindowBeginBoundsChangingEvent<Topic, Type>;
+        'bounds-changed': WindowBoundsChange<Topic, Type>;
+        'bounds-changing': WindowBoundsChange<Topic, Type>;
+        'close-requested': WindowEvent<Topic, Type>;
+        'closed': WindowEvent<Topic, Type>;
+        'closing': WindowEvent<Topic, Type>;
+        'disabled-movement-bounds-changed': WindowBoundsChange<Topic, Type>;
+        'disabled-movement-bounds-changing': WindowBoundsChange<Topic, Type>;
+        'embedded': WindowEvent<Topic, Type>;
+        'end-user-bounds-changing': WindowEndBoundsChangingEvent<Topic, Type>;
+        'external-process-exited': WindowExternalProcessExitedEvent<Topic, Type>;
+        'external-process-started': WindowExternalProcessStartedEvent<Topic, Type>;
+        'hidden': WindowHiddenEvent<Topic, Type>;
+        'hotkey': InputEvent & WindowEvent<Topic, Type>;
+        'initialized': WindowEvent<Topic, Type>;
+        'layout-initialized': WindowEvent<Topic, Type>;
+        'layout-ready': WindowEvent<Topic, Type>;
+        'maximized': WindowEvent<Topic, Type>;
+        'minimized': WindowEvent<Topic, Type>;
+        'options-changed': WindowOptionsChangedEvent<Topic, Type>;
+        'performance-report': WindowPerformanceReport<Topic, Type>;
+        'preload-scripts-state-changed': WindowPreloadScriptsStateChangeEvent<Topic, Type>;
+        'preload-scripts-state-changing': WindowPreloadScriptsStateChangeEvent<Topic, Type>;
+        'reloaded': WindowReloadedEvent<Topic, Type>;
+        'restored': WindowEvent<Topic, Type>;
+        'show-requested': WindowEvent<Topic, Type>;
+        'shown': WindowEvent<Topic, Type>;
+        'user-movement-disabled': WindowEvent<Topic, Type>;
+        'user-movement-enabled': WindowEvent<Topic, Type>;
+        'view-attached': WindowEvent<Topic, Type>;
+        'view-detached': ViewDetached<Topic, Type>;
+        'will-move': WillMoveOrResize<Topic, Type>;
+        'will-resize': WillMoveOrResize<Topic, Type>;
+    }
+
+    export interface PropagatedWindowEventMapping<Topic = string, Type = string> extends BaseEventMap {
+        'window-begin-user-bounds-changing': WindowBeginBoundsChangingEvent<Topic, Type>;
+        'window-blurred': WindowEvent<Topic, Type>;
+        'window-bounds-changed': WindowBoundsChange<Topic, Type>;
+        'window-bounds-changing': WindowBoundsChange<Topic, Type>;
+        'window-certificate-selection-shown': CertificateSelectionShownEvent<Topic, Type>;
+        'window-closed': WindowEvent<Topic, Type>;
+        'window-closing': WindowEvent<Topic, Type>;
+        'window-crashed': CrashedEvent & WindowEvent<Topic, Type>;
+        'window-disabled-movement-bounds-changed': WindowBoundsChange<Topic, Type>;
+        'window-disabled-movement-bounds-changing': WindowBoundsChange<Topic, Type>;
+        'window-embedded': WindowEvent<Topic, Type>;
+        'window-end-user-bounds-changing': WindowBeginBoundsChangingEvent<Topic, Type>;
+        'window-external-process-exited': WindowExternalProcessExitedEvent<Topic, Type>;
+        'window-external-process-started': WindowExternalProcessStartedEvent<Topic, Type>;
+        'window-focused': WindowEvent<Topic, Type>;
+        'window-hidden': WindowHiddenEvent<Topic, Type>;
+        'window-hotkey': InputEvent & WindowEvent<Topic, Type>;
+        'window-initialized': WindowEvent<Topic, Type>;
+        'window-layout-initialized': WindowEvent<Topic, Type>;
+        'window-layout-ready': WindowEvent<Topic, Type>;
+        'window-maximized': WindowEvent<Topic, Type>;
+        'window-minimized': WindowEvent<Topic, Type>;
+        'window-navigation-rejected': WindowNavigationRejectedEvent<Topic, Type>;
+        'window-options-changed': WindowOptionsChangedEvent<Topic, Type>;
+        'window-performance-report': WindowPerformanceReport<Topic, Type>;
+        'window-preload-scripts-state-changed': WindowPreloadScriptsStateChangeEvent<Topic, Type>;
+        'window-preload-scripts-state-changing': WindowPreloadScriptsStateChangedEvent<Topic, Type>;
+        'window-resource-load-failed': WindowResourceLoadFailedEvent<Topic, Type>;
+        'window-resource-response-received': WindowResourceResponseReceivedEvent<Topic, Type>;
+        'window-reloaded': WindowReloadedEvent<Topic, Type>;
+        'window-restored': WindowEvent<Topic, Type>;
+        'window-shown': WindowEvent<Topic, Type>;
+        'window-user-movement-disabled': WindowEvent<Topic, Type>;
+        'window-user-movement-enabled': WindowEvent<Topic, Type>;
+        'window-will-move': WillMoveOrResize<Topic, Type>;
+        'window-will-resize': WillMoveOrResize<Topic, Type>;
+    }
+
+    export interface ViewEventMapping<Topic = string, Type = string> extends WebContentsEventMapping {
+        'attached': WindowEvent<Topic, Type>;
+        'created': WindowEvent<Topic, Type>;
+        'destroyed': WindowEvent<Topic, Type>;
+        'hidden': WindowEvent<Topic, Type>;
+        'hotkey': InputEvent & WindowEvent<Topic, Type>;
+        'shown': WindowEvent<Topic, Type>;
+        'target-changed': TargetChangedEvent<Topic, Type>;
+    }
+
+    interface PropagatedViewIdentity {
+        viewIdentity: OpenFin.Identity;
+    }
+
+    export interface PropagatedViewEventMapping<Topic = string, Type = string> extends BaseEventMap {
+        'view-blurred': WindowEvent<Topic, Type> & PropagatedViewIdentity;
+        'view-certificate-selection-shown': CertificateSelectionShownEvent<Topic, Type> & PropagatedViewIdentity;
+        'view-crashed': CrashedEvent & WindowEvent<Topic, Type> & PropagatedViewIdentity;
+        'view-created': CrashedEvent & WindowEvent<Topic, Type> & PropagatedViewIdentity;
+        'view-destroyed': WindowEvent<Topic, Type> & PropagatedViewIdentity;
+        'view-did-change-theme-color': WindowEvent<Topic, Type> & PropagatedViewIdentity;
+        'view-focused': WindowEvent<Topic, Type> & PropagatedViewIdentity;
+        'view-hidden': WindowEvent<Topic, Type> & PropagatedViewIdentity;
+        'view-hotkey': InputEvent & WindowEvent<Topic, Type> & PropagatedViewIdentity;
+        'view-navigation-rejected': WindowNavigationRejectedEvent<Topic, Type> & PropagatedViewIdentity;
+        'view-page-favicon-updated': WindowEvent<Topic, Type> & PropagatedViewIdentity;
+        'view-page-title-updated': WindowEvent<Topic, Type> & PropagatedViewIdentity;
+        'view-resource-load-failed': WindowResourceLoadFailedEvent<Topic, Type> & PropagatedViewIdentity;
+        'view-resource-response-received': WindowResourceResponseReceivedEvent<Topic, Type> & PropagatedViewIdentity;
+        'view-shown': WindowEvent<Topic, Type> & PropagatedViewIdentity;
+        'view-target-changed': TargetChangedEvent<Topic, Type> & PropagatedViewIdentity;
+    }
+
+    export type ViewEvents = {
+        [Type in keyof ViewEventMapping]: ViewEventMapping<'view', Type>[Type];
+    };
+
+    export type PropagatedViewEvents<Topic> = {
+        [Type in keyof PropagatedViewEventMapping]: PropagatedViewEventMapping<Topic, Type>[Type];
+    };
+
+    export interface InputEvent {
+        inputType: 'keyUp' | 'keyDown';
+        ctrlKey: boolean;
+        shiftKey: boolean;
+        altKey: boolean;
+        metaKey: boolean;
+        key: string;
+        code: string;
+        repeat: boolean;
+        command?: string;
+    }
+
+    export interface TargetChangedEvent<Topic, Type> extends WindowEvent<Topic, Type> {
+        previousTarget: OpenFin.Identity;
+        target: OpenFin.Identity;
+    }
+
+    // This is the type we should be using. It takes the more generic mapping and applies the proper Topic and Type to each event
+    export type WindowEvents = PropagatedViewEventMapping<'window'> &
+        {
+            [Type in keyof WindowEventMapping]: WindowEventMapping<'window', Type>[Type];
+        };
+
+    export type PropagatedWindowEvents<Topic> = {
+        [Type in keyof PropagatedWindowEventMapping]: PropagatedWindowEventMapping<Topic, Type>[Type];
+    };
+
+    export interface ApplicationEventMapping<Topic = string, Type = string> extends BaseEventMap {
+        'closed': ApplicationEvent<Topic, Type>;
+        'connected': ApplicationEvent<Topic, Type>;
+        'crashed': CrashedEvent & ApplicationEvent<Topic, Type>;
+        'initialized': ApplicationEvent<Topic, Type>;
+        'manifest-changed': ApplicationEvent<Topic, Type>;
+        'not-responding': ApplicationEvent<Topic, Type>;
+        'responding': ApplicationEvent<Topic, Type>;
+        'run-requested': RunRequestedEvent<Topic, Type>;
+        'started': ApplicationEvent<Topic, Type>;
+        'tray-icon-clicked': TrayIconClicked<Topic, Type>;
+        'window-alert-requested': WindowAlertRequestedEvent<Topic, Type>;
+        'window-auth-requested': WindowAuthRequestedEvent<Topic, Type>;
+        'window-created': WindowEvent<Topic, Type>;
+        'window-end-load': WindowEndLoadEvent<Topic, Type>;
+        'window-not-responding': WindowEvent<Topic, Type>;
+        'window-performance-report': WindowPerformanceReport<Topic, Type>;
+        'window-responding': WindowEvent<Topic, Type>;
+        'window-show-requested': WindowEvent<Topic, Type>;
+        'window-start-load': WindowEvent<Topic, Type>;
+    }
+
+    export interface PropagatedApplicationEventMapping<Topic = string, Type = string> {
+        'application-closed': ApplicationEvent<Topic, Type>;
+        'application-connected': ApplicationEvent<Topic, Type>;
+        'application-crashed': CrashedEvent & ApplicationEvent<Topic, Type>;
+        'application-initialized': ApplicationEvent<Topic, Type>;
+        'application-manifest-changed': ApplicationEvent<Topic, Type>;
+        'application-not-responding': ApplicationEvent<Topic, Type>;
+        'application-responding': ApplicationEvent<Topic, Type>;
+        'application-started': ApplicationEvent<Topic, Type>;
+        'application-tray-icon-clicked': TrayIconClicked<Topic, Type>;
+        'window-created': WindowEvent<Topic, Type>;
+        'window-did-change-theme-color': WindowEvent<Topic, Type>;
+        'window-end-load': WindowEndLoadEvent<Topic, Type>;
+        'window-not-responding': WindowEvent<Topic, Type>;
+        'window-page-favicon-updated': WindowEvent<Topic, Type>;
+        'window-page-title-updated': WindowEvent<Topic, Type>;
+        'window-performance-report': WindowPerformanceReport<Topic, Type>;
+        'window-responding': WindowEvent<Topic, Type>;
+        'window-start-load': WindowEvent<Topic, Type>;
+    }
+
+    export type ApplicationEvents = PropagatedWindowEvents<'application'> &
+        PropagatedViewEvents<'application'> &
+        {
+            [Type in keyof ApplicationEventMapping]: ApplicationEventMapping<'application', Type>[Type];
+        };
+    export type PropagatedApplicationEvents<Topic> = {
+        [Type in keyof PropagatedApplicationEventMapping]: PropagatedApplicationEventMapping<Topic, Type>[Type];
+    };
+
+    export interface PlatformEventMapping<Topic = string, Type = string> extends ApplicationEventMapping {
+        'platform-api-ready': ApplicationEvent<Topic, Type>;
+        'platform-snapshot-applied': ApplicationEvent<Topic, Type>;
+    }
+
+    export interface PropagatedPlatformEventMapping<Topic = string, Type = string>
+        extends PropagatedApplicationEventMapping {
+        'platform-api-ready': ApplicationEvent<Topic, Type>;
+        'platform-snapshot-applied': ApplicationEvent<Topic, Type>;
+    }
+
+    export type PlatformEvents = PropagatedWindowEvents<'application'> &
+        PropagatedViewEvents<'application'> &
+        {
+            [Type in keyof PlatformEventMapping]: PlatformEventMapping<'application', Type>[Type];
+        };
+    export type PropagatedPlatformEvents<Topic> = {
+        [Type in keyof PropagatedPlatformEventMapping]: PropagatedPlatformEventMapping<Topic, Type>[Type];
+    };
+
+    export interface IdleEvent<Topic, Type> extends BaseEvent<Topic, Type> {
+        elapsedTime: number;
+        isIdle: boolean;
+    }
+
+    export type MonitorEvent<Topic, Type> = OpenFin.MonitorInfo & BaseEvent<Topic, Type>;
+
+    export interface SessionChangedEvent<Topic, Type> extends BaseEvent<Topic, Type> {
+        reason: 'lock' | 'unlock' | 'remote-connect' | 'remote-disconnect' | 'unknown';
+    }
+
+    export interface SystemEventMapping<Topic = string, Type = string> extends BaseEventMap {
+        'application-created': ApplicationEvent<Topic, Type>;
+        'desktop-icon-clicked': ApplicationEvent<Topic, Type>;
+        'idle-state-changed': IdleEvent<Topic, Type>;
+        'monitor-info-changed': MonitorEvent<Topic, Type>;
+        'session-changed': SessionChangedEvent<Topic, Type>;
+    }
+    export type SystemEvents = PropagatedWindowEvents<'system'> &
+        PropagatedApplicationEvents<'system'> &
+        PropagatedViewEvents<'system'> &
+        {
+            [Type in keyof SystemEventMapping]: SystemEventMapping<'system', Type>[Type];
+        };
+
+    export interface GlobalHotkeyEvent<Type> extends RuntimeEvent<'global-hotkey', Type> {
+        identity: Identity;
+        hotkey: string;
+    }
+
+    export interface GlobalHotkeyEvents extends BaseEventMap {
+        registered: GlobalHotkeyEvent<'registered'>;
+        unregistered: GlobalHotkeyEvent<'unregistered'>;
+    }
+
+    export interface ExternalApplicationEvents extends BaseEventMap {
+        connected: RuntimeEvent<'externalapplication', 'connected'>;
+        disconnected: RuntimeEvent<'externalapplication', 'disconnected'>;
+    }
+
+    export type ChannelAction = (payload: unknown, id: ProviderIdentity | OpenFin.ClientIdentity) => unknown;
+
+    export type ChannelMiddleware = (
+        topic: string,
+        payload: unknown,
+        senderIdentity: ProviderIdentity | OpenFin.ClientIdentity
+    ) => unknown;
+
+    export type ErrorMiddleware = (
+        topic: string,
+        error: Error,
+        id: ProviderIdentity | OpenFin.ClientIdentity
+    ) => unknown;
+
+    export interface SystemApplicationInfo {
+        isPlatform: boolean;
+        isRunning: boolean;
+        uuid: string;
+        parentUuid?: string;
+    }
+
+    export interface InstalledApps {
+        [key: string]: InstallationInfo;
+    }
+
+    export interface InstallationInfo {
+        cachedManifest: any;
+    }
+
+    export interface GetLogRequestType {
+        name: string;
+        endFile?: string;
+        sizeLimit?: number;
+    }
+
+    export interface LogInfo {
+        name: string;
+        size: number;
+        date: string;
+    }
+
+    // 2.4 supports string enum types, currently we use 2.2
+    export type LogLevel = 'verbose' | 'info' | 'warning' | 'error' | 'fatal';
+
+    export interface ProcessInfo {
+        cpuUsage?: number;
+        name?: string;
+        nonPagedPoolUsage?: number;
+        pageFaultCount?: number;
+        pagedPoolUsage?: number;
+        pagefileUsage?: number;
+        peakNonPagedPoolUsage?: number;
+        peakPagedPoolUsage?: number;
+        peakPagefileUsage?: number;
+        peakWorkingSetSize?: number;
+        processId?: number;
+        uuid?: string;
+        workingSetSize?: number;
+    }
+
+    export type PermissionState = 'granted' | 'denied' | 'unavailable';
+
+    export interface RegistryInfo {
+        data: any;
+        rootKey: string;
+        subkey: string;
+        type: string;
+        value: string;
+    }
+
+    export interface Entity {
+        type: string;
+        uuid: string;
+    }
+
+    export interface WindowInfo {
+        childWindows: Array<WindowDetail>;
+        mainWindow: WindowDetail;
+        uuid: string;
+    }
+
+    export interface WindowDetail {
+        bottom: number;
+        height: number;
+        isShowing: boolean;
+        left: number;
+        name: string;
+        right: number;
+        state: string;
+        top: number;
+        width: number;
+    }
+
+    export interface WebOptions {
+        preloadScripts?: OpenFin.PreloadScript[];
+        uuid: string;
+        name: string;
+        contentCreation?: OpenFin.ContentCreationOptions;
+        contentRedirect?: Partial<OpenFin.ContentRedirect>;
+        customContext?: any;
+        experimental?: any;
+        processAffinity?: string;
+        backgroundThrottling?: boolean;
+        interop?: OpenFin.InteropConfig;
+    }
+
+    // Error types
+    export type ERROR_BOX_TYPES =
+        | 'OF_error_box:app_initialization'
+        | 'OF_error_box:main_process'
+        | 'OF_error_box:renderer_crash';
+
+    export type LayoutPresetType = 'columns' | 'grid' | 'rows' | 'tabs';
+
+    export interface InitLayoutOptions {
+        containerId?: string;
+    }
+
+    export interface PresetLayoutOptions {
+        presetType: LayoutPresetType;
+    }
+
+    export interface DragPayload {
+        'view-config': OpenFin.ViewCreationOptions;
+        'view-identity': [string, string, string]; // [componentState, uuid, name]
+    }
+
+    export interface Message<T> {
+        action: string;
+        payload: T;
+        correlationId?: number;
+    }
+
+    export interface EventMessage extends Message<RuntimeEvent> {
+        action: 'process-desktop-event';
+        payload: RuntimeEvent;
+    }
+
+    export interface Payload {
+        success: boolean;
+        data: any;
+    }
+
+    export interface AuthorizationPayload {
+        token: string;
+        file: string;
+    }
+
+    /*
+    To Add an api call:
+    1. The action (string passed to wire.sendAction and key in the actionMap on the core side) should be the key in the protocolmap
+    2. The request for that key is the interface of the second object passed to wire.sendAction, it will be picked up as message.payload in the handler
+    3. The response for that key is what the core api handler either returns or passes to "ack". It will be the 'data' property of the return value of wire.sendAction
+    */
+    export 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;
+        };
+        'get-view-window': {
+            request: OpenFin.Identity;
+            response: OpenFin.Identity;
+        };
+        'window-get-views': {
+            request: OpenFin.Identity;
+            response: OpenFin.Identity[];
+        };
+        'hide-view': {
+            request: OpenFin.Identity;
+            response: void;
+        };
+        'launch-manifest': {
+            request: { manifestUrl: string; opts?: OpenFin.RvmLaunchOptions };
+            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': {
+            request: void;
+            response: any;
+        };
+        'set-file-download-location': {
+            request: OpenFin.ApplicationIdentity & { downloadLocation: string };
+            response: void;
+        };
+        'close-popup-menu': {
+            request: OpenFin.Identity;
+            response: void;
+        };
+        'fdc3-add-context-listener': {
+            request: void;
+            response: void;
+        };
+        'fdc3-broadcast': {
+            request: void;
+            response: void;
+        };
+        'fdc3-get-system-channels': {
+            request: void;
+            response: void;
+        };
+        'fdc3-join-channel': {
+            request: void;
+            response: void;
+        };
+        'fdc3-leave-current-channel': {
+            request: void;
+            response: void;
+        };
+        'interop-connect-sync': {
+            request: void;
+            response: void;
+        };
+        'interop-client-set-context': {
+            request: void;
+            response: void;
+        };
+        'interop-client-add-context-handler': {
+            request: void;
+            response: void;
+        };
+        'interop-client-get-context-groups': {
+            request: void;
+            response: void;
+        };
+        'interop-client-join-context-group': {
+            request: void;
+            response: void;
+        };
+        'interop-client-remove-from-context-group': {
+            request: void;
+            response: void;
+        };
+        'interop-client-get-all-clients-in-context-group': {
+            request: void;
+            response: void;
+        };
+        'interop-client-get-info-for-context-group': {
+            request: void;
+            response: void;
+        };
+        'interop-broker-add-client-to-context-group': {
+            request: void;
+            response: void;
+        };
+        'interop-broker-get-all-clients-in-context-group': {
+            request: void;
+            response: void;
+        };
+        'interop-broker-get-context-groups': {
+            request: void;
+            response: void;
+        };
+        'interop-broker-get-info-for-context-group': {
+            request: void;
+            response: void;
+        };
+        'interop-broker-is-action-authorized': {
+            request: void;
+            response: void;
+        };
+        'interop-broker-is-connection-authorized': {
+            request: void;
+            response: void;
+        };
+        'interop-broker-join-context-group': {
+            request: void;
+            response: void;
+        };
+        'interop-broker-remove-client-from-context-group': {
+            request: void;
+            response: void;
+        };
+        'interop-broker-remove-from-context-group': {
+            request: void;
+            response: void;
+        };
+        'interop-broker-set-context': {
+            request: void;
+            response: void;
+        };
+        'query-permission-for-current-context': {
+            request: { apiName: string; identity: OpenFin.Identity };
+            response: OpenFin.QueryPermissionResult;
+        };
+    }
+
+    interface ProtocolMapBase {
+        [action: string]: {
+            request: any;
+            response: any;
+            specialResponse?: any; // Used for anything not on payload.data (only request-external-authorization for now)
+        };
+    }
+
+    export type MessageHandler = (data: any) => boolean;
+
+    export interface ViewState extends OpenFin.ViewCreationOptions {
+        url: string;
+    }
+
+    export interface OsConfig {
+        manifestLocation: string;
+        namedPipeName: string;
+        urlPath: string;
+        executablePath: string;
+    }
+
+    export interface Wire extends EventEmitter {
+        connect(address: string): Promise<any>;
+        connectSync(): any;
+        send(data: any): Promise<any>;
+        shutdown(): Promise<void>;
+    }
+    export interface WireConstructor {
+        new (onmessage: (data: any) => void): Wire;
+    }
+
+    export interface RuntimeConfig {
+        version: string;
+        fallbackVersion?: string;
+        securityRealm?: string;
+        verboseLogging?: boolean;
+        arguments?: string;
+        rvmDir?: string;
+    }
+
+    export interface ServiceConfig {
+        name: string;
+        manifestUrl: string;
+    }
+
+    export interface 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; // in seconds
+    }
+
+    export interface ConfigWithUuid extends BaseConfig {
+        uuid: string;
+    }
+
+    export interface ExistingConnectConfig extends ConfigWithUuid {
+        address: string;
+    }
+
+    export interface ConfigWithRuntime extends BaseConfig {
+        runtime: RuntimeConfig;
+    }
+
+    export interface ExternalConfig extends BaseConfig {
+        manifestUrl: string;
+    }
+
+    export type NewConnectConfig = ConfigWithUuid & ConfigWithRuntime;
+
+    export type PortDiscoveryConfig = (ExternalConfig & ConfigWithRuntime) | NewConnectConfig;
+
+    export type ConnectConfig = ExistingConnectConfig | NewConnectConfig | ExternalConfig;
+
+    export type InternalConnectConfig = ExistingConnectConfig | NewConnectConfig;
+
+    export type ReadyState =  // https://github.com/websockets/ws/blob/master/doc/ws.md#ready-state-constants
+        | 'CONNECTING' // The connection is not yet open.
+        | 'OPEN' // The connection is open and ready to communicate.
+        | 'CLOSING' // The connection is in the process of closing.
+        | 'CLOSED'; // The connection is closed.
+
+    export interface ChildContentOptions {
+        options: any;
+        entityType: EntityType;
+    }
+
+    export interface ErrorPlainObject {
+        stack: string;
+        message: string;
+        toString(): string;
+    }
 }