@openfin/core 30.73.23 → 30.73.27

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@openfin/core",
-    "version": "30.73.23",
+    "version": "30.73.27",
     "license": "Apache-2.0",
     "main": "./src/mock.js",
     "types": "./src/mock.d.ts",

package/src/OpenFin.d.ts

@@ -1,12 +1,13 @@
 import type { Application } from './api/application';
-import { ApplicationEvents } from './api/events/application';
-import { ExternalApplicationEvents } from './api/events/externalApplication';
-import { FrameEvents } from './api/events/frame';
-import { GlobalHotkeyEvents } from './api/events/globalHotkey';
-import { PlatformEvents } from './api/events/platform';
-import { SystemEvents } from './api/events/system';
-import { ViewEvents } from './api/events/view';
-import { WindowEvents, WindowOptionsChangedEvent } from './api/events/window';
+import { ApplicationEvent } from './api/events/application';
+import { ExternalApplicationEvent } from './api/events/externalApplication';
+import { FrameEvent } from './api/events/frame';
+import { GlobalHotkeyEvent } from './api/events/globalHotkey';
+import { PlatformEvent } from './api/events/platform';
+import { AppVersionEvent, SystemEvent } from './api/events/system';
+import { TypedEventEmitter } from './api/events/typedEventEmitter';
+import { ViewEvent } from './api/events/view';
+import { WindowEvent, WindowOptionsChangedEvent } from './api/events/window';
 import type { ExternalApplication } from './api/external-application';
 import { FinApi } from './api/fin';
 import type { _Frame } from './api/frame';
