@sisense/sdk-ui 1.21.0 → 1.23.0

package/dist/packages/sdk-ui/src/common/components/menu/types.d.ts

@@ -2,6 +2,7 @@ import { MenuPosition, MenuItemSection } from '../../../types';
 export type MenuOptions = {
     position: MenuPosition;
     itemSections: MenuItemSection[];
+    onClose?: () => void;
 };
 export type BeforeMenuOpenHandler = (options: MenuOptions) => MenuOptions | null;
 export type OpenMenuFn = (options: MenuOptions) => void;

package/dist/packages/sdk-ui/src/common/hooks/use-fetch.d.ts

@@ -31,7 +31,7 @@ export type UseQueryResult<TData, TError> = TanstackUseQueryResult<TData, TError
   });
  ```
  * @returns Query state that contains the status of the query execution, the result data, or the error if any occurred
- * @group Fusion Embed
+ * @group Fusion Assets
  */
 export declare const useFetch: <TData = unknown, TError = unknown>(path: string, init?: RequestInit | undefined, options?: {
     requestConfig?: RequestConfig | undefined;

package/dist/packages/sdk-ui/src/common/hooks/use-synced-state.d.ts

@@ -0,0 +1,19 @@
+import { Dispatch, SetStateAction } from 'react';
+type UseSyncedStateOptions<T> = {
+    /**
+     * A callback function that is triggered when the state is updated via the local setter,
+     * but not through synchronization with `syncValue`.
+     */
+    onLocalStateChange?: (state: T) => void;
+    /**
+     * A custom comparison function to determine if the external `syncValue` is different
+     * from the current state. The default function performs a deep equality check using `isEqual`.
+     */
+    syncCompareFn?: (currentState: T, syncValue: T) => boolean;
+};
+/**
+ * A custom React hook that behaves like the regular `useState`, but also synchronizes the state
+ * with an external `syncValue`.
+ */
+export declare function useSyncedState<T>(syncValue: T, { onLocalStateChange, syncCompareFn }?: UseSyncedStateOptions<T>): [T, Dispatch<SetStateAction<T>>];
+export {};

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

@@ -9,7 +9,15 @@ type DataSelection = {
 };
 export declare function getWidgetSelections(widgetType: WidgetTypeInternal, dataOptions: ChartDataOptions | PivotTableDataOptions, points: Array<ChartDataPoint>): DataSelection[];
 export declare function getSelectableWidgetAttributes(widgetType: WidgetTypeInternal, dataOptions: ChartDataOptions | PivotTableDataOptions): Attribute[];
-export declare function createCommonFiltersOverSelections(selections: DataSelection[], existingCommonFilters: Filter[]): Filter[];
+type FiltersWithSelectionFlag = {
+    filters: Filter[];
+    isSelection: boolean;
+};
+/**
+ * Creates a set of common filters based on the current selections, considering existing filters and
+ * the common filters unselection rules.
+ */
+export declare function createCommonFiltersOverSelections(selections: DataSelection[], existingCommonFilters: Filter[], allowPartialUnselection?: boolean): FiltersWithSelectionFlag;
 export declare function getWidgetSelectionsTitleMenuItem(widgetType: WidgetTypeInternal, dataOptions: ChartDataOptions | PivotTableDataOptions, points: Array<ChartDataPoint>): MenuItemSection | null;
 export declare function getSelectMenuItem(title: string, selectHandler: () => void): MenuItemSection;
 export {};

package/dist/packages/sdk-ui/src/common-filters/use-common-filters.d.ts

@@ -2,11 +2,13 @@
 import { type Filter } from '@sisense/sdk-data';
 import { CommonFiltersOptions } from './types.js';
 import { WidgetProps } from '../props.js';
-import { OpenMenuFn } from '../common/components/menu/types.js';
+import { BeforeMenuOpenHandler, OpenMenuFn } from '../common/components/menu/types.js';
 /** @internal */
-export declare const useCommonFilters: ({ initialFilters, openMenu, }?: {
+export declare const useCommonFilters: ({ initialFilters, openMenu, onBeforeMenuOpen, onFiltersChange, }?: {
     initialFilters?: Filter[] | undefined;
     openMenu?: OpenMenuFn | undefined;
+    onBeforeMenuOpen?: BeforeMenuOpenHandler | undefined;
+    onFiltersChange?: ((filters: Filter[]) => void) | undefined;
 }) => {
     filters: Filter[];
     setFilters: import("react").Dispatch<import("react").SetStateAction<Filter[]>>;

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

@@ -25,8 +25,7 @@ import { DashboardByIdProps } from './types';
  *
  * To learn more about this and related dashboard components,
  * see [Embedded Dashboards](/guides/sdk/guides/dashboards/index.html).
- *
- * @group Fusion Embed
+ * @group Fusion Assets
  * @fusionEmbed
  * @beta
  */

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

@@ -1,14 +1,91 @@
 import { Filter } from '@sisense/sdk-data';
 import { DashboardProps } from './types';
 /**
- * Utility functions to manipulate DashboardProps.
+ * Creates a new dashboard instance with its filters replaced by a new set of filters.
  *
- * @group Dashboards
+ * This function does not modify the original dashboard; instead, it returns a new dashboard with the updated filters.
+ *
+ * @example
+ * Replace all filters on a dashboard with a new set of filters.
+ * ```ts
+ * const existingDashboard: DashboardProps = {...}
+ * const newFilters: Filter[] = [{...}, {...}, ...];
+ * const updatedDashboard = replaceFilters(existingDashboard, newFilters);
+ * ```
+ * @param dashboard - The original dashboard (`DashboardProps`) whose filters are to be replaced.
+ * @param newFilters - An array of new filters to set on the dashboard.
+ * @returns A new dashboard instance with the updated filters.
+ */
+export declare const replaceFilters: (dashboard: DashboardProps, newFilters: Filter[]) => DashboardProps;
+/**
+ * Creates a new dashboard instance with an additional filter added to its existing filters.
+ *
+ * This function does not modify the original dashboard; instead, it returns a new dashboard with the added filter.
+ *
+ * @example
+ * Add a new filter to a dashboard.
+ * ```ts
+ * const existingDashboard: DashboardProps = {...};
+ * const newFilter: Filter = {...};
+ * const updatedDashboard = addFilter(existingDashboard, newFilter);
+ * ```
+ * @param dashboard - The original dashboard (`DashboardProps`) to which the filter will be added.
+ * @param newFilter - The filter to add to the dashboard.
+ * @returns A new dashboard instance with the new filter added.
+ */
+export declare const addFilter: (dashboard: DashboardProps, newFilter: Filter) => DashboardProps;
+/**
+ * Creates a new dashboard instance with additional filters added to its existing filters.
+ *
+ * This function does not modify the original dashboard; instead, it returns a new dashboard with the added filters.
+ *
+ * @example
+ * Add multiple new filters to a dashboard.
+ * ```ts
+ * const existingDashboard: DashboardProps = {...};
+ * const newFilters: Filter[] = [{...}, {...}, ...];
+ * const updatedDashboard = addFilters(existingDashboard, newFilters);
+ * ```
+ * @param dashboard - The original dashboard (`DashboardProps`) to which the filters will be added.
+ * @param newFilters - An array of filters to add to the dashboard.
+ * @returns A new dashboard instance with the new filters added.
+ */
+export declare const addFilters: (dashboard: DashboardProps, newFilters: Filter[]) => DashboardProps;
+/**
+ * Creates a new dashboard instance with a specific filter modified.
+ *
+ * This function searches for a filter with the same GUID as the provided `filterToModify` and replaces it with `newFilter`.
+ * This function does not modify the original dashboard; instead, it returns a new dashboard with the updated filters.
+ *
+ * @example
+ * Modify a filter in a dashboard.
+ * ```ts
+ * const existingDashboard: DashboardProps = {...};
+ * const filterToModify: Filter = {...};
+ * const newFilter: Filter = {...};
+ * const updatedDashboard = modifyFilter(existingDashboard, filterToModify, newFilter);
+ * ```
+ * @param dashboard - The original dashboard (`DashboardProps`) containing the filter to modify.
+ * @param filterToModify - The existing filter to be modified.
+ * @param newFilter - The new filter to replace the existing one.
+ * @returns A new dashboard instance with the specified filter modified.
+ */
+export declare const modifyFilter: (dashboard: DashboardProps, filterToModify: Filter, newFilter: Filter) => DashboardProps;
+/**
+ * Creates a new dashboard instance with a specific filter removed.
+ *
+ * This function removes the filter with the same GUID as the provided filter from the dashboard's filters.
+ * This function does not modify the original dashboard; instead, it returns a new dashboard with the updated filters.
+ *
+ * @example
+ * Remove a filter from a dashboard.
+ * ```ts
+ * const existingDashboard: DashboardProps = {...};
+ * const filterToRemove: Filter = {...};
+ * const updatedDashboard = removeFilter(existingDashboard, filterToRemove);
+ * ```
+ * @param dashboard - The original dashboard (`DashboardProps`) from which to remove the filter.
+ * @param filter - The filter to be removed.
+ * @returns A new dashboard instance with the specified filter removed.
  */
-export declare const DashboardHelpers: {
-    replaceFilters: (dashboard: DashboardProps, newFilters: Filter[]) => DashboardProps;
-    modifyFilter: (dashboard: DashboardProps, filterToModify: Filter, newFilter: Filter) => DashboardProps;
-    removeFilter: (dashboard: DashboardProps, filter: Filter) => DashboardProps;
-    addFilter: (dashboard: DashboardProps, newFilter: Filter) => DashboardProps;
-    addFilters: (dashboard: DashboardProps, newFilters: Filter[]) => DashboardProps;
-};
+export declare const removeFilter: (dashboard: DashboardProps, filter: Filter) => DashboardProps;

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

@@ -1,5 +1,14 @@
 /// <reference types="react" />
 import { DashboardProps } from '../dashboard/types';
+import { Filter } from '@sisense/sdk-data';
+export declare enum DashboardChangeType {
+    /** Dashboard filters have been updated */
+    FILTERS_UPDATE = "FILTERS.UPDATE"
+}
+export type DashboardChangeAction = {
+    type: DashboardChangeType.FILTERS_UPDATE;
+    payload: Filter[];
+};
 /**
  * React component that renders a dashboard whose elements are customizable. It includes internal logic of applying common filters to widgets.
  *
@@ -33,7 +42,6 @@ export default CodeExample;
  *
  * To learn more about this and related dashboard components,
  * see [Embedded Dashboards](/guides/sdk/guides/dashboards/index.html).
- *
  * @group Dashboards
  * @beta
  */

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

@@ -1,4 +1,5 @@
 export { DashboardById } from './dashboard-by-id';
 export { Dashboard } from './dashboard';
+export { useComposedDashboard, type ComposableDashboardProps, type UseComposedDashboardOptions, } from './use-composed-dashboard';
+export { useDashboardTheme, type DashboardThemeParams } from './use-dashboard-theme';
 export type { DashboardByIdProps, DashboardProps, DashboardLayoutOptions, DashboardStyleOptions, DashboardConfig, } from './types';
-export { DashboardHelpers } from './dashboard-helpers';

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

@@ -1,6 +1,7 @@
 import { DashboardStyleOptions, WidgetsOptions, WidgetsPanelLayout } from '../models';
 import { WidgetProps } from '../props';
 import { DataSource, Filter } from '@sisense/sdk-data';
+import { DashboardChangeAction } from '../dashboard/dashboard';
 export type { DashboardStyleOptions, WidgetsPanelColumnLayout } from '../models';
 /**
  * Props for the DashboardById component
@@ -10,6 +11,17 @@ export interface DashboardByIdProps {
      * The OID of the dashboard to render.
      */
     dashboardOid: string;
+    /**
+     * Boolean flag indicating whether changes to the embedded dashboard should be saved to the dashboard in Fusion.
+     *
+     * If not specified, the default value is `false`.
+     *
+     * Limitations:
+     * - WAT authentication does not support persistence.
+     * - As an alpha feature, currently only changes to dashboard filters are persisted.
+     * @internal
+     */
+    persist?: boolean;
 }
 /**
  * Props for the DashboardContainer component
@@ -72,6 +84,12 @@ export interface DashboardProps {
     widgetsOptions?: WidgetsOptions;
     /** The style options for the dashboard */
     styleOptions?: DashboardStyleOptions;
+    /**
+     * Callback to receive changes
+     *
+     * @internal
+     */
+    onChange?: (action: DashboardChangeAction) => void;
 }
 /**
  * Props for the Dashboard Header component

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

@@ -0,0 +1,30 @@
+import { DashboardProps } from './types.js';
+import { Filter } from '@sisense/sdk-data';
+export type ComposableDashboardProps = Pick<DashboardProps, 'filters' | 'widgets' | 'widgetsOptions'>;
+export type UseComposedDashboardOptions = {
+    /**
+     * @internal
+     */
+    onFiltersChange?: (filters: Filter[]) => 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
+ */
+export declare function useComposedDashboardInternal<D extends ComposableDashboardProps | DashboardProps>(initialDashboard: D, { onFiltersChange }?: UseComposedDashboardOptions): {
+    dashboard: D;
+    setFilters: (filters: Filter[]) => void;
+};
+/**
+ * React hook that takes in separate dashboard elements and
+ * composes them into a coordinated dashboard with change detection, cross filtering, and drill down.
+ *
+ * @group Dashboards
+ * @alpha
+ */
+export declare const useComposedDashboard: <D extends DashboardProps | ComposableDashboardProps>(args_0: D, args_1?: UseComposedDashboardOptions | undefined) => {
+    dashboard: D;
+    setFilters: (filters: Filter[]) => void;
+};

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

@@ -0,0 +1,40 @@
+import { DashboardStyleOptions } from '../models';
+/**
+ * @internal
+ */
+export interface DashboardThemeParams {
+    styleOptions?: DashboardStyleOptions;
+}
+/**
+ * {@link useDashboardTheme} without tracking to be used inside other hooks or components in Compose SDK.
+ *
+ * @param params - Parameters of the dashboard to be retrieved
+ * @internal
+ */
+export declare const useDashboardThemeInternal: ({ styleOptions }: DashboardThemeParams) => {
+    themeSettings: {
+        dashboard: {
+            backgroundColor: string;
+            dividerLineWidth: number;
+            dividerLineColor: string;
+        };
+        palette?: import("..").ColorPaletteTheme | undefined;
+    };
+};
+/**
+ * React hook that returns dashboard theme settings
+ *
+ * @group Dashboards
+ * @alpha
+ * @internal
+ */
+export declare const useDashboardTheme: (args_0: DashboardThemeParams) => {
+    themeSettings: {
+        dashboard: {
+            backgroundColor: string;
+            dividerLineWidth: number;
+            dividerLineColor: string;
+        };
+        palette?: import("..").ColorPaletteTheme | undefined;
+    };
+};

package/dist/packages/sdk-ui/src/decorators/hook-decorators/with-tracking.d.ts

@@ -2,6 +2,7 @@ import { ClientApplication } from '../../app/client-application';
 export type HookDecorator<DecoratorConfig> = (decoratorConfig: DecoratorConfig) => <HookArgs extends any[], HookResult>(hook: (...args: HookArgs) => HookResult) => (...args: HookArgs) => HookResult;
 /**
  * Tracks the hook event and sends it to the server.
+ *
  * @param hookName - The name of the hook
  * @param packageName - The name of the package
  * @param app - The client application

package/dist/packages/sdk-ui/src/filters/components/common/member-radio.d.ts

@@ -0,0 +1,8 @@
+import { type FunctionComponent, type InputHTMLAttributes } from 'react';
+type MemberRadioProps = {
+    label?: string;
+    isLabelInactive?: boolean;
+    wrapperClassName?: string;
+} & InputHTMLAttributes<HTMLInputElement>;
+export declare const MemberRadio: FunctionComponent<MemberRadioProps>;
+export {};

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

@@ -1,6 +1,7 @@
+import React from 'react';
 import { DateRangeFilter } from '@sisense/sdk-data';
 type DateRangeFilterDisplayProps = {
     filter: DateRangeFilter;
 };
-export declare const DateRangeFilterDisplay: (props: DateRangeFilterDisplayProps) => import("react/jsx-runtime").JSX.Element;
+export declare const DateRangeFilterDisplay: React.FC<DateRangeFilterDisplayProps>;
 export {};

package/dist/packages/sdk-ui/src/filters/components/filters-panel/filters-panel.d.ts

@@ -3,7 +3,6 @@ import { DataSource, Filter } from '@sisense/sdk-data';
 /**
  * Props of the {@link FiltersPanel} component
  *
- * @internal
  */
 export type FiltersPanelProps = {
     /** Array of filters to display */
@@ -16,6 +15,7 @@ export type FiltersPanelProps = {
 /**
  * Filters panel component that renders a list of filter tiles
  *
- * @internal
+ * @group Filter Tiles
+ * @alpha
  */
 export declare const FiltersPanel: import("react").FunctionComponent<FiltersPanelProps>;

package/dist/packages/sdk-ui/src/filters/components/filters-panel/index.d.ts

@@ -1,2 +1,2 @@
-export { FiltersPanel } from './filters-panel';
+export { FiltersPanel, type FiltersPanelProps } from './filters-panel';
 export { FiltersPanelTile } from './filters-panel-tile';

package/dist/packages/sdk-ui/src/filters/components/member-filter-tile/member-list.d.ts

@@ -7,6 +7,7 @@ export interface MemberListProps {
     checkAllMembers: () => void;
     uncheckAllMembers: () => void;
     excludeMembers: boolean;
+    multiSelection: boolean;
     disabled: boolean;
 }
 export declare const MemberList: FunctionComponent<MemberListProps>;

package/dist/packages/sdk-ui/src/formulas/use-get-shared-formula.d.ts

@@ -67,7 +67,7 @@ export type SharedFormulaSuccessState = {
     status: 'success';
 };
 /**
- * Fetch a [shared formula](https://docs.sisense.com/main/SisenseLinux/shared-formulas.htm) from the a Fusion Embed instance.
+ * Fetch a [shared formula](https://docs.sisense.com/main/SisenseLinux/shared-formulas.htm) from the a Fusion instance.
  *
  * The formula can be identified either by `oid` or by name and data source pair.
  *
@@ -84,7 +84,7 @@ export type SharedFormulaSuccessState = {
     const { formula, isLoading, isError } = useGetSharedFormula({ name: 'My Shared Formula', datasource: DM.DataSource })
     ```
  * @returns Formula load state that contains the status of the execution, the result formula, or the error if any
