@sisense/sdk-ui 2.10.0 → 2.11.0

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

@@ -1,5 +1,6 @@
 import { DashboardProps } from './types';
 import { Filter, FilterRelations } from '@sisense/sdk-data';
+import type { JumpToDashboardConfig } from './hooks/jtd/jtd-types';
 /**
  * Creates a new dashboard instance with its filters replaced by a new set of filters.
  *
@@ -107,3 +108,111 @@ export declare const removeFilter: (dashboard: DashboardProps, filterToRemove: F
  * @returns A new dashboard instance with the specified filters removed.
  */
 export declare const removeFilters: (dashboard: DashboardProps, filtersToRemove: Filter[]) => DashboardProps;
+/**
+ * Creates a new `DashboardProps` instance with JTD (Jump To Dashboard) configuration applied to a single widget.
+ *
+ * Jump To Dashboard (JTD) allows users to navigate from one dashboard to another when interacting with widgets,
+ * such as clicking on chart data points or using context menus. This function applies JTD configuration to a specific
+ * widget in a dashboard, enabling jump-to-dashboard functionality.
+ *
+ * This function does not modify the original dashboard; instead, it returns a new `DashboardProps` instance with the JTD
+ * configuration applied. If the specified widget does not exist in the dashboard, the function returns the original
+ * `DashboardProps` unchanged and logs a warning to the console.
+ *
+ * @example
+ * Apply JTD configuration to a dashboard widget.
+ * ```ts
+ * const jtdConfig: JumpToDashboardConfig = {
+ *   targets: [{ id: 'dashboardId1', caption: 'Analytics Dashboard' }],
+ *   interaction: {
+ *     triggerMethod: 'rightclick',
+ *     contextMenuCaption: 'Jump to Analytics'
+ *   }
+ * };
+ *
+ * const updatedDashboard = dashboardHelpers.applyJtdConfig(dashboard, 'widgetId3', jtdConfig);
+ * ```
+ *
+ * @param dashboard - The original dashboard to modify. Must be a valid `DashboardProps` object containing the target widget.
+ * @param widgetOid - The unique identifier (OID) of the widget to apply JTD configuration to. Must match an existing widget ID in the dashboard.
+ * @param config - The JTD configuration to apply.
+ *
+ * @returns A new `DashboardProps` instance with the JTD configuration applied to the specified widget. If the widget doesn't exist, returns the original dashboard unchanged.
+ *
+ * @group Dashboard Utilities
+ */
+export declare const applyJtdConfig: (dashboard: DashboardProps, widgetOid: string, config: JumpToDashboardConfig) => DashboardProps;
+/**
+ * Creates a new `DashboardProps` instance with JTD (Jump To Dashboard) configurations applied to multiple widgets in a single operation.
+ *
+ * Jump To Dashboard (JTD) allows users to navigate from one dashboard to another when interacting with widgets.
+ * This function efficiently applies JTD configurations to multiple widgets in a single operation.
+ *
+ * This function does not modify the original dashboard; instead, it returns a new `DashboardProps` instance with all valid
+ * JTD configurations applied. Configurations for non-existent widgets are automatically filtered out, and warnings
+ * are logged to the console for invalid widget OIDs.
+ *
+ * @example
+ * Apply a variety of Jump To Dashboard configuration options to multiple widgets in a single operation.
+ * ```ts
+ * import { dashboardHelpers } from '@sisense/sdk-ui';
+ *
+ * const dashboard: DashboardProps = {
+ *   title: 'Executive Dashboard',
+ *   widgets: [
+ *     { id: 'widgetId1', widgetType: 'chart', chartType: 'column', dataOptions: {...} },
+ *     { id: 'widgetId2', widgetType: 'chart', chartType: 'pie', dataOptions: {...} },
+ *     { id: 'widgetId3', widgetType: 'table', dataOptions: {...} }
+ *   ]
+ * };
+ *
+ * const jtdConfigs = {
+ *   'widgetId1': {
+ *     enabled: true,
+ *     targets: [{ id: 'dashboardId1', caption: 'Sales Breakdown' }],
+ *     interaction: {
+ *       triggerMethod: 'rightclick'
+ *     }
+ *   },
+ *   'widgetId2': {
+ *     targets: [{ id: 'dashboardId2', caption: 'Revenue Analysis' }],
+ *     interaction: {
+ *       triggerMethod: 'click',
+ *       contextMenuCaption: 'Analyze Revenue'
+ *     }
+ *   },
+ *   'widgetId3': {
+ *     enabled: true,
+ *     targets: [
+ *       { id: 'dashboardId3', caption: 'Customer Details' },
+ *       { id: 'dashboardId4', caption: 'Product Analytics' }
+ *     ],
+ *     interaction: {
+ *       triggerMethod: 'rightclick'
+ *     }
+ *   }
+ * };
+ *
+ * const updatedDashboard = dashboardHelpers.applyJtdConfigs(dashboard, jtdConfigs);
+ * ```
+ *
+ * @example Error handling
+ * Batch apply JTD configurations with error handling.
+ * ```ts
+ * const configsWithInvalidWidget = {
+ *   'widgetId1': { targets: [{ id: 'dashboardId1', caption: 'Target' }] },
+ *   'invalidWidgetId': { targets: [{ id: 'dashboardId2', caption: 'Other' }] } // Will be filtered out
+ * };
+ *
+ * const result = dashboardHelpers.applyJtdConfigs(dashboard, configsWithInvalidWidget);
+ * // Console warning: "Widgets with OIDs [invalidWidgetId] not found in dashboard..."
+ * // Only 'widgetId1' gets the JTD configuration applied
+ * ```
+ *
+ * @param dashboard - The original dashboard to modify. Must be a valid `DashboardProps` object with widgets to configure.
+ * @param jtdConfigs - An object mapping widget OIDs (keys) to their respective JTD configurations (values).
+ * @returns A new `DashboardProps` instance with all valid JTD configurations applied to their respective widgets. Invalid widget configurations are skipped and warnings are logged.
+ *
+ * @group Dashboard Utilities
+ */
+export declare const applyJtdConfigs: (dashboard: DashboardProps, jtdConfigs: Record<string, JumpToDashboardConfig>) => DashboardProps;

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

