@sisense/sdk-ui 1.24.0 → 1.25.0

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

@@ -8,9 +8,11 @@ export interface ChatConfig {
      */
     enableFollowupQuestions: boolean;
     /**
-     * Number of recommended queries that should be shown in a chat session
+     * Number of recommended queries that should initially be shown in a chat session
      *
-     * If not specified, the default value is `4`
+     * If not specified, the default value is `4`.
+     *
+     * Set to `0` to disable initial recommendations.
      */
     numOfRecommendations: number;
     /**

package/dist/packages/sdk-ui/src/analytics-composer/common/stringify-props.d.ts

@@ -0,0 +1,5 @@
+import { DataSource, Filter, FilterRelations } from '@sisense/sdk-data';
+import { ChartDataOptions } from '../../types';
+export declare function stringifyDataOptions(dataOptions: ChartDataOptions): string;
+export declare function stringifyDataSource(dataSource: DataSource | undefined): string;
+export declare function stringifyExtraImports(filters: Filter[] | FilterRelations): string;

package/dist/packages/sdk-ui/src/analytics-composer/execute-query/execute-query-composer.d.ts

@@ -0,0 +1,8 @@
+import { ExecuteQueryCodeParams } from '../types.js';
+/**
+ * Converts query params to CSDK code.
+ *
+ * @param queryParams - queryParams params
+ * @returns CSDK code string
+ */
+export declare const toExecuteQueryCode: (executeQueryCodeParams: ExecuteQueryCodeParams) => string;

package/dist/packages/sdk-ui/src/analytics-composer/execute-query/to-execute-query-code.d.ts

@@ -0,0 +1,2 @@
+import { ExecuteQueryCodeParams } from '../types.js';
+export declare const toExecuteQueryCode: ({ queryParams, uiFramework, }: ExecuteQueryCodeParams) => string;

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

@@ -10,3 +10,8 @@ export * as widgetComposer from './widget/widget-composer';
  * @internal
  */
 export * as dashboardComposer from './dashboard/dashboard-composer';
+/**
+ * Utility functions to compose props and code for executing queries.
+ * @internal
+ */
+export * as executeQueryComposer from './execute-query/execute-query-composer';

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

@@ -1,5 +1,6 @@
 import { WidgetProps } from '../props';
 import { ChartDataOptions } from '../types';
+import { ExecuteQueryParams } from '../query-execution';
 import { MetadataItem } from '@sisense/sdk-data';
 import { DynamicChartType } from '../chart-options-processor/translations/types.js';
 export type KeysOfUnion<T> = T extends T ? keyof T : never;
@@ -85,7 +86,7 @@ export type UiFramework = 'react' | 'vue' | 'angular';
  * Code Template Key
  * @internal
  */
-export type CodeTemplateKey = 'baseChartTmpl' | 'chartTmpl' | 'chartWidgetTmpl' | 'widgetByIdTmpl' | 'executeQueryByWidgetIdTmpl' | 'executeQueryWidgetTmpl';
+export type CodeTemplateKey = 'baseChartTmpl' | 'chartTmpl' | 'chartWidgetTmpl' | 'widgetByIdTmpl' | 'executeQueryByWidgetIdTmpl' | 'executeQueryTmpl';
 /**
  * Code Templates
  * @internal
@@ -118,7 +119,7 @@ export type WidgetCodeConfig = BaseCodeConfig & {
  * Client-side Widget Code Params
  * @internal
  */
-export type ClientSideWidgetCodeParams = WidgetCodeConfig & {
+export type ClientSideWidgetCodeParams = BaseCodeConfig & {
     widgetProps: WidgetProps;
 };
 /**
@@ -151,3 +152,9 @@ export declare const isByIdWidgetCodeParams: (params: WidgetCodeParams) => param
 export type WidgetPropsConfig = {
     useCustomizedStyleOptions?: boolean;
 };
+/**
+ * @internal
+ */
+export type ExecuteQueryCodeParams = BaseCodeConfig & {
+    queryParams: ExecuteQueryParams;
+};

package/dist/packages/sdk-ui/src/analytics-composer/widget/to-widget-code.d.ts

@@ -1,3 +1,3 @@
 import { ByIdWidgetCodeParams, ClientSideWidgetCodeParams } from '../types.js';
 export declare const toWidgetCodeById: ({ dashboardOid, widgetOid, uiFramework, chartType, includeChart, }: ByIdWidgetCodeParams) => string;
-export declare const toWidgetCodeClientSide: ({ widgetProps, uiFramework, includeChart, }: ClientSideWidgetCodeParams) => string;
+export declare const toWidgetCodeClientSide: ({ widgetProps, uiFramework, }: ClientSideWidgetCodeParams) => string;

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

@@ -21,7 +21,19 @@ export declare class RestApi {
     /**
      * Get all dashboards
      */
-    getDashboards: (options?: GetDashboardsOptions) => Promise<DashboardDto[] | undefined>;
+    getDashboards: (options?: GetDashboardsOptions) => Promise<({
+        oid: string;
+        title: string;
+        datasource: import("@sisense/sdk-data").JaqlDataSource;
+        widgets?: WidgetDto[] | undefined;
+        filters?: (import("./types/dashboard-dto").FilterDto | import("./types/dashboard-dto").CascadingFilterDto)[] | undefined;
+        filterRelations?: {
+            datasource: string;
+            filterRelations: import("@sisense/sdk-data").FilterRelationsModelNode;
+        }[] | undefined;
+        layout?: import("./types/dashboard-dto").LayoutDto | undefined;
+        style?: import("./types/dashboard-dto").DashboardStyleDto | undefined;
+    } & import("../utils/utility-types").AnyObject)[]>;
     /**
      * Get a specific dashboard
      */

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

@@ -1,9 +1,9 @@
 import { WidgetDto } from '../../widget-by-id/types';
-import { FilterJaql, FilterRelationsModel, JaqlDataSource } from '@sisense/sdk-data';
+import { FilterJaql, FilterRelationsModel, FilterRelationsModelNode, JaqlDataSource } from '@sisense/sdk-data';
 import { AnyObject } from '../../utils/utility-types';
 /** @internal */
 export type LayoutDto = {
-    columns: {
+    columns?: {
         width: number;
         cells?: {
             subcells: {
@@ -23,9 +23,12 @@ export type FilterDto = {
     disabled?: boolean;
     locked?: boolean;
 };
+type CascadeLevel = FilterJaql & {
+    instanceid?: string;
+};
 export type CascadingFilterDto = {
     isCascading: true;
-    levels: FilterJaql[];
+    levels: CascadeLevel[];
     instanceid?: string;
     disabled?: boolean;
     locked?: boolean;
@@ -48,8 +51,10 @@ export type DashboardDto = {
     widgets?: WidgetDto[];
     filters?: Array<FilterDto | CascadingFilterDto>;
     filterRelations?: {
-        filterRelations: FilterRelationsModel;
+        datasource: string;
+        filterRelations: FilterRelationsModel | FilterRelationsModelNode;
     }[];
     layout?: LayoutDto;
     style?: DashboardStyleDto;
 } & AnyObject;
+export {};

package/dist/packages/sdk-ui/src/chart-data-processor/data-table-date-period.d.ts

@@ -1,7 +1,4 @@
-export type SystemSettings = {
-    language: string;
-};
-export declare const getBaseDateFnsLocale: (systemSettings?: SystemSettings) => Locale;
+export declare const getBaseDateFnsLocale: (language?: string) => Locale;
 export declare enum DatePeriod {
     YEAR = "years",
     QUARTER = "quarters",

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

@@ -14,7 +14,9 @@ export declare function flattenCascadingFilters(filters: Filter[]): {
  * @param originalFilters - Original filters with maybe cascading filters.
  * @returns reassembled filters.
  */
-export declare function reassembleCascadingFilters(updatedFilters: PureFilter[], originalFilters: (PureFilter | CascadingFilter)[]): (PureFilter | CascadingFilter)[];
+export declare function reassembleCascadingFilters(updatedFilters: PureFilter[], originalFilters: (PureFilter | CascadingFilter)[], config?: {
+    shouldResetFiltersDeeperThanModified?: boolean;
+}): (PureFilter | CascadingFilter)[];
 /**
  * Converts cascading filters to pure filters and vice versa.
  *

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

@@ -4,14 +4,15 @@ import { CommonFiltersOptions } from './types.js';
 import { WidgetTypeInternal } from '../models/widget/types';
 import { OpenMenuFn } from '../common/components/menu/types';
 import { TFunction } from '@sisense/sdk-common';
-type CommonFiltersToWidgetConnectProps = Pick<ChartWidgetProps, 'filters' | 'highlights' | 'onDataPointClick' | 'onDataPointsSelected' | 'onDataPointContextMenu'> & {
+type CommonFiltersConnectionProps = Pick<ChartWidgetProps, 'highlights' | 'onDataPointClick' | 'onDataPointsSelected' | 'onDataPointContextMenu'> & {
+    filters: Filter[];
     renderToolbar: RenderToolbarHandler;
 };
 /**
- * Prepares common filters to be used in widget connect props
+ * Prepares common filters for connection to widget props
  *
  * @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, translate: TFunction, openMenu?: OpenMenuFn): CommonFiltersToWidgetConnectProps;
+export declare function prepareCommonFiltersConnectionProps(commonFilters: Filter[], updateCommonFilters: (filters: Filter[]) => void, widgetType: WidgetTypeInternal, dataOptions: ChartDataOptions | PivotTableDataOptions, options: CommonFiltersOptions, translate: TFunction, openMenu?: OpenMenuFn): CommonFiltersConnectionProps;
 export {};

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

@@ -11,16 +11,41 @@ export declare enum CommonFiltersApplyMode {
  * Options for common filters defined at the dashboard level to be applied to certain widgets.
  */
 export type CommonFiltersOptions = {
+    /**
+     * Apply mode for common filters: 'highlight' or 'filter'.
+     */
     applyMode?: `${CommonFiltersApplyMode}`;
+    /**
+     * Boolean flag whether widget interactions – for example, selection of bars on a bar chart –
+     * should affect common filters.
+     *
+     * If not specified, the default value is `true`.
+     */
     shouldAffectFilters?: boolean;
+    /**
+     * Filters to ignore when applying common filters.
+     */
     ignoreFilters?: FiltersIgnoringRules;
+    /**
+     * Boolean flag whether to apply all background filters as slice filters ignoring "disabled" state and "ignoreFilters" rules
+     *
+     * If not specified, the default value is `true`.
+     */
     forceApplyBackgroundFilters?: boolean;
 };
 /**
  * Filters ignoring rules.
  */
 export type FiltersIgnoringRules = {
+    /**
+     * Boolean flag whether to ignore all filters.
+     *
+     * If not specified, the default value is `false`.
+     */
     all?: boolean;
+    /**
+     * Filter GUIDs to ignore.
+     */
     ids?: string[];
 };
 /** @internal */

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

@@ -1,17 +1,16 @@
-/// <reference types="react" />
-import { type Filter } from '@sisense/sdk-data';
+import { FilterRelations, type Filter } from '@sisense/sdk-data';
 import { CommonFiltersOptions } from './types.js';
 import { WidgetProps } from '../props.js';
 import { BeforeMenuOpenHandler, OpenMenuFn } from '../common/components/menu/types.js';
 /** @internal */
-export declare const useCommonFilters: ({ initialFilters, openMenu, onBeforeMenuOpen, onFiltersChange, }?: {
-    initialFilters?: Filter[] | undefined;
+export declare const useCommonFilters: ({ initialFilters: initialCommonFiltersOrFilterRelations, openMenu, onBeforeMenuOpen, onFiltersChange, }?: {
+    initialFilters?: Filter[] | FilterRelations | undefined;
     openMenu?: OpenMenuFn | undefined;
     onBeforeMenuOpen?: BeforeMenuOpenHandler | undefined;
-    onFiltersChange?: ((filters: Filter[]) => void) | undefined;
+    onFiltersChange?: ((filters: Filter[] | FilterRelations) => void) | undefined;
 }) => {
-    filters: Filter[];
-    setFilters: import("react").Dispatch<import("react").SetStateAction<Filter[]>>;
-    addFilter: (newFilter: Filter) => void;
-    connectToWidgetProps: (widget: WidgetProps, options?: CommonFiltersOptions) => WidgetProps;
+    filters: Filter[] | FilterRelations;
+    setFilters: (filtersOrFilterRelations: Filter[] | FilterRelations) => void;
+    addFilter: (filter: Filter) => void;
+    connectToWidgetProps: (widgetProps: WidgetProps, options?: CommonFiltersOptions) => WidgetProps;
 };

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

@@ -0,0 +1,26 @@
+import { Filter, FilterRelations } from '@sisense/sdk-data';
+/**
+ * Result of the FilterRelations conversion.
+ */
+type UseFilterRelationsConversionResult = {
+    /** The current filters or filter relations. */
+    filtersOrFilterRelations: Filter[] | FilterRelations;
+    /** The current regular filters without relations. */
+    regularFilters: Filter[];
+    /** Adds a new filter to the current filters (recalculates relations if needed). */
+    addFilter: (filter: Filter) => void;
+    /** Completely replaces the current filters and relations with new ones. */
+    setFiltersOrFilterRelations: (filtersOrFilterRelations: Filter[] | FilterRelations) => void;
+    /** Completely replaces the current filters with new ones (recalculates relations if needed). */
+    setFilters: (filters: Filter[]) => void;
+    /** Calculates relations for some other filters based on current relations and applies them */
+    applyRelationsToOtherFilters: (otherFilters: Filter[]) => Filter[] | FilterRelations;
+};
+/**
+ * Hook for handling conversion between regular filters and filter relations.
+ *
+ * @param initialFiltersOrFilterRelations - Initial filters or filter relations.
+ * @returns The result of the conversion. See {@link UseFilterRelationsConversionResult}.
+ */
+export declare function useConvertFilterRelations(initialFiltersOrFilterRelations: Filter[] | FilterRelations, onFiltersChange?: (filters: Filter[] | FilterRelations) => void): UseFilterRelationsConversionResult;
+export {};

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

@@ -1,5 +1,5 @@
-import { Filter } from '@sisense/sdk-data';
 import { DashboardProps } from './types';
+import { Filter, FilterRelations } from '@sisense/sdk-data';
 /**
  * Creates a new dashboard instance with its filters replaced by a new set of filters.
  *
@@ -13,10 +13,10 @@ import { DashboardProps } from './types';
  * 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.
+ * @param newFilters - An array of new filters or filter relations to set on the dashboard.
  * @returns A new dashboard instance with the updated filters.
  */
-export declare const replaceFilters: (dashboard: DashboardProps, newFilters: Filter[]) => DashboardProps;
+export declare const replaceFilters: (dashboard: DashboardProps, newFilters: Filter[] | FilterRelations) => DashboardProps;
 /**
  * Creates a new dashboard instance with an additional filter added to its existing filters.
  *
@@ -52,19 +52,31 @@ export declare const addFilter: (dashboard: DashboardProps, newFilter: Filter) =
  */
 export declare const addFilters: (dashboard: DashboardProps, newFilters: Filter[]) => DashboardProps;
 /**
- * Creates a new dashboard instance with a specific filter modified.
+ * Creates a new dashboard instance with a specific filter replaced.
  *
- * This function searches for a filter with the same GUID as the provided `filterToModify` and replaces it with `newFilter`.
+ * This function searches for a filter with the same GUID as the provided `filterToReplace` 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.
+ * Replace a filter in a dashboard.
  * ```ts
  * const existingDashboard: DashboardProps = {...};
- * const filterToModify: Filter = {...};
+ * const filterToReplace: Filter = {...};
  * const newFilter: Filter = {...};
- * const updatedDashboard = modifyFilter(existingDashboard, filterToModify, newFilter);
+ * const updatedDashboard = replaceFilter(existingDashboard, filterToReplace, newFilter);
  * ```
+ * @param dashboard - The original dashboard (`DashboardProps`) containing the filter to be replaced.
+ * @param filterToReplace - The existing filter to be replaced.
+ * @param newFilter - The new filter to replace the existing one.
+ * @returns A new dashboard instance with the specified filter replaced.
+ */
+export declare const replaceFilter: (dashboard: DashboardProps, filterToReplace: Filter, newFilter: Filter) => DashboardProps;
+/**
+ * Creates a new dashboard instance with a specific filter modified.
+ * Alias for `replaceFilter`.
+ *
+ * @deprecated Use {@link replaceFilter} instead
+ *
  * @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.
@@ -85,7 +97,25 @@ export declare const modifyFilter: (dashboard: DashboardProps, filterToModify: F
  * const updatedDashboard = removeFilter(existingDashboard, filterToRemove);
  * ```
  * @param dashboard - The original dashboard (`DashboardProps`) from which to remove the filter.
- * @param filter - The filter to be removed.
+ * @param filterToRemove - The filter to be removed.
  * @returns A new dashboard instance with the specified filter removed.
  */
-export declare const removeFilter: (dashboard: DashboardProps, filter: Filter) => DashboardProps;
+export declare const removeFilter: (dashboard: DashboardProps, filterToRemove: Filter) => DashboardProps;
+/**
+ * Creates a new dashboard instance with multiple filters removed.
+ *
+ * This function removes all filters with the same GUID as the provided filters 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 multiple filters from a dashboard.
+ * ```ts
+ * const existingDashboard: DashboardProps = {...};
+ * const filtersToRemove: Filter[] = [{...}, {...}, ...];
+ * const updatedDashboard = removeFilters(existingDashboard, filtersToRemove);
+ * ```
+ * @param dashboard - The original dashboard (`DashboardProps`) from which the specified filters are removed.
+ * @param filtersToRemove - An array of filters to remove.
+ * @returns A new dashboard instance with the specified filters removed.
+ */
+export declare const removeFilters: (dashboard: DashboardProps, filtersToRemove: Filter[]) => DashboardProps;

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

@@ -1,6 +1,6 @@
 /// <reference types="react" />
 import { DashboardProps } from '../dashboard/types';
-import { Filter } from '@sisense/sdk-data';
+import { Filter, FilterRelations } from '@sisense/sdk-data';
 export declare enum DashboardChangeType {
     /** Dashboard filters have been updated */
     FILTERS_UPDATE = "FILTERS.UPDATE",
@@ -9,7 +9,7 @@ export declare enum DashboardChangeType {
 }
 export type DashboardChangeAction = {
     type: DashboardChangeType.FILTERS_UPDATE;
-    payload: Filter[];
+    payload: Filter[] | FilterRelations;
 } | {
     type: DashboardChangeType.UI_FILTERS_PANEL_COLLAPSE;
     payload: boolean;

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

@@ -1,7 +1,7 @@
 import { DashboardStyleOptions, WidgetsOptions, WidgetsPanelLayout } from '../models';
 import { WidgetProps } from '../props';
-import { DataSource, Filter } from '@sisense/sdk-data';
 import { DashboardChangeAction } from '../dashboard/dashboard';
+import { DataSource, Filter, FilterRelations } from '@sisense/sdk-data';
 export type { DashboardStyleOptions, WidgetsPanelColumnLayout } from '../models';
 /**
  * Props for the DashboardById component
@@ -19,7 +19,7 @@ export interface DashboardByIdProps {
      * Limitations:
      * - WAT authentication does not support persistence.
      * - As an alpha feature, currently only changes to dashboard filters are persisted.
-     * @internal
+     * @alpha
      */
     persist?: boolean;
 }
@@ -31,8 +31,8 @@ export interface DashboardContainerProps {
     layoutOptions?: DashboardLayoutOptions;
     config?: DashboardConfig;
     widgets: WidgetProps[];
-    filters: Filter[];
-    onFiltersChange: (filters: Filter[]) => void;
+    filters: Filter[] | FilterRelations;
+    onFiltersChange: (filters: Filter[] | FilterRelations) => void;
     defaultDataSource?: DataSource;
     /**
      * Callback to receive changes
@@ -95,7 +95,7 @@ export interface DashboardProps {
     /** The widgets to render in the dashboard */
     widgets: WidgetProps[];
     /** The dashboard filters to be applied to each of the widgets based on the widget filter options */
-    filters?: Filter[];
+    filters?: Filter[] | FilterRelations;
     /** The default data source to use for the dashboard */
     defaultDataSource?: DataSource;
     /** The options for each of the widgets */

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

@@ -1,11 +1,11 @@
 import { DashboardProps } from './types.js';
-import { Filter } from '@sisense/sdk-data';
+import { Filter, FilterRelations } from '@sisense/sdk-data';
 export type ComposableDashboardProps = Pick<DashboardProps, 'filters' | 'widgets' | 'widgetsOptions'>;
 export type UseComposedDashboardOptions = {
     /**
      * @internal
      */
-    onFiltersChange?: (filters: Filter[]) => void;
+    onFiltersChange?: (filters: Filter[] | FilterRelations) => void;
 };
 /**
  * {@link useComposedDashboard} without tracking to be used inside other hooks or components in Compose SDK.
@@ -15,7 +15,7 @@ export type UseComposedDashboardOptions = {
  */
 export declare function useComposedDashboardInternal<D extends ComposableDashboardProps | DashboardProps>(initialDashboard: D, { onFiltersChange }?: UseComposedDashboardOptions): {
     dashboard: D;
-    setFilters: (filters: Filter[]) => void;
+    setFilters: (filters: Filter[] | FilterRelations) => void;
 };
 /**
  * React hook that takes in separate dashboard elements and
@@ -26,5 +26,5 @@ export declare function useComposedDashboardInternal<D extends ComposableDashboa
  */
 export declare const useComposedDashboard: <D extends DashboardProps | ComposableDashboardProps>(args_0: D, args_1?: UseComposedDashboardOptions | undefined) => {
     dashboard: D;
-    setFilters: (filters: Filter[]) => void;
+    setFilters: (filters: Filter[] | FilterRelations) => void;
 };

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

@@ -1,14 +1,14 @@
 /// <reference types="react" />
-import { DataSource, Filter } from '@sisense/sdk-data';
+import { DataSource, Filter, FilterRelations } from '@sisense/sdk-data';
 /**
  * Props of the {@link FiltersPanel} component
  *
  */
 export type FiltersPanelProps = {
     /** Array of filters to display */
-    filters: Filter[];
+    filters: Filter[] | FilterRelations;
     /** Callback to handle changes in filters */
-    onFiltersChange: (filters: Filter[]) => void;
+    onFiltersChange: (filters: Filter[] | FilterRelations) => void;
     /** Default data source used for filter tiles */
     defaultDataSource?: DataSource;
 };

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

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

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

@@ -0,0 +1,122 @@
+import { Filter, FilterRelations } from '@sisense/sdk-data';
+/**
+ * Returns a function that adds a filter to existing filters or filter relations.
+ *
+ * @param filter - The filter to add.
+ * @returns A function that takes existing filters or filter relations and returns updated filters or filter relations with the new filter added.
+ * @group Filter Utilities
+ * @example
+ * ```ts
+ * // Using with an array of filters
+ * const originalFilters = [filterByAgeRange];
+ * const updatedFilters = withAddedFilter(filterByCost)(originalFilters);
+ * // [filterByAgeRange, filterByCost]
+ *
+ * // Using with filter relations
+ * const originalFilterRelations = filterFactory.logic.or(filterByAgeRange, filterByRevenue);
+ * const updatedFilterRelations = withAddedFilter(filterByCost)(originalFilterRelations);
+ * // (filterByAgeRange OR filterByRevenue) AND filterByCost
+ * ```
+ * @internal
+ */
+export declare function withAddedFilter(filter: Filter): (filters: Filter[] | FilterRelations | undefined) => Filter[] | FilterRelations;
+/**
+ * Returns a function that adds multiple filters to existing filters or filter relations.
+ *
+ * @param filtersToAdd - An array of filters to add.
+ * @returns A function that takes existing filters or filter relations and returns updated filters or filter relations with the new filters added.
+ * @group Filter Utilities
+ * @example
+ * ```ts
+ * // Using with an array of filters
+ * const originalFilters = [filterByAgeRange];
+ * const updatedFilters = withAddedFilters([filterByCost, filterByRevenue])(originalFilters);
+ * // [filterByAgeRange, filterByCost, filterByRevenue]
+ *
+ * // Using with filter relations
+ * const originalFilterRelations = filterFactory.logic.or(filterByAgeRange, filterByRevenue);
+ * const updatedFilterRelations = withAddedFilters([filterByCost, filterByRevenue])(originalFilterRelations);
+ * // (filterByAgeRange OR filterByRevenue) AND filterByCost AND filterByRevenue
+ * ```
+ *
+ * @internal
+ */
+export declare function withAddedFilters(filtersToAdd: Filter[]): (filters: Filter[] | FilterRelations | undefined) => Filter[] | FilterRelations;
+/**
+ * Returns a function that removes a filter from existing filters or filter relations.
+ *
+ * @param filterToRemove - The filter to remove.
+ * @returns A function that takes existing filters or filter relations and returns updated filters or filter relations without the specified filter.
+ * @group Filter Utilities
+ * @example
+ * ```ts
+ * // Using with an array of filters
+ * const originalFilters = [filterByAgeRange, filterByRevenue, filterByCost];
+ * const updatedFilters = withoutFilter(filterByCost)(originalFilters);
+ * // [filterByAgeRange, filterByRevenue]
+ *
+ * // Using with filter relations
+ * const originalFilterRelations = filterFactory.logic.or(filterByAgeRange, filterByRevenue);
+ * const updatedFiltersRelations = withoutFilter(filterByRevenue)(originalFilterRelations);
+ * // filterByAgeRange
+ * ```
+ *
+ * @internal
+ */
+export declare function withoutFilter(filterToRemove: Filter): (filters: Filter[] | FilterRelations | undefined) => Filter[] | FilterRelations;
+/**
+ * Returns a function that removes multiple filters from existing filters or filter relations.
+ *
+ * @param filtersToRemove - An array of filters to remove.
+ * @returns A function that takes existing filters or filter relations and returns updated filters or filter relations without the specified filters.
+ * @group Filter Utilities
+ * @example
+ * ```ts
+ * // Using with an array of filters
+ * const originalFilters = [filterByAgeRange, filterByRevenue, filterByCost];
+ * const updatedFilters = withRemovedFilters([filterByRevenue, filterByCost])(originalFilters);
+ * // [filterByAgeRange]
+ *
+ * // Using with filter relations
+ * const originalFilterRelations = filterFactory.logic.or(filterByAgeRange, filterByRevenue);
+ * const updatedFiltersRelations = withRemovedFilters([filterByRevenue])(originalFilterRelations);
+ * // filterByAgeRange
+ * ```
+ *
+ * @internal
+ */
+export declare function withoutFilters(filtersToRemove: Filter[]): (filters: Filter[] | FilterRelations | undefined) => Filter[] | FilterRelations;
+/**
+ * Returns a function that replaces a filter with a new filter in existing filters or filter relations.
+ *
+ * @param filterToReplace - The filter to replace.
+ * @param newFilter - The new filter to use as a replacement.
+ * @returns A function that takes existing filters or filter relations and returns updated filters or filter relations with the filter replaced.
+ * @group Filter Utilities
+ * @example
+ * ```ts
+ * // Using with an array of filters
+ * const originalFilters = [filterByAgeRange, filterByRevenue];
+ * const updatedFilters = withReplacedFilter(filterByRevenue, filterByCost)(originalFilters);
+ * // [filterByAgeRange, filterByCost]
+ *
+ * // Using with filter relations
+ * const originalFilterRelations = filterFactory.logic.or(filterByAgeRange, filterByRevenue);
+ * const updatedFilterRelations = withReplacedFilter(filterByRevenue, filterByCost)(originalFilterRelations);
+ * // (filterByAgeRange OR filterByCost)
+ * ```
+ *
+ * @internal
+ */
+export declare function withReplacedFilter(filterToReplace: Filter, newFilter: Filter): (filters: Filter[] | FilterRelations | undefined) => Filter[] | FilterRelations;
+/**
+ * Finds a filter in an array of filters or filter relations.
+ * Returns the first filter that satisfies the provided search function.
+ * @group Filter Utilities
+ * @param filters - An array of filters or filter relations to search.
+ * @param searchFn - A function that takes a filter and returns a boolean indicating whether the filter satisfies the search criteria.
+ * @returns The first filter that satisfies the search function, or `undefined` if no filter is found.
+ *
+ * @internal
+ */
+export declare function findFilter(filters: Filter[] | FilterRelations | undefined, searchFn: (filter: Filter) => boolean): Filter | undefined;

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

@@ -4,4 +4,5 @@ export * from './components/criteria-filter-tile';
 export * from './components/cascading-filter-tile';
 export * from './components/filters-panel';
 export * from './components/custom-filter-tile';
+export * from './helpers';
 export { type FilterVariant } from './components/common/filter-utils';

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

@@ -1,4 +1,4 @@
-import { DataSource, Filter } from '@sisense/sdk-data';
+import { DataSource, Filter, FilterRelations } from '@sisense/sdk-data';
 import { DashboardStyleOptions, WidgetModel } from '../../models';
 import { type WidgetsOptions } from './types';
 import { DashboardLayoutOptions } from '../../dashboard';
@@ -42,7 +42,7 @@ export interface DashboardModel {
      *
      * @internal
      */
-    filters: Filter[];
+    filters: Filter[] | FilterRelations;
     /**
      * Dashboard options for each of the widgets.
      *

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

@@ -1,4 +1,5 @@
 import { HttpClient } from '@sisense/sdk-rest-client';
+import { DashboardModel } from '../../models/dashboard';
 import { CompleteThemeSettings } from '../../types';
 import { AppSettings } from '../../app/settings/settings';
 export interface GetDashboardModelOptions {
@@ -26,4 +27,4 @@ export interface GetDashboardModelOptions {
  * @returns The dashboard model
  * @internal
  */
-export declare function getDashboardModel(http: HttpClient, dashboardOid: string, options?: GetDashboardModelOptions, themeSettings?: CompleteThemeSettings, appSettings?: AppSettings): Promise<import('../../models/dashboard').DashboardModel>;
+export declare function getDashboardModel(http: HttpClient, dashboardOid: string, options?: GetDashboardModelOptions, themeSettings?: CompleteThemeSettings, appSettings?: AppSettings): Promise<DashboardModel>;