@openfin/workspace-platform 20.0.2 → 20.0.4

package/browser/src/hooks/EnterpriseSearchMenu/useUpdateInputExpansionState.d.ts

@@ -0,0 +1,15 @@
+import { FocusEventHandler, MutableRefObject } from 'react';
+import { SearchViewExpansionState } from '../../../../browser/src/components/ControlBar/LeftControlsContainer/EnterpriseNavigationContainer/AddressBar/AddressBar';
+/**
+ * Custom hook that returns action handlers for the address input DOM element that update the search view expansion state.
+ *
+ * @param {MutableRefObject<HTMLInputElement>} addressBarInputRef - Ref object pointing to the address input element.
+ * @param {boolean} shouldExpand - Boolean indicating if the search results view should expand.
+ * @param {React.Dispatch<React.SetStateAction<string>>} setSearchText - Function that updates the search text.
+ * @param {Dispatch<SetStateAction<SearchViewExpansionState>>} setShouldExpandMenu - Function that updates whether the menu should expand and the method of expansion.
+ */
+export declare const useUpdateInputExpansionState: (addressBarInputRef: MutableRefObject<HTMLInputElement>, shouldExpand: boolean, setSearchText: React.Dispatch<React.SetStateAction<string>>, setShouldExpandMenu: React.Dispatch<React.SetStateAction<SearchViewExpansionState>>) => {
+    onChange: import("react").ChangeEventHandler<HTMLInputElement>;
+    onClick: import("react").MouseEventHandler<HTMLInputElement>;
+    onBlur: FocusEventHandler<HTMLInputElement>;
+};

package/browser/src/hooks/EnterpriseSearchMenu/useUpdateViewExpansionState.d.ts

@@ -0,0 +1,32 @@
+/// <reference types="lodash" />
+import { Dispatch, SetStateAction } from 'react';
+import { OpenFin } from '@openfin/core';
+import { SearchViewExpansionState } from '../../../../browser/src/components/ControlBar/LeftControlsContainer/EnterpriseNavigationContainer/AddressBar/AddressBar';
+export declare let lastViewEvent: {
+    viewIdentity: OpenFin.Identity;
+    type: 'view-focused' | 'tab-created';
+};
+/**
+ * This function enables the following behaviors:
+ *  - When a new view tab is created via the new tab button that is on the landing page, the adress input will focus.
+ *  - When a user clicks on an inactive view tab that is on the landing page, the address input will focus.
+ *  - When a user clicks on an active view tab is on the landing page while the address input bar is focused, the view will focus.
+ */
+export declare const debouncedHandleAddressFocusOnLandingPage: import("lodash").DebouncedFunc<({ viewIdentity, type }: typeof lastViewEvent) => Promise<boolean>>;
+/**
+ * This function enables the following behaviors:
+ *  - When a user re-organizes a view tab on the landing page in a layout, the address input will focus.
+ *  - When a user drags a page tab that is on the landing page into a layout, the address input will focus.
+ *  - When a user drags out a view or page tab on the landing page to create a new window, the address input will focus (from 'tab-created' event).
+ */
+export declare const resetLastFocusedViewAndHandleViewFocused: (event: typeof lastViewEvent) => Promise<boolean>;
+/**
+ * Custom hook that responds to updates to view expansion state updates, handles view focus events, and controls
+ * focus on the address input.
+ *
+ * @param {SearchViewExpansionState} shouldExpandMenu - Object with boolean indicating if the search results view should expand and the method of expansion.
+ * @param {OpenFin.View} addressSearchResultsView - View object corresponding to the search results view.
+ * @param {Dispatch<SetStateAction<number>>} setAddressBarWidth - Function that updates the width in pixels of the address input bar in its expanded state.
+ * @param {Dispatch<SetStateAction<SearchViewExpansionState>>} setShouldExpandMenu - Function that updates whether the menu should expand and the method of expansion.
+ */
+export declare const useUpdateViewExpansionState: (shouldExpandMenu: SearchViewExpansionState, addressSearchResultsView: OpenFin.View, setAddressBarWidth: Dispatch<SetStateAction<number>>, setShouldExpandMenu: Dispatch<SetStateAction<SearchViewExpansionState>>) => void;

package/browser/src/hooks/useEnterpriseHotkeys.d.ts