@@ -0,0 +1,7 @@
+export { type JumpToDashboardConfig, type JumpToDashboardConfigForPivot, type JtdTarget, type TriggerMethod, } from './jtd';
+/**
+ * Internal JTD hook for dashboard composition
+ * @internal
+ */
+export { useJtdInternal } from './use-jtd';
+export { useJtdWidget } from './use-jtd-widget';

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

@@ -1,5 +1,20 @@
-export { getFiltersFromDataPoint, getFormulaContextFilters, filterByAllowedDimensions, handleFormulaDuplicateFilters, mergeJtdFilters, } from './jtd-filters';
-export { getJtdClickHandler, getJtdClickHandlerForMultiplePoints, handleDataPointClick, handleTextWidgetClick, } from './jtd-handlers';
-export { getJumpToDashboardMenuItem, getJumpToDashboardMenuItemForMultiplePoints, } from './jtd-menu';
-export { addPointerCursorToChart, applyClickNavigationForChart, applyClickNavigationForText, applyClickNavigationForPivot, applyRightClickNavigation, applyRightClickNavigationForPivot, applyPivotLinkStyling, addJtdIconToHeader, } from './jtd-widget-transforms';
-export { type JtdCoreData, type JtdContext, type JtdActions, type JtdClickHandlerData, type JtdWidgetTransformConfig, type JtdDataPointClickEvent, type JtdMenuItem, } from './jtd-types';
+/**
+ * Jump To Dashboard configuration for regular widgets
+ * @group Dashboards
+ */
+export { type JumpToDashboardConfig } from './jtd-types';
+/**
+ * Jump To Dashboard configuration for pivot widgets
+ * @group Dashboards
+ */
+export { type JumpToDashboardConfigForPivot } from './jtd-types';
+/**
+ * Target dashboard configuration for Jump To Dashboard
+ * @group Dashboards
+ */
+export { type JtdTarget } from './jtd-types';
+/**
+ * Trigger method for Jump To Dashboard interactions
+ * @group Dashboards
+ */
+export { type TriggerMethod } from './jtd-types';

