@openfin/workspace-platform 5.2.0 → 5.5.0

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

@@ -0,0 +1,101 @@
+/// <reference types="openfin-adapter/fin" />
+import type { AttachedPage, AttachPagesToWindowPayload, DetachPagesFromWindowPayload, ReorderPagesForWindowPayload, SetActivePageForWindowPayload, UpdatePageForWindowPayload } from './shapes';
+/**
+ * All of the remote procedures that can be called in the
+ * platform window's address space regarding attached pages.
+ */
+export declare enum ChannelAction {
+    GetPages = "get-pages",
+    GetActivePageForWindow = "get-active-page-for-window",
+    AttachPagesToWindow = "attach-pages-to-window",
+    DetachPagesFromWindow = "detach-pages-from-window",
+    SetActivePageForWindow = "set-active-page-for-window",
+    RenamePage = "rename-page",
+    ReorderPagesForWindow = "reorder-pages-for-window",
+    UpdatePageForWindow = "update-page-for-window",
+    UpdatePagesWindowOptions = "update-pages-window-options",
+    IsDetachingPages = "is-detaching-pages",
+    IsActivePageChanging = "is-active-page-changing"
+}
+export declare enum EventType {
+    AttachedPagesToWindow = "attached-pages-to-window",
+    DetachedPagesFromWindow = "detached-pages-from-window"
+}
+export declare const getWindowChannelId: (identity: OpenFin.Identity) => string;
+export declare const getEventEmitter: (identity: OpenFin.Identity) => {
+    emit: (event: string | number, ...payload: any[]) => Promise<void>;
+    addListener: (event: string | number, listener: import("@common/utils/shared-emitter").Listener) => void;
+    removeListener: (event: string | number, listener: import("@common/utils/shared-emitter").Listener) => void;
+    once: (event: string | number, listener: import("@common/utils/shared-emitter").Listener) => void;
+};
+/**
+ * Get the pages attached to a window.
+ * @param identity the identity of the window to get the attached pages of.
+ * @returns the pages attached to the window.
+ */
+export declare const getPages: (identity: OpenFin.Identity) => Promise<AttachedPage[]>;
+/**
+ * Get the active attached page for the specified window.
+ * @param identity the window identity to get the active attached page of.
+ * @returns the active attached page for the window.
+ */
+export declare const getActivePageForWindow: (identity: OpenFin.Identity) => Promise<AttachedPage>;
+/**
+ * Set the active attached page for the specified window.
+ * @param identity the window identity to set the active attached page of.
+ */
+export declare const setActivePageForWindow: (payload: SetActivePageForWindowPayload) => Promise<void>;
+/**
+ * Attach a page to an open window.
+ * If the page is already attached to a window, an error will be thrown.
+ *
+ * @param payload the attach pages to window payload.
+ */
+export declare const attachPagesToWindow: (payload: AttachPagesToWindowPayload) => Promise<void>;
+/**
+ * Detach pages from the window they are currently attached to.
+ * A detached page will not have its views cleaned up.
+ *
+ * @param payload the detach pages from window payload.
+ */
+export declare const detachPagesFromWindow: (payload: DetachPagesFromWindowPayload) => Promise<void>;
+export interface RenamePagePayload {
+    /** The OF window identity the page is attached to. */
+    identity: OpenFin.Identity;
+    /** The id of the page to change the name of. */
+    pageId: string;
+    /** The new title of the page. */
+    newTitle: string;
+}
+/**
+ * Rename an attached page.
+ * The page must be attached to the specified window.
+ *
+ * @param page the page to rename.
+ */
+export declare const renamePage: (payload: RenamePagePayload) => Promise<void>;
+/**
+ * Reorder pages attached to an open window.
+ * @param payload the reorder pages for window payload.
+ */
+export declare const reorderPagesForWindow: (payload: ReorderPagesForWindowPayload) => Promise<void>;
+/**
+ * Update a page attached to a window.
+ * @param payload the update page for window payload.
+ */
+export declare const updatePageForWindow: (payload: UpdatePageForWindowPayload) => Promise<void>;
+/**
+ * Forces a window to save its attached page state to window options.
+ * @param identity the identity of the window to save the pages of in window options.
+ */
+export declare const updatePagesWindowOptions: (identity: OpenFin.Identity) => Promise<void>;
+/**
+ * Check if the window identity is currently detaching pages.
+ * @param identity the OF window identity to check.
+ */
+export declare const isDetachingPages: (identity: OpenFin.Identity) => Promise<boolean>;
+/**
+ * Check if the window identity is in the middle of changing active pages.
+ * @param identity the OF window identity to check.
+ */
+export declare const isActivePageChanging: (identity: OpenFin.Identity) => Promise<boolean>;

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

