@sisense/sdk-ui 2.28.0 → 2.30.0

package/dist/packages/sdk-ui/src/domains/dashboarding/common-filters/utils.d.ts

@@ -22,5 +22,5 @@ type GetWidgetDataOptionsWithDrilldownParams = {
  * @param params.drilldownOptions - The drilldown options of the widget.
  * @returns The widget data options with drilldown applied.
  */
-export declare function getWidgetDataOptionsWithDrilldown({ widgetType, chartType, dataOptions, drilldownOptions, }: GetWidgetDataOptionsWithDrilldownParams): import('../../../index.js').CategoricalChartDataOptions | import('../../../index.js').ScatterChartDataOptions | import('../../../index.js').IndicatorChartDataOptions | import('../../../index.js').BoxplotChartDataOptions | import('../../../index.js').BoxplotChartCustomDataOptions | import('../../../index.js').AreamapChartDataOptions | import('../../../index.js').ScattermapChartDataOptions | import('../../../index.js').RangeChartDataOptions | import('../../../index.js').CalendarHeatmapChartDataOptions | import('../../../index.js').TableDataOptions | PivotTableDataOptions | GenericDataOptions;
+export declare function getWidgetDataOptionsWithDrilldown({ widgetType, chartType, dataOptions, drilldownOptions, }: GetWidgetDataOptionsWithDrilldownParams): import('../../../index.js').CategoricalChartDataOptions | import('../../../index.js').ScatterChartDataOptions | import('../../../index.js').IndicatorChartDataOptions | import('../../../index.js').BoxplotChartDataOptions | import('../../../index.js').BoxplotChartCustomDataOptions | import('../../../index.js').AreamapChartDataOptions | import('../../../index.js').ScattermapChartDataOptions | import('../../../index.js').RangeChartDataOptions | import('../../../index.js').CalendarHeatmapChartDataOptions | import('../../../index.js').SankeyChartDataOptions | import('../../../index.js').TableDataOptions | PivotTableDataOptions | GenericDataOptions;
 export {};

package/dist/packages/sdk-ui/src/domains/dashboarding/components/dashboard-container.d.ts

@@ -1,2 +1,2 @@
 import { DashboardContainerProps } from '../../../domains/dashboarding/types';
-export declare const DashboardContainer: ({ editMode, onLayoutChange, renderToolbar, title, layoutOptions, config, widgets, filters, onFiltersChange, defaultDataSource, filterPanelCollapsed, onFilterPanelCollapsedChange, }: DashboardContainerProps) => import("react/jsx-runtime").JSX.Element;
+export declare const DashboardContainer: ({ editMode, onLayoutChange, headerItems, headerConfig, title, layoutOptions, config, widgets, filters, onFiltersChange, defaultDataSource, filterPanelCollapsed, onFilterPanelCollapsedChange, }: DashboardContainerProps) => import("react/jsx-runtime").JSX.Element;

package/dist/packages/sdk-ui/src/domains/dashboarding/components/dashboard-header-config.d.ts

@@ -0,0 +1,127 @@
+import { ReactNode } from 'react';
+/**
+ * Size of a custom dashboard header item, in pixels.
+ *
+ * @alpha
+ */
+export interface DashboardHeaderItemSize {
+    /**
+     * Fixed width of the item, in pixels.
+     *
+     * If omitted, it falls back to the default dashboard header item size of `28px`.
+     */
+    width?: number;
+    /**
+     * Fixed height of the item, in pixels.
+     *
+     * If omitted, falls back to the default dashboard header item size of `28px`.
+     */
+    height?: number;
+}
+/**
+ * Props passed to a {@link DashboardHeaderItemComponent} when it is rendered.
+ *
+ * @alpha
+ */
+export interface DashboardHeaderItemComponentProps {
+    /** The size resolved for the item by the header layout, with defaults applied. */
+    size: {
+        /**
+         * Fixed width of the item, in pixels.
+         */
+        width: number;
+        /**
+         * Fixed height of the item, in pixels.
+         */
+        height: number;
+    };
+}
+/**
+ * A React component that renders the content of a custom dashboard header item.
+ *
+ * @alpha
+ */
+export type DashboardHeaderItemComponent = (props: DashboardHeaderItemComponentProps) => ReactNode;
+/**
+ * Position of a custom dashboard header item relative to the other items.
+ *
+ * - `auto` (default) — placed in the trailing group, after the center spacer.
+ * - `before` / `after` — placed immediately before/after the item with the given `target` id.
+ *   Pass a {@link DashboardHeaderTargets} constant to anchor to a built-in item (works even when
+ *   that built-in is currently hidden), or any custom item id to anchor to another injected item.
+ * - `first` / `last` — placed at the very start/end of the header.
+ *
+ * @alpha
+ */
+export type DashboardHeaderItemPosition = {
+    type: 'auto';
+} | {
+    type: 'before';
+    target: string;
+} | {
+    type: 'after';
+    target: string;
+} | {
+    type: 'first';
+} | {
+    type: 'last';
+};
+/**
+ * A custom item to inject into the dashboard header.
+ *
+ * @alpha
+ */
+export interface DashboardHeaderItem {
+    /**
+     * Unique identifier of the item.
+     *
+     * Must not match a built-in dashboard header item id (see {@link DashboardHeaderTargets}).
+     */
+    id: string;
+    /**
+     * Component that renders the content of the item.
+     */
+    component: DashboardHeaderItemComponent;
+    /**
+     * Placement of the item.
+     *
+     * Defaults to `{ type: 'auto' }` (after the center spacer).
+     */
+    position?: DashboardHeaderItemPosition;
+    /**
+     * Size of the item.
+     */
+    size?: DashboardHeaderItemSize;
+}
+/**
+ * A dashboard header item after the built-in and custom items have been ordered (position applied).
+ *
+ * This is the shape passed to {@link DashboardHeaderConfig.onBeforeRender}.
+ *
+ * @alpha
+ */
+export type DashboardResolvedHeaderItem = Omit<DashboardHeaderItem, 'position'>;
+/**
+ * Transforms the fully ordered list of dashboard header items right before rendering.
+ *
+ * @alpha
+ */
+export type DashboardHeaderItemsTransform = (items: ReadonlyArray<DashboardResolvedHeaderItem>) => DashboardResolvedHeaderItem[];
+/**
+ * Configuration for the dashboard header items.
+ *
+ * @alpha
+ */
+export interface DashboardHeaderConfig {
+    /**
+     * Custom items to inject into the header.
+     *
+     * Each item's `id` must not match a built-in item id (see {@link DashboardHeaderTargets}).
+     */
+    items?: DashboardHeaderItem[];
+    /**
+     * Advanced hook to inspect and rewrite the full, ordered list of header items (built-in +
+     * custom) right before rendering.
+     */
+    onBeforeRender?: DashboardHeaderItemsTransform;
+}

package/dist/packages/sdk-ui/src/domains/dashboarding/components/dashboard-header-targets.d.ts

@@ -0,0 +1,30 @@
+/**
+ * Ids of the built-in dashboard header items.
+ *
+ * Use these as `target`s for the `before`/`after` position of a {@link DashboardHeaderItem}.
+ * A target stays valid even when it is not currently shown (e.g. the filter toggle when
+ * its icon is disabled): the position resolves as if the built-in were there, so the custom item lands
+ * in a stable spot regardless of which built-ins happen to be visible.
+ *
+ * @alpha
+ */
+export declare const DashboardHeaderTargets: {
+    /** The dashboard title. */
+    readonly Title: "dashboard-header-title";
+    /** The flexible center spacer that separates the title and trailing groups. */
+    readonly Spacer: "dashboard-header-spacer";
+    /** The edit-mode toolbar (undo/redo/cancel/apply), shown while editing with batch changes. */
+    readonly EditModeToolbar: "dashboard-header-edit-mode-toolbar";
+    /** The edit-mode toggle button. */
+    readonly EditToggle: "dashboard-header-edit-toggle";
+    /** The filters-panel toggle button. */
+    readonly FilterToggle: "dashboard-header-filter-toggle";
+    /** The overflow/context menu button. */
+    readonly Menu: "dashboard-header-menu";
+};
+/**
+ * Union of the built-in dashboard header item ids, usable as `target` for `before`/`after` positions.
+ *
+ * @alpha
+ */
+export type DashboardHeaderTarget = (typeof DashboardHeaderTargets)[keyof typeof DashboardHeaderTargets];

package/dist/packages/sdk-ui/src/domains/dashboarding/components/dashboard-header-title.d.ts

@@ -0,0 +1,20 @@
+import { HeaderItem } from '../../../domains/shared/header';
+/**
+ * Props for {@link DashboardHeaderTitle}.
+ */
+export interface DashboardHeaderTitleProps {
+    /** The dashboard title text. */
+    title: string;
+}
+/**
+ * The dashboard title, rendered as the content of the built-in title header item.
+ */
+export declare const DashboardHeaderTitle: ({ title }: DashboardHeaderTitleProps) => import("react/jsx-runtime").JSX.Element;
+/**
+ * Builds the built-in title header item.
+ *
+ * The title can be targeted by `before`/`after`. It uses the internal `fill: 'truncate'` so it
+ * takes its natural content width on the leading side and is the only item that shrinks/ellipsizes
+ * under pressure (action buttons keep their size); the center spacer absorbs the free space.
+ */
+export declare const createDashboardTitleItem: (title: string) => HeaderItem;

package/dist/packages/sdk-ui/src/domains/dashboarding/components/dashboard-header.d.ts

@@ -1,3 +1,12 @@
 import { DashboardHeaderProps } from '../../../domains/dashboarding/types';
 export declare const DASHBOARD_HEADER_HEIGHT = 48;
-export declare const DashboardHeader: ({ title, toolbar }: DashboardHeaderProps) => import("react/jsx-runtime").JSX.Element;
+/** Default size (px) for dashboard header items that don't specify their own size. */
+export declare const DASHBOARD_HEADER_ITEM_SIZE = 28;
+/**
+ * Dashboard header.
+ *
+ * Pure renderer: it receives the full list of built-in header items (title and center spacer
+ * included), resolves them against the user {@link DashboardHeaderConfig} (ordering then
+ * `onBeforeRender`), and renders the result. Auto-positioned items land after the center spacer.
+ */
+export declare const DashboardHeader: ({ items, config }: DashboardHeaderProps) => import("react/jsx-runtime").JSX.Element;

package/dist/packages/sdk-ui/src/domains/dashboarding/constants.d.ts

@@ -1,11 +1,11 @@
 import type { DeepRequired } from 'ts-essentials';
 import { DashboardByIdConfig, DashboardConfig, EditModeConfig, WidgetsPanelConfig } from './types.js';
-export declare const DEFAULT_DASHBOARD_CONFIG: DeepRequired<Omit<DashboardConfig, 'widgetsPanel' | 'tabbers'> & {
+export declare const DEFAULT_DASHBOARD_CONFIG: DeepRequired<Omit<DashboardConfig, 'widgetsPanel' | 'tabbers' | 'header'> & {
     widgetsPanel: Omit<WidgetsPanelConfig, 'editMode'> & {
         editMode: Omit<EditModeConfig, 'isEditing'>;
     };
 }>;
-export declare const DEFAULT_DASHBOARD_BY_ID_CONFIG: DeepRequired<Omit<DashboardByIdConfig, 'widgetsPanel' | 'tabbers'> & {
+export declare const DEFAULT_DASHBOARD_BY_ID_CONFIG: DeepRequired<Omit<DashboardByIdConfig, 'widgetsPanel' | 'tabbers' | 'header'> & {
     widgetsPanel: Omit<WidgetsPanelConfig, 'editMode'> & {
         editMode: Omit<EditModeConfig, 'isEditing'>;
     };

package/dist/packages/sdk-ui/src/domains/dashboarding/dashboard-helpers.d.ts

@@ -1,4 +1,5 @@
 import { Filter, FilterRelations } from '@sisense/sdk-data';
+import { DashboardHeaderItem } from './components/dashboard-header-config.js';
 import type { JumpToDashboardConfig } from './hooks/jtd/jtd-types.js';
 import { DashboardProps } from './types.js';
 /**
@@ -216,3 +217,23 @@ export declare const applyJtdConfig: (dashboard: DashboardProps, widgetOid: stri
  * @group Dashboard Utilities
  */
 export declare const applyJtdConfigs: (dashboard: DashboardProps, jtdConfigs: Record<string, JumpToDashboardConfig>) => DashboardProps;
+/**
+ * Creates a transformer that appends the given item to `config.header.items` of a dashboard.
+ *
+ * This is the canonical way for a dashboard customization (see `DashboardCustomization`) to add a
+ * header toolbar item. The returned transformer is pure — it does not modify the original dashboard;
+ * instead, it returns a new dashboard with the header item added.
+ *
+ * @example
+ * Add a custom header item to a dashboard.
+ * ```ts
+ * const updatedDashboard = withHeaderItem({
+ *   id: 'my-button',
+ *   component: () => <MyButton />,
+ * })(dashboard);
+ * ```
+ * @param item - The header item to add.
+ * @returns A transformer `(dashboard: DashboardProps) => DashboardProps` with the item appended.
+ * @sisenseInternal
+ */
+export declare const withHeaderItem: (item: DashboardHeaderItem) => (dashboard: Readonly<DashboardProps>) => DashboardProps;

package/dist/packages/sdk-ui/src/domains/dashboarding/dashboard-model/get-dashboard-model.d.ts

@@ -30,6 +30,13 @@ export interface GetDashboardModelOptions {
      * @internal
      */
     useLegacyApiVersion?: boolean;
+    /**
+     * Whether to fetch the dashboard with admin-level access.
+     *
+     * @default false
+     * @sisenseInternal
+     */
+    adminAccess?: boolean;
 }
 /**
  * Retrieves a dashboard model by its OID.

package/dist/packages/sdk-ui/src/domains/dashboarding/dashboard-model/translate-dashboard-utils.d.ts

@@ -1,13 +1,13 @@
-import { Dimension, Filter, FilterRelations, FilterRelationsModel, FilterRelationsModelNode, Measure } from '@sisense/sdk-data';
+import { Dimension, Filter, FilterRelations, Measure } from '@sisense/sdk-data';
 import { JtdTarget, JumpToDashboardConfig, JumpToDashboardConfigForPivot, TriggerMethod } from '../../../domains/dashboarding/hooks/jtd/jtd-types';
-import { TabbersConfig } from '../../../domains/dashboarding/hooks/use-tabber';
+import { TabberConfig, TabbersConfig } from '../../../domains/dashboarding/hooks/use-tabber';
 import { Panel, WidgetDto } from '../../../domains/widgets/components/widget-by-id/types';
 import { RestApi } from '../../../infra/api/rest-api';
 import { type CascadingFilterDto, DashboardDto, type FilterDto, type LayoutDto } from '../../../infra/api/types/dashboard-dto';
 import type { SpecificWidgetOptions, WidgetsOptions, WidgetsPanelColumnLayout } from './types';
 type WidgetJtdDtoSlice = Pick<WidgetDto, 'oid' | 'type' | 'metadata' | 'drillToDashboardConfig'>;
 export declare const translateLayout: (layout: LayoutDto) => WidgetsPanelColumnLayout;
-export declare function extractDashboardFilters(dashboardFilters: Array<FilterDto | CascadingFilterDto>, filterRelationsModel?: FilterRelationsModel | FilterRelationsModelNode): Filter[] | FilterRelations;
+export declare function extractDashboardFilters(dashboardFilters: Array<FilterDto | CascadingFilterDto>, filterRelationsDtoOptions?: DashboardDto['filterRelations']): Filter[] | FilterRelations;
 export declare const getJtdNavigateType: (widget: WidgetJtdDtoSlice) => TriggerMethod;
 export declare const convertDimensionsToDimIndexes: (widget: WidgetJtdDtoSlice, dimensionIds: string[]) => string[];
 /**
@@ -39,6 +39,48 @@ export declare function translateWidgetsOptions(widgets?: WidgetDto[]): WidgetsO
  * @internal
  */
 export declare function withSpecificWidgetOptions(widgetOptions?: SpecificWidgetOptions): (widgetDto: WidgetDto) => WidgetDto;
+/**
+ * The dashboard-level context held about a single widget, gathered from the
+ * (separate) containers it can live in: `widgetsOptions[id]`
+ * ({@link SpecificWidgetOptions}: common filters, JTD, partial DTO snapshot) and
+ * `config.tabbers[id]` ({@link TabberConfig}: per-tab show/hide mapping).
+ *
+ * Consumed by {@link withDashboardWidgetContext} to re-project this context onto a
+ * freshly-translated {@link WidgetDto} on add/duplicate, so dashboard-level config
+ * survives the model → DTO write path.
+ *
+ * @internal
+ */
+export type WidgetContext = {
+    /** Per-widget options from `widgetsOptions[id]`. */
+    options?: SpecificWidgetOptions;
+    /** Tabber show/hide mapping from `config.tabbers[id]`. */
+    tabber?: TabberConfig;
+};
+/**
+ * Overlays a {@link TabberConfig} onto a tabber {@link WidgetDto}.
+ *
+ * The widget-level translator (`toTabberWidgetStyle`) rebuilds `style.tabs[]` with
+ * tab names / `activeTab` / styling but empty `displayWidgetIds` — the widget model
+ * does not know about other widgets' ids. This overlays the dashboard-level
+ * show/hide mapping back onto those tabs by index. No-op for non-tabber DTOs or
+ * when there is no tabber config.
+ *
+ * @internal
+ */
+export declare function withTabberWidgetConfig(tabberConfig?: TabberConfig): (widgetDto: WidgetDto) => WidgetDto;
+/**
+ * Projects all dashboard-level {@link WidgetContext} for a widget onto a freshly
+ * translated {@link WidgetDto}. Composes the per-container projections
+ * ({@link withSpecificWidgetOptions} for `widgetsOptions`, {@link withTabberWidgetConfig}
+ * for `config.tabbers`); each is last-write-wins and a no-op when its slice is absent.
+ *
+ * This is the single seam that re-attaches dashboard-level widget config on
+ * add/duplicate; a new per-widget side-channel adds its projection here.
+ *
+ * @internal
+ */
+export declare function withDashboardWidgetContext(context: WidgetContext): (widgetDto: WidgetDto) => WidgetDto;
 export declare function translateTabbersOptions(widgets?: WidgetDto[]): TabbersConfig;
 /**
  * Replace all shared formulas, which defined by id references, in the dashboard with their actual values.

package/dist/packages/sdk-ui/src/domains/dashboarding/dashboard-model/use-dashboard-model/dashboard-model-reducer/persist-dashboard-model-middleware.d.ts

@@ -1,4 +1,5 @@
 import { DataSource } from '@sisense/sdk-data';
+import { DashboardModel } from '../../../../../domains/dashboarding/dashboard-model';
 import { RestApi } from '../../../../../infra/api/rest-api';
 import { AppSettings } from '../../../../../infra/app/settings/settings';
 import { CompleteThemeSettingsInternal } from '../../../../../types';
@@ -22,6 +23,14 @@ export type PersistDashboardModelMiddlewareParams = {
      * still satisfies the server's datasource schema.
      */
     dashboardDataSource?: DataSource;
+    /**
+     * Pre-reducer dashboard model snapshot. Used by UPDATE_WIDGET to read
+     * `widgetsOptions[oid].partialDtoOptions.options` so the Fusion PATCH carries
+     * the full options object (Fusion replaces, not merges).
+     *
+     * @internal
+     */
+    model?: DashboardModel;
 };
 /**
  * Middleware that persists the dashboard model changes to the Sisense server.
@@ -29,4 +38,4 @@ export type PersistDashboardModelMiddlewareParams = {
  * @returns Promise resolving to the action (possibly transformed, e.g. for ADD_WIDGET)
  * @internal
  */
-export declare function persistDashboardModelMiddleware({ dashboardOid, action, restApi, sharedMode, appSettings, themeSettings, dashboardDataSource, }: PersistDashboardModelMiddlewareParams): Promise<UseDashboardModelInternalAction>;
+export declare function persistDashboardModelMiddleware({ dashboardOid, action, restApi, sharedMode, appSettings, themeSettings, dashboardDataSource, model, }: PersistDashboardModelMiddlewareParams): Promise<UseDashboardModelInternalAction>;

package/dist/packages/sdk-ui/src/domains/dashboarding/dashboard-model/use-dashboard-model/dashboard-model-reducer/types.d.ts

@@ -1,5 +1,7 @@
 import { Filter, FilterRelations } from '@sisense/sdk-data';
 import { DashboardModel, SpecificWidgetOptions, WidgetsPanelLayout } from '../../../../../domains/dashboarding/dashboard-model';
+import { TabberConfig } from '../../../../../domains/dashboarding/hooks/use-tabber';
+import type { WidgetPropsUpdate } from '../../../../../domains/dashboarding/persistence/update-types.js';
 import type { WidgetDto } from '../../../../../domains/widgets/components/widget-by-id/types';
 import { WidgetModel } from '../../../../../domains/widgets/widget-model';
 export type UseDashboardModelState = DashboardModel | null;
@@ -21,6 +23,7 @@ export declare enum UseDashboardModelActionType {
     FILTERS_UPDATE = "FILTERS.UPDATE",
     ADD_WIDGET = "WIDGETS.ADD",
     PATCH_WIDGET = "WIDGETS.PATCH",
+    UPDATE_WIDGET = "WIDGETS.UPDATE",
     WIDGETS_PANEL_LAYOUT_UPDATE = "WIDGETS_PANEL_LAYOUT.UPDATE",
     WIDGETS_DELETE = "WIDGETS.DELETE"
 }
@@ -46,6 +49,18 @@ export type WidgetPatch = {
             max: number;
         };
     };
+    /**
+     * Full opaque widget style to send in the PATCH request. Used for custom
+     * (plugin) widgets whose `styleOptions` round-trip through `WidgetDto.style`.
+     * Must reconstruct the entire style object (the server replaces it on PATCH).
+     */
+    style?: WidgetDto['style'];
+    /**
+     * Full custom-widget options bag to send in the PATCH request.
+     * Must include all existing keys alongside the changed ones, because the
+     * server replaces the entire object rather than merging.
+     */
+    customOptions?: Record<string, unknown>;
 };
 /**
  * Internal actions for the dashboard model state used in {@link useDashboardModel}.
@@ -62,12 +77,26 @@ export type UseDashboardModelInternalAction = UseDashboardModelAction | {
         widgets: string[];
     };
 };
+/**
+ * Props-shaped widget update action. Carries a partial `WidgetPropsUpdate` that
+ * the reducer applies to the in-memory `WidgetModel` and the persist middleware
+ * translates to a targeted DTO patch via its per-field mapping table.
+ *
+ * @internal
+ */
+export type UseDashboardModelUpdateWidgetAction = {
+    type: UseDashboardModelActionType.UPDATE_WIDGET;
+    payload: {
+        widgetOid: string;
+        update: WidgetPropsUpdate;
+    };
+};
 /**
  * Actions for the dashboard model state used in {@link useDashboardModel}.
  *
  * @internal
  */
-export type UseDashboardModelAction = UseDashboardModelFilterUpdateAction | UseDashboardModelAddWidgetAction | UseDashboardModelPatchWidgetAction | UseDashboardModelLayoutUpdateAction | UseDashboardWidgetsDeleteAction;
+export type UseDashboardModelAction = UseDashboardModelFilterUpdateAction | UseDashboardModelAddWidgetAction | UseDashboardModelPatchWidgetAction | UseDashboardModelUpdateWidgetAction | UseDashboardModelLayoutUpdateAction | UseDashboardWidgetsDeleteAction;
 /**
  * Filter update actions for the dashboard model state used in {@link useDashboardModel}.
  *
@@ -95,6 +124,12 @@ export type UseDashboardModelAddWidgetAction = {
         widget: WidgetModel;
         widgetsPanelLayout?: WidgetsPanelLayout;
         widgetOptions?: SpecificWidgetOptions;
+        /**
+         * Dashboard-level tabber config for the widget (from `config.tabbers[id]`),
+         * carried so the persist middleware can project it back onto the widget DTO
+         * and the reducer can store it under the new widget id on duplication.
+         */
+        tabberConfig?: TabberConfig;
     };
 };
 /**

package/dist/packages/sdk-ui/src/domains/dashboarding/dashboard-model/use-dashboard-model/dashboard-model-reducer/utils.d.ts

@@ -1,5 +1,6 @@
 import { Filter, FilterRelations } from '@sisense/sdk-data';
 import { SpecificWidgetOptions, WidgetsPanelLayout } from '../../../../../domains/dashboarding/dashboard-model';
+import { TabberConfig } from '../../../../../domains/dashboarding/hooks/use-tabber';
 import { WidgetModel } from '../../../../../domains/widgets/widget-model';
 import { AddWidgetPayload } from './types.js';
 /**
@@ -24,6 +25,7 @@ export declare function parseAddWidgetPayload(payload: AddWidgetPayload): {
     widget: WidgetModel;
     widgetsPanelLayout?: WidgetsPanelLayout;
     widgetOptions?: SpecificWidgetOptions;
+    tabberConfig?: TabberConfig;
 };
 /**
  * Appends a widget cell to the first column's first row. Creates row/cells if missing.

package/dist/packages/sdk-ui/src/domains/dashboarding/dashboard-module/dashboard-module.d.ts

@@ -0,0 +1,34 @@
+import { ApiContract, ApiField, Module } from '../../../infra/modules/types';
+import { DashboardCustomization } from './types.js';
+/** Name of the `dashboard` module. */
+export declare const DASHBOARD_MODULE_NAME = "dashboard";
+/**
+ * API declaration for the `dashboard` module.
+ */
+export interface DashboardModuleApiDefinition {
+    /**
+     * Registry of dashboard customization middlewares. Each contribution is applied, in registration
+     * order, to the props of every {@link Dashboard}.
+     */
+    customizations: ApiField<DashboardCustomization[], DashboardCustomization[]>;
+}
+/**
+ * The `dashboard` module.
+ *
+ * Owns the `customizations` registry — other modules contribute {@link DashboardCustomization}
+ * middlewares there (via their `integrations`), which `Dashboard` applies to its props. Register it
+ * on `SisenseContextProvider`'s `modules` prop together with the modules that customize dashboards.
+ *
+ * @example
+ * ```ts
+ * <SisenseContextProvider modules={[DashboardModule, ...otherModules]} ... />
+ * ```
+ * @sisenseInternal
+ */
+export declare const DashboardModule: Module<DashboardModuleApiDefinition>;
+/**
+ * API contract for contributing to the `dashboard` module.
+ *
+ * @sisenseInternal
+ */
+export type DashboardModuleApi = ApiContract<DashboardModuleApiDefinition>;

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

