react-semaphor 0.1.506 → 0.1.508

package/dist/types/lib/query-context/filter-group-utils.d.ts

@@ -0,0 +1,3 @@
+import { FilterGroup } from '../types/explorer-types.js';
+export declare function mergeFilterGroups(groups: (FilterGroup | undefined)[]): FilterGroup | undefined;
+export declare function getFilterGroupKey(filterGroup: FilterGroup | undefined): string | undefined;

package/dist/types/lib/query-context/resolve-runtime-card-filters.d.ts

@@ -0,0 +1,29 @@
+import { CardDrillPath } from '../dashboard-view-state/index.js';
+import { CardConfig, FilterGroup } from '../types/explorer-types.js';
+import { TCard } from '../types/common-types.js';
+import { SelectionFilterSource } from './compile-selection-filters.js';
+/**
+ * Combines a card's authored filters, its drill path and the selections that
+ * narrow it into one merged FilterGroup. A selection carried by a
+ * drill-through or into an insight arrives here like any other: the input
+ * resolver has already resolved it for this card.
+ *
+ * Filter combination logic:
+ * - Inside a filter group (group.filters): AND
+ * - Between drill steps: AND
+ * - Within a selection: AND inside a tuple, OR across tuples, AND across source cards
+ * - Between authored filters, the drill path, and selections: AND
+ */
+export declare function resolveRuntimeCardFilters(card: TCard, options?: {
+    includeAuthoredFilters?: boolean;
+    /** Other cards' selections, already resolved for this card. */
+    selections?: SelectionFilterSource[];
+    /** This card's drill path, from card view state. */
+    drill?: CardDrillPath;
+}): FilterGroup | undefined;
+/**
+ * The configuration a card runs with: grouped at its current drill level, with
+ * the resolved runtime filters. Validated here so every consumer (queries,
+ * exports, and so on) gets a valid comparison configuration.
+ */
+export declare function resolveRuntimeCardConfig(card: TCard, drill: CardDrillPath | undefined, resolvedFilters: FilterGroup | undefined): CardConfig;

package/dist/types/lib/selection/click-to-filter-authoring-support.d.ts

@@ -0,0 +1,9 @@
+import { TCard } from '../types/common-types.js';
+/**
+ * Card types that get the new click-to-filter authoring: the fields rule, the
+ * Matrix sources, Review cards and its field mapping. The aggregate table and
+ * the legacy pivot are legacy producers. Their clicks still filter, and an
+ * author can still turn that on or off and set the receiver flag, but they get
+ * none of the new options.
+ */
+export declare function supportsClickToFilterAuthoring(type: TCard['type']): boolean;

package/dist/types/lib/selection/selection-from-click-context.d.ts

@@ -0,0 +1,41 @@
+import { SelectionTuple } from '../../shared/analytics-protocol/selection-contract.js';
+import { ClickToFilterSettings } from '../../shared/dashboard-authoring/click-to-filter-settings.js';
+import { DashboardCardFilterSourceInventory } from '../../shared/dashboard-authoring/dashboard-card-source-index.js';
+import { Field } from '../types/explorer-types.js';
+import { ClickFilterCondition } from '../types/interaction-types.js';
+export type SelectionTupleUnavailableReason = 
+/** The click carried no dimension value (a total, a blank area). */
+'noFields'
+/** The fields rule needs the clicked column and it is not a filterable dimension. */
+ | 'clickedColumnNotFilterable'
+/** None of the clicked fields are among the author's chosen columns. */
+ | 'noChosenColumns'
+/** A field is calculated, or is not on a source this card executes. */
+ | 'fieldNotFilterable'
+/** The builder produced a condition that is not an equality or a blank. */
+ | 'unsupportedCondition';
+export type SelectionTupleResult = {
+    status: 'ready';
+    tuple: SelectionTuple;
+} | {
+    status: 'unavailable';
+    code: SelectionTupleUnavailableReason;
+    /** Viewer-facing; shown as a tooltip on the source. */
+    reason: string;
+};
+/**
+ * Turns a click-context builder's output into one selection tuple: applies the
+ * card's fields rule, drops measures, and grounds every explorer field on one
+ * of the source card's own executable sources. One ungroundable condition
+ * makes the whole tuple unavailable, because a partial tuple would filter to
+ * more than the viewer clicked.
+ */
+export declare function selectionTupleFromClickContext(params: {
+    settings: Pick<ClickToFilterSettings, 'fields'>;
+    /** Builder output. */
+    conditions: ClickFilterCondition[];
+    /** The dimension column under the pointer; required for 'clickedCell'. */
+    clickedField?: Field;
+    /** buildDashboardCardSourceIndex(card) of the source card. */
+    sourceIndex: DashboardCardFilterSourceInventory;
+}): SelectionTupleResult;

