@openfin/core 25.68.30 → 25.70.2

package/src/api/clipboard/index.js

@@ -1,88 +1,88 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const base_1 = require("../base");
-/**
- * WriteRequestType interface
- * @typedef { object } WriteRequestType
- * @property { string } data Data to be written
- * @property { string } [type] Clipboard Type
- */
-/**
- * The Clipboard API allows reading and writing to the clipboard in multiple formats.
- * @namespace
- */
-class Clipboard extends base_1.Base {
-    /**
-     * Writes data into the clipboard as plain text
-     * @param { WriteRequestType } writeObj This object is described in the WriteRequestType typeof
-     * @return {Promise.<void>}
-     * @tutorial Clipboard.writeText
-     */
-    writeText(writeObj) {
-        return this.wire.sendAction('clipboard-write-text', writeObj).then(() => undefined);
-    }
-    /**
-     * Read the content of the clipboard as plain text
-     * @param { string } type Clipboard Type
-     * @return {Promise.<string>}
-     * @tutorial Clipboard.readText
-     */
-    readText(type) {
-        return this.wire.sendAction('clipboard-read-text', type).then(({ payload }) => payload.data);
-    }
-    /**
-     * Writes data into the clipboard as Html
-     * @param { WriteRequestType } writeObj This object is described in the WriteRequestType typedef
-     * @return {Promise.<void>}
-     * @tutorial Clipboard.writeHtml
-     */
-    writeHtml(writeObj) {
-        return this.wire.sendAction('clipboard-write-html', writeObj).then(() => undefined);
-    }
-    /**
-     * Read the content of the clipboard as Html
-     * @param { string } type Clipboard Type
-     * @return {Promise.<string>}
-     * @tutorial Clipboard.readHtml
-     */
-    readHtml(type) {
-        return this.wire.sendAction('clipboard-read-html', type).then(({ payload }) => payload.data);
-    }
-    /**
-     * Writes data into the clipboard as Rtf
-     * @param { WriteRequestType } writeObj This object is described in the WriteRequestType typedef
-     * @return {Promise.<void>}
-     * @tutorial Clipboard.writeRtf
-     */
-    writeRtf(writeObj) {
-        return this.wire.sendAction('clipboard-write-rtf', writeObj).then(() => undefined);
-    }
-    /**
-     * Read the content of the clipboard as Rtf
-     * @param { string } type Clipboard Type
-     * @return {Promise.<string>}
-     * @tutorial Clipboard.readRtf
-     */
-    readRtf(type) {
-        return this.wire.sendAction('clipboard-read-rtf', type).then(({ payload }) => payload.data);
-    }
-    /**
-     * Writes data into the clipboard
-     * @param { WriteAnyRequestType } writeObj This object is described in the WriteAnyRequestType typedef
-     * @return {Promise.<void>}
-     * @tutorial Clipboard.write
-     */
-    write(writeObj) {
-        return this.wire.sendAction('clipboard-write', writeObj).then(() => undefined);
-    }
-    /**
-     * Reads available formats for the clipboard type
-     * @param { string } type Clipboard Type
-     * @return {Promise.Array.<string>}
-     * @tutorial Clipboard.getAvailableFormats
-     */
-    getAvailableFormats(type) {
-        return this.wire.sendAction('clipboard-read-formats', type).then(({ payload }) => payload.data);
-    }
-}
-exports.default = Clipboard;
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const base_1 = require("../base");
+/**
+ * WriteRequestType interface
+ * @typedef { object } WriteRequestType
+ * @property { string } data Data to be written
+ * @property { string } [type] Clipboard Type
+ */
+/**
+ * The Clipboard API allows reading and writing to the clipboard in multiple formats.
+ * @namespace
+ */
+class Clipboard extends base_1.Base {
+    /**
+     * Writes data into the clipboard as plain text
+     * @param { WriteRequestType } writeObj This object is described in the WriteRequestType typeof
+     * @return {Promise.<void>}
+     * @tutorial Clipboard.writeText
+     */
+    writeText(writeObj) {
+        return this.wire.sendAction('clipboard-write-text', writeObj).then(() => undefined);
+    }
+    /**
+     * Read the content of the clipboard as plain text
+     * @param { string } type Clipboard Type
+     * @return {Promise.<string>}
+     * @tutorial Clipboard.readText
+     */
+    readText(type) {
+        return this.wire.sendAction('clipboard-read-text', type).then(({ payload }) => payload.data);
+    }
+    /**
+     * Writes data into the clipboard as Html
+     * @param { WriteRequestType } writeObj This object is described in the WriteRequestType typedef
+     * @return {Promise.<void>}
+     * @tutorial Clipboard.writeHtml
+     */
+    writeHtml(writeObj) {
+        return this.wire.sendAction('clipboard-write-html', writeObj).then(() => undefined);
+    }
+    /**
+     * Read the content of the clipboard as Html
+     * @param { string } type Clipboard Type
+     * @return {Promise.<string>}
+     * @tutorial Clipboard.readHtml
+     */
+    readHtml(type) {
+        return this.wire.sendAction('clipboard-read-html', type).then(({ payload }) => payload.data);
+    }
+    /**
+     * Writes data into the clipboard as Rtf
+     * @param { WriteRequestType } writeObj This object is described in the WriteRequestType typedef
+     * @return {Promise.<void>}
+     * @tutorial Clipboard.writeRtf
+     */
+    writeRtf(writeObj) {
+        return this.wire.sendAction('clipboard-write-rtf', writeObj).then(() => undefined);
+    }
+    /**
+     * Read the content of the clipboard as Rtf
+     * @param { string } type Clipboard Type
+     * @return {Promise.<string>}
+     * @tutorial Clipboard.readRtf
+     */
+    readRtf(type) {
+        return this.wire.sendAction('clipboard-read-rtf', type).then(({ payload }) => payload.data);
+    }
+    /**
+     * Writes data into the clipboard
+     * @param { WriteAnyRequestType } writeObj This object is described in the WriteAnyRequestType typedef
+     * @return {Promise.<void>}
+     * @tutorial Clipboard.write
+     */
+    write(writeObj) {
+        return this.wire.sendAction('clipboard-write', writeObj).then(() => undefined);
+    }
+    /**
+     * Reads available formats for the clipboard type
+     * @param { string } type Clipboard Type
+     * @return {Promise.Array.<string>}
+     * @tutorial Clipboard.getAvailableFormats
+     */
+    getAvailableFormats(type) {
+        return this.wire.sendAction('clipboard-read-formats', type).then(({ payload }) => payload.data);
+    }
+}
+exports.default = Clipboard;

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