- * @group Fusion Embed
+ * @group Fusion Assets
  * @fusionEmbed
  */
 export declare const useGetSharedFormula: (params: UseGetSharedFormulaParams) => SharedFormulaState;

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

@@ -1,20 +1,21 @@
-export { ClientApplication, createClientApplication } from './app/client-application';
+export { type ClientApplication, createClientApplication } from './app/client-application';
 export * from './chart-data-options/types';
 export { Chart } from './chart';
 export { ThemeProvider } from './theme-provider';
 export * from './dashboard';
-export { DashboardWidget } from './dashboard-widget/dashboard-widget';
-export { getSortType } from './dashboard-widget/utils';
-export { type WidgetType, type CartesianWidgetType, type CategoricalWidgetType, type TabularWidgetType, type TextWidgetType, } from './dashboard-widget/types';
+export { DashboardWidget } from './widget-by-id/dashboard-widget';
+export { WidgetById } from './widget-by-id/widget-by-id';
+export { type WidgetType, type CartesianWidgetType, type CategoricalWidgetType, type TabularWidgetType, type TextWidgetType, } from './widget-by-id/types';
 export * from './query-execution';
 export { executeQuery } from './query/execute-query';
 export { SisenseContextProvider } from './sisense-context/sisense-context-provider';
 export { DrilldownWidget } from './widgets/drilldown-widget';