@@ -770,7 +771,7 @@ export declare type PlatformProvider = {
      * 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<HostContextChangedPayload | undefined>;
+    onWindowContextUpdated(payload: WindowOptionsChangedEvent): Promise<HostContextChangedPayload | undefined>;
     /**
      * Closes a Window.
      * By default it will fire any before unload handler set by a View in the Window.
@@ -979,21 +980,7 @@ export declare type AppVersionRuntimeInfo = {
     healthCheck: boolean | null;
     error: string | null;
 };
-export declare type AppVersionProgressEvent = {
-    type: 'app-version-progress';
-} & AppVersionProgress;
-export declare type AppVersionErrorEvent = {
-    type: 'app-version-error';
-} & AppVersionError;
-export declare type AppVersionCompleteEvent = {
-    type: 'app-version-complete';
-} & AppVersionProgress;
-export declare type AppVersionRuntimeStatusEvent = {
-    type: 'runtime-status';
-} & AppVersionRuntimeInfo;
-export declare type AppVersionEvents = AppVersionProgressEvent | AppVersionRuntimeStatusEvent | AppVersionCompleteEvent | AppVersionErrorEvent;
-export declare type AppVersionEventNames = AppVersionEvents['type'];
-export declare type LaunchEmitter = import('./api/events/typedEventEmitter').TypedEventEmitter<AppVersionEvents>;
+export declare type LaunchEmitter = TypedEventEmitter<AppVersionEvent>;
 export declare type RvmLaunchOptions = {
     noUi?: boolean;
     userAppConfigArgs?: object;
@@ -1433,7 +1420,19 @@ export interface PopupResult<T = any> {
     data?: T;
     lastDispatchResult?: PopupResult;
 }
-export type { SystemEvents, ApplicationEvents, WindowEvents, ViewEvents, GlobalHotkeyEvents, FrameEvents, PlatformEvents, ExternalApplicationEvents };
+export declare type AppVersionProgressEvent = {
+    type: 'app-version-progress';
+} & AppVersionProgress;
+export declare type AppVersionErrorEvent = {
+    type: 'app-version-error';
+} & AppVersionError;
+export declare type AppVersionCompleteEvent = {
+    type: 'app-version-complete';
+} & AppVersionProgress;
+export declare type AppVersionRuntimeStatusEvent = {
+    type: 'runtime-status';
+} & AppVersionRuntimeInfo;
+export type { SystemEvent, ApplicationEvent, WindowEvent, ViewEvent, GlobalHotkeyEvent, FrameEvent, PlatformEvent, ExternalApplicationEvent };
 export declare type ContextMenuOptions = {
     template?: Array<PrebuiltContextMenuItem>;
     enabled?: boolean;

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

@@ -7,7 +7,7 @@ import Transport from '../../transport/transport';
  * @class
  * @hideconstructor
  */
-export declare class Application extends EmitterBase<OpenFin.ApplicationEvents> {
+export declare class Application extends EmitterBase<OpenFin.ApplicationEvent> {
     identity: OpenFin.ApplicationIdentity;
     _manifestUrl?: string;
     private window;

package/src/api/base.d.ts

@@ -1,9 +1,9 @@
 /// <reference types="node" />
 import { EventEmitter } from 'events';
-import type * as OpenFin from '../OpenFin';
 import Transport from '../transport/transport';
+import type * as OpenFin from '../OpenFin';
 import Fin from './fin';
-import { BaseEventMap } from './events/base';
+import { BaseEvent, EventHandler } from './events/base';
 declare type ApplicationIdentity = OpenFin.ApplicationIdentity;
 declare type Identity = OpenFin.Identity;
 export declare class Base {
@@ -15,27 +15,29 @@ export declare class Base {
     protected isOpenFinEnvironment: () => boolean;
     protected isBrowserEnvironment: () => boolean;
 }
-export declare class EmitterBase<EventTypes extends BaseEventMap> extends Base {
+export declare class EmitterBase<EmitterEvent extends BaseEvent, EmitterEventType extends EmitterEvent['type'] = EmitterEvent['type']> extends Base {
     #private;
     private topic;
     protected identity: ApplicationIdentity;
     constructor(wire: Transport, topic: string, ...additionalAccessors: string[]);
     eventNames: () => (string | symbol)[];
-    emit: <E extends string | symbol | Extract<keyof EventTypes, string>>(eventName: E, payload: E extends Extract<keyof EventTypes, string> ? EventTypes[E] : any, ...args: any[]) => boolean;
+    emit: <EventType extends EmitterEventType>(eventType: EventType, payload: Extract<EmitterEvent, {
+        type: EventType;
+    }>, ...args: any[]) => boolean;
     private hasEmitter;
     private getOrCreateEmitter;
     listeners: (type: string | symbol) => Function[];
     listenerCount: (type: string | symbol) => number;
-    protected registerEventListener: (eventType: Extract<keyof EventTypes, string> | string | symbol, options: OpenFin.SubscriptionOptions, applySubscription: (emitter: EventEmitter) => void, undoSubscription: (emitter: EventEmitter) => void) => Promise<void>;
-    protected deregisterEventListener: (eventType: Extract<keyof EventTypes, string> | string | symbol, options?: OpenFin.SubscriptionOptions) => Promise<void | EventEmitter>;
-    on<E extends Extract<keyof EventTypes, string> | string | symbol>(eventType: E, listener: (payload: E extends keyof EventTypes ? EventTypes[E] : any, ...args: any[]) => void, options?: OpenFin.SubscriptionOptions): Promise<this>;
-    addListener: <E extends string | symbol | Extract<keyof EventTypes, string>>(eventType: E, listener: (payload: E extends keyof EventTypes ? EventTypes[E] : any, ...args: any[]) => void, options?: OpenFin.SubscriptionOptions) => Promise<this>;
-    once<E extends Extract<keyof EventTypes, string> | string | symbol>(eventType: E, listener: (payload: E extends keyof EventTypes ? EventTypes[E] : any, ...args: any[]) => void, options?: OpenFin.SubscriptionOptions): Promise<this>;
-    prependListener<E extends Extract<keyof EventTypes, string> | string | symbol>(eventType: E, listener: (payload: E extends keyof EventTypes ? EventTypes[E] : any, ...args: any[]) => void, options?: OpenFin.SubscriptionOptions): Promise<this>;
-    prependOnceListener<E extends Extract<keyof EventTypes, string> | string | symbol>(eventType: E, listener: (payload: E extends keyof EventTypes ? EventTypes[E] : any, ...args: any[]) => void, options?: OpenFin.SubscriptionOptions): Promise<this>;
-    removeListener<E extends Extract<keyof EventTypes, string> | string | symbol>(eventType: E, listener: (payload: E extends keyof EventTypes ? EventTypes[E] : any, ...args: any[]) => void, options?: OpenFin.SubscriptionOptions): Promise<this>;
-    protected deregisterAllListeners(eventType: Extract<keyof EventTypes, string> | string | symbol): Promise<EventEmitter | void>;
-    removeAllListeners(eventType?: Extract<keyof EventTypes, string> | string | symbol): Promise<this>;
+    protected registerEventListener: (eventType: EmitterEventType, options: OpenFin.SubscriptionOptions, applySubscription: (emitter: EventEmitter) => void, undoSubscription: (emitter: EventEmitter) => void) => Promise<void>;
+    protected deregisterEventListener: (eventType: EmitterEventType, options?: OpenFin.SubscriptionOptions) => Promise<void | EventEmitter>;
+    on<EventType extends EmitterEventType>(eventType: EventType, listener: EventHandler<EmitterEvent, EventType>, options?: OpenFin.SubscriptionOptions): Promise<this>;
+    addListener: <EventType extends EmitterEventType>(eventType: EventType, listener: EventHandler<EmitterEvent, EventType>, options?: OpenFin.SubscriptionOptions) => Promise<this>;
+    once<EventType extends EmitterEventType>(eventType: EventType, listener: EventHandler<EmitterEvent, EventType>, options?: OpenFin.SubscriptionOptions): Promise<this>;
+    prependListener<EventType extends EmitterEventType>(eventType: EventType, listener: EventHandler<EmitterEvent, EventType>, options?: OpenFin.SubscriptionOptions): Promise<this>;
+    prependOnceListener<EventType extends EmitterEventType>(eventType: EventType, listener: EventHandler<EmitterEvent, EventType>, options?: OpenFin.SubscriptionOptions): Promise<this>;
+    removeListener<EventType extends EmitterEventType>(eventType: EventType, listener: EventHandler<EmitterEvent, EventType>, options?: OpenFin.SubscriptionOptions): Promise<this>;
+    protected deregisterAllListeners(eventType: EmitterEventType): Promise<EventEmitter | void>;
+    removeAllListeners(eventType?: EmitterEventType): Promise<this>;
     private deleteEmitterIfNothingRegistered;
 }
 export declare class Reply<TOPIC extends string, TYPE extends string | void> implements Identity {

package/src/api/base.js

@@ -42,8 +42,8 @@ class EmitterBase extends Base {
         this.topic = topic;
         _EmitterBase_emitterAccessor.set(this, void 0);
         this.eventNames = () => (this.hasEmitter() ? this.getOrCreateEmitter().eventNames() : []);
-        this.emit = (eventName, payload, ...args) => {
-            return this.hasEmitter() ? this.getOrCreateEmitter().emit(eventName, payload, ...args) : false;
+        this.emit = (eventType, payload, ...args) => {
+            return this.hasEmitter() ? this.getOrCreateEmitter().emit(eventType, payload, ...args) : false;
         };
         this.hasEmitter = () => this.wire.eventAggregator.has(__classPrivateFieldGet(this, _EmitterBase_emitterAccessor, "f"));
         this.getOrCreateEmitter = () => this.wire.eventAggregator.getOrCreate(__classPrivateFieldGet(this, _EmitterBase_emitterAccessor, "f"));

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

@@ -1,70 +1,79 @@
 import type * as OpenFin from '../../OpenFin';
-import { ApplicationEvent, BaseEventMap, WindowEvent } from './base';
-import { PropagatedWindowEvents, WindowAlertRequestedEvent, WindowAuthRequestedEvent, WindowEndLoadEvent, WindowPerformanceReport } from './window';
-import { PropagatedViewEvents } from './view';
-export interface CrashedEvent {
+import { IdentityEvent, NamedEvent, PropagatedEvent } from './base';
+import { PropagatedWindowEvent } from './window';
+import { PropagatedViewEvent } from './view';
+export declare type CrashedEvent = NamedEvent & {
+    type: 'crashed';
     reason: 'normal-termination' | 'abnormal-termination' | 'killed' | 'crashed' | 'still-running' | 'launch-failed' | 'out-of-memory' | 'integrity-failure';
     exitCode: number;
     details: {
         reason: string;
         exitCode: number;
     };
-}
-export interface RunRequestedEvent<Topic, Type> extends ApplicationEvent<Topic, Type> {
-    userAppConfigArgs: any;
+};
+export declare type RunRequestedEvent = IdentityEvent & {
+    type: 'run-requested';
+    userAppConfigArgs: Record<string, any>;
     manifest: OpenFin.ManifestInfo;
-}
-export interface TrayIconClicked<Topic, Type> extends ApplicationEvent<Topic, Type> {
+};
+export declare type TrayIconClickedEvent = IdentityEvent & {
+    type: 'tray-icon-clicked';
     button: 0 | 1 | 2;
     bounds: OpenFin.Rectangle;
     x: number;
     y: number;
     monitorInfo: any;
-}
-export interface ApplicationEventMapping<Topic = string, Type = string> extends BaseEventMap {
-    'closed': ApplicationEvent<Topic, Type>;
-    'connected': ApplicationEvent<Topic, Type>;
-    'crashed': CrashedEvent & ApplicationEvent<Topic, Type>;
-    'initialized': ApplicationEvent<Topic, Type>;
-    'manifest-changed': ApplicationEvent<Topic, Type>;
-    'not-responding': ApplicationEvent<Topic, Type>;
-    'responding': ApplicationEvent<Topic, Type>;
-    'run-requested': RunRequestedEvent<Topic, Type>;
-    'started': ApplicationEvent<Topic, Type>;
-    'tray-icon-clicked': TrayIconClicked<Topic, Type>;
-    'window-alert-requested': WindowAlertRequestedEvent<Topic, Type>;
-    'window-auth-requested': WindowAuthRequestedEvent<Topic, Type>;
-    'window-created': WindowEvent<Topic, Type>;
-    'window-end-load': WindowEndLoadEvent<Topic, Type>;
-    'window-not-responding': WindowEvent<Topic, Type>;
-    'window-performance-report': WindowPerformanceReport<Topic, Type>;
-    'window-responding': WindowEvent<Topic, Type>;
-    'window-show-requested': WindowEvent<Topic, Type>;
-    'window-start-load': WindowEvent<Topic, Type>;
-}
-export interface PropagatedApplicationEventMapping<Topic = string, Type = string> {
-    'application-closed': ApplicationEvent<Topic, Type>;
-    'application-connected': ApplicationEvent<Topic, Type>;
-    'application-crashed': CrashedEvent & ApplicationEvent<Topic, Type>;
-    'application-initialized': ApplicationEvent<Topic, Type>;
-    'application-manifest-changed': ApplicationEvent<Topic, Type>;
-    'application-not-responding': ApplicationEvent<Topic, Type>;
-    'application-responding': ApplicationEvent<Topic, Type>;
-    'application-started': ApplicationEvent<Topic, Type>;
-    'application-tray-icon-clicked': TrayIconClicked<Topic, Type>;
-    'window-created': WindowEvent<Topic, Type>;
-    'window-did-change-theme-color': WindowEvent<Topic, Type>;
-    'window-end-load': WindowEndLoadEvent<Topic, Type>;
-    'window-not-responding': WindowEvent<Topic, Type>;
-    'window-page-favicon-updated': WindowEvent<Topic, Type>;
-    'window-page-title-updated': WindowEvent<Topic, Type>;
-    'window-performance-report': WindowPerformanceReport<Topic, Type>;
-    'window-responding': WindowEvent<Topic, Type>;
-    'window-start-load': WindowEvent<Topic, Type>;
-}
-export declare type ApplicationEvents = PropagatedWindowEvents<'application'> & PropagatedViewEvents<'application'> & {
-    [Type in keyof ApplicationEventMapping]: ApplicationEventMapping<'application', Type>[Type];
-};
-export declare type PropagatedApplicationEvents<Topic> = {
-    [Type in keyof PropagatedApplicationEventMapping]: PropagatedApplicationEventMapping<Topic, Type>[Type];
 };
+export declare type WindowAlertRequestedEvent = NamedEvent & {
+    type: 'window-alert-requested';
+};
+export declare type WindowCreatedEvent = NamedEvent & {
+    type: 'window-created';
+};
+export declare type WindowEndLoadEvent = NamedEvent & {
+    type: 'window-end-load';
+};
+export declare type WindowNotRespondingEvent = NamedEvent & {
+    type: 'window-not-responding';
+};
+export declare type WindowRespondingEvent = NamedEvent & {
+    type: 'window-responding';
+};
+export declare type WindowStartLoadEvent = NamedEvent & {
+    type: 'window-start-load';
+};
+/**
+ * A Window event that is natively published at the Application level (not Window).
+ */
+export declare type ApplicationWindowEvent = WindowAlertRequestedEvent | WindowCreatedEvent | WindowEndLoadEvent | WindowNotRespondingEvent | WindowRespondingEvent | WindowStartLoadEvent;
+export declare type ClosedEvent = IdentityEvent & {
+    type: 'closed';
+};
+export declare type ApplicationConnectedEvent = IdentityEvent & {
+    type: 'connected';
+};
+export declare type InitializedEvent = IdentityEvent & {
+    type: 'initialized';
+};
+export declare type ManifestChangedEvent = IdentityEvent & {
+    type: 'manifest-changed';
+};
+export declare type NotRespondingEvent = IdentityEvent & {
+    type: 'not-responding';
+};
+export declare type RespondingEvent = IdentityEvent & {
+    type: 'responding';
+};
+export declare type StartedEvent = IdentityEvent & {
+    type: 'started';
+};
+/**
+ * An Application event that does propagate to (republish on) parent topics.
+ */
+export declare type WillPropagateApplicationEvent = ClosedEvent | ApplicationConnectedEvent | CrashedEvent | InitializedEvent | ManifestChangedEvent | NotRespondingEvent | RespondingEvent | RunRequestedEvent | StartedEvent | TrayIconClickedEvent;
+export declare type ApplicationEvent = {
+    topic: 'application';
+} & (PropagatedViewEvent | PropagatedWindowEvent | ApplicationWindowEvent | WillPropagateApplicationEvent);
+export declare type ApplicationEventType = ApplicationEvent['type'];
+export declare type PropagatedApplicationEvent = PropagatedEvent<'application', WillPropagateApplicationEvent> | ApplicationWindowEvent;
+export declare type PropagatedApplicationEventType = PropagatedApplicationEvent['type'];

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

@@ -1,17 +1,35 @@
-import { FrameEvent } from './frame';
-export declare type RuntimeEvent<Topic = string, Type = string> = Topic extends 'window' | 'view' ? WindowEvent<Topic, Type> : Topic extends 'frame' ? FrameEvent<Type> : Topic extends 'application' ? ApplicationEvent<Topic, Type> : BaseEvent<Topic, Type>;
-export interface BaseEvent<Topic, Type> {
-    topic: Topic;
-    type: Type;
-}
-export interface ApplicationEvent<Topic, Type> extends BaseEvent<Topic, Type> {
+import type * as OpenFin from '../../OpenFin';
+/**
+ * Modifies an event key to reflect propagation by prefixing with the topic.
+ */
+export declare type PropagatedEventType<Topic extends string, Type extends string> = `${Topic}-${Type}`;
+/**
+ * Modifies an event shape to reflect propagation to a parent topic.  The 'type' field
+ * is prefixed with the original topic, and a new property is added with the original topic's identity.
+ */
+export declare type PropagatedEvent<Topic extends string, Event extends {
+    type: string;
+}> = Event extends infer E extends {
+    type: string;
+} ? Omit<E, 'type'> & {
+    type: PropagatedEventType<Topic, E['type']>;
+} & {
+    [topic in `${Topic}Identity`]: OpenFin.Identity;
+} : never;
+/**
+ * Handler for an event on an EventEmitter; selects the correct type for the event
+ * payload from the provided union based on the provided string literal type.
+ */
+export declare type EventHandler<EmitterEvent extends BaseEvent, EventType extends string> = (payload: Extract<EmitterEvent, {
+    type: EventType;
+}>, ...args: any[]) => void;
+export declare type BaseEvent = {
+    topic: string;
+    type: string;
+};
+export declare type IdentityEvent = BaseEvent & {
     uuid: string;
-}
-export interface WindowEvent<Topic, Type> extends ApplicationEvent<Topic, Type> {
+};
+export declare type NamedEvent = IdentityEvent & {
     name: string;
-}
-export interface BaseEventMap {
-    [name: string]: any;
-    newListener: string;
-    listenerRemoved: string;
-}
+};

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

@@ -1,10 +1,15 @@
-import { ApplicationEvent, BaseEventMap } from './base';
-export interface ChannelEvent<Type> extends ApplicationEvent<'channel', Type> {
+import { NamedEvent } from './base';
+export declare type BaseChannelEvent = NamedEvent & {
     channelName: string;
     channelId: string;
-    name: string;
-}
-export interface ChannelEvents extends BaseEventMap {
-    connected: ChannelEvent<'connected'>;
-    disconnected: ChannelEvent<'disconnected'>;
-}
+};
+export declare type ChannelConnectedEvent = BaseChannelEvent & {
+    type: 'connected';
+};
+export declare type ChannelDisconnectedEvent = BaseChannelEvent & {
+    type: 'disconnected';
+};
+export declare type ChannelEvent = {
+    topic: 'channel';
+} & (ChannelConnectedEvent | ChannelDisconnectedEvent);
+export declare type ChannelEventType = ChannelEvent['type'];

package/src/api/events/eventAggregator.js

@@ -6,11 +6,7 @@ function isEventMessage(message) {
 }
 function mapKeyFromEvent(event) {
     const { topic } = event;
-    if (topic === 'frame') {
-        const { uuid, name } = event;
-        return [topic, uuid, name];
-    }
-    if (topic === 'window') {
+    if (topic === 'frame' || topic === 'window' || topic === 'view') {
         const { uuid, name } = event;
         return [topic, uuid, name];
     }
@@ -18,10 +14,6 @@ function mapKeyFromEvent(event) {
         const { uuid } = event;
         return [topic, uuid];
     }
-    if (topic === 'view') {
-        const { uuid, name } = event;
-        return [topic, uuid, name];
-    }
     return [topic];
 }
 class EventAggregator extends emitterMap_1.EmitterMap {

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

@@ -1,5 +1,10 @@
-import { BaseEventMap, RuntimeEvent } from './base';
-export interface ExternalApplicationEvents extends BaseEventMap {
-    connected: RuntimeEvent<'externalapplication', 'connected'>;
-    disconnected: RuntimeEvent<'externalapplication', 'disconnected'>;
-}
+import { BaseEvent } from './base';
+export declare type ExternalApplicationConnectedEvent = BaseEvent & {
+    type: 'connected';
+};
+export declare type ExternalApplicationDisconnectedEvent = BaseEvent & {
+    type: 'disconnected';
+};
+export declare type ExternalApplicationEvent = {
+    topic: 'externalapplication';
+} & (ExternalApplicationConnectedEvent | ExternalApplicationDisconnectedEvent);

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

@@ -1,9 +1,15 @@
-import { BaseEventMap, WindowEvent } from './base';
-export interface FrameEvent<Type> extends WindowEvent<'frame', Type> {
+import { NamedEvent } from './base';
+export declare type BaseFrameEvent = NamedEvent & {
     entityType: 'iframe';
     frameName: string;
-}
-export interface FrameEvents extends BaseEventMap {
-    connected: FrameEvent<'connected'>;
-    disconnected: FrameEvent<'disconnected'>;
-}
+};
+export declare type FrameConnectedEvent = BaseFrameEvent & {
+    type: 'connected';
+};
+export declare type FrameDisconnectedEvent = BaseFrameEvent & {
+    type: 'disconnected';
+};
+export declare type FrameEvent = {
+    topic: 'frame';
+} & (FrameConnectedEvent | FrameDisconnectedEvent);
+export declare type FrameEventType = FrameEvent['type'];

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

@@ -1,12 +1,11 @@
-import type * as OpenFin from '../../OpenFin';
-import { BaseEventMap, RuntimeEvent } from './base';
-declare type Identity = OpenFin.Identity;
-export interface GlobalHotkeyEvent<Type> extends RuntimeEvent<'global-hotkey', Type> {
-    identity: Identity;
-    hotkey: string;
-}
-export interface GlobalHotkeyEvents extends BaseEventMap {
-    registered: GlobalHotkeyEvent<'registered'>;
-    unregistered: GlobalHotkeyEvent<'unregistered'>;
-}
-export {};
+import { BaseEvent } from './base';
+export declare type RegisteredEvent = BaseEvent & {
+    type: 'registered';
+};
+export declare type UnregisteredEvent = BaseEvent & {
+    type: 'unregistered';
+};
+export declare type GlobalHotkeyEvent = {
+    topic: 'global-hotkey';
+    hotkey: 'string';
+} & (RegisteredEvent | UnregisteredEvent);

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

@@ -1,18 +1,12 @@
-import { ApplicationEvent } from './base';
-import { PropagatedWindowEvents } from './window';
-import { PropagatedViewEvents } from './view';
-import { ApplicationEventMapping, PropagatedApplicationEventMapping } from './application';
-export interface PlatformEventMapping<Topic = string, Type = string> extends ApplicationEventMapping {
-    'platform-api-ready': ApplicationEvent<Topic, Type>;
-    'platform-snapshot-applied': ApplicationEvent<Topic, Type>;
-}
-export interface PropagatedPlatformEventMapping<Topic = string, Type = string> extends PropagatedApplicationEventMapping {
-    'platform-api-ready': ApplicationEvent<Topic, Type>;
-    'platform-snapshot-applied': ApplicationEvent<Topic, Type>;
-}
-export declare type PlatformEvents = PropagatedWindowEvents<'application'> & PropagatedViewEvents<'application'> & {
-    [Type in keyof PlatformEventMapping]: PlatformEventMapping<'application', Type>[Type];
+import { BaseEvent } from './base';
+import { PropagatedViewEvent } from './view';
+import { PropagatedWindowEvent } from './window';
+export declare type PlatformApiReadyEvent = BaseEvent & {
+    type: 'platform-api-ready';
 };
-export declare type PropagatedPlatformEvents<Topic> = {
-    [Type in keyof PropagatedPlatformEventMapping]: PropagatedPlatformEventMapping<Topic, Type>[Type];
+export declare type PlatformSnapshotAppliedEvent = BaseEvent & {
+    type: 'platform-snapshot-applied';
 };
+export declare type PlatformEvent = {
+    topic: 'platform';
+} & (PropagatedWindowEvent | PropagatedViewEvent | PlatformApiReadyEvent | PlatformSnapshotAppliedEvent);

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

@@ -1,38 +1,51 @@
 import type * as OpenFin from '../../OpenFin';
-import { ApplicationEvent, BaseEvent, 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 { PropagatedApplicationEvent } from './application';
+import { BaseEvent } from './base';
+import { PropagatedViewEvent } from './view';
+import { PropagatedWindowEvent } from './window';
+import { AppVersionCompleteEvent, AppVersionErrorEvent, AppVersionProgressEvent, AppVersionRuntimeStatusEvent } from '../../OpenFin';
+declare type NotRequested<EventType> = EventType extends `${infer U}-requested` ? never : EventType;
+declare type ExcludeRequested<Event extends {
+    type: string;
+}> = Event & {
+    type: NotRequested<Event['type']>;
+};
+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 declare 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 declare type WithId<T extends AppVersionEventNames> = `${T}.${string}`;
+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;
-declare type AppVersionEventNames = OpenFin.AppVersionEvents['type'];
-declare type IdEventNames = WithId<AppVersionEventNames>;
-export declare type AppVersionTypeFromIdEvent<T extends IdEventNames> = Extract<OpenFin.AppVersionEvents, {
+export declare type AppVersionTypeFromIdEvent<T extends IdEventType> = Extract<AppVersionEvent, {
     type: WithoutId<T>;
 }>;
-export declare type AppVersionEventsWithId = {
-    [key in IdEventNames]: Omit<AppVersionTypeFromIdEvent<key>, 'type'> & {
-        type: key;
-        topic: 'system';
-        appVersionId: string;
-    };
+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 SystemEvents = PropagatedWindowEvents<'system'> & PropagatedApplicationEvents<'system'> & PropagatedViewEvents<'system'> & {
-    [Type in keyof SystemEventMapping]: SystemEventMapping<'system', Type>[Type];
-} & AppVersionEventsWithId;
+export declare type SystemEvent = {
+    topic: 'system';
+} & (ExcludeRequested<PropagatedWindowEvent> | ExcludeRequested<PropagatedViewEvent> | PropagatedApplicationEvent | ApplicationCreatedEvent | DesktopIconClickedEvent | IdleEvent | MonitorEvent | SessionChangedEvent | AppVersionEventWithId);
+export declare type SystemEventType = SystemEvent['type'];
 export {};

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

@@ -1,13 +1,20 @@
 export declare type Listener<T extends {
     type: string;
 }> = (payload: T) => void;
-export interface TypedEventEmitter<Events extends {
+export interface TypedEventEmitter<Event extends {
     type: string;
-}> {
-    on<Event extends Events>(event: Event['type'], listener: Listener<Event>): this;
-    once<Event extends Events>(event: Event['type'], listener: Listener<Event>): this;
-    addListener<Event extends Events>(event: Event['type'], listener: Listener<Event>): this;
-    removeListener<Event extends Events>(event: Event['type'], listener: Listener<Event>): this;
-    removeAllListeners<Event extends Events>(event?: Event['type']): this;
-    emit<Event extends Events>(event: Event['type'], payload: Event): boolean;
+}, 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;
 }