@sisense/sdk-ui 1.21.0 → 1.22.0

package/dist/packages/sdk-ui/src/ai/chat-config.d.ts

@@ -33,7 +33,7 @@ export interface ChatConfig {
      */
     chatMode?: ChatMode;
     /** The input prompt text to show in the chat input box */
-    inputPromptText: string;
+    inputPromptText?: string;
     /**
      * The welcome text to show at the top of a chat session.
      *

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

@@ -49,6 +49,10 @@ export declare class RestApi {
      * Get hierarchies
      */
     getHierarchies: ({ dataSource, dimension, ids, alwaysIncluded, }: GetHierarchiesOptions) => Promise<HierarchyDto[]>;
+    /**
+     * Partially update a dashboard
+     */
+    patchDashboard: (dashboardOid: string, dashboard: Partial<DashboardDto>) => Promise<DashboardDto | undefined>;
 }
 export declare const useGetApi: () => RestApi;
 export {};

package/dist/packages/sdk-ui/src/app/client-application.d.ts

@@ -1,10 +1,10 @@
-import { HttpClient, Authenticator } from '@sisense/sdk-rest-client';
+import { HttpClient } from '@sisense/sdk-rest-client';
 import { QueryClient } from '@sisense/sdk-query-client';
 import { DataSource } from '@sisense/sdk-data';
 import { DateConfig } from '../query/date-formats';
 import { AppSettings } from './settings/settings';
 import { PivotClient } from '@sisense/sdk-pivot-client';
-import { LoadingIndicatorConfig } from '../types';
+import { CustomTranslationObject, LoadingIndicatorConfig } from '../types';
 import { TrackingEventDetails } from '@sisense/sdk-tracking';
 import { SisenseContextProviderProps } from '../props';
 /**
@@ -15,10 +15,60 @@ export type AppConfig = {
      * A [date-fns Locale](https://date-fns.org/v2.30.0/docs/Locale)
      */
     locale?: Locale;