@@ -0,0 +1,12 @@
+import type { Page } from '../../../../common/src/api/pages/shapes';
+export declare const store: import("idb-keyval").UseStore;
+export declare function getPage(id: string): Promise<Page>;
+export declare function getPageList(filter?: string): Promise<Page[]>;
+export declare function createPage({ page }: {
+    page: any;
+}): Promise<void>;
+export declare function deletePage(id: string): Promise<void>;
+export declare function updatePage({ pageId, page }: {
+    pageId: any;
+    page: any;
+}): Promise<void>;

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

@@ -0,0 +1,22 @@
+import { LayoutExtended } from '../../../../common/src/utils/layout';
+import type { AttachedPage, Page, PageLayout, PageWithUpdatableRuntimeAttribs } from './shapes';
+export declare function getLegacyPages(): Promise<Page[]>;
+export declare function cleanPage(page: AttachedPage): Page;
+/**
+ * Get a page layout.
+ * @param layout the layout to add details to.
+ * @returns the layout with extra details.
+ */
+export declare const getPageLayout: (layout: any) => Promise<PageLayout>;
+/**
+ * Generates a Page object which represents a page.
+ * @param title the title for the page.
+ * @param layout the layout for the page.
+ */
+export declare const makePage: (title: string, layout: LayoutExtended) => Promise<PageWithUpdatableRuntimeAttribs>;
+/**
+ * Clone a page.
+ * @param page the page to clone.
+ * @returns a clone of the given page.
+ */
+export declare const clonePage: (page: Page) => Promise<PageWithUpdatableRuntimeAttribs>;

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

@@ -0,0 +1,16 @@
+import type { AttachedPage, PageLayout } from '../../../../common/src/api/pages/shapes';
+interface Workstack {
+    id: string;
+    name: string;
+    isReadOnly: boolean;
+    layout: PageLayout;
+    isActive: boolean;
+}
+export declare function convertWorkstackToAttachedPage(workstack: Workstack & AttachedPage): AttachedPage;
+/**
+ * Attempts to fix any misconfigurations in a list of attached pages.
+ * @param pages the pages to fix.
+ * @returns the fixed pages.
+ */
+export declare const fixAttachedPages: (pages: AttachedPage[]) => AttachedPage[];
+export {};

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

@@ -0,0 +1,77 @@
+/// <reference types="openfin-adapter/fin" />
+import type { LayoutExtended } from '../../utils/layout';
+export interface PageLayoutDetails {
+    /** The id of the machine that created the page. */
+    machineId: string;
+    /** The name of the machine that created the page. */
+    machineName?: string;
+}
+export declare type PageLayout = LayoutExtended & {
+    layoutDetails?: PageLayoutDetails;
+};
+export interface Page {
+    /** A UI friendly title for the page. */
+    title: string;
+    /** The unique ID of the page. */
+    pageId: string;
+    /** An optional UI friendly description of the page. */
+    description?: string;
+    /** A optional UI friendly tooltip for the page. */
+    tooltip?: string;
+    /** True if the page is read only. In this state, the page is locked and cannot be unlocked. */
+    isReadOnly?: boolean;
+    /** The layout of the page. */
+    layout: PageLayout;
+}
+declare type AttachedPageMetadata = {
+    /** The window the page is currently attached to. */
+    parentIdentity?: OpenFin.Identity;
+    /** True if the page is the currently active page for its parent window. */
+    isActive?: boolean;
+    /** True if the page has unsaved changes. */
+    hasUnsavedChanges?: boolean;
+};
+export declare type AttachedPage = Page & AttachedPageMetadata;
+export declare type PageWithUpdatableRuntimeAttribs = Page & Pick<AttachedPage, 'hasUnsavedChanges'>;
+export interface DetachPagesFromWindowPayload {
+    /** The OF window identity to detach the pages from. */
+    identity: OpenFin.Identity;
+    /** The ids of the pages to detach. */
+    pageIds: string[];
+}
+export interface SetActivePageForWindowPayload {
+    /** The OF window identity to set the active page of. */
+    identity: OpenFin.Identity;
+    /**
+     * The id of the page to set as active.
+     * The page must be attached to the target window.
+     */
+    pageId: string;
+}
+export interface ReorderPagesForWindowPayload {
+    /** The OF window identity the pages to change the order of. */
+    identity: OpenFin.Identity;
+    /** The ordered ids of the attached pages. */
+    pageIds: string[];
+}
+export interface UpdatePageForWindowPayload {
+    /** The OF window identity the pages to change the order of. */
+    identity: OpenFin.Identity;
+    /** The id of the attached page to update. */
+    pageId: string;
+    /** The partial updated state of the page. */
+    page: Partial<PageWithUpdatableRuntimeAttribs>;
+}
+export interface AttachPagesToWindowPayload {
+    /** The OF window identity to attach the pages to. */
+    identity: OpenFin.Identity;
+    /** The pages to attach. */
+    pages: PageWithUpdatableRuntimeAttribs[];
+}
+export interface GetSavedPageMetadataPayload {
+    /** The OF window identity to attach the pages to. */
+    identity: OpenFin.Identity;
+    /** The id of the page to get the save state of. */
+    pageId: string;
+}
+export {};

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

