@openfin/workspace-platform 5.7.2 → 6.0.0

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

@@ -6,6 +6,8 @@
 import type { Page } from '../../common/src/api/pages/shapes';
 import type { Workspace } from '../../common/src/api/workspaces';
 import type { Action, DispatchedSearchResult, SearchListenerRequest, SearchListenerResponse, SearchProvider, SearchResult } from '../../search-api/src/index';
+import { CustomTemplate, ListPairs } from './templates';
+export * from './templates';
 export type { Action, DispatchedSearchResult, SearchListenerRequest, SearchListenerResponse, SearchProviderInfo, SearchResult, ScoreOrder, SearchTag, SearchProvider, UserInputListener, ResultDispatchListener, SearchResponse } from '../../search-api/src/index';
 export type { Workspace } from '../../common/src/api/workspaces';
 export type { LayoutExtended, LayoutContentExtended, LayoutSettingsExtended, LayoutContentItemExtended, LayoutComponentExtended, LayoutComponentStateExtended, LayoutStack } from '../../common/src/utils/layout';
@@ -573,6 +575,10 @@ export declare enum CLITemplate {
      * Contact Information Template
      */
     Contact = "Contact",
+    /**
+     * Custom Template
+     */
+    Custom = "Custom",
     /**
      * Definition List Template
      */
@@ -593,7 +599,6 @@ export interface CLISearchResultWithTemplate<T extends keyof typeof CLITemplate,
     template: T;
     templateContent: C;
 }
-export declare type ListPairs = [string, string][];
 /**
  * Contact Data.
  */
