@openfin/core 25.68.26

package/src/api/window/bounds-changed.d.ts

@@ -0,0 +1,10 @@
+import { Reply } from '../base';
+export default class BoundsChangedReply extends Reply<'window', 'bounds-changed'> {
+    changeType: BoundsChangeType;
+    deferred: boolean;
+    height: number;
+    width: number;
+    top: number;
+    left: number;
+}
+export declare type BoundsChangeType = 'position' | 'size' | 'position_and_size';

package/src/api/window/bounds-changed.js

@@ -0,0 +1,6 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const base_1 = require("../base");
+class BoundsChangedReply extends base_1.Reply {
+}
+exports.default = BoundsChangedReply;

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

@@ -0,0 +1,5 @@
+import _WindowModule from './Factory';
+export default _WindowModule;
+export * from './shapes';
+export * from './Instance';
+export * from './bounds-changed';

package/src/api/window/index.js

@@ -0,0 +1,17 @@
+"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("./shapes"), exports);
+__exportStar(require("./Instance"), exports);
+__exportStar(require("./bounds-changed"), exports);

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

@@ -0,0 +1,13 @@
+export interface CloseEventShape {
+    name: string;
+    uuid: string;
+    type: string;
+    topic: string;
+}
+export interface WindowInfo {
+    canNavigateBack: boolean;
+    canNavigateForward: boolean;
+    preloadScripts: Array<any>;
+    title: string;
+    url: string;
+}

package/src/api/window/shapes.js

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

package/src/environment/environment.d.ts

@@ -0,0 +1,28 @@
+import { NewConnectConfig } from '../transport/wire';
+import { EntityType } from '../shapes/EntityType';
+export interface Environment {
+    getManagerConstructor(): Promise<any>;
+    getProviderInitializer(): Promise<any>;
+    writeToken(path: string, token: string): Promise<string>;
+    retrievePort(config: NewConnectConfig): Promise<number>;
+    getNextMessageId(): any;
+    getRandomId(): string;
+    createChildContent(options: ChildContentOptions): Promise<any>;
+    getWebWindow(identity: OpenFin.Identity): Window;
+    getCurrentEntityIdentity(): OpenFin.EntityInfo;
+    getCurrentEntityType(): EntityType;
+    raiseEvent(eventName: string, eventArgs: any): void;
+    childViews: boolean;
+    getUrl(): string;
+    getDefaultChannelOptions(): {
+        create: OpenFin.ChannelCreateOptions;
+        connect: OpenFin.ChannelConnectOptions;
+    };
+    getRtcPeer(): RTCPeerConnection;
+    whenReady(): Promise<void>;
+}
+export interface ChildContentOptions {
+    options: any;
+    entityType: EntityType;
+}
+export declare const notImplementedEnvErrorMsg = "Not implemented in this environment";

package/src/environment/environment.js

@@ -0,0 +1,4 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.notImplementedEnvErrorMsg = void 0;
+exports.notImplementedEnvErrorMsg = 'Not implemented in this environment';

package/src/environment/node-env.d.ts

@@ -0,0 +1,25 @@
+import { Environment, ChildContentOptions } from './environment';
+import { NewConnectConfig } from '../transport/wire';
+import { EntityType } from '../shapes/EntityType';
+export default class NodeEnvironment implements Environment {
+    getDefaultChannelOptions(): {
+        create: OpenFin.ChannelCreateOptions;
+        connect: OpenFin.ChannelConnectOptions;
+    };
+    getRtcPeer(): RTCPeerConnection;
+    private messageCounter;
+    childViews: boolean;
+    getManagerConstructor(): Promise<any>;
+    getProviderInitializer(): Promise<any>;
+    whenReady(): Promise<void>;
+    writeToken: (path: string, token: string) => Promise<string>;
+    retrievePort: (config: NewConnectConfig) => Promise<number>;
+    getNextMessageId: () => any;
+    getRandomId: () => string;
+    createChildContent(options: ChildContentOptions): Promise<any>;
+    getWebWindow: (identity: OpenFin.Identity) => Window;
+    getCurrentEntityIdentity: () => OpenFin.EntityInfo;
+    getCurrentEntityType: () => EntityType;
+    raiseEvent: (eventName: string, eventArgs: any) => void;
+    getUrl: () => string;
+}

