@sisense/sdk-ui 2.10.0 → 2.12.0

package/dist/packages/sdk-ui/src/dashboard/hooks/jtd/jtd-types.d.ts

@@ -1,9 +1,9 @@
-import { type Filter } from '@sisense/sdk-data';
+import { Attribute, type Filter, Measure } from '@sisense/sdk-data';
+import { OpenMenuFn } from '../../../common/components/menu/types.js';
+import { OpenModalFn } from '../../../common/components/modal/modal-context';
+import { DashboardConfig, DashboardProps } from '../../../dashboard/types';
 import { WidgetProps } from '../../../props.js';
 import { DataPoint } from '../../../types';
-import { JtdConfig, JtdDrillTarget } from '../../../widget-by-id/types';
-import { OpenModalFn } from '../../../common/components/modal/modal-context';
-import { OpenMenuFn } from '../../../common/components/menu/types.js';
 /**
  * Menu item structure for JTD navigation
  *
@@ -44,6 +44,8 @@ export interface JtdContext {
     dashboardFilters: Filter[];
     /** The original widget filters */
     originalWidgetFilters: Filter[];
+    /** Extra filters to be applied with highest priority */
+    extraFilters?: Filter[];
 }
 /**
  * Base interface for JTD action functions
@@ -59,13 +61,13 @@ export interface JtdActions {
     translate?: (key: string) => string;
 }
 /**
- * Extended core data for JTD click handlers that includes drill target
+ * Extended core data for JTD click handlers that includes jump target
  *
  * @internal
  */
 export interface JtdClickHandlerData extends JtdCoreData {
-    /** The drill target */
-    drillTarget: JtdDrillTarget;
+    /** The jump target */
+    jumpTarget: JtdTarget;
 }
 /**
  * Configuration for widget transforms, combining config and context
@@ -79,6 +81,8 @@ export interface JtdWidgetTransformConfig {
     dashboardFilters: Filter[];
     /** The original widget filters */
     originalWidgetFilters: Filter[];
+    /** Extra filters to be applied with highest priority */
+    extraFilters?: Filter[];
 }
 /**
  * Event-related data for handling data point clicks
@@ -91,3 +95,254 @@ export interface JtdDataPointClickEvent {
     /** Function to get menu item */
     getJumpToDashboardMenuItem: (coreData: JtdCoreData, context: JtdContext, actions: Pick<JtdActions, 'openModal' | 'translate'>) => JtdMenuItem;
 }