package/dist/packages/sdk-ui/src/dashboard/hooks/jtd/jtd-config-transformers.d.ts

@@ -0,0 +1,85 @@
+import { WidgetProps } from '../../../props';
+import type { JtdConfig, JtdTarget, JumpToDashboardConfig, JumpToDashboardConfigForPivot, PivotDimId } from './jtd-types';
+import type { Attribute, Dimension, Measure } from '@sisense/sdk-data';
+import { PivotTableDataOptions } from '../../../index-typedoc';
+import type { Panel } from '../../../widget-by-id/types';
+/**
+ * Transform legacy JtdConfig to new JumpToDashboardConfig format
+ *
+ * @param jtdConfig - The legacy JTD configuration
+ * @returns Transformed Jump To Dashboard configuration
+ * @internal
+ */
+export declare const transformJtdConfigToJumpToDashboardConfig: (jtdConfig: JtdConfig) => JumpToDashboardConfig;
+export declare const isPivotJumpToDashboardConfig: (config: JumpToDashboardConfig | JumpToDashboardConfigForPivot) => config is JumpToDashboardConfigForPivot;
+/**
+ * Transform common part of public JumpToDashboardConfig to inner JtdConfig format
+ *
+ * @param jumpConfig - The new Jump To Dashboard configuration
+ * @returns Transformed legacy JTD configuration
+ * @internal
+ */
+export declare const transformJumpToDashboardConfigToJtdConfigCommon: (jumpConfig: JumpToDashboardConfig | JumpToDashboardConfigForPivot) => Omit<JtdConfig, 'jumpTargets'>;
+export declare const transformJumpToDashboardConfigToJtdConfigForPivot: (jumpConfig: JumpToDashboardConfigForPivot, dataOptions: PivotTableDataOptions) => JtdConfig;
+/**
+ * Type guard to check if a config is a JumpToDashboardConfig
+ *
+ * @param config - The configuration to check
+ * @returns True if the config is a JumpToDashboardConfig
+ * @internal
+ */
+export declare const isJumpToDashboardConfig: (config: JtdConfig | JumpToDashboardConfig | JumpToDashboardConfigForPivot) => config is JumpToDashboardConfig | JumpToDashboardConfigForPivot;
+/**
+ * Normalize configuration to JumpToDashboardConfig format
+ * Accepts both legacy JtdConfig and new JumpToDashboardConfig
+ *
+ * @internal
+ * @param config - Either JtdConfig or JumpToDashboardConfig
+ * @returns Normalized JumpToDashboardConfig
+ */
+export declare const normalizeToJumpToDashboardConfig: (config: JtdConfig | JumpToDashboardConfig) => JumpToDashboardConfig;
+/**
+ * Normalize configuration to legacy JtdConfig format
+ * Accepts both legacy JtdConfig and new JumpToDashboardConfig
+ *
+ * @internal
+ * @param config - Either JtdConfig or JumpToDashboardConfig
+ * @returns Normalized JtdConfig
+ */
+export declare const normalizeToJtdConfig: (config: JtdConfig | JumpToDashboardConfig | JumpToDashboardConfigForPivot, widgetProps: WidgetProps) => JtdConfig;
+/**
+ * Enhanced matching strategy that considers location, expression, level, and other properties
+ * @param dimension - The dimension or measure object
+ * @param panels - Constructed panels with PanelItems
+ * @returns PivotDimId like "columns.0", "rows.1", "values.0"
+ * @internal
+ */
+export declare const dimensionToPivotDimId: (dimension: Attribute | Measure | {
+    dimension: Attribute;
+    location: 'row' | 'column' | 'value';
+}, panels: Panel[]) => PivotDimId | null;
+/**
+ * Convert PivotDimId back to Dimension/Measure using widget structure
+ * @param pivotDimId - PivotDimId like "columns.0", "rows.1", "values.0"
+ * @param widgetStructure - Widget structure with rows/columns/values arrays
+ * @returns The dimension or measure object, or null if not found
+ * @internal
+ */
+export declare const pivotDimIdToDimension: (pivotDimId: PivotDimId, widgetStructure: {
+    rows?: Array<Dimension | Measure>;
+    columns?: Array<Dimension | Measure>;
+    values?: Array<Dimension | Measure>;
+}) => Dimension | Measure | null;
+/**
+ * Convert Map-based pivot targets to array-based pivot targets (for internal JtdConfig)
+ * @param targetsMap - Map of dimensions/measures to targets
+ * @param panels - Widget metadata panels (source of truth for dimension positions)
+ * @returns Array of targets with pivotDimensions
+ * @internal
+ */
+export declare const mapTargetsToArrayTargets: (targetsMap: Map<Attribute | {
+    dimension: Attribute;
+    location: 'row' | 'column' | 'value';
+} | Measure, JtdTarget[]>, panels: Panel[]) => Array<JtdTarget & {
+    pivotDimensions?: PivotDimId[];
+}>;

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