@@ -0,0 +1,4 @@
+import type OpenFin from '@openfin/core';
+export declare const processHotKeys: (e: OpenFin.Events.ViewEvents.HotkeyEvent, isOsWindows: boolean, viewId?: OpenFin.Identity) => void;
+declare const useEnterpriseHotkeys: (viewId?: OpenFin.Identity) => void;
+export default useEnterpriseHotkeys;

package/browser/src/hooks/usePanelBounds.d.ts

@@ -0,0 +1,4 @@
+import { PanelConfigVertical, PanelPosition } from '../../../common/src/api/pages/shapes';
+export type CSSBounds = Partial<Record<'top' | 'right' | 'bottom' | 'left' | 'height' | 'width', string>>;
+export declare const BookmarksPanelConfig: PanelConfigVertical;
+export declare const usePanelBounds: (panelPosition: PanelPosition | 'Center') => Partial<Record<"top" | "left" | "height" | "width" | "bottom" | "right", string>>;

package/browser/src/hooks/useSingleViewPage.d.ts

@@ -0,0 +1,2 @@
+export declare const useIsPageSingleView: (pageId: string) => boolean;
+export declare const useIsActivePageSingleView: () => boolean;

package/browser/src/hooks/useWindowFocusState.d.ts

@@ -0,0 +1,17 @@
+/// <reference types="react" />
+type WindowState = 'focused' | 'view-focused' | 'blurred';
+/**
+ * Creates a context which exposes information about the specified window's state
+ */
+export declare const WindowStateProvider: (props: {
+    children: React.ReactNode;
+}) => JSX.Element;
+/**
+ * Tracks the window's current state.
+ */
+export declare const useWindowState: () => WindowState;
+/**
+ * Tracks whether the window or any view within it is focused.
+ */
+declare const useWindowFocusState: () => boolean;
+export default useWindowFocusState;

package/browser/src/slices/menu.d.ts

@@ -0,0 +1,28 @@
+import { PayloadAction } from '@reduxjs/toolkit';
+import { Menu, UserMenuParams } from '../../../common/src/utils/menu';
+export interface SystemMenuParams {
+    parentName: string;
+}
+export type CompleteMenuParams<M extends Menu> = UserMenuParams[M] & SystemMenuParams;
+interface ActiveState<M extends Menu = Menu> {
+    type: M | null;
+    params: UserMenuParams[M] | null;
+}
+export interface InitialState {
+    active: ActiveState;
+}
+export interface MenusRootState {
+    menu: InitialState;
+}
+export declare const menuSlice: import("@reduxjs/toolkit").Slice<InitialState, {
+    openMenu: (state: import("immer/dist/internal").WritableDraft<InitialState>, action: PayloadAction<ActiveState>) => void;
+    closeActiveMenu: (state: import("immer/dist/internal").WritableDraft<InitialState>) => void;
+}, "menu">;
+export declare const openMenu: <M extends Menu = Menu>(menu: M, params: UserMenuParams[M]) => {
+    payload: ActiveState<Menu>;
+    type: string;
+};
+export declare const closeActiveMenu: import("@reduxjs/toolkit").ActionCreatorWithoutPayload<string>;
+export declare const selectActiveMenu: (state: MenusRootState) => ActiveState;
+declare const _default: import("redux").Reducer<InitialState>;
+export default _default;

package/browser/src/slices/modal/close.d.ts

@@ -0,0 +1,10 @@
+export interface ClosePageRequestPayload {
+    pageId: string;
+    closeType?: 'page' | 'view';
+}
+export declare const handleClosePageRequest: import("@reduxjs/toolkit").AsyncThunk<void, ClosePageRequestPayload, {}>;
+export declare const closeBrowserWindow: () => Promise<void>;
+/**
+ * Show the close window modal
+ */
+export declare const handleCloseWindowRequest: import("@reduxjs/toolkit").AsyncThunk<void, void, {}>;

package/browser/src/slices/modal/index.d.ts

@@ -0,0 +1,8 @@
+export interface PagesModalRootState {
+    modal: {
+        isModalOpen: boolean;
+    };
+}
+export declare const modalSlice: import("@reduxjs/toolkit").Slice<{}, {}, "modal">;
+declare const _default: import("redux").Reducer<{}>;
+export default _default;

package/browser/src/slices/pages/attached.d.ts

