@openfin/core 30.73.5 → 30.73.7

package/src/api/events/system.d.ts

@@ -1,22 +1,52 @@
-import { BaseEvent, ApplicationEvent, BaseEventMap } from './base';
-import { PropagatedWindowEvents } from './window';
-import { PropagatedApplicationEvents } from './application';
-import { PropagatedViewEvents } from './view';
-export interface IdleEvent<Topic, Type> extends BaseEvent<Topic, Type> {
+import type * as OpenFin from '../../OpenFin';
+import { PropagatedApplicationEvent } from './application';
+import { BaseEvent } from './base';
+import { PropagatedViewEvent } from './view';
+import { PropagatedWindowEvent } from './window';
+import { AppVersionCompleteEvent, AppVersionErrorEvent, AppVersionProgressEvent, AppVersionRuntimeStatusEvent } from '../../OpenFin';
+export declare type NotRequested<EventType> = EventType extends `${infer U}-requested` ? never : EventType;
+export declare type ExcludeRequested<Event extends {
+    type: string;
+}> = Event extends {
+    type: NotRequested<string>;
+} ? Extract<Event, {
+    type: NotRequested<Event['type']>;
+}> : never;
+export declare type IdleEvent = {
+    type: 'idle-state-changed';
     elapsedTime: number;
     isIdle: boolean;
-}
-export declare type MonitorEvent<Topic, Type> = OpenFin.MonitorInfo & BaseEvent<Topic, Type>;
-export interface SessionChangedEvent<Topic, Type> extends BaseEvent<Topic, Type> {
+};
+export declare type MonitorEvent = OpenFin.MonitorInfo & {
+    type: 'monitor-info-changed';
+};
+export declare type SessionChangedEvent = {
+    type: 'session-changed';
     reason: 'lock' | 'unlock' | 'remote-connect' | 'remote-disconnect' | 'unknown';
-}
-export interface SystemEventMapping<Topic = string, Type = string> extends BaseEventMap {
-    'application-created': ApplicationEvent<Topic, Type>;
-    'desktop-icon-clicked': ApplicationEvent<Topic, Type>;
-    'idle-state-changed': IdleEvent<Topic, Type>;
-    'monitor-info-changed': MonitorEvent<Topic, Type>;
-    'session-changed': SessionChangedEvent<Topic, Type>;
-}
-export declare type SystemEvents = PropagatedWindowEvents<'system'> & PropagatedApplicationEvents<'system'> & PropagatedViewEvents<'system'> & {
-    [Type in keyof SystemEventMapping]: SystemEventMapping<'system', Type>[Type];
 };
+export declare type AppVersionEvent = AppVersionProgressEvent | AppVersionRuntimeStatusEvent | AppVersionCompleteEvent | AppVersionErrorEvent;
+export declare type AppVersionEventType = AppVersionEvent['type'];
+export declare type IdEventType = WithId<AppVersionEventType>;
+export declare type WithId<T extends AppVersionEventType> = `${T}.${string}`;
+export declare type WithoutId<T extends string> = T extends WithId<infer U> ? U : never;
+export declare type AppVersionTypeFromIdEvent<T extends IdEventType> = Extract<AppVersionEvent, {
+    type: WithoutId<T>;
+}>;
+export declare type EventWithId<Event extends AppVersionEvent> = Event extends infer E extends {
+    type: AppVersionEventType;
+} ? Omit<E, 'type'> & {
+    type: WithId<E['type']>;
+    topic: 'system';
+    appVersionId: string;
+} : never;
+export declare type AppVersionEventWithId = EventWithId<AppVersionEvent>;
+export declare type ApplicationCreatedEvent = BaseEvent & {
+    type: 'application-created';
+};
+export declare type DesktopIconClickedEvent = BaseEvent & {
+    type: 'desktop-icon-clicked';
+};
+export declare type SystemEvent = {
+    topic: 'system';
+} & (ExcludeRequested<PropagatedWindowEvent> | PropagatedViewEvent | PropagatedApplicationEvent | ApplicationCreatedEvent | DesktopIconClickedEvent | IdleEvent | MonitorEvent | SessionChangedEvent | AppVersionEventWithId);
+export declare type SystemEventType = SystemEvent['type'];

package/src/api/events/typedEventEmitter.d.ts

@@ -0,0 +1,20 @@
+export declare type Listener<T extends {
+    type: string;
+}> = (payload: T) => void;
+export interface TypedEventEmitter<Event extends {
+    type: string;
+}, EmitterEventType = Event['type']> {
+    on<EventType extends EmitterEventType>(event: EventType, listener: Listener<Extract<Event, {
+        type: EventType;
+    }>>): this;
+    addListener<EventType extends EmitterEventType>(event: EventType, listener: Listener<Extract<Event, {
+        type: EventType;
+    }>>): this;
+    removeListener<EventType extends EmitterEventType>(event: EventType, listener: Listener<Extract<Event, {
+        type: EventType;
+    }>>): this;
+    removeAllListeners<EventType extends EmitterEventType>(event?: EmitterEventType): this;
+    emit<EventType extends EmitterEventType>(event: EventType, payload: Extract<Event, {
+        type: EventType;
+    }>): boolean;
+}

package/src/api/events/typedEventEmitter.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/src/api/events/view.d.ts

@@ -1,56 +1,40 @@
-import { WebContentsEventMapping, WindowResourceLoadFailedEvent, WindowResourceResponseReceivedEvent, CertificateSelectionShownEvent } from './webcontents';
-import { WindowEvent, BaseEventMap } from './base';
-import { WindowNavigationRejectedEvent } from './window';
-import { CrashedEvent } from './application';
-export interface ViewEventMapping<Topic = string, Type = string> extends WebContentsEventMapping {
-    'attached': WindowEvent<Topic, Type>;
-    'created': WindowEvent<Topic, Type>;
-    'destroyed': WindowEvent<Topic, Type>;
-    'hidden': WindowEvent<Topic, Type>;
-    'hotkey': InputEvent & WindowEvent<Topic, Type>;
-    'shown': WindowEvent<Topic, Type>;
-    'target-changed': TargetChangedEvent<Topic, Type>;
-}
-interface PropagatedViewIdentity {
-    viewIdentity: OpenFin.Identity;
-}
-export interface PropagatedViewEventMapping<Topic = string, Type = string> extends BaseEventMap {
-    'view-blurred': WindowEvent<Topic, Type> & PropagatedViewIdentity;
-    'view-certificate-selection-shown': CertificateSelectionShownEvent<Topic, Type> & PropagatedViewIdentity;
-    'view-crashed': CrashedEvent & WindowEvent<Topic, Type> & PropagatedViewIdentity;
-    'view-created': CrashedEvent & WindowEvent<Topic, Type> & PropagatedViewIdentity;
-    'view-destroyed': WindowEvent<Topic, Type> & PropagatedViewIdentity;
-    'view-did-change-theme-color': WindowEvent<Topic, Type> & PropagatedViewIdentity;
-    'view-focused': WindowEvent<Topic, Type> & PropagatedViewIdentity;
-    'view-hidden': WindowEvent<Topic, Type> & PropagatedViewIdentity;
-    'view-hotkey': InputEvent & WindowEvent<Topic, Type> & PropagatedViewIdentity;
-    'view-navigation-rejected': WindowNavigationRejectedEvent<Topic, Type> & PropagatedViewIdentity;
-    'view-page-favicon-updated': WindowEvent<Topic, Type> & PropagatedViewIdentity;
-    'view-page-title-updated': WindowEvent<Topic, Type> & PropagatedViewIdentity;
-    'view-resource-load-failed': WindowResourceLoadFailedEvent<Topic, Type> & PropagatedViewIdentity;
-    'view-resource-response-received': WindowResourceResponseReceivedEvent<Topic, Type> & PropagatedViewIdentity;
-    'view-shown': WindowEvent<Topic, Type> & PropagatedViewIdentity;
-    'view-target-changed': TargetChangedEvent<Topic, Type> & PropagatedViewIdentity;
-}
-export declare type ViewEvents = {
-    [Type in keyof ViewEventMapping]: ViewEventMapping<'view', Type>[Type];
-};
-export declare type PropagatedViewEvents<Topic> = {
-    [Type in keyof PropagatedViewEventMapping]: PropagatedViewEventMapping<Topic, Type>[Type];
-};
-export interface InputEvent {
-    inputType: 'keyUp' | 'keyDown';
-    ctrlKey: boolean;
-    shiftKey: boolean;
-    altKey: boolean;
-    metaKey: boolean;
-    key: string;
-    code: string;
-    repeat: boolean;
-    command?: string;
-}
-export interface TargetChangedEvent<Topic, Type> extends WindowEvent<Topic, Type> {
+import type * as OpenFin from '../../OpenFin';
+import { NonPropagatedWebContentsEvent, WillPropagateWebContentsEvent } from './webcontents';
+import { NamedEvent, PropagatedEvent } from './base';
+export declare type TargetChangedEvent = NamedEvent & {
+    type: 'target-changed';
     previousTarget: OpenFin.Identity;
     target: OpenFin.Identity;
-}
-export {};
+};
+/**
+ * A View event that does not propagate to (republish on) parent topics.
+ */
+export declare type NonPropagatedViewEvent = NonPropagatedWebContentsEvent;
+export declare type AttachedEvent = NamedEvent & {
+    type: 'attached';
+};
+export declare type CreatedEvent = NamedEvent & {
+    type: 'created';
+};
+export declare type DestroyedEvent = NamedEvent & {
+    type: 'destroyed';
+};
+export declare type HiddenEvent = NamedEvent & {
+    type: 'hidden';
+};
+export declare type HotkeyEvent = NamedEvent & {
+    type: 'hotkey';
+};
+export declare type ShownEvent = NamedEvent & {
+    type: 'shown';
+};
+/**
+ * A View event that does propagate to (republish on) parent topics.
+ */
+export declare type WillPropagateViewEvent = WillPropagateWebContentsEvent | AttachedEvent | CreatedEvent | DestroyedEvent | HiddenEvent | HotkeyEvent | ShownEvent | TargetChangedEvent;
+export declare type ViewEvent = {
+    topic: 'view';
+} & (NonPropagatedViewEvent | WillPropagateViewEvent);
+export declare type ViewEventType = ViewEvent['type'];
+export declare type PropagatedViewEvent = PropagatedEvent<'view', WillPropagateViewEvent>;
+export declare type PropagatedViewEventType = PropagatedViewEvent['type'];

package/src/api/events/webcontents.d.ts

@@ -1,13 +1,15 @@
-import { BaseEventMap, WindowEvent } from './base';
+import type * as OpenFin from '../../OpenFin';
+import { NamedEvent } from './base';
 import { CrashedEvent } from './application';
-import { WindowNavigationRejectedEvent } from './window';
-export interface WindowResourceLoadFailedEvent<Topic, Type> extends WindowEvent<Topic, Type> {
+export declare type ResourceLoadFailedEvent = NamedEvent & {
+    type: 'resource-load-failed';
     errorCode: number;
     errorDescription: string;
     validatedURL: string;
     isMainFrame: boolean;
-}
-export interface WindowResourceResponseReceivedEvent<Topic, Type> extends WindowEvent<Topic, Type> {
+};
+export declare type ResourceResponseReceivedEvent = NamedEvent & {
+    type: 'response-received';
     status: boolean;
     newUrl: string;
     originalUrl: string;
@@ -16,33 +18,58 @@ export interface WindowResourceResponseReceivedEvent<Topic, Type> extends Window
     referrer: string;
     headers: any;
     resourceType: 'mainFrame' | 'subFrame' | 'styleSheet' | 'script' | 'image' | 'object' | 'xhr' | 'other';
-}
-export interface PageTitleUpdatedEvent<Topic, Type> extends WindowEvent<Topic, Type> {
+};
+export declare type PageTitleUpdatedEvent = NamedEvent & {
+    type: 'page-title-updated';
     title: string;
-}
-export interface CertificateErrorEvent<Topic, Type> extends WindowEvent<Topic, Type> {
+};
+export declare type CertificateErrorEvent = NamedEvent & {
+    type: 'certificate-error';
     error: string;
     url: string;
     certificate: OpenFin.Certificate;
-}
-export interface CertificateSelectionShownEvent<Topic, Type> extends WindowEvent<Topic, Type> {
+};
+export declare type CertificateSelectionShownEvent = NamedEvent & {
+    type: 'certificate-selection-shown';
     url: string;
     certificates: OpenFin.Certificate[];
-}
-export interface FaviconUpdatedEvent<Topic, Type> extends WindowEvent<Topic, Type> {
+};
+export declare type FaviconUpdatedEvent = NamedEvent & {
+    type: 'page-favicon-updated';
     favicons: string[];
-}
-export interface WebContentsEventMapping<Topic = string, Type = string> extends BaseEventMap {
-    'blurred': WindowEvent<Topic, Type>;
-    'certificate-error': CertificateErrorEvent<Topic, Type>;
-    'certificate-selection-shown': CertificateSelectionShownEvent<Topic, Type>;
-    'crashed': CrashedEvent & WindowEvent<Topic, Type>;
-    'did-change-theme-color': WindowEvent<Topic, Type>;
-    'focused': WindowEvent<Topic, Type>;
-    'found-in-page': WindowEvent<Topic, Type>;
-    'navigation-rejected': WindowNavigationRejectedEvent<Topic, Type>;
-    'page-favicon-updated': FaviconUpdatedEvent<Topic, Type>;
-    'page-title-updated': PageTitleUpdatedEvent<Topic, Type>;
-    'resource-load-failed': WindowResourceLoadFailedEvent<Topic, Type>;
-    'resource-response-received': WindowResourceResponseReceivedEvent<Topic, Type>;
-}
+};
+export declare type NavigationRejectedEvent = NamedEvent & {
+    type: 'navigation-rejected';
+    sourceName?: string;
+    url: string;
+};
+export declare type FoundInPageEvent = NamedEvent & {
+    type: 'found-in-page';
+};
+/**
+ * A WebContents event that does not propagate to (republish on) parent topics.
+ */
+export declare type NonPropagatedWebContentsEvent = FoundInPageEvent | CertificateErrorEvent;
+export declare type BlurredEvent = NamedEvent & {
+    type: 'blurred';
+};
+export declare type DidChangeThemeColorEvent = NamedEvent & {
+    type: 'did-change-theme-color';
+};
+export declare type FocusedEvent = NamedEvent & {
+    type: 'focused';
+};
+export declare type ChildContentBlockedEvent = NamedEvent & {
+    type: 'child-content-blocked';
+};
+export declare type ChildContentOpenedInBrowserEvent = NamedEvent & {
+    type: 'child-content-opened-in-browser';
+};
+export declare type ChildViewCreatedEvent = NamedEvent & {
+    type: 'child-view-created';
+};
+/**
+ * A WebContents event that does propagate to (republish on) parent topics.
+ */
+export declare type WillPropagateWebContentsEvent = BlurredEvent | CertificateSelectionShownEvent | CrashedEvent | DidChangeThemeColorEvent | FocusedEvent | NavigationRejectedEvent | FaviconUpdatedEvent | PageTitleUpdatedEvent | ResourceLoadFailedEvent | ResourceResponseReceivedEvent | ChildContentBlockedEvent | ChildContentOpenedInBrowserEvent | ChildViewCreatedEvent;
+export declare type WebContentsEvent = NonPropagatedWebContentsEvent | WillPropagateWebContentsEvent;

package/src/api/events/window.d.ts

@@ -1,12 +1,14 @@
-import { CrashedEvent } from './application';
-import { WindowEvent, BaseEventMap } from './base';
-import { WebContentsEventMapping, WindowResourceLoadFailedEvent, WindowResourceResponseReceivedEvent, CertificateSelectionShownEvent } from './webcontents';
-import { PropagatedViewEventMapping, InputEvent } from './view';
-export interface WindowAlertRequestedEvent<Topic, Type> extends WindowEvent<Topic, Type> {
+import type * as OpenFin from '../../OpenFin';
+import { NamedEvent, PropagatedEvent } from './base';
+import { PropagatedViewEvent } from './view';
+import { NonPropagatedWebContentsEvent, WillPropagateWebContentsEvent } from './webcontents';
+export declare type AlertRequestedEvent = NamedEvent & {
+    type: 'alert-requested';
     message: string;
     url: string;
-}
-export interface WindowAuthRequestedEvent<Topic, Type> extends WindowEvent<Topic, Type> {
+};
+export declare type AuthRequestedEvent = NamedEvent & {
+    type: 'auth-requested';
     authInfo: {
         host: string;
         isProxy: boolean;
@@ -14,165 +16,177 @@ export interface WindowAuthRequestedEvent<Topic, Type> extends WindowEvent<Topic
         realm: string;
         scheme: string;
     };
-}
-export interface WindowEndLoadEvent<Topic, Type> extends WindowEvent<Topic, Type> {
+};
+export declare type EndLoadEvent = NamedEvent & {
+    type: 'end-load';
     documentName: string;
     isMain: boolean;
-}
-export interface WindowNavigationRejectedEvent<Topic, Type> extends WindowEvent<Topic, Type> {
-    sourceName?: string;
-    url: string;
-}
-export interface WillRedirectEvent<Topic, Type> extends WindowEvent<Topic, Type> {
+};
+export declare type WillRedirectEvent = NamedEvent & {
+    type: 'will-redirect';
     blocked: boolean;
     isInPlace: boolean;
     url: string;
-}
-export interface WindowReloadedEvent<Topic, Type> extends WindowEvent<Topic, Type> {
+};
+export declare type ReloadedEvent = NamedEvent & {
+    type: 'reloaded';
     url: string;
-}
-export interface WindowOptionsChangedEvent<Topic, Type> extends WindowEvent<Topic, Type> {
+};
+export declare type WindowOptionsChangedEvent = NamedEvent & {
+    type: 'options-changed';
     options: OpenFin.WindowOptions;
     diff: OpenFin.WindowOptionDiff;
-}
-export interface WindowExternalProcessExitedEvent<Topic, Type> extends WindowEvent<Topic, Type> {
+};
+export declare type ExternalProcessExitedEvent = NamedEvent & {
+    type: 'external-process-exited';
     processUuid: string;
     exitCode: number;
-}
-export interface WindowExternalProcessStartedEvent<Topic, Type> extends WindowEvent<Topic, Type> {
+};
+export declare type ExternalProcessStartedEvent = NamedEvent & {
+    type: 'external-process-started';
     processUuid: string;
-}
-export interface WindowHiddenEvent<Topic, Type> extends WindowEvent<Topic, Type> {
+};
+export declare type HiddenEvent = NamedEvent & {
+    type: 'hidden';
     reason: 'closing' | 'hide' | 'hide-on-close';
-}
-export interface PreloadScriptInfoRunning {
+};
+export declare type PreloadScriptInfoRunning = {
     state: 'load-started' | 'load-failed' | 'load-succeeded' | 'failed' | 'succeeded';
-}
-export interface PreloadScriptInfo {
+};
+export declare type PreloadScriptInfo = {
     state: 'load-failed' | 'failed' | 'succeeded';
-}
-export interface WindowPreloadScriptsStateChangeEvent<Topic, Type> extends WindowEvent<Topic, Type> {
-    preloadScripts: (PreloadScriptInfoRunning & any)[];
-}
-export interface WindowPreloadScriptsStateChangedEvent<Topic, Type> extends WindowEvent<Topic, Type> {
+};
+export declare type PreloadScriptsStateChangeEvent = NamedEvent & {
     preloadScripts: (PreloadScriptInfoRunning & any)[];
-}
-export interface WindowBeginBoundsChangingEvent<Topic, Type> extends WindowEvent<Topic, Type> {
-    height: number;
-    left: number;
-    top: number;
-    width: number;
-    windowState: 'minimized' | 'normal' | 'maximized';
-}
-export interface WindowEndBoundsChangingEvent<Topic, Type> extends WindowEvent<Topic, Type> {
+};
+export declare type UserBoundsChangeEvent = NamedEvent & {
     height: number;
     left: number;
     top: number;
     width: number;
     windowState: 'minimized' | 'normal' | 'maximized';
-}
-export interface WindowBoundsChange<Topic, Type> extends WindowEvent<Topic, Type> {
+};
+export declare type BoundsChangeEvent = NamedEvent & {
     changeType: 0 | 1 | 2;
     deferred: boolean;
     height: number;
     left: number;
     top: number;
     width: number;
-}
-export interface WillMoveOrResize<Topic, Type> extends WindowEvent<Topic, Type> {
+};
+export declare type WillMoveOrResizeEvent = NamedEvent & {
     height: number;
     left: number;
     top: number;
     width: number;
     monitorScaleFactor: number;
-}
-export declare type WindowPerformanceReport<Topic, Type> = Performance & WindowEvent<Topic, Type>;
-export interface ViewDetached<Topic, Type> extends WindowEvent<Topic, Type> {
+};
+export declare type PerformanceReportEvent = Performance & NamedEvent & {
+    type: 'performance-report';
+};
+export declare type ViewDetachedEvent = NamedEvent & {
+    type: 'view-detached';
     previousTarget: OpenFin.Identity;
     target: OpenFin.Identity;
     viewIdentity: OpenFin.Identity;
-}
-export interface WindowEventMapping<Topic = string, Type = string> extends WebContentsEventMapping {
-    'auth-requested': WindowAuthRequestedEvent<Topic, Type>;
-    'begin-user-bounds-changing': WindowBeginBoundsChangingEvent<Topic, Type>;
-    'bounds-changed': WindowBoundsChange<Topic, Type>;
-    'bounds-changing': WindowBoundsChange<Topic, Type>;
-    'close-requested': WindowEvent<Topic, Type>;
-    'closed': WindowEvent<Topic, Type>;
-    'closing': WindowEvent<Topic, Type>;
-    'disabled-movement-bounds-changed': WindowBoundsChange<Topic, Type>;
-    'disabled-movement-bounds-changing': WindowBoundsChange<Topic, Type>;
-    'embedded': WindowEvent<Topic, Type>;
-    'end-user-bounds-changing': WindowEndBoundsChangingEvent<Topic, Type>;
-    'external-process-exited': WindowExternalProcessExitedEvent<Topic, Type>;
-    'external-process-started': WindowExternalProcessStartedEvent<Topic, Type>;
-    'hidden': WindowHiddenEvent<Topic, Type>;
-    'hotkey': InputEvent & WindowEvent<Topic, Type>;
-    'initialized': WindowEvent<Topic, Type>;
-    'layout-initialized': WindowEvent<Topic, Type>;
-    'layout-ready': WindowEvent<Topic, Type>;
-    'maximized': WindowEvent<Topic, Type>;
-    'minimized': WindowEvent<Topic, Type>;
-    'options-changed': WindowOptionsChangedEvent<Topic, Type>;
-    'performance-report': WindowPerformanceReport<Topic, Type>;
-    'preload-scripts-state-changed': WindowPreloadScriptsStateChangeEvent<Topic, Type>;
-    'preload-scripts-state-changing': WindowPreloadScriptsStateChangeEvent<Topic, Type>;
-    'reloaded': WindowReloadedEvent<Topic, Type>;
-    'restored': WindowEvent<Topic, Type>;
-    'show-requested': WindowEvent<Topic, Type>;
-    'shown': WindowEvent<Topic, Type>;
-    'user-movement-disabled': WindowEvent<Topic, Type>;
-    'user-movement-enabled': WindowEvent<Topic, Type>;
-    'view-attached': WindowEvent<Topic, Type>;
-    'view-detached': ViewDetached<Topic, Type>;
-    'will-move': WillMoveOrResize<Topic, Type>;
-    'will-redirect': WillRedirectEvent<Topic, Type>;
-    'will-resize': WillMoveOrResize<Topic, Type>;
-}
-export interface PropagatedWindowEventMapping<Topic = string, Type = string> extends BaseEventMap {
-    'window-begin-user-bounds-changing': WindowBeginBoundsChangingEvent<Topic, Type>;
-    'window-blurred': WindowEvent<Topic, Type>;
-    'window-bounds-changed': WindowBoundsChange<Topic, Type>;
-    'window-bounds-changing': WindowBoundsChange<Topic, Type>;
-    'window-certificate-selection-shown': CertificateSelectionShownEvent<Topic, Type>;
-    'window-closed': WindowEvent<Topic, Type>;
-    'window-closing': WindowEvent<Topic, Type>;
-    'window-crashed': CrashedEvent & WindowEvent<Topic, Type>;
-    'window-disabled-movement-bounds-changed': WindowBoundsChange<Topic, Type>;
-    'window-disabled-movement-bounds-changing': WindowBoundsChange<Topic, Type>;
-    'window-embedded': WindowEvent<Topic, Type>;
-    'window-end-user-bounds-changing': WindowBeginBoundsChangingEvent<Topic, Type>;
-    'window-external-process-exited': WindowExternalProcessExitedEvent<Topic, Type>;
-    'window-external-process-started': WindowExternalProcessStartedEvent<Topic, Type>;
-    'window-focused': WindowEvent<Topic, Type>;
-    'window-hidden': WindowHiddenEvent<Topic, Type>;
-    'window-hotkey': InputEvent & WindowEvent<Topic, Type>;
-    'window-initialized': WindowEvent<Topic, Type>;
-    'window-layout-initialized': WindowEvent<Topic, Type>;
-    'window-layout-ready': WindowEvent<Topic, Type>;
-    'window-maximized': WindowEvent<Topic, Type>;
-    'window-minimized': WindowEvent<Topic, Type>;
-    'window-navigation-rejected': WindowNavigationRejectedEvent<Topic, Type>;
-    'window-options-changed': WindowOptionsChangedEvent<Topic, Type>;
-    'window-performance-report': WindowPerformanceReport<Topic, Type>;
-    'window-preload-scripts-state-changed': WindowPreloadScriptsStateChangeEvent<Topic, Type>;
-    'window-preload-scripts-state-changing': WindowPreloadScriptsStateChangedEvent<Topic, Type>;
-    'window-resource-load-failed': WindowResourceLoadFailedEvent<Topic, Type>;
-    'window-resource-response-received': WindowResourceResponseReceivedEvent<Topic, Type>;
-    'window-reloaded': WindowReloadedEvent<Topic, Type>;
-    'window-restored': WindowEvent<Topic, Type>;
-    'window-shown': WindowEvent<Topic, Type>;
-    'window-user-movement-disabled': WindowEvent<Topic, Type>;
-    'window-user-movement-enabled': WindowEvent<Topic, Type>;
-    'window-view-attached': WindowEvent<Topic, Type>;
-    'window-view-detached': ViewDetached<Topic, Type>;
-    'window-will-move': WillMoveOrResize<Topic, Type>;
-    'window-will-redirect': WillRedirectEvent<Topic, Type>;
-    'window-will-resize': WillMoveOrResize<Topic, Type>;
-}
-export declare type WindowEvents = PropagatedViewEventMapping<'window'> & {
-    [Type in keyof WindowEventMapping]: WindowEventMapping<'window', Type>[Type];
-};
-export declare type PropagatedWindowEvents<Topic> = {
-    [Type in keyof PropagatedWindowEventMapping]: PropagatedWindowEventMapping<Topic, Type>[Type];
 };
+export declare type InputEvent = {
+    inputType: 'keyUp' | 'keyDown';
+    ctrlKey: boolean;
+    shiftKey: boolean;
+    altKey: boolean;
+    metaKey: boolean;
+    key: string;
+    code: string;
+    repeat: boolean;
+    command?: string;
+};
+/**
+ * A Window event that does not propagate to (republish on) parent topics.
+ */
+export declare type NonPropagatedWindowEvent = NonPropagatedWebContentsEvent;
+export declare type BeginUserBoundsChangingEvent = UserBoundsChangeEvent & {
+    type: 'begin-user-bounds-changing';
+};
+export declare type BoundsChangedEvent = BoundsChangeEvent & {
+    type: 'bounds-changed';
+};
+export declare type BoundsChangingEvent = BoundsChangeEvent & {
+    type: 'bounds-changing';
+};
+export declare type WindowCloseRequestedEvent = NamedEvent & {
+    type: 'close-requested';
+};
+export declare type WindowClosedEvent = NamedEvent & {
+    type: 'closed';
+};
+export declare type WindowClosingEvent = NamedEvent & {
+    type: 'closing';
+};
+export declare type DisabledMovementBoundsChangedEvent = BoundsChangeEvent & {
+    type: 'disabled-movement-bounds-changed';
+};
+export declare type DisabledMovementBoundsChangingEvent = BoundsChangeEvent & {
+    type: 'disabled-movement-bounds-changing';
+};
+export declare type EmbeddedEvent = NamedEvent & {
+    type: 'embedded';
+};
+export declare type EndUserBoundsChangingEvent = UserBoundsChangeEvent & {
+    type: 'end-user-bounds-changing';
+};
+export declare type WindowHotkeyEvent = InputEvent & NamedEvent & {
+    type: 'hotkey';
+};
+export declare type WindowInitializedEvent = NamedEvent & {
+    type: 'initialized';
+};
+export declare type LayoutInitializedEvent = NamedEvent & {
+    type: 'layout-initialized';
+};
+export declare type LayoutReadyEvent = NamedEvent & {
+    type: 'layout-ready';
+};
+export declare type MaximizedEvent = NamedEvent & {
+    type: 'maximized';
+};
+export declare type MinimizedEvent = NamedEvent & {
+    type: 'minimized';
+};
+export declare type PreloadScriptsStateChangedEvent = PreloadScriptsStateChangeEvent & {
+    type: 'preload-script-state-changed';
+};
+export declare type PreloadScriptsStateChangingEvent = PreloadScriptsStateChangeEvent & {
+    type: 'preload-script-state-changing';
+};
+export declare type WindowRestoredEvent = NamedEvent & {
+    type: 'restored';
+};
+export declare type WindowShowRequestedEvent = NamedEvent & {
+    type: 'show-requested';
+};
+export declare type WindowShownEvent = NamedEvent & {
+    type: 'shown';
+};
+export declare type UserMovementEnabledEvent = NamedEvent & {
+    type: 'user-movement-enabled';
+};
+export declare type UserMovementDisabledEvent = NamedEvent & {
+    type: 'user-movement-disabled';
+};
+export declare type WillMoveEvent = WillMoveOrResizeEvent & {
+    type: 'will-move';
+};
+export declare type WillResizeEvent = WillMoveOrResizeEvent & {
+    type: 'will-resize';
+};
+/**
+ * A Window event that does propagate to (republish on) parent topics.
+ */
+export declare type WillPropagateWindowEvent = WillPropagateWebContentsEvent | PropagatedViewEvent | ViewDetachedEvent | AuthRequestedEvent | BeginUserBoundsChangingEvent | BoundsChangedEvent | BoundsChangingEvent | WindowCloseRequestedEvent | WindowClosedEvent | WindowClosingEvent | DisabledMovementBoundsChangedEvent | DisabledMovementBoundsChangingEvent | EmbeddedEvent | EndUserBoundsChangingEvent | ExternalProcessExitedEvent | ExternalProcessStartedEvent | HiddenEvent | WindowHotkeyEvent | WindowInitializedEvent | LayoutInitializedEvent | LayoutReadyEvent | MaximizedEvent | MinimizedEvent | WindowOptionsChangedEvent | PerformanceReportEvent | PreloadScriptsStateChangedEvent | PreloadScriptsStateChangingEvent | ReloadedEvent | WindowRestoredEvent | WindowShowRequestedEvent | WindowShownEvent | UserMovementDisabledEvent | UserMovementEnabledEvent | WillMoveEvent | WillRedirectEvent | WillResizeEvent;
+export declare type WindowEvent = {
+    topic: 'window';
+} & (WillPropagateWindowEvent | NonPropagatedWindowEvent);
+export declare type WindowEventType = WindowEvent['type'];
+export declare type PropagatedWindowEvent = PropagatedEvent<'window', WillPropagateWindowEvent>;
+export declare type PropagatedWindowEventType = PropagatedWindowEvent['type'];

package/src/api/external-application/Factory.d.ts

@@ -1,3 +1,4 @@
+import type * as OpenFin from '../../OpenFin';
 import { Base } from '../base';
 /**
  * @lends ExternalApplication

package/src/api/external-application/Instance.d.ts

@@ -1,3 +1,4 @@
+import type * as OpenFin from '../../OpenFin';
 import { EmitterBase } from '../base';
 import Transport from '../../transport/transport';
 /**
@@ -12,7 +13,7 @@ import Transport from '../../transport/transport';
  * @class
  * @hideconstructor
  */
-export declare class ExternalApplication extends EmitterBase<OpenFin.ExternalApplicationEvents> {
+export declare class ExternalApplication extends EmitterBase<OpenFin.ExternalApplicationEvent> {
     identity: OpenFin.ApplicationIdentity;
     constructor(wire: Transport, identity: OpenFin.ApplicationIdentity);
     /**