package/src/environment/node-env.js

@@ -0,0 +1,64 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+/* eslint-disable class-methods-use-this */
+const fs_1 = require("fs");
+const crypto_1 = require("crypto");
+const environment_1 = require("./environment");
+const port_discovery_1 = require("../transport/port-discovery");
+const transport_errors_1 = require("../transport/transport-errors");
+class NodeEnvironment {
+    constructor() {
+        this.messageCounter = 0;
+        this.childViews = false;
+        this.writeToken = (path, token) => {
+            return new Promise((resolve) => {
+                fs_1.writeFile(path, token, () => resolve(token));
+            });
+        };
+        this.retrievePort = (config) => {
+            const pd = new port_discovery_1.default(config, this);
+            return pd.retrievePort();
+        };
+        this.getNextMessageId = () => {
+            // eslint-disable-next-line no-plusplus
+            return this.messageCounter++;
+        };
+        this.getRandomId = () => {
+            return crypto_1.randomBytes(16).toString('hex');
+        };
+        this.getWebWindow = (identity) => {
+            throw new transport_errors_1.NotSupportedError('Not supported outside of OpenFin web context');
+        };
+        this.getCurrentEntityIdentity = () => {
+            throw new transport_errors_1.NotImplementedError(environment_1.notImplementedEnvErrorMsg);
+        };
+        this.getCurrentEntityType = () => {
+            return 'external connection';
+        };
+        this.raiseEvent = (eventName, eventArgs) => {
+            throw new transport_errors_1.NotImplementedError(environment_1.notImplementedEnvErrorMsg);
+        };
+        this.getUrl = () => {
+            throw new transport_errors_1.NotImplementedError('Not Implemented');
+        };
+    }
+    getDefaultChannelOptions() {
+        return { create: {}, connect: {} };
+    }
+    getRtcPeer() {
+        throw new Error('Method not implemented.');
+    }
+    async getManagerConstructor() {
+        throw new Error('Method not implemented.');
+    }
+    async getProviderInitializer() {
+        throw new Error('Method not implemented.');
+    }
+    whenReady() {
+        return Promise.resolve();
+    }
+    createChildContent(options) {
+        throw new transport_errors_1.NotImplementedError('Not Implemented');
+    }
+}
+exports.default = NodeEnvironment;

package/src/environment/openfin-env.d.ts

@@ -0,0 +1,29 @@
+import { Environment, ChildContentOptions } from './environment';
+import { NewConnectConfig } from '../transport/wire';
+import { EntityType } from '../shapes/EntityType';
+export default class OpenFinEnvironment implements Environment {
+    #private;
+    private raiseEventAsync;
+    childViews: boolean;
+    constructor();
+    getDefaultChannelOptions(): {
+        create: OpenFin.ChannelCreateOptions;
+        connect: OpenFin.ChannelConnectOptions;
+    };
+    getRtcPeer(): RTCPeerConnection;
+    getManagerConstructor(): Promise<any>;
+    getProviderInitializer(): Promise<any>;
+    writeToken: (path: string, token: string) => Promise<string>;
+    retrievePort: (config: NewConnectConfig) => Promise<number>;
+    getNextMessageId: () => any;
+    createChildContent: ({ options, entityType }: ChildContentOptions) => Promise<unknown>;
+    private normalizeOptions;
+    getRandomId: () => string;
+    private resolveUrl;
+    getWebWindow: (identity: OpenFin.Identity) => Window;
+    getCurrentEntityIdentity: () => OpenFin.EntityInfo;
+    getCurrentEntityType: () => EntityType;
+    raiseEvent: (eventName: string, eventArgs: any) => void;
+    getUrl: () => string;
+    whenReady(): Promise<void>;
+}

