@openfin/workspace 19.3.1 → 19.3.3

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

@@ -0,0 +1,16 @@
+import OpenFin from '@openfin/core';
+import { BrowserSearchMenuKeyboardEvent } from '../../../../common/src/utils/popup-window';
+import type { AttachedPageInternal } from '../../../../common/src/api/pages/shapes';
+import { SearchViewExpansionState } from '../../components/ControlBar/LeftControlsContainer/EnterpriseNavigationContainer/AddressBar/AddressBar';
+/**
+ * Custom hook that sends messages to the search view with updates about the browser window's views, search text changes, and whether
+ * the address search view should expand.
+ *
+ * @param {OpenFin.Identity[]} selectedViews - Array of currently selected views in the browser window.
+ * @param {BroadcastChannel} searchMenuChannel - The broadcast channel used to communicate with the search results view.
+ * @param {AttachedPageInternal} activePage - Object representing the currently active page in the browser window.
+ * @param {SearchViewExpansionState} shouldExpandMenu - Object with boolean indicating if the search results view should expand and the method of expansion.
+ * @param {string} searchText - String representing the current text in the address input.
+ * @param {BrowserSearchMenuKeyboardEvent} keyboardEvent - Object representing keyboard event to send to search results view to shift focus or interact with results.
+ */
+export declare const usePostMessageToSearchMenuView: (selectedViews: OpenFin.Identity[], searchMenuChannel: BroadcastChannel, activePage: AttachedPageInternal, shouldExpandMenu: SearchViewExpansionState, searchText: string, keyboardEvent: BrowserSearchMenuKeyboardEvent) => void;

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

@@ -0,0 +1,3 @@
+import { OpenFin } from '@openfin/core';
+import { WindowIdentity } from '../../../../common/src/utils/window';
+export declare const useProcessChildContentBlockEvent: (browserWindow: OpenFin.Window, currentOFIdentity: WindowIdentity) => void;

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

@@ -0,0 +1,16 @@
+import type OpenFin from '@openfin/core';
+import { SecureIconState } from '../../../../browser/src/components/ControlBar/LeftControlsContainer/EnterpriseNavigationContainer/AddressBar/AddressBar';
+/**
+ * Custom hook that manages the contents of the address input as users interact with the browser and navigate views.
+ * This hook handles the auto-focusing the address input on the landing page, registers handlers for view URL changes,
+ * and manages the state of the secure icon displayed next to valid addresses.
+ *
+ * @param {string} searchText - String representing the current text in the address input.
+ * @param {OpenFin.Identity[]} selectedViews - Array of currently selected views in the browser window.
+ * @param {React.MutableRefObject<HTMLInputElement>} addressBarInputRef - Ref object associated with the address input DOM element.
+ * @param {SecureIconState} isSecure - Object describing whether the currently focused view's site is secure and whether to show an icon in the address bar.
+ * @param {Dispatch<SetStateAction<SearchViewExpansionState>>} setShouldExpandMenu - Function that updates whether the menu should expand and the method of expansion.
+ * @param {React.Dispatch<React.SetStateAction<SecureIconState>>} setIsSecure - Function that updates whether the currently focused view's site is secure and whether to show an icon in the address bar.
+ */
+declare const useSearchMenuViewLifecycleManager: (searchText: string, selectedViews: OpenFin.Identity[], addressBarInputRef: React.MutableRefObject<HTMLInputElement>, isSecure: SecureIconState, setSearchText: React.Dispatch<React.SetStateAction<string>>, setIsSecure: React.Dispatch<React.SetStateAction<SecureIconState>>) => void;
+export default useSearchMenuViewLifecycleManager;

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,14 @@
+import { Dispatch, SetStateAction } from 'react';
+import { OpenFin } from '@openfin/core';
+import { SearchViewExpansionState } from '../../../../browser/src/components/ControlBar/LeftControlsContainer/EnterpriseNavigationContainer/AddressBar/AddressBar';
+/**
+ * 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 {React.MutableRefObject<HTMLInputElement>} addressBarInputRef - Ref object associated with the address input DOM element.
+ * @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, addressBarInputRef: React.MutableRefObject<HTMLInputElement>, 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/app-directory.d.ts

@@ -6,8 +6,8 @@ import type { LaunchAppRequest, SearchSitesRequest, SearchSitesResponse, Site }
  * @param app the app directory entry.
  * @param opts launch options.
  */
-export declare function launchApp({ app, target }: LaunchAppRequest): Promise<void | OpenFin.View | OpenFin.Identity | OpenFin.Application | OpenFin.Platform>;
-export declare const enterpriseAppDirectoryChannelClient: () => Promise<import("../../../common/src/utils/channels").withDisconnectListener<OpenFin.ChannelClient>>;
+export declare function launchApp({ app, target }: LaunchAppRequest): Promise<void | OpenFin.Identity | OpenFin.Platform | OpenFin.View | OpenFin.Application>;
+export declare const enterpriseAppDirectoryChannelClient: () => Promise<OpenFin.ChannelClient>;
 export declare function getResults(payload: {
     req: SearchSitesRequest;
 } & {

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
@@ -1291,6 +1337,10 @@ export interface BrowserWindowFactory {
      * ```
      *
      * @param options the browser window creation options
+     * @remarks
+     * **View names are singleton**: It is not recommended to provide view names, but if they are provided, they can only be used by one view at a time.
+     *
+     * **Expected Behavior**: If a new view is created using the same view name as an already existing view, the new view will be created, with the view name, and the existing view will be destroyed.
      */
     createWindow(options: BrowserCreateWindowRequest): Promise<BrowserWindowModule>;
     /**
@@ -1611,6 +1661,10 @@ export interface WorkspacePlatformModule extends OpenFin.Platform {
      *   }
      * });
      * ```
+     * @remarks
+     * **View names are singleton**: It is not recommended to provide view names, but if they are provided, they can only be used by one view at a time.
+     *
+     * **Expected Behavior**: If a new view is created using the same view name as an already existing view, the new view will be created, with the view name, and the existing view will be destroyed.
      */
     createView(viewOptions: Partial<OpenFin.ViewOptions> | BrowserCreateViewRequest, target?: OpenFin.CreateViewTarget, targetView?: OpenFin.Identity): Promise<OpenFin.View>;
     /**
@@ -1728,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.
      */
@@ -1740,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 {
     /**
@@ -1980,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>;