@@ -1,9 +1,9 @@
 import { type Filter } from '@sisense/sdk-data';
 import { WidgetProps } from '../../../props.js';
 import { DataPoint, ScatterDataPoint } from '../../../types';
-import { JtdConfig } from '../../../widget-by-id/types';
+import { JtdConfig } from './jtd-types';
 /**
- * Jump to Dashboard (JTD) Filter Merging Logic:
+ * Jump To Dashboard (JTD) Filter Merging Logic:
  *
  * When a user clicks on a datapoint to open a JTD modal, multiple types of filters are merged:
  *
@@ -57,6 +57,7 @@ import { JtdConfig } from '../../../widget-by-id/types';
  * @param clickedWidget - The clicked widget
  * @param jtdConfig - The JTD configuration
  * @returns Array of formula context filters
+ * @internal
  */
 export declare const getFormulaContextFilters: (clickedWidget: WidgetProps, jtdConfig: JtdConfig) => Filter[];
 /**

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

@@ -1,5 +1,67 @@
 import type { CustomDataCellFormatter, CustomHeaderCellFormatter } from '../../../pivot-table/formatters/types';
-import { JtdConfig } from '../../../widget-by-id/types';
+import { JtdConfig, JtdTarget } from './jtd-types';
+import { PivotTableDataPoint } from '../../../types';
+/**
+ * Check if a formatter cell ID is actionable for JTD
+ * Used by hyperlink formatters with cell IDs like "rows.0", "columns.1", "values.2"
+ *
+ * @param jtdConfig - The JTD configuration
+ * @param cellId - The cell ID from formatters (e.g., "rows.0")
+ * @returns Object with actionable status and matching target
+ * @internal
+ */
+export declare function getPivotFormatterCellActionability(jtdConfig: JtdConfig, cellId: string): {
+    isActionable: boolean;
+    matchingTarget?: JtdTarget;
+};
+/**
+ * Check if a click handler pivot point is actionable for JTD
+ * Used by click handlers with pivot data points containing custom dimension IDs
+ *
+ * @param jtdConfig - The JTD configuration
+ * @param pivotPoint - The pivot data point from click handlers
+ * @returns Object with actionable status and matching target
+ * @internal
+ */
+export declare function isPivotClickHandlerActionable(jtdConfig: JtdConfig, pivotPoint: PivotTableDataPoint): {
+    isActionable: boolean;
+    matchingTarget?: JtdTarget;
+};
+/**
+ * Find all actionable jump targets for a pivot point (for right-click menus)
+ * Used by right-click handlers that need to show multiple targets
+ *
+ * @param jtdConfig - The JTD configuration
+ * @param pivotPoint - The pivot data point from click handlers
+ * @returns Object with actionable status and all matching targets
+ * @internal
+ *
+ * @example
+ * ```typescript
+ * // Usage in right-click menu handler for pivot tables
+ * const onPivotRightClick = (pivotPoint: PivotTableDataPoint) => {
+ *   const { isActionable, matchingTargets } = findAllActionablePivotTargets(jtdConfig, pivotPoint);
+ *
+ *   if (!isActionable) {
+ *     return; // No menu - headers are not clickable or no valid targets
+ *   }
+ *
+ *   // Only valid targets are returned:
+ *   // - Targets with matching pivot dimensions for this cell
+ *   // - NEVER targets with non-matching pivot dimensions
+ *   const menuItems = matchingTargets.map(target => ({
+ *     caption: target.caption,
+ *     onClick: () => handleJumpToDashboard(target, pivotPoint)
+ *   }));
+ *
+ *   openContextMenu({ items: menuItems });
+ * };
+ * ```
+ */
+export declare function getPivotTargetActionability(jtdConfig: JtdConfig, pivotPoint: PivotTableDataPoint): {
+    isActionable: boolean;
+    matchingTargets: JtdTarget[];
+};
 /**
  * Creates a data cell formatter that applies hyperlink styling for JTD navigation
  *
@@ -12,7 +74,7 @@ export declare function createJtdHyperlinkDataCellFormatter(hyperlinkColor: stri
  * Creates a header cell formatter that applies hyperlink styling for JTD navigation
  *
  * @param hyperlinkColor - The color to use for hyperlink text (uses theme's hyperlinkColor or defaults to DEFAULT_HYPERLINK_COLOR)
- * @param jtdConfig - JTD configuration containing drill targets
+ * @param jtdConfig - JTD configuration containing jump targets
  * @returns A header cell formatter that applies hyperlink styling to matching header cells
  */
 export declare function createJtdHyperlinkHeaderCellFormatter(hyperlinkColor: string, jtdConfig: JtdConfig): CustomHeaderCellFormatter;

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