-export { processDrilldownSelections } from './widgets/common/use-drilldown';
+export { processDrilldownSelections } from './widgets/common/use-drilldown-core';
 export { ChartWidget } from './widgets/chart-widget';
 export { TableWidget } from './widgets/table-widget';
 export { PivotTableWidget } from './widgets/pivot-table-widget';
 export { TextWidget } from './widgets/text-widget';
+export { Widget } from './widgets/widget';
 export { ContextMenu } from './common/components/menu/context-menu/context-menu';
 export { DrilldownBreadcrumbs } from './widgets/common/drilldown-breadcrumbs';
 export * from './line-chart';
@@ -44,20 +45,29 @@ export { getThemeSettingsByOid } from './themes/theme-loader';
 export { getDefaultThemeSettings } from './theme-provider/default-theme-settings';
 export { useGetDashboardModel, useGetDashboardModels, getDashboardModel, getDashboardModels, useGetWidgetModel, getWidgetModel, translateToDashboardResponse, translateToDashboardsResponse, useGetHierarchyModels, getHierarchyModels, type DashboardModel, type GetDashboardModelParams, type GetDashboardModelsParams, type DashboardModelState, type DashboardModelLoadingState, type DashboardModelSuccessState, type DashboardModelErrorState, type DashboardModelsState, type DashboardModelsLoadingState, type DashboardModelsSuccessState, type DashboardModelsErrorState, type WidgetModel, type WidgetDataOptions, type WidgetModelState, type WidgetModelLoadingState, type WidgetModelErrorState, type WidgetModelSuccessState, type GetWidgetModelParams, type GetDashboardModelOptions, type GetDashboardModelsOptions, type WidgetsPanelColumnLayout as WidgetsPanelColumnLayout, type WidgetsPanelLayout as WidgetsPanelLayout, type WidgetId, type WidgetsOptions, type CommonFiltersOptions, type CommonFiltersApplyMode, type FiltersIgnoringRules, type HierarchyModel, type Hierarchy, type HierarchyId, type GetHierarchiesParams, type HierarchyModelsState, type HierarchyModelsLoadingState, type HierarchyModelsErrorState, type HierarchyModelsSuccessState, } from './models';
 /**
- * Utility functions to translate between widget abstractions of models and UI props.
+ * Utility functions to translate a Fusion widget model from and to other widget data structures
  *
- * @group Fusion Embed
+ * @group Fusion Assets
  * @fusionEmbed
+ * @shortDescription Utility functions to translate a Fusion widget model from and to other widget data structures
  */
 export * as widgetModelTranslator from './models/widget/widget-model-translator';
 /**
- * Utility functions to translate between dashboard abstractions of models and UI props.
+ * Utility functions to translate a Fusion dashboard model from and to other dashboard data structures
  *
- * @group Fusion Embed
+ * @group Fusion Assets
  * @fusionEmbed
+ * @shortDescription Utility functions to translate a Fusion dashboard model from and to other dashboard data structures
  */
 export * as dashboardModelTranslator from './models/dashboard/dashboard-model-translator';