@@ -0,0 +1,64 @@
+/// <reference types="openfin-adapter/fin" />
+/** The name of the channel for the centralized workspace protocol. */
+export declare const channelName = "__of_workspace_protocol__";
+/**
+ * All of the remote procedures that can be called in the
+ * Workspace Provider's address space.
+ *
+ * When adding a new channel action make sure to register a
+ * handler for the remote procedure in the Workspace Provider.
+ * All of the registered channel action handlers can be found here:
+ * @see link: [Provider Protocol Handlers](https://github.com/openfin/workspace/provider/src/api/protocol.ts)
+ */
+export declare enum ChannelAction {
+    RegisterStorefrontProvider = "register-storefront-provider",
+    DeregisterStorefrontProvider = "deregister-storefront-provider",
+    GetStorefrontProviders = "get-storefront-providers",
+    HideStorefront = "hide-storefront",
+    GetStorefrontProviderApps = "get-storefront-provider-apps",
+    GetStorefrontProviderLandingPage = "get-storefront-provider-landing-page",
+    GetStorefrontProviderFooter = "get-storefront-provider-footer",
+    GetStorefrontProviderNavigation = "get-storefront-provider-navigation",
+    LaunchStorefrontProviderApp = "launch-storefront-provider-app",
+    ShowStorefront = "show-storefront",
+    CreateStorefrontWindow = "create-storefront-window",
+    ShowHome = "show-home",
+    HideHome = "hide-home",
+    AssignHomeSearchContext = "assign-home-search-context",
+    GetLegacyPages = "get-legacy-pages",
+    GetLegacyWorkspaces = "get-legacy-workspaces",
+    GetComputedPlatformTheme = "get-computed-platform-theme"
+}
+export interface ChannelClient extends OpenFin.ChannelClient {
+    dispatch: (action: ChannelAction, payload: any) => Promise<any>;
+}
+/**
+ * Get a channel client for the centralized Workspace protocol.
+ *
+ * The channel client is automatically connected to the Workspace Provider,
+ * in which acts as a centralized location for executing Workspace API logic.
+ *
+ * The channel client can execute remote procedures on the provider via its `dispatch` function.
+ * A call to the `dispatch` function will block until the channel action has concluded execution
+ * in the Workspace Provider's address space.
+ * For a list of supported procedures, see the `ChannelAction` enum.
+ *
+ * @returns the channel client for the centralized workspace protocol.
+ */
+export declare const getChannelClient: () => Promise<ChannelClient>;
+/**
+ * Returns true if the current application was launched via a library (such as the Client APIs).
+ * Otherwise, returns false.
+ */
+export declare const isLaunchedViaLib: () => Promise<boolean>;
+/**
+ * Launches the Workspace Provider.
+ * If the Workspace Provider is already running, does nothing.
+ */
+export declare const launchProvider: () => Promise<void>;
+/**
+ * Launches the Workspace provider if it is not running.
+ * Then gets a Channel Client that is connected to the Workspace Provider.
+ * @returns the Channel Client that is connected to the Workspace Provider.
+ */
+export declare const getChannelClientAndLaunchProvider: () => Promise<ChannelClient>;

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