@@ -0,0 +1,69 @@
+import { WindowEvent, BaseEventMap, ApplicationEvent } from './base';
+import { WindowAlertRequestedEvent, WindowAuthRequestedEvent, WindowEndLoadEvent, PropagatedWindowEvents, WindowPerformanceReport } from './window';
+import { PropagatedViewEvents } from './view';
+export interface CrashedEvent {
+    reason: 'normal-termination' | 'abnormal-termination' | 'killed' | 'crashed' | 'still-running' | 'launch-failed' | 'out-of-memory' | 'integrity-failure';
+    exitCode: number;
+    details: {
+        reason: string;
+        exitCode: number;
+    };
+}
+export interface RunRequestedEvent<Topic, Type> extends ApplicationEvent<Topic, Type> {
+    userAppConfigArgs: any;
+    manifest: OpenFin.ManifestInfo;
+}
+export interface TrayIconClicked<Topic, Type> extends ApplicationEvent<Topic, Type> {
+    button: 0 | 1 | 2;
+    bounds: OpenFin.Rectangle;
+    x: number;
+    y: number;
+    monitorInfo: any;
+}
+export interface 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];
+};

package/src/api/events/application.js

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

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

@@ -0,0 +1,17 @@
+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> {
+    uuid: string;
+}
+export interface WindowEvent<Topic, Type> extends ApplicationEvent<Topic, Type> {
+    name: string;
+}
+export interface BaseEventMap {
+    [name: string]: any;
+    newListener: string;
+    listenerRemoved: string;
+}

package/src/api/events/base.js

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

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