-export type { AutoZoomNavigatorScrollerLocation } from './dashboard-widget/types';
+/**
+ * Utility functions to manipulate `DashboardProps`
+ *
+ * @group Dashboards
+ * @shortDescription Utility functions to manipulate dashboard elements
+ */
+export * as dashboardHelpers from './dashboard/dashboard-helpers';
+export type { AutoZoomNavigatorScrollerLocation } from './widget-by-id/types';
 export { boxWhiskerProcessResult } from './boxplot-utils';
 export { queryStateReducer } from './query-execution/query-state-reducer';
 export * from './props';
@@ -66,12 +76,17 @@ export * from './filters';
 export * from './formulas';
 export { trackHook } from './decorators/hook-decorators';
 export * from './common/hooks/data-load-state-reducer';
-export { createDataOptionsFromPanels } from './dashboard-widget/translate-widget-data-options';
+export { createDataOptionsFromPanels } from './widget-by-id/translate-widget-data-options';
 export { type DashboardDto } from './api/types/dashboard-dto';
-export { type WidgetDto } from './dashboard-widget/types';
-export { extractCombinedFilters } from './dashboard-widget/translate-dashboard-filters';
+export { type WidgetDto } from './widget-by-id/types';
+export { extractCombinedFilters } from './widget-by-id/translate-dashboard-filters';
 export { useThemeContext } from './theme-provider';
 export { LoadingIndicator } from './common/components/loading-indicator';
 export { LoadingOverlay } from './common/components/loading-overlay';
 export { useFetch, type RequestConfig, type UseQueryResult } from './common/hooks/use-fetch';
 export type { EmptyObject } from './utils/utility-types';
