@openfin/core 25.68.26

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

@@ -0,0 +1,169 @@
+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> {
+    message: string;
+    url: string;
+}
+export interface WindowAuthRequestedEvent<Topic, Type> extends WindowEvent<Topic, Type> {
+    authInfo: {
+        host: string;
+        isProxy: boolean;
+        port: number;
+        realm: string;
+        scheme: string;
+    };
+}
+export interface WindowEndLoadEvent<Topic, Type> extends WindowEvent<Topic, Type> {
+    documentName: string;
+    isMain: boolean;
+}
+export interface WindowNavigationRejectedEvent<Topic, Type> extends WindowEvent<Topic, Type> {
+    sourceName?: string;
+    url: string;
+}
+export interface WindowReloadedEvent<Topic, Type> extends WindowEvent<Topic, Type> {
+    url: string;
+}
+export interface WindowOptionsChangedEvent<Topic, Type> extends WindowEvent<Topic, Type> {
+    options: OpenFin.WindowOptions;
+    diff: OpenFin.WindowOptionDiff;
+}
+export interface WindowExternalProcessExitedEvent<Topic, Type> extends WindowEvent<Topic, Type> {
+    processUuid: string;
+    exitCode: number;
+}
+export interface WindowExternalProcessStartedEvent<Topic, Type> extends WindowEvent<Topic, Type> {
+    processUuid: string;
+}
+export interface WindowHiddenEvent<Topic, Type> extends WindowEvent<Topic, Type> {
+    reason: 'closing' | 'hide' | 'hide-on-close';
+}
+export interface PreloadScriptInfoRunning {
+    state: 'load-started' | 'load-failed' | 'load-succeeded' | 'failed' | 'succeeded';
+}
+export interface 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> {
+    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> {
+    height: number;
+    left: number;
+    top: number;
+    width: number;
+    windowState: 'minimized' | 'normal' | 'maximized';
+}
+export interface WindowBoundsChange<Topic, Type> extends WindowEvent<Topic, Type> {
+    changeType: 0 | 1 | 2;
+    deferred: boolean;
+    height: number;
+    left: number;
+    top: number;
+    width: number;
+}
+export interface WillMoveOrResize<Topic, Type> extends WindowEvent<Topic, Type> {
+    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> {
+    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-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-will-move': WillMoveOrResize<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];
+};

package/src/api/events/window.js

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

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

@@ -0,0 +1,26 @@
+import { Base } from '../base';
+/**
+ * @lends ExternalApplication
+ */
+export default class ExternalApplicationModule extends Base {
+    /**
+     * Asynchronously returns an External Application object that represents an external application.
+     * <br>It is possible to wrap a process that does not yet exist, (for example, to listen for startup-related events)
+     * provided its uuid is already known.
+     * @param {string} uuid The UUID of the external application to be wrapped
+     * @return {Promise.<ExternalApplication>}
+     * @tutorial ExternalApplication.wrap
+     * @static
+     */
+    wrap(uuid: string): Promise<OpenFin.ExternalApplication>;
+    /**
+     * Synchronously returns an External Application object that represents an external application.
+     * <br>It is possible to wrap a process that does not yet exist, (for example, to listen for startup-related events)
+     * provided its uuid is already known.
+     * @param {string} uuid The UUID of the external application to be wrapped
+     * @return {ExternalApplication}
+     * @tutorial ExternalApplication.wrapSync
+     * @static
+     */
+    wrapSync(uuid: string): OpenFin.ExternalApplication;
+}

package/src/api/external-application/Factory.js

@@ -0,0 +1,40 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const base_1 = require("../base");
+const Instance_1 = require("./Instance");
+/**
+ * @lends ExternalApplication
+ */
+class ExternalApplicationModule extends base_1.Base {
+    /**
+     * Asynchronously returns an External Application object that represents an external application.
+     * <br>It is possible to wrap a process that does not yet exist, (for example, to listen for startup-related events)
+     * provided its uuid is already known.
+     * @param {string} uuid The UUID of the external application to be wrapped
+     * @return {Promise.<ExternalApplication>}
+     * @tutorial ExternalApplication.wrap
+     * @static
+     */
+    wrap(uuid) {
+        this.wire.sendAction('external-application-wrap').catch((e) => {
+            // we do not want to expose this error, just continue if this analytics-only call fails
+        });
+        return Promise.resolve(new Instance_1.ExternalApplication(this.wire, { uuid }));
+    }
+    /**
+     * Synchronously returns an External Application object that represents an external application.
+     * <br>It is possible to wrap a process that does not yet exist, (for example, to listen for startup-related events)
+     * provided its uuid is already known.
+     * @param {string} uuid The UUID of the external application to be wrapped
+     * @return {ExternalApplication}
+     * @tutorial ExternalApplication.wrapSync
+     * @static
+     */
+    wrapSync(uuid) {
+        this.wire.sendAction('external-application-wrap-sync').catch((e) => {
+            // we do not want to expose this error, just continue if this analytics-only call fails
+        });
+        return new Instance_1.ExternalApplication(this.wire, { uuid });
+    }
+}
+exports.default = ExternalApplicationModule;

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

@@ -0,0 +1,102 @@
+import { EmitterBase } from '../base';
+import Transport from '../../transport/transport';
+import { ExternalApplicationEvents } from '../events/externalApplication';
+/**
+ * @classdesc An ExternalApplication object representing native language adapter connections to the runtime. Allows
+ * the developer to listen to <a href="tutorial-ExternalApplication.EventEmitter.html">application events.</a>
+ * Discovery of connections is provided by <a href="tutorial-System.getAllExternalApplications.html">getAllExternalApplications.</a>
+ *
+ * Processes that can be wrapped as `ExternalApplication`s include the following:
+ * - Processes which have connected to an OpenFin runtime via an adapter
+ * - Processes started via `System.launchExternalApplication`
+ * - Processes monitored via `System.monitorExternalProcess`
+ * @class
+ * @hideconstructor
+ */
+export declare class ExternalApplication extends EmitterBase<ExternalApplicationEvents> {
+    identity: OpenFin.ApplicationIdentity;
+    constructor(wire: Transport, identity: OpenFin.ApplicationIdentity);
+    /**
+     * Adds a listener to the end of the listeners array for the specified event.
+     * @param { string | symbol } eventType  - The type of the event.
+     * @param { Function } listener - Called whenever an event of the specified type occurs.
+     * @param { SubOptions } [options] - Option to support event timestamps.
+     * @return {Promise.<this>}
+     * @function addListener
+     * @memberof ExternalApplication
+     * @instance
+     * @tutorial ExternalApplication.EventEmitter
+     */
+    /**
+     * Adds a listener to the end of the listeners array for the specified event.
+     * @param { string | symbol } eventType  - The type of the event.
+     * @param { Function } listener - Called whenever an event of the specified type occurs.
+     * @param { SubOptions } [options] - Option to support event timestamps.
+     * @return {Promise.<this>}
+     * @function on
+     * @memberof ExternalApplication
+     * @instance
+     * @tutorial ExternalApplication.EventEmitter
+     */
+    /**
+     * Adds a one time listener for the event. The listener is invoked only the first time the event is fired, after which it is removed.
+     * @param { string | symbol } eventType  - The type of the event.
+     * @param { Function } listener - The callback function.
+     * @param { SubOptions } [options] - Option to support event timestamps.
+     * @return {Promise.<this>}
+     * @function once
+     * @memberof ExternalApplication
+     * @instance
+     * @tutorial ExternalApplication.EventEmitter
+     */
+    /**
+     * Adds a listener to the beginning of the listeners array for the specified event.
+     * @param { string | symbol } eventType  - The type of the event.
+     * @param { Function } listener - The callback function.
+     * @param { SubOptions } [options] - Option to support event timestamps.
+     * @return {Promise.<this>}
+     * @function prependListener
+     * @memberof ExternalApplication
+     * @instance
+     * @tutorial ExternalApplication.EventEmitter
+     */
+    /**
+     * Adds a one time listener for the event. The listener is invoked only the first time the event is fired, after which it is removed.
+     * The listener is added to the beginning of the listeners array.
+     * @param { string | symbol } eventType  - The type of the event.
+     * @param { Function } listener - The callback function.
+     * @param { SubOptions } [options] - Option to support event timestamps.
+     * @return {Promise.<this>}
+     * @function prependOnceListener
+     * @memberof ExternalApplication
+     * @instance
+     * @tutorial ExternalApplication.EventEmitter
+     */
+    /**
+     * Remove a listener from the listener array for the specified event.
+     * Caution: Calling this method changes the array indices in the listener array behind the listener.
+     * @param { string | symbol } eventType  - The type of the event.
+     * @param { Function } listener - The callback function.
+     * @param { SubOptions } [options] - Option to support event timestamps.
+     * @return {Promise.<this>}
+     * @function removeListener
+     * @memberof ExternalApplication
+     * @instance
+     * @tutorial ExternalApplication.EventEmitter
+     */
+    /**
+     * Removes all listeners, or those of the specified event.
+     * @param { string | symbol } [eventType]  - The type of the event.
+     * @return {Promise.<this>}
+     * @function removeAllListeners
+     * @memberof ExternalApplication
+     * @instance
+     * @tutorial ExternalApplication.EventEmitter
+     */
+    /**
+     * Retrieves information about the external application.
+     * @return {Promise.<ExternalApplicationInfo>}
+     * @tutorial ExternalApplication.getInfo
+     */
+    getInfo(): Promise<OpenFin.ExternalApplicationInfo>;
+}

package/src/api/external-application/Instance.js

@@ -0,0 +1,109 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ExternalApplication = void 0;
+/* eslint-disable import/prefer-default-export */
+const base_1 = require("../base");
+/**
+ * @classdesc An ExternalApplication object representing native language adapter connections to the runtime. Allows
+ * the developer to listen to <a href="tutorial-ExternalApplication.EventEmitter.html">application events.</a>
+ * Discovery of connections is provided by <a href="tutorial-System.getAllExternalApplications.html">getAllExternalApplications.</a>
+ *
+ * Processes that can be wrapped as `ExternalApplication`s include the following:
+ * - Processes which have connected to an OpenFin runtime via an adapter
+ * - Processes started via `System.launchExternalApplication`
+ * - Processes monitored via `System.monitorExternalProcess`
+ * @class
+ * @hideconstructor
+ */
+class ExternalApplication extends base_1.EmitterBase {
+    constructor(wire, identity) {
+        super(wire, 'external-application', identity.uuid);
+        this.identity = identity;
+    }
+    /**
+     * Adds a listener to the end of the listeners array for the specified event.
+     * @param { string | symbol } eventType  - The type of the event.
+     * @param { Function } listener - Called whenever an event of the specified type occurs.
+     * @param { SubOptions } [options] - Option to support event timestamps.
+     * @return {Promise.<this>}
+     * @function addListener
+     * @memberof ExternalApplication
+     * @instance
+     * @tutorial ExternalApplication.EventEmitter
+     */
+    /**
+     * Adds a listener to the end of the listeners array for the specified event.
+     * @param { string | symbol } eventType  - The type of the event.
+     * @param { Function } listener - Called whenever an event of the specified type occurs.
+     * @param { SubOptions } [options] - Option to support event timestamps.
+     * @return {Promise.<this>}
+     * @function on
+     * @memberof ExternalApplication
+     * @instance
+     * @tutorial ExternalApplication.EventEmitter
+     */
+    /**
+     * Adds a one time listener for the event. The listener is invoked only the first time the event is fired, after which it is removed.
+     * @param { string | symbol } eventType  - The type of the event.
+     * @param { Function } listener - The callback function.
+     * @param { SubOptions } [options] - Option to support event timestamps.
+     * @return {Promise.<this>}
+     * @function once
+     * @memberof ExternalApplication
+     * @instance
+     * @tutorial ExternalApplication.EventEmitter
+     */
+    /**
+     * Adds a listener to the beginning of the listeners array for the specified event.
+     * @param { string | symbol } eventType  - The type of the event.
+     * @param { Function } listener - The callback function.
+     * @param { SubOptions } [options] - Option to support event timestamps.
+     * @return {Promise.<this>}
+     * @function prependListener
+     * @memberof ExternalApplication
+     * @instance
+     * @tutorial ExternalApplication.EventEmitter
+     */
+    /**
+     * Adds a one time listener for the event. The listener is invoked only the first time the event is fired, after which it is removed.
+     * The listener is added to the beginning of the listeners array.
+     * @param { string | symbol } eventType  - The type of the event.
+     * @param { Function } listener - The callback function.
+     * @param { SubOptions } [options] - Option to support event timestamps.
+     * @return {Promise.<this>}
+     * @function prependOnceListener
+     * @memberof ExternalApplication
+     * @instance
+     * @tutorial ExternalApplication.EventEmitter
+     */
+    /**
+     * Remove a listener from the listener array for the specified event.
+     * Caution: Calling this method changes the array indices in the listener array behind the listener.
+     * @param { string | symbol } eventType  - The type of the event.
+     * @param { Function } listener - The callback function.
+     * @param { SubOptions } [options] - Option to support event timestamps.
+     * @return {Promise.<this>}
+     * @function removeListener
+     * @memberof ExternalApplication
+     * @instance
+     * @tutorial ExternalApplication.EventEmitter
+     */
+    /**
+     * Removes all listeners, or those of the specified event.
+     * @param { string | symbol } [eventType]  - The type of the event.
+     * @return {Promise.<this>}
+     * @function removeAllListeners
+     * @memberof ExternalApplication
+     * @instance
+     * @tutorial ExternalApplication.EventEmitter
+     */
+    /**
+     * Retrieves information about the external application.
+     * @return {Promise.<ExternalApplicationInfo>}
+     * @tutorial ExternalApplication.getInfo
+     */
+    getInfo() {
+        return this.wire.sendAction('get-external-application-info', this.identity).then(({ payload }) => payload.data);
+    }
+}
+exports.ExternalApplication = ExternalApplication;

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

@@ -0,0 +1,3 @@
+import ExternalApplicationModule from './Factory';
+export default ExternalApplicationModule;
+export * from './Instance';

package/src/api/external-application/index.js

@@ -0,0 +1,15 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !exports.hasOwnProperty(p)) __createBinding(exports, m, p);
+}
+Object.defineProperty(exports, "__esModule", { value: true });
+const Factory_1 = require("./Factory");
+exports.default = Factory_1.default;
+__exportStar(require("./Instance"), exports);

