drizzle-cube 0.5.7 → 0.6.0

package/dist/client/components/AnalysisBuilder/AnalysisFilterItem.d.ts

@@ -10,5 +10,5 @@ interface AnalysisFilterItemProps {
     /** Callback to update this filter */
     onUpdate: (filter: SimpleFilter) => void;
 }
-export default function AnalysisFilterItem({ filter, schema, onRemove, onUpdate }: AnalysisFilterItemProps): import("react/jsx-runtime").JSX.Element;
+export default function AnalysisFilterItem({ filter, schema, onRemove, onUpdate }: AnalysisFilterItemProps): import("react").JSX.Element;
 export {};

package/dist/client/components/AnalysisBuilder/AnalysisFilterSection.d.ts

@@ -12,5 +12,5 @@ interface AnalysisFilterSectionProps {
     /** Only allow dimension filters (no measures) - used for funnel step filters */
     dimensionsOnly?: boolean;
 }
-export default function AnalysisFilterSection({ filters, schema, onFiltersChange, onFieldDropped, dimensionsOnly }: AnalysisFilterSectionProps): import("react/jsx-runtime").JSX.Element;
+export default function AnalysisFilterSection({ filters, schema, onFiltersChange, onFieldDropped, dimensionsOnly }: AnalysisFilterSectionProps): import("react").JSX.Element;
 export {};

package/dist/client/components/AnalysisBuilder/AnalysisModeErrorBoundary.d.ts

@@ -22,6 +22,6 @@ export declare class AnalysisModeErrorBoundary extends Component<Props, State> {
     componentDidCatch(error: Error, errorInfo: React.ErrorInfo): void;
     handleReset: () => void;
     handleSwitchToSafeMode: () => void;
-    render(): string | number | boolean | Iterable<React.ReactNode> | import("react/jsx-runtime").JSX.Element | null | undefined;
+    render(): string | number | boolean | Iterable<React.ReactNode> | React.JSX.Element | null | undefined;
 }
 export default AnalysisModeErrorBoundary;

package/dist/client/components/AnalysisBuilder/AnalysisQueryPanelParts.d.ts