@@ -0,0 +1,83 @@
+import type { AttachedPageInternal } from '../../../../common/src/api/pages/shapes';
+export interface AttachedPagesRootState {
+    attachedPages: {
+        activePageIndex: number;
+        attachedPages: AttachedPageInternal[];
+        isDetachingPages: boolean;
+        isActivePageChanging: boolean;
+        isInitialized: boolean;
+    };
+}
+interface Action<P> {
+    type: string;
+    payload: P;
+}
+interface UpdatePageAtIndexPayload {
+    index: number;
+    page: Partial<AttachedPageInternal>;
+}
+/**
+ * The source of truth for the current Browser window's attached page state.
+ */
+export declare const attachedPagesSlice: import("@reduxjs/toolkit").Slice<{
+    activePageIndex: number;
+    attachedPages: AttachedPageInternal[];
+    isDetachingPages: boolean;
+    isActivePageChanging: boolean;
+    isInitialized: boolean;
+}, {
+    setPages: (state: import("immer/dist/internal").WritableDraft<{
+        activePageIndex: number;
+        attachedPages: AttachedPageInternal[];
+        isDetachingPages: boolean;
+        isActivePageChanging: boolean;
+        isInitialized: boolean;
+    }>, action: Action<AttachedPageInternal[]>) => void;
+    updatePageAtIndex: (state: import("immer/dist/internal").WritableDraft<{
+        activePageIndex: number;
+        attachedPages: AttachedPageInternal[];
+        isDetachingPages: boolean;
+        isActivePageChanging: boolean;
+        isInitialized: boolean;
+    }>, action: Action<UpdatePageAtIndexPayload>) => void;
+    setIsDetachingPages: (state: import("immer/dist/internal").WritableDraft<{
+        activePageIndex: number;
+        attachedPages: AttachedPageInternal[];
+        isDetachingPages: boolean;
+        isActivePageChanging: boolean;
+        isInitialized: boolean;
+    }>, action: Action<boolean>) => void;
+    setIsActivePageChanging: (state: import("immer/dist/internal").WritableDraft<{
+        activePageIndex: number;
+        attachedPages: AttachedPageInternal[];
+        isDetachingPages: boolean;
+        isActivePageChanging: boolean;
+        isInitialized: boolean;
+    }>, action: Action<boolean>) => void;
+    setIsInitialized: (state: import("immer/dist/internal").WritableDraft<{
+        activePageIndex: number;
+        attachedPages: AttachedPageInternal[];
+        isDetachingPages: boolean;
+        isActivePageChanging: boolean;
+        isInitialized: boolean;
+    }>, action: Action<boolean>) => void;
+}, "attached-pages">;
+export declare const setPages: import("@reduxjs/toolkit").ActionCreatorWithOptionalPayload<AttachedPageInternal[], string>, updatePageAtIndex: import("@reduxjs/toolkit").ActionCreatorWithOptionalPayload<UpdatePageAtIndexPayload, string>, setIsActivePageChanging: import("@reduxjs/toolkit").ActionCreatorWithOptionalPayload<boolean, string>, setIsDetachingPages: import("@reduxjs/toolkit").ActionCreatorWithOptionalPayload<boolean, string>, setIsInitialized: import("@reduxjs/toolkit").ActionCreatorWithOptionalPayload<boolean, string>;
+export declare const selectActivePage: (state: AttachedPagesRootState) => AttachedPageInternal;
+export declare const selectActivePageWithIndex: (state: AttachedPagesRootState) => [AttachedPageInternal, number];
+export declare const selectPage: (state: AttachedPagesRootState, pageId: string) => AttachedPageInternal;
+export declare const selectPageByLayoutContainerKey: (state: AttachedPagesRootState, layoutContainerKey: string) => AttachedPageInternal;
+export declare const selectPageAtIndex: (state: AttachedPagesRootState, index: number) => AttachedPageInternal;
+export declare const selectPageWithIndex: (state: AttachedPagesRootState, pageId: string) => [AttachedPageInternal, number];
+export declare const selectPages: (state: AttachedPagesRootState) => AttachedPageInternal[];
+export declare const selectIsDetachingPages: (state: AttachedPagesRootState) => boolean;
+export declare const selectIsActivePageChanging: (state: AttachedPagesRootState) => boolean;
+export declare const selectIsInitialized: (state: AttachedPagesRootState) => boolean;
+declare const _default: import("redux").Reducer<{
+    activePageIndex: number;
+    attachedPages: AttachedPageInternal[];
+    isDetachingPages: boolean;
+    isActivePageChanging: boolean;
+    isInitialized: boolean;
+}>;
+export default _default;

