@openfin/core 25.68.26

package/src/api/interop/fdc3/utils.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.UnsupportedChannelApiError = exports.UnsupportedError = void 0;
+class UnsupportedError extends Error {
+    constructor(apiName) {
+        super(apiName);
+        this.message = `${apiName} is not a supported API`;
+    }
+}
+exports.UnsupportedError = UnsupportedError;
+class UnsupportedChannelApiError extends Error {
+    constructor(apiName) {
+        super(apiName);
+        this.message = `Calling ${apiName} on an instance of a System Channel returned by fdc3.getSystemChannels is not supported. If you would like to use a System Channel, please use fdc3.joinChannel, fdc3.addContextListener, and fdc3.broadcast instead.`;
+    }
+}
+exports.UnsupportedChannelApiError = UnsupportedChannelApiError;

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

@@ -0,0 +1,4 @@
+import InteropModule from './Factory';
+export default InteropModule;
+export * from './InteropClient';
+export * from './InteropBroker';

package/src/api/interop/index.js

@@ -0,0 +1,16 @@
+"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("./InteropClient"), exports);
+__exportStar(require("./InteropBroker"), exports);

package/src/api/interop/utils.d.ts

@@ -0,0 +1,11 @@
+export declare const generateId: () => string;
+export declare const wrapInTryCatch: <T>(f: (...args: any[]) => T, prefix?: string) => (...args: any[]) => T;
+export declare const wrapContextHandler: (handler: OpenFin.ContextHandler, handlerId: string) => (context: OpenFin.Context) => Promise<void>;
+export declare const generateOverrideError: (clientApi: string, brokerApi: string) => string;
+export declare const generateOverrideWarning: (interopClientApi: string, fdc3ClientApi: string, brokerApi: string, identity: OpenFin.ClientIdentity) => string;
+export declare const BROKER_ERRORS: {
+    fireIntent: string;
+    fireIntentForContext: string;
+    getInfoForIntent: string;
+    getInfoForIntentsByContext: string;
+};

package/src/api/interop/utils.js

@@ -0,0 +1,36 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BROKER_ERRORS = exports.generateOverrideWarning = exports.generateOverrideError = exports.wrapContextHandler = exports.wrapInTryCatch = exports.generateId = void 0;
+exports.generateId = () => `${Math.random()}${Date.now()}`;
+exports.wrapInTryCatch = (f, prefix) => (...args) => {
+    try {
+        return f(...args);
+    }
+    catch (e) {
+        throw new Error((prefix || '') + e);
+    }
+};
+exports.wrapContextHandler = (handler, handlerId) => {
+    return async (context) => {
+        try {
+            await handler(context);
+        }
+        catch (error) {
+            console.error(`Error thrown by handler ${handlerId} for context type ${context.type}: ${error}`);
+            throw error;
+        }
+    };
+};
+exports.generateOverrideError = (clientApi, brokerApi) => {
+    return `You have tried to to use ${clientApi} but ${brokerApi} has not been overridden in the Interop Broker. Please override this function. Refer to our documentation for more info.`;
+};
+exports.generateOverrideWarning = (interopClientApi, fdc3ClientApi, brokerApi, identity) => {
+    const { uuid, name } = identity;
+    return `Entity with identity: ${uuid}/${name} has called ${interopClientApi} or ${fdc3ClientApi} but ${brokerApi} has not been overridden.`;
+};
+exports.BROKER_ERRORS = {
+    fireIntent: exports.generateOverrideError('fireIntent', 'handleFiredIntent'),
+    fireIntentForContext: exports.generateOverrideError('fireIntentForContext', 'handleFiredIntentForContext'),
+    getInfoForIntent: exports.generateOverrideError('getInfoForIntent', 'handleInfoForIntent'),
+    getInfoForIntentsByContext: exports.generateOverrideError('getInfoForIntentsByContext', 'handleInfoForIntentsByContext')
+};