+/**
+ * Configuration for Jump To Dashboard functionality.
+ * Allows users to navigate from a widget to another dashboard with contextual filtering.
+ */
+export interface JumpToDashboardConfig {
+    /**
+     * Whether Jump To Dashboard functionality is enabled
+     * @default true
+     */
+    enabled?: boolean;
+    /** List of target dashboards that can be navigated to */
+    targets: JtdTarget[];
+    /** Configuration for user interaction behavior */
+    interaction?: {
+        /**
+         * How users trigger the jump action
+         * Note that not all widgets support both trigger methods
+         *
+         * @default 'rightclick'
+         **/
+        triggerMethod?: TriggerMethod;
+        /**
+         * Caption prefix for jumping action (i.e in context menu)
+         * @default 'Jump to'
+         */
+        captionPrefix?: string;
+        /**
+         * Whether to show the Jump To Dashboard icon in the toolbar of the source widget
+         * @default true
+         */
+        showIcon?: boolean;
+    };
+    /**
+     * Configuration for the target dashboard display.
+     * This configuration will be merged with target dashboard config, having higher priority
+     * @default {}
+     */
+    targetDashboardConfig?: DashboardConfig;
+    /** Configuration for filter handling between source and target dashboards */
+    filtering?: {
+        /**
+         * Additional filters to apply to the target dashboard
+         *
+         * @example
+         * const extraFilters = [dashboardProps.filters[0], dashboardProps.widgets[0].filters[0]]
+         *
+         * @default []
+         */
+        extraFilters?: Filter[];
+        /**
+         * Dashboard-level filter dimensions to pass through
+         *
+         * undefined - include all
+         * [] - include nothing
+         * [string] - include specific dimensions
+         *
+         * example: ["[ER.Date (Calendar)]", "[Doctors.Specialty]"]
+         * @default undefined
+         */
+        includeDashboardFilters?: string[];
+        /**
+         * Widget-level filter dimensions to pass through
+         *
+         * undefined - include all
+         * [] - include nothing
+         * [string] - include specific dimensions
+         *
+         * example: ["[ER.Date (Calendar)]", "[Doctors.Specialty]"]
+         * @default undefined
+         */
+        includeWidgetFilters?: string[];
+        /**
+         * Whether to merge filters with existing target dashboard filters or replace them
+         * @default false
+         */
+        mergeWithTargetFilters?: boolean;
+    };
+    /** Configuration for the modal window that will display the target dashboard */
+    modal?: {
+        /**
+         * Width of the modal window
+         * @default 85 (when measurementUnit is '%') or 1200 (when measurementUnit is 'px')
+         */
+        width?: number;
+        /**
+         * Height of the modal window
+         * @default 85 (when measurementUnit is '%') or 800 (when measurementUnit is 'px')
+         */
+        height?: number;
+        /**
+         * Unit of measurement for width/height
+         * @default 'px'
+         */
+        measurementUnit?: '%' | 'px';
+    };
+}
+/**
+ * Configuration for Jump To Dashboard functionality for pivot widgets.
+ * Used for pivot widgets, allowing to configure jumping to different dashboard from different dimensions
+ * @see {@link JumpToDashboardConfig}
+ */
+export interface JumpToDashboardConfigForPivot extends Omit<JumpToDashboardConfig, 'targets'> {
+    /**
+     * Map of target dashboards for different dimensions/measures
+     *
+     * @alpha
+     * @example
+     *
+     * const FormulaMeasure = dashboardProps.widgets[0].dataOptions.values[0];
+     * const ageRangeAttribute = dashboardProps.widgets[0].dataOptions.rows[1];
+     *
+     * const targets = new Map([
+     *    [ageRangeAttribute, [target, target2]],
+     *    [FormulaMeasure, [target3]],
+     * ]);
+     *
+     */
+    targets: Map<Attribute | {
+        dimension: Attribute;
+        location: 'row' | 'column' | 'value';
+    } | Measure, JtdTarget[]>;
+}
+/**
+ * Target dashboard for Jump To Dashboard functionality.
+ * Supports both dashboard ID reference and in-code dashboard object.
+ * @see JumpToDashboardConfig
+ * @see DashboardProps
+ */
+export type JtdTarget = {
+    caption: string;
+    id: string;
+} | {
+    caption: string;
+    dashboard: DashboardProps;
+};
+/**
+ * Type guard to check if a jump target contains dashboard props
+ * @internal
+ */
+export declare const isJumpTargetWithDashboardProps: (target: JtdTarget) => target is {
+    caption: string;
+    dashboard: DashboardProps;
+};
+/**
+ * Type guard to check if a jump target contains dashboard ID
+ * @internal
+ */
+export declare const isJumpTargetWithId: (target: JtdTarget) => target is {
+    caption: string;
+    id: string;
+};
+/**
+ * @internal
+ */
+export type PivotDimType = 'columns' | 'rows' | 'values';
+/**
+ * @internal
+ */
+export type NonNegativeIntString = Exclude<`${bigint}`, `-${string}`>;
+/**
+ * Pivot dimension ID
+ * example: "columns.0", "rows.0", "values.0", "columns.1", "rows.1", "values.1", etc.
+ * @internal
+ */
+export type PivotDimId = `${PivotDimType}.${NonNegativeIntString}`;
+export type JtdTargetDto = {
+    caption: string;
+    id?: string;
+    oid?: string;
+};
+export type JtdPivotTargetDto = JtdTargetDto & {
+    pivotDimensions: string[];
+};
+/**
+ * Legacy representation of JTD config from Fusion
+ * @internal
+ */
+export type JtdConfigDto = {
+    drilledDashboardPrefix: string;
+    drilledDashboardsFolderPrefix: string;
+    displayFilterPane: boolean;
+    displayDashboardsPane: boolean;
+    displayToolbarRow: boolean;
+    displayHeaderRow: boolean;
+    volatile: boolean;
+    hideDrilledDashboards: boolean;
+    hideSharedDashboardsForNonOwner: boolean;
+    drillToDashboardRightMenuCaption: string;
+    drillToDashboardNavigateType: number;
+    drillToDashboardNavigateTypePivot: number;
+    drillToDashboardNavigateTypeCharts: number;
+    drillToDashboardNavigateTypeOthers: number;
+    drilledDashboardDisplayType: number;
+    dashboardIds: Array<JtdTargetDto | JtdPivotTargetDto>;
+    modalWindowResize: boolean;
+    modalWindowMeasurement?: 'px' | '%';
+    modalWindowWidth?: number;
+    modalWindowHeight?: number;
+    showFolderNameOnMenuSelection: boolean;
+    resetDashFiltersAfterJTD: boolean;
+    sameCubeRestriction: boolean;
+    showJTDIcon?: boolean;
+    sendPieChartMeasureFiltersOnClick: boolean;
+    forceZeroInsteadNull: boolean;
+    mergeTargetDashboardFilters: boolean;
+    drillToDashboardByName: boolean;
+    sendBreakByValueFilter: boolean;
+    ignoreFiltersSource: boolean;
+    sendFormulaFiltersDuplicate?: number | 'none' | undefined;
+    enabled?: boolean;
+    version?: string;
+    includeDashFilterDims?: string[];
+    includeWidgetFilterDims?: string[];
+};
+/**
+ * Jump To Dashboard action trigger method type
+ * click - when user clicks on the widget
+ * rightclick - when user right clicks on the widget, opening the context menu
+ * @see {@link JumpToDashboardConfig}
+ */
+export type TriggerMethod = 'click' | 'rightclick';
+/**
+ * @internal
+ */
+export type JtdTargetInner = JtdTarget & {
+    pivotDimensions?: PivotDimId[];
+};
+/**
+ * Internal representation of Jump To Dashboard configuration object.
+ * This is the legacy format that includes fields like drilledDashboardPrefix
+ * and modalWindowResize that don't have direct equivalents in JumpToDashboardConfig.
+ * @internal
+ */
+export type JtdConfig = {
+    jumpedDashboardPrefix?: string;
+    dashboardConfig?: DashboardConfig;
+    jumpToDashboardRightMenuCaption?: string;
+    navigateType?: TriggerMethod;
+    includeDashFilterDims?: string[];
+    includeWidgetFilterDims?: string[];
+    jumpTargets: Array<JtdTargetInner>;
+    modalWindowResize?: boolean;
+    modalWindowMeasurement?: 'px' | '%';
+    modalWindowWidth?: number;
+    modalWindowHeight?: number;
+    showJtdIcon?: boolean;
+    mergeTargetDashboardFilters?: boolean;
+    sendFormulaFiltersDuplicate?: number | 'none' | undefined;
+    enabled?: boolean;
+    extraFilters?: Filter[];
+};