+export { translateColumnToAttribute } from './chart-data-options/utils';
+export { isSameAttribute } from './utils/filters';
+export { updateDrilldownSelections } from './widgets/common/use-drilldown-core';
+export { getSelectionTitleMenuItem, getDrilldownMenuItems } from './widgets/hooks/use-drilldown';
+export { type TranslationDictionary, PACKAGE_NAMESPACE as translationNamespace, } from './translation/resources';

package/dist/packages/sdk-ui/src/models/dashboard/dashboard-model-translator.d.ts

@@ -10,10 +10,10 @@ import { AppSettings } from '../../app/settings/settings.js';
  * ```tsx
  * <Dashboard {...dashboardModelTranslator.toDashboardProps(dashboardModel)} />
  * ```
- * @group Fusion Embed
+ * @group Fusion Assets
  * @fusionEmbed
  */
-export declare function toDashboardProps(dashboardModel: DashboardModel): Required<DashboardProps>;
+export declare function toDashboardProps(dashboardModel: DashboardModel): DashboardProps;
 /**
  * Creates a new dashboard model from a dashboard DTO.
  *

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

@@ -5,7 +5,7 @@ import { DashboardLayoutOptions } from '../../dashboard';
 /**
  * Model of Sisense Fusion dashboard defined in the abstractions of Compose SDK.
  *
- * @group Fusion Embed
+ * @group Fusion Assets
  * @fusionEmbed
  */
 export interface DashboardModel {

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

@@ -5,3 +5,5 @@ export * from './use-get-dashboard-model';
 export * from './use-get-dashboard-models';
 export * from './dashboard-model';
 export * as dashboardModelTranslator from './dashboard-model-translator';
+export * from './use-dashboard-model/use-dashboard-model';
+export * from './use-dashboard-model/use-dashboard-model-reducer';

package/dist/packages/sdk-ui/src/models/dashboard/translate-dashboard-dto-utils.d.ts

@@ -0,0 +1,11 @@
+import { Filter } from '@sisense/sdk-data';
+import { CascadingFilterDto, FilterDto } from '../../api/types/dashboard-dto';
+/**
+ * Translates a {@link Filter} to a {@link FilterDto}.
+ * @param filter
+ *
+ * @returns FilterDto
+ *
+ * @internal
+ */
+export declare function filterToFilterDto(filter: Filter): FilterDto | CascadingFilterDto;

package/dist/packages/sdk-ui/src/models/dashboard/translate-dashboard-utils.d.ts

@@ -1,7 +1,7 @@
 import { type LayoutDto, type FilterDto, type CascadingFilterDto } from '../../api/types/dashboard-dto';
 import type { WidgetsPanelColumnLayout, WidgetsOptions } from './types';
 import { Filter } from '@sisense/sdk-data';
-import { WidgetDto } from '../../dashboard-widget/types';
+import { WidgetDto } from '../../widget-by-id/types';
 export declare const translateLayout: (layout: LayoutDto) => WidgetsPanelColumnLayout;
 export declare function extractDashboardFilters(dashboardFilters: Array<FilterDto | CascadingFilterDto>): Filter[];
 export declare function translateWidgetsOptions(widgets?: WidgetDto[]): WidgetsOptions;

package/dist/packages/sdk-ui/src/models/dashboard/use-dashboard-model/use-dasboard-model-utils.d.ts

@@ -0,0 +1,22 @@
+import { UseDashboardModelAction } from '../../../models';
+import { DashboardChangeAction } from '../../../dashboard/dashboard';
+import { Authenticator } from '@sisense/sdk-rest-client';
+/**
+ * Convert a dashboard change action to a use dashboard model action.
+ * @param action - The dashboard change action to convert
+ *
+ * @returns The useDashboardModel action or null if the action is not supported
+ *
+ * @internal
+ */
+export declare function dashboardChangeActionToUseDashboardModelAction(action: DashboardChangeAction): UseDashboardModelAction | null;
+/**
+ * Check if the persistence is supported and log a warning if it is not.
+ * @param authType - The authentication type
+ * @param shouldWarn - Whether to log a warning
+ *
+ * @returns True if the persistence is supported, false otherwise
+ *
+ * @internal
+ */
+export declare function checkPersistenceSupport(authType: Authenticator['type'], shouldWarn: boolean): boolean;

package/dist/packages/sdk-ui/src/models/dashboard/use-dashboard-model/use-dashboard-model-reducer.d.ts

@@ -0,0 +1,63 @@
+import { DashboardModel } from '../../../models';
+import { Filter } from '@sisense/sdk-data';
+import { RestApi } from '../../../api/rest-api';
+export type UseDashboardModelState = DashboardModel | null;
+/**
+ * Internal action types for the dashboard model state used in {@link useDashboardModel}.
+ *
+ * @internal
+ */
+export declare enum UseDashboardModelActionTypeInternal {
+    DASHBOARD_INIT = "DASHBOARD.INIT"
+}
+/**
+ * Action types for the dashboard model state used in {@link useDashboardModel}.
+ *
+ * @internal
+ */
+export declare enum UseDashboardModelActionType {
+    FILTERS_UPDATE = "FILTERS.UPDATE"
+}
+/**
+ * Internal actions for the dashboard model state used in {@link useDashboardModel}.
+ *
+ * @internal
+ */
+type UseDashboardModelInternalAction = UseDashboardModelAction | {
+    type: UseDashboardModelActionTypeInternal.DASHBOARD_INIT;
+    payload: DashboardModel;
+};
+/**
+ * Actions for the dashboard model state used in {@link useDashboardModel}.
+ *
+ * @internal
+ */
+export type UseDashboardModelAction = {
+    type: UseDashboardModelActionType.FILTERS_UPDATE;
+    payload: Filter[];
+};
+/**
+ * Reducer for the dashboard model state used in {@link useDashboardModel}.
+ * @param state
+ * @param action
+ *
+ * @internal
+ */
+export declare function dashboardReducer(state: UseDashboardModelState, action: UseDashboardModelInternalAction): UseDashboardModelState;
+/**
+ * Middleware connector for {@link persistDashboardModelMiddleware}.
+ * @param restApi - The Sisense REST API instance
+ * @param reducer - The dashboard model reducer
+ *
+ * @internal
+ */
+export declare function withPersistDashboardModelMiddleware(restApi: RestApi, reducer: (state: UseDashboardModelState, action: UseDashboardModelInternalAction) => UseDashboardModelState): (state: UseDashboardModelState, action: UseDashboardModelInternalAction) => UseDashboardModelState;
+/**
+ * Middleware that persists the dashboard model changes to the Sisense server.
+ * @param restApi - The Sisense REST API instance
+ * @param reducer - The dashboard model reducer
+ *
+ * @internal
+ */
+export declare function persistDashboardModelMiddleware(state: DashboardModel, action: UseDashboardModelAction, restApi: RestApi): Promise<import("../../..").DashboardDto | undefined> | Promise<null>;
+export {};