@openfin/core 25.68.27 → 25.68.30

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;
@@ -14,63 +17,64 @@ declare namespace OpenFin {
     export type InteropBroker = import('./src/api/interop/index').InteropBroker;
     export type SnapshotSource = import('./src/api/snapshot-source/index').SnapshotSource;
 
-    export interface ApplicationIdentity {
+    export type ApplicationIdentity = {
         // used for applications
         uuid: string;
-    }
+    };
 
-    export interface Identity {
+    export type Identity = {
         // used for views/windows/frames
         uuid: string;
         name: string;
-    }
+    };
 
-    export interface ClientIdentity {
+    export type ClientIdentity = {
         uuid: string;
         name: string;
         endpointId: string;
         isLocalEndpointId: boolean; // If true, this connection is from a legacy client.
-    }
+    };
 
-    export interface ClientIdentityMultiRuntime extends ClientIdentity {
+    export type ClientIdentityMultiRuntime = ClientIdentity & {
         runtimeUuid: string;
-    }
+    };
 
-    export interface EntityInfo {
+    export type EntityInfo = {
         uuid: string;
         name: string;
         entityType: EntityType;
-    }
-    export type EntityType = import('./src/shapes/EntityType').EntityType;
+    };
 
-    export interface Bounds {
+    export type EntityType = 'window' | 'iframe' | 'external connection' | 'view' | 'unknown';
+
+    export type Bounds = {
         top: number;
         left: number;
         height: number;
         width: number;
-    }
+    };
 
     /**
      * Returned from getBounds call. bottom and right are never used for setting.
      */
-    export interface WindowBounds extends Bounds {
+    export type WindowBounds = Bounds & {
         bottom: number;
         right: number;
-    }
+    };
 
-    export interface Rectangle {
+    export type Rectangle = {
         x: number;
         y: number;
         width: number;
         height: number;
-    }
+    };
 
-    export interface ApplicationCreationOptions extends Partial<ApplicationOption> {
+    export type ApplicationCreationOptions = Partial<ApplicationOption> & {
         name: string;
         uuid: string;
-    }
+    };
 
-    export interface ApplicationOption extends LegacyWinOptionsInAppOptions {
+    export type ApplicationOption = LegacyWinOptionsInAppOptions & {
         disableIabSecureLogging: boolean;
         loadErrorMessage: string;
         mainWindowOptions: WindowCreationOptions;
@@ -92,18 +96,18 @@ declare namespace OpenFin {
         apiDiagnostics: boolean;
         defaultDomainSettings: DefaultDomainSettings;
         enableJumpList: boolean;
-    }
+    };
 
-    interface InteropBrokerOptions {
+    type InteropBrokerOptions = {
         contextGroups?: ContextGroupInfo;
-    }
+    };
 
-    export interface ContextGroupInfo {
+    export type ContextGroupInfo = {
         id: string;
         displayMetadata?: DisplayMetadata;
-    }
+    };
 
-    export interface DisplayMetadata {
+    export type DisplayMetadata = {
         /**
          * A user-readable name for this context group, e.g: `"Red"`
          */
@@ -116,7 +120,7 @@ declare namespace OpenFin {
          * A URL of an image that can be used to display this context group
          */
         readonly glyph?: string;
-    }
+    };
 
     export type LegacyWinOptionsInAppOptions = Pick<
         WindowCreationOptions,
@@ -158,7 +162,7 @@ declare namespace OpenFin {
         | 'waitForPageLoad'
     >;
 
-    export interface Snapshot {
+    export type Snapshot = {
         windows: WindowCreationOptions[];
         snapshotDetails?: {
             monitorInfo: MonitorInfo;
@@ -168,23 +172,23 @@ declare namespace OpenFin {
         interopSnapshotDetails?: {
             contextGroupStates: ContextGroupStates;
         };
-    }
+    };
 
-    export interface ContextGroupStates {
+    export type ContextGroupStates = {
         [key: string]: {
             [key: string]: Context;
         };
-    }
+    };
 
-    export interface Context {
+    export type Context = {
         id?: {
             [key: string]: string;
         };
         name?: string;
         type: string;
-    }
+    };
 
-    export interface MonitorInfo {
+    export type MonitorInfo = {
         deviceScaleFactor: number;
         dpi: Point;
         nonPrimaryMonitors: MonitorDetails[];
@@ -192,26 +196,26 @@ declare namespace OpenFin {
         reason: string;
         taskbar: TaskBar;
         virtualScreen: DipRect;
-    }
+    };
 
-    export interface Point {
+    export type Point = {
         x: number;
         y: number;
-    }
+    };
 
-    export interface PointTopLeft {
+    export type PointTopLeft = {
         top: number;
         left: number;
-    }
+    };
 
-    export interface RectangleByEdgePositions {
+    export type RectangleByEdgePositions = {
         top: number;
         left: number;
         bottom: number;
         right: number;
-    }
+    };
 
-    export interface MonitorDetails {
+    export type MonitorDetails = {
         available: DipScaleRects;
         availableRect: RectangleByEdgePositions;
         deviceId: string | number; // Number on mac
@@ -221,32 +225,36 @@ declare namespace OpenFin {
         name: string | number; // Number on mac
         dpi: Point;
         monitor: DipScaleRects;
-    }
+    };
 
-    export interface DipRect extends RectangleByEdgePositions {
+    export type DipRect = RectangleByEdgePositions & {
         dipRect: RectangleByEdgePositions;
         scaledRect: RectangleByEdgePositions;
-    }
+    };
 
-    export interface DipScaleRects {
+    export type DipScaleRects = {
         dipRect: RectangleByEdgePositions;
         scaledRect: RectangleByEdgePositions;
-    }
+    };
 
-    export interface TaskBar extends DipScaleRects {
+    export type TaskBar = DipScaleRects & {
         edge: string;
         rect: RectangleByEdgePositions;
-    }
+    };
 
-    export interface WindowCreationOptions extends Partial<WindowOptions> {
+    export type WindowCreationOptions = Partial<WindowOptions> & {
         name: string;
-    }
+    };
+
+    export type UpdatableWindowOptions = Partial<MutableWindowOptions>;
 
-    export interface DefaultWindowOptions extends WindowOptions {
+    export type DefaultWindowOptions = WindowOptions & {
         permissions: Partial<Permissions>;
-    }
+    };
+
+    export type WindowOptions = MutableWindowOptions & ConstWindowOptions;
 
-    export interface WindowOptions extends WindowUpdatableOptions {
+    export type ConstWindowOptions = {
         accelerator: Partial<Accelerator>;
         api: Api;
         applicationIcon: string;
@@ -284,9 +292,9 @@ declare namespace OpenFin {
         y: number;
         experimental?: any;
         fdc3InteropApi?: string;
-    }
+    };
 
-    export interface WindowUpdatableOptions {
+    export type MutableWindowOptions = {
         alphaMask: RGB;
         alwaysOnTop: boolean;
         aspectRatio: number;
@@ -311,73 +319,21 @@ declare namespace OpenFin {
         showTaskbarIcon: boolean;
         interop: InteropConfig;
         workspacePlatform: WorkspacePlatformOptions;
-    }
+    };
 
-    export interface WorkspacePlatformOptions {
-        pages: Page[];
+    export type WorkspacePlatformOptions = {
         /** Leaving this as any for now until we figure out what the shape should look like in Workspace */
         [key: string]: any;
-    }
-
-    type LayoutSettingsExtended = LayoutOptions['settings'] & {
-        reorderEnabled?: boolean;
-    };
-
-    type LayoutComponentStateExtended = LayoutComponent['componentState'] & { name: string; uuid: string };
-
-    type LayoutComponentExtended = Omit<OpenFin.LayoutComponent, 'componentState'> & {
-        componentState: LayoutComponentStateExtended;
-    };
-
-    type LayoutStack = { type: 'stack'; content: LayoutContent };
-
-    type LayoutContentItemExtended = OpenFin.LayoutRow | OpenFin.LayoutColumn | LayoutComponentExtended | LayoutStack;
-
-    type LayoutContentExtended = LayoutContentItemExtended[];
-
-    type LayoutExtended = {
-        settings: LayoutSettingsExtended;
-        content: LayoutContentExtended;
     };
 
-    interface PageLayoutDetails {
-        /** The id of the machine that created the page. */
-        machineId: string;
-
-        /** The name of the machine that created the page. */
-        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 {
+    export type WebRequestHeader = {
         [key: string]: string;
-    }
+    };
 
-    export interface CustomRequestHeaders {
+    export type CustomRequestHeaders = {
         urlPatterns: string[];
         headers: WebRequestHeader[]; // key=value is added to headers
-    }
+    };
 
     export type WindowOptionDiff = {
         [key in keyof WindowOptions]: {
@@ -386,7 +342,7 @@ declare namespace OpenFin {
         };
     };
 
-    export interface ResizeRegion {
+    export type ResizeRegion = {
         size?: number;
         bottomRightCorner?: number;
         sides?: {
@@ -395,76 +351,76 @@ declare namespace OpenFin {
             left?: boolean;
             right?: boolean;
         };
-    }
+    };
 
-    export interface Accelerator {
+    export type Accelerator = {
         devtools: boolean;
         reload: boolean;
         reloadIgnoringCache: boolean;
         zoom: boolean;
-    }
+    };
 
-    export interface Api {
+    export type Api = {
         iframe?: {
             crossOriginInjection?: boolean;
             sameOriginInjection?: boolean;
             enableDeprecatedSharedName?: boolean;
         };
-    }
+    };
 
-    export interface ContentNavigation {
+    export type ContentNavigation = {
         whitelist?: string[];
         blacklist?: string[];
-    }
+    };
 
-    export interface ContentRedirect {
+    export type ContentRedirect = {
         whitelist: string[];
         blacklist: string[];
-    }
+    };
 
-    export interface CornerRounding {
+    export type CornerRounding = {
         height: number;
         width: number;
-    }
+    };
 
-    export interface DownloadPreloadOption {
+    export type DownloadPreloadOption = {
         url: string;
-    }
+    };
 
-    export interface DownloadPreloadInfo {
+    export type DownloadPreloadInfo = {
         success: boolean;
         url?: string;
         error: string;
-    }
+    };
 
-    export interface RGB {
+    export type RGB = {
         red: number;
         blue: number;
         green: number;
-    }
+    };
 
-    export interface ContextMenuSettings {
+    export type ContextMenuSettings = {
         enable: boolean;
         devtools?: boolean;
         reload?: boolean;
-    }
+    };
 
-    export interface Hotkey {
+    export type Hotkey = {
         keys: string;
         preventDefault?: boolean;
-    }
+    };
 
-    export interface ShortcutOverride extends Hotkey {
+    export type ShortcutOverride = Hotkey & {
         command: string;
-    }
+    };
 
-    export interface PreloadScript {
+    export type PreloadScript = {
         mandatory?: boolean;
         state?: 'load-started' | 'load-failed' | 'load-succeeded' | 'failed' | 'succeeded';
         url: string;
-    }
+    };
 
-    export interface AutoResizeOptions {
+    export type AutoResizeOptions = {
         /**
          * If true, the view's width will grow and shrink together with the window. false
          * by default.
@@ -485,28 +441,31 @@ declare namespace OpenFin {
          * the window. false by default.
          */
         vertical?: boolean;
-    }
+    };
 
-    export interface InteropConfig {
+    export type InteropConfig = {
         currentContextGroup?: string | null;
         providerId?: string;
-    }
+    };
 
-    export interface ViewInfo {
+    export type ViewInfo = {
         canNavigateBack: boolean;
         canNavigateForward: boolean;
         processAffinity: string;
         title: string;
         url: string;
         favicons: string[];
-    }
-    export interface ViewCreationOptions extends Partial<ViewOptions> {
+    };
+
+    export type UpdatableViewOptions = Partial<MutableViewOptions>;
+
+    export type ViewCreationOptions = Partial<ViewOptions> & {
         name: string;
         url: string;
         target: Identity;
-    }
+    };
 
-    export interface UpdatableViewOptions {
+    export type MutableViewOptions = {
         autoResize: AutoResizeOptions;
         contextMenuSettings: ContextMenuSettings;
         backgroundColor: string;
@@ -519,13 +478,15 @@ declare namespace OpenFin {
         preventDragOut: boolean;
         // Doesn't get defaulted
         interop?: InteropConfig;
-    }
+    };
 
-    export interface DefaultViewOptions extends ViewOptions {
+    export type DefaultViewOptions = ViewOptions & {
         permissions: Partial<Permissions>;
-    }
+    };
 
-    export interface ViewOptions extends UpdatableViewOptions {
+    export type ViewOptions = ConstViewOptions & MutableViewOptions;
+
+    export type ConstViewOptions = {
         name: string;
         url: string;
         target: Identity;
@@ -539,9 +500,9 @@ declare namespace OpenFin {
         zoomLevel: number;
         experimental: any;
         fdc3InteropApi?: string;
-    }
+    };
 
-    export interface Certificate {
+    export type Certificate = {
         data: string;
         fingerprint: string;
         issuer: CertificatePrincipal;
@@ -552,85 +513,82 @@ declare namespace OpenFin {
         subjectName: string;
         validExpiry: number;
         validStart: number;
-    }
+    };
 
-    interface CertificatePrincipal {
+    type CertificatePrincipal = {
         commonName: string;
         country: string;
         locality: string;
         organizations: string[];
         organizationUnits: string[];
         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;
     };
 
-    export interface ApplySnapshotOptions {
+    export type ApplySnapshotOptions = {
         closeExistingWindows?: boolean;
         closeSnapshotWindows?: boolean;
         skipOutOfBoundsCheck?: boolean;
-    }
+    };
 
-    export interface ApplySnapshotPayload {
+    export type ApplySnapshotPayload = {
         snapshot: Snapshot;
         options?: ApplySnapshotOptions;
-    }
-    export interface CreateViewPayload {
+    };
+    export type CreateViewPayload = {
         opts: Partial<ViewOptions>;
         target: Identity;
         targetView?: Identity;
-    }
+    };
 
-    export interface ReplaceViewPayload {
+    export type ReplaceViewPayload = {
         opts: {
             viewToReplace: Identity;
             newView: Partial<ViewOptions>;
         };
         target: Identity;
-    }
+    };
 
-    export interface CloseViewPayload {
+    export type CloseViewPayload = {
         view: Identity;
-    }
+    };
 
-    export interface FetchManifestPayload {
+    export type FetchManifestPayload = {
         manifestUrl: string;
-    }
+    };
 
-    export interface ReplaceLayoutOpts {
+    export type ReplaceLayoutOpts = {
         layout: LayoutOptions;
-    }
-    export interface ReplaceLayoutPayload {
+    };
+    export type ReplaceLayoutPayload = {
         opts: ReplaceLayoutOpts;
         target: Identity;
-    }
+    };
 
-    export interface SetWindowContextPayload {
+    export type SetWindowContextPayload = {
         context: any;
         entityType: EntityType;
         target: Identity;
-    }
+    };
 
-    export interface LaunchIntoPlatformPayload {
+    export type LaunchIntoPlatformPayload = {
         manifest: any;
-    }
+    };
 
-    export interface GetWindowContextPayload {
+    export type GetWindowContextPayload = {
         entityType: EntityType;
         target: Identity;
-    }
+    };
 
-    export interface ApplicationPermissions {
+    export type ApplicationPermissions = {
         setFileDownloadLocation: boolean;
-    }
+    };
 
-    export interface SystemPermissions {
+    export type SystemPermissions = {
         getAllExternalWindows: boolean;
         launchExternalProcess: boolean;
         readRegistryValue:
@@ -644,7 +602,7 @@ declare namespace OpenFin {
             enabled: boolean;
             protocols: string[];
         };
-    }
+    };
 
     export type WebPermission =
         | 'audio'
@@ -658,38 +616,38 @@ declare namespace OpenFin {
         | 'clipboard-read'
         | 'clipboard-sanitized-write';
 
-    export interface Permissions {
+    export type Permissions = {
         Application?: Partial<ApplicationPermissions>;
         System?: Partial<SystemPermissions>;
         webAPIs?: WebPermission[];
-    }
+    };
 
-    export interface PlatformWindowCreationOptions extends Partial<WindowCreationOptions> {
+    export type PlatformWindowCreationOptions = Partial<WindowCreationOptions> & {
         updateStateIfExists?: boolean;
         reason?: WindowCreationReason;
-    }
+    };
 
-    export interface PlatformWindowOptions extends WindowCreationOptions {
+    export type PlatformWindowOptions = WindowCreationOptions & {
         stylesheetUrl: string;
-    }
+    };
 
-    export interface PlatformViewCreationOptions extends Partial<ViewOptions> {
+    export type PlatformViewCreationOptions = Partial<ViewOptions> & {
         url: string;
         target: Identity;
-    }
+    };
 
     export type ProcessAffinityStrategy = 'same' | 'different';
 
-    export interface PlatformOptions extends ApplicationCreationOptions {
+    export type PlatformOptions = ApplicationCreationOptions & {
         defaultWindowOptions?: Partial<PlatformWindowOptions>;
         defaultViewOptions?: Partial<PlatformViewCreationOptions>;
         disableDefaultCommands?: boolean;
         viewProcessAffinityStrategy?: ProcessAffinityStrategy;
         providerUrl?: string;
         permissions?: Partial<Permissions>;
-    }
+    };
 
-    export interface Manifest {
+    export type Manifest = {
         appAssets?: {
             alias: string;
             args?: string;
@@ -743,9 +701,9 @@ declare namespace OpenFin {
             forwardErrorReports?: boolean;
             enableErrorReporting?: boolean;
         };
-    }
+    };
 
-    export interface LayoutOptions {
+    export type LayoutOptions = {
         settings: {
             popoutWholeStack?: boolean;
             constrainDragToContainer?: boolean;
@@ -755,19 +713,19 @@ declare namespace OpenFin {
             constrainDragToHeaders?: boolean;
         };
         content: LayoutContent;
-    }
+    };
 
     export type LayoutContent = (LayoutRow | LayoutColumn | LayoutComponent)[];
 
-    export interface LayoutRow {
+    export type LayoutRow = {
         type: 'row';
         content: LayoutContent;
-    }
-    export interface LayoutColumn {
+    };
+    export type LayoutColumn = {
         type: 'column';
         content: LayoutContent;
-    }
-    export interface LayoutComponent {
+    };
+    export type LayoutComponent = {
         type: 'component';
         componentName: 'view';
         componentState: {
@@ -775,7 +733,7 @@ declare namespace OpenFin {
             url: string;
             title?: string;
         };
-    }
+    };
 
     export type OverrideCallback<T extends any = PlatformProvider, U extends T = T> = (
         arg: Constructor<T>,
@@ -784,13 +742,144 @@ declare namespace OpenFin {
 
     export type Constructor<T = {}> = new (...args: any[]) => T;
 
-    type PlatformProvider = import('./src/shapes/Platform').PlatformProvider;
-    export interface InitPlatformOptions {
+    export type HostContextChangedReasons = 'updated' | 'reparented';
+
+    export type WindowCreationReason =
+        | 'tearout'
+        | 'create-view-without-target'
+        | 'api-call'
+        | 'app-creation'
+        | 'restore';
+
+    // TODO: Real PlatformProvider type def
+    export type 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 type InitPlatformOptions = {
         overrideCallback?: OverrideCallback<PlatformProvider>;
         interopOverride?: OverrideCallback<InteropBroker>;
-    }
+    };
 
-    export interface ProcessDetails {
+    export type ProcessDetails = {
         cpuUsage: number;
         nonPagedPoolUsage: number;
         pageFaultCount: number;
@@ -803,80 +892,80 @@ declare namespace OpenFin {
         workingSetSize: number;
         privateSetSize: number;
         pid: number;
-    }
+    };
 
-    export interface FrameProcessDetails extends ProcessDetails {
+    export type FrameProcessDetails = ProcessDetails & {
         url: string;
         entityType: string;
-    }
+    };
 
-    export interface EntityProcessDetails extends FrameProcessDetails {
+    export type EntityProcessDetails = FrameProcessDetails & {
         name: string;
         uuid: string;
         iframes: FrameProcessDetails[];
-    }
+    };
 
-    export interface AppProcessInfo {
+    export type AppProcessInfo = {
         uuid: string;
         entities: EntityProcessDetails[];
-    }
+    };
 
-    export interface NonAppProcessDetails extends ProcessDetails {
+    export type NonAppProcessDetails = ProcessDetails & {
         name: string;
-    }
+    };
 
-    export interface SystemProcessInfo {
+    export type SystemProcessInfo = {
         apps: AppProcessInfo[];
         browserProcess: NonAppProcessDetails;
         nonApps: NonAppProcessDetails[];
-    }
+    };
 
-    export interface ClearCacheOption {
+    export type ClearCacheOption = {
         appcache?: boolean;
         cache?: boolean;
         cookies?: boolean;
         localStorage?: boolean;
-    }
+    };
 
-    export interface CookieInfo {
+    export type CookieInfo = {
         name: string;
         // expirationDate: Date;
         domain: string;
         path: string;
-    }
+    };
 
-    export interface CookieOption {
+    export type CookieOption = {
         name: string;
-    }
+    };
 
-    export interface CrashReporterOptions {
+    export type CrashReporterOptions = {
         diagnosticsMode: boolean;
-    }
+    };
 
-    export interface CrashReporterState extends CrashReporterOptions {
+    export type CrashReporterState = CrashReporterOptions & {
         isRunning: boolean;
         diagnosticMode: boolean;
-    }
+    };
 
-    export interface Time {
+    export type Time = {
         user: number;
         nice: number;
         sys: number;
         idle: number;
         irq: number;
-    }
+    };
 
-    export interface CpuInfo {
+    export type CpuInfo = {
         model: string;
         speed: number;
         times: Time;
-    }
+    };
 
-    export interface GpuInfo {
+    export type GpuInfo = {
         name: string;
-    }
+    };
 
-    export interface HostSpecs {
+    export type HostSpecs = {
         aeroGlassEnabled?: boolean;
         arch: string;
         cpus: CpuInfo[];
@@ -884,29 +973,29 @@ declare namespace OpenFin {
         memory: number;
         name: string;
         screenSaver?: boolean;
-    }
+    };
 
-    export interface PrinterInfo {
+    export type PrinterInfo = {
         name: string;
         description: string;
         status: number;
         isDefault: boolean;
-    }
+    };
 
-    export interface Dpi {
+    export type Dpi = {
         horizontal?: number;
         vertical?: number;
-    }
+    };
 
-    export interface Margins {
+    export type Margins = {
         marginType?: 'default' | 'none' | 'printableArea' | 'custom';
         top?: number;
         bottom?: number;
         left?: number;
         right?: number;
-    }
+    };
 
-    export interface PrintOptions {
+    export type PrintOptions = {
         silent?: boolean;
         printBackground?: boolean;
         deviceName?: string;
@@ -920,103 +1009,103 @@ declare namespace OpenFin {
         pageRanges?: Record<string, number>;
         duplexMode?: 'simplex' | 'shortEdge' | 'longEdge';
         dpi?: Dpi;
-    }
-    export interface WriteRequestType {
+    };
+    export type WriteRequestType = {
         data: string;
         type?: string;
-    }
+    };
 
-    export interface WriteAnyRequestType {
+    export type WriteAnyRequestType = {
         data: {
             text?: string;
             html?: string;
             rtf?: string;
         };
         type?: string;
-    }
+    };
 
-    export interface SubscriptionOptions {
+    export type SubscriptionOptions = {
         timestamp?: number;
-    }
+    };
 
-    export interface SharedWorkerInfo {
+    export type SharedWorkerInfo = {
         id: string;
         url: string;
-    }
+    };
 
-    export interface ServiceIdentifier {
+    export type ServiceIdentifier = {
         name: string;
-    }
+    };
 
-    export interface ServiceConfiguration {
+    export type ServiceConfiguration = {
         config: object;
         name: string;
-    }
+    };
 
-    export interface RVMInfo {
+    export type RVMInfo = {
         'action': string;
         'appLogDirectory': string;
         'path': string;
         'start-time': string;
         'version': string;
         'working-dir': string;
-    }
+    };
 
-    export interface RvmLaunchOptions {
+    export type RvmLaunchOptions = {
         noUi?: boolean;
         userAppConfigArgs?: object;
-    }
+    };
 
-    export interface ShortCutConfig {
+    export type ShortCutConfig = {
         desktop?: boolean;
         startMenu?: boolean;
         systemStartup?: boolean;
-    }
+    };
 
-    export interface TerminateExternalRequestType {
+    export type TerminateExternalRequestType = {
         uuid: string;
         timeout: number;
         killTree: boolean;
-    }
+    };
 
-    export interface TrayInfo {
+    export type TrayInfo = {
         bounds: OpenFin.Rectangle;
         monitorInfo: OpenFin.MonitorInfo;
         x: number;
         y: number;
-    }
+    };
 
-    export interface Transition {
+    export type Transition = {
         opacity?: Opacity;
         position?: Position;
         size?: Size;
-    }
+    };
 
-    export interface Size extends TransitionBase {
+    export type Size = TransitionBase & {
         width: number;
         height: number;
-    }
+    };
 
-    export interface Opacity extends TransitionBase {
+    export type Opacity = TransitionBase & {
         opacity: number;
-    }
+    };
 
-    export interface TransitionBase {
+    export type TransitionBase = {
         duration: number;
         relative?: boolean;
-    }
+    };
 
-    export interface Position extends TransitionBase {
+    export type Position = TransitionBase & {
         left: number;
         top: number;
-    }
+    };
 
     export type AnchorType = 'top-left' | 'top-right' | 'bottom-left' | 'bottom-right';
 
-    export interface TransitionOptions {
+    export type TransitionOptions = {
         interrupt: boolean;
         tween?: tween;
-    }
+    };
 
     type tween =
         | 'linear'
@@ -1037,31 +1126,31 @@ declare namespace OpenFin {
         | 'ease-out-elastic'
         | 'ease-in-out-elastic';
 
-    export interface FindInPageOptions {
+    export type FindInPageOptions = {
         forward?: boolean;
         findNext?: boolean;
         matchCase?: boolean;
         wordStart?: boolean;
         medialCapitalAsWordStart?: boolean;
-    }
+    };
 
-    export interface FrameInfo {
+    export type FrameInfo = {
         name: string;
         uuid: string;
         entityType: EntityType;
         parent: Identity;
-    }
+    };
 
-    export interface ExternalApplicationInfo {
+    export type ExternalApplicationInfo = {
         parent: Identity;
-    }
+    };
 
-    export interface ExternalConnection {
+    export type ExternalConnection = {
         token: string;
         uuid: string;
-    }
+    };
 
-    export interface ExternalProcessRequestType {
+    export type ExternalProcessRequestType = {
         path?: string;
         alias?: string;
         arguments?: string;
@@ -1071,114 +1160,111 @@ declare namespace OpenFin {
         uuid?: string;
         initialWindowState?: string;
         cwd?: string;
-    }
+    };
 
-    export interface CertificationInfo {
+    export type CertificationInfo = {
         serial?: string;
         subject?: string;
         publickey?: string;
         thumbprint?: string;
         trusted?: boolean;
-    }
+    };
 
-    export interface ExitCode {
+    export type ExitCode = {
         topic: string;
         uuid: string;
         exitCode: number;
-    }
+    };
 
-    export interface LaunchExternalProcessListener {
+    export type LaunchExternalProcessListener = {
         (code: ExitCode): void;
-    }
+    };
 
-    export interface ExternalProcessInfo {
+    export type ExternalProcessInfo = {
         pid: number;
         listener?: LaunchExternalProcessListener;
-    }
+    };
 
-    export interface AppAssetInfo {
+    export type AppAssetInfo = {
         src: string;
         alias: string;
         version: string;
         target?: string;
         args?: string;
         mandatory?: boolean;
-    }
+    };
 
-    export interface RuntimeDownloadOptions {
+    export type RuntimeDownloadOptions = {
         version: string;
-    }
+    };
 
-    export interface AppAssetRequest {
+    export type AppAssetRequest = {
         alias: string;
-    }
+    };
 
-    export interface RuntimeDownloadProgress {
+    export type RuntimeDownloadProgress = {
         downloadedBytes: number;
         totalBytes: number;
-    }
+    };
 
-    export interface CertifiedAppInfo {
+    export type CertifiedAppInfo = {
         isRunning: boolean;
         isOptedIntoCertfiedApp?: boolean;
         isCertified?: boolean;
         isSSLCertified?: boolean;
         isPresentInAppDirectory?: boolean;
-    }
-    export interface JumpListCategory {
+    };
+    export type JumpListCategory = {
         name?: string;
         items: Array<JumpListTask | JumpListSeparator>;
-    }
+    };
 
     export type JumpListItem = JumpListTask | JumpListSeparator;
 
-    export interface JumpListTask {
+    export type JumpListTask = {
         type: 'task';
         title: string;
         description: string;
         deepLink: string;
         iconPath?: string;
         iconIndex?: number;
-    }
+    };
 
-    export interface JumpListSeparator {
+    export type JumpListSeparator = {
         type: 'separator';
-    }
-    export interface ApplicationInfo {
+    };
+
+    export type ApplicationInfo = {
         initialOptions: OpenFin.ApplicationCreationOptions;
         launchMode: string;
         manifest: OpenFin.Manifest & { [key: string]: any };
         manifestUrl: string;
         parentUuid?: string;
         runtime: { version: string };
-    }
-
-    export interface LogInfo {
-        logId: string;
-    }
+    };
 
-    export interface ManifestInfo {
+    export type ManifestInfo = {
         uuid: string;
         manifestUrl: string;
-    }
+    };
 
-    export interface ClickedMenuResult {
+    export type ClickedMenuResult = {
         result: 'clicked';
         data: any;
-    }
+    };
 
-    export interface ClosedMenuResult {
+    export type ClosedMenuResult = {
         result: 'closed';
-    }
+    };
 
     export type MenuResult = ClickedMenuResult | ClosedMenuResult;
 
-    export interface ShowPopupMenuOptions {
+    export type ShowPopupMenuOptions = {
         template: MenuItemTemplate[];
         x?: number;
         y?: number;
-    }
-    export interface MenuItemTemplate {
+    };
+    export type MenuItemTemplate = {
         /**
          * Can be `normal`, `separator`, `submenu`, or `checkbox`.
          * Defaults to 'normal' unless a 'submenu' key exists
@@ -1214,13 +1300,13 @@ declare namespace OpenFin {
          * Image Data URI with image dimensions inferred from the encoded string
          */
         icon?: string;
-    }
+    };
 
-    export interface NativeWindowIntegrationProviderAuthorization {
+    export type NativeWindowIntegrationProviderAuthorization = {
         authorizedUuid: string;
-    }
+    };
 
-    export interface RuntimeInfo {
+    export type RuntimeInfo = {
         architecture: string;
         manifestUrl: string;
         port: number;
@@ -1230,75 +1316,74 @@ declare namespace OpenFin {
         chromeVersion: string;
         electronVersion: string;
         devtoolsPort?: number;
-    }
+    };
 
-    export interface DefaultDomainSettings {
+    export type DefaultDomainSettings = {
         rules: DefaultDomainSettingsRule[];
-    }
+    };
 
-    export interface DefaultDomainSettingsRule {
+    export type DefaultDomainSettingsRule = {
         // match pattern is a domain based string type
         match: string[];
         options: {
             downloadSettings: FileDownloadSettings;
         };
-    }
+    };
 
     export type FileDownloadBehaviorNames = 'prompt' | 'no-prompt' | 'block';
 
-    export interface FileDownloadSettings {
+    export type FileDownloadSettings = {
         rules: DownloadRule[];
-    }
+    };
 
-    export interface DownloadRule {
+    export type DownloadRule = {
         behavior: FileDownloadBehaviorNames;
         // match pattern is a string type
         match: string[];
-    }
-    export interface ContextSubscription {
+    };
+    export type ContextSubscription = {
         handler: ContextHandler;
         contextType?: string;
-    }
+    };
 
     export type ContextHandler = (context: OpenFin.Context) => void;
 
-    export interface Intent<MetadataType = IntentMetadata> {
+    export type Intent<MetadataType = IntentMetadata> = {
         name: string;
         context: Context;
         metadata?: MetadataType;
-    }
+    };
 
-    export interface IntentMetadata<TargetType = any> {
+    export type IntentMetadata<TargetType = any> = {
         target?: TargetType;
-    }
+    };
 
     export type IntentHandler = (intent: OpenFin.Intent) => void;
     type MatchPattern = string;
 
     export type ContentCreationBehaviorNames = 'window' | 'view' | 'block' | 'browser';
-    export interface ContentCreationRule<T = ContentCreationBehaviorNames> {
+    export type ContentCreationRule<T = ContentCreationBehaviorNames> = {
         behavior: T;
         match: MatchPattern[];
         options?: T extends 'window' ? Partial<WindowOptions> : T extends 'view' ? Partial<OpenFin.ViewOptions> : never;
-    }
+    };
 
-    export interface ContentCreationOptions {
+    export type ContentCreationOptions = {
         rules: ContentCreationRule[];
-    }
-    export interface SnapshotProvider<T> {
+    };
+    export type SnapshotProvider<T> = {
         getSnapshot: () => Promise<T>;
         applySnapshot: (snapshot: T) => Promise<void>;
-    }
+    };
 
-    export type PermissionState = import('./src/api/system/queryPermissionTypes').PermissionState;
-    export interface QueryPermissionResult {
+    export type QueryPermissionResult = {
         permission: string;
         state: PermissionState;
         granted: boolean;
         rawValue?: unknown;
-    }
+    };
 
-    export interface SessionContextGroup {
+    export type SessionContextGroup = {
         id: string;
         setContext: (context: OpenFin.Context) => Promise<void>;
         getCurrentContext: (type?: string) => Promise<OpenFin.Context>;
@@ -1306,35 +1391,960 @@ declare namespace OpenFin {
             handler: OpenFin.ContextHandler,
             contextType?: string
         ) => Promise<{ unsubscribe: () => void }>;
-    }
+    };
 
     export type MessagingProtocols = import('./src/api/interappbus/channel/protocols/index').MessagingProtocols;
 
-    export interface ChannelCreateOptions {
+    export type ChannelCreateOptions = {
         protocols?: MessagingProtocols[];
-    }
+    };
 
-    export interface ChannelConnectOptions extends ChannelCreateOptions {
+    export type ChannelConnectOptions = ChannelCreateOptions & {
         wait?: boolean;
         payload?: any;
-    }
+    };
 
-    export interface ContextForIntent<MetadataType = any> extends Context {
+    export type ContextForIntent<MetadataType = any> = Context & {
         metadata?: MetadataType;
-    }
+    };
 
-    export interface InfoForIntentOptions {
+    export type InfoForIntentOptions = {
         name: string;
         context?: OpenFin.Context;
-    }
+    };
 
-    export interface ProviderIdentity extends Identity {
+    export type ProviderIdentity = Identity & {
         channelId: string;
         channelName: string;
-    }
+    };
 
-    export interface RegisterUsageData {
+    export type RegisterUsageData = {
         data: unknown;
         type: string;
-    }
+    };
+
+    export type ProxyInfo = {
+        config: ProxyConfig;
+        system: ProxySystemInfo;
+    };
+
+    export type ProxyConfig = {
+        proxyAddress: string;
+        proxyPort: number;
+        type: string;
+    };
+
+    export type ProxySystemInfo = {
+        autoConfigUrl: string;
+        bypass: string;
+        enabled: boolean;
+        proxy: string;
+    };
+
+    export type BaseEvent<Topic, Type> = {
+        topic: Topic;
+        type: Type;
+    };
+
+    export type ApplicationEvent<Topic, Type> = BaseEvent<Topic, Type> & {
+        uuid: string;
+    };
+
+    export type WindowEvent<Topic, Type> = ApplicationEvent<Topic, Type> & {
+        name: string;
+    };
+
+    export type BaseEventMap = {
+        [name: string]: any;
+        newListener: string;
+        listenerRemoved: string;
+    };
+
+    export type WindowResourceLoadFailedEvent<Topic, Type> = WindowEvent<Topic, Type> & {
+        errorCode: number;
+        errorDescription: string;
+        validatedURL: string;
+        isMainFrame: boolean;
+    };
+
+    export type WindowResourceResponseReceivedEvent<Topic, Type> = 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 type PageTitleUpdatedEvent<Topic, Type> = WindowEvent<Topic, Type> & {
+        title: string;
+    };
+
+    export type CertificateErrorEvent<Topic, Type> = WindowEvent<Topic, Type> & {
+        error: string;
+        url: string;
+        certificate: OpenFin.Certificate;
+    };
+
+    export type CertificateSelectionShownEvent<Topic, Type> = WindowEvent<Topic, Type> & {
+        url: string;
+        certificates: OpenFin.Certificate[];
+    };
+
+    export type FaviconUpdatedEvent<Topic, Type> = WindowEvent<Topic, Type> & {
+        favicons: string[];
+    };
+
+    export type 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 type WindowNavigationRejectedEvent<Topic, Type> = WindowEvent<Topic, Type> & {
+        sourceName?: string; // DEPRECATED
+        url: string;
+    };
+
+    export type FrameEvent<Type> = WindowEvent<'frame', Type> & {
+        entityType: 'iframe';
+        frameName: string;
+    };
+
+    export type FrameEvents = 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 type WebContentsEventMapping<Topic = string, Type = string> = 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 type RunRequestedEvent<Topic, Type> = ApplicationEvent<Topic, Type> & {
+        userAppConfigArgs: any;
+        manifest: OpenFin.ManifestInfo;
+    };
+
+    export type TrayIconClicked<Topic, Type> = ApplicationEvent<Topic, Type> & {
+        button: 0 | 1 | 2;
+        bounds: OpenFin.Rectangle;
+        x: number;
+        y: number;
+        monitorInfo: any;
+    };
+
+    export type WindowAlertRequestedEvent<Topic, Type> = WindowEvent<Topic, Type> & {
+        message: string;
+        url: string;
+    };
+
+    export type WindowAuthRequestedEvent<Topic, Type> = WindowEvent<Topic, Type> & {
+        authInfo: {
+            host: string;
+            isProxy: boolean;
+            port: number;
+            realm: string;
+            scheme: string;
+        };
+    };
+
+    export type WindowEndLoadEvent<Topic, Type> = WindowEvent<Topic, Type> & {
+        documentName: string;
+        isMain: boolean;
+    };
+
+    export type WindowReloadedEvent<Topic, Type> = WindowEvent<Topic, Type> & {
+        url: string;
+    };
+
+    export type WindowOptionsChangedEvent<Topic, Type> = WindowEvent<Topic, Type> & {
+        options: OpenFin.WindowOptions;
+        diff: OpenFin.WindowOptionDiff;
+    };
+
+    export type WindowExternalProcessExitedEvent<Topic, Type> = WindowEvent<Topic, Type> & {
+        processUuid: string;
+        exitCode: number;
+    };
+
+    export type WindowExternalProcessStartedEvent<Topic, Type> = WindowEvent<Topic, Type> & {
+        processUuid: string;
+    };
+
+    export type WindowHiddenEvent<Topic, Type> = WindowEvent<Topic, Type> & {
+        reason: 'closing' | 'hide' | 'hide-on-close';
+    };
+
+    export type 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 type PreloadScriptInfo = {
+        state:
+            | 'load-failed' // preload script failed to load
+            | 'failed' // preload script failed to eval
+            | 'succeeded'; // preload script eval'ed successfully
+    };
+    export type WindowPreloadScriptsStateChangeEvent<Topic, Type> = WindowEvent<Topic, Type> & {
+        preloadScripts: (PreloadScriptInfoRunning & any)[];
+    };
+    export type WindowPreloadScriptsStateChangedEvent<Topic, Type> = WindowEvent<Topic, Type> & {
+        preloadScripts: (PreloadScriptInfoRunning & any)[];
+    };
+
+    export type WindowBeginBoundsChangingEvent<Topic, Type> = WindowEvent<Topic, Type> & {
+        height: number;
+        left: number;
+        top: number;
+        width: number;
+        windowState: 'minimized' | 'normal' | 'maximized';
+    };
+
+    export type WindowEndBoundsChangingEvent<Topic, Type> = WindowEvent<Topic, Type> & {
+        height: number;
+        left: number;
+        top: number;
+        width: number;
+        windowState: 'minimized' | 'normal' | 'maximized';
+    };
+
+    export type WindowBoundsChange<Topic, Type> = WindowEvent<Topic, Type> & {
+        changeType: 0 | 1 | 2;
+        deferred: boolean;
+        height: number;
+        left: number;
+        top: number;
+        width: number;
+    };
+
+    export type WillMoveOrResize<Topic, Type> = WindowEvent<Topic, Type> & {
+        height: number;
+        left: number;
+        top: number;
+        width: number;
+        monitorScaleFactor: number;
+    };
+
+    export type WindowPerformanceReport<Topic, Type> = Performance & WindowEvent<Topic, Type>;
+
+    export type ViewDetached<Topic, Type> = WindowEvent<Topic, Type> & {
+        previousTarget: OpenFin.Identity;
+        target: OpenFin.Identity;
+        viewIdentity: OpenFin.Identity;
+    };
+
+    export type WindowEventMapping<Topic = string, Type = string> = 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 type PropagatedWindowEventMapping<Topic = string, Type = string> = 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 type ViewEventMapping<Topic = string, Type = string> = 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>;
+    };
+
+    type PropagatedViewIdentity = {
+        viewIdentity: OpenFin.Identity;
+    };
+
+    export type PropagatedViewEventMapping<Topic = string, Type = string> = 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 type InputEvent = {
+        inputType: 'keyUp' | 'keyDown';
+        ctrlKey: boolean;
+        shiftKey: boolean;
+        altKey: boolean;
+        metaKey: boolean;
+        key: string;
+        code: string;
+        repeat: boolean;
+        command?: string;
+    };
+
+    export type TargetChangedEvent<Topic, Type> = 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 type ApplicationEventMapping<Topic = string, Type = string> = 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 type 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 type PlatformEventMapping<Topic = string, Type = string> = ApplicationEventMapping & {
+        'platform-api-ready': ApplicationEvent<Topic, Type>;
+        'platform-snapshot-applied': ApplicationEvent<Topic, Type>;
+    };
+
+    export type PropagatedPlatformEventMapping<Topic = string, Type = string> = 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 type IdleEvent<Topic, Type> = BaseEvent<Topic, Type> & {
+        elapsedTime: number;
+        isIdle: boolean;
+    };
+
+    export type MonitorEvent<Topic, Type> = OpenFin.MonitorInfo & BaseEvent<Topic, Type>;
+
+    export type SessionChangedEvent<Topic, Type> = BaseEvent<Topic, Type> & {
+        reason: 'lock' | 'unlock' | 'remote-connect' | 'remote-disconnect' | 'unknown';
+    };
+
+    export type SystemEventMapping<Topic = string, Type = string> = 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 type GlobalHotkeyEvent<Type> = RuntimeEvent<'global-hotkey', Type> & {
+        identity: Identity;
+        hotkey: string;
+    };
+
+    export type GlobalHotkeyEvents = BaseEventMap & {
+        registered: GlobalHotkeyEvent<'registered'>;
+        unregistered: GlobalHotkeyEvent<'unregistered'>;
+    };
+
+    export type ExternalApplicationEvents = 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 type SystemApplicationInfo = {
+        isPlatform: boolean;
+        isRunning: boolean;
+        uuid: string;
+        parentUuid?: string;
+    };
+
+    export type InstalledApps = {
+        [key: string]: InstallationInfo;
+    };
+
+    export type InstallationInfo = {
+        cachedManifest: any;
+    };
+
+    export type GetLogRequestType = {
+        name: string;
+        endFile?: string;
+        sizeLimit?: number;
+    };
+
+    export type 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 type 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 type RegistryInfo = {
+        data: any;
+        rootKey: string;
+        subkey: string;
+        type: string;
+        value: string;
+    };
+
+    export type Entity = {
+        type: string;
+        uuid: string;
+    };
+
+    export type WindowInfo = {
+        childWindows: Array<WindowDetail>;
+        mainWindow: WindowDetail;
+        uuid: string;
+    };
+
+    export type WindowDetail = {
+        bottom: number;
+        height: number;
+        isShowing: boolean;
+        left: number;
+        name: string;
+        right: number;
+        state: string;
+        top: number;
+        width: number;
+    };
+
+    export type 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 type InitLayoutOptions = {
+        containerId?: string;
+    };
+
+    export type PresetLayoutOptions = {
+        presetType: LayoutPresetType;
+    };
+
+    export type DragPayload = {
+        'view-config': OpenFin.ViewCreationOptions;
+        'view-identity': [string, string, string]; // [componentState, uuid, name]
+    };
+
+    export type Message<T> = {
+        action: string;
+        payload: T;
+        correlationId?: number;
+    };
+
+    export type EventMessage = Message<RuntimeEvent> & {
+        action: 'process-desktop-event';
+        payload: RuntimeEvent;
+    };
+
+    export type Payload = {
+        success: boolean;
+        data: any;
+    };
+
+    export type 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 type 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 type ProtocolMap = 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;
+        };
+    };
+
+    type 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 type ViewState = OpenFin.ViewCreationOptions & {
+        url: string;
+    };
+
+    export type OsConfig = {
+        manifestLocation: string;
+        namedPipeName: string;
+        urlPath: string;
+        executablePath: string;
+    };
+
+    export type Wire = EventEmitter & {
+        connect(address: string): Promise<any>;
+        connectSync(): any;
+        send(data: any): Promise<any>;
+        shutdown(): Promise<void>;
+    };
+    export type WireConstructor = {
+        new (onmessage: (data: any) => void): Wire;
+    };
+
+    export type RuntimeConfig = {
+        version: string;
+        fallbackVersion?: string;
+        securityRealm?: string;
+        verboseLogging?: boolean;
+        arguments?: string;
+        rvmDir?: string;
+    };
+
+    export type ServiceConfig = {
+        name: string;
+        manifestUrl: string;
+    };
+
+    export 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; // in seconds
+    };
+
+    export type ConfigWithUuid = BaseConfig & {
+        uuid: string;
+    };
+
+    export type ExistingConnectConfig = ConfigWithUuid & {
+        address: string;
+    };
+
+    export type ConfigWithRuntime = BaseConfig & {
+        runtime: RuntimeConfig;
+    };
+
+    export type ExternalConfig = 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 type ChildContentOptions = {
+        options: any;
+        entityType: EntityType;
+    };
+
+    export type ErrorPlainObject = {
+        stack: string;
+        message: string;
+        toString(): string;
+    };
 }