package/src/environment/openfin-env.js

@@ -0,0 +1,105 @@
+"use strict";
+var __classPrivateFieldSet = (this && this.__classPrivateFieldSet) || function (receiver, privateMap, value) {
+    if (!privateMap.has(receiver)) {
+        throw new TypeError("attempted to set private field on non-instance");
+    }
+    privateMap.set(receiver, value);
+    return value;
+};
+var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (receiver, privateMap) {
+    if (!privateMap.has(receiver)) {
+        throw new TypeError("attempted to get private field on non-instance");
+    }
+    return privateMap.get(receiver);
+};
+var _ready;
+Object.defineProperty(exports, "__esModule", { value: true });
+const transport_errors_1 = require("../transport/transport-errors");
+class OpenFinEnvironment {
+    constructor() {
+        _ready.set(this, void 0);
+        this.writeToken = (path, token) => {
+            throw new transport_errors_1.NotImplementedError('Not Implemented');
+        };
+        this.retrievePort = (config) => {
+            throw new transport_errors_1.NotImplementedError('Not Implemented');
+        };
+        this.getNextMessageId = () => {
+            return fin.desktop.getUuid();
+        };
+        // eslint-disable-next-line @typescript-eslint/explicit-function-return-type
+        this.createChildContent = async ({ options, entityType }) => {
+            const opts = this.normalizeOptions(options);
+            return new Promise((y, n) => fin.__internal_.createChildContent({ entityType, options: opts }, y, n));
+        };
+        this.normalizeOptions = (options) => {
+            const { uuid: parentUuid } = fin.__internal_.initialOptions;
+            const opts = JSON.parse(JSON.stringify(options));
+            const ABOUT_BLANK = 'about:blank';
+            opts.uuid = opts.uuid || parentUuid;
+            opts.url = opts.url || ABOUT_BLANK;
+            if (opts.url !== ABOUT_BLANK) {
+                opts.url = this.resolveUrl(opts.url);
+            }
+            return opts;
+        };
+        this.getRandomId = () => {
+            const intArray = new Uint32Array(1);
+            return window.crypto.getRandomValues(intArray)[0].toString(32);
+        };
+        this.getWebWindow = (identity) => {
+            return fin.__internal_.getWebWindow(identity.name);
+        };
+        this.getCurrentEntityIdentity = () => {
+            return fin.__internal_.entityInfo;
+        };
+        this.getCurrentEntityType = () => {
+            return this.getCurrentEntityIdentity().entityType || 'unknown';
+        };
+        this.raiseEvent = (eventName, eventArgs) => {
+            this.raiseEventAsync(eventName, eventArgs);
+        };
+        this.getUrl = () => {
+            return location.href;
+        };
+        this.raiseEventAsync = fin.__internal_.raiseEventAsync;
+        delete fin.__internal_.raiseEventAsync;
+        this.childViews = fin.__internal_.childViews;
+        __classPrivateFieldSet(this, _ready, new Promise((resolve) => {
+            fin.desktop.main(resolve);
+        }));
+    }
+    getDefaultChannelOptions() {
+        var _a, _b;
+        return {
+            create: {},
+            connect: {},
+            ...((_b = (_a = fin.__internal_.initialOptions.experimental) === null || _a === void 0 ? void 0 : _a.defaultChannelOptions) !== null && _b !== void 0 ? _b : {})
+        };
+    }
+    getRtcPeer() {
+        return new RTCPeerConnection();
+    }
+    async getManagerConstructor() {
+        const ManagerConstructor = (await Promise.resolve().then(() => require(
+        /* webpackChunkName: 'layout' */
+        '../api/platform/renderer/openfin-layout'))).default;
+        return ManagerConstructor;
+    }
+    async getProviderInitializer() {
+        const providerInitializer = (await Promise.resolve().then(() => require(
+        /* webpackChunkName: 'provider' */
+        '../api/platform/renderer/platform-provider'))).default;
+        return providerInitializer;
+    }
+    // eslint-disable-next-line class-methods-use-this
+    resolveUrl(url) {
+        const newUrl = new URL(url, location.href);
+        return newUrl.href;
+    }
+    whenReady() {
+        return __classPrivateFieldGet(this, _ready);
+    }
+}
+exports.default = OpenFinEnvironment;
+_ready = new WeakMap();

