@openfin/workspace 19.3.0 → 19.3.2

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

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

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

@@ -1291,6 +1291,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 +1615,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>;
     /**

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

package/common/src/components/Icon/CustomIcon.d.ts

@@ -0,0 +1,15 @@
+import React from 'react';
+import { IconSizeType } from '@openfin/ui-library';
+/**
+ * Simple and reusable icon component. The required prop is an iconURL.
+ */
+interface CustomIconProps {
+    iconURL?: string;
+    testId?: string;
+    size?: IconSizeType;
+    description?: string;
+    backgroundColor?: string;
+    applyThemeColor?: boolean;
+}
+export declare const CustomIcon: React.FC<CustomIconProps>;
+export {};

package/common/src/hooks/context.d.ts

@@ -0,0 +1,50 @@
+/// <reference types="react" />
+import { ProviderInfoInternal, ProviderType } from '../../../common/src/api/provider';
+export type ProviderContext<T extends ProviderType = any> = {
+    /**
+     * The currently active provider.
+     */
+    activeProvider: ProviderInfoInternal<T> | undefined;
+    /**
+     * Sets the active provider.
+     * @param provider The provider to set as active.
+     */
+    setActiveProvider: (provider: ProviderInfoInternal<T>) => void;
+    /**
+     * All providers currently available.
+     */
+    providers: ProviderInfoInternal<T>[];
+    /**
+     * Updates a provider.
+     * Dispatches a channel action back to the Workspace Provider.
+     *
+     * @param updatedProvider The updated provider.
+     * @returns A promise that resolves when the provider has been updated.
+     */
+    updateProvider: (updatedProvider: ProviderInfoInternal<T>) => Promise<void>;
+};
+/**
+ * A hook that returns data related to the active provider, and all providers
+ *
+ * A generic **must** be provided to specify the type of provider to return
+ *
+ * @example
+ * ```ts
+ * const { activeProvider, setActiveProvider, providers } = usePlatformProviders<'dock'>();
+ * ```
+ */
+export declare const usePlatformProviders: <T extends ProviderType = never>() => T extends never ? never : ProviderContext<T>;
+export declare const ProviderContext: <T extends ProviderType>({ children, providerType }: {
+    children?: React.ReactNode;
+    providerType: T;
+}) => JSX.Element;
+export declare const BrowserTypeContext: import("react").Context<{
+    isEnterprise?: boolean | null;
+}>;
+export declare const BrowserLayoutDragContext: import("react").Context<{
+    isAcceptingLayoutDrag: boolean;
+    setIsAcceptingLayoutDrag: (value: boolean) => void;
+}>;
+export declare const BrowserContext: ({ children }: {
+    children?: React.ReactNode;
+}) => JSX.Element;

package/common/src/hooks/usePlatformTheme.d.ts

@@ -0,0 +1,6 @@
+import type OpenFin from '@openfin/core';
+/**
+ * Set the current theme based on the platform identity provided.
+ * @param identity the platform identity.
+ */
+export declare const usePlatformTheme: (identity?: OpenFin.Identity) => void;

package/common/src/hooks/useSystemSchemeCheck.d.ts

@@ -0,0 +1,13 @@
+import { ColorSchemeType } from '@openfin/ui-library';
+/**
+ * Custom hook that checks the system color scheme and provides information about the current scheme.
+ *
+ * @returns An object containing the current color scheme, system color scheme, and a boolean indicating if the scheme is dark.
+ */
+interface SystemSchemeCheck {
+    currentScheme: Omit<ColorSchemeType, 'system'>;
+    systemScheme: Omit<ColorSchemeType, 'system'>;
+    isSchemeDark: boolean;
+}
+declare function useSystemSchemeCheck(): SystemSchemeCheck;
+export default useSystemSchemeCheck;

package/common/src/slices/environment.d.ts