@@ -0,0 +1,64 @@
+import { default as React } from 'react';
+import { AnalysisQueryPanelProps, BreakdownItem } from './types';
+import { MetaField } from '../../shared/types';
+import { QueryMergeStrategy } from '../../types';
+type Props = AnalysisQueryPanelProps;
+/** True when the funnel mode UI has all the callbacks it needs to render. */
+export declare function canRenderFunnelMode(p: Props): boolean;
+/** True when the flow mode UI has all the callbacks/state it needs to render. */
+export declare function canRenderFlowMode(p: Props): boolean;
+/**
+ * Whether a dedicated mode (funnel/flow/retention) replaces the standard layout.
+ */
+export declare function shouldRenderModeContent(p: Props): boolean;
+/**
+ * Renders the dedicated mode UI (funnel / flow / retention) when one of those
+ * analysis types is active and all the required callbacks are present. Returns
+ * null when the standard query/chart/display layout should be used instead.
+ */
+export declare function AnalysisModeContent(props: Props): React.JSX.Element | null;
+interface TabBarProps {
+    activeTab: Props['activeTab'];
+    onActiveTabChange: Props['onActiveTabChange'];
+    isMultiQuery: boolean;
+    queryCount: number;
+    activeQueryIndex: number;
+    onAddQuery?: Props['onAddQuery'];
+    getQueryTabLabel: (index: number) => string;
+    handleQueryTabClick: (index: number) => void;
+    handleRemoveQuery: (e: React.MouseEvent, index: number) => void;
+}
+export declare function QueryPanelTabBar(props: TabBarProps): React.JSX.Element;
+export declare function MergeStrategyControls({ mergeStrategy, onMergeStrategyChange, isFunnelMode, funnelBindingKey, onFunnelBindingKeyChange, schema, }: {
+    mergeStrategy: QueryMergeStrategy;
+    onMergeStrategyChange?: Props['onMergeStrategyChange'];
+    isFunnelMode: boolean;
+    funnelBindingKey?: Props['funnelBindingKey'];
+    onFunnelBindingKeyChange?: Props['onFunnelBindingKeyChange'];
+    schema: Props['schema'];
+}): React.JSX.Element;
+export declare function AdapterValidationBanner({ adapterValidation, }: {
+    adapterValidation: NonNullable<Props['adapterValidation']>;
+}): React.JSX.Element;
+export declare function MultiQueryValidationBanner({ multiQueryValidation, }: {
+    multiQueryValidation: NonNullable<Props['multiQueryValidation']>;
+}): React.JSX.Element;
+interface TabContentProps extends Props {
+    isMultiQuery: boolean;
+    getFieldMeta: (breakdown: BreakdownItem) => MetaField | null;
+    comparisonEnabledBreakdown: BreakdownItem | undefined;
+}
+/**
+ * Renders the active tab's body (query sections / chart config / display config)
+ * for the standard (non-mode) layout.
+ */
+export declare function QueryPanelTabContent(props: TabContentProps): React.JSX.Element | null;
+export declare function LockedBreakdownList({ breakdowns, getFieldMeta, comparisonEnabledBreakdown, onBreakdownGranularityChange, onBreakdownComparisonToggle, onMergeStrategyChange, }: {
+    breakdowns: BreakdownItem[];
+    getFieldMeta: (breakdown: BreakdownItem) => MetaField | null;
+    comparisonEnabledBreakdown: BreakdownItem | undefined;
+    onBreakdownGranularityChange: Props['onBreakdownGranularityChange'];
+    onBreakdownComparisonToggle?: Props['onBreakdownComparisonToggle'];
+    onMergeStrategyChange?: Props['onMergeStrategyChange'];
+}): React.JSX.Element;
+export {};

package/dist/client/components/AnalysisBuilder/AnalysisResultsHeader.d.ts

@@ -0,0 +1,67 @@
+/**
+ * AnalysisResultsHeader
+ *
+ * Presentational header for AnalysisResultsPanel: the status / row-count line,
+ * the toolbar of action buttons (display limit, AI, palette, share, refresh,
+ * clear, schema, debug) and the large-dataset performance warning. Extracted to
+ * keep the panel's renderHeader flat. Behaviour and markup are identical to the
+ * previous inline rendering.
+ *
+ * Props are grouped into cohesive named slices instead of a flat bag, and each
+ * sub-component receives only the slice it needs:
+ *   - `summary`  → results state / row-count line + debug-error indicator
+ *   - `toolbar`  → action handlers and their transient state
+ *   - `display`  → view / visibility flags driving which controls render
+ */
+type Row = Record<string, unknown>;
+/** Results state + row counts that drive the status line, warning and error dot. */
+export interface ResultsSummary {
+    executionResults: Row[] | null | undefined;
+    executionStatus: string;
+    totalRowCount: number | null;
+    resultsStale: boolean;
+    executionError: unknown;
+    debugDataPerQuery: Array<{
+        error?: unknown;
+    }>;
+}
+/** Action handlers and their transient state for the toolbar buttons. */
+export interface ResultsToolbarActions {
+    displayLimit: number;
+    onDisplayLimitChange?: (limit: number) => void;
+    isAIOpen?: boolean;
+    onAIToggle?: () => void;
+    onColorPaletteChange?: (palette: string) => void;
+    currentPaletteName?: string;
+    onShareClick?: () => void;
+    shareButtonState: string;
+    canShare: boolean;
+    onRefreshClick?: (opts: {
+        bustCache: boolean;
+    }) => void;
+    canRefresh: boolean;
+    isRefreshing: boolean;
+    showCacheBustIndicator: boolean;
+    setIsHoveringRefresh: (v: boolean) => void;
+    onClearClick?: () => void;
+    canClear: boolean;
+    setIsClearConfirmOpen: (v: boolean) => void;
+    setShowDebug: (v: boolean) => void;
+    setShowSchema: (v: boolean) => void;
+}
+/** View / visibility flags deciding which controls render. */
+export interface ResultsDisplayFlags {
+    activeView: string;
+    showDebug: boolean;
+    showSchema: boolean;
+    enableAI?: boolean;
+    isFunnelMode: boolean;
+    showSchemaDiagram: boolean;
+}
+export interface ResultsHeaderProps {
+    summary: ResultsSummary;
+    toolbar: ResultsToolbarActions;
+    display: ResultsDisplayFlags;
+}
+export default function ResultsHeader({ summary, toolbar, display }: ResultsHeaderProps): import("react").JSX.Element;
+export {};