@@ -0,0 +1,62 @@
+/// <reference types="openfin-adapter/fin" />
+import type { ThemePaletteSet } from '@openfin/ui-library';
+export interface ComputedThemes extends Array<ComputedTheme> {
+}
+export interface ComputedTheme {
+    label: string;
+    logoUrl?: string;
+    theme: ThemePaletteSet;
+}
+export interface CustomThemes extends Array<CustomThemeOptions> {
+}
+export interface CustomThemeOptions {
+    label: string;
+    logoUrl?: string;
+    palette: CustomPaletteSet;
+}
+export interface DefaultPaletteSet {
+    brandPrimary: string;
+    brandSecondary: string;
+    backgroundPrimary: string;
+}
+export interface CustomPaletteSet extends DefaultPaletteSet {
+    functional1?: string;
+    functional2?: string;
+    functional3?: string;
+    functional4?: string;
+    functional5?: string;
+    functional6?: string;
+    functional7?: string;
+    functional8?: string;
+    functional9?: string;
+    functional10?: string;
+    statusSuccess?: string;
+    statusWarning?: string;
+    statusCritical?: string;
+    statusActive?: string;
+    inputBackground?: string;
+    inputColor?: string;
+    inputPlaceholder?: string;
+    inputDisabled?: string;
+    inputFocused?: string;
+    textDefault?: string;
+    textHelp?: string;
+    textInactive?: string;
+    background1?: string;
+    background2?: string;
+    background3?: string;
+    background4?: string;
+    background5?: string;
+    background6?: string;
+}
+/**
+ * computeThemes()
+ * Accepts the array of registered CustomThemes objects
+ * Creates a light and dark palette from a tempalte overriding with custom options
+ * Uses createTheme to build theme object
+ * Creates a ThemePaletteSet
+ * @param customPalettes
+ * @returns theme object ready to be applied to the UI
+ */
+export declare const computeThemes: (customPalettes: CustomThemes) => ComputedThemes;
+export declare const getComputedPlatformTheme: (platformIdentity: OpenFin.Identity) => Promise<ComputedTheme>;

package/common/src/api/workspaces/index.d.ts

@@ -0,0 +1,7 @@
+/// <reference types="openfin-adapter/fin" />
+export interface Workspace {
+    workspaceId: string;
+    title: string;
+    snapshot: OpenFin.Snapshot;
+}
+export declare const getLegacyWorkspaces: () => Promise<Workspace[]>;

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

@@ -0,0 +1,38 @@
+/// <reference types="openfin-adapter/fin" />
+export declare enum ApplicationUUID {
+    /**
+     * The UUID of workspace.
+     * Home is a part of this application.
+     */
+    Workspace = "openfin-browser"
+}
+export interface ApplicationEvent {
+    viewIdentity?: OpenFin.Identity;
+    name?: string;
+    uuid?: string;
+}
+export declare type ApplicationListener = (ev: ApplicationEvent) => void;
+export declare enum ApplicationEventType {
+    RunRequested = "run-requested",
+    WindowOptionsChanged = "window-options-changed",
+    WindowClosed = "window-closed",
+    WindowCreated = "window-created"
+}
+export declare enum LaunchModeType {
+    FinProtocol = "fin-protocol"
+}
+export declare type ApplicationInfoExtended = OpenFin.ApplicationInfo & {
+    initialOptions: OpenFin.ApplicationInfo['initialOptions'] & {
+        userAppConfigArgs: any;
+    };
+};
+export declare const currentOFAppIdentity: {
+    uuid: string;
+    name: string;
+};
+export declare const workspaceOFAppIdentity: {
+    name: ApplicationUUID;
+    uuid: ApplicationUUID;
+};
+export declare const getCurrentOFApplication: () => import("openfin-adapter").Application;
+export declare const getWorkspaceOFApplication: () => import("openfin-adapter").Application;

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

@@ -0,0 +1,8 @@
+/**
+ * Make a function that connects to a channel.
+ * If already connected to the channel, will return the channel connection.
+ * If disconnected from the channel, will automatically reconnect.
+ * @param channelName the name of the channel to connect to.
+ * @returns the function to connect to the channel.
+ */
+export default function makeGetChannelClient(channelName: string): () => Promise<import("openfin-adapter").ChannelClient>;

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

@@ -0,0 +1,16 @@
+declare const makeDebouncedFunc: <T extends (...args: any[]) => Promise<any>>(func: T, debounceTimeout?: number) => T;
+/**
+ * Debounce a specified function.
+ *
+ * When the debounced function is called, the underlying wrapped function
+ * will be called.
+ *
+ * If the function is called again while the promise returned by the wrapped
+ * function is still resolving, the call will be blocked until the promise has
+ * resolved.
+ *
+ * Once the promise has been resolved, the wrapped function will be called again
+ * after a specified debounce timeout.
+ *
+ */
+export default makeDebouncedFunc;