package/src/api/fin.d.ts

@@ -0,0 +1,49 @@
+/// <reference types="node" />
+import { EventEmitter } from 'events';
+import Transport from '../transport/transport';
+import System from './system/index';
+import _WindowModule from './window/index';
+import ApplicationModule from './application/index';
+import InterApplicationBus from './interappbus/index';
+import Clipboard from './clipboard/index';
+import ExternalApplicationModule from './external-application/index';
+import _FrameModule from './frame/index';
+import GlobalHotkey from './global-hotkey/index';
+import ViewModule from './view/index';
+import PlatformModule from './platform/index';
+import { EntityType } from '../shapes/EntityType';
+import { Me } from './me';
+import InteropModule from './interop';
+import SnapshotSourceModule from './snapshot-source';
+export interface FinApi<MeType extends EntityType> {
+    readonly System: System;
+    readonly Window: _WindowModule;
+    readonly Application: ApplicationModule;
+    readonly InterApplicationBus: InterApplicationBus;
+    readonly Clipboard: Clipboard;
+    readonly ExternalApplication: ExternalApplicationModule;
+    readonly Frame: _FrameModule;
+    readonly GlobalHotkey: GlobalHotkey;
+    readonly View: ViewModule;
+    readonly Platform: PlatformModule;
+    readonly Interop: InteropModule;
+    readonly SnapshotSource: SnapshotSourceModule;
+    readonly me: Me<MeType>;
+}
+export default class Fin<MeType extends EntityType = EntityType> extends EventEmitter implements FinApi<MeType> {
+    private wire;
+    System: System;
+    Window: _WindowModule;
+    Application: ApplicationModule;
+    InterApplicationBus: InterApplicationBus;
+    Clipboard: Clipboard;
+    ExternalApplication: ExternalApplicationModule;
+    Frame: _FrameModule;
+    GlobalHotkey: GlobalHotkey;
+    View: ViewModule;
+    Platform: PlatformModule;
+    Interop: InteropModule;
+    SnapshotSource: SnapshotSourceModule;
+    readonly me: Me<MeType>;
+    constructor(wire: Transport<MeType>);
+}