@@ -624,6 +629,11 @@ export interface ContactInfo {
  */
 export interface CLISearchResultContact<A extends Action = Action> extends CLISearchResultWithTemplate<CLITemplate.Contact, ContactInfo, A> {
 }
+/**
+ * A Search Result that renders custom templates.
+ */
+export interface CLISearchResultCustom<A extends Action = Action> extends CLISearchResultWithTemplate<CLITemplate.Custom, CustomTemplate, A> {
+}
 /**
  * Definition List Search Result
  */
@@ -642,7 +652,7 @@ export interface CLISearchResultSimpleText<A extends Action = Action> extends CL
 /**
  * A search result that can be rendered by Home UI.
  */
-export declare type HomeSearchResult = CLISearchResultContact<HomeAction> | CLISearchResultSimpleText<HomeAction> | CLISearchResultList<HomeAction> | CLISearchResultPlain<HomeAction>;
+export declare type HomeSearchResult = CLISearchResultContact<HomeAction> | CLISearchResultSimpleText<HomeAction> | CLISearchResultList<HomeAction> | CLISearchResultPlain<HomeAction> | CLISearchResultCustom<HomeAction>;
 export declare enum CLIFilterOptionType {
     /**
      * Display a multi-select drop down for the options

package/client-api/src/templates.d.ts

@@ -0,0 +1,135 @@
+/**
+ *  OpenFin Workspace Custom Templates API
+ *
+ *  @module Templates
+ */
+export declare type ListPairs = [string, string][];
+export declare type CustomTemplateData = Record<string, string | ListPairs>;
+export declare type ContainerFragmentTypes = PlainContainerTemplateFragment | ButtonTemplateFragment;
+export declare type PresentationFragmentTypes = TextTemplateFragment | ImageTemplateFragment | ListTemplateFragment;
+export declare type InteractiveFragmentTypes = ButtonTemplateFragment | TextTemplateFragment | ImageTemplateFragment;
+/**
+ * The options to build your custom template composition layout.
+ */
+export declare type TemplateFragment = PlainContainerTemplateFragment | ButtonTemplateFragment | TextTemplateFragment | ListTemplateFragment | ImageTemplateFragment;
+export declare const ContainerTemplateFragmentNames: {
+    readonly Container: "Container";
+    readonly Button: "Button";
+};
+export declare const PresentationTemplateFragmentNames: {
+    readonly Text: "Text";
+    readonly Image: "Image";
+    readonly List: "List";
+};
+export declare const TemplateFragmentTypes: {
+    readonly Text: "Text";
+    readonly Image: "Image";
+    readonly List: "List";
+    readonly Container: "Container";
+    readonly Button: "Button";
+};
+export interface BaseTemplateFragment<T extends keyof typeof TemplateFragmentTypes> {
+    /**
+     * Type of the template fragment.
+     */
+    type: T;
+    /**
+     * CSS style properties of the fragment.
+     *
+     * All the available custom template fragments support all of the React's inline style properties (with camelCase keys)
+     *
+     * Note: "position: fixed" is disallowed as a fragment style.
+     */
+    style?: Record<string, string | number>;
+}
+export interface FragmentAction {
+    /**
+     * The action that will be dispatched back to provider when this fragment is clicked.
+     *
+     */
+    action?: string;
+    /**
+     * The aria compliant description for this action.
+     * If you leave this blank, the renderer will generate a generic description of
+     * the fragment's type and its action.
+     *
+     */
+    actionDescription?: string;
+}
+export interface ContainerTemplateFragment<T extends keyof typeof ContainerTemplateFragmentNames> extends BaseTemplateFragment<T> {
+    /**
+     * Sub-fragments of the container.
+     *
+     * You can use container template fragment to create nested composition structures.
+     */
+    children?: TemplateFragment[];
+}
+export interface PresentationTemplateFragment<T extends keyof typeof PresentationTemplateFragmentNames> extends BaseTemplateFragment<T> {
+    /**
+     * Optional flag.
+     *
+     * If a template fragment is flagged as optional, The service will not require
+     * the fragment's `dataKey` to exist in `templateData`. If a fragment is optional and its data
+     * is missing, the fragment will be omitted quietly by the renderer.
+     */
+    optional?: boolean;
+    /**
+     * Data key of the template fragment.
+     *
+     * The data associated with this fragment will be looked up in `templateData` map with this key.
+     *
+     * Example:
+     * ```ts
+     * const myTemplateLayout = {
+     *    type: FragmentTypes.Text,
+     *    dataKey: 'info',
+     * }
+     *
+     * const searchResult: CLISearchResultCustom = {
+     *     //...
+     *     template: CLITemplate.Custom,
+     *     templateContent: {
+     *         layout: myTemplateLayout,
+     *         data: {
+     *             info: 'My Custom Search Result Info',
+     *         }
+     *     }
+     * };
+     * ```
+     *
+     */
+    dataKey: string;
+}
+/**
+ * Some common stylization options for the `Button` component.
+ */
+export declare enum ButtonStyle {
+    Primary = "primary",
+    Secondary = "secondary",
+    TextOnly = "textOnly"
+}
+export declare type PlainContainerTemplateFragment = ContainerTemplateFragment<'Container'>;
+export declare type ButtonTemplateFragment = ContainerTemplateFragment<'Button'> & FragmentAction & {
+    /**
+     * Style of the button emitted by this fragment.
+     */
+    buttonStyle?: ButtonStyle;
+};
+export declare type TextTemplateFragment = PresentationTemplateFragment<'Text'> & FragmentAction;
+export declare type ImageTemplateFragment = PresentationTemplateFragment<'Image'> & FragmentAction & {
+    /**
+     * Alternative (accessibility) text for the image.
+     */
+    alternativeText: string;
+};
+export declare type ListTemplateFragment = PresentationTemplateFragment<'List'>;
+export interface CustomTemplate {
+    /**
+     * Root of the template composition tree. See {@link ContainerTemplateFragment} for nesting.
+     */
+    layout: TemplateFragment;
+    /**
+     * Data associated with the custom search result template's presentation fragments.
+     */
+    data: CustomTemplateData;
+}

package/client-api-platform/src/api/browser/browser-module.d.ts

@@ -1,6 +1,7 @@
 /// <reference types="openfin-adapter/fin" />
 import type { AttachedPage, Page, PageWithUpdatableRuntimeAttribs } from '../../../../common/src/api/pages/shapes';
-import { OpenGlobalContextMenuRequest, OpenViewTabContextMenuRequest } from '../../../../client-api-platform/src/shapes';
+import { OpenPageTabContextMenuRequest } from '../../../../client-api-platform/src/index';
+import { IconTrayOptions, OpenGlobalContextMenuRequest, OpenViewTabContextMenuRequest, WindowStateButtonOptions } from '../../../../client-api-platform/src/shapes';
 export declare const getBrowserModule: (identity: OpenFin.Identity) => {
     identity: OpenFin.Identity;
     openfinWindow: import("openfin-adapter").Window;
@@ -12,5 +13,8 @@ export declare const getBrowserModule: (identity: OpenFin.Identity) => {
     updatePage: (req: any) => Promise<any>;
     reorderPages: (req: any) => Promise<any>;
     _openGlobalContextMenu: (req: OpenGlobalContextMenuRequest) => Promise<any>;
+    replaceIconTrayOptions: (options: IconTrayOptions) => Promise<void>;
+    replaceWindowStateButtonOptions: (options: WindowStateButtonOptions) => Promise<void>;
     _openViewTabContextMenu: (req: OpenViewTabContextMenuRequest) => Promise<any>;
+    _openPageTabContextMenu: (req: OpenPageTabContextMenuRequest) => Promise<any>;
 };

package/client-api-platform/src/api/browser/index.d.ts

@@ -13,7 +13,10 @@ export declare const getBrowserApi: (identity: OpenFin.ApplicationIdentity) => {
         updatePage: (req: any) => Promise<any>;
         reorderPages: (req: any) => Promise<any>;
         _openGlobalContextMenu: (req: import("../../shapes").OpenGlobalContextMenuRequest) => Promise<any>;
+        replaceIconTrayOptions: (options: import("../../shapes").IconTrayOptions) => Promise<void>;
+        replaceWindowStateButtonOptions: (options: import("../../shapes").WindowStateButtonOptions) => Promise<void>;
         _openViewTabContextMenu: (req: import("../../shapes").OpenViewTabContextMenuRequest) => Promise<any>;
+        _openPageTabContextMenu: (req: import("../../shapes").OpenPageTabContextMenuRequest) => Promise<any>;
     };
     createWindow: (options: BrowserCreateWindowRequest) => Promise<BrowserWindowModule>;
     getAllAttachedPages: () => Promise<AttachedPage[]>;

package/client-api-platform/src/api/context-menu/browser-logo-handler.d.ts

@@ -1,4 +1,3 @@
-import { NamedIdentity } from 'openfin-adapter/src/identity';
-import { GlobalContextMenuItemData } from '../../shapes';
-declare const handler: (winIdentity: NamedIdentity, data: GlobalContextMenuItemData) => Promise<void>;
+import { GlobalContextMenuItemData, OpenGlobalContextMenuPayload } from '../../shapes';
+declare const handler: (data: GlobalContextMenuItemData, payload: OpenGlobalContextMenuPayload) => Promise<void>;
 export default handler;

package/client-api-platform/src/api/context-menu/browser-pagetab-handler.d.ts

@@ -0,0 +1,3 @@
+import { OpenPageTabContextMenuPayload } from '../../../../client-api-platform/src/index';
+import { PageTabContextMenuItemData } from '../../../../client-api-platform/src/shapes';
+export declare const pageTabContextMenuItemHandler: (data: PageTabContextMenuItemData, payload: OpenPageTabContextMenuPayload) => Promise<void>;

package/client-api-platform/src/api/context-menu/browser-viewtab-handler.d.ts

@@ -1,4 +1,3 @@
-import { NamedIdentity } from 'openfin-adapter/src/identity';
 import { OpenViewTabContextMenuPayload, ViewTabMenuData } from '../../../../client-api-platform/src/index';
-declare const handler: (winIdentity: NamedIdentity, data: ViewTabMenuData, payload: OpenViewTabContextMenuPayload) => Promise<void>;
+declare const handler: (data: ViewTabMenuData, payload: OpenViewTabContextMenuPayload) => Promise<void>;
 export default handler;

package/client-api-platform/src/api/context-menu/index.d.ts

@@ -1,10 +1,13 @@
 import { NamedIdentity } from 'openfin-adapter/src/identity';
-import { OpenGlobalContextMenuPayload, OpenGlobalContextMenuRequest, OpenViewTabContextMenuPayload, OpenViewTabContextMenuRequest } from '../../../../client-api-platform/src/shapes';
+import { OpenPageTabContextMenuPayload } from '../../../../client-api-platform/src/index';
+import { OpenGlobalContextMenuPayload, OpenGlobalContextMenuRequest, OpenPageTabContextMenuRequest, OpenViewTabContextMenuPayload, OpenViewTabContextMenuRequest } from '../../../../client-api-platform/src/shapes';
 export declare function openGlobalContextMenuInternal(payload: OpenGlobalContextMenuRequest & {
     identity: NamedIdentity;
 }, callerIdentity: any): Promise<void>;
-export declare const openGlobalContextMenu: (payload: OpenGlobalContextMenuPayload, callerIdentity: any) => Promise<void>;
+export declare const openCommonContextMenu: (payload: OpenGlobalContextMenuPayload | OpenViewTabContextMenuPayload | OpenPageTabContextMenuPayload, callerIdentity: any) => Promise<void>;
 export declare function openViewTabContextMenuInternal(payload: OpenViewTabContextMenuRequest & {
     identity: NamedIdentity;
 }, callerIdentity: any): Promise<void>;
-export declare const openViewTabContextMenu: (payload: OpenViewTabContextMenuPayload, callerIdentity: any) => Promise<void>;
+export declare function openPageTabContextMenuInternal(payload: OpenPageTabContextMenuRequest & {
+    identity: NamedIdentity;
+}, callerIdentity: any): Promise<void>;

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

@@ -34,8 +34,9 @@ export declare enum ChannelAction {
     GetLastFocusedBrowserWindow = "getLastFocusedBrowserWindow",
     GetThemes = "getThemes",
     OpenGlobalContextMenuInternal = "openGlobalContextMenuInternal",
-    InvokeCustomActionInternal = "invokeCustomActionInternal",
-    OpenViewTabContextMenuInternal = "openViewTabContextMenuInternal"
+    OpenViewTabContextMenuInternal = "openViewTabContextMenuInternal",
+    OpenPageTabContextMenuInternal = "openPageTabContextMenuInternal",
+    InvokeCustomActionInternal = "invokeCustomActionInternal"
 }
 /**
  * Get a channel client for a specific Workspace platform.

package/client-api-platform/src/init/utils.d.ts

@@ -1,7 +1,7 @@
 /// <reference types="openfin-adapter/fin" />
 import { Identity } from 'openfin-adapter';
 import type { CustomThemeOptions } from '../../../common/src/api/theming';
-import { BrowserCreateWindowRequest, BrowserInitConfig } from '..';
+import type { BrowserInitConfig } from '..';
 export declare function overrideViewOptions(options: Partial<OpenFin.ViewOptions>, initOptions: OpenFin.ViewOptions): any;
 export declare function preserveInteropIfManifestConflict(opts: Partial<OpenFin.ViewOptions>, fetchManifest: ({ manifestUrl: string }: {
     manifestUrl: any;
@@ -28,19 +28,6 @@ declare type LegacyWindowOptions = Omit<OpenFin.PlatformWindowCreationOptions, '
     workstacks?: OpenFin.Page[];
 };
 export declare const initWorkspacePlatformOptions: (options: LegacyWindowOptions | OpenFin.PlatformWindowCreationOptions) => OpenFin.PlatformWindowCreationOptions;
-/**
- * hasLayout()
- * Function to force layout settings
- * - Check if layout property exists if so process data, else return as is
- * - Define behavior settings
- * - Force dimension options
- * - Validate icon
- *
- * Ticket: WRK-???
- *
- * @param options - options used to handle layout settings
- * @returns processed or unprocesseed options
- */
-export declare const applyBrowserDefaults: (options: OpenFin.PlatformWindowCreationOptions, initOptions: BrowserCreateWindowRequest, theme: CustomThemeOptions) => OpenFin.PlatformWindowCreationOptions;
 export declare const applyPageDefaults: (pages: OpenFin.Page[], defaultPageOptions?: BrowserInitConfig['defaultPageOptions']) => OpenFin.Page[];
+export declare const applyBrowserDefaults: (options: OpenFin.PlatformWindowCreationOptions, initOptions: Pick<BrowserInitConfig, 'defaultWindowOptions' | 'defaultPageOptions'>, theme: CustomThemeOptions) => OpenFin.PlatformWindowCreationOptions;
 export {};

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

@@ -58,6 +58,15 @@ export declare enum GlobalContextMenuOptionType {
     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;
@@ -66,11 +75,31 @@ export interface GlobalContextMenuItemData extends ContextMenuItemData {
 export interface GlobalContextMenuItemTemplate extends OpenFin.MenuItemTemplate {
     data: GlobalContextMenuItemData;
 }
-/**Payload received by a Custom Action that is invoked by a custom context menu option */
+/**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;
-    customData: any | undefined;
+    /** 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.
@@ -81,7 +110,7 @@ export declare type OpenGlobalContextMenuPayload = OpenGlobalContextMenuRequest
     /** Identity of the Browser window where context menu should be shown. */
     identity: NamedIdentity;
     /** Default function that handles stock context menu options. */
-    callback: (data: GlobalContextMenuItemData) => any;
+    callback: (data: GlobalContextMenuItemData, payload: OpenGlobalContextMenuPayload) => any;
 };
 export interface ViewTabContextMenuTemplate extends OpenFin.MenuItemTemplate {
     data: ViewTabMenuData;
@@ -100,6 +129,19 @@ export interface OpenViewTabContextMenuRequest {
     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",
@@ -130,7 +172,18 @@ export declare type OpenViewTabContextMenuPayload = OpenViewTabContextMenuReques
     /** 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: OpenViewTabContextMenuRequest) => any;
+    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.
@@ -414,7 +467,66 @@ export interface BrowserWindowModule {
      * @param req the reorder pages request.
      */
     reorderPages(req: ReorderPagesRequest): Promise<void>;
+    /**
+     * Replace icon tray options with custom icon tray 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).replaceIconTrayOptions({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 Icon Tray button'
+     *          }
+     *      }
+     *  }]})
+     *
+     *  const openFinWindow = fin.Window.wrapSync(identity);
+     *  // call getOptions() to view updated iconTrayOptions under workspacePlatform
+     *  await openFinWindow.getOptions()
+     * ```
+     * @param options new icon tray options.
+     */
+    replaceIconTrayOptions(options: IconTrayOptions): 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>;
     _openViewTabContextMenu(req: OpenViewTabContextMenuRequest): Promise<void>;
+    _openPageTabContextMenu(req: OpenPageTabContextMenuRequest): Promise<void>;
 }
 /**
  * Factory for wrapping browser windows and global operations.
@@ -481,7 +593,66 @@ export interface BrowserWindowFactory {
      *      workspacePlatform {
      *          pages: [page],
      *          title: 'My Window Title',
-     *          favicon: 'https://google.com/favicon.ico'
+     *          favicon: 'https://google.com/favicon.ico',
+     *          disableMultiplePages: true,  // disable page functonality for the window
+     *          iconTrayOptions: {  // 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 Icon Tray 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);
@@ -763,14 +934,21 @@ export interface WorkspacePlatformProvider extends OpenFin.PlatformProvider {
      * @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: any): any;
+    openGlobalContextMenu(req: OpenGlobalContextMenuPayload, callerIdentity: OpenFin.Identity): any;
     /**
      * Implementation for showing a view tab context menu given a menu template,
      * handler callback, and screen coordinates
      * @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: any): any;
+    openViewTabContextMenu(req: OpenViewTabContextMenuPayload, callerIdentity: OpenFin.Identity): any;
+    /**
+     * Implementation for showing a page tab context menu given a menu template,
+     * handler callback, and screen coordinates
+     * @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
@@ -779,6 +957,7 @@ export declare enum CustomActionCallerType {
     CustomButton = "CustomButton",
     GlobalContextMenu = "GlobalContextMenu",
     ViewTabContextMenu = "ViewTabContextMenu",
+    PageTabContextMenu = "PageTabContextMenu",
     API = "API"
 }
 /**The payload received by a Custom Action.
@@ -786,7 +965,7 @@ export declare enum CustomActionCallerType {
  * 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;
+} | CustomButtonActionPayload | GlobalContextMenuOptionActionPayload | ViewTabCustomActionPayload | PageTabContextMenuOptionActionPayload;
 /**
  * Configures a custom action when the control is invoked
  */
@@ -864,16 +1043,75 @@ export interface WorkspacePlatformInitConfig {
  *    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>;

package/common/src/api/browser-protocol.d.ts

@@ -15,7 +15,9 @@ export interface AddToChannelRequest {
 export declare enum ChannelAction {
     CloseBrowserWindow = "close-browser-window",
     QuitPlatform = "quit-platform",
-    CloseActivePage = "close-active-page",
+    ClosePage = "close-page",
     AddToChannel = "add-to-channel",
-    RemoveFromChannel = "remove-from-channel"
+    RemoveFromChannel = "remove-from-channel",
+    SavePage = "save-page",
+    DuplicatePage = "duplicate-page"
 }