package/src/api/me.d.ts

@@ -0,0 +1,35 @@
+import { EntityType } from '../shapes/EntityType';
+import Transport from '../transport/transport';
+import type { InteropClient } from './interop';
+export declare type EntityTypeHelpers<T extends EntityType> = T extends 'view' ? {
+    isView: true;
+    isWindow: false;
+    isExternal: false;
+    isFrame: false;
+} : T extends 'window' ? {
+    isView: false;
+    isWindow: true;
+    isExternal: false;
+    isFrame: false;
+} : T extends 'iframe' ? {
+    isView: false;
+    isWindow: false;
+    isExternal: false;
+    isFrame: true;
+} : T extends 'external connection' ? {
+    isView: false;
+    isWindow: false;
+    isExternal: true;
+    isFrame: false;
+} : T extends 'unknown' ? {
+    isView: false;
+    isWindow: false;
+    isExternal: false;
+    isFrame: false;
+} : never;
+export declare function getBaseMe<T extends EntityType = EntityType>(entityType: T, uuid: string, name: string): OpenFin.EntityInfo & EntityTypeHelpers<T>;
+export interface WithInterop {
+    interop: InteropClient;
+}
+export declare type Me<MeType extends EntityType> = OpenFin.EntityInfo & (MeType extends 'view' ? EntityTypeHelpers<'view'> & OpenFin.View & WithInterop : MeType extends 'window' ? EntityTypeHelpers<'window'> & OpenFin.Window & WithInterop : MeType extends 'iframe' ? EntityTypeHelpers<'iframe'> & OpenFin.Frame & WithInterop : EntityTypeHelpers<MeType> & WithInterop);
+export declare function getMe<MeType extends EntityType>(wire: Transport<MeType>): Me<MeType>;

package/src/api/me.js

@@ -0,0 +1,60 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getMe = exports.getBaseMe = void 0;
+const view_1 = require("./view");
+const frame_1 = require("./frame");
+const window_1 = require("./window");
+function getBaseMe(entityType, uuid, name) {
+    const entityTypeHelpers = {
+        isView: entityType === 'view',
+        isWindow: entityType === 'window',
+        isFrame: entityType === 'iframe',
+        isExternal: entityType === 'external connection'
+    };
+    return { ...entityTypeHelpers, uuid, name, entityType };
+}
+exports.getBaseMe = getBaseMe;
+// We need to do a lot of casting as unknown here because the compiler get's confused about matching types. What matters is that it works on the outside
+function getMe(wire) {
+    const { uuid, name, entityType } = wire.me;
+    const interopObject = {
+        setContext() {
+            throw new Error('Interop API has not been instantiated. Either connection has failed or you have not declared interop in your config.');
+        },
+        addContextHandler() {
+            throw new Error('Interop API has not been instantiated. Either connection has failed or you have not declared interop in your config.');
+        },
+        getContextGroups() {
+            throw new Error('Interop API has not been instantiated. Either connection has failed or you have not declared interop in your config.');
+        },
+        joinContextGroup() {
+            throw new Error('Interop API has not been instantiated. Either connection has failed or you have not declared interop in your config.');
+        },
+        removeFromContextGroup() {
+            throw new Error('Interop API has not been instantiated. Either connection has failed or you have not declared interop in your config.');
+        },
+        getAllClientsInContextGroup() {
+            throw new Error('Interop API has not been instantiated. Either connection has failed or you have not declared interop in your config.');
+        },
+        getInfoForContextGroup() {
+            throw new Error('Interop API has not been instantiated. Either connection has failed or you have not declared interop in your config.');
+        }
+    };
+    switch (entityType) {
+        case 'view':
+            return Object.assign(new view_1.View(wire, { uuid, name }), getBaseMe(entityType, uuid, name), {
+                interop: interopObject
+            });
+        case 'window':
+            return Object.assign(new window_1._Window(wire, { uuid, name }), getBaseMe(entityType, uuid, name), {
+                interop: interopObject
+            });
+        case 'iframe':
+            return Object.assign(new frame_1._Frame(wire, { uuid, name }), getBaseMe(entityType, uuid, name), {
+                interop: interopObject
+            });
+        default:
+            return { ...getBaseMe(entityType, uuid, name) };
+    }
+}
+exports.getMe = getMe;

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