@@ -0,0 +1,22 @@
+export interface EnvironmentRootState {
+    environment: {
+        isWindows: boolean;
+    };
+}
+export declare const getEnvironment: import("@reduxjs/toolkit").AsyncThunk<boolean, void, {}>;
+export declare const environmentSlice: import("@reduxjs/toolkit").Slice<{
+    isWindows: boolean;
+}, {
+    setEnvironment: (state: import("immer/dist/internal").WritableDraft<{
+        isWindows: boolean;
+    }>, action: {
+        payload: any;
+        type: string;
+    }) => void;
+}, "environment">;
+export declare const setEnvironment: import("@reduxjs/toolkit").ActionCreatorWithPayload<any, string>;
+export declare const selectIsWindows: (state: EnvironmentRootState) => boolean;
+declare const _default: import("redux").Reducer<{
+    isWindows: boolean;
+}>;
+export default _default;

package/common/src/slices/target-theming.d.ts

@@ -0,0 +1,56 @@
+import { ColorSchemeOptionType } from '../../../client-api-platform/src/shapes';
+import type { ComputedTheme } from '../api/theming';
+export interface TargetThemingRootState {
+    targetTheming: {
+        isFetchingTheme: boolean;
+        currentTheme: ComputedTheme | undefined;
+        hasTriedFetch: boolean;
+        currentScheme: ColorSchemeOptionType | undefined;
+    };
+}
+export declare const targetThemingSlice: import("@reduxjs/toolkit").Slice<{
+    isFetchingTheme: boolean;
+    currentTheme: ComputedTheme | undefined;
+    hasTriedFetch: boolean;
+    currentScheme: ColorSchemeOptionType | undefined;
+}, {
+    setTheme: (state: import("immer/dist/internal").WritableDraft<{
+        isFetchingTheme: boolean;
+        currentTheme: ComputedTheme | undefined;
+        hasTriedFetch: boolean;
+        currentScheme: ColorSchemeOptionType | undefined;
+    }>, action: {
+        payload: any;
+        type: string;
+    }) => void;
+    setIsFetchingTheme: (state: import("immer/dist/internal").WritableDraft<{
+        isFetchingTheme: boolean;
+        currentTheme: ComputedTheme | undefined;
+        hasTriedFetch: boolean;
+        currentScheme: ColorSchemeOptionType | undefined;
+    }>, action: {
+        payload: any;
+        type: string;
+    }) => void;
+    setCurrentScheme: (state: import("immer/dist/internal").WritableDraft<{
+        isFetchingTheme: boolean;
+        currentTheme: ComputedTheme | undefined;
+        hasTriedFetch: boolean;
+        currentScheme: ColorSchemeOptionType | undefined;
+    }>, action: {
+        payload: any;
+        type: string;
+    }) => void;
+}, "targetTheming">;
+export declare const setTheme: import("@reduxjs/toolkit").ActionCreatorWithPayload<any, string>, setIsFetchingTheme: import("@reduxjs/toolkit").ActionCreatorWithPayload<any, string>, setCurrentScheme: import("@reduxjs/toolkit").ActionCreatorWithPayload<any, string>;
+export declare const selectTargetTheming: (state: TargetThemingRootState) => ComputedTheme;
+export declare const selectCurrentScheme: (state: TargetThemingRootState) => ColorSchemeOptionType;
+export declare const selectHasTriedFetch: (state: TargetThemingRootState) => boolean;
+export declare const selectIsFetchingTheme: (state: TargetThemingRootState) => boolean;
+declare const _default: import("redux").Reducer<{
+    isFetchingTheme: boolean;
+    currentTheme: ComputedTheme;
+    hasTriedFetch: boolean;
+    currentScheme: ColorSchemeOptionType;
+}>;
+export default _default;

package/common/src/styles/svg-icons.d.ts

@@ -0,0 +1,7 @@
+/// <reference types="react" />
+export declare const StyledIcon: import("styled-components").StyledComponent<({ tabIndex, icon, children, size, containerSize, "data-testid": dataTestId, ...props }: import("@openfin/ui-library").IconProps) => JSX.Element, import("styled-components").DefaultTheme, {
+    disabled?: boolean;
+    isEnterprise?: boolean;
+    windowFocused?: boolean;
+}, never>;
+export declare const ThemedSVG: import("styled-components").StyledComponent<"svg", import("styled-components").DefaultTheme, {}, never>;

package/common/src/utils/a11y/index.d.ts

@@ -0,0 +1,3 @@
+export type HTMLElementWithAria = HTMLElement & {
+    ariaLabel: string | null;
+};

