@openfin/workspace 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-platform/shapes").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-platform/shapes").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-platform/shapes").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/init/override-callback/enterprise-page-required-layout-settings.d.ts

@@ -0,0 +1,5 @@
+import { PageLayout } from '../../../../common/src/api/pages/shapes';
+export type EnterprisePageRequiredLayoutSettings = {
+    newTabButtonUrl: string;
+};
+export declare const applyEnterprisePageRequiredLayoutSettings: (requiredSettings: EnterprisePageRequiredLayoutSettings, layout: PageLayout) => void;

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

@@ -4,7 +4,7 @@ import type { AnalyticsEvent, AnalyticsEventInternal } from '../../common/src/ut
 import { CustomActionSpecifier, CustomButtonConfig } from '../../common/src/api/action';
 import { Resource } from '../../common/src/api/i18next';
 import { TrackedSite } from '../../common/src/api/pages/idb';
-import type { AddDefaultPagePayload, AttachedPage, CopyPagePayload, HandlePagesAndWindowClosePayload, HandlePagesAndWindowCloseResult, HandleSaveModalOnPageClosePayload, Page, PageWithUpdatableRuntimeAttribs, SaveModalOnPageCloseResult, ShouldPageClosePayload, ShouldPageCloseResult, ViewsPreventingUnloadPayload } from '../../common/src/api/pages/shapes';
+import { AddDefaultPagePayload, AttachedPage, BookmarkNode, CopyPagePayload, CreateBookmarkNodeRequest, HandlePagesAndWindowClosePayload, HandlePagesAndWindowCloseResult, HandleSaveModalOnPageClosePayload, Page, PageWithUpdatableRuntimeAttribs, SaveModalOnPageCloseResult, ShouldPageClosePayload, ShouldPageCloseResult, UpdateBookmarkNodeRequest, 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';
@@ -170,6 +170,12 @@ export declare enum EnterpriseMainContextMenuOptionType {
     Print = "Print",
     Pin = "Pin"
 }
+/** @internal */
+export declare enum BookmarkItemContextMenuOptionType {
+    EditName = "Edit Name",
+    Move = "Move",
+    Delete = "Delete"
+}
 /**Shape of the data property of a global context menu template item */
 export interface GlobalContextMenuItemData extends ContextMenuItemData {
     type: GlobalContextMenuOptionType;
@@ -189,6 +195,13 @@ export interface AppearanceContextMenuItemData extends GlobalContextMenuItemData
 export type GlobalContextMenuItemTemplate = OpenFin.MenuItemTemplate<GlobalContextMenuItemData>;
 /** @internal */
 export type EnterpriseMainContextMenuItemTemplate = OpenFin.MenuItemTemplate<EnterpriseMainContextMenuItemData>;
+/** @internal */
+export interface BookmarkItemContextMenuItemData extends ContextMenuItemData {
+    type: BookmarkItemContextMenuOptionType;
+    parentId?: string;
+}
+/** @internal */
+export type BookmarkItemContextMenuItemTemplate = OpenFin.MenuItemTemplate<BookmarkItemContextMenuItemData>;
 /**Shape of the data property of a page tab context menu template item */
 export interface PageTabContextMenuItemData extends ContextMenuItemData {
     type: PageTabContextMenuOptionType;
@@ -1084,6 +1097,39 @@ export interface BrowserWindowModule {
     _getCuratedContent(req?: any): Promise<Site[]>;
     /** @internal */
     _handleRequestNavigation(args: NavigationRequest): Promise<void>;
+    _bookmarks: BrowserBookmarks;
+}
+export interface BrowserBookmarks {
+    /**
+     * Implementation for creating a new bookmark node.
+     * @param req The request object specifying the attributes of the new node.
+     * @internal
+     */
+    _createBookmarkNode(req: CreateBookmarkNodeRequest): Promise<BookmarkNode>;
+    /**
+     * Implementation for getting a bookmark node.
+     * @param string The unique id of the node. Returns root node when left undefined.
+     * @internal
+     */
+    _getBookmarkNode(id?: string): Promise<BookmarkNode | undefined>;
+    /**
+     * Implementation for searching for a bookmark node.
+     * @param query The string used to filter bookmark nodes by title or, in the case of bookmarks, URL, as well.
+     * @internal
+     */
+    _searchBookmarkNodes(query: string): Promise<BookmarkNode[]>;
+    /**
+     * Implementation for updating a bookmark node.
+     * @param req The request object with the updated attributes of the targeted node.
+     * @internal
+     */
+    _updateBookmarkNode(req: UpdateBookmarkNodeRequest): Promise<BookmarkNode | undefined>;
+    /**
+     * Implementation for deleting a bookmark node.
+     * @param id The unique id of the node.
+     * @internal
+     */
+    _deleteBookmarkNode(id: string): Promise<void>;
 }
 /**
  * @internal
@@ -1736,6 +1782,12 @@ export interface WorkspacePlatformModule extends OpenFin.Platform {
      * Implementation for getting the notifications workspace platform configuration.
      */
     getNotificationsConfig(): Promise<NotificationsCustomManifestOptions | undefined>;
+    _raiseAnalytics(events: AnalyticsEventInternal[]): Promise<void>;
+    /**
+     * Triggers all browser windows to refresh bookmarks data
+     * @internal
+     */
+    _refreshBookmarksInternal(): Promise<void>;
     /**
      * The browser window factory for the Workspace Platform.
      */
@@ -1748,7 +1800,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 {
     /**
@@ -1988,6 +2039,8 @@ export interface WorkspacePlatformProvider extends OpenFin.PlatformProvider {
     }): Promise<SearchSitesResponse>;
     /** @internal */
     handleRequestNavigationInternal(req: NavigationRequest): Promise<void>;
+    /** @internal */
+    refreshBookmarksInternal(): Promise<void>;
 }
 /**
  * The origins from which a custom action can be invoked

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 {};