@openfin/core 25.68.30 → 26.69.32

package/OpenFin.d.ts

@@ -2,7 +2,6 @@
 
 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;
@@ -12,7 +11,7 @@ declare namespace OpenFin {
     export type Layout = import('./src/api/platform/layout/index').Layout;
     export type View = import('./src/api/view/index').View;
     export type Window = import('./src/api/window/index')._Window;
-    export type WebContent = View | Window;
+    export type WebContent = View | OpenFin.Window;
     export type InteropClient = import('./src/api/interop/index').InteropClient;
     export type InteropBroker = import('./src/api/interop/index').InteropBroker;
     export type SnapshotSource = import('./src/api/snapshot-source/index').SnapshotSource;
@@ -69,12 +68,12 @@ declare namespace OpenFin {
         height: number;
     };
 
-    export type ApplicationCreationOptions = Partial<ApplicationOption> & {
+    export type ApplicationCreationOptions = Partial<ApplicationOptions> & {
         name: string;
         uuid: string;
     };
 
-    export type ApplicationOption = LegacyWinOptionsInAppOptions & {
+    export type ApplicationOptions = LegacyWinOptionsInAppOptions & {
         disableIabSecureLogging: boolean;
         loadErrorMessage: string;
         mainWindowOptions: WindowCreationOptions;
@@ -96,6 +95,7 @@ declare namespace OpenFin {
         apiDiagnostics: boolean;
         defaultDomainSettings: DefaultDomainSettings;
         enableJumpList: boolean;
+        enableBeforeUnload: boolean;
     };
 
     type InteropBrokerOptions = {
@@ -500,6 +500,7 @@ declare namespace OpenFin {
         zoomLevel: number;
         experimental: any;
         fdc3InteropApi?: string;
+        enableBeforeUnload: boolean;
     };
 
     export type Certificate = {
@@ -729,7 +730,7 @@ declare namespace OpenFin {
         type: 'component';
         componentName: 'view';
         componentState: {
-            identity: Identity;
+            name: string;
             url: string;
             title?: string;
         };
@@ -870,8 +871,10 @@ declare namespace OpenFin {
          * @return { Promise<HostContextChangedPayload> } The event that it raised.
          */
         onWindowContextUpdated(
-            payload: WindowOptionsChangedEvent<'window', 'options-changed'>
+            payload: import('./src/api/events/window').WindowOptionsChangedEvent<'window', 'options-changed'>
         ): Promise<OpenFin.HostContextChangedPayload | undefined>;
+
+        closeWindow(payload: CloseWindowPayload, callerIdentity: Identity): Promise<void>;
     };
 
     export type InitPlatformOptions = {
@@ -1341,10 +1344,6 @@ declare namespace OpenFin {
         // match pattern is a string type
         match: string[];
     };
-    export type ContextSubscription = {
-        handler: ContextHandler;
-        contextType?: string;
-    };
 
     export type ContextHandler = (context: OpenFin.Context) => void;
 
@@ -1359,9 +1358,10 @@ declare namespace OpenFin {
     };
 
     export type IntentHandler = (intent: OpenFin.Intent) => void;
-    type MatchPattern = string;
 
     export type ContentCreationBehaviorNames = 'window' | 'view' | 'block' | 'browser';
+
+    type MatchPattern = string;
     export type ContentCreationRule<T = ContentCreationBehaviorNames> = {
         behavior: T;
         match: MatchPattern[];
@@ -1423,6 +1423,31 @@ declare namespace OpenFin {
         type: string;
     };
 
+    export interface ViewsPreventingUnloadPayload {
+        windowShouldClose: boolean;
+        windowId: OpenFin.Identity;
+        viewsPreventingUnload: OpenFin.Identity[];
+        viewsNotPreventingUnload: OpenFin.Identity[];
+        closeType: 'view' | 'window';
+    }
+
+    export interface BeforeUnloadUserDecision {
+        windowShouldClose: boolean;
+        viewsToClose: OpenFin.Identity[];
+    }
+
+    export interface ViewStatuses {
+        viewsPreventingUnload: OpenFin.Identity[];
+        viewsNotPreventingUnload: OpenFin.Identity[];
+    }
+
+    export interface CloseWindowPayload {
+        windowId: Identity;
+        options: {
+            skipBeforeUnload?: boolean;
+        };
+    }
+
     export type ProxyInfo = {
         config: ProxyConfig;
         system: ProxySystemInfo;
@@ -1441,492 +1466,6 @@ declare namespace OpenFin {
         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 = (
@@ -1941,7 +1480,7 @@ declare namespace OpenFin {
         id: ProviderIdentity | OpenFin.ClientIdentity
     ) => unknown;
 
-    export type SystemApplicationInfo = {
+    export type ApplicationState = {
         isPlatform: boolean;
         isRunning: boolean;
         uuid: string;
@@ -1968,25 +1507,13 @@ declare namespace OpenFin {
         date: string;
     };
 
+    export type SendApplicationLogResponse = {
+        logId: 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 = {
@@ -1997,12 +1524,20 @@ declare namespace OpenFin {
         value: string;
     };
 
-    export type Entity = {
-        type: string;
+    export type ApplicationType = {
+        type: 'application' | 'external-app';
         uuid: string;
     };
 
     export type WindowInfo = {
+        canNavigateBack: boolean;
+        canNavigateForward: boolean;
+        preloadScripts: Array<any>;
+        title: string;
+        url: string;
+    };
+
+    export type ApplicationWindowInfo = {
         childWindows: Array<WindowDetail>;
         mainWindow: WindowDetail;
         uuid: string;
@@ -2020,25 +1555,6 @@ declare namespace OpenFin {
         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 = {
@@ -2049,302 +1565,55 @@ declare namespace OpenFin {
         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 ResultBehavior = 'close' | 'hide' | 'none';
+    export type PopupBaseBehavior = 'close' | 'hide';
 
-    export type MessageHandler = (data: any) => boolean;
+    export type PopupResultBehavior = 'none' | PopupBaseBehavior;
 
-    export type ViewState = OpenFin.ViewCreationOptions & {
-        url: string;
-    };
-
-    export type OsConfig = {
-        manifestLocation: string;
-        namedPipeName: string;
-        urlPath: string;
-        executablePath: string;
-    };
+    export type PopupBlurBehavior = 'modal' | PopupBaseBehavior;
 
-    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;
+    export interface PopupOptions {
+        initialOptions?: OpenFin.WindowCreationOptions;
+        additionalOptions?: OpenFin.UpdatableWindowOptions;
         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;
-    };
+        url?: string;
+        height?: number;
+        width?: number;
+        x?: number;
+        y?: number;
+        blurBehavior?: PopupBlurBehavior;
+        resultDispatchBehavior?: PopupResultBehavior;
+        hideOnClose?: boolean;
+        focus?: boolean;
+        onPopupReady?: (popupWindow: OpenFin.Window) => any;
+        onPopupResult?: (payload: PopupResult) => any;
+    }
+
+    export type PopupInteraction = 'clicked' | 'dismissed';
+
+    export interface PopupResult<T = any> {
+        identity: {
+            name: string;
+            uuid: string;
+        };
+        result: PopupInteraction;
+        data?: T;
+        lastDispatchResult?: PopupResult;
+    }
 
-    export type ExternalConfig = BaseConfig & {
-        manifestUrl: string;
-    };
+    export type SystemEvents = import('./src/api/events/system').SystemEvents;
 
-    export type NewConnectConfig = ConfigWithUuid & ConfigWithRuntime;
+    export type ApplicationEvents = import('./src/api/events/application').ApplicationEvents;
 
-    export type PortDiscoveryConfig = (ExternalConfig & ConfigWithRuntime) | NewConnectConfig;
+    export type WindowEvents = import('./src/api/events/window').WindowEvents;
 
-    export type ConnectConfig = ExistingConnectConfig | NewConnectConfig | ExternalConfig;
+    export type ViewEvents = import('./src/api/events/view').ViewEvents;
 
-    export type InternalConnectConfig = ExistingConnectConfig | NewConnectConfig;
+    export type GlobalHotkeyEvents = import('./src/api/events/globalHotkey').GlobalHotkeyEvents;
 
-    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 FrameEvents = import('./src/api/events/frame').FrameEvents;
 
-    export type ChildContentOptions = {
-        options: any;
-        entityType: EntityType;
-    };
+    export type PlatformEvents = import('./src/api/events/platform').PlatformEvents;
 
-    export type ErrorPlainObject = {
-        stack: string;
-        message: string;
-        toString(): string;
-    };
+    export type ExternalApplicationEvents = import('./src/api/events/externalApplication').ExternalApplicationEvents;
 }