@@ -1,13 +1,12 @@
 import { type Filter } from '@sisense/sdk-data';
 import { WidgetProps } from '../../../props.js';
 import { PivotTableDataPoint, DataPoint } from '../../../types';
-import { JtdConfig } from '../../../widget-by-id/types';
+import { JtdActions, JtdClickHandlerData, JtdConfig, JtdContext, JtdCoreData, JtdDataPointClickEvent } from './jtd-types';
 import { OpenModalFn } from '../../../common/components/modal/modal-context';
-import { JtdCoreData, JtdContext, JtdActions, JtdClickHandlerData, JtdDataPointClickEvent } from './jtd-types';
 /**
  * Get the JTD click handler for a specific data point of the specific widget
  *
- * @param data - Core data with drill target (config, drill target, widget props, point)
+ * @param data - Core data with jump target (config, jump target, widget props, point)
  * @param context - Context data (filters)
  * @param actions - Action functions
  * @returns The JTD click handler
@@ -17,7 +16,7 @@ export declare const getJtdClickHandler: (data: JtdClickHandlerData, context: Jt
 /**
  * Get the JTD click handler for multiple data points
  *
- * @param data - Core data with drill target (config, drill target, widget props, points)
+ * @param data - Core data with jump target (config, jump target, widget props, points)
  * @param context - Context data (filters)
  * @param actions - Action functions
  * @returns The JTD click handler
@@ -45,7 +44,7 @@ export declare const convertPivotToDataPoint: (pivotPoint: PivotTableDataPoint)
 /**
  * Handle pivot table data point click
  *
- * @param data - Core data with drill target (config, drill target, widget props, pivot point)
+ * @param data - Core data with jump target (config, jump target, widget props, pivot point)
  * @param context - Context data (filters)
  * @param actions - Action functions
  * @param eventData - Event-related data

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

@@ -1,4 +1,5 @@
 import { JtdCoreData, JtdContext, JtdActions } from './jtd-types';
+export declare const jumpToDashboardMenuId = "jump-to-dashboard-menu";
 /**
  * Get the JTD menu item for a specific data point of the specific widget
  *

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

@@ -1,7 +1,7 @@
-import { type Filter } from '@sisense/sdk-data';
+import { Attribute, Measure, type Filter } from '@sisense/sdk-data';
 import { WidgetProps } from '../../../props.js';
 import { DataPoint } from '../../../types';
-import { JtdConfig, JtdDrillTarget } from '../../../widget-by-id/types';
+import { DashboardConfig, DashboardProps } from '../../../dashboard/types';
 import { OpenModalFn } from '../../../common/components/modal/modal-context';
 import { OpenMenuFn } from '../../../common/components/menu/types.js';
 /**
@@ -44,6 +44,8 @@ export interface JtdContext {
     dashboardFilters: Filter[];
     /** The original widget filters */
     originalWidgetFilters: Filter[];