package/src/api/fin.js

@@ -0,0 +1,43 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const events_1 = require("events");
+// Import from the file rather than the directory in case someone consuming types is using module resolution other than "node"
+const index_1 = require("./system/index");
+const index_2 = require("./window/index");
+const index_3 = require("./application/index");
+const index_4 = require("./interappbus/index");
+const index_5 = require("./clipboard/index");
+const index_6 = require("./external-application/index");
+const index_7 = require("./frame/index");
+const index_8 = require("./global-hotkey/index");
+const index_9 = require("./view/index");
+const index_10 = require("./platform/index");
+const me_1 = require("./me");
+const fin_store_1 = require("../transport/fin_store");
+const interop_1 = require("./interop");
+const snapshot_source_1 = require("./snapshot-source");
+class Fin extends events_1.EventEmitter {
+    constructor(wire) {
+        super();
+        fin_store_1.registerFin(wire, this);
+        this.wire = wire;
+        this.System = new index_1.default(wire);
+        this.Window = new index_2.default(wire);
+        this.Application = new index_3.default(wire);
+        this.InterApplicationBus = new index_4.default(wire);
+        this.Clipboard = new index_5.default(wire);
+        this.ExternalApplication = new index_6.default(wire);
+        this.Frame = new index_7.default(wire);
+        this.GlobalHotkey = new index_8.default(wire);
+        this.Platform = new index_10.default(wire, this.InterApplicationBus.Channel);
+        this.View = new index_9.default(wire);
+        this.Interop = new interop_1.default(wire);
+        this.SnapshotSource = new snapshot_source_1.default(wire);
+        this.me = me_1.getMe(wire);
+        // Handle disconnect events
+        wire.on('disconnected', () => {
+            this.emit('disconnected');
+        });
+    }
+}
+exports.default = Fin;

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