@@ -0,0 +1,58 @@
+import { Filter, FilterRelations } from '@sisense/sdk-data';
+import { WidgetsPanelLayout } from '../../../domains/dashboarding/dashboard-model';
+import { DashboardProps } from '../../../domains/dashboarding/types';
+import { WidgetProps } from '../../../domains/widgets/components/widget/types';
+/**
+ * Dashboard state API.
+ *
+ * Passed as the second argument to every {@link DashboardCustomization}. Each method is backed by
+ * the composition layer's own state, so mutations flow through the normal dashboard pipeline and are
+ * persisted automatically when the dashboard has persistence enabled.
+ *
+ * @sisenseInternal
+ */
+export interface DashboardStateApi {
+    /**
+     * Adds a widget to the dashboard. Persists automatically when the dashboard is configured with
+     * persistence enabled; otherwise updates local state only.
+     *
+     * @param widget - The widget to add.
+     * @returns void
+     */
+    addWidget: (widget: WidgetProps) => void;
+    /**
+     * Replaces the dashboard filters.
+     *
+     * @param filters - The new filters or filter relations to apply.
+     * @returns void
+     */
+    setFilters: (filters: Filter[] | FilterRelations) => void;
+    /**
+     * Replaces the widgets-panel layout.
+     *
+     * @param layout - The new widgets-panel layout.
+     * @returns void
+     */
+    setWidgetsLayout: (layout: WidgetsPanelLayout) => void;
+}
+/**
+ * A dashboard customization middleware.
+ *
+ * Receives the dashboard props and returns a (possibly) modified copy — for example to
+ * inject a header item via `config.header.items`. The second argument is a {@link DashboardStateApi}
+ * for imperatively mutating dashboard state (e.g. adding a widget) in response to later user
+ * interaction. Customizations must be pure with respect to `dashboard` (return new props rather than
+ * mutate the argument) and idempotent, since they are re-applied on every render.
+ *
+ * @sisenseInternal
+ */
+export type DashboardCustomization = (
+/**
+ * The current dashboard props (read-only). Return a new object with your modifications rather
+ * than mutating this value directly.
+ *
+ * @param dashboard - Current dashboard props.
+ * @param stateApi - API for imperatively mutating dashboard state.
+ * @returns Modified dashboard props.
+ */
+dashboard: Readonly<DashboardProps>, stateApi: DashboardStateApi) => DashboardProps;