+    /** Extra filters to be applied with highest priority */
+    extraFilters?: Filter[];
 }
 /**
  * Base interface for JTD action functions
@@ -59,13 +61,13 @@ export interface JtdActions {
     translate?: (key: string) => string;
 }
 /**
- * Extended core data for JTD click handlers that includes drill target
+ * Extended core data for JTD click handlers that includes jump target
  *
  * @internal
  */
 export interface JtdClickHandlerData extends JtdCoreData {
-    /** The drill target */
-    drillTarget: JtdDrillTarget;
+    /** The jump target */
+    jumpTarget: JtdTarget;
 }
 /**
  * Configuration for widget transforms, combining config and context
@@ -79,6 +81,8 @@ export interface JtdWidgetTransformConfig {
     dashboardFilters: Filter[];
     /** The original widget filters */
     originalWidgetFilters: Filter[];
+    /** Extra filters to be applied with highest priority */
+    extraFilters?: Filter[];
 }
 /**
  * Event-related data for handling data point clicks
@@ -91,3 +95,254 @@ export interface JtdDataPointClickEvent {
     /** Function to get menu item */
     getJumpToDashboardMenuItem: (coreData: JtdCoreData, context: JtdContext, actions: Pick<JtdActions, 'openModal' | 'translate'>) => JtdMenuItem;
 }