@@ -0,0 +1,36 @@
+import { Base } from '../base';
+/**
+ * @lends Frame
+ */
+export default class _FrameModule extends Base {
+    /**
+     * Asynchronously returns a reference to the specified frame. The frame does not have to exist
+     * @param {Identity} identity - the identity of the frame you want to wrap
+     * @return {Promise.<_Frame>}
+     * @tutorial Frame.wrap
+     * @static
+     */
+    wrap(identity: OpenFin.Identity): Promise<OpenFin.Frame>;
+    /**
+     * Synchronously returns a reference to the specified frame. The frame does not have to exist
+     * @param {Identity} identity - the identity of the frame you want to wrap
+     * @return {_Frame}
+     * @tutorial Frame.wrapSync
+     * @static
+     */
+    wrapSync(identity: OpenFin.Identity): OpenFin.Frame;
+    /**
+     * Asynchronously returns a reference to the current frame
+     * @return {Promise.<_Frame>}
+     * @tutorial Frame.getCurrent
+     * @static
+     */
+    getCurrent(): Promise<OpenFin.Frame>;
+    /**
+     * Synchronously returns a reference to the current frame
+     * @return {_Frame}
+     * @tutorial Frame.getCurrentSync
+     * @static
+     */
+    getCurrentSync(): OpenFin.Frame;
+}