package/src/mock.d.ts

@@ -0,0 +1,4 @@
+/// <reference path="../OpenFin.d.ts" />
+export declare const fin: import("./api/fin").FinApi<"window" | "iframe" | "view">;
+export declare const inOpenFin: boolean;
+export default OpenFin;

package/src/mock.js

@@ -0,0 +1,91 @@
+"use strict";
+var _a;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.inOpenFin = exports.fin = void 0;
+/* eslint-disable import/prefer-default-export */
+/* eslint-disable spaced-comment */
+/* eslint-disable @typescript-eslint/triple-slash-reference */
+/* eslint-disable @typescript-eslint/explicit-function-return-type */
+/* eslint-disable class-methods-use-this */
+/// <reference path="../OpenFin.d.ts"/>
+const events_1 = require("events");
+const fin_1 = require("./api/fin");
+const transport_1 = require("./transport/transport");
+class MockWire extends events_1.EventEmitter {
+    connect(address) {
+        throw new Error('You are not running in OpenFin.');
+    }
+    connectSync() {
+        throw new Error('You are not running in OpenFin.');
+    }
+    send(data) {
+        throw new Error('You are not running in OpenFin.');
+    }
+    shutdown() {
+        throw new Error('You are not running in OpenFin.');
+    }
+    // eslint-disable-next-line no-useless-constructor
+    constructor() {
+        super();
+    }
+}
+class MockEnvironment {
+    constructor() {
+        this.childViews = true;
+    }
+    getDefaultChannelOptions() {
+        throw new Error('Method not implemented.');
+    }
+    getRtcPeer() {
+        throw new Error('Method not implemented.');
+    }
+    getManagerConstructor() {
+        throw new Error('Method not implemented.');
+    }
+    getProviderInitializer() {
+        throw new Error('Method not implemented.');
+    }
+    writeToken(path, token) {
+        throw new Error('Method not implemented.');
+    }
+    retrievePort(config) {
+        throw new Error('Method not implemented.');
+    }
+    getNextMessageId() {
+        throw new Error('Method not implemented.');
+    }
+    getRandomId() {
+        throw new Error('Method not implemented.');
+    }
+    createChildContent(options) {
+        throw new Error('Method not implemented.');
+    }
+    getWebWindow(identity) {
+        throw new Error('Method not implemented.');
+    }
+    getCurrentEntityIdentity() {
+        throw new Error('Method not implemented.');
+    }
+    getCurrentEntityType() {
+        return 'unknown';
+    }
+    raiseEvent(eventName, eventArgs) {
+        throw new Error('Method not implemented.');
+    }
+    getUrl() {
+        throw new Error('Method not implemented.');
+    }
+    whenReady() {
+        throw new Error('Method not implemented.');
+    }
+}
+exports.fin = ((typeof window !== 'undefined' && ((_a = window) === null || _a === void 0 ? void 0 : _a.fin)) ||
+    (() => {
+        const environment = new MockEnvironment();
+        const transport = new transport_1.default(MockWire, environment, {
+            uuid: '',
+            name: ''
+        });
+        return new fin_1.default(transport);
+    })());
+exports.inOpenFin = typeof window !== 'undefined' && typeof window.fin === 'object';

package/src/shapes/ERROR_BOX_TYPES.d.ts