package/browser/src/slices/tab-focus.d.ts

@@ -0,0 +1,85 @@
+import { PayloadAction } from '@reduxjs/toolkit';
+import type OpenFin from '@openfin/core';
+import { BrowserRootState } from '../../../browser/src/store';
+export interface TabFocusRootState {
+    tabFocus: {
+        showAllContextGroups: boolean;
+        layoutsWithSelectedViews: Record<string, OpenFin.Identity[]>;
+    };
+}
+export declare const tabFocusSlice: import("@reduxjs/toolkit").Slice<{
+    showAllContextGroups: boolean;
+    layoutsWithSelectedViews: Record<string, OpenFin.Identity[]>;
+}, {
+    /**
+     * Select a single view
+     */
+    selectViewReducer: (state: import("immer/dist/internal").WritableDraft<{
+        showAllContextGroups: boolean;
+        layoutsWithSelectedViews: Record<string, OpenFin.Identity[]>;
+    }>, action: PayloadAction<{
+        viewId: OpenFin.Identity;
+        layoutContainerKey: string;
+    }>) => void;
+    /**
+     * Add a view to the list of currently selected views (multi-select);
+     */
+    addSelectedViewReducer: (state: import("immer/dist/internal").WritableDraft<{
+        showAllContextGroups: boolean;
+        layoutsWithSelectedViews: Record<string, OpenFin.Identity[]>;
+    }>, action: PayloadAction<{
+        viewId: OpenFin.Identity;
+        layoutContainerKey: string;
+    }>) => void;
+    /**
+     * Clears selected view from a specified page
+     */
+    clearSelectedViewsReducer: (state: import("immer/dist/internal").WritableDraft<{
+        showAllContextGroups: boolean;
+        layoutsWithSelectedViews: Record<string, OpenFin.Identity[]>;
+    }>, action: PayloadAction<{
+        layoutContainerKey: string;
+    }>) => void;
+    /**
+     * Delete entry for pageId from pagesWithSelectedViews
+     */
+    deletePageWithSelectedViewsReducer: (state: import("immer/dist/internal").WritableDraft<{
+        showAllContextGroups: boolean;
+        layoutsWithSelectedViews: Record<string, OpenFin.Identity[]>;
+    }>, action: PayloadAction<string>) => void;
+    toggleContextGroupOutlines: (state: import("immer/dist/internal").WritableDraft<{
+        showAllContextGroups: boolean;
+        layoutsWithSelectedViews: Record<string, OpenFin.Identity[]>;
+    }>) => void;
+}, "tab-focus">;
+export declare const selectView: import("@reduxjs/toolkit").AsyncThunk<void, {
+    viewId: OpenFin.Identity;
+    pageId: string;
+}, {}>;
+export declare const selectViewForLayoutContainerKey: import("@reduxjs/toolkit").AsyncThunk<void, {
+    viewId: OpenFin.Identity;
+    layoutContainerKey: string;
+}, {}>;
+export declare const addSelectedView: import("@reduxjs/toolkit").AsyncThunk<void, {
+    viewId: OpenFin.Identity;
+    pageId: string;
+}, {}>;
+export declare const clearSelectedViews: import("@reduxjs/toolkit").AsyncThunk<void, {
+    pageId: string;
+}, {}>;
+export declare const deletePageWithSelectedViews: import("@reduxjs/toolkit").AsyncThunk<void, string, {}>;
+export declare const toggleContextGroupOutlines: import("@reduxjs/toolkit").ActionCreatorWithoutPayload<string>, selectViewReducer: import("@reduxjs/toolkit").ActionCreatorWithOptionalPayload<{
+    viewId: OpenFin.Identity;
+    layoutContainerKey: string;
+}, string>;
+export declare const selectShowAllContextGroups: (state: TabFocusRootState) => boolean;
+export declare const selectSelectedViewsForPage: (state: BrowserRootState, pageId: string) => OpenFin.Identity[];
+export declare const selectSelectedViewsForLayoutContainerKey: (layoutContainerKey: string) => (state: BrowserRootState) => OpenFin.Identity[];
+export declare const selectLayoutsWithSelectedViews: (state: TabFocusRootState) => Record<string, OpenFin.Identity[]>;
+export declare const selectFirstViewNameForLayoutContainerKey: (layoutContainerKey: string) => (state: BrowserRootState) => string;
+export declare const selectFirstViewIdForLayoutContainerKey: (layoutContainerKey: string) => (state: BrowserRootState) => string;
+declare const _default: import("redux").Reducer<{
+    showAllContextGroups: boolean;
+    layoutsWithSelectedViews: Record<string, OpenFin.Identity[]>;
+}>;
+export default _default;