package/dist/client/components/AnalysisBuilder/BreakdownComparisonToggle.d.ts

@@ -0,0 +1,13 @@
+/**
+ * BreakdownComparisonToggle Component
+ *
+ * "vs prior" period-comparison toggle for time-dimension breakdowns.
+ * Extracted from BreakdownItemCard to keep its render body flat.
+ */
+interface BreakdownComparisonToggleProps {
+    enableComparison?: boolean;
+    comparisonDisabled?: boolean;
+    onComparisonToggle: () => void;
+}
+declare const BreakdownComparisonToggle: import('react').NamedExoticComponent<BreakdownComparisonToggleProps>;
+export default BreakdownComparisonToggle;

package/dist/client/components/AnalysisBuilder/BreakdownRow.d.ts

@@ -0,0 +1,26 @@
+import { DragEvent } from 'react';
+import { MetaField } from '../../shared/types';
+import { BreakdownItem } from './types';
+interface BreakdownRowProps {
+    breakdown: BreakdownItem;
+    fieldMeta: MetaField | null;
+    sortDirection: 'asc' | 'desc' | null;
+    sortPriority: number | undefined;
+    index: number;
+    transform: string;
+    showGapBefore: boolean;
+    isAnyDragging: boolean;
+    isDragging: boolean;
+    comparisonDisabled: boolean;
+    onRemove: (id: string) => void;
+    onGranularityChange: (id: string, granularity: string) => void;
+    onComparisonToggle?: (id: string) => void;
+    onOrderChange?: (field: string, direction: 'asc' | 'desc' | null) => void;
+    onReorder?: (fromIndex: number, toIndex: number) => void;
+    onItemDragOver: (e: DragEvent, index: number) => void;
+    onItemDrop: (e: DragEvent) => void;
+    onDragStart: (e: DragEvent, index: number) => void;
+    onDragEnd: () => void;
+}
+declare const BreakdownRow: import('react').NamedExoticComponent<BreakdownRowProps>;
+export default BreakdownRow;

package/dist/client/components/AnalysisBuilder/DisplayOptionControl.d.ts

@@ -0,0 +1,10 @@
+import { ChartDisplayConfig, ColorPalette } from '../../types';
+import { DisplayOptionConfig } from '../../charts/chartConfigs';
+interface DisplayOptionControlProps {
+    option: DisplayOptionConfig;
+    displayConfig: ChartDisplayConfig;
+    colorPalette?: ColorPalette;
+    onDisplayConfigChange: (config: ChartDisplayConfig) => void;
+}
+export default function DisplayOptionControl({ option, displayConfig, colorPalette, onDisplayConfigChange, }: DisplayOptionControlProps): import("react").JSX.Element | null;
+export {};

package/dist/client/components/AnalysisBuilder/ExecutionPlanPanelParts.d.ts