package/dist/types/lib/selection/selection-labels.d.ts

@@ -0,0 +1,3 @@
+import { SelectionTuple } from '../../shared/analytics-protocol/selection-contract.js';
+/** "West, East +3": the first two labels, then a count once there are more than three. */
+export declare function selectionChipLabel(tuples: SelectionTuple[]): string;

package/dist/types/lib/selection/selection-notices.d.ts

@@ -0,0 +1,9 @@
+import { SelectionTupleResult } from './selection-from-click-context.js';
+/**
+ * Tells the viewer why a click did not filter. A click on a column that simply
+ * is not a filter column stays silent: it is the ordinary case on a
+ * clicked-cell table, not a problem to report.
+ */
+export declare function notifySelectionUnavailable(result: Extract<SelectionTupleResult, {
+    status: 'unavailable';
+}>): void;

package/dist/types/lib/selection/selection-reducer.d.ts

@@ -0,0 +1,46 @@
+import { SelectionTuple } from '../../shared/analytics-protocol/selection-contract.js';
+export type SelectionGesture<TTuple = SelectionTuple> = 
+/** Plain click. */
+{
+    kind: 'replace';
+}
+/** Cmd/Ctrl-click; Shift-click on charts and matrix; tap when checkboxes are shown. */
+ | {
+    kind: 'toggle';
+}
+/** Shift-click on tables. `ordered` is the visible row order after sort and filter. */
+ | {
+    kind: 'range';
+    anchor: TTuple;
+    ordered: TTuple[];
+}
+/** Esc, blank plot area, chip dismiss, card Clear. */
+ | {
+    kind: 'clear';
+};
+export type SelectionReduceResult<TTuple = SelectionTuple> = {
+    tuples: TTuple[];
+    outcome: 'selected' | 'added' | 'removed' | 'cleared' | 'rangeSelected' | 'limitReached';
+};
+/** Pure selection state transition. `incoming` is ignored by `clear`. */
+export declare function reduceSelection(current: SelectionTuple[], incoming: SelectionTuple, gesture: SelectionGesture<SelectionTuple>, options: {
+    multipleSelection: boolean;
+    limit?: number;
+}): SelectionReduceResult<SelectionTuple>;
+export declare function reduceSelection<TTuple>(current: TTuple[], incoming: TTuple, gesture: SelectionGesture<TTuple>, options: {
+    multipleSelection: boolean;
+    limit?: number;
+    tupleKey: (tuple: TTuple) => string;
+}): SelectionReduceResult<TTuple>;
+/** What the pointer asked for. A range still needs the anchor and the visible row order, which the caller owns. */
+export type SelectionGestureIntent = 'replace' | 'toggle' | 'range';
+export declare function gestureFromPointer(event: {
+    shiftKey: boolean;
+    metaKey: boolean;
+    ctrlKey: boolean;
+    pointerType?: string;
+}, visual: 'table' | 'chart' | 'matrix', options: {
+    multipleSelection: boolean;
+    hasAnchor: boolean;
+    checkboxesShown: boolean;
+}): SelectionGestureIntent;

package/dist/types/lib/stores/dashboard-store.d.ts