package/dist/packages/sdk-ui/src/domains/dashboarding/hooks/duplicate-widget/use-duplicate-widget-menu-item.d.ts

@@ -1,11 +1,14 @@
 /// <reference types="react" />
 import type { WidgetsOptions, WidgetsPanelLayout } from '../../../../domains/dashboarding/dashboard-model/types.js';
+import type { TabbersConfig } from '../../../../domains/dashboarding/hooks/use-tabber.js';
 import { type WidgetProps } from '../../../../domains/widgets/components/widget/types.js';
 import type { DashboardPersistenceManager } from '../../persistence/types.js';
 /** Setter for widgets array (e.g. React setState or updater function). */
 export type SetWidgets = React.Dispatch<React.SetStateAction<WidgetProps[]>>;
 /** Setter for widgets options array (e.g. React setState or updater function). */
 export type SetWidgetsOptions = React.Dispatch<React.SetStateAction<WidgetsOptions>>;
+/** Setter for the dashboard-level tabbers config (e.g. React setState or updater function). */
+export type SetTabbersConfig = React.Dispatch<React.SetStateAction<TabbersConfig>>;
 /** Setter for widgets panel layout. */
 export type SetWidgetsLayout = (newLayout: WidgetsPanelLayout) => void;
 /** Options for the duplicate widget middleware hook. */