package/common/src/utils/defer-auto-show.d.ts

@@ -0,0 +1,18 @@
+/// <reference types="openfin-adapter/fin" />
+interface InternalWindowOptions extends OpenFin.PlatformWindowCreationOptions {
+    workspacePlatform: OpenFin.WindowOptions['workspacePlatform'] & {
+        _internalAutoShow: boolean;
+    };
+}
+/**
+ * Apply options to a window's options that will disallow the Core from auto showing the window.
+ * Instead, a script within the window itself must handle showing the window if deferred auto showing is enabled.
+ * When it comes time to show the window, the script can auto show if deferred by simply calling the `autoShowIfDeferred` function.
+ * @param opts the window options to apply deferred auto show to.
+ */
+export declare function applyDeferAutoShowOptions(opts: OpenFin.PlatformWindowCreationOptions): InternalWindowOptions;
+/**
+ * Will show the current window if deferred auto show is enabled.
+ */
+export declare function autoShowIfDeferred(): Promise<void>;
+export {};

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

@@ -0,0 +1,36 @@
+export declare enum Env {
+    Local = "local",
+    Dev = "dev",
+    Staging = "staging",
+    Prod = "prod"
+}
+export declare const isFin: boolean;
+export declare const isJest: boolean;
+export declare const isWindowDefined: boolean;
+export declare const isDocumentDefined: boolean;
+export declare const isWindowDefinedWithIndexDB: boolean;
+export declare const finUUID: string;
+export declare const finName: string;
+export declare const finEntityType: "" | import("openfin-adapter/src/shapes/EntityType").EntityType;
+export declare const env: Env;
+export declare const isEnvLocal: boolean;
+export declare const isEnvDev: boolean;
+export declare const isEnvStaging: boolean;
+export declare const isEnvProd: boolean;
+export declare const isLibrary: boolean;
+export declare const workspaceProviderFinsLink: string;
+export declare const workspaceProviderFallbackUrl: string;
+export declare const workspaceAppsUrl: string;
+export declare const workspaceStorefrontFooterUrl: string;
+export declare const workspaceStorefrontLandingPageUrl: string;
+export declare const workspaceStorefrontNavigationUrl: string;
+export declare const workspaceShareUrl: string;
+export declare const workspaceCdnUrl: string;
+export declare const workspaceCdnEnvUrl: string;
+export declare const workspaceRuntimeVersion: string;
+/**
+ * A promise that resolves when:
+ *    - The window 'load' event is fired.
+ *    - The window first paint occurs.
+ */
+export declare const firstPaint: Promise<void>;

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

@@ -0,0 +1,52 @@
+/// <reference types="openfin-adapter/fin" />
+export declare type LayoutComponentStateExtended = OpenFin.LayoutComponent['componentState'] & {
+    name: string;
+    uuid: string;
+};
+export declare type LayoutComponentExtended = Omit<OpenFin.LayoutComponent, 'componentState'> & {
+    componentState: LayoutComponentStateExtended;
+};
+export declare type LayoutStack = {
+    type: 'stack';
+    content: OpenFin.LayoutContent;
+};
+export declare type LayoutContentItemExtended = OpenFin.LayoutRow | OpenFin.LayoutColumn | LayoutComponentExtended | LayoutStack;
+export declare type LayoutContentExtended = LayoutContentItemExtended[];
+export declare type LayoutSettingsExtended = OpenFin.LayoutOptions['settings'] & {
+    reorderEnabled?: boolean;
+};
+export declare type LayoutExtended = {
+    settings?: LayoutSettingsExtended;
+    content: LayoutContentExtended;
+};
+export declare enum LayoutDOMEventType {
+    TabCreated = "tab-created",
+    ContainerCreated = "container-created",
+    ContainerResized = "container-resized"
+}
+export interface LayoutDOMEvent {
+    type: LayoutDOMEventType;
+    detail: {
+        containerSelector: string;
+        tabSelector: string;
+    };
+    isInitialized: boolean;
+}
+export declare type LayoutDOMEventListener = (ev: LayoutDOMEvent) => void;
+/**
+ * Deep clones a layout and removes view names.
+ * @param layout The Layout to be cloned
+ * @returns A copy of the layout with names removed
+ */
+export declare const cloneLayoutAndRemoveNames: (layout: any) => any;
+export declare const mapContentComponentState: (content: OpenFin.LayoutContent | LayoutContentExtended) => LayoutComponentStateExtended[];
+export declare const getLayoutWithSingleView: (title: string, url: string) => Promise<any>;
+export declare const isLayoutTabActive: (tabSelector: string) => boolean;
+export declare const containerId = "layout_container";
+export declare const getViewComponents: () => LayoutContentExtended;
+export declare const removeLayoutView: (name: string) => Promise<void>;
+export declare const addLayoutEventListener: (event: LayoutDOMEventType, listener: LayoutDOMEventListener) => void;
+/**
+ * Initialize the layout for the current OF window.
+ */
+export declare const initLayout: () => Promise<void>;