package/browser/src/store/index.d.ts

@@ -0,0 +1,90 @@
+/**
+ * Redux store for a Browser Window.
+ */
+declare const store: import("@reduxjs/toolkit").EnhancedStore<{
+    environment: {
+        isWindows: boolean;
+    };
+    modal: {};
+    attachedPages: {
+        activePageIndex: number;
+        attachedPages: import("../../../common/src/api/pages/shapes").AttachedPageInternal[];
+        isDetachingPages: boolean;
+        isActivePageChanging: boolean;
+        isInitialized: boolean;
+    };
+    tabFocus: {
+        showAllContextGroups: boolean;
+        layoutsWithSelectedViews: Record<string, {
+            uuid: string;
+            name: string;
+        }[]>;
+    };
+    menu: import("@browser/slices/menu").InitialState;
+    targetTheming: {
+        isFetchingTheme: boolean;
+        currentTheme: import("../../../common/src/api/theming").ComputedTheme;
+        hasTriedFetch: boolean;
+        currentScheme: import("client-api-platform").ColorSchemeOptionType; /**
+         * Redux store for a Browser Window.
+         */
+    };
+}, import("redux").AnyAction, [import("redux-thunk").ThunkMiddleware<{
+    environment: {
+        isWindows: boolean;
+    };
+    modal: {};
+    attachedPages: {
+        activePageIndex: number;
+        attachedPages: import("../../../common/src/api/pages/shapes").AttachedPageInternal[];
+        isDetachingPages: boolean;
+        isActivePageChanging: boolean;
+        isInitialized: boolean;
+    };
+    tabFocus: {
+        showAllContextGroups: boolean;
+        layoutsWithSelectedViews: Record<string, {
+            uuid: string;
+            name: string;
+        }[]>;
+    };
+    menu: import("@browser/slices/menu").InitialState;
+    targetTheming: {
+        isFetchingTheme: boolean;
+        currentTheme: import("../../../common/src/api/theming").ComputedTheme;
+        hasTriedFetch: boolean;
+        currentScheme: import("client-api-platform").ColorSchemeOptionType; /**
+         * Redux store for a Browser Window.
+         */
+    };
+}, import("redux").AnyAction, null> | import("redux-thunk").ThunkMiddleware<{
+    environment: {
+        isWindows: boolean;
+    };
+    modal: {};
+    attachedPages: {
+        activePageIndex: number;
+        attachedPages: import("../../../common/src/api/pages/shapes").AttachedPageInternal[];
+        isDetachingPages: boolean;
+        isActivePageChanging: boolean;
+        isInitialized: boolean;
+    };
+    tabFocus: {
+        showAllContextGroups: boolean;
+        layoutsWithSelectedViews: Record<string, {
+            uuid: string;
+            name: string;
+        }[]>;
+    };
+    menu: import("@browser/slices/menu").InitialState;
+    targetTheming: {
+        isFetchingTheme: boolean;
+        currentTheme: import("../../../common/src/api/theming").ComputedTheme;
+        hasTriedFetch: boolean;
+        currentScheme: import("client-api-platform").ColorSchemeOptionType; /**
+         * Redux store for a Browser Window.
+         */
+    };
+}, import("redux").AnyAction>]>;
+export default store;
+export type BrowserRootState = ReturnType<typeof store.getState>;

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

@@ -0,0 +1,6 @@
+import { BookmarkNode, CreateBookmarkNodeRequest, UpdateBookmarkNodeRequest } from '../../../../common/src/api/pages/shapes';
+export declare const createBookmarkNodeInternal: (req: CreateBookmarkNodeRequest) => Promise<BookmarkNode>;
+export declare const getBookmarkNodeInternal: (id?: string) => Promise<BookmarkNode | undefined>;
+export declare const searchBookmarkNodesInternal: (query: string) => Promise<BookmarkNode[]>;
+export declare const updateBookmarkNodeInternal: (req: UpdateBookmarkNodeRequest) => Promise<BookmarkNode | undefined>;
+export declare const deleteBookmarkNodeInternal: (id: string) => Promise<void>;

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