@@ -0,0 +1,22 @@
+import { ReactNode } from 'react';
+import { ExplainResult } from '../../types';
+export declare function SqlBlock({ sql, sqlLoading, sqlError, sqlPlaceholder, formattedSql, title, height, headerRight, }: {
+    sql: {
+        sql: string;
+        params?: unknown[];
+    } | null | undefined;
+    sqlLoading: boolean;
+    sqlError?: Error | null;
+    sqlPlaceholder: string;
+    formattedSql: string;
+    title: string;
+    height: string;
+    headerRight: ReactNode;
+}): import("react").JSX.Element;
+export declare function ExplainResults({ explainLoading, explainError, explainResult, useAnalyze, aiButton, }: {
+    explainLoading: boolean;
+    explainError?: Error | null;
+    explainResult: ExplainResult | null;
+    useAnalyze: boolean;
+    aiButton: ReactNode;
+}): import("react").JSX.Element | null;

package/dist/client/components/AnalysisBuilder/ExplainAIPanel.d.ts

@@ -1,3 +1,4 @@
+import { default as React } from 'react';
 import { AIExplainAnalysis } from '../../types';
 interface ExplainAIPanelProps {
     /** AI analysis result */
@@ -11,5 +12,5 @@ interface ExplainAIPanelProps {
  * ExplainAIPanel - Modal component for displaying AI analysis results
  * Shows in a near full-screen modal with scrolling
  */
-export declare function ExplainAIPanel({ analysis, onClose, onClear }: ExplainAIPanelProps): import("react/jsx-runtime").JSX.Element;
+export declare function ExplainAIPanel({ analysis, onClose, onClear }: ExplainAIPanelProps): React.JSX.Element;
 export default ExplainAIPanel;

package/dist/client/components/AnalysisBuilder/FieldDetailPanel.d.ts

@@ -1,4 +1,4 @@
 import { FieldDetailPanelProps } from './types';
-declare function FieldDetailPanel({ field }: FieldDetailPanelProps): import("react/jsx-runtime").JSX.Element;
+declare function FieldDetailPanel({ field }: FieldDetailPanelProps): import("react").JSX.Element;
 declare const _default: import('react').MemoExoticComponent<typeof FieldDetailPanel>;
 export default _default;

package/dist/client/components/AnalysisBuilder/FieldSearchItem.d.ts

@@ -1,6 +1,6 @@
 import { FieldSearchItemProps } from './types';
 declare function FieldSearchItem({ field, isSelected, isFocused, onClick, onMouseEnter, ...props }: FieldSearchItemProps & {
     'data-field-index'?: number;
-}): import("react/jsx-runtime").JSX.Element;
+}): import("react").JSX.Element;
 declare const _default: import('react').MemoExoticComponent<typeof FieldSearchItem>;
 export default _default;

package/dist/client/components/AnalysisBuilder/FieldSearchModal.d.ts

@@ -1,2 +1,2 @@
 import { FieldSearchModalProps } from './types';
-export default function FieldSearchModal({ isOpen, onClose, onSelect, mode, schema, selectedFields, recentFields: externalRecentFields }: FieldSearchModalProps): import("react/jsx-runtime").JSX.Element | null;
+export default function FieldSearchModal({ isOpen, onClose, onSelect, mode, schema, selectedFields, recentFields: externalRecentFields }: FieldSearchModalProps): import("react").JSX.Element | null;

package/dist/client/components/AnalysisBuilder/FieldSearchResults.d.ts

@@ -0,0 +1,16 @@
+import { FieldOption } from './types';
+import { MetaResponse } from '../../shared/types';
+interface FieldSearchResultsProps {
+    mode: 'metrics' | 'breakdown' | 'filter' | 'dimensionFilter';
+    schema: MetaResponse | null;
+    searchTerm: string;
+    recentOptions: FieldOption[];
+    groupedFields: Map<string, FieldOption[]>;
+    filteredCount: number;
+    selectedFields: string[];
+    focusedIndex: number;
+    onSelectField: (field: FieldOption, fieldIndex: number, shiftKey: boolean) => void;
+    onFocusField: (field: FieldOption, index: number) => void;
+}
+declare const FieldSearchResults: import('react').NamedExoticComponent<FieldSearchResultsProps>;
+export default FieldSearchResults;

package/dist/client/components/AnalysisBuilder/FilterConfigModal.d.ts