@@ -1,11 +1,10 @@
-import ApplicationEvent = OpenFin.ApplicationEvent;
-import BaseEventMap = OpenFin.BaseEventMap;
-export interface ChannelEvent<Type> extends ApplicationEvent<'channel', Type> {
-    channelName: string;
-    channelId: string;
-    name: string;
-}
-export interface ChannelEvents extends BaseEventMap {
-    connected: ChannelEvent<'connected'>;
-    disconnected: ChannelEvent<'disconnected'>;
-}
+import { BaseEventMap, ApplicationEvent } from './base';
+export interface ChannelEvent<Type> extends ApplicationEvent<'channel', Type> {
+    channelName: string;
+    channelId: string;
+    name: string;
+}
+export interface ChannelEvents extends BaseEventMap {
+    connected: ChannelEvent<'connected'>;
+    disconnected: ChannelEvent<'disconnected'>;
+}

package/src/api/events/channel.js

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

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

@@ -1,11 +1,11 @@
-/// <reference types="node" />
-import { EventEmitter } from 'events';
-export declare class EmitterMap {
-    private storage;
-    constructor();
-    private hashKeys;
-    getOrCreate(keys: EmitterAccessor): EventEmitter;
-    has(keys: EmitterAccessor): boolean;
-    delete(keys: EmitterAccessor): boolean;
-}
-export declare type EmitterAccessor = string[];
+/// <reference types="node" />
+import { EventEmitter } from 'events';
+export declare class EmitterMap {
+    private storage;
+    constructor();
+    private hashKeys;
+    getOrCreate(keys: EmitterAccessor): EventEmitter;
+    has(keys: EmitterAccessor): boolean;
+    delete(keys: EmitterAccessor): boolean;
+}
+export declare type EmitterAccessor = string[];

package/src/api/events/emitterMap.js

@@ -1,35 +1,35 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.EmitterMap = void 0;
-const events_1 = require("events");
-class EmitterMap {
-    constructor() {
-        this.storage = new Map();
-    }
-    // eslint-disable-next-line class-methods-use-this
-    hashKeys(keys) {
-        const hashed = keys.map(normalizeString);
-        return hashed.join('/');
-    }
-    getOrCreate(keys) {
-        const hash = this.hashKeys(keys);
-        if (!this.storage.has(hash)) {
-            this.storage.set(hash, new events_1.EventEmitter());
-        }
-        // We set it above
-        // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
-        return this.storage.get(hash);
-    }
-    has(keys) {
-        return this.storage.has(this.hashKeys(keys));
-    }
-    delete(keys) {
-        const hash = this.hashKeys(keys);
-        return this.storage.delete(hash);
-    }
-}
-exports.EmitterMap = EmitterMap;
-function normalizeString(s) {
-    const b = Buffer.from(s);
-    return b.toString('base64');
-}
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EmitterMap = void 0;
+const events_1 = require("events");
+class EmitterMap {
+    constructor() {
+        this.storage = new Map();
+    }
+    // eslint-disable-next-line class-methods-use-this
+    hashKeys(keys) {
+        const hashed = keys.map(normalizeString);
+        return hashed.join('/');
+    }
+    getOrCreate(keys) {
+        const hash = this.hashKeys(keys);
+        if (!this.storage.has(hash)) {
+            this.storage.set(hash, new events_1.EventEmitter());
+        }
+        // We set it above
+        // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+        return this.storage.get(hash);
+    }
+    has(keys) {
+        return this.storage.has(this.hashKeys(keys));
+    }
+    delete(keys) {
+        const hash = this.hashKeys(keys);
+        return this.storage.delete(hash);
+    }
+}
+exports.EmitterMap = EmitterMap;
+function normalizeString(s) {
+    const b = Buffer.from(s);
+    return b.toString('base64');
+}

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

@@ -1,5 +1,5 @@
-import { EmitterMap } from './emitterMap';
-import Message = OpenFin.Message;
-export default class EventAggregator extends EmitterMap {
-    dispatchEvent: (message: Message<any>) => boolean;
-}
+import { Message } from '../../transport/transport';
+import { EmitterMap } from './emitterMap';
+export default class EventAggregator extends EmitterMap {
+    dispatchEvent: (message: Message<any>) => boolean;
+}

package/src/api/events/eventAggregator.js