@@ -6,7 +6,8 @@ export declare enum AnchorBehavior {
     BottomRight = 1,
     Center = 2
 }
-export declare const openCommonContextMenu: (payload: OpenGlobalContextMenuPayload | OpenViewTabContextMenuPayload | OpenPageTabContextMenuPayload | OpenSaveButtonContextMenuPayload, _callerIdentity: OpenFin.Identity, type?: ContextMenuType, anchorBehavior?: AnchorBehavior) => Promise<void>;
+type ContextMenuPayload = OpenGlobalContextMenuPayload | OpenViewTabContextMenuPayload | OpenPageTabContextMenuPayload | OpenSaveButtonContextMenuPayload;
+export declare const openCommonContextMenu: (payload: ContextMenuPayload, _callerIdentity: OpenFin.Identity, type?: ContextMenuType, anchorBehavior?: AnchorBehavior) => Promise<void>;
 export declare function openGlobalContextMenuInternal(this: WorkspacePlatformProvider, payload: InternalOpenGlobalContextMenuRequest & {
     identity: OpenFin.Identity;
 }, callerIdentity: OpenFin.Identity): Promise<void>;
@@ -19,3 +20,4 @@ export declare function openPageTabContextMenuInternal(this: WorkspacePlatformPr
 export declare function openSaveButtonContextMenuInternal(this: WorkspacePlatformProvider, payload: OpenSaveButtonContextMenuRequest & {
     identity: OpenFin.Identity;
 }, callerIdentity: OpenFin.Identity): Promise<void>;
+export {};

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

@@ -2,7 +2,7 @@ import type OpenFin from '@openfin/core';
 import { IconProps, Languages } from '@openfin/ui-library';
 import type { AnalyticsEvent, AnalyticsEventInternal } from '../../common/src/utils/usage-register';
 import { CustomActionSpecifier, CustomButtonConfig } from '../../common/src/api/action';
-import type { AddDefaultPagePayload, AttachedPage, CopyPagePayload, HandlePagesAndWindowClosePayload, HandlePagesAndWindowCloseResult, HandleSaveModalOnPageClosePayload, Page, PageWithUpdatableRuntimeAttribs, SaveModalOnPageCloseResult, ShouldPageClosePayload, ShouldPageCloseResult, ViewsPreventingUnloadPayload } from '../../common/src/api/pages/shapes';
+import { AddDefaultPagePayload, AttachedPage, CopyPagePayload, HandlePagesAndWindowClosePayload, HandlePagesAndWindowCloseResult, HandleSaveModalOnPageClosePayload, Page, PageWithUpdatableRuntimeAttribs, SaveModalOnPageCloseResult, ShouldPageClosePayload, ShouldPageCloseResult, ViewsPreventingUnloadPayload } from '../../common/src/api/pages/shapes';
 import { SetActivePageForWindowPayload } from '../../common/src/api/pages/shapes';
 import { NotificationsCustomManifestOptions } from '../../common/src/api/shapes/notifications';
 import type { CustomThemes } from '../../common/src/api/theming';
@@ -959,6 +959,9 @@ export interface BrowserWindowModule {
      * @property {string} [value] - The value associated with the 'custom' type.
      */
     updateBrowserWindowTitle(title: WindowTitle): Promise<void>;
+    _bookmarks: BrowserBookmarks;
+}
+export interface BrowserBookmarks {
 }
 /**
  * Factory for wrapping browser windows and global operations.
@@ -1519,6 +1522,7 @@ export interface WorkspacePlatformModule extends OpenFin.Platform {
      * Implementation for getting the notifications workspace platform configuration.
      */
     getNotificationsConfig(): Promise<NotificationsCustomManifestOptions | undefined>;
+    _raiseAnalytics(events: AnalyticsEventInternal[]): Promise<void>;
     /**
      * The browser window factory for the Workspace Platform.
      */
@@ -1531,7 +1535,6 @@ export interface WorkspacePlatformModule extends OpenFin.Platform {
      * Theme API for the Workspace Platform.
      */
     Theme: ThemeApi;
-    _raiseAnalytics(events: AnalyticsEventInternal[]): Promise<void>;
 }
 export interface WorkspacePlatformProvider extends OpenFin.PlatformProvider {
     /**

package/common/src/api/pages/internal.d.ts

@@ -0,0 +1,8 @@
+import { CopyPagePayload, HandleSaveModalOnPageClosePayload, Page, SaveModalOnPageCloseResult, ShouldPageClosePayload, ShouldPageCloseResult } from '../../../../common/src/api/pages/shapes';
+import { shouldWindowClose } from '../../../../client-api-platform/src/api/pages';
+import { HandlePageChangesPayload, ModifiedPageState } from '../../../../client-api-platform/src/shapes';
+export declare const requestPageSaveModalDecision: (req: HandleSaveModalOnPageClosePayload) => Promise<SaveModalOnPageCloseResult>;
+export declare const requestShouldPageClose: (req: ShouldPageClosePayload) => Promise<ShouldPageCloseResult>;
+export declare const requestShouldWindowClose: (payload: Parameters<typeof shouldWindowClose>[0]) => ReturnType<typeof shouldWindowClose>;
+export declare const copyPage: (req: CopyPagePayload) => Promise<Page>;
+export declare const requestPageChangesDecision: (req: HandlePageChangesPayload) => Promise<ModifiedPageState>;

package/common/src/api/pages/shapes.d.ts

@@ -257,4 +257,95 @@ export type AddPagePayload = {
     /** Index at which the page should be added */
     insertionIndex?: number;
 };
+/**
+ * A node that represents either a bookmark or folder in the bookmark tree.
+ */
+export interface BookmarkNode {
+    /**
+     * The unique id of the node.
+     */
+    id: string;
+    /**
+     * The title of the bookmark or folder.
+     */
+    title: string;
+    /**
+     * The unique URL associated with a bookmark. Is undefined for folders.
+     */
+    url?: string;
+    /**
+     * When this bookmark or folder was created, in milliseconds since the epoch.
+     */
+    dateCreated: number;
+    /**
+     * The favicon to display next to titles for bookmarks. When no icon or a
+     * broken icon is provided, the default globe icon will be used instead. Is
+     * undefined for folders.
+     */
+    favIcon?: string;
+    /**
+     * The id of the parent folder that contains a bookmark. Is undefined for the
+     * root node.
+     */
+    parentId?: string;
+    /**
+     * The children of this node. Can only contain bookmarks. Is undefined for
+     * bookmarks.
+     */
+    children?: BookmarkNode[];
+}
+/**
+ * Request object to create a new bookmark node.
+ */
+export interface CreateBookmarkNodeRequest {
+    /**
+     * The title of the bookmark or folder.
+     */
+    title: string;
+    /**
+     * The unique URL associated with the bookmark. Omit for folders.
+     */
+    url?: string;
+    /**
+     * The favicon to display next to titles for bookmarks. When no icon or a
+     * broken icon is provided, the default globe icon will be used instead. Omit
+     * for folders.
+     */
+    favIcon?: string;
+    /**
+     * The id of the parent folder for this bookmark. Omit for bookmarks under
+     * "All Bookmarks" and folders.
+     */
+    parentId?: string;
+}
+export type UpdatedBookmarkNodeAttrs = {
+    /**
+     * The new title to apply to the bookmark/folder.
+     */
+    title?: string;
+    /**
+     * The id of the parent folder to move this bookmark to. Leave undefined to
+     * move bookmark under "All Bookmarks". Omit for folders.
+     */
+    parentId?: string;
+    /**
+     * The favicon to display next to titles for bookmarks. When no icon or a
+     * broken icon is provided, the default globe icon will be used instead. Omit
+     * for folders.
+     */
+    favIcon?: string;
+};
+/**
+ * Request object to update a bookmark node.
+ */
+export interface UpdateBookmarkNodeRequest {
+    /**
+     * The unique id of the bookmark.
+     */
+    id: string;
+    /**
+     * The object describing which attributes of the bookmark to update.
+     */
+    changes: UpdatedBookmarkNodeAttrs;
+}
 export {};

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

@@ -32,7 +32,8 @@ declare enum GeneralBrowserChannelActions {
     DuplicatePage = "duplicate-page",
     SetSelectedScheme = "set-selected-scheme",
     ShowBrowserIndicator = "show-browser-indicator",
-    SetSelectedLanguage = "set-selected-language"
+    SetSelectedLanguage = "set-selected-language",
+    RefreshBookmarksInternal = "refresh-bookmarks"
 }
 /**
  * All of the remote procedures that can be called in the
@@ -73,6 +74,7 @@ export declare const BrowserChannelAction: {
     SetSelectedScheme: GeneralBrowserChannelActions.SetSelectedScheme;
     ShowBrowserIndicator: GeneralBrowserChannelActions.ShowBrowserIndicator;
     SetSelectedLanguage: GeneralBrowserChannelActions.SetSelectedLanguage;
+    RefreshBookmarksInternal: GeneralBrowserChannelActions.RefreshBookmarksInternal;
 };
 export type BrowserChannelAction = typeof BrowserChannelAction;
 export {};

package/common/src/api/protocol/workspace-platform.d.ts

@@ -72,6 +72,7 @@ export declare enum WorkspacePlatformChannelAction {
     SearchSitesInternal = "searchSitesInternal",
     GetCuratedContentInternal = "getCuratedContentInternal",
     HandleRequestNavigationInternal = "handleRequestNavigationInternal",
+    RefreshBookmarksInternal = "refreshBookmarksInternal",
     GetNotificationsConfig = "getNotificationsConfig"
 }
 export type PlatFormSupportedFeatures = boolean | {

package/common/src/api/theming.d.ts

@@ -1,6 +1,6 @@
 import type { DefaultTheme } from 'styled-components';
 import type OpenFin from '@openfin/core';
-import { ThemeSet } from '@openfin/ui-library';
+import { ColorSchemeType, ThemeSet } from '@openfin/ui-library';
 import { ColorSchemeOptionType } from '../../../client-api-platform/src/shapes';
 export type WorkspaceComponentSetSelectedSchemePayload = {
     newScheme: ColorSchemeOptionType;
@@ -246,3 +246,4 @@ export declare const OpenFinDarkTheme: {
 export declare const computeThemes: (customThemes: CustomThemes, storedScheme?: ColorSchemeOptionType) => ComputedThemes;
 export declare const getComputedPlatformTheme: (platformIdentity: OpenFin.Identity) => Promise<ComputedTheme>;
 export declare const setSelectedScheme: (ctx: ColorSchemeOptionType) => Promise<void>;
+export declare const getComputedScheme: (identity?: OpenFin.Identity) => Promise<Exclude<ColorSchemeType, 'system'>>;

package/common/src/api/workspace-events.d.ts

@@ -0,0 +1,49 @@
+import { NavigatePayload } from '../../../common/src/utils/navigate';
+import { ProviderConnectionPayload, ProviderDisconnectionPayload, ProviderUpdatePayload } from './provider';
+/**
+ * All Workspace related events that can be emitted or listened to
+ * by the Workspace Provider or any of the workspace components
+ */
+type EventTypeTypes = {
+    /**
+     * Emitted when a search is invoked.
+     */
+    'search-invoked': [string];
+    /**
+     * Emitted when a new provider is connected.
+     *
+     * For example, when a Dock Provider is successfully registered by the platform provider
+     */
+    'provider-connected': [ProviderConnectionPayload];
+    /**
+     * Emitted when a provider is disconnected.
+     *
+     * For example, when a Dock Provider is deregistered by the platform provider
+     */
+    'provider-disconnected': [ProviderDisconnectionPayload];
+    /**
+     * Emitted when a provider is updated.
+     *
+     * For example, when a Dock Provider is updated by the platform provider
+     */
+    'provider-updated': [ProviderUpdatePayload];
+    /**
+     * Emmitted when notifications is created or destroyed.
+     */
+    'update-notification-running-status': [];
+    /**
+     * Emitted when the list of search providers has been updated.
+     */
+    'search-provider-list-updated': [];
+    /**
+     * Emmitted when a component is created or destroyed.
+     */
+    'component-lifecycle-update': [];
+    /**
+     * Emitted when component should be navigated to.
+     * Contains the target provider ID and the component name.
+     */
+    'component-navigation': [NavigatePayload];
+};
+export declare const addListener: <EventKey extends keyof EventTypeTypes>(event: EventKey, listener: (...payload: EventTypeTypes[EventKey]) => void) => void, removeListener: <EventKey extends keyof EventTypeTypes>(event: EventKey, listener: (...payload: EventTypeTypes[EventKey]) => void) => void, emit: <EventKey extends keyof EventTypeTypes>(event: EventKey, ...payload: EventTypeTypes[EventKey]) => Promise<void>;
+export {};