@@ -0,0 +1,6 @@
+declare enum ERROR_BOX_TYPES {
+    APP_INITIALIZATION = "OF_error_box:app_initialization",
+    MAIN_PROCESS = "OF_error_box:main_process",
+    RENDERER_CRASH = "OF_error_box:renderer_crash"
+}
+export default ERROR_BOX_TYPES;

package/src/shapes/ERROR_BOX_TYPES.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+// Error types
+var ERROR_BOX_TYPES;
+(function (ERROR_BOX_TYPES) {
+    ERROR_BOX_TYPES["APP_INITIALIZATION"] = "OF_error_box:app_initialization";
+    ERROR_BOX_TYPES["MAIN_PROCESS"] = "OF_error_box:main_process";
+    ERROR_BOX_TYPES["RENDERER_CRASH"] = "OF_error_box:renderer_crash";
+})(ERROR_BOX_TYPES || (ERROR_BOX_TYPES = {}));
+exports.default = ERROR_BOX_TYPES;

package/src/shapes/EntityType.d.ts

@@ -0,0 +1 @@
+export declare type EntityType = 'window' | 'iframe' | 'external connection' | 'view' | 'unknown';

package/src/shapes/EntityType.js

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

package/src/shapes/LayoutPresetType.d.ts

@@ -0,0 +1 @@
+export declare type LayoutPresetType = 'columns' | 'grid' | 'rows' | 'tabs';

package/src/shapes/LayoutPresetType.js

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

package/src/shapes/Platform.d.ts