@@ -0,0 +1,109 @@
+import { Base } from '../base';
+import { Channel } from '../interappbus/channel/index';
+import Transport from '../../transport/transport';
+import { LayoutModule } from './layout/index';
+/**
+ * InitPlatformOptions interface
+ * @typedef { object } InitPlatformOptions
+ * @property { OverrideCallback } [overrideCallback] a callback function that can be used to extend or replace default Provider behavior.
+ */
+/**
+ * @typedef { same | different } ProcessAffinityStrategy
+ * @summary Strategy to place views that share a domain into different process affinities or the same process affinity.
+ * @property { string } same views in the same domain will have the same process affinity.
+ * @property { string } different views in the same domain will have different process affinities.
+ */
+/**
+ * @typedef { object } PlatformOptions
+ * @summary The options object required by {@link Platform#start Platform.start}
+ * Any {@link ApplicationOption Application option} is also a valid platform option
+ * @property {Array.<Object>} [commands] Configuration for keyboard commands.
+ * For details and usage, see [Using Keyboard Commands]{@link https://developers.openfin.co/docs/platform-api#section-5-3-using-keyboard-commands}.
+ * @property {DefaultWindowOptions} [defaultWindowOptions] Default window options apply to all platform windows.
+ * @property {View~options} [defaultViewOptions] Default view options apply to all platform views.
+ * @property {ProcessAffinityStrategy} [viewProcessAffinityStrategy] 'same' | 'different'.
+ */
+/**
+ * @typedef { object } DefaultWindowOptions
+ * @summary Default window options apply to all platform windows.
+ * Any {@link Window~options Window option} is also a valid Default Window option
+ * used by default in any window that is created in the current platform's scope.
+ * Individual window options will override these defaults.
+ * @property {string} [stylesheetUrl]
+ * Specify a path of a custom CSS file to be injected to all of the platform's windows.
+ * _note_: this option is only applied to windows that use the Default OpenFin Window.
+ * Windows with a specified url (Custom Windows) will not be affected by this option.
+ */
+/**
+ * Snapshot interface
+ * @typedef { object } Snapshot
+ * @property { WindowOption[] } windows The array of window options objects
+ */
+/**
+ * @lends Platform
+ */
+export default class PlatformModule extends Base {
+    private _channel;
+    Layout: LayoutModule;
+    private _initializer;
+    constructor(wire: Transport, channel: Channel);
+    /**
+     * Initializes a Platform. Must be called from the Provider when using a custom provider.
+     * @param { InitPlatformOptions } [options] - platform options including a callback function that can be used to extend or replace
+     * default Provider behavior.
+     * @return {Promise.<void>}
+     * @tutorial Platform.init
+     * @experimental
+     * @static
+     */
+    init(options?: OpenFin.InitPlatformOptions): Promise<void>;
+    /**
+     * Asynchronously returns a Platform object that represents an existing platform.
+     * @param { Identity } identity
+     * @return {Promise.<Platform>}
+     * @tutorial Platform.wrap
+     * @static
+     */
+    wrap(identity: OpenFin.ApplicationIdentity): Promise<OpenFin.Platform>;
+    /**
+     * Synchronously returns a Platform object that represents an existing platform.
+     * @param { Identity } identity
+     * @return {Platform}
+     * @tutorial Platform.wrapSync
+     * @static
+     */
+    wrapSync(identity: OpenFin.ApplicationIdentity): OpenFin.Platform;
+    /**
+     * Asynchronously returns a Platform object that represents the current platform.
+     * @return {Promise.<Platform>}
+     * @tutorial Platform.getCurrent
+     * @static
+     */
+    getCurrent(): Promise<OpenFin.Platform>;
+    /**
+     * Synchronously returns a Platform object that represents the current platform.
+     * @return {Platform}
+     * @tutorial Platform.getCurrentSync
+     * @static
+     */
+    getCurrentSync(): OpenFin.Platform;
+    /**
+     * Creates and starts a Platform and returns a wrapped and running Platform instance. The wrapped Platform methods can
+     * be used to launch content into the platform.  Promise will reject if the platform is already running.
+     * @param { PlatformOptions } platformOptions
+     * @return {Promise.<Platform>}
+     * @tutorial Platform.start
+     * @static
+     */
+    start(platformOptions: OpenFin.PlatformOptions): Promise<OpenFin.Platform>;
+    /**
+     * Retrieves platforms's manifest and returns a wrapped and running Platform.  If there is a snapshot in the manifest,
+     * it will be launched into the platform.
+     * @param {string} manifestUrl - The URL of platform's manifest.
+     * @param {RvmLaunchOptions} [opts] - Parameters that the RVM will use.
+     * @return {Promise.<Platform>}
+     * @tutorial Platform.startFromManifest
+     * @static
+     */
+    startFromManifest(manifestUrl: string, opts?: OpenFin.RvmLaunchOptions): Promise<OpenFin.Platform>;
+}