+/**
+ * Configuration for Jump To Dashboard functionality.
+ * Allows users to navigate from a widget to another dashboard with contextual filtering.
+ */
+export interface JumpToDashboardConfig {
+    /**
+     * Whether Jump To Dashboard functionality is enabled
+     * @default true
+     */
+    enabled?: boolean;
+    /** List of target dashboards that can be navigated to */
+    targets: JtdTarget[];
+    /** Configuration for user interaction behavior */
+    interaction?: {
+        /**
+         * How users trigger the jump action
+         * Note that not all widgets support both trigger methods
+         *
+         * @default 'rightclick'
+         **/
+        triggerMethod?: TriggerMethod;
+        /**
+         * Caption prefix for jumping action (i.e in context menu)
+         * @default 'Jump to'
+         */
+        captionPrefix?: string;
+        /**
+         * Whether to show the Jump To Dashboard icon in the toolbar of the source widget
+         * @default true
+         */
+        showIcon?: boolean;
+    };
+    /**
+     * Configuration for the target dashboard display.
+     * This configuration will be merged with target dashboard config, having higher priority
+     * @default {}
+     */
+    targetDashboardConfig?: DashboardConfig;
+    /** Configuration for filter handling between source and target dashboards */
+    filtering?: {
+        /**
+         * Additional filters to apply to the target dashboard
+         *
+         * @example
+         * const extraFilters = [dashboardProps.filters[0], dashboardProps.widgets[0].filters[0]]
+         *
+         * @default []
+         */
+        extraFilters?: Filter[];
+        /**
+         * Dashboard-level filter dimensions to pass through
+         *
+         * undefined - include all
+         * [] - include nothing
+         * [string] - include specific dimensions
+         *
+         * example: ["[ER.Date (Calendar)]", "[Doctors.Specialty]"]
+         * @default undefined
+         */
+        includeDashboardFilters?: string[];
+        /**
+         * Widget-level filter dimensions to pass through
+         *
+         * undefined - include all
+         * [] - include nothing
+         * [string] - include specific dimensions
+         *
+         * example: ["[ER.Date (Calendar)]", "[Doctors.Specialty]"]
+         * @default undefined
+         */
+        includeWidgetFilters?: string[];
+        /**
+         * Whether to merge filters with existing target dashboard filters or replace them
+         * @default false
+         */
+        mergeWithTargetFilters?: boolean;
+    };
+    /** Configuration for the modal window that will display the target dashboard */
+    modal?: {
+        /**
+         * Width of the modal window
+         * @default 85 (when measurementUnit is '%') or 1200 (when measurementUnit is 'px')
+         */
+        width?: number;
+        /**
+         * Height of the modal window
+         * @default 85 (when measurementUnit is '%') or 800 (when measurementUnit is 'px')
+         */
+        height?: number;
+        /**
+         * Unit of measurement for width/height
+         * @default 'px'
+         */
+        measurementUnit?: '%' | 'px';
+    };
+}
+/**
+ * Configuration for Jump To Dashboard functionality for pivot widgets.
+ * Used for pivot widgets, allowing to configure jumping to different dashboard from different dimensions
+ * @see {@link JumpToDashboardConfig}
+ */
+export interface JumpToDashboardConfigForPivot extends Omit<JumpToDashboardConfig, 'targets'> {
+    /**
+     * Map of target dashboards for different dimensions/measures
+     *
+     * @alpha
+     * @example
+     *
+     * const FormulaMeasure = dashboardProps.widgets[0].dataOptions.values[0];
+     * const ageRangeAttribute = dashboardProps.widgets[0].dataOptions.rows[1];
+     *
+     * const targets = new Map([
+     *    [ageRangeAttribute, [target, target2]],
+     *    [FormulaMeasure, [target3]],
+     * ]);
+     *
+     */
+    targets: Map<Attribute | {
+        dimension: Attribute;
+        location: 'row' | 'column' | 'value';
+    } | Measure, JtdTarget[]>;
+}
+/**
+ * Target dashboard for Jump To Dashboard functionality.
+ * Supports both dashboard ID reference and in-code dashboard object.
+ * @see JumpToDashboardConfig
+ * @see DashboardProps
+ */
+export type JtdTarget = {
+    caption: string;
+    id: string;
+} | {
+    caption: string;
+    dashboard: DashboardProps;
+};
+/**
+ * Type guard to check if a jump target contains dashboard props
+ * @internal
+ */
+export declare const isJumpTargetWithDashboardProps: (target: JtdTarget) => target is {
+    caption: string;
+    dashboard: DashboardProps;
+};
+/**
+ * Type guard to check if a jump target contains dashboard ID
+ * @internal
+ */
+export declare const isJumpTargetWithId: (target: JtdTarget) => target is {
+    caption: string;
+    id: string;
+};
+/**
+ * @internal
+ */
+export type PivotDimType = 'columns' | 'rows' | 'values';
+/**
+ * @internal
+ */
+export type NonNegativeIntString = Exclude<`${bigint}`, `-${string}`>;
+/**
+ * Pivot dimension ID
+ * example: "columns.0", "rows.0", "values.0", "columns.1", "rows.1", "values.1", etc.
+ * @internal
+ */
+export type PivotDimId = `${PivotDimType}.${NonNegativeIntString}`;
+export type JtdTargetDto = {
+    caption: string;
+    id?: string;
+    oid?: string;
+};
+export type JtdPivotTargetDto = JtdTargetDto & {
+    pivotDimensions: string[];
+};
+/**
+ * Legacy representation of JTD config from Fusion
+ * @internal
+ */
+export type JtdConfigDto = {
+    drilledDashboardPrefix: string;
+    drilledDashboardsFolderPrefix: string;
+    displayFilterPane: boolean;
+    displayDashboardsPane: boolean;
+    displayToolbarRow: boolean;
+    displayHeaderRow: boolean;
+    volatile: boolean;
+    hideDrilledDashboards: boolean;
+    hideSharedDashboardsForNonOwner: boolean;
+    drillToDashboardRightMenuCaption: string;
+    drillToDashboardNavigateType: number;
+    drillToDashboardNavigateTypePivot: number;
+    drillToDashboardNavigateTypeCharts: number;
+    drillToDashboardNavigateTypeOthers: number;
+    drilledDashboardDisplayType: number;
+    dashboardIds: Array<JtdTargetDto | JtdPivotTargetDto>;
+    modalWindowResize: boolean;
+    modalWindowMeasurement?: 'px' | '%';
+    modalWindowWidth?: number;
+    modalWindowHeight?: number;
+    showFolderNameOnMenuSelection: boolean;
+    resetDashFiltersAfterJTD: boolean;
+    sameCubeRestriction: boolean;
+    showJTDIcon?: boolean;
+    sendPieChartMeasureFiltersOnClick: boolean;
+    forceZeroInsteadNull: boolean;
+    mergeTargetDashboardFilters: boolean;
+    drillToDashboardByName: boolean;
+    sendBreakByValueFilter: boolean;
+    ignoreFiltersSource: boolean;
+    sendFormulaFiltersDuplicate?: number | 'none' | undefined;
+    enabled?: boolean;
+    version?: string;
+    includeDashFilterDims?: string[];
+    includeWidgetFilterDims?: string[];
+};
+/**
+ * Jump To Dashboard action trigger method type
+ * click - when user clicks on the widget
+ * rightclick - when user right clicks on the widget, opening the context menu
+ * @see {@link JumpToDashboardConfig}
+ */
+export type TriggerMethod = 'click' | 'rightclick';
+/**
+ * @internal
+ */
+export type JtdTargetInner = JtdTarget & {
+    pivotDimensions?: PivotDimId[];
+};
+/**
+ * Internal representation of Jump To Dashboard configuration object.
+ * This is the legacy format that includes fields like drilledDashboardPrefix
+ * and modalWindowResize that don't have direct equivalents in JumpToDashboardConfig.
+ * @internal
+ */
+export type JtdConfig = {
+    jumpedDashboardPrefix?: string;
+    dashboardConfig?: DashboardConfig;
+    jumpToDashboardRightMenuCaption?: string;
+    navigateType?: TriggerMethod;
+    includeDashFilterDims?: string[];
+    includeWidgetFilterDims?: string[];
+    jumpTargets: Array<JtdTargetInner>;
+    modalWindowResize?: boolean;
+    modalWindowMeasurement?: 'px' | '%';
+    modalWindowWidth?: number;
+    modalWindowHeight?: number;
+    showJtdIcon?: boolean;
+    mergeTargetDashboardFilters?: boolean;
+    sendFormulaFiltersDuplicate?: number | 'none' | undefined;
+    enabled?: boolean;
+    extraFilters?: Filter[];
+};