package/common/src/utils/local-storage-key.d.ts

@@ -0,0 +1,8 @@
+declare enum LocalStorageKey {
+    LastLaunchedWorkspaceId = "activeWorkspaceId",
+    LastFocusedBrowserWindow = "lastFocusedBrowserWindow",
+    MachineName = "machineName",
+    NewTabPageLayout = "NewTabPageLayout",
+    NewTabPageSort = "NewTabPageSort"
+}
+export default LocalStorageKey;

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

@@ -0,0 +1,26 @@
+import { LogLocal } from './shapes';
+/**
+ * Responsible of capturing log information locally and centrally alongside the logs of other windows/views.
+ *
+ * **Warning: if you don't specify a name then it will still log out your messages but it becomes harder to distinguish where the log entry came from**
+ *
+ * Basic usage example:
+ *
+ * ```ts
+ * import logger from '../utils/logger';
+ *   const log = logger("My Component");
+ *
+ *   log.info("Initialised.");
+ * ```
+ * More information can be found [here](https://github.com/openfin/browser/blob/main/docs/Logging.md)
+ * @param name  Specify a name for this logger that will be the prefix of all log messages.
+ * @param logLocal  Specify an object to say what loglevel should be logged to the local window console e.g. { info: true }.
+ */
+export default function logger(name?: string, logLocal?: LogLocal): {
+    trace: (message: string, ...args: any[]) => void;
+    debug: (message: string, ...args: any[]) => void;
+    info: (message: string, ...args: any[]) => void;
+    warn: (message: string, ...args: any[]) => void;
+    error: (message: string, error?: any, ...args: any[]) => void;
+    fatal: (message: string, error?: any, ...args: any[]) => void;
+};

package/common/src/utils/logger/manager.d.ts

@@ -0,0 +1,35 @@
+import { LogEntry, LogOptions } from './shapes';
+declare class LogInterface {
+    private worker;
+    private name;
+    private requestResponseHandler;
+    private errorListeners;
+    constructor();
+    getLogs(fromId?: number): Promise<LogEntry[]>;
+    trace(message: string, sourceName?: string, args?: any[]): void;
+    debug(message: string, sourceName?: string, args?: any[]): void;
+    info(message: string, sourceName?: string, args?: any[]): void;
+    warn(message: string, sourceName?: string, args?: any[]): void;
+    error(message: string, error?: any, sourceName?: string, args?: any[]): void;
+    fatal(message: string, error?: any, sourceName?: string, args?: any[]): void;
+    configure(options: LogOptions): void;
+    onLogError(listener: (error: Error) => void): void;
+    removeListener(listener: (...args: unknown[]) => void): void;
+    private log;
+    private listener;
+}
+/**
+ * Responsible for managing the way logging behaves and retrieving logs. Additionally exposes logging functions but logger should be used for logging.
+ *
+ * Basic usage example:
+ *
+ * ```ts
+ * import logManager from '../utils/log-manager';
+ *
+ * const logs = await logManager.getLogs();
+ *
+ * ```
+ * More information can be found [here](https://github.com/openfin/browser/blob/main/docs/Logging.md)
+ */
+declare let instance: LogInterface | undefined;
+export default instance;

package/common/src/utils/logger/shapes.d.ts

@@ -0,0 +1,27 @@
+export declare type LogLevel = 'trace' | 'debug' | 'info' | 'warn' | 'error' | 'fatal';
+export interface LogOptions {
+    instanceId?: string;
+    auditLimit?: number;
+    auditLevel?: LogLevel;
+    logLevel?: LogLevel;
+}
+export declare type LogLocal = {
+    [key in LogLevel]?: boolean;
+};
+export interface LogEntry {
+    id?: number;
+    level: LogLevel;
+    name: string;
+    source?: string;
+    message: string;
+    error?: string;
+    ts?: number;
+    data?: any[];
+}
+export interface GetLogOptions {
+    from?: number;
+    responseId: number;
+}
+export declare const LogColors: {
+    [key in LogLevel]: string;
+};