package/src/api/platform/Factory.js

@@ -0,0 +1,188 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+/* eslint-disable no-undef, no-underscore-dangle */
+const base_1 = require("../base");
+const index_1 = require("./layout/index");
+const Instance_1 = require("./Instance");
+/**
+ * InitPlatformOptions interface
+ * @typedef { object } InitPlatformOptions
+ * @property { OverrideCallback } [overrideCallback] a callback function that can be used to extend or replace default Provider behavior.
+ */
+/**
+ * @typedef { same | different } ProcessAffinityStrategy
+ * @summary Strategy to place views that share a domain into different process affinities or the same process affinity.
+ * @property { string } same views in the same domain will have the same process affinity.
+ * @property { string } different views in the same domain will have different process affinities.
+ */
+/**
+ * @typedef { object } PlatformOptions
+ * @summary The options object required by {@link Platform#start Platform.start}
+ * Any {@link ApplicationOption Application option} is also a valid platform option
+ * @property {Array.<Object>} [commands] Configuration for keyboard commands.
+ * For details and usage, see [Using Keyboard Commands]{@link https://developers.openfin.co/docs/platform-api#section-5-3-using-keyboard-commands}.
+ * @property {DefaultWindowOptions} [defaultWindowOptions] Default window options apply to all platform windows.
+ * @property {View~options} [defaultViewOptions] Default view options apply to all platform views.
+ * @property {ProcessAffinityStrategy} [viewProcessAffinityStrategy] 'same' | 'different'.
+ */
+/**
+ * @typedef { object } DefaultWindowOptions
+ * @summary Default window options apply to all platform windows.
+ * Any {@link Window~options Window option} is also a valid Default Window option
+ * used by default in any window that is created in the current platform's scope.
+ * Individual window options will override these defaults.
+ * @property {string} [stylesheetUrl]
+ * Specify a path of a custom CSS file to be injected to all of the platform's windows.
+ * _note_: this option is only applied to windows that use the Default OpenFin Window.
+ * Windows with a specified url (Custom Windows) will not be affected by this option.
+ */
+/**
+ * Snapshot interface
+ * @typedef { object } Snapshot
+ * @property { WindowOption[] } windows The array of window options objects
+ */
+/**
+ * @lends Platform
+ */
+class PlatformModule extends base_1.Base {
+    constructor(wire, channel) {
+        super(wire);
+        this._channel = channel;
+        this._initializer = (...args) => this.wire.environment
+            .getProviderInitializer()
+            .then((initConstructor) => initConstructor(this.wire.environment)(...args));
+        /**
+         * @namespace
+         * @desc Layouts give app providers the ability to embed multiple views in a single window.  The Layout namespace
+         * enables the initialization and manipulation of a window's Layout.  A Layout will
+         * <a href="tutorial-Layout.DOMEvents.html">emit events locally</a> on the DOM element representing the layout-container.
+         */
+        this.Layout = new index_1.LayoutModule(this.wire);
+    }
+    /**
+     * Initializes a Platform. Must be called from the Provider when using a custom provider.
+     * @param { InitPlatformOptions } [options] - platform options including a callback function that can be used to extend or replace
+     * default Provider behavior.
+     * @return {Promise.<void>}
+     * @tutorial Platform.init
+     * @experimental
+     * @static
+     */
+    async init(options) {
+        const overrideCallback = options === null || options === void 0 ? void 0 : options.overrideCallback;
+        const interopBroker = await this.fin.Interop.init(this.fin.me.uuid, options === null || options === void 0 ? void 0 : options.interopOverride);
+        // eslint-disable-next-line @typescript-eslint/ban-ts-ignore
+        // @ts-ignore debugging purposes
+        window.interopBroker = interopBroker;
+        return this._initializer(overrideCallback, interopBroker);
+    }
+    /**
+     * Asynchronously returns a Platform object that represents an existing platform.
+     * @param { Identity } identity
+     * @return {Promise.<Platform>}
+     * @tutorial Platform.wrap
+     * @static
+     */
+    async wrap(identity) {
+        this.wire.sendAction('platform-wrap').catch((e) => {
+            // don't expose
+        });
+        return new Instance_1.Platform({ uuid: identity.uuid }, this._channel);
+    }
+    /**
+     * Synchronously returns a Platform object that represents an existing platform.
+     * @param { Identity } identity
+     * @return {Platform}
+     * @tutorial Platform.wrapSync
+     * @static
+     */
+    wrapSync(identity) {
+        this.wire.sendAction('platform-wrap-sync').catch((e) => {
+            // don't expose
+        });
+        return new Instance_1.Platform({ uuid: identity.uuid }, this._channel);
+    }
+    /**
+     * Asynchronously returns a Platform object that represents the current platform.
+     * @return {Promise.<Platform>}
+     * @tutorial Platform.getCurrent
+     * @static
+     */
+    async getCurrent() {
+        this.wire.sendAction('platform-get-current').catch((e) => {
+            // don't expose
+        });
+        return this.wrap({ uuid: this.wire.me.uuid });
+    }
+    /**
+     * Synchronously returns a Platform object that represents the current platform.
+     * @return {Platform}
+     * @tutorial Platform.getCurrentSync
+     * @static
+     */
+    getCurrentSync() {
+        this.wire.sendAction('platform-get-current-sync').catch((e) => {
+            // don't expose
+        });
+        return this.wrapSync({ uuid: this.wire.me.uuid });
+    }
+    /**
+     * Creates and starts a Platform and returns a wrapped and running Platform instance. The wrapped Platform methods can
+     * be used to launch content into the platform.  Promise will reject if the platform is already running.
+     * @param { PlatformOptions } platformOptions
+     * @return {Promise.<Platform>}
+     * @tutorial Platform.start
+     * @static
+     */
+    start(platformOptions) {
+        this.wire.sendAction('platform-start').catch((e) => {
+            // don't expose
+        });
+        // eslint-disable-next-line no-async-promise-executor
+        return new Promise(async (resolve, reject) => {
+            try {
+                const { uuid } = platformOptions;
+                // eslint-disable-next-line @typescript-eslint/ban-ts-ignore
+                // @ts-ignore using private variable.
+                const app = await this.fin.Application._create({ ...platformOptions, isPlatformController: true });
+                app.once('platform-api-ready', () => resolve(this.wrapSync({ uuid })));
+                // eslint-disable-next-line @typescript-eslint/ban-ts-ignore
+                // @ts-ignore using private variable.
+                app._run({ uuid });
+            }
+            catch (e) {
+                reject(e);
+            }
+        });
+    }
+    /**
+     * Retrieves platforms's manifest and returns a wrapped and running Platform.  If there is a snapshot in the manifest,
+     * it will be launched into the platform.
+     * @param {string} manifestUrl - The URL of platform's manifest.
+     * @param {RvmLaunchOptions} [opts] - Parameters that the RVM will use.
+     * @return {Promise.<Platform>}
+     * @tutorial Platform.startFromManifest
+     * @static
+     */
+    startFromManifest(manifestUrl, opts) {
+        this.wire.sendAction('platform-start-from-manifest').catch((e) => {
+            // don't expose
+        });
+        // eslint-disable-next-line no-async-promise-executor
+        return new Promise(async (resolve, reject) => {
+            try {
+                // eslint-disable-next-line @typescript-eslint/ban-ts-ignore
+                // @ts-ignore using private variable.
+                const app = await this.fin.Application._createFromManifest(manifestUrl);
+                app.once('platform-api-ready', () => resolve(this.wrapSync({ uuid: app.identity.uuid })));
+                // eslint-disable-next-line @typescript-eslint/ban-ts-ignore
+                // @ts-ignore using private method without warning.
+                app._run(opts);
+            }
+            catch (e) {
+                reject(e);
+            }
+        });
+    }
+}
+exports.default = PlatformModule;

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