@@ -1,3 +1,4 @@
+import { default as React } from 'react';
 import { SimpleFilter } from '../../types';
 import { MetaResponse } from '../../shared/types';
 interface FilterConfigModalProps {
@@ -12,5 +13,5 @@ interface FilterConfigModalProps {
     /** Element to position the modal near */
     anchorElement?: HTMLElement | null;
 }
-export default function FilterConfigModal({ filter: initialFilter, schema, onSave, onCancel, anchorElement }: FilterConfigModalProps): import("react/jsx-runtime").JSX.Element;
+export default function FilterConfigModal({ filter: initialFilter, schema, onSave, onCancel, anchorElement }: FilterConfigModalProps): React.JSX.Element;
 export {};

package/dist/client/components/AnalysisBuilder/FilterValueInput.d.ts

@@ -0,0 +1,63 @@
+import { ChangeEvent, MouseEvent, KeyboardEvent, RefObject } from 'react';
+import { SimpleFilter } from '../../types';
+import { DateRangeType } from '../../shared/types';
+type OperatorMeta = {
+    requiresValues?: boolean;
+    valueType?: string;
+    supportsMultipleValues?: boolean;
+} | undefined;
+/** Which control to render: the filter being edited and its operator metadata. */
+export interface FilterFieldContext {
+    filter: SimpleFilter;
+    operatorMeta: OperatorMeta;
+    shouldShowDateRange: boolean;
+    shouldShowComboBox: boolean;
+}
+/** State + handlers for the date-range selector (inDateRange on time fields). */
+export interface DateRangeGroup {
+    rangeType: DateRangeType;
+    numberValue: number;
+    label: string;
+    isOpen: boolean;
+    onToggle: (open: boolean) => void;
+    onRangeTypeChange: (rangeType: DateRangeType) => void;
+    onNumberValueChange: (value: number) => void;
+    onCustomStartDate: (e: ChangeEvent<HTMLInputElement>) => void;
+    onCustomEndDate: (e: ChangeEvent<HTMLInputElement>) => void;
+    /** Close sibling dropdowns when this one opens. */
+    onOpen: () => void;
+}
+/** Async distinct-value combo-box state + handlers (equals/in on dimensions). */
+export interface ComboBoxGroup {
+    isOpen: boolean;
+    options: unknown[];
+    loading: boolean;
+    error: unknown;
+    searchText: string;
+    highlightedIndex: number;
+    listRef: RefObject<HTMLDivElement>;
+    onSearchTextChange: (text: string) => void;
+    onHighlightedIndexChange: (index: number) => void;
+    onSelect: (value: unknown, event?: MouseEvent | {
+        shiftKey: boolean;
+    }) => void;
+    onRemove: (value: unknown) => void;
+    onKeyDown: (e: KeyboardEvent) => void;
+    /** Open the combo-box, closing sibling dropdowns. */
+    onOpen: () => void;
+}
+/** Handlers for the plain between/date/number/text inputs. */
+export interface SimpleInputHandlers {
+    onBetweenStart: (e: ChangeEvent<HTMLInputElement>) => void;
+    onBetweenEnd: (e: ChangeEvent<HTMLInputElement>) => void;
+    onDate: (e: ChangeEvent<HTMLInputElement>) => void;
+    onDirect: (e: ChangeEvent<HTMLInputElement>) => void;
+}
+export interface FilterValueInputProps {
+    field: FilterFieldContext;
+    dateRange: DateRangeGroup;
+    combo: ComboBoxGroup;
+    inputs: SimpleInputHandlers;
+}
+export default function FilterValueInput({ field, dateRange, combo, inputs }: FilterValueInputProps): import("react").JSX.Element;
+export {};

package/dist/client/components/AnalysisBuilder/FlowDepthControls.d.ts

@@ -0,0 +1,10 @@
+import { ChartType } from '../../types';
+interface FlowDepthControlsProps {
+    chartType: ChartType;
+    stepsBefore: number;
+    stepsAfter: number;
+    onStepsBeforeChange: (count: number) => void;
+    onStepsAfterChange: (count: number) => void;
+}
+declare const FlowDepthControls: import('react').NamedExoticComponent<FlowDepthControlsProps>;
+export default FlowDepthControls;

package/dist/client/components/AnalysisBuilder/FlowVisualizationPicker.d.ts

@@ -0,0 +1,7 @@
+import { ChartType } from '../../types';
+interface FlowVisualizationPickerProps {
+    chartType: ChartType;
+    onChartTypeChange: (type: ChartType) => void;
+}
+declare const FlowVisualizationPicker: import('react').NamedExoticComponent<FlowVisualizationPickerProps>;
+export default FlowVisualizationPicker;

package/dist/client/components/AnalysisBuilder/LegacyBooleanOptions.d.ts

@@ -0,0 +1,8 @@
+import { ChartDisplayConfig } from '../../types';
+interface LegacyBooleanOptionsProps {
+    displayOptions?: string[];
+    displayConfig: ChartDisplayConfig;
+    onDisplayConfigChange: (config: ChartDisplayConfig) => void;
+}
+declare const LegacyBooleanOptions: import('react').NamedExoticComponent<LegacyBooleanOptionsProps>;
+export default LegacyBooleanOptions;

package/dist/client/components/AnalysisBuilder/LimitSection.d.ts

@@ -10,5 +10,5 @@ interface LimitSectionProps {
     /** Callback when limit changes */
     onLimitChange: (limit: number | undefined) => void;
 }
-export default function LimitSection({ limit, onLimitChange }: LimitSectionProps): import("react/jsx-runtime").JSX.Element;
+export default function LimitSection({ limit, onLimitChange }: LimitSectionProps): import("react").JSX.Element;
 export {};

package/dist/client/components/AnalysisBuilder/MetricRow.d.ts

@@ -0,0 +1,23 @@
+import { DragEvent } from 'react';
+import { MetaField } from '../../shared/types';
+import { MetricItem } from './types';
+interface MetricRowProps {
+    metric: MetricItem;
+    fieldMeta: MetaField | null;
+    sortDirection: 'asc' | 'desc' | null;
+    sortPriority: number | undefined;
+    index: number;
+    transform: string;
+    showGapBefore: boolean;
+    isAnyDragging: boolean;
+    isDragging: boolean;
+    onRemove: (id: string) => void;
+    onOrderChange?: (field: string, direction: 'asc' | 'desc' | null) => void;
+    onReorder?: (fromIndex: number, toIndex: number) => void;
+    onItemDragOver: (e: DragEvent, index: number) => void;
+    onItemDrop: (e: DragEvent) => void;
+    onDragStart: (e: DragEvent, index: number) => void;
+    onDragEnd: () => void;
+}
+declare const MetricRow: import('react').NamedExoticComponent<MetricRowProps>;
+export default MetricRow;

package/dist/client/components/AnalysisBuilder/SectionHeading.d.ts

@@ -8,5 +8,5 @@ interface SectionHeadingProps {
  * Consistent section heading style for Analysis Builder panels.
  * Change the styles here to update all section headings at once.
  */
-export default function SectionHeading({ children, className }: SectionHeadingProps): import("react/jsx-runtime").JSX.Element;
+export default function SectionHeading({ children, className }: SectionHeadingProps): import("react").JSX.Element;
 export {};

package/dist/client/components/AnalysisBuilder/SortToggleButton.d.ts

@@ -0,0 +1,13 @@
+/**
+ * SortToggleButton Component
+ *
+ * Shared sort-direction toggle used by MetricItemCard and BreakdownItemCard.
+ * Renders the direction icon, optional sort-priority badge, and tooltip.
+ */
+interface SortToggleButtonProps {
+    sortDirection?: 'asc' | 'desc' | null;
+    sortPriority?: number;
+    onToggleSort: () => void;
+}
+declare const SortToggleButton: import('react').NamedExoticComponent<SortToggleButtonProps>;
+export default SortToggleButton;

package/dist/client/components/AnalysisBuilder/StringArrayInput.d.ts

@@ -0,0 +1,17 @@
+/**
+ * StringArrayInput Component
+ *
+ * A textarea that edits an array of strings. Uses local state while editing and
+ * only commits to the parent on blur. Extracted from DisplayOptionControl so the
+ * structured-option renderers stay presentational. Behaviour is identical to the
+ * previous inline implementation.
+ */
+interface StringArrayInputProps {
+    label: string;
+    value: string[];
+    onChange: (value: string[]) => void;
+    placeholder?: string;
+    description?: string;
+}
+export default function StringArrayInput({ label, value, onChange, placeholder, description, }: StringArrayInputProps): import("react").JSX.Element;
+export {};

package/dist/client/components/AnalysisBuilder/filterConfigModalUtils.d.ts

@@ -0,0 +1,30 @@
+/**
+ * filterConfigModalUtils
+ *
+ * Pure helpers extracted from FilterConfigModal to keep the component's effects
+ * and render flat. Behaviour is identical to the previous inline logic.
+ *
+ * `deriveRangeFromDateRange` lives in the shared `dateRangeUtils` module and is
+ * re-exported here to keep existing import paths stable.
+ */
+export type { DerivedRange } from '../shared/dateRangeUtils';
+export { deriveRangeFromDateRange } from '../shared/dateRangeUtils';
+/** Action the value-dropdown keyboard handler should apply, decided purely. */
+export type ValueKeyAction = {
+    type: 'none';
+} | {
+    type: 'highlight';
+    index: number;
+} | {
+    type: 'select';
+    index: number;
+} | {
+    type: 'close';
+};
+/**
+ * Pure keyboard-navigation logic for the filter value dropdown. Given the key
+ * and current state, returns the action to apply (no side effects), so the
+ * branchy decision can be unit-tested and the React handler stays a thin
+ * dispatcher.
+ */
+export declare function resolveValueKeyboardAction(key: string, isOpen: boolean, length: number, highlightedIndex: number): ValueKeyAction;

package/dist/client/components/AnalysisBuilder/hooks/useAnalysisBuilderImperativeHandle.d.ts

@@ -0,0 +1,13 @@
+import { Ref } from 'react';
+import { StoreApi } from 'zustand';
+import { AnalysisBuilderRef } from '../types';
+import { AnalysisBuilderStore } from '../../../stores/analysisBuilderStore';
+interface ImperativeHandleDeps {
+    getQueryConfig: AnalysisBuilderRef['getQueryConfig'];
+    getChartConfig: AnalysisBuilderRef['getChartConfig'];
+    getAnalysisType: AnalysisBuilderRef['getAnalysisType'];
+    clearQuery: AnalysisBuilderRef['clearQuery'];
+    storeApi: StoreApi<AnalysisBuilderStore>;
+}
+export declare function useAnalysisBuilderImperativeHandle(ref: Ref<AnalysisBuilderRef>, deps: ImperativeHandleDeps): void;
+export {};

package/dist/client/components/AnalysisBuilder/hooks/useDragReorder.d.ts

@@ -0,0 +1,25 @@
+import { DragEvent } from 'react';
+/**
+ * Calculate the vertical transform for an item while a drag is in progress.
+ * Pure helper extracted to keep the hook body flat.
+ */
+export declare function computeItemTransform(itemIndex: number, draggedIndex: number | null, dropTargetIndex: number | null): string;
+export interface DragReorderApi {
+    draggedIndex: number | null;
+    dropTargetIndex: number | null;
+    handleDragStart: (e: DragEvent, index: number) => void;
+    handleDragEnd: () => void;
+    handleItemDragOver: (e: DragEvent, itemIndex: number) => void;
+    handleItemDrop: (e: DragEvent) => void;
+    handleSectionDragLeave: (e: DragEvent) => void;
+    handleEndZoneDragOver: (e: DragEvent) => void;
+    getItemTransform: (itemIndex: number) => string;
+    shouldShowGapIndicator: (itemIndex: number) => boolean;
+}
+/**
+ * @param dragType  Label written into the drag dataTransfer payload.
+ * @param getField  Resolves the field name for a given index (for the payload).
+ * @param itemCount Current number of items (used for end-of-list drop zone).
+ * @param onReorder Optional reorder callback (fromIndex, toIndex).
+ */
+export declare function useDragReorder(dragType: string, getField: (index: number) => string, itemCount: number, onReorder?: (fromIndex: number, toIndex: number) => void): DragReorderApi;

package/dist/client/components/AnalysisBuilder/hooks/useFieldSearchKeyboard.d.ts

@@ -0,0 +1,11 @@
+import { KeyboardEvent, RefObject } from 'react';
+import { FieldOption } from '../types';
+export interface FieldSearchKeyboardApi {
+    focusedField: FieldOption | null;
+    setFocusedField: (field: FieldOption | null) => void;
+    focusedIndex: number;
+    setFocusedIndex: (index: number) => void;
+    resultsContainerRef: RefObject<HTMLDivElement>;
+    handleKeyDown: (e: KeyboardEvent) => void;
+}
+export declare function useFieldSearchKeyboard(flatFieldsList: FieldOption[], onSelectField: (field: FieldOption, fieldIndex: number, shiftKey: boolean) => void, onClose: () => void): FieldSearchKeyboardApi;

package/dist/client/components/AnalysisBuilder/utils/axisConfigUtils.d.ts

@@ -0,0 +1,23 @@
+import { ChartAxisConfig } from '../../../types';
+interface DropZoneShape {
+    key: string;
+    maxItems?: number;
+    enableDualAxis?: boolean;
+}
+/**
+ * Compute the new config after dropping `field` onto `toAxis` (optionally moving
+ * it from `fromAxis`). Applies the default left/right yAxisAssignment for dual-axis
+ * drop zones.
+ */
+export declare function applyAxisDrop(chartConfig: ChartAxisConfig, field: string, fromAxis: string, toAxis: string, dropZoneConfig: DropZoneShape | undefined): ChartAxisConfig;
+/**
+ * Compute the new config after removing `field` from `fromAxis`, cleaning up any
+ * yAxisAssignment entry.
+ */
+export declare function applyAxisRemove(chartConfig: ChartAxisConfig, field: string, fromAxis: string): ChartAxisConfig;
+/**
+ * Compute the new config after reordering items within `axisKey`. Returns null
+ * when no reorder is applicable (non-array, single item, or no-op move).
+ */
+export declare function applyAxisReorder(chartConfig: ChartAxisConfig, fromIndex: number, toIndex: number, axisKey: string): ChartAxisConfig | null;
+export {};

package/dist/client/components/AnalysisBuilder/utils/executionPlanMarkdown.d.ts

@@ -0,0 +1,8 @@
+import { CubeQuery } from '../../../types';
+import { QueryAnalysis } from '../../../shared/types';
+/**
+ * Generate markdown representation of query execution plan.
+ */
+export declare function generateExecutionPlanMarkdown(analysis: QueryAnalysis, query: CubeQuery | null, sql?: {
+    sql: string;
+} | null): string;

package/dist/client/components/AnalysisBuilder/utils/fieldUtils.d.ts

@@ -26,6 +26,11 @@ export declare function getFieldTitle(fieldName: string, schema: MetaResponse |
 export declare function getFieldType(field: MetaField): FieldType;
 /**
  * Convert schema to flat list of field options
+ *
+ * - 'metrics': measures only
+ * - 'breakdown' / 'dimensionFilter': dimensions only ('dimensionFilter' is used
+ *   for funnel step filters where measures don't work)
+ * - 'filter': both measures and dimensions
  */
 export declare function schemaToFieldOptions(schema: MetaResponse | null, mode: 'metrics' | 'breakdown' | 'filter' | 'dimensionFilter'): FieldOption[];
 /**