package/dist/packages/sdk-ui/src/dashboard/hooks/use-dashboard-header-toolbar.d.ts

@@ -1,16 +1,24 @@
+/**
+ * @internal
+ */
 export interface DashboardHeaderToolbarMenuItem {
     title: string;
     icon?: JSX.Element;
     ariaLabel?: string;
     onClick: () => void;
 }
+/**
+ * @internal
+ */
 export interface UseDashboardHeaderToolbarProps {
     menuItems: DashboardHeaderToolbarMenuItem[];
+    toolbarComponents?: JSX.Element[];
 }
 /**
  * Hook that returns a toolbar element for dashboard header
+ * @internal
  */
-export declare const useDashboardHeaderToolbar: ({ menuItems }: UseDashboardHeaderToolbarProps) => {
+export declare const useDashboardHeaderToolbar: ({ menuItems, toolbarComponents, }: UseDashboardHeaderToolbarProps) => {
     toolbar: () => import("react/jsx-runtime").JSX.Element;
 };
 export default useDashboardHeaderToolbar;

package/dist/packages/sdk-ui/src/dashboard/hooks/use-edit-mode-toolbar.d.ts

@@ -1,6 +1,7 @@
 import { WidgetsPanelLayout } from '../../models';
 /**
  * Props for the useEditModeToolbar hook
+ * @internal
  */
 export interface UseEditModeToolbarProps {
     /**
@@ -23,6 +24,7 @@ export interface UseEditModeToolbarProps {
 }
 /**
  * Return type for the useEditModeToolbar hook
+ * @internal
  */
 export interface UseEditModeToolbarResult {
     /**
@@ -47,5 +49,6 @@ export interface UseEditModeToolbarResult {
  *
  * @param props Configuration options for the toolbar
  * @returns Layout state and toolbar component
+ * @internal
  */
 export declare function useEditModeToolbar({ initialLayout, onApply, onCancel, historyCapacity, }: UseEditModeToolbarProps): UseEditModeToolbarResult;

package/dist/packages/sdk-ui/src/dashboard/hooks/use-jtd-widget.d.ts

@@ -0,0 +1,68 @@
+import { WidgetProps } from '../../props.js';
+import { JumpToDashboardConfig } from './jtd/jtd-types';
+import { JumpToDashboardConfigForPivot } from './use-jtd';
+/**
+ * Hook to add Jump To Dashboard (JTD) functionality to individual Widget components.
+ *
+ * Jump To Dashboard (JTD) allows users to navigate from one dashboard to another when interacting with widgets,
+ * such as clicking on chart data points or using context menus. This hook is particularly useful when rendering
+ * Widget components directly (not through a Dashboard component), but you still want JTD navigation functionality.
+ *
+ * For widgets that are part of a dashboard, consider using `applyJtdConfig` or `applyJtdConfigs` instead,
+ * as they apply JTD configuration at the dashboard level rather than individual widget level.
+ *
+ * Note: dashboard-only 'includeDashboardFilters' is not supported and would just be ignored, since we do not have a dashboard in the current context.
+ *
+ * This hook enhances the provided widget props with JTD navigation capabilities, including:
+ * - Click and right-click event handlers for navigation
+ * - Hyperlink styling for actionable pivot cells (when applicable)
+ * - JTD icon display in widget headers
+ *
+ * @example
+ * Basic JTD configuration with right-click navigation.
+ * ```typescript
+ * import { useJtdWidget } from '@sisense/sdk-ui';
+ *
+ * const jtdConfig: JumpToDashboardConfig = {
+ *   targets: [{ id: 'dashboard-1', caption: 'Sales Dashboard' }],
+ *   interaction: {
+ *     triggerMethod: 'rightclick',
+ *     captionPrefix: 'Jump to'
+ *   }
+ * };
+ *
+ * const MyComponent = () => {
+ *   const widgetWithJtd = useJtdWidget(myWidgetProps, jtdConfig);
+ *
+ *   return <Widget {...widgetWithJtd} />;
+ * };
+ * ```
+ *
+ * @example
+ * JTD configuration with multiple targets and custom styling.
+ * ```typescript
+ * const jtdConfig: JumpToDashboardConfig = {
+ *   enabled: true,
+ *   targets: [
+ *     { id: 'sales-dashboard', caption: 'Sales Analysis' },
+ *     { id: 'marketing-dashboard', caption: 'Marketing Insights' }
+ *   ],
+ *   interaction: {
+ *     triggerMethod: 'click',
+ *     captionPrefix: 'Navigate to',
+ *     showIcon: true
+ *   },
+ *   filtering: {
+ *     mergeWithTargetFilters: true,
+ *     includeWidgetFilters: true
+ *   }
+ * };
+ *
+ * const widgetWithJtd = useJtdWidget(chartProps, jtdConfig);
+ * ```
+ *
+ * @returns Enhanced widget props with JTD navigation capabilities, menu combination, and styling applied
+ *
+ * @group Dashboards
+ */
+export declare const useJtdWidget: (widgetProps: WidgetProps | null, config: JumpToDashboardConfig | JumpToDashboardConfigForPivot) => WidgetProps | null;

package/dist/packages/sdk-ui/src/dashboard/hooks/use-jtd.d.ts

@@ -1,22 +1,49 @@
 import { type Filter } from '@sisense/sdk-data';
-import { WidgetProps } from '../../props.js';
 import { OpenMenuFn } from '../../common/components/menu/types.js';
-import { WidgetsOptions } from '../../index-typedoc';
+import { type JtdActions } from '../../dashboard/hooks/jtd/jtd-types';
+import { JtdConfig } from '../../dashboard/hooks/jtd/jtd-types';
+import { WidgetsOptions } from '../../models/dashboard/types';
+import { WidgetProps } from '../../props.js';
+import { CompleteThemeSettings } from '../../types';
+/**
+ * Shared function to apply JTD functionality to a widget.
+ * Extracted to avoid code duplication between use-jtd.ts and use-jtd-widget.ts
+ *
+ * @param widgetProps - The widget props to enhance
+ * @param config - JTD application configuration
+ * @returns Enhanced widget props with JTD functionality
+ * @internal
+ */
+export declare const applyJtdToWidget: (widgetProps: WidgetProps, config: {
+    normalizedJtdConfig: JtdConfig;
+    dashboardFilters: Filter[];
+    originalWidgetFilters: Filter[];
+    extraFilters?: Filter[];
+    actions: JtdActions;
+    themeSettings: CompleteThemeSettings;
+}) => WidgetProps;
 /**
- * Jump to Dashboard (JTD) hook.
+ * Internal Jump To Dashboard (JTD) hook.
  * Implements the JTD functionality for each widget with JTD config.
- * @param widgetOptions - The widget options of the dashboard
- * @param dashboardFilters - The dashboard filters to use
- * @param widgetFilters - The widget filters to use
- * @param openMenu - The open menu function to use
+ * Supports both legacy JtdConfig and new JumpToDashboardConfig formats.
+ *
+ * @param config - The configuration object
+ * @param config.widgetOptions - The widget options of the dashboard
+ * @param config.dashboardFilters - The dashboard filters to use
+ * @param config.widgetFilters - The widget filters to use
+ * @param config.extraFilters - Extra filters to apply with highest priority
+ * @param config.openMenu - The open menu function to use
  * @returns The connect to widget props function
+ * @internal
  */
-export declare const useJtd: ({ widgetOptions, dashboardFilters, widgetFilters, openMenu, }: {
+export declare const useJtdInternal: ({ widgetOptions, dashboardFilters, widgetFilters, openMenu, extraFilters, }: {
     widgetOptions: WidgetsOptions;
     dashboardFilters?: Filter[] | undefined;
     widgetFilters?: Map<string, Filter[]> | undefined;
+    extraFilters?: Filter[] | undefined;
     openMenu: OpenMenuFn;
 }) => {
     connectToWidgetProps: (widgetProps: WidgetProps) => WidgetProps;
 };
 export * from './jtd';
+export { useJtdWidget } from './use-jtd-widget';

package/dist/packages/sdk-ui/src/dashboard/hooks/use-tabber.d.ts

@@ -1,7 +1,10 @@
-import { WidgetProps } from '../../props';
 import { WidgetPanelLayoutManager } from '../../dashboard/hooks/use-widgets-layout';
-import { TabberTab } from '../../types';
 import { TabbersOptions, WidgetsPanelColumnLayout } from '../../models';
+import { WidgetProps } from '../../props';
+import { TabberTab } from '../../types';
+/**
+ * @internal
+ */
 export type UseTabber = ({ widgets, config, }: {
     widgets: WidgetProps[];
     config?: TabbersOptions | undefined;
@@ -9,10 +12,20 @@ export type UseTabber = ({ widgets, config, }: {
     layoutManager: WidgetPanelLayoutManager;
     widgets: WidgetProps[];
 };
+/**
+ * @internal
+ */
 export type SingleTabberConfig = {
     tabs: TabberTab[];
     activeTab: number;
 };
 export declare const isTabberWidget: (widget: WidgetProps) => boolean;
 export declare const modifyLayout: (tabbersOptions: TabbersOptions, tabberState: Record<string, number>) => (layout: WidgetsPanelColumnLayout) => WidgetsPanelColumnLayout;
+/**
+ * Hook that modifies widget properties so it became a tabber widget.
+ * Incapsulates logic for updating layout via navigating tabs
+ * @param widgets
+ * @param tabbersConfigs
+ * @internal
+ */
 export declare const useTabber: UseTabber;

package/dist/packages/sdk-ui/src/dashboard/index.d.ts

@@ -1,5 +1,6 @@
 export { DashboardById } from './dashboard-by-id';
 export { Dashboard } from './dashboard';
-export { useComposedDashboard, useComposedDashboardInternal, type ComposableDashboardProps, type UseComposedDashboardOptions, } from './use-composed-dashboard';
+export { useComposedDashboard, useComposedDashboardInternal, type ComposableDashboardProps, type UseComposedDashboardOptions, type ComposedDashboardResult, } from './use-composed-dashboard';
 export { useDashboardTheme, type DashboardThemeParams } from './use-dashboard-theme';
+export * from './hooks';
 export type { DashboardByIdProps, DashboardProps, DashboardLayoutOptions, DashboardStyleOptions, DashboardConfig, DashboardByIdConfig, WidgetsPanelConfig, EditModeConfig, DashboardFiltersPanelConfig, } from './types';

package/dist/packages/sdk-ui/src/dashboard/types.d.ts

@@ -1,9 +1,9 @@
-import { DashboardStyleOptions, TabbersOptions, WidgetsOptions, WidgetsPanelLayout } from '../models';
-import { WidgetProps } from '../props';
-import { DashboardChangeAction } from '../dashboard/dashboard';
+import { ReactNode } from 'react';
 import { DataSource, Filter, FilterRelations } from '@sisense/sdk-data';
+import { DashboardChangeAction } from '../dashboard/dashboard';
 import { FiltersPanelConfig } from '../filters/components/filters-panel/types';
-import { ReactNode } from 'react';
+import { DashboardStyleOptions, TabbersOptions, WidgetsOptions, WidgetsPanelLayout } from '../models';
+import { WidgetProps } from '../props';
 export type { DashboardStyleOptions, WidgetsPanelColumnLayout, WidgetsPanelLayout, WidgetsPanelCell, WidgetsPanelRow, WidgetsPanelColumn, } from '../models';
 /**
  * Props of the {@link DashboardById} component.
@@ -58,6 +58,14 @@ export interface DashboardFiltersPanelConfig extends FiltersPanelConfig {
      * This state has a higher priority than `collapsedInitially` when enabled.
      */
     persistCollapsedStateToLocalStorage?: boolean;
+    /**
+     * If enabled, the expand/collapse arrow on the divider between the filters panel and the dashboard content will be replaced with a filter toggle icon on the dashboard toolbar.
+     *
+     * If the dashboard toolbar is configured to be not visible, this setting will be ignored.
+     *
+     * If not specified, the default value is `false`.
+     */
+    showFilterIconInToolbar?: boolean;
 }
 /**
  * Widgets panel configuration
@@ -145,7 +153,7 @@ export interface DashboardConfig {
         /**
          * Determines whether the toolbar is visible.
          *
-         * If not specified, the default value is `false`.
+         * If not specified, the default value is `true`.
          */
         visible: boolean;
     };

package/dist/packages/sdk-ui/src/dashboard/use-composed-dashboard.d.ts

@@ -1,6 +1,6 @@
-import { DashboardProps } from './types.js';
 import { Filter, FilterRelations } from '@sisense/sdk-data';
 import { WidgetsPanelLayout } from '../models';
+import { DashboardProps } from './types.js';
 export type ComposableDashboardProps = Pick<DashboardProps, 'filters' | 'widgets' | 'widgetsOptions' | 'layoutOptions' | 'tabbersOptions'>;
 export type UseComposedDashboardOptions = {
     /**
@@ -9,24 +9,67 @@ export type UseComposedDashboardOptions = {
     onFiltersChange?: (filters: Filter[] | FilterRelations) => void;
 };
 /**
- * {@link useComposedDashboard} without tracking to be used inside other hooks or components in Compose SDK.
- *
- * @param params - Parameters of the composable dashboard props
- * @internal
+ * Result of the {@link useComposedDashboard} hook.
  */
-export declare function useComposedDashboardInternal<D extends ComposableDashboardProps | DashboardProps>(initialDashboard: D, { onFiltersChange }?: UseComposedDashboardOptions): {
+export type ComposedDashboardResult<D extends ComposableDashboardProps | DashboardProps> = {
+    /** The composable dashboard object containing the current state of the dashboard. */
     dashboard: D;
+    /** API to set filters on the dashboard. */
     setFilters: (filters: Filter[] | FilterRelations) => void;
+    /** API to set the layout of the widgets on the dashboard. */
     setWidgetsLayout: (newLayout: WidgetsPanelLayout) => void;
 };
+/**
+ * {@link useComposedDashboard} without tracking to be used inside other hooks or components in Compose SDK.
+ *
+ * @internal
+ */
+export declare function useComposedDashboardInternal<D extends ComposableDashboardProps | DashboardProps>(initialDashboard: D, { onFiltersChange }?: UseComposedDashboardOptions): ComposedDashboardResult<D>;
 /**
  * React hook that takes in separate dashboard elements and
  * composes them into a coordinated dashboard with change detection, cross filtering, and drill down.
  *
+ * @example
+ * ```ts
+ * import { useComposedDashboard } from '@sisense/sdk-ui/dashboard/use-composed-dashboard.js';
+ * import { Widget } from '@sisense/sdk-ui';
+ * import { DashboardProps } from '../dashboard/types.js';
+ * import { FilterTile } from '../filters';
+ *
+ * const CodeExample = () => {
+ *   const dashboardProps: DashboardProps = { ... };
+ *
+ *   const {
+ *     dashboard: { title, widgets, filters = [] }
+ *   } = useComposedDashboard(dashboardProps);
+ *
+ *   return (
+ *     <div>
+ *       <span>{title}</span>
+ *       <div>
+ *         {widgets.map((widget) => (
+ *           <Widget key={widget.id} {...widget} />
+ *         ))}
+ *       </div>
+ *
+ *       {Array.isArray(filters) ? filters.map((filter) => (
+ *         <FilterTile
+ *           key={filter.name}
+ *           filter={filter}
+ *           onChange={(filter) => console.log('Updated filter', filter)}
+ *         />
+ *       )) : null}
+ *     </div>
+ *   );
+ * }
+ *   export default CodeExample;
+ * ```
+ *
+ * @template {D extends ComposableDashboardProps | DashboardProps} D - The type parameter for a dashboard properties, restricted to ComposableDashboardProps or DashboardProps
+ * @param {D} initialDashboard - set of properties for the Dashboard component
+ * @param {UseComposedDashboardOptions} [options] - Options for the composable.
+ *
+ * @return {ComposedDashboardResult} An object containing the composed dashboard and APIs to interact with it.
  * @group Dashboards
  */
-export declare const useComposedDashboard: <D extends DashboardProps | ComposableDashboardProps>(args_0: D, args_1?: UseComposedDashboardOptions | undefined) => {
-    dashboard: D;
-    setFilters: (filters: Filter[] | FilterRelations) => void;
-    setWidgetsLayout: (newLayout: WidgetsPanelLayout) => void;
-};
+export declare const useComposedDashboard: <D extends DashboardProps | ComposableDashboardProps>(initialDashboard: D, options?: UseComposedDashboardOptions) => ComposedDashboardResult<D>;

package/dist/packages/sdk-ui/src/decorators/component-decorators/with-tracking/error-tracker.d.ts

@@ -1,6 +1,6 @@
-import { ErrorEventOptions } from '@sisense/sdk-tracking';
-import { HttpClient } from '@sisense/sdk-rest-client';
 import { Component, ReactNode } from 'react';
+import { HttpClient } from '@sisense/sdk-rest-client';
+import { ErrorEventOptions } from '@sisense/sdk-tracking';
 import { SisenseContextPayload } from '../../../sisense-context/sisense-context';
 type ErrorTrackerProps = {
     children: ReactNode;

package/dist/packages/sdk-ui/src/filters/components/common/basic-input.d.ts

@@ -1,4 +1,4 @@
-import { type FunctionComponent, type InputHTMLAttributes, CSSProperties } from 'react';
+import { CSSProperties, type FunctionComponent, type InputHTMLAttributes } from 'react';
 type BasicInputProps = {
     label?: string;
     callback: (value: string) => void;

package/dist/packages/sdk-ui/src/filters/components/common/date-range-field-button.d.ts

@@ -1,4 +1,4 @@
-import { type FunctionComponent, type ButtonHTMLAttributes } from 'react';
+import { type ButtonHTMLAttributes, type FunctionComponent } from 'react';
 import { Themable } from '../../../theme-provider/types';
 export type Variant = 'white' | 'grey';
 type InputProps = {

package/dist/packages/sdk-ui/src/filters/components/criteria-filter-tile/criteria-filter-display.d.ts

@@ -1,5 +1,5 @@
 import { FunctionComponent } from 'react';
-import { FilterOptionType, CriteriaFilterValueType } from './criteria-filter-operations.js';
+import { CriteriaFilterValueType, FilterOptionType } from './criteria-filter-operations.js';
 /**
  * Props for {@link CriteriaFilterDisplay}
  */