@@ -24,6 +27,10 @@ export type UseDuplicateWidgetMenuItemParams = {
     widgetsOptions?: WidgetsOptions;
     /** Setter to update widgets options (e.g. from parent state). */
     setWidgetsOptions: SetWidgetsOptions;
+    /** Dashboard-level tabbers config (copied to the cloned widget so its tab show/hide mapping survives). */
+    tabbersConfig?: TabbersConfig;
+    /** Setter to update the tabbers config (e.g. from parent state). */
+    setTabbersConfig?: SetTabbersConfig;
     persistence?: Pick<DashboardPersistenceManager, 'addWidget'>;
 };
 /** Output of the duplicate widget middleware. */

package/dist/packages/sdk-ui/src/domains/dashboarding/hooks/use-dashboard-header-menu-item.d.ts

@@ -0,0 +1,9 @@
+import { HeaderItem } from '../../../domains/shared/header';
+import { MenuItemSection } from '../../../props';
+/**
+ * Builds the built-in dashboard header menu item from the given menu sections.
+ *
+ * Always returns the item so it can anchor `before`/`after` positioning; it is marked `hidden`
+ * (anchor-only, not rendered) when there are no menu sections.
+ */
+export declare const useDashboardHeaderMenuItem: (menuItemSections?: MenuItemSection[]) => HeaderItem;

