@openfin/workspace 6.2.2 → 6.3.0

package/client-api-platform/src/shapes.d.ts

@@ -0,0 +1,1177 @@
+/// <reference types="openfin-adapter/fin" />
+import type { InteropBroker } from 'openfin-adapter/src/api/interop';
+import { NamedIdentity } from 'openfin-adapter/src/identity';
+import { IconProps } from '@openfin/ui-library';
+import type { AttachedPage, Page, PageWithUpdatableRuntimeAttribs } from '../../common/src/api/pages/shapes';
+import type { CustomThemes } from '../../common/src/api/theming';
+import type { App } from '../../client-api/src/shapes';
+export type { CustomThemes } from '../../common/src/api/theming';
+export type { App, Image, AppIntent } from '../../client-api/src/shapes';
+export { AppManifestType } from '../../client-api/src/shapes';
+export type { AttachedPage, Page, PageWithUpdatableRuntimeAttribs, PageLayout, PageLayoutDetails } from '../../common/src/api/pages/shapes';
+/**
+ * Request for creating a saved page in persistent storage.
+ */
+export interface CreateSavedPageRequest {
+    /** The page to create. */
+    page: Page;
+}
+/**
+ * Request for updating a saved page in persistent storage.
+ */
+export interface UpdateSavedPageRequest {
+    /** The ID of the page to update. */
+    pageId: string;
+    /** The updated page. */
+    page: Page;
+}
+/**
+ * Request for reordering the pages attached to a window.
+ */
+export interface ReorderPagesRequest {
+    /** An array of page ids that specify the order of the pages attached to the window. */
+    pageIds: string[];
+}
+/**
+ * Request for opening a logo context menu in Browser.
+ */
+export interface OpenGlobalContextMenuRequest {
+    /** Screen x-coordinate where context menu should be shown. */
+    x: number;
+    /** Screen y-coordinate where context menu should be shown. */
+    y: number;
+    /** Miscellaneous options necessary for implementing custom logic in the provider override. */
+    customData?: any;
+}
+/**Shape of the data property of a context menu template item */
+export interface ContextMenuItemData {
+    type: string;
+    action?: CustomActionSpecifier;
+}
+/**Types of global context menu options, including pre-defined ones.
+ * User-defined context menu items should use the value `Custom` */
+export declare enum GlobalContextMenuOptionType {
+    NewWindow = "NewWindow",
+    NewPage = "NewPage",
+    CloseWindow = "CloseWindow",
+    OpenStorefront = "OpenStorefront",
+    Quit = "Quit",
+    Custom = "Custom"
+}
+/**Types of page tab context menu options, including pre-defined ones.
+ * User-defined context menu items should use the value `Custom` */
+export declare enum PageTabContextMenuOptionType {
+    Close = "Close",
+    Duplicate = "Duplicate",
+    Rename = "Rename",
+    Save = "Save",
+    Custom = "Custom"
+}
+/**Shape of the data property of a global context menu template item */
+export interface GlobalContextMenuItemData extends ContextMenuItemData {
+    type: GlobalContextMenuOptionType;
+}
+/**Configuration of an option in the global context menu */
+export interface GlobalContextMenuItemTemplate extends OpenFin.MenuItemTemplate {
+    data: GlobalContextMenuItemData;
+}
+/**Shape of the data property of a page tab context menu template item */
+export interface PageTabContextMenuItemData extends ContextMenuItemData {
+    type: PageTabContextMenuOptionType;
+}
+/**Configuration of an option in the page tab context menu */
+export interface PageTabContextMenuItemTemplate extends OpenFin.MenuItemTemplate {
+    data: PageTabContextMenuItemData;
+}
+/**Payload received by a Custom Action that is invoked by a custom global context menu option */
+export interface GlobalContextMenuOptionActionPayload {
+    callerType: CustomActionCallerType.GlobalContextMenu;
+    /** Identity of the browser window where the context menu is invoked */
+    windowIdentity: OpenFin.Identity;
+    /** Any data necessary for the functioning of specified custom action*/
+    customData?: any;
+}
+/**Payload received by a Custom Action that is invoked by a custom page tab context menu option */
+export interface PageTabContextMenuOptionActionPayload {
+    callerType: CustomActionCallerType.PageTabContextMenu;
+    /** Identity of the browser window where the context menu is invoked */
+    windowIdentity: OpenFin.Identity;
+    /** Any data necessary for the functioning of specified custom action*/
+    customData?: any;
+    /** Id of the page on which the context menu is invoked */
+    pageId: string;
+}
+/**
+ * Payload received by the openGlobalContextMenu provider override.
+ */
+export declare type OpenGlobalContextMenuPayload = OpenGlobalContextMenuRequest & {
+    /** Template defining the options to show in the context menu. */
+    template: GlobalContextMenuItemTemplate[];
+    /** Identity of the Browser window where context menu should be shown. */
+    identity: NamedIdentity;
+    /** Default function that handles stock context menu options. */
+    callback: (data: GlobalContextMenuItemData, payload: OpenGlobalContextMenuPayload) => any;
+};
+export interface ViewTabContextMenuTemplate extends OpenFin.MenuItemTemplate {
+    data: ViewTabMenuData;
+}
+/**
+ * Request for opening a view tab context menu in Browser.
+ */
+export interface OpenViewTabContextMenuRequest {
+    /** Screen x-coordinate where context menu should be shown. */
+    x: number;
+    /** Screen y-coordinate where context menu should be shown. */
+    y: number;
+    /** Miscellaneous options necessary for implementing custom logic in the provider override. */
+    customData?: any;
+    /** Template defining the options to show in the context menu. */
+    template: ViewTabContextMenuTemplate[];
+    selectedViews: OpenFin.Identity[];
+}
+/**
+ * Request for opening a page tab context menu in Browser.
+ */
+export interface OpenPageTabContextMenuRequest {
+    /** Screen x-coordinate where context menu should be shown. */
+    x: number;
+    /** Screen y-coordinate where context menu should be shown. */
+    y: number;
+    /** Miscellaneous options necessary for implementing custom logic in the provider override. */
+    customData?: any;
+    /** Id of the page on which the context menu is invoked */
+    pageId: string;
+}
+export declare enum ViewTabMenuOptionType {
+    NewView = "NewView",
+    DuplicateViews = "DuplicateView",
+    OpenWithDefaultBrowser = "OpenWithDefaultBrowser",
+    ReloadViews = "ReloadTab",
+    CloseViews = "CloseTab",
+    AddToChannel = "AddToChannel",
+    RemoveFromChannel = "RemoveFromChannel",
+    Custom = "Custom"
+}
+export interface ViewTabMenuData {
+    type: ViewTabMenuOptionType;
+    action?: CustomActionSpecifier;
+    option?: string;
+}
+export interface ViewTabCustomActionPayload {
+    callerType: CustomActionCallerType.ViewTabContextMenu;
+    /** Any data necessary for the functioning of specified custom action*/
+    customData: any;
+    /** Identity of the Browser window where context menu should be shown. */
+    windowIdentity: NamedIdentity;
+    selectedViews: OpenFin.Identity[];
+}
+/**
+ * Payload received by the openViewTabContextMenu provider override.
+ */
+export declare type OpenViewTabContextMenuPayload = OpenViewTabContextMenuRequest & {
+    /** Identity of the Browser window where context menu should be shown. */
+    identity: NamedIdentity;
+    /** Default function that handles stock context menu options. */
+    callback: (data: ViewTabMenuData, req: OpenViewTabContextMenuPayload) => any;
+};
+/**
+ * Payload received by the openViewTabContextMenu provider override.
+ */
+export declare type OpenPageTabContextMenuPayload = OpenPageTabContextMenuRequest & {
+    /** Identity of the Browser window where context menu should be shown. */
+    identity: NamedIdentity;
+    /** Template defining the options to show in the context menu. */
+    template: PageTabContextMenuItemTemplate[];
+    /** Default function that handles stock context menu options. */
+    callback: (data: PageTabContextMenuItemData, req: OpenPageTabContextMenuPayload) => any;
+};
+/**
+ * Request to update the attributes of a page in which is attached to a running browser window.
+ */
+export interface UpdateAttachedPageRequest {
+    /** The ID of the page to update. */
+    pageId: string;
+    /** The updated page. */
+    page: Partial<PageWithUpdatableRuntimeAttribs>;
+}
+/**
+ * Types of buttons on browser windows
+ */
+export declare enum BrowserButtonType {
+    ShowHideTabs = "ShowHideTabs",
+    ColorLinking = "ColorLinking",
+    PresetLayouts = "PresetLayouts",
+    SavePage = "SavePage",
+    Minimise = "Minimise",
+    Maximise = "Maximise",
+    Close = "Close",
+    Custom = "Custom"
+}
+/**
+ * The shape of the payload sent by a custom button click to a custom action handler
+ */
+export interface CustomButtonActionPayload {
+    /** Calling the CustomButton type */
+    callerType: CustomActionCallerType.CustomButton;
+    /** Identity for the current window. */
+    windowIdentity: OpenFin.Identity;
+    /** Any data necessary for the functioning of specified custom action*/
+    customData: any;
+    /** Screen x-coordinate where custom button should be shown. */
+    x: number;
+    /** Screen y-coordinate where custom button should be shown. */
+    y: number;
+}
+/**
+ * Custom browser buttons
+ */
+export interface CustomBrowserButtonConfig {
+    /** Type of cutom browser button */
+    type: BrowserButtonType.Custom;
+    /** Button name text when hovered over */
+    tooltip: string;
+    /** Disable custom button true or false */
+    disabled?: boolean;
+    /** icon URL for icon image */
+    iconUrl: string;
+    /** Custom action once the button is clicked */
+    action: CustomActionSpecifier;
+}
+/**
+ * Default Browser Button types
+ */
+export interface PreDefinedButtonConfig {
+    /** Type of default browser button */
+    type: BrowserButtonType;
+    /** Button name text when hovered over */
+    tooltip?: string;
+    /** icon URL for icon image */
+    iconUrl?: string;
+    iconProps?: IconProps;
+    disabled?: boolean;
+}
+declare type ShowHideTabsConfig = {
+    type: BrowserButtonType.ShowHideTabs;
+    disabled?: boolean;
+};
+/**
+ *  Buttons on the left of WindowStateButtonOptions
+ */
+export declare type ToolbarButton = ShowHideTabsConfig | CustomBrowserButtonConfig | PreDefinedButtonConfig;
+export interface ToolbarOptions {
+    buttons: ToolbarButton[];
+}
+/**
+ * Buttons to the top far right of Browser
+ */
+export declare type WindowStateButton = CustomBrowserButtonConfig | PreDefinedButtonConfig;
+export interface WindowStateButtonOptions {
+    buttons: WindowStateButton[];
+}
+/**
+ * Request for creating a browser window.
+ */
+export interface BrowserCreateWindowRequest extends Omit<OpenFin.PlatformWindowCreationOptions, 'workspacePlatform'> {
+    /** WorkspacePlatform specific window options. These options will not work unless a workspace platform has been initialized. */
+    workspacePlatform: {
+        /** The initial set of pages to add to the created browser window. */
+        pages: Page[];
+        /** The favicon to display on the top left of the created browser window. */
+        favicon?: string;
+        /** A UI friendly title for the created browser window. */
+        title?: string;
+        /**
+         * Landing page that shows up when you add a new tab from the plus button that exists in the tabstrip.
+         * If you do not provide a newTabUrl, then the plus button in the tabstrip will not be shown and users cannot create a new empty tab.
+         */
+        newTabUrl?: string;
+        /**
+         * Landing page that shows up when you add a new page from the plus button that exists in the window frame where the page selector is shown.
+         * If you do not provide a newPageUrl, then the new Page plus button will not be shown and you cannot create a new empty Page or Window.
+         */
+        newPageUrl?: string;
+        toolbarOptions?: ToolbarOptions;
+        windowStateButtonOptions?: WindowStateButtonOptions;
+        /**
+         * Remove the Page UI and only allow a single page in the browser window.
+         * Must be set to true for this behavior.  If this is not set to false,
+         * then an empty `pages` option will be populated with a single page.
+         */
+        disableMultiplePages?: boolean;
+    };
+}
+/**
+ * A window that is part of a browser snapshot.
+ */
+export declare type BrowserSnapshotWindow = OpenFin.WindowCreationOptions & BrowserCreateWindowRequest;
+/**
+ * A browser snapshot.
+ */
+export interface BrowserSnapshot {
+    /** The state of the windows that were running at the time the snapshot was taken. */
+    windows: BrowserSnapshotWindow[];
+}
+/**
+ * Controller for interacting with a browser window.
+ */
+export interface BrowserWindowModule {
+    /** The identity of the browser window. */
+    identity: OpenFin.Identity;
+    /** Underlying OpenFin window Controller. */
+    openfinWindow: OpenFin.Window;
+    /**
+     * Get a page that is attached to the browser window.
+     *
+     * ```ts
+     * import * as WorkspacePlatform from '@openfin/workspace-platform';
+     *
+     * const workspacePlatform = WorkspacePlatform.getCurrentSync();
+     * // assume a browser window already exists
+     * const windows = await workspacePlatform.Browser.getAllWindows();
+     * const page = await windows[0].getPage('MyPageId');
+     * ```
+     * @param id the id of the page to get.
+     */
+    getPage(id: string): Promise<AttachedPage>;
+    /**
+     * Return all the pages that are attached to a browser window.
+     *
+     * ```ts
+     * import * as WorkspacePlatform from '@openfin/workspace-platform';
+     *
+     * const workspacePlatform = WorkspacePlatform.getCurrentSync();
+     * // assume a browser window already exists
+     * const windows = await workspacePlatform.Browser.getAllWindows();
+     * const pages = await windows[0].getPages();
+     * ```
+     */
+    getPages(): Promise<AttachedPage[]>;
+    /**
+     * Set the active page for the browser window.  If `multiplePagesDisabled` is `true` an error will be thrown.
+     *
+     * ```ts
+     * import * as WorkspacePlatform from '@openfin/workspace-platform';
+     *
+     * const workspacePlatform = WorkspacePlatform.getCurrentSync();
+     * // assume a browser window already exists
+     * const windows = await workspacePlatform.Browser.getAllWindows();
+     * await windows[0].setActivePage('MyPageId');
+     * ```
+     * @param id the id of the attached page to set as active.
+     */
+    setActivePage(id: string): Promise<void>;
+    /**
+     * Attach a page to a browser window.
+     * If `multiplePagesDisabled` is `true` or a page with same id or title is attached to an existing browser window, an error will be thrown.
+     *
+     * ```ts
+     * import * as WorkspacePlatform from '@openfin/workspace-platform';
+     *
+     * const workspacePlatform = WorkspacePlatform.getCurrentSync();
+     * const layout = {
+     *      content: [
+     *          {
+     *              type: 'stack',
+     *              content: [
+     *                  {
+     *                      type: 'component',
+     *                      componentName: 'view',
+     *                      componentState: {
+     *                          name: 'myViewName',
+     *                          url: 'http://google.com'
+     *                      }
+     *                  }
+     *              ]
+     *           }
+     *      ]
+     * };
+     * const page = {
+     *      title: 'myPageTitle',
+     *      pageId: 'myPageId',
+     *      layout
+     * };
+     * // assume a browser window already exists
+     * const windows = await workspacePlatform.Browser.getAllWindows();
+     * await windows[0].addPage(page);
+     * // focus window
+     * await windows[0].openfinWindow.focus();
+     * // restore window if minimized
+     * await windows[0].openfinWindow.restore();
+     * ```
+     * @param page the attach page to a browser window.
+     */
+    addPage(page: PageWithUpdatableRuntimeAttribs): Promise<void>;
+    /**
+     * Remove an attached page from the browser window.
+     *
+     * ```ts
+     * import * as WorkspacePlatform from '@openfin/workspace-platform';
+     *
+     * const workspacePlatform = WorkspacePlatform.getCurrentSync();
+     * // assume a browser window already exists
+     * const windows = await workspacePlatform.Browser.getAllWindows();
+     * await windows[0].removePage('myPageId');
+     * ```
+     * @param id the id of the attached page to remove from the browser window.
+     */
+    removePage(id: string): Promise<void>;
+    /**
+     * Update a page in which is attached to the browser window.
+     *
+     * ```ts
+     * import * as WorkspacePlatform from '@openfin/workspace-platform';
+     *
+     * const workspacePlatform = WorkspacePlatform.getCurrentSync();
+     * const layout = {
+     *      content: [
+     *          {
+     *              type: 'stack',
+     *              content: [
+     *                  {
+     *                      type: 'component',
+     *                      componentName: 'view',
+     *                      componentState: {
+     *                          name: 'myViewName',
+     *                          url: 'http://google.com'
+     *                      }
+     *                  }
+     *              ]
+     *           }
+     *      ]
+     * };
+     * const page = {
+     *      title: 'myPageTitle',
+     *      pageId: 'myPageId',
+     *      layout
+     * };
+     * // assume a browser window already exists
+     * const windows = await workspacePlatform.Browser.getAllWindows();
+     * const req = {
+     *      pageId: 'myPageId',
+     *      page
+     * };
+     * await windows[0].updatePage(req);
+     * ```
+     * @param req the update request.
+     */
+    updatePage(req: UpdateAttachedPageRequest): Promise<void>;
+    /**
+     * Reorder pages attached to the browser window.  If `multiplePagesDisabled` is `true` an error will be thrown.
+     *
+     * ```ts
+     * import * as WorkspacePlatform from '@openfin/workspace-platform';
+     *
+     * const workspacePlatform = WorkspacePlatform.getCurrentSync();
+     * // assume a browser window already exists and has three pages in it
+     * const windows = await workspacePlatform.Browser.getAllWindows();
+     * await windows[0].reorderPages(['myPageId2', 'myPageId1', 'myPageId3']);
+     * ```
+     * @param req the reorder pages request.
+     */
+    reorderPages(req: ReorderPagesRequest): Promise<void>;
+    /**
+     * Replace toolbar options with custom toolbar options
+     *
+     * ```ts
+     * import * as WorkspacePlatform from '@openfin/workspace-platform';
+     *
+     * // to set the array to our default buttons, pass in null
+     *
+     * const workspacePlatform = WorkspacePlatform.getCurrentSync();
+     * workspacePlatform.Browser.wrapSync(identity).replaceToolbarOptions({buttons:[{
+     *      type: 'Custom',
+     *      tooltip: 'Custom Tooltip',
+     *      disabled: false,
+     *      iconUrl: 'https://www.openfin.co/favicon.ico',
+     *      action: {
+     *          id: 'sample-custom-action-name',
+     *          customData: {
+     *              message: 'Clicked on custom Toolbar button'
+     *          }
+     *      }
+     *  }]})
+     *
+     *  const openFinWindow = fin.Window.wrapSync(identity);
+     *  // call getOptions() to view updated toolbarOptions under workspacePlatform
+     *  await openFinWindow.getOptions()
+     * ```
+     * @param options new toolbar options.
+     */
+    replaceToolbarOptions(options: ToolbarOptions): Promise<void>;
+    /**
+     * Replace window state button options with custom window state button options
+     *
+     * ```ts
+     * import * as WorkspacePlatform from '@openfin/workspace-platform';
+     *
+     * // to set the array to our default buttons, pass in null
+     *
+     * const workspacePlatform = WorkspacePlatform.getCurrentSync();
+     * workspacePlatform.Browser.wrapSync(identity).replaceWindowStateButtonOptions({buttons:[{
+     *     type: 'Custom',
+     *     tooltip: 'Custom tooltip',
+     *     disabled: false,
+     *     iconUrl: 'https://www.openfin.co/favicon.ico',
+     *     action: {
+     *         id: 'sample-custom-action-name',
+     *         customData: {
+     *             message: 'Clicked on custom window state button'
+     *         }
+     *     }
+     * }]})
+     *
+     *  const openFinWindow = fin.Window.wrapSync(identity);
+     *  // call getOptions() to view updated windowStateButtonOptions under workspacePlatform
+     *  await openFinWindow.getOptions()
+     * ```
+     * @param options new window state options.
+     */
+    replaceWindowStateButtonOptions(options: WindowStateButtonOptions): Promise<void>;
+    /**
+     * Open global context menu in the browser window. By default, this context menu appears
+     * when clicking on the logo in the upper-left corner of the window.
+     *
+     * ```ts
+     * import * as WorkspacePlatform from '@openfin/workspace-platform';
+     *
+     * const browserIdentity = {
+     *     name: 'example-browser-window-name',
+     *     uuid: 'my-application'
+     * };
+     * const workspacePlatform = WorkspacePlatform.getCurrentSync();
+     * workspacePlatform.Browser.wrapSync(browserIdentity)._openGlobalContextMenu({
+     *     x: 100,
+     *     y: 150
+     * });
+     * ```
+     * @param req the global context menu request.
+     * @internal
+     */
+    _openGlobalContextMenu(req: OpenGlobalContextMenuRequest): Promise<void>;
+    _openViewTabContextMenu(req: OpenViewTabContextMenuRequest): Promise<void>;
+    _openPageTabContextMenu(req: OpenPageTabContextMenuRequest): Promise<void>;
+}
+/**
+ * Factory for wrapping browser windows and global operations.
+ */
+export interface BrowserWindowFactory {
+    /**
+     * Synchronously returns a Browser Window object that represents an existing window
+     *
+     * @param identity of the window
+     */
+    wrapSync: (identity: OpenFin.Identity) => BrowserWindowModule;
+    /**
+     * Get a list of all pages that are attached to any running browser window.
+     *
+     * ```ts
+     * import * as WorkspacePlatform from '@openfin/workspace-platform';
+     *
+     * const workspacePlatform = WorkspacePlatform.getCurrentSync();
+     * const attachedPages = await workspacePlatform.Browser.getAllAttachedPages();
+     * ```
+     */
+    getAllAttachedPages(): Promise<AttachedPage[]>;
+    /**
+     *  Get all the Browser Windows that are running in the Workspace Platform.
+     *
+     * ```ts
+     * import * as WorkspacePlatform from '@openfin/workspace-platform';
+     *
+     * const workspacePlatform = WorkspacePlatform.getCurrentSync();
+     * const windows = await workspacePlatform.Browser.getAllWindows();
+     * ```
+     */
+    getAllWindows(): Promise<BrowserWindowModule[]>;
+    /**
+     * Create a new browser window.
+     *
+     * ```ts
+     * import * as WorkspacePlatform from '@openfin/workspace-platform';
+     *
+     * const workspacePlatform = WorkspacePlatform.getCurrentSync();
+     * const layout = {
+     *      content: [
+     *          {
+     *              type: 'stack',
+     *              content: [
+     *                  {
+     *                      type: 'component',
+     *                      componentName: 'view',
+     *                      componentState: {
+     *                          name: 'myViewName',
+     *                          url: 'http://google.com'
+     *                      }
+     *                  }
+     *              ]
+     *           }
+     *      ]
+     * };
+     * const page = {
+     *      title: 'myPageTitle',
+     *      pageId: 'myPageId',
+     *      layout
+     * };
+     * const options: BrowserCreateWindowRequest = {
+     *      workspacePlatform {
+     *          pages: [page],
+     *          title: 'My Window Title',
+     *          favicon: 'https://google.com/favicon.ico',
+     *          disableMultiplePages: true,  // disable page functonality for the window
+     *          toolbarOptions: {  // configure the set of tray icons for the window
+     *              buttons: [
+     *                  {  // adding a custom tray icon for the window
+     *                      type: BrowserButtonType.Custom,
+     *                      tooltip: 'Sample Tray Icon',
+     *                      disabled: false,
+     *                      iconUrl: 'https://www.openfin.co/favicon.ico',
+     *                      action: {
+     *                          // This action needs to be registed in customActions property in the call WorkspacePlatform.init
+     *                          id: 'sample-trayicon-custom-action',
+     *                          customData: {
+     *                              message: 'Clicked on custom Toolbar button'
+     *                          }
+     *                      }
+     *                  },
+     *                  {
+     *                      type: BrowserButtonType.ShowHideTabs
+     *                  },
+     *                  {
+     *                      type: BrowserButtonType.ColorLinking
+     *                  },
+     *                  {
+     *                      type: BrowserButtonType.PresetLayouts
+     *                  },
+     *                  {
+     *                      type: BrowserButtonType.SavePage
+     *                  }
+     *             ]
+     *          }
+     *          windowStateButtonOptions: { configure the set of icons for setting window states
+     *              buttons: [
+     *                   {   // adding a custom window state icon for the window
+     *                       id: 'windowState123',
+     *                       type: BrowserButtonType.Custom,
+     *                       tooltip: 'Sample Window State button',
+     *                       disabled: false,
+     *                       iconUrl: 'https://www.openfin.co/favicon.ico',
+     *                       action: {
+     *                          // This action needs to be registed in customActions property in the call WorkspacePlatform.init
+     *                           id: 'sample-window-state-custom-action',
+     *                           customData: {
+     *                               message: 'Clicked on custom Window State button'
+     *                           }
+     *                       }
+     *                   },
+     *                   {  // override tooltip and icon URL for standard Maximise button
+     *                      type: BrowserButtonType.Maximise,
+     *                      tooltip: overrideWindowStateIcons ? 'Studio Maximise' : undefined,
+     *                      iconUrl: overrideWindowStateIcons ? 'https://www.openfin.co/favicon.ico' : undefined
+     *                   },
+     *                   {
+     *                      type: BrowserButtonType.Minimise
+     *                   },
+     *                   {
+     *                      type: BrowserButtonType.Close
+     *                   }
+     *              ]
+     *          }
+     *      }
+     * };
+     * const window = await workspacePlatform.Browser.createWindow(options);
+     * ```
+     *
+     * @param options the browser window creation options
+     */
+    createWindow(options: BrowserCreateWindowRequest): Promise<BrowserWindowModule>;
+    /**
+     * Get a unique title for a page.
+     *
+     * ```ts
+     * import * as WorkspacePlatform from '@openfin/workspace-platform';
+     *
+     * const workspacePlatform = WorkspacePlatform.getCurrentSync();
+     * const uniqueTitle = await workspacePlatform.Browser.getUniquePageTitle('myTitle');
+     * ```
+     * @param title a prefix for the title.
+     */
+    getUniquePageTitle(title?: string): Promise<string>;
+    /**
+     * Get the identity of the last focused Browser window.
+     *
+     * ```ts
+     * import * as WorkspacePlatform from '@openfin/workspace-platform';
+     *
+     * const workspacePlatform = WorkspacePlatform.getCurrentSync();
+     * const windowIdentity = await workspacePlatform.Browser.getLastFocusedWindow();
+     * ```
+     */
+    getLastFocusedWindow(): Promise<OpenFin.Identity>;
+}
+/**
+ * API for interacting with persistent storage.
+ */
+export interface WorkspacePlatformStorage {
+    /**
+     * Get all pages that are saved in persistent storage.
+     *
+     * ```ts
+     * import * as WorkspacePlatform from '@openfin/workspace-platform';
+     *
+     * const workspacePlatform = WorkspacePlatform.getCurrentSync();
+     * const pages = await workspacePlatform.Storage.getPages();
+     * ```
+     */
+    getPages(): Promise<Page[]>;
+    /**
+     * Get a specific page in persistent storage.
+     *
+     * ```ts
+     * import * as WorkspacePlatform from '@openfin/workspace-platform';
+     *
+     * const workspacePlatform = WorkspacePlatform.getCurrentSync();
+     * const myPage = await workspacePlatform.Storage.getPage('myPageId');
+     * ```
+     * @param id the id of the page to get.
+     */
+    getPage(id: string): Promise<Page>;
+    /**
+     * Create a page in persistent storage.
+     *
+     * ```ts
+     * import * as WorkspacePlatform from '@openfin/workspace-platform';
+     *
+     * const workspacePlatform = WorkspacePlatform.getCurrentSync();
+     * const layout = {
+     *      content: [
+     *          {
+     *              type: 'stack',
+     *              content: [
+     *                  {
+     *                      type: 'component',
+     *                      componentName: 'view',
+     *                      componentState: {
+     *                          name: 'myViewName',
+     *                          url: 'http://google.com'
+     *                      }
+     *                  }
+     *              ]
+     *           }
+     *      ]
+     * };
+     * const page = {
+     *      title: 'myPageTitle',
+     *      pageId: 'myPageId',
+     *      layout
+     * };
+     * await workspacePlatform.Storage.createPage({page});
+     * ```
+     * @param page the page to create in persistent storage.
+     */
+    createPage(page: CreateSavedPageRequest): Promise<void>;
+    /**
+     * Update a page in persistent storage.
+     *
+     * ```ts
+     * import * as WorkspacePlatform from '@openfin/workspace-platform';
+     *
+     * const workspacePlatform = WorkspacePlatform.getCurrentSync();
+     * const layout = {
+     *      content: [
+     *          {
+     *              type: 'stack',
+     *              content: [
+     *                  {
+     *                      type: 'component',
+     *                      componentName: 'view',
+     *                      componentState: {
+     *                          name: 'myViewName',
+     *                          url: 'http://google.com'
+     *                      }
+     *                  }
+     *              ]
+     *           }
+     *      ]
+     * };
+     * const page = {
+     *      title: 'myPageTitle',
+     *      pageId: 'myPageId',
+     *      layout
+     * };
+     * const req = {
+     *      pageId: 'myPageId',
+     *      page
+     * };
+     * await workspacePlatform.Storage.updatePage(req);
+     * ```
+     * @param req the update saved page request.
+     */
+    updatePage(req: UpdateSavedPageRequest): Promise<void>;
+    /**
+     * Delete a page from persistent storage.
+     *
+     * ```ts
+     * import * as WorkspacePlatform from '@openfin/workspace-platform';
+     *
+     * const workspacePlatform = WorkspacePlatform.getCurrentSync();
+     * await workspacePlatform.Storage.deletePage('myPageId');
+     * ```
+     * @param id the id of the page to delete.
+     */
+    deletePage(id: string): Promise<void>;
+    /**
+     * Save a page in persistent storage.
+     *
+     * This is a helper function that will call `getPage` to determine if a page is already in storage.
+     * If the page is already in storage, it will call `updatePage`.
+     * If it does not exist in storage, the function will call `createPage` instead.
+     *
+     * ```ts
+     * import * as WorkspacePlatform from '@openfin/workspace-platform';
+     *
+     * const workspacePlatform = WorkspacePlatform.getCurrentSync();
+     * const layout = {
+     *      content: [
+     *          {
+     *              type: 'stack',
+     *              content: [
+     *                  {
+     *                      type: 'component',
+     *                      componentName: 'view',
+     *                      componentState: {
+     *                          name: 'myViewName',
+     *                          url: 'http://google.com'
+     *                      }
+     *                  }
+     *              ]
+     *           }
+     *      ]
+     * };
+     * const page = {
+     *      title: 'myPageTitle',
+     *      pageId: 'myPageId',
+     *      layout
+     * };
+     * await workspacePlatform.Storage.savePage(page);
+     * ```
+     * @param page the page to save.
+     */
+    savePage(page: Page): Promise<void>;
+}
+/**
+ * Request for launching an application.
+ */
+export interface LaunchAppRequest {
+    target?: OpenFin.EntityInfo;
+    app: App;
+}
+/**
+ * Get Themes from API
+ */
+export interface ThemeApi {
+    getThemes(): Promise<CustomThemes>;
+}
+/**
+ * Controller for a Workspace Platform.
+ */
+export interface WorkspacePlatformModule extends OpenFin.Platform {
+    /**
+     * Launch a browser snapshot that contains windows with pages.
+     *
+     * @param snapshot the browser snapshot to launch or a url or filepath to retrieve a JSON snapshot.
+     */
+    applySnapshot(snapshot: BrowserSnapshot | string): Promise<OpenFin.Platform>;
+    /**
+     * Get a snapshot that contains browser windows with pages.
+     */
+    getSnapshot(): Promise<BrowserSnapshot>;
+    /**
+     * Invokes a custom action defined by platform provider
+     * @internal
+     */
+    _invokeCustomAction(actionId: string, payload: CustomActionPayload): Promise<any>;
+    /**
+     * Launch an application.
+     * ```ts
+     * import * as WorkspacePlatform from '@openfin/workspace-platform';
+     *
+     * const workspacePlatform = WorkspacePlatform.getCurrentSync();
+     * const req = {
+     *      app: {
+     *          appId: 'myAppId',
+     *          title: 'appTitle',
+     *          manifest: 'http://localhost/app.json',
+     *          manifestType: AppManifestType.Manifest,
+     *          icons:[
+     *              {
+     *                  icon: "https://cdn.openfin.co/demos/notifications/generator/images/icon-blue.png",
+     *                  src: "https://cdn.openfin.co/demos/notifications/generator/images/icon-blue.png",
+     *                  type: "ico",
+     *              },
+     *          ]
+     *      }
+     * }
+     * workspacePlatform.launchApp(req);
+     *
+     * ```
+     * @param req the launch app request.
+     */
+    launchApp(req: LaunchAppRequest): Promise<void>;
+    /**
+     * The browser window factory for the Workspace Platform.
+     */
+    Browser: BrowserWindowFactory;
+    /**
+     * The storage API for the Workspace Platform.
+     */
+    Storage: WorkspacePlatformStorage;
+    /**
+     * Theme API for the Workspace Platform.
+     */
+    Theme: ThemeApi;
+}
+export interface WorkspacePlatformProvider extends OpenFin.PlatformProvider {
+    /**
+     * Implementation for getting a list of saved pages from persistent storage.
+     * @param query an optional query.
+     */
+    getSavedPages(query?: string): Promise<Page[]>;
+    /**
+     * Implementation for getting a single page in persistent storage.
+     * @param id
+     */
+    getSavedPage(id: string): Promise<Page>;
+    /**
+     * Implementation for creating a saved page in persistent storage.
+     * @param req the create saved page request.
+     */
+    createSavedPage(req: CreateSavedPageRequest): Promise<void>;
+    /**
+     * Implementation for updating a saved page in persistent storage.
+     * @param req the update saved page request.
+     */
+    updateSavedPage(req: UpdateSavedPageRequest): Promise<void>;
+    /**
+     * Implementation for deleting a saved page in persistent storage.
+     * @param id of the id of the page to delete.
+     */
+    deleteSavedPage(id: string): Promise<void>;
+    /**
+     * Implementation for showing a global context menu given a menu template,
+     * handler callback, and screen coordinates. For an example of overriding, see {@link BrowserOverrideCallback}.
+     * @param req the payload received by the provider call
+     * @param callerIdentity OF identity of the entity from which the request originated
+     */
+    openGlobalContextMenu(req: OpenGlobalContextMenuPayload, callerIdentity: OpenFin.Identity): any;
+    /**
+     * Implementation for showing a view tab context menu given a menu template,
+     * handler callback, and screen coordinates. For an example of overriding, see {@link BrowserOverrideCallback}.
+     * @param req the payload received by the provider call
+     * @param callerIdentity OF identity of the entity from which the request originated
+     */
+    openViewTabContextMenu(req: OpenViewTabContextMenuPayload, callerIdentity: OpenFin.Identity): any;
+    /**
+     * Implementation for showing a page tab context menu given a menu template,
+     * handler callback, and screen coordinates. For an example of overriding, see {@link BrowserOverrideCallback}.
+     * @param req the payload received by the provider call
+     * @param callerIdentity OF identity of the entity from which the request originated
+     */
+    openPageTabContextMenu(req: OpenPageTabContextMenuPayload, callerIdentity: OpenFin.Identity): any;
+}
+/**
+ * The origins from which a custom action can be invoked
+ */
+export declare enum CustomActionCallerType {
+    CustomButton = "CustomButton",
+    GlobalContextMenu = "GlobalContextMenu",
+    ViewTabContextMenu = "ViewTabContextMenu",
+    PageTabContextMenu = "PageTabContextMenu",
+    API = "API"
+}
+/**The payload received by a Custom Action.
+ * The `callerType` property can be used to determine what data is available in the payload and cast accordingly.
+ * When `callerType == CustomActionCallerType.API`, the payload is defined by the code directly invoking the action.*/
+export declare type CustomActionPayload = {
+    callerType: CustomActionCallerType.API;
+} | CustomButtonActionPayload | GlobalContextMenuOptionActionPayload | ViewTabCustomActionPayload | PageTabContextMenuOptionActionPayload;
+/**
+ * Configures a custom action when the control is invoked
+ */
+export interface CustomActionSpecifier {
+    /** Identifier of a custom action defined at platform initialization*/
+    id: string;
+    /** Any data necessary for the functioning of specified custom action*/
+    customData?: any;
+}
+/**
+ * Payload received by invokeCustomActionInternal platform provider method
+ * @internal
+ */
+export interface InvokeCustomActionRequest {
+    actionId: string;
+    payload: CustomActionPayload;
+}
+/**
+ * Defines custom action map where the key is the custom action ID and value is the action handler
+ */
+export interface CustomActionsMap {
+    [actionId: string]: (payload: CustomActionPayload) => any;
+}
+/**
+ * Configuration for initializing a Workspace platform.
+ */
+export interface WorkspacePlatformInitConfig {
+    customActions?: CustomActionsMap;
+    /** Config for overriding browser options and behavior. */
+    browser?: BrowserInitConfig;
+    /** Custom Themes object
+     *
+     * ```ts
+     * import * as WorkspacePlatform from '@openfin/workspace-platform';
+     *
+     * // This is the palette used to create the OpenFin dark theme
+     * const customPalette: WorkspacePlatform.CustomPaletteSet = {
+     *   brandPrimary: '#504CFF',
+     *   brandSecondary: '#383A40',
+     *   backgroundPrimary: '#000',
+     *   background1: '#111214',
+     *   background2: '#1E1F23',
+     *   background3: '#24262B',
+     *   background4: '#2F3136',
+     *   background5: '#383A40',
+     *   background6: '#53565F',
+     *   statusSuccess: '#35C759',
+     *   statusWarning: '#C93400',
+     *   statusCritical: '#000',
+     *   statusActive: '#0879C4',
+     *   inputBackground: '#53565F',
+     *   inputColor: '#FFFFFF',
+     *   inputPlaceholder: '#C9CBD2',
+     *   inputDisabled: '#7D808A',
+     *   inputFocused: '#C9CBD2',
+     *   textDefault: '#FFFFFF',
+     *   textHelp: '#C9CBD2',
+     *   textInactive: '#7D808A',
+     * };
+     *
+     * const customTheme: WorkspacePlatform.CustomThemes = [{
+     *   label: "My Custom Theme",
+     *   palette: customPalette
+     * }];
+     *
+     * await WorkspacePlatform.init({
+     *   browser: { overrideCallback },
+     *   theme: customThemes
+     * });
+     */
+    theme?: CustomThemes;
+}
+/**
+ * Extend or replace default functionality in order to customize behavior of a Workspace Platform Provider.
+ *
+ * To implement your own handlers for Workspace Platform behavior, extend the provided class and override any methods you'd like to alter.
+ *
+ * ```ts
+ * import * as WorkspacePlatform from '@openfin/workspace-platform';
+ * import { UpdateSavedPageRequest } from '../../client-api-platform/src/shapes';
+ *
+ * const overrideCallback: WorkspacePlatform.BrowserOverrideCallback = async (
+ *    WorkspacePlatformProvider
+ * ) => {
+ *   class Override extends WorkspacePlatformProvider {
+ *       // ovrride default behavior of updateSavedPage
+ *       updateSavedPage = async (req: UpdateSavedPageRequest): Promise<void> => {
+ *           console.log(`saving page ${req.page.pageId}`);
+ *           // calling custom function to the save page here
+ *       };
+ *
+ *       // add a custom menu item in Global Context Menu
+ *       openGlobalContextMenu(req: WorkspacePlatform.OpenGlobalContextMenuPayload, callerIdentity: any) {
+ *            return super.openGlobalContextMenu(
+ *               {
+ *                   ...req,
+ *                   template: [
+ *                       ...req.template,
+ *                       {
+ *                           label: 'Sample custom global option',
+ *                           data: {
+ *                               type: GlobalContextMenuOptionType.Custom,
+ *                               action: {
+ *                                      // This action needs to be registed in customActions property in the call WorkspacePlatform.init
+ *                                   id: 'sample-custom-global-menu-action'
+ *                               }
+ *                           }
+ *                       }
+ *                   ]
+ *               },
+ *               callerIdentity
+ *           );
+ *       }
+ *
+ *       // add a custom menu item in View Tab Context Menu
+ *       openViewTabContextMenu = async (payload: OpenViewTabContextMenuPayload, callerIdentity) => {
+ *           return super.openViewTabContextMenu({
+ *               ...payload,
+ *               template: [
+ *                   {
+ *                       label: 'Sample View Tab Context Menu',
+ *                       data: {
+ *                           type: ViewTabMenuOptionType.Custom,
+ *                           action: {
+ *                                  // This action needs to be registed in customActions property in the call WorkspacePlatform.init
+ *                               id: 'sample-viewtab-action',
+ *                               customData: 'Custom View Tab Action'
+ *                           }
+ *                       }
+ *                   },
+ *                   ...payload.template
+ *               ]
+ *           }, callerIdentity);
+ *       };
+ *
+ *
+ *   }
+ *   return new Override();
+ * };
+ *
+ * await WorkspacePlatform.init({
+ *  browser: { overrideCallback },
+ *       customActions: {
+ *           'sample-custom-global-menu-action': (payload: CustomActionPayload) => {
+ *               alert('This custom action works ' + JSON.stringify(payload));
+ *               return 'someresponse';
+ *           },
+ *           'sample-viewtab-action': (payload: ViewTabCustomActionPayload) => {
+ *               alert('This custom action works ' + JSON.stringify(payload));
+ *               return 'someresponse';
+ *           }
+ *       }
+ *
+ *
+ * });
+ */
+export declare type BrowserOverrideCallback = OpenFin.OverrideCallback<WorkspacePlatformProvider>;
+/**
+ * Configuration for initializing a Browser.
+ */
+export interface BrowserInitConfig {
+    /**
+     * Default options for creating a new browser window. Any option not included in WorkspacePlatform.getCurrentSync().Browser.createWindow(options) call will default to the value provided in this field.
+     */
+    defaultWindowOptions?: BrowserCreateWindowRequest;
+    /** Default options when creating a new page. If `iconUrl`, `unsavedIconUrl` or `closeButton` are not defined when creating a page, setting will default to `defaultPageOptions`. */
+    defaultPageOptions?: Pick<Page, 'iconUrl' | 'unsavedIconUrl' | 'closeButton'>;
+    /**
+     * The default options when creating a new browser window. Any option not included in WorkspacePlatform.getCurrentSync().Browser.createView(options) call will default to the value provided in this field.
+     */
+    defaultViewOptions?: OpenFin.ViewOptions;
+    /**
+     * Override workspace platform behavior
+     */
+    overrideCallback?: BrowserOverrideCallback;
+    /**
+     * Override workspace platform interop behavior
+     * https://cdn.openfin.co/docs/javascript/stable/InteropBroker.html
+     */
+    interopOverride?: OpenFin.OverrideCallback<InteropBroker, InteropBroker>;
+}