package/common/src/utils/custom-logo.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Custom React hook to check the accessibility of a custom logo image.
+ * This hook initiates an image load and returns a boolean value indicating
+ * whether the image is accessible or not.
+ *
+ * @param customLogoUrl The URL of the custom logo to check. If undefined, the hook immediately returns false.
+ * @returns A state value that is true if the custom logo is accessible and has loaded successfully, and false otherwise.
+ * @example
+ * ```jsx
+ * function Component() {
+ *   const logoAccessible = useCustomLogoAccessible('http://example.com/logo.png');
+ *   return logoAccessible ? <img src='http://example.com/logo.png' /> : <DefaultLogo />;
+ * }
+ * ```
+ */
+export declare const useCustomLogoAccessible: (customLogoUrl: string | undefined) => boolean;

package/common/src/utils/enterpriseBrowser.d.ts

@@ -6,3 +6,4 @@ export declare function formatUrl(url: string): string;
 export declare const getIsEnterpriseBrowser: (id?: OpenFin.Identity) => Promise<boolean>;
 export declare const getMenuWindowWidth: () => Promise<number>;
 export declare const isLandingPage: (url: string) => boolean;
+export declare const isLandingPageOrEmpty: (url: string) => boolean;

package/common/src/utils/interop.d.ts

@@ -0,0 +1,30 @@
+import type OpenFin from '@openfin/core';
+export declare enum InteropEventType {
+    JoinedContextGroup = "joined-context-group",
+    RemovedFromContextGroup = "removed-from-context-group"
+}
+type InteropEventPayload<E extends InteropEventType> = {
+    [InteropEventType.JoinedContextGroup]: {
+        viewIdentity: OpenFin.Identity;
+        contextGroupId: string;
+    };
+    [InteropEventType.RemovedFromContextGroup]: {
+        viewIdentity: OpenFin.Identity;
+    };
+}[E];
+export type InteropListener<EventType extends InteropEventType> = (payload: InteropEventPayload<EventType>) => void;
+/**
+ * Returns contextGroup data.
+ * @returns Promise<ContextGroup[]>
+ */
+export declare function getContextGroups(): Promise<OpenFin.ContextGroupInfo[]>;
+export declare const joinContextGroup: (viewIdentity: OpenFin.Identity, contextGroupId: string) => Promise<void>;
+export declare const removeFromGroup: (viewIdentity: OpenFin.Identity) => Promise<void>;
+export declare function getViewContextGroupId(viewIdentity: OpenFin.Identity): Promise<string | null | undefined>;
+/**
+ * Listen for interop events.
+ * @param event the interop event to listen for.
+ * @param listener the function to call when the event occurs.
+ */
+export declare const addInteropListener: <Event_1 extends InteropEventType>(event: Event_1, listener: InteropListener<Event_1>) => Promise<void>;
+export {};

package/common/src/utils/layout.d.ts

@@ -65,6 +65,12 @@ export declare const cloneViewComponentWithoutName: (componentState: any) => any
  * @returns A copy of the layout with names removed
  */
 export declare const cloneLayoutAndRemoveNames: (layout: PageLayout) => any;
+/**
+ * Deep clones a layout and removes generated view names.
+ * @param layout The Layout to be cloned
+ * @returns A copy of the layout with generated names removed
+ */
+export declare const cloneLayoutAndRemoveGeneratedNames: (layout: PageLayout) => any;
 export declare const mapContentComponentState: (content: OpenFin.LayoutContent) => OpenFin.LayoutComponent['componentState'][];
 export declare const getLayoutWithSingleView: (title: string, url: string, winIdentity?: OpenFin.Identity) => Promise<any>;
 export declare const layoutNameInitializedMap: Map<string, boolean>;

package/common/src/utils/navigate.d.ts

@@ -0,0 +1,8 @@
+import type OpenFin from '@openfin/core';
+import { ComponentName } from '../../../common/src/utils/usage-register';
+export interface NavigatePayload {
+    componentName: ComponentName;
+    platformIdentity: OpenFin.Identity;
+    providerId?: string;
+}
+export declare const navigateTo: (componentName: ComponentName, platformIdentity: OpenFin.Identity, providerId?: string) => Promise<void>;