@@ -0,0 +1,122 @@
+import { View } from '../view';
+import { EmitterBase } from '../base';
+import { Channel } from '../interappbus/channel/index';
+import ChannelClient from '../interappbus/channel/client';
+import { LayoutModule } from './layout';
+import { PlatformEvents } from '../events/platform';
+/** Manages the life cycle of windows and views in the application.
+ *
+ * Enables taking snapshots of itself and applying them to restore a previous configuration
+ * as well as listen to <a href="tutorial-Platform.EventEmitter.html">platform events</a>.
+ * @namespace
+ */
+export declare class Platform extends EmitterBase<PlatformEvents> {
+    #private;
+    Layout: LayoutModule;
+    private _channel;
+    Application: OpenFin.Application;
+    identity: OpenFin.ApplicationIdentity;
+    constructor(identity: OpenFin.ApplicationIdentity, channel: Channel);
+    getClient: (identity?: OpenFin.ApplicationIdentity) => Promise<ChannelClient>;
+    /**
+     * Creates a new view and attaches it to a specified target window.
+     * @param { View~options } viewOptions View creation options
+     * @param { Identity } [target] The window to which the new view is to be attached. If no target, create a view in a new window.
+     * @param { Identity } [targetView] If provided, the new view will be added to the same tabstrip as targetView.
+     * @return { Promise<View> }
+     * @tutorial Platform.createView
+     */
+    createView(viewOptions: OpenFin.PlatformViewCreationOptions, target?: OpenFin.Identity, targetView?: OpenFin.Identity): Promise<View>;
+    /**
+     * Creates a new Window.
+     * @param { Window~options } options Window creation options
+     * @return { Promise<_Window> }
+     * @tutorial Platform.createWindow
+     */
+    createWindow(options: OpenFin.PlatformWindowCreationOptions): Promise<OpenFin.Window & OpenFin.Identity>;
+    /**
+     * Closes current platform, all its windows, and their views.
+     * @return { Promise<void> }
+     * @tutorial Platform.quit
+     */
+    quit(): Promise<void>;
+    /**
+     * Closes a specified view in a target window.
+     * @param { Identity } viewIdentity View identity
+     * @return { Promise<void> }
+     * @tutorial Platform.closeView
+     */
+    closeView(viewIdentity: OpenFin.Identity): Promise<void>;
+    /**
+     * ***DEPRECATED - please use Platform.createView.***
+     * Reparents a specified view in a new target window.
+     * @param { Identity } viewIdentity View identity
+     * @param { Identity } target new owner window identity
+     * @return { Promise<View> }
+     * @tutorial Platform.createView
+     */
+    reparentView(viewIdentity: OpenFin.Identity, target: OpenFin.Identity): Promise<View>;
+    /**
+     * Returns a snapshot of the platform in its current state.
+     *
+     * Can be used to restore an application to a previous state.
+     * @return { Promise<Snapshot> }
+     * @tutorial Platform.getSnapshot
+     */
+    getSnapshot(): Promise<OpenFin.Snapshot>;
+    /**
+     * Adds a snapshot to a running Platform.
+     * Requested snapshot must be a valid Snapshot object, or a url or filepath to such an object.
+     *
+     * Can optionally close existing windows and overwrite current platform state with that of a snapshot.
+     *
+     * The function accepts either a snapshot taken using {@link Platform#getSnapshot getSnapshot},
+     * or a url or filepath to a snapshot JSON object.
+     * @param { Snapshot | string } requestedSnapshot Snapshot to apply, or a url or filepath.
+     * @param { ApplySnapshotOptions } [options] Optional parameters to specify whether existing windows should be closed.
+     * @return { Promise<Platform> }
+     * @tutorial Platform.applySnapshot
+     */
+    applySnapshot(requestedSnapshot: OpenFin.Snapshot | string, options?: OpenFin.ApplySnapshotOptions): Promise<Platform>;
+    /**
+     * Fetches a JSON manifest using the browser process and returns a Javascript object.
+     * Can be overwritten using {@link Platform#init Platform.init}.
+     * @param { string } manifestUrl The URL of the manifest to fetch.
+     * @return { Promise<any> }
+     * @tutorial Platform.fetchManifest
+     */
+    fetchManifest(manifestUrl: string): Promise<any>;
+    launchLegacyManifest: (manifestUrl: string) => Promise<Platform>;
+    /**
+     * Retrieves a manifest by url and launches a legacy application manifest or snapshot into the platform.  Returns a promise that
+     * resolves to the wrapped Platform.
+     * @param {string} manifestUrl - The URL of the manifest that will be launched into the platform.  If this app manifest
+     * contains a snapshot, that will be launched into the platform.  If not, the application described in startup_app options
+     * will be launched into the platform. The applicable startup_app options will become {@link View~options View Options}.
+     * @return {Promise<Platform>}
+     * @tutorial Platform.launchContentManifest
+     * @experimental
+     */
+    launchContentManifest(manifestUrl: string): Promise<Platform>;
+    /**
+     * Set the context of a host window. The context will be available to the window itself, and to its child Views. It will be saved in any platform snapshots.
+     * It can be retrieved using {@link Platform#getWindowContext getWindowContext}.
+     * @param {any} context - A field where serializable context data can be stored to be saved in platform snapshots.
+     * @param {Identity} [target] - A target window or view may optionally be provided. If no target is provided, the update will be applied
+     * to the current window (if called from a Window) or the current host window (if called from a View).
+     * @return {Promise<void>}
+     * @tutorial Platform.setWindowContext
+     * @experimental
+     */
+    setWindowContext(context?: any, target?: OpenFin.Identity): Promise<void>;
+    /**
+     * Get the context context of a host window that was previously set using {@link Platform#setWindowContext setWindowContext}.
+     * The context will be saved in any platform snapshots.  Returns a promise that resolves to the context.
+     * @param {Identity} [target] - A target window or view may optionally be provided. If no target is provided, target will be
+     * the current window (if called from a Window) or the current host window (if called from a View).
+     * @return {Promise<any>}
+     * @tutorial Platform.getWindowContext
+     * @experimental
+     */
+    getWindowContext(target?: OpenFin.Identity): Promise<any>;
+}