@@ -1,6 +1,6 @@
 import { AuthToken, TBaseQuery, Breakpoint, ControlDefinition, CustomCard, StyleProps, TCard, TDashboard, TEvent, TFrame, TSheet, TStyle, AIScopeTable, TLens, CacheConfig, EmailSettings, FilterLayoutSettings, DocumentDefinition, DashboardInput, DashboardInputSlot, DashboardInputValues, DashboardLifecycleEvent } from '../types/common-types.js';
 import { TFilter, TFilterValue } from '../../components/surfboard/filter/types.js';
-import { ClickFilterCondition } from '../types/interaction-types.js';
+import { TransientInputContext } from '../dashboard-inputs/transient-input-context.js';
 import { default as ReactGridLayout } from 'react-grid-layout';
 import { DashboardAIContext } from '../types/assistant-types.js';
 import { FilterGroup, Field } from '../types/explorer-types.js';
@@ -14,6 +14,8 @@ import { DashboardFilterAuthoringSettingsUpdate } from '../dashboard-inputs/dash
 import { GlobalDateComparisonSelection } from '../../shared/analytics-protocol/index.js';
 import { CalendarPreferencesResponse, ReportRuntimeContext, ResolvedCalendarPreferenceSources } from '../../shared/report-runtime-context/index.js';
 import { ResolvedValueFormatPreferenceSources, ResolvedValueFormatPreferences } from '../../shared/value-format-preferences/index.js';
