@sisense/sdk-ui 1.18.1 → 1.20.0

package/dist/{api → packages/sdk-ui/src/api}/rest-api.d.ts

@@ -1,8 +1,10 @@
 import { HttpClient } from '@sisense/sdk-rest-client';
 import { FeatureCollection as GeoJsonFeatureCollection } from 'geojson';
-import { WidgetDto } from '../dashboard-widget/types';
+import { type DataSource } from '@sisense/sdk-data';
+import { HierarchyDto, WidgetDto } from '../dashboard-widget/types';
 import type { DashboardDto } from './types/dashboard-dto';
 import { PaletteDto } from '../api/types/palette-dto';
+import { GetHierarchiesOptions } from '../models/hierarchy/types';
 type GetDashboardsOptions = {
     searchByTitle?: string;
     fields?: string[];
@@ -13,7 +15,8 @@ type GetDashboardOptions = {
 };
 export declare class RestApi {
     private httpClient;
-    constructor(httpClient: HttpClient | undefined);
+    private defaultDataSource?;
+    constructor(httpClient: HttpClient | undefined, defaultDataSource?: DataSource);
     /**
      * Get all dashboards
      */
@@ -42,6 +45,10 @@ export declare class RestApi {
      * Get all palettes
      */
     getPalettes: () => Promise<PaletteDto[] | undefined>;
+    /**
+     * Get hierarchies
+     */
+    getHierarchies: ({ dataSource, dimension, ids, alwaysIncluded, }: GetHierarchiesOptions) => Promise<HierarchyDto[]>;
 }
 export declare const useGetApi: () => RestApi;
 export {};

package/dist/{api → packages/sdk-ui/src/api}/types/dashboard-dto.d.ts

@@ -1,8 +1,8 @@
-import { WidgetDto, Datasource } from '../../dashboard-widget/types';
-import { FilterJaql, FilterRelationsModel } from '@sisense/sdk-data';
+import { WidgetDto } from '../../dashboard-widget/types';
+import { FilterJaql, FilterRelationsModel, JaqlDataSource } from '@sisense/sdk-data';
 import { AnyObject } from '../../utils/utility-types';
 /** @internal */
-export type Layout = {
+export type LayoutDto = {
     columns: {
         width: number;
         cells?: {
@@ -44,12 +44,12 @@ export declare const isCascadingFilterDto: (filter: FilterDto | CascadingFilterD
 export type DashboardDto = {
     oid: string;
     title: string;
-    datasource: Datasource;
+    datasource: JaqlDataSource;
     widgets?: WidgetDto[];
     filters?: Array<FilterDto | CascadingFilterDto>;
     filterRelations?: {
         filterRelations: FilterRelationsModel;
     }[];
-    layout?: Layout;
+    layout?: LayoutDto;
     style?: DashboardStyleDto;
 } & AnyObject;

package/dist/{app → packages/sdk-ui/src/app}/settings/settings.d.ts

@@ -26,5 +26,5 @@ type ServerSettings = {
  * @param isWat - Whether the application is running with WAT authentication
  * @returns - Application settings
  */
-export declare function getSettings(customConfig: ConfigurableAppSettings, httpClient: Pick<HttpClient, 'get'>, useDefaultPalette?: boolean): Promise<AppSettings>;
+export declare function getSettings(customConfig: ConfigurableAppSettings, httpClient: Pick<HttpClient, 'get' | 'url'>, useDefaultPalette?: boolean): Promise<AppSettings>;
 export {};

package/dist/{chart-data → packages/sdk-ui/src/chart-data}/boxplot-data.d.ts

@@ -1,5 +1,5 @@
 import { DataTable } from '../chart-data-processor/table-processor.js';
-import { BoxplotChartData } from './types.js';
+import { BoxplotChartData, ChartData } from './types.js';
 import { BoxplotChartDataOptionsInternal } from '../chart-data-options/types.js';
 /**
  * Creates data for box plot charts given chart data table and data options
@@ -9,3 +9,4 @@ import { BoxplotChartDataOptionsInternal } from '../chart-data-options/types.js'
  * @returns Box plot chart data
  */
 export declare const boxplotData: (chartDataOptions: BoxplotChartDataOptionsInternal, dataTable: DataTable) => BoxplotChartData;
+export declare function isBoxplotChartData(chartData: ChartData): chartData is BoxplotChartData;

package/dist/{chart-data → packages/sdk-ui/src/chart-data}/cartesian-data.d.ts

@@ -3,6 +3,13 @@ import { Column, DataTable } from '../chart-data-processor/table-processor';
 import { CartesianChartData, CategoricalXValues } from './types';
 import { CartesianChartDataOptionsInternal, Value } from '../chart-data-options/types';
 export declare const validateCartesianChartDataOptions: (chartDataOptions: CartesianChartDataOptionsInternal) => CartesianChartDataOptionsInternal;
+/**
+ * Creates cartesian data for chart like line/area/bar and others given table of data and options
+ *
+ * @param chartDataOptions - Internal cartesian chart data options
+ * @param dataTable - Data table
+ * @returns Cartesian chart data
+ */
 export declare const cartesianData: (chartDataOptions: CartesianChartDataOptionsInternal, dataTable: DataTable) => CartesianChartData;
 export declare const sortDirection: (sortType: SortDirection | undefined) => 1 | -1 | 0;
 export declare const getOrderedXValues: (dataTable: DataTable, sortedMeasures: Value[], xColumns: Column[], rownumColumnName?: string) => CategoricalXValues[];

package/dist/{chart-data-options → packages/sdk-ui/src/chart-data-options}/utils.d.ts

@@ -23,4 +23,21 @@ export declare const translateCategoryToAttribute: (category: Category) => Attri
 export declare const getDataOptionTitle: (option: Category | Value) => string;
 export declare const translateColumnToAttribure: (c: StyledColumn | Column) => Attribute;
 export declare const translateColumnToMeasure: (c: MeasureColumn | CalculatedMeasureColumn | StyledMeasureColumn) => Measure;
+export declare const translateCategoryOrValueToColumn: <Source extends Value | Category, Target extends AnyColumn>(option: Source) => Target;
+export declare const translateCategoryToColumn: (option: Category) => Column | StyledColumn;
+export declare const translateValueToColumn: (option: Value) => MeasureColumn | CalculatedMeasureColumn | StyledMeasureColumn;
+/**
+ * Checks if category is a StyledColumns.
+ *
+ * @param category - The category to check.
+ * @internal
+ */
+export declare function isStyledColumn(category: Column | StyledColumn): category is StyledColumn;
+/**
+ * Checks if an category is a StyledCategory.
+ *
+ * @param category - The category to check.
+ * @internal
+ */
+export declare function isCategoryStyle(category: Column | CategoryStyle): category is CategoryStyle;
 export {};

package/dist/{chart-options-processor → packages/sdk-ui/src/chart-options-processor}/advanced-chart-options.d.ts

@@ -1,5 +1,7 @@
+import { Measure } from '@sisense/sdk-data';
 import { SeriesType } from './chart-options-service';
 import { AxisSettings } from './translations/axis-section';
+import { CartesianChartDataOptions } from '..';
 export declare const FORECAST_PREFIX = "$forecast";
 export declare const TREND_PREFIX = "$trend";
 export declare const isForecastSeries: (name: string) => boolean;
@@ -21,3 +23,19 @@ export declare const formatTrendSeries: (series: SeriesType, seriesHash: {
     [x: string]: SeriesType;
 }) => void;
 export declare const formatAdvancedAnalyticsSeries: (series: SeriesType[]) => void;
+/**
+ * Extracts trend measures from data options if applicable.
+ *
+ * @param dataOptions - The Cartesian chart data options.
+ * @returns An array of trend measures.
+ * @internal
+ */
+export declare const extractTrendMeasures: (dataOptions: CartesianChartDataOptions) => Measure[];
+/**
+ * Extracts forecast measures from data options if applicable.
+ *
+ * @param dataOptions - The Cartesian chart data options.
+ * @returns An array of forecast measures.
+ * @internal
+ */
+export declare const extractForecastMeasures: (dataOptions: CartesianChartDataOptions) => Measure[];

package/dist/{chart-options-processor → packages/sdk-ui/src/chart-options-processor}/apply-event-handlers.d.ts

@@ -1,6 +1,7 @@
 import { HighchartsPointerEvent, HighchartsSelectEvent } from '../types';
 import { HighchartsOptionsInternal } from '../chart-options-processor/chart-options-service';
 import { SisenseChartDataPointEventHandler, SisenseChartDataPointsEventHandler } from '../sisense-chart/types';
+import { ChartDataOptionsInternal } from '..';
 export type HighchartsEventOptions = {
     chart: {
         zoomType?: string;
@@ -19,7 +20,7 @@ export type HighchartsEventOptions = {
         };
     };
 };
-export declare const applyEventHandlersToChart: (chartOptions: HighchartsOptionsInternal, { onDataPointClick, onDataPointContextMenu, onDataPointsSelected, }?: {
+export declare const applyEventHandlersToChart: (chartOptions: HighchartsOptionsInternal, dataOptions: ChartDataOptionsInternal, { onDataPointClick, onDataPointContextMenu, onDataPointsSelected, }?: {
     onDataPointClick?: SisenseChartDataPointEventHandler | undefined;
     onDataPointContextMenu?: SisenseChartDataPointEventHandler | undefined;
     onDataPointsSelected?: SisenseChartDataPointsEventHandler | undefined;

package/dist/packages/sdk-ui/src/chart-options-processor/data-points.d.ts

@@ -0,0 +1,10 @@
+import { HighchartsPoint } from '../types';
+import { SisenseChartDataPoint } from '../sisense-chart/types';
+import { Category, ChartDataOptionsInternal, Value } from '..';
+export declare function getDataPointMetadata(dataOptionPath: string, dataOption: Category | Value): {
+    measure?: import("@sisense/sdk-data").Measure | undefined;
+    attribute?: import("@sisense/sdk-data").Attribute | undefined;
+    id: string;
+    dataOption: import("..").AnyColumn;
+};
+export declare function getDataPoint(point: HighchartsPoint, dataOptions: ChartDataOptionsInternal): SisenseChartDataPoint;

package/dist/{chart-options-processor → packages/sdk-ui/src/chart-options-processor}/translations/design-options.d.ts

@@ -44,6 +44,7 @@ export type PolarType = 'line' | 'area' | 'column';
 export type PolarChartDesignOptions = CartesianChartDesignOptions & {
     polarType: PolarType;
 };
+export declare function isPolarChartDesignOptions(options: CartesianChartDesignOptions): options is PolarChartDesignOptions;
 export type PieChartDesignOptions = BaseDesignOptionsType & {
     pieType?: PieType;
     pieLabels?: PieLabels;

package/dist/{chart-options-processor → packages/sdk-ui/src/chart-options-processor}/translations/translations-to-highcharts.d.ts

@@ -1,7 +1,7 @@
 import { ChartType } from '../../types';
 import { ChartDataOptionsInternal, CategoricalChartDataOptionsInternal, CartesianChartDataOptionsInternal } from '../../chart-data-options/types';
 import { CategoricalSeriesValues, ChartData, CartesianChartData } from '../../chart-data/types';
-import { StackableChartDesignOptions } from './design-options';
+import { PolarChartDesignOptions, StackableChartDesignOptions } from './design-options';
 import { AxisMinMax, AxisSettings } from './axis-section';
 import { Stacking } from '../chart-options-service';
 import { DesignOptions } from './types';
@@ -60,7 +60,7 @@ export type AxisClipped = {
  * @returns internal highcharts chart type
  */
 export declare const determineHighchartsChartType: (chartType: ChartType, designOptions: DesignOptions) => HighchartsType;
-export declare const addStackingIfSpecified: (chartType: ChartType, designOptions: StackableChartDesignOptions) => {
+export declare const addStackingIfSpecified: (chartType: ChartType, designOptions: StackableChartDesignOptions | PolarChartDesignOptions) => {
     stacking?: Stacking | undefined;
     showTotal: boolean;
 };

package/dist/packages/sdk-ui/src/charts/map-charts/areamap/areamap-utils.d.ts

@@ -0,0 +1,11 @@
+import { AreamapChartDataOptionsInternal, GeoDataElement } from '../../../index';
+export declare function getAreamapDataPoint(geoDataElement: GeoDataElement, dataOptions: AreamapChartDataOptionsInternal): {
+    entries: {
+        geo: import('../../../index').DataPointEntry[];
+        color: import('../../../index').DataPointEntry[];
+    };
+    geoName: string;
+    originalValue: number;
+    formattedOriginalValue: string;
+    color?: import('../../../index').Color | undefined;
+};

package/dist/{charts → packages/sdk-ui/src/charts}/map-charts/areamap/areamap.d.ts

@@ -1,6 +1,6 @@
 /// <reference types="react" />
 import { AreamapChartDataOptionsInternal } from '../../../chart-data-options/types.js';
-import { AreamapData } from '../../../chart-data/types.js';
+import { AreamapData, ChartData } from '../../../chart-data/types.js';
 import { AreamapChartDesignOptions } from '../../../chart-options-processor/translations/design-options.js';
 import { AreamapDataPointEventHandler } from '../../../props';
 import { ChartRendererProps } from '../../../chart/types.js';
@@ -11,4 +11,5 @@ export type AreamapProps = {
     onDataPointClick?: AreamapDataPointEventHandler;
 };
 export declare const Areamap: React.FC<AreamapProps>;
+export declare const isAreamapData: (chartData: ChartData) => chartData is AreamapData;
 export declare const isAreamapProps: (props: ChartRendererProps) => props is AreamapProps;

package/dist/{charts → packages/sdk-ui/src/charts}/map-charts/scattermap/scattermap.d.ts

@@ -1,4 +1,4 @@
-import { ScattermapChartData } from '../../../chart-data/types.js';
+import { ChartData, ScattermapChartData } from '../../../chart-data/types.js';
 import { ScattermapDataPointEventHandler } from '../../../props.js';
 import { ScattermapChartDataOptionsInternal } from '../../../chart-data-options/types.js';
 import { ScattermapChartDesignOptions } from '../../../chart-options-processor/translations/design-options.js';
@@ -13,4 +13,5 @@ export type ScattermapProps = {
     onDataPointClick?: ScattermapDataPointEventHandler;
 };
 export declare const Scattermap: ({ chartData, dataOptions, dataSource, filters, designOptions, onDataPointClick, }: ScattermapProps) => import("react/jsx-runtime").JSX.Element;
+export declare const isScattermapData: (chartData: ChartData) => chartData is ScattermapChartData;
 export declare const isScattermapProps: (props: ChartRendererProps) => props is ScattermapProps;

package/dist/{charts → packages/sdk-ui/src/charts}/map-charts/scattermap/utils/location.d.ts

@@ -1,8 +1,8 @@
-import { ScattermapLocationLevel } from '../../../../chart-data-options/types';
+import { ScattermapLocationLevel, ScattermapChartDataOptionsInternal } from '../../../../chart-data-options/types';
 import { ScattermapDataPoint } from '../../../../types';
 import { ScattermapChartLocation } from '../../../../chart-data/types';
 export declare const LOCATION_DELIMITER = ",";
 export declare function combineLocationNames(names: string[]): string;
 export declare function splitLocationName(combinedLocation: string): string[];
 export declare function getLocationGeoLevel(level: ScattermapLocationLevel): "country" | "city" | "adm" | undefined;
-export declare function locationToScattermapDataPoint(location: ScattermapChartLocation): ScattermapDataPoint;
+export declare function getScattermapDataPoint(location: ScattermapChartLocation, dataOptions: ScattermapChartDataOptionsInternal): ScattermapDataPoint;

package/dist/packages/sdk-ui/src/common/components/loading-indicator.d.ts

@@ -0,0 +1,13 @@
+import { CompleteThemeSettings } from '../../types';
+/**
+ * Component that displays a loading indicator.
+ *
+ * @param themeSettings - Theme settings to use for the loading indicator.
+ * @param onCancel - Function to call when cancel is clicked.
+ * @returns A loading indicator with optional cancel.
+ * @internal
+ */
+export declare const LoadingIndicator: ({ themeSettings, onCancel, }: {
+    themeSettings?: CompleteThemeSettings | undefined;
+    onCancel?: (() => void) | undefined;
+}) => import("react/jsx-runtime").JSX.Element;

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

@@ -0,0 +1,7 @@
+import { ContextMenuProps } from '../../../../props';
+/**
+ * Context menu
+ *
+ * @group Drilldown
+ */
+export declare const ContextMenu: ({ position, itemSections, children, closeContextMenu, }: ContextMenuProps) => import("react/jsx-runtime").JSX.Element;

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

@@ -0,0 +1 @@
+export { ContextMenu } from './context-menu';

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

@@ -0,0 +1,10 @@
+import { CSSProperties, ReactNode } from 'react';
+type MenuItemProps = {
+    children: ReactNode;
+    disabled?: boolean;
+    style?: CSSProperties;
+    className?: string;
+    onClick?: () => void;
+};
+export declare const MenuItem: ({ children, disabled, style, className, onClick }: MenuItemProps) => import("react/jsx-runtime").JSX.Element;
+export {};

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

@@ -0,0 +1,6 @@
+import { ReactNode } from 'react';
+type MenuSectionProps = {
+    children: ReactNode;
+};
+export declare const MenuSection: ({ children }: MenuSectionProps) => import("react/jsx-runtime").JSX.Element;
+export {};

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

@@ -0,0 +1,10 @@
+import { ReactNode } from 'react';
+import { MenuPosition } from '../../../../index';
+type MenuProps = {
+    children: ReactNode;
+    open: boolean;
+    position: MenuPosition | null;
+    onClose: () => void;
+};
+export declare const Menu: ({ children, open, position, onClose }: MenuProps) => import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/packages/sdk-ui/src/common/components/menu/context-menu/nested-menu-item.d.ts

@@ -0,0 +1,11 @@
+import { CSSProperties, ReactNode } from 'react';
+type NestedMenuItemProps = {
+    children: ReactNode;
+    label: string | ReactNode;
+    allowOpen: boolean;
+    disabled?: boolean;
+    style?: CSSProperties;
+    className?: string;
+};
+export declare const NestedMenuItem: ({ children, label, allowOpen, disabled, style, className, }: NestedMenuItemProps) => import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/packages/sdk-ui/src/common/components/menu/context-menu/right-arrow-icon.d.ts

@@ -0,0 +1,3 @@
+export default function RightArrowIcon({ color }: {
+    color?: string;
+}): import("react/jsx-runtime").JSX.Element;

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

@@ -0,0 +1,15 @@
+/// <reference types="react" />
+import { OpenMenuFn } from './types';
+type MenuSettings = {
+    openMenu: OpenMenuFn;
+    closeMenu: () => void;
+};
+export declare const MenuContext: import("react").Context<MenuSettings | null>;
+/**
+ * Hook to get the menu context (menu API)
+ *
+ * @returns The menu context
+ * @internal
+ */
+export declare const useMenuContext: () => MenuSettings | null;
+export {};

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

@@ -0,0 +1,12 @@
+/**
+ * A collection of unique menu IDs for all menu sections from all components.
+ *
+ * Each default menu section in the CSDK should have an unique 'id' to distinguish it.
+ *
+ * @internal
+ */
+export declare enum MenuIds {
+    DRILLDOWN_CHART_POINTS_SELECTION = "drilldown-chart-points-selection",
+    DRILLDOWN_DRILL_DIRECTIONS = "drilldown-drill-directions",
+    CROSSFILTERING_CHART_POINTS_SELECTION = "crossfiltering-chart-points-selection"
+}

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

@@ -0,0 +1,11 @@
+/// <reference types="react" />
+import { BeforeMenuOpenHandler } from './types';
+export interface MenuProviderProps {
+    /** Optional handler function to process menu options before opening the menu. */
+    onBeforeMenuOpen?: BeforeMenuOpenHandler;
+    children?: React.ReactNode;
+}
+/**
+ * The general menu provider component that decides whether to use the root or node-level menu provider.
+ */
+export declare const MenuProvider: ({ children, onBeforeMenuOpen }: MenuProviderProps) => import("react/jsx-runtime").JSX.Element;

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

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

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

@@ -0,0 +1,20 @@
+import { MenuOptions } from '../components/menu/types.js';
+type IsTargetMenuFn = (menuOptions: MenuOptions) => boolean;
+type CombineMenusFn = (currentMenuOptions: MenuOptions, capturedMenuOptions: MenuOptions) => MenuOptions;
+interface CombinedMenuParams {
+    /** Function to determine if the captured menu is the target menu */
+    isTargetMenu: IsTargetMenuFn;
+    /** Function to combine the current menu options with the captured menu options */
+    combineMenus: CombineMenusFn;
+}
+/**
+ * Custom hook to manage a combined menu, allowing you to capture
+ * other menu before openning and combine it with the current one.
+ *
+ * @internal
+ */
+export declare const useCombinedMenu: ({ isTargetMenu, combineMenus }: CombinedMenuParams) => {
+    openMenu: (options: MenuOptions) => void;
+    onBeforeMenuOpen: (options: MenuOptions) => MenuOptions | null;
+};
+export {};

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

@@ -0,0 +1,11 @@
+/**
+ * Hook to access menu API.
+ *
+ * Throws an error if used outside the menu context.
+ *
+ * @internal
+ */
+export declare const useMenu: () => {
+    openMenu: import("../components/menu/types.js").OpenMenuFn;
+    closeMenu: () => void;
+};

package/dist/packages/sdk-ui/src/common/hooks/use-with-change-detection.d.ts

@@ -0,0 +1,20 @@
+import { AnyObject } from '../../utils/utility-types';
+export declare const defaultMerger: <P extends AnyObject>(existingValue: P, delta: Partial<P>) => P & Partial<P>;
+type UseWithChangeDetectionParams<P extends AnyObject> = {
+    target: P | P[];
+    onChange: (delta: Partial<P>, index?: number) => void;
+};
+/**
+ * A hook that extends a target object (or array of objects) with change detection functionality.
+ * It monitors changes and triggers the provided `onChange` callback whenever a change occurs.
+ *
+ * This hook can handle both single object and array of objects.
+ *
+ * @internal
+ */
+export declare function useWithChangeDetection<P extends AnyObject>(params: UseWithChangeDetectionParams<P>): (P & {
+    onChange: (delta: Partial<P>) => void;
+}) | (P & {
+    onChange: (delta: Partial<P>) => void;
+})[];
+export {};

package/dist/{common-filters → packages/sdk-ui/src/common-filters}/common-filters-connector.d.ts

@@ -2,7 +2,9 @@ import { type Filter } from '@sisense/sdk-data';
 import { ChartDataOptions, ChartWidgetProps, PivotTableDataOptions, RenderToolbarHandler } from '../index.js';
 import { CommonFiltersOptions } from './types.js';
 import { WidgetTypeInternal } from '../models/widget/types';
-type CommonFiltersToWidgetConnectProps = Pick<ChartWidgetProps, 'filters' | 'highlights' | 'onDataPointClick' | 'onDataPointsSelected'> & {
+import { OpenMenuFn } from '../common/components/menu/types';
+import { TFunction } from '@sisense/sdk-common';
+type CommonFiltersToWidgetConnectProps = Pick<ChartWidgetProps, 'filters' | 'highlights' | 'onDataPointClick' | 'onDataPointsSelected' | 'onDataPointContextMenu'> & {
     renderToolbar: RenderToolbarHandler;
 };
 /**
@@ -11,5 +13,5 @@ type CommonFiltersToWidgetConnectProps = Pick<ChartWidgetProps, 'filters' | 'hig
  * @param filters - Pure filters (non-cascading)
  * @param setFilters - Function to set updated pure filters (non-cascading)
  */
-export declare function prepareCommonFiltersToWidgetConnectProps(commonFilters: Filter[], updateCommonFilters: (filters: Filter[]) => void, widgetType: WidgetTypeInternal, dataOptions: ChartDataOptions | PivotTableDataOptions, options: CommonFiltersOptions): CommonFiltersToWidgetConnectProps;
+export declare function prepareCommonFiltersToWidgetConnectProps(commonFilters: Filter[], updateCommonFilters: (filters: Filter[]) => void, widgetType: WidgetTypeInternal, dataOptions: ChartDataOptions | PivotTableDataOptions, options: CommonFiltersOptions, translate: TFunction, openMenu?: OpenMenuFn): CommonFiltersToWidgetConnectProps;
 export {};

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

@@ -0,0 +1,15 @@
+import { Attribute, Filter } from '@sisense/sdk-data';
+import { ChartDataOptions, ChartDataPoint, PivotTableDataOptions, MenuItemSection } from '../index.js';
+import { WidgetTypeInternal } from '../models/widget/types.js';
+export declare const SELECTION_TITLE_MAXIMUM_ITEMS = 2;
+type DataSelection = {
+    attribute: Attribute;
+    values: (string | number)[];
+    displayValues: string[];
+};
+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[];
+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/{common-filters → packages/sdk-ui/src/common-filters}/use-common-filters.d.ts

@@ -1,13 +1,15 @@
 /// <reference types="react" />
 import { type Filter } from '@sisense/sdk-data';
-import { WidgetModel } from '../index.js';
 import { CommonFiltersOptions } from './types.js';
+import { WidgetProps } from '../props.js';
+import { OpenMenuFn } from '../common/components/menu/types.js';
 /** @internal */
-export declare const useCommonFilters: ({ initialFilters, }?: {
+export declare const useCommonFilters: ({ initialFilters, openMenu, }?: {
     initialFilters?: Filter[] | undefined;
+    openMenu?: OpenMenuFn | undefined;
 }) => {
     filters: Filter[];
     setFilters: import("react").Dispatch<import("react").SetStateAction<Filter[]>>;
     addFilter: (newFilter: Filter) => void;
-    connectToWidgetModel: (widget: WidgetModel, options?: CommonFiltersOptions) => WidgetModel;
+    connectToWidgetProps: (widget: WidgetProps, options?: CommonFiltersOptions) => WidgetProps;
 };

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

@@ -0,0 +1,24 @@
+import { WidgetsPanelLayout } from '../../models';
+import { WidgetProps } from '../../props';
+/**
+ * Props for the {@link ContentPanel} component.
+ *
+ * @internal
+ */
+export interface ContentPanelProps {
+    /**
+     * An object defining how the widgets should be laid out.
+     */
+    layout?: WidgetsPanelLayout;
+    /**
+     * A list of widget props to render.
+     */
+    widgets: WidgetProps[];
+}
+/**
+ * A React component used for rendering a layout of widgets.
+ *
+ * @param props - {@link ContentPanelProps}
+ * @internal
+ */
+export declare const ContentPanel: ({ layout, widgets }: ContentPanelProps) => import("react/jsx-runtime").JSX.Element;

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

@@ -0,0 +1,2 @@
+import { DashboardContainerProps } from '../../dashboard/types';
+export declare const DashboardContainer: ({ title, layoutOptions, config, widgets, filters, onFiltersChange, defaultDataSource, }: DashboardContainerProps) => import("react/jsx-runtime").JSX.Element;

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

@@ -22,9 +22,8 @@ import { DashboardByIdProps } from './types';
 
   export default CodeExample;
  * ```
- *
  * @group Fusion Embed
  * @fusionEmbed
- * @alpha
+ * @beta
  */
 export declare const DashboardById: import("react").FunctionComponent<DashboardByIdProps>;

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

@@ -7,8 +7,10 @@ import { DashboardProps } from '../dashboard/types';
  *
  * @example
  *
+ * Example of rendering a Fusion dashboard using the `useGetDashboardModel hook and the `Dashboard` component.
+ *
  * ```ts
- * import { Dashboard, useGetDashboardModel } from '@sisense/sdk-ui';
+ * import { Dashboard, useGetDashboardModel, dashboardModelTranslator } from '@sisense/sdk-ui';
 
 const CodeExample = () => {
   const { dashboard } = useGetDashboardModel({
@@ -20,17 +22,7 @@ const CodeExample = () => {
   return (
     <>
       {dashboard && (
-        <Dashboard
-        defaultDataSource={dashboard.dataSource}
-        title={dashboard.title}
-        layout={dashboard.layout}
-        styleOptions={dashboard.styleOptions}
-        widgets={dashboard.widgets}
-        filters={dashboard.filters}
-        widgetFilterOptions={
-          dashboard.widgetFilterOptions
-        }
-        />
+        <Dashboard {...dashboardModelTranslator.toDashboardProps(dashboard)} />
       )}
     </>
   );
@@ -38,9 +30,7 @@ const CodeExample = () => {
 
 export default CodeExample;
  * ```
- *
- * @group Fusion Embed
- * @fusionEmbed
- * @alpha
+ * @group Dashboarding
+ * @beta
  */
 export declare const Dashboard: import("react").FunctionComponent<DashboardProps>;

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

@@ -0,0 +1,3 @@
+export { DashboardById } from './dashboard-by-id';
+export { Dashboard } from './dashboard';
+export type { DashboardByIdProps, DashboardProps, DashboardLayoutOptions, DashboardStyleOptions, DashboardConfig, } from './types';