@@ -1,43 +1,43 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const emitterMap_1 = require("./emitterMap");
-function isEventMessage(message) {
-    return message.action === 'process-desktop-event';
-}
-function mapKeyFromEvent(event) {
-    const { topic } = event;
-    if (topic === 'frame') {
-        const { uuid, name } = event;
-        return [topic, uuid, name];
-    }
-    if (topic === 'window') {
-        const { uuid, name } = event;
-        return [topic, uuid, name];
-    }
-    if (topic === 'application') {
-        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 {
-    constructor() {
-        super(...arguments);
-        this.dispatchEvent = (message) => {
-            if (isEventMessage(message)) {
-                const { payload } = message;
-                const accessor = mapKeyFromEvent(payload);
-                if (this.has(accessor)) {
-                    this.getOrCreate(accessor).emit(payload.type, payload);
-                    return true;
-                }
-            }
-            return false;
-        };
-    }
-}
-exports.default = EventAggregator;
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const emitterMap_1 = require("./emitterMap");
+function isEventMessage(message) {
+    return message.action === 'process-desktop-event';
+}
+function mapKeyFromEvent(event) {
+    const { topic } = event;
+    if (topic === 'frame') {
+        const { uuid, name } = event;
+        return [topic, uuid, name];
+    }
+    if (topic === 'window') {
+        const { uuid, name } = event;
+        return [topic, uuid, name];
+    }
+    if (topic === 'application') {
+        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 {
+    constructor() {
+        super(...arguments);
+        this.dispatchEvent = (message) => {
+            if (isEventMessage(message)) {
+                const { payload } = message;
+                const accessor = mapKeyFromEvent(payload);
+                if (this.has(accessor)) {
+                    this.getOrCreate(accessor).emit(payload.type, payload);
+                    return true;
+                }
+            }
+            return false;
+        };
+    }
+}
+exports.default = EventAggregator;

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

@@ -0,0 +1,5 @@
+import { RuntimeEvent, BaseEventMap } from './base';
+export interface ExternalApplicationEvents extends BaseEventMap {
+    connected: RuntimeEvent<'externalapplication', 'connected'>;
+    disconnected: RuntimeEvent<'externalapplication', 'disconnected'>;
+}

package/src/api/events/externalApplication.js

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

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

@@ -0,0 +1,9 @@
+import { BaseEventMap, WindowEvent } from './base';
+export interface FrameEvent<Type> extends WindowEvent<'frame', Type> {
+    entityType: 'iframe';
+    frameName: string;
+}
+export interface FrameEvents extends BaseEventMap {
+    connected: FrameEvent<'connected'>;
+    disconnected: FrameEvent<'disconnected'>;
+}

package/src/api/events/frame.js

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

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

@@ -0,0 +1,10 @@
+import { RuntimeEvent, BaseEventMap } from './base';
+import 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'>;
+}

package/src/api/events/globalHotkey.js

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

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

@@ -0,0 +1,18 @@
+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];
+};
+export declare type PropagatedPlatformEvents<Topic> = {
+    [Type in keyof PropagatedPlatformEventMapping]: PropagatedPlatformEventMapping<Topic, Type>[Type];
+};

package/src/api/events/platform.js

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

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

@@ -0,0 +1,22 @@
+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> {
+    elapsedTime: number;
+    isIdle: boolean;
+}
+export declare type MonitorEvent<Topic, Type> = OpenFin.MonitorInfo & BaseEvent<Topic, Type>;
+export interface SessionChangedEvent<Topic, Type> extends BaseEvent<Topic, Type> {
+    reason: 'lock' | 'unlock' | 'remote-connect' | 'remote-disconnect' | 'unknown';
+}
+export interface SystemEventMapping<Topic = string, Type = string> extends BaseEventMap {
+    'application-created': ApplicationEvent<Topic, Type>;
+    'desktop-icon-clicked': ApplicationEvent<Topic, Type>;
+    'idle-state-changed': IdleEvent<Topic, Type>;
+    'monitor-info-changed': MonitorEvent<Topic, Type>;
+    'session-changed': SessionChangedEvent<Topic, Type>;
+}
+export declare type SystemEvents = PropagatedWindowEvents<'system'> & PropagatedApplicationEvents<'system'> & PropagatedViewEvents<'system'> & {
+    [Type in keyof SystemEventMapping]: SystemEventMapping<'system', Type>[Type];
+};

package/src/api/events/system.js

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

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

@@ -0,0 +1,56 @@
+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> {
+    previousTarget: OpenFin.Identity;
+    target: OpenFin.Identity;
+}
+export {};