package/dist/packages/sdk-ui/src/domains/dashboarding/hooks/use-widget-updates-persistence.d.ts

@@ -0,0 +1,27 @@
+import type { DashboardPersistenceManager } from '../../../domains/dashboarding/persistence/types';
+import type { WidgetProps } from '../../../domains/widgets/components/widget/types';
+type Persistence = Pick<DashboardPersistenceManager, 'updateWidget'> | undefined;
+/**
+ * Composition middleware that adds persistable widget-update plumbing to a
+ * widget list. For each widget that exposes a known runtime-state callback
+ * (currently only `styleOptions.navigator.onScrollerChange` for charts with
+ * a navigator), the hook injects a handler that:
+ *
+ * 1. Applies the update optimistically to local widget state (the parent
+ *    `useComposedDashboardInternal` re-renders with the new value).
+ * 2. Schedules a debounced (500 ms) call to `persistence.updateWidget` with
+ *    a {@link WidgetPropsUpdate}-shaped payload.
+ *
+ * When `persistence` is `undefined`, the optimistic apply still runs (so
+ * visualizations behave correctly in read-only mode) and the persist call
+ * is skipped.
+ *
+ * Errors during persistence are logged via `console.error`; the hook does
+ * not roll back local state.
+ *
+ * @sisenseInternal
+ */
+export declare function useWidgetUpdatesPersistence(widgets: WidgetProps[], setWidgets: (updater: (prev: WidgetProps[]) => WidgetProps[]) => void, persistence?: Persistence): {
+    widgets: WidgetProps[];
+};
+export {};

package/dist/packages/sdk-ui/src/domains/dashboarding/persistence/deep-merge.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Deep-merges a partial `update` into `base` for widget-update persistence.
+ *
+ * Merge semantics (shared by every merge point of the unified widget-update
+ * channel — pending-update accumulator, optimistic apply, model reducer and
+ * DTO patch):
+ * - nested plain objects are merged recursively at any depth;
+ * - arrays, primitives and non-plain objects (e.g. `Date`) are replaced
+ *   wholesale (last-write-wins);
+ * - keys cannot be deleted via merge — overwrite with an explicit value
+ *   (e.g. `null`) instead.
+ *
+ * Pure: returns a new object, never mutates the inputs.
+ *
+ * @internal
+ */
+export declare function deepMerge<T extends object>(base: T, update: object): T;