+import { DashboardNavigationEntry, DashboardNavigationState, DashboardTransientContextScope, InsightRenderRequest, NavigationRejection } from '../dashboard-navigation/index.js';
+import { CardViewStateMap, DrillStep } from '../dashboard-view-state/index.js';
 type AddFrameOptions = {
     position?: 'start' | 'end';
     insertAfterFrameId?: string;
@@ -93,25 +95,38 @@ export type DashboardStore = {
     cardControlValuesMap: Record<string, Record<string, unknown>>;
     /** Runtime-only dashboard input values keyed by input runtime scope. */
     dashboardInputValues: DashboardInputValues;
+    /** Session-only per-card view state (the drill path), keyed by cardId. Never persisted. */
+    cardViewState: CardViewStateMap;
     /** Fixed execution clock from a strict dashboard input replay snapshot. */
     dashboardInputReferenceTime?: string;
     semanticExecutionPayload: SemanticExecutionPayload;
     reportContext: ReportRuntimeContext | null;
     /** Access-token session that owns the hydrated report context. */
     reportContextSessionAccessToken: string | null;
-    drillHistory: Array<{
-        sourceDashboardId: string;
-        targetDashboardId: string;
-        sourceDashboardTitle?: string;
-        filters: ClickFilterCondition[];
-        contextMode: 'interactionFilters' | 'full' | 'none';
-        timestamp: number;
-    }>;
-    drillContext: {
-        filters: ClickFilterCondition[];
-        sourceDashboardId: string;
-        sourceDashboardTitle?: string;
-    } | null;
+    /**
+     * Drill-through history, the dashboard navigation points at, and open
+     * insights. Session only.
+     */
+    navigationStack: DashboardNavigationState['navigationStack'];
+    navigationTarget: DashboardNavigationState['navigationTarget'];
+    insightRenderRequests: DashboardNavigationState['insightRenderRequests'];
+    /**
+     * Carried contexts restored from an execution snapshot (print, embed), for
+     * the dashboard that snapshot renders. Null in a live session, where the
+     * navigation stack decides. Read through `selectEffectiveTransientContexts`.
+     */
+    restoredTransientContextScope: DashboardTransientContextScope | null;
+    /**
+     * Context kept for the dashboard being left until dashboard selection
+     * catches up with `navigationTarget`. Null outside that short handoff.
+     */
+    outgoingTransientContextScope: DashboardTransientContextScope | null;
+    /**
+     * A drill-through the viewer asked for, built at the click, waiting for its
+     * destination to load. It becomes a navigation entry only then, so the
+     * dashboard being left keeps its own carried context until it goes away.
+     */
+    pendingDrillThrough: DashboardNavigationEntry | null;
     onEvent?: (event: TEvent) => void;
     onDashboardLifecycleEvent?: (event: DashboardLifecycleEvent) => void;
     onSaveFunction?: (dashboard: TDashboard, description?: string) => void;
@@ -156,6 +171,12 @@ type Actions = {
     resetDashboardInputComparisonSelection: (input: Pick<DashboardInput, 'id' | 'runtimeScope'>, target: DashboardInputRuntimeTarget) => void;
     clearDashboardInputSlot: (input: Pick<DashboardInput, 'id' | 'runtimeScope'>, target: DashboardInputRuntimeTarget) => void;
     removeDashboardInputSlot: (input: Pick<DashboardInput, 'id' | 'runtimeScope'>, target: DashboardInputRuntimeTarget) => void;
+    /** Drills one level into a card. `hierarchyId` is set for an authored hierarchy. */
+    pushDrillStep: (cardId: string, step: DrillStep, hierarchyId?: string) => void;
+    /** Drills one level back up. */
+    popDrillStep: (cardId: string) => void;
+    resetCardViewState: (cardId: string) => void;
+    resetAllCardViewState: () => void;
     setDashboardControlsModel: (controls: ControlDefinition[], defaultValues?: Record<string, unknown>, options?: DashboardControlsModelOptions) => void;
     updateDashboardControl: (controlId: string, updates: Partial<ControlDefinition>) => void;
     reorderDashboardControls: (orderedControlIds: string[]) => void;
@@ -186,6 +207,9 @@ type Actions = {
         semanticExecutionPayload?: SemanticExecutionPayload;
         dashboardInputValues?: DashboardInputValues;
         dashboardInputReferenceTime?: string;
+        /** Drill paths replayed from an execution snapshot. */
+        cardViewState?: CardViewStateMap;
+        transientContexts?: TransientInputContext[];
         reportContext?: ReportRuntimeContext;
         authToken?: AuthToken;
     }) => void;
@@ -302,9 +326,30 @@ type Actions = {
         error?: string;
     };
     isCardIdUnique: (cardId: string, currentCardId?: string) => boolean;
-    navigateWithDrill: (targetDashboardId: string, sourceDashboardId: string, sourceDashboardTitle: string | undefined, filters: ClickFilterCondition[], contextMode: 'interactionFilters' | 'full' | 'none') => void;
-    goBackFromDrill: () => void;
-    clearDrillContext: () => void;
+    /**
+     * Holds a drill-through until its destination has loaded; see
+     * `pendingDrillThrough`. The dashboard drill host completes it with
+     * `navigateToDashboard`, or cancels it when the destination cannot load.
+     */
+    requestDrillThrough: (entry: DashboardNavigationEntry) => void;
+    cancelDrillThrough: () => void;
+    /**
+     * Drill through: pushes the entry, points navigation at its destination and
+     * closes open insights, as one transition. A rejected entry changes nothing.
+     */
+    navigateToDashboard: (entry: DashboardNavigationEntry) => {
+        success: true;
+    } | {
+        success: false;
+        reason: NavigationRejection;
+    };
+    /** One step back, as one transition. Returns false at the root. */
+    goBack: () => boolean;
+    /** Forgets the drill history and stays on the current dashboard. */
+    clearNavigation: () => void;
+    openInsightRequest: (request: InsightRenderRequest) => void;
+    closeInsightRequest: (sourceCardId: string) => void;
+    closeAllInsightRequests: () => void;
 };
 export declare const useDashboardStore: import('zustand').UseBoundStore<Omit<import('zustand').StoreApi<DashboardStore>, "setState"> & {
     setState(nextStateOrUpdater: DashboardStore | Partial<DashboardStore> | ((state: import('immer').WritableDraft<DashboardStore>) => void), shouldReplace?: false): void;

package/dist/types/lib/stores/editor-store.d.ts

@@ -6,7 +6,6 @@ import { FilterByColumn, OldFilterValue, GroupByColumn, MetricColumn, OrderBy, Q
 import { TableActions } from './table-actions.js';
 import { CardConfig, QueryColumnKeyMap } from '../types/explorer-types.js';
 import { ExplorerActions } from './explorer-actions.js';
-import { DrillActions } from './drill-actions.js';
 /**
  * Draft slots for preserving work when switching between dev and standard modes.
  * When user switches FROM a mode, the current work is saved to that mode's draft slot.
@@ -97,7 +96,7 @@ export type EditorStore = {
     /** Draft slots for mode switching - preserves work when toggling between dev/standard */
     modeDrafts: ModeDrafts;
 };
-type Actions = TableActions & ExplorerActions & DrillActions & {
+type Actions = TableActions & ExplorerActions & {
     /** Resets the editor store to its initial state. Called when loading a new dashboard. */
     resetEditorStore: () => void;
     setEditorFilterMode: (filterColumnName: string, filterMode: 'include' | 'exclude') => void;

package/dist/types/lib/stores/index.d.ts

@@ -1,7 +1,5 @@
-export { useInteractionStore, useResolvedCardConfig, useClickFiltersForCard, createInitialInteractionState, } from './interaction-store.js';
 export { useChartJSStore } from './chartjs-store.js';
 export { useDashboardStore } from './dashboard-store.js';
-export { usePointerInteractionStore } from './pointer-interaction-store.js';
 export { useEditorStore, useEditorActions } from './editor-store.js';
 export { useAssistantLayoutStore, useAssistantPanel, useFullscreenAssistant, useAssistantContainer, } from './assistant-layout-store.js';
 export { useAIInteractionStore, useCurrentAIContext, useAISelectedEntities, useAIActions, } from './ai-interaction-store.js';

package/dist/types/lib/types/common-types.d.ts

@@ -1,3 +1,4 @@
+import { CardViewStateMap } from '../dashboard-view-state/index.js';
 import { TFilter, TFilterValue, Operation, TCustomFilterPreferences, DateSelectionMode, DefaultDateFilter, FilterFieldMeta, FilterSemanticContext } from '../../components/surfboard/filter/types.js';
 import { FontSpec } from 'chart.js';
 import { TChartType } from '../charts/types.js';
@@ -6,13 +7,18 @@ import { TablePreferences } from '../../components/visual/data-table/types/data-
 import { CalculatedFieldFormula, CardConfig, Field, FormatSpec, AggregateFunction, GroupByField, MetricField, PaginationConfig, DateFormatValue, EntityType, TimeGranularity, DataSource } from './explorer-types.js';
 import { ComparisonPresentationSpec, GlobalDateComparisonSelection, MetricComparisonPolarity, SemaphorDerivedFieldDefinition, TemporalBucketFormat } from '../../shared/analytics-protocol/index.js';
 import { DashboardFilterApplication, DashboardFilterOptionSource, DashboardFilterOptionDependencies, DashboardFilterOptionPopulation } from '../../shared/dashboard-authoring/dashboard-filter-mapping-types.js';
+import { ClickToFilterSettings, LinkedClickToFilterOverrides } from '../../shared/dashboard-authoring/click-to-filter-settings.js';
+import { SelectionInputValue } from '../../shared/analytics-protocol/selection-contract.js';
+import { ResolvedCardSelection } from '../dashboard-inputs/resolve-selection-input.js';
+import { TransientInputContext } from '../dashboard-inputs/transient-input-context.js';
 import { DashboardAIContext } from './assistant-types.js';
-import { CardInteractionConfig, InteractionState, InteractionTargetOverride } from './interaction-types.js';
+import { CardInteractionConfig, InteractionTargetOverride } from './interaction-types.js';
 import { SemanticExecutionPayload } from './semantic-runtime-types.js';
 import { ReportRuntimeContext } from '../../shared/report-runtime-context/index.js';
 import { PresentationExecutionSnapshot } from '../../shared/format-utils/index.js';
 import { JSX } from 'react';
 export type { DashboardFilterApplication, DashboardFilterBoundCardApplication, DashboardFilterCardApplication, DashboardFilterExcludedCardApplication, DashboardFilterTarget, DashboardFilterTargetField, DashboardFilterTargetSource, DashboardFilterOptionSource, } from '../../shared/dashboard-authoring/dashboard-filter-mapping-types.js';
+export type { ClickToFilterCardMapping, ClickToFilterFieldsRule, ClickToFilterMatrixSources, ClickToFilterSettings, LinkedClickToFilterOverrides, } from '../../shared/dashboard-authoring/click-to-filter-settings.js';
 export type Level = 'database' | 'schema' | 'table';
 export type SelectionState = Record<Level, string | null>;
 export declare const EMPTY_SELECTION: SelectionState;
@@ -253,11 +259,6 @@ export type DashboardProps = {
      * inputs instead of documentInputValues.
      */
     dashboardInputExecutionSnapshot?: DashboardInputExecutionSnapshot;
-    /**
-     * Runtime interaction state captured for deterministic print/replay entry
-     * points. Ordinary dashboard consumers should leave this unset.
-     */
-    interactionExecutionSnapshot?: Record<string, InteractionState>;
     /** Server-resolved immutable presentation snapshot for internal print views. */
     presentationExecutionSnapshot?: PresentationExecutionSnapshot;
     /**
@@ -1044,12 +1045,37 @@ export type NormalizedFilterDashboardInput = FilterDashboardInputBase & {
     optionDependencies?: DashboardFilterOptionDependencies;
     optionPopulation?: DashboardFilterOptionPopulation;
     application?: DashboardFilterApplication;
+    /**
+     * Runtime-only policy for synthesized inputs whose predicate must never be
+     * sent to a SQL card without an explicit, validated binding, and must never
+     * block a card: a target it cannot use (ambiguous, incompatible, stale)
+     * drops the predicate for that card, because no author of this dashboard
+     * could repair it. Authored inputs omit it and keep the existing SQL Auto and
+     * blocking behavior.
+     */
+    unmappedTargetPolicy?: 'requireFieldProof';
     definitionOrigin: 'embedded' | 'dashboardFilter';
 };
 export type ControlDashboardInput = DashboardInputBase & {
     kind: 'control';
     control: ControlDefinition;
 };
+/**
+ * Synthesized per enabled source card at runtime; never persisted and not a
+ * member of `DashboardInput`. It is deliberately not a member of
+ * `NormalizedDashboardInput` either: that union feeds aliases, exports, toolbar
+ * controls and authored defaults, none of which a selection has. Selection
+ * inputs travel on their own typed list (`buildSelectionDashboardInputs`), so
+ * no consumer can read one as a control.
+ * Base fields: id = selectionInputId(cardId), label = card title,
+ * variableName = `selection_${cardId}`, scope = settings.targets,
+ * runtimeScope = 'shared', presentation hidden.
+ */
+export type SelectionDashboardInput = DashboardInputBase & {
+    kind: 'selection';
+    sourceCardId: string;
+    settings: ClickToFilterSettings;
+};
 export type NormalizedDashboardInput = NormalizedFilterDashboardInput | ControlDashboardInput;
 export type DashboardInputValue = {
     kind: 'filter';
@@ -1057,6 +1083,9 @@ export type DashboardInputValue = {
 } | {
     kind: 'control';
     value: unknown;
+} | {
+    kind: 'selection';
+    selection: SelectionInputValue;
 };
 export type DashboardInputSlot = {
     status: 'set';
@@ -1130,6 +1159,8 @@ export type ResolvedDashboardInputContext = {
     dateComparisonInputs?: ResolvedDashboardDateComparisonInput[];
     variablesById: Record<string, ResolvedDashboardInput>;
     missingRequiredInputs: ResolvedDashboardInput[];
+    /** Other cards' selections, resolved for this card. Empty without a card. */
+    selections: ResolvedCardSelection[];
 };
 export type DashboardInputVariableRef = {
     source: 'dashboardInput';
@@ -1196,6 +1227,19 @@ export type DashboardInputExecutionSnapshot = {
     cardId?: string;
     mode: 'dashboard' | 'document' | 'visual';
     dashboardInputValues: DashboardInputValues;
+    /**
+     * Drill paths by card, so an export shows each card at the level the viewer
+     * was looking at. Present only when a card is drilled.
+     */
+    cardViewState?: CardViewStateMap;
+    /**
+     * Contexts carried to the rendered dashboard by a drill-through: hidden
+     * definitions plus their values, under their own namespace. Their context
+     * mode decides whether the dashboard's own toolbar filters apply, so the
+     * replay reads the mode from here rather than from a second field. The
+     * navigation history is not captured. Present only after a drill-through.
+     */
+    transientContexts?: TransientInputContext[];
     generatedAt?: string;
     timezone?: string;
 };
@@ -1226,6 +1270,12 @@ export type TCard = {
     linkedSourceCardId?: string;
     linkedReferenceOverrides?: DashboardCardReferenceRemapping;
     linkedInteractionTargetOverrides?: Record<string, InteractionTargetOverride>;
+    /** Author settings for click to filter. Absent means "derive from legacy interactions or defaults". */
+    clickToFilter?: ClickToFilterSettings;
+    /** Receiver side. false = this card ignores selections from every source card. Default true. */
+    respondsToSelections?: boolean;
+    /** Instance-level click-to-filter overrides for a linked library visual. */
+    linkedClickToFilterOverrides?: LinkedClickToFilterOverrides;
     paginationConfig?: PaginationConfig;
     queryConfig?: QueryConfig;
     customCfg?: any;
@@ -1527,6 +1577,10 @@ export type EmailSettings = {
 export type TDashboard = {
     id: string;
     title?: string;
+    interactionDefaults?: {
+        /** Dashboard creation sets 'on'. Absent resolves to 'off', so existing dashboards do not change. */
+        clickToFilter: 'on' | 'off';
+    };
     aiContext?: DashboardAIContext;
     summary?: {
         enabled?: boolean;

package/dist/types/lib/types/explorer-types.d.ts

@@ -1,4 +1,4 @@
-import { ClickFilterInteraction, DrillHierarchy, TimeDrillStep } from './interaction-types.js';
+import { TimeDrillStep } from './interaction-types.js';
 import { SemaphorDerivedFieldDefinition, MatrixConfig, SemaphorSourceRef, SemaphorResultColumn, SemaphorPivotValue, SemaphorTimeGrain, SemanticGroupedTemporalInput, TemporalBucketMetadata, TemporalBucketFormat, MetricComparisonConfig, MetricComparisonPolarity } from '../../shared/analytics-protocol/index.js';
 import { CanonicalPivotResultContract, CanonicalPivotResultState, FlatTableExportTotalsBehavior, FlatTableExportTotalsRequest, QueryColumnKeyMap as SharedQueryColumnKeyMap } from '../../shared/format-utils/index.js';
 import { TemporalResultOwner } from '../../shared/dashboard-authoring/index.js';
@@ -619,27 +619,6 @@ export interface CardConfig {
     filters?: FilterGroup;
     joinPlan?: JoinPlan;
     rowLimit?: number;
-    /**
-     * One or more hierarchies that define drillable paths through dimensions.
-     */
-    drillHierarchies?: DrillHierarchy[];
-    /**
-     * Optional list of dimensions allowed for dynamic drill-down across this card.
-     * Used only when drill steps contain `mode: 'dynamicDrill'` or `type: 'dynamic'`.
-     */
-    allowedDrillTargets?: Field[];
-    /**
-     * NOT UOptional preload settings for inline drill previews
-     */
-    inlineDrillPreview?: {
-        enabled: boolean;
-        limit: number;
-        mode: 'lazy' | 'preloaded';
-    };
-    /**
-     * Configuration for on-click dashboard filters triggered by this card.
-     */
-    clickFilterInteractions?: ClickFilterInteraction[];
     summary?: {
         enabled?: boolean;
         showOnCard?: boolean;