+    /**
+     * Translation Configurations
+     *
+     * @internal
+     */
+    translationConfig?: {
+        /**
+         * Language code to be used for translations
+         *
+         * @internal
+         */
+        language?: string;
+        /**
+         * Additional translation resources to be loaded
+         *
+         * You can find the list of available translation keys in the translation folder of every package.
+         *
+         * Translation keys that are not provided will default to the English translation.
+         * If translation is provided for a package other than sdk-ui, please specify the packageName property using camelCase.
+         *
+         * Important: Do not translate parts in {{}} - these are placeholders for dynamic values and will be matched using provided variable names.
+         *
+         * @example
+         * ```typescript
+         * customTranslations: [
+         *   {
+         *     language: 'fr',
+         *     resources: {
+         *       errors: {
+         *        invalidFilterType: 'Type de filtre invalide',
+         *       },
+         *     },
+         *   },
+         *   {
+         *     language: 'es',
+         *     packageName: 'sdkData'
+         *     resources: {
+         *       errors: {
+         *         measure: {
+         *           unsupportedType: 'Tipo de medida no compatible',
+         *         },
+         *       },
+         *     },
+         *   },
+         * ]
+         * ```
+         */
+        customTranslations?: CustomTranslationObject[];
+    };
     /**
      * Language code to be used for translations
      *
      * @internal
+     * @deprecated Use `translationConfig.language` instead
      */
     language?: string;
     /**
@@ -81,10 +131,12 @@ export type AppConfig = {
      */
     trackingConfig?: {
         /**
-         * Whether to enable tracking
+         * Whether to enable or disable tracking in development or test environment.
          *
          * If not specified, the default value is `true`
          *
+         * In production, tracking is always enabled.
+         *
          * @internal
          */
         enabled?: boolean;
@@ -99,7 +151,7 @@ export type AppConfig = {
  *
  * @internal
  */
-export declare class ClientApplication {
+export interface ClientApplication {
     /**
      * Gets the underlying HTTP Client
      */
@@ -115,7 +167,7 @@ export declare class ClientApplication {
     /**
      * Gets the default data source being used as default for child components with no explicitly defined data source
      */
-    readonly defaultDataSource: DataSource;
+    readonly defaultDataSource?: DataSource;
     /**
      * Gets the application settings
      */
@@ -129,14 +181,6 @@ export declare class ClientApplication {
          */
         clear: () => void;
     };
-    /**
-     * Construct new Sisense Client Application
-     *
-     * @param url - URL to the sisense environment
-     * @param auth - Authentication to be used
-     * @param defaultDataSource - Default data source to be used by child components by default
-     */
-    constructor(url: string, auth: Authenticator, defaultDataSource?: DataSource);
 }
 type ClientApplicationParams = Pick<SisenseContextProviderProps, 'appConfig' | 'defaultDataSource' | 'url' | 'token' | 'wat' | 'ssoEnabled' | 'enableSilentPreAuth' | 'useFusionAuth'>;
 /** @internal */

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

@@ -17,6 +17,11 @@ type ServerSettings = {
     serverLanguage: string;
     serverVersion: string;
     serverFeatures: FeatureMap;
+    user: {
+        tenant: {
+            name: string;
+        };
+    };
 };
 /**
  * Gets the application settings

package/dist/packages/sdk-ui/src/boxplot-utils.d.ts

@@ -14,10 +14,11 @@ export declare const boxWhiskerProcessResultInternal: (boxWhiskerData: QueryResu
 /**
  * Processes box whisker data and outliers data to combine them into a single data set.
  *
- * @param {QueryResultData} boxWhiskerData - The data for the box whisker.
- * @param {QueryResultData} outliersData - The data for the outliers.
- * @param {BoxplotChartCustomDataOptions} [dataOptions] - Optional data options for customizing data processing.
- * @returns {QueryResultData} The combined data with outliers included in the box whisker plot.
+ * @param boxWhiskerData - The data for the box whisker.
+ * @param outliersData - The data for the outliers.
+ * @param dataOptions - Optional data options for customizing data processing.
+ * @returns The combined data with outliers included in the box whisker plot.
+ * @shortDescription Utility function that combines box whisker data and outliers data
  * @group Charts
  */
 export declare function boxWhiskerProcessResult(boxWhiskerData: QueryResultData, outliersData: QueryResultData, dataOptions?: BoxplotChartCustomDataOptions): QueryResultData;

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

@@ -16,6 +16,7 @@ import { ChartProps } from '../props';
  *
  * @param props - Chart properties
  * @returns Chart component representing a chart type as specified in `ChartProps.`{@link ChartProps.chartType | chartType}
+ * @shortDescription Common component for rendering charts of different types including table
  * @group Charts
  */
 export declare const Chart: import("react").FunctionComponent<ChartProps>;

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

@@ -75,7 +75,7 @@ export declare const addStackingIfSpecified: (chartType: ChartType, designOption
  */
 export declare const indexMapWhenOnlyY: (categories: string[], index: number) => (-1 | 0)[];
 export declare const formatSeriesContinuousXAxis: (series: CategoricalSeriesValues, indexMap: number[], treatNullDataAsZeros: boolean, interval: number, maxCategories: number, dateFormatter: (time: number) => string, yAxisSettings: AxisSettings, axisClipped: AxisClipped) => HighchartsSeriesValues;
-export declare const formatSeries: (series: CategoricalSeriesValues, indexMap: number[], treatNullDataAsZeros: boolean, categories?: string[], categoryColors?: string[]) => HighchartsSeriesValues;
+export declare const formatSeries: (series: CategoricalSeriesValues, indexMap: number[], treatNullDataAsZeros: boolean, categories?: string[], categoryColors?: string[], convertValuesToAbsolute?: boolean) => HighchartsSeriesValues;
 export declare const adjustMinMaxWhenInvalid: (explicitAxis: AxisMinMax, autoMinMax: AxisMinMax) => {
     min: number;
     max: number;

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/dashboard-widget/dashboard-widget.d.ts

@@ -11,7 +11,7 @@ import { DashboardWidgetProps } from '../props';
  *
  * ## Example
  *
- * Display two dashboard widgets from a Fusion Embed instance.
+ * Display two dashboard widgets from a Fusion instance.
  *
  * <iframe
  *  src='https://csdk-playground.sisense.com/?example=fusion-assets%2Ffusion-widgets&mode=docs'
@@ -20,7 +20,7 @@ import { DashboardWidgetProps } from '../props';
  *  style='border:none;'
  * />
  *
- * @group Fusion Embed
+ * @group Fusion Assets
  * @fusionEmbed
  */
 export declare const DashboardWidget: FunctionComponent<DashboardWidgetProps>;

package/dist/packages/sdk-ui/src/dashboard-widget/translate-widget-data-options.d.ts

@@ -1,8 +1,8 @@
-import { DimensionalBaseMeasure, DimensionalAttribute, DimensionalCalculatedMeasure, Jaql, JaqlDataSource } from '@sisense/sdk-data';
+import { DimensionalBaseMeasure, DimensionalAttribute, DimensionalCalculatedMeasure, Jaql, JaqlDataSource, Filter } from '@sisense/sdk-data';
 import { StyledMeasureColumn, StyledColumn, Color } from '../types';
 import { Panel, PanelItem, WidgetType, WidgetStyle, BoxplotWidgetStyle } from './types';
 import { WidgetDataOptions } from '../models';
-export declare function createDimensionalElementFromJaql(jaql: Jaql, format?: PanelItem['format']): import("@sisense/sdk-data").Filter | DimensionalAttribute | DimensionalCalculatedMeasure | DimensionalBaseMeasure;
+export declare function createDimensionalElementFromJaql(jaql: Jaql, format?: PanelItem['format']): Filter | DimensionalAttribute | DimensionalCalculatedMeasure | DimensionalBaseMeasure;
 /** @internal */
 export declare function applyStatisticalModels(dataOption: StyledMeasureColumn, statisticalModels?: {
     forecast?: {
@@ -19,9 +19,19 @@ export declare function applyStatisticalModels(dataOption: StyledMeasureColumn,
 }): StyledMeasureColumn;
 export declare function createDataColumn(item: PanelItem, customPaletteColors?: Color[]): StyledColumn | StyledMeasureColumn;
 /** @internal */
+export declare function createPanelItem(column: StyledColumn | StyledMeasureColumn): PanelItem;
+/** @internal */
 export declare const createDataOptionsFromPanels: (panels: Panel[], variantColors: Color[]) => {
     [key: string]: any[];
 };
+export declare const createPanelsFromDataOptions: (dataOptions: {
+    [key: string]: any[];
+}) => {
+    name: string;
+    items: {
+        jaql: any;
+    }[];
+}[];
 export declare function createColumnsFromPanelItems<ColumnType = StyledColumn | StyledMeasureColumn>(panels: Panel[], panelName: string, customPaletteColors?: Color[]): ColumnType[];
 export declare function extractBoxplotBoxType(style: BoxplotWidgetStyle): "iqr" | "extremums" | "standardDeviation";
 /**

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

@@ -5,6 +5,7 @@ import { FiltersMergeStrategy, Panel, PanelItem, TextWidgetDtoStyle, WidgetStyle
 import { ChartProps, ChartWidgetProps, PivotTableWidgetProps, PluginWidgetProps, RenderToolbarHandler, TextWidgetProps, CommonWidgetProps, WithWidgetType, WidgetProps } from '..';
 import { WidgetTypeInternal } from '../models/widget/types';
 export declare function getChartType(widgetType: WidgetType): ChartType;
+export declare function getWidgetTypeFromChartType(chartType: ChartType): WidgetType;
 export declare function getChartSubtype(widgetSubtype: WidgetSubtype): ChartSubtype | undefined;
 type WidgetTypeOrString = string | WidgetType;
 export declare function isSupportedWidgetType(widgetType: WidgetTypeOrString): widgetType is WidgetType;

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/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/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;