@@ -0,0 +1,112 @@
+import type { WindowOptionsChangedEvent } from '../api/events/window';
+export declare enum HostContextChangedReasons {
+    updated = "updated",
+    reparented = "reparented"
+}
+export declare enum WindowCreationReason {
+    Tearout = "tearout",
+    CreateViewWithoutTarget = "create-view-without-target",
+    APICall = "api-call",
+    AppCreation = "app-creation",
+    Restore = "restore"
+}
+export interface PlatformProvider {
+    /**
+     * Handles requests to create a window in the current platform.
+     * @param { WindowOption } payload Window options for the window to be created.
+     * @param { Identity } [identity] If {@link Platform#createWindow Platform.createWindow} was called, the identity of the caller will be here.
+     * If `createWindow` was called as part of applying a snapshot or creating a view without a target window, `identity` will be undefined.
+     */
+    createWindow(options: OpenFin.PlatformWindowCreationOptions, identity?: OpenFin.Identity): Promise<OpenFin.Window>;
+    /**
+     * Gets the current state of windows and their views and returns a snapshot object containing that info.
+     * @param { undefined } payload Undefined unless you've defined a custom `getSnapshot` protocol.
+     * @param { Identity } identity Identity of the entity that called {@link Platform#getSnapshot Platform.getSnapshot}.
+     * @return { Promise<Snapshot> } Snapshot of current platform state.
+     */
+    getSnapshot(payload: undefined, identity: OpenFin.Identity): Promise<OpenFin.Snapshot>;
+    /**
+     * Called when a snapshot is being applied and some windows in that snapshot would be fully or partially off-screen.
+     * Returns an array of windows with modified positions, such that any off-screen windows are positioned in the top left
+     * corner of the main monitor.
+     * @param { Snapshot } snapshot The snapshot to be applied.
+     * @param { WindowOptions[] } outOfBoundsWindows An array of WindowOptions for any windows that would be off-screen.
+     * @return { Promise<WindowOptions[]> } An array of WindowOptions with their position modified to fit on screen.
+     */
+    positionOutOfBoundsWindows(snapshot: OpenFin.Snapshot, outOfBoundsWindows: OpenFin.WindowCreationOptions[]): Promise<OpenFin.WindowCreationOptions[]>;
+    /**
+     * Handles requests to apply a snapshot to the current Platform.
+     * @param { ApplySnapshotPayload } payload Payload containing the snapshot to be applied, as well as any options.
+     * @param { Identity } [identity] Identity of the entity that called {@link Platform#applySnapshot Platform.applySnapshot}.
+     * Undefined if called internally (e.g. when opening the initial snapshot).
+     * @return { Promise<void> }
+     */
+    applySnapshot(payload: OpenFin.ApplySnapshotPayload, identity?: OpenFin.Identity): Promise<void>;
+    /**
+     * Closes the current Platform and all child windows and views.
+     * @param { undefined } payload Undefined unless you have implemented a custom quite protocol.
+     * @param { Identity } identity Identity of the entity that called {@link Platform#quit Platform.quit}.
+     * @return { Promise<void> }
+     */
+    quit(payload: undefined, identity: OpenFin.Identity): Promise<void>;
+    /**
+     * Closes a view
+     * @param { CloseViewPayload } payload Specifies the `target` view to be closed.
+     * @param { Identity } identity Identity of the entity that called {@link Platform#closeView Platform.closeView}.
+     */
+    closeView(payload: OpenFin.CloseViewPayload, identity?: OpenFin.Identity): Promise<any>;
+    /**
+     * Creates a new view and attaches it to a specified target window.
+     * @param { CreateViewPayload } payload Creation options for the new view.
+     * @param { Identity } identity Identity of the entity that called {@link Platform#createView Platform.createView}.
+     * @return { Promise<void> }
+     */
+    createView(payload: OpenFin.CreateViewPayload, identity: OpenFin.Identity): Promise<OpenFin.View>;
+    /** Handles requests to fetch manifests in the current platform.
+     * @param { FetchManifestPayload } payload Payload containing the manifestUrl to be fetched.
+     * @param { Identity } callerIdentity If {@link Platform#fetchManifest Platform.fetchManifest}
+     * was called, the identity of the caller will be here.
+     * If `fetchManifest` was called internally, `callerIdentity` will be the provider's identity.
+     */
+    fetchManifest(payload: OpenFin.FetchManifestPayload, callerIdentity: OpenFin.Identity): Promise<any>;
+    /**
+     * Replaces a Platform window's layout with a new layout. Any views that were in the old layout but not the new layout will be destroyed.
+     * @param { ReplaceLayoutPayload } payload Contains the `target` window and an `opts` object with a `layout` property to apply.
+     * @param { Identity } [identity] Identity of the entity that called {@link Platform#replaceLayout Platform.replaceLayout}.
+     * Undefined if `replaceLayout` is called internally (e.g. while applying a snapshot).
+     * @return { Promise<void> }
+     */
+    replaceLayout(payload: OpenFin.ReplaceLayoutPayload, identity?: OpenFin.Identity): Promise<void>;
+    replaceView(payload: OpenFin.ReplaceViewPayload, identity?: OpenFin.Identity): Promise<void>;
+    launchIntoPlatform(payload: OpenFin.LaunchIntoPlatformPayload): Promise<void>;
+    /**
+     * Handles requests to set a window's context. `target` may be a window or a view.
+     * If it is a window, that window's `customContext` will be updated.
+     * If it is a view, the `customContext` of that view's current host window will be updated.
+     * @param { SetWindowContextPayload } payload Object containing the requested `context` update,
+     * the `target`'s identity, and the target's `entityType`.
+     * @param { Identity } [identity] Identity of the entity that called {@link Platform#setWindowContext Platform.setWindowContext}.
+     * Undefined if `setWindowContext` is called internally (e.g. while applying a snapshot).
+     * @return { Promise<any> } The new context.
+     */
+    setWindowContext(payload: OpenFin.SetWindowContextPayload, identity?: OpenFin.Identity): Promise<any>;
+    /**
+     * Handles requests to get a window's context. `target` may be a window or a view.
+     * If it is a window, that window's `customContext` will be returned.
+     * If it is a view, the `customContext` of that view's current host window will be returned.
+     * @param { GetWindowContextPayload } payload Object containing the requested `context` update,
+     * the `target`'s identity, and the target's `entityType`.
+     * @param { Identity } [identity] Identity of the entity that called {@link Platform#getWindowContext Platform.getWindowContext}.
+     * Undefined when `getWindowContext` is called internally
+     * (e.g. when getting a window's context for the purpose of raising a "host-context-changed" event on a reparented view).
+     * @return { Promise<any> } The new context.
+     */
+    getWindowContext(payload: OpenFin.GetWindowContextPayload, identity?: OpenFin.Identity): Promise<any>;
+    /**
+     * Called when a window's `customContext` is updated. Responsible for raising the `host-context-updated` event on that window's child views.
+     * @param { WindowOptionsChangedEvent<'window', 'options-changed'> } payload The event payload for the window whose context has changed.
+     * 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<OpenFin.HostContextChangedPayload | undefined>;
+}

package/src/shapes/Platform.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WindowCreationReason = exports.HostContextChangedReasons = void 0;
+var HostContextChangedReasons;
+(function (HostContextChangedReasons) {
+    HostContextChangedReasons["updated"] = "updated";
+    HostContextChangedReasons["reparented"] = "reparented";
+})(HostContextChangedReasons = exports.HostContextChangedReasons || (exports.HostContextChangedReasons = {}));
+var WindowCreationReason;
+(function (WindowCreationReason) {
+    WindowCreationReason["Tearout"] = "tearout";
+    WindowCreationReason["CreateViewWithoutTarget"] = "create-view-without-target";
+    WindowCreationReason["APICall"] = "api-call";
+    WindowCreationReason["AppCreation"] = "app-creation";
+    WindowCreationReason["Restore"] = "restore";
+})(WindowCreationReason = exports.WindowCreationReason || (exports.WindowCreationReason = {}));

package/src/shapes/WebOptions.d.ts

@@ -0,0 +1,12 @@
+export interface WebOptions {
+    preloadScripts?: OpenFin.PreloadScript[];
+    uuid: string;
+    name: string;
+    contentCreation?: OpenFin.ContentCreationOptions;
+    contentRedirect?: Partial<OpenFin.ContentRedirect>;
+    customContext?: any;
+    experimental?: any;
+    processAffinity?: string;
+    backgroundThrottling?: boolean;
+    interop?: OpenFin.InteropConfig;
+}

package/src/shapes/WebOptions.js

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

package/src/shapes/WindowOptions.d.ts

@@ -0,0 +1,42 @@
+import ERROR_BOX_TYPES from './ERROR_BOX_TYPES';
+import { WebOptions } from './WebOptions';
+export interface WindowOptions extends Partial<OpenFin.WindowOptions>, Partial<WindowInternalOptions> {
+    name: string;
+    uuid: string;
+}
+export interface WindowInternalOptions extends WebOptions {
+    'alwaysOnBottom': boolean;
+    'appLogFlushInterval': number;
+    'center': boolean;
+    'description': string;
+    'disableIabSecureLogging': boolean;
+    'draggable': boolean;
+    'enableAppLogging': boolean;
+    'enable-plugins': boolean;
+    'enableLargerThanScreen': boolean;
+    'exitOnClose': boolean;
+    'experimental': any;
+    'hasLoaded': boolean;
+    'hideOnBlur': boolean;
+    'hideOnClose': boolean;
+    'hideWhileChildrenVisible': boolean;
+    'isRawWindowOpen': boolean;
+    'launchExternal': string;
+    'loadErrorMessage': string;
+    'nonPersistent': boolean;
+    'nonPersistant': boolean;
+    'plugins': boolean;
+    'preload': string | OpenFin.PreloadScript[];
+    'resize': boolean;
+    'show': boolean;
+    'skipTaskbar': boolean;
+    'taskbarIcon': string;
+    'title': string;
+    'toShowOnRun': boolean;
+    'transparent': boolean;
+    '_type': ERROR_BOX_TYPES;
+    'webPreferences': {
+        nodeIntegration: boolean;
+        plugins: boolean;
+    };
+}

package/src/shapes/WindowOptions.js

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