drizzle-cube 0.6.0 → 0.6.2

package/dist/cjs/client/components/shared/filterValueSelector/FilterValueInputs.d.ts

@@ -0,0 +1,55 @@
+import { default as React } from 'react';
+type ChangeHandler = (e: React.ChangeEvent<HTMLInputElement>) => void;
+export declare function NoValueInput(): React.JSX.Element;
+interface DateRangeInputProps {
+    values: any[];
+    onStartChange: ChangeHandler;
+    onEndChange: ChangeHandler;
+}
+export declare function DateRangeInput({ values, onStartChange, onEndChange }: DateRangeInputProps): React.JSX.Element;
+interface BetweenInputProps {
+    values: any[];
+    onStartChange: ChangeHandler;
+    onEndChange: ChangeHandler;
+}
+export declare function BetweenInput({ values, onStartChange, onEndChange }: BetweenInputProps): React.JSX.Element;
+interface SingleDateInputProps {
+    values: any[];
+    onChange: ChangeHandler;
+}
+export declare function SingleDateInput({ values, onChange }: SingleDateInputProps): React.JSX.Element;
+interface NumberInputProps {
+    values: any[];
+    onChange: ChangeHandler;
+}
+export declare function NumberInput({ values, onChange }: NumberInputProps): React.JSX.Element;
+interface TextInputProps {
+    values: any[];
+    onChange: ChangeHandler;
+    valueType: string;
+}
+export declare function TextInput({ values, onChange, valueType }: TextInputProps): React.JSX.Element;
+interface MultiDateInputProps {
+    values: any[];
+    onValuesChange: (values: any[]) => void;
+    onValueRemove: (value: any) => void;
+}
+export declare function MultiDateInput({ values, onValuesChange, onValueRemove }: MultiDateInputProps): React.JSX.Element;
+interface ComboBoxInputProps {
+    dropdownRef: React.RefObject<HTMLDivElement>;
+    supportsMultipleValues: boolean;
+    values: any[];
+    isOpen: boolean;
+    searchText: string;
+    hasLoadedInitial: boolean;
+    valuesLoading: boolean;
+    valuesError: any;
+    distinctValues: any[];
+    onValuesChange: (values: any[]) => void;
+    onValueRemove: (value: any) => void;
+    onValueSelect: (value: any) => void;
+    onToggle: () => void;
+    onSearchChange: ChangeHandler;
+}
+export declare function ComboBoxInput({ dropdownRef, supportsMultipleValues, values, isOpen, searchText, hasLoadedInitial, valuesLoading, valuesError, distinctValues, onValuesChange, onValueRemove, onValueSelect, onToggle, onSearchChange }: ComboBoxInputProps): React.JSX.Element;
+export {};

package/dist/cjs/client/components/shared/filterValueSelector/useFilterValueSelectorState.d.ts

@@ -0,0 +1,25 @@
+import { ChangeEvent } from 'react';
+import { FilterValueSelectorProps } from '../types.js';
+declare const COMBO_OPERATORS: string[];
+export declare function useFilterValueSelectorState({ fieldName, operator, values, onValuesChange, schema }: FilterValueSelectorProps): {
+    operatorMeta: import('../../../shared/types.js').FilterOperatorMeta;
+    isOpen: boolean;
+    searchText: string;
+    hasLoadedInitial: boolean;
+    dropdownRef: import('react').RefObject<HTMLDivElement>;
+    isTimeDimension: boolean;
+    shouldShowComboBox: boolean;
+    distinctValues: any[];
+    valuesLoading: boolean;
+    valuesError: string | null;
+    handleDropdownToggle: () => void;
+    handleSearchChange: (e: ChangeEvent<HTMLInputElement>) => void;
+    handleValueSelect: (value: any) => void;
+    handleValueRemove: (valueToRemove: any) => void;
+    handleDirectInput: (e: ChangeEvent<HTMLInputElement>) => void;
+    handleDateInput: (e: ChangeEvent<HTMLInputElement>) => void;
+    handleDateRangeEndInput: (e: ChangeEvent<HTMLInputElement>) => void;
+    handleBetweenStartInput: (e: ChangeEvent<HTMLInputElement>) => void;
+    handleBetweenEndInput: (e: ChangeEvent<HTMLInputElement>) => void;
+};
+export { COMBO_OPERATORS };

package/dist/cjs/client/components/shared/queryFieldUtils.d.ts

@@ -0,0 +1,21 @@
+import { CubeQuery, SimpleFilter } from '../../types.js';
+import { MetaResponse } from './types.js';
+/** Collect the set of field names currently selected by a query. */
+export declare function getSelectedFieldNames(query: CubeQuery): Set<string>;
+/**
+ * Validate operator compatibility / value requirements for a filter.
+ * Assumes the filter member is already known to exist.
+ */
+export declare function validateFilterOperator(filter: SimpleFilter, schema: MetaResponse): string[];
+/**
+ * Get sort direction for a field from the order object
+ */
+export declare function getSortDirection(fieldName: string, order: Record<string, 'asc' | 'desc'> | undefined): 'asc' | 'desc' | null;
+/**
+ * Get tooltip text for sort button based on current direction
+ */
+export declare function getSortTooltip(direction: 'asc' | 'desc' | null): string;
+/**
+ * Get next sort direction in the cycle: null -> asc -> desc -> null
+ */
+export declare function getNextSortDirection(current: 'asc' | 'desc' | null): 'asc' | 'desc' | null;

package/dist/cjs/client/components/shared/types.d.ts

@@ -0,0 +1,60 @@
+import { CubeQuery, FilterOperator, Filter, SimpleFilter, GroupFilter } from '../../types.js';
+export type { MetaField, MetaResponse, DateRangeType } from '../../shared/types.js';
+export { FILTER_OPERATORS, DATE_RANGE_OPTIONS, TIME_GRANULARITIES } from '../../shared/types.js';
+export interface FilterBuilderProps {
+    filters: Filter[];
+    schema: import('../../shared/types.js').MetaResponse | null;
+    query: CubeQuery;
+    onFiltersChange: (filters: Filter[]) => void;
+    hideFieldSelector?: boolean;
+}
+export interface FilterItemProps {
+    filter: SimpleFilter;
+    index: number;
+    onFilterChange: (index: number, filter: SimpleFilter) => void;
+    onFilterRemove: (index: number) => void;
+    schema: import('../../shared/types.js').MetaResponse | null;
+    query: CubeQuery;
+    hideFieldSelector?: boolean;
+    hideOperatorSelector?: boolean;
+    hideRemoveButton?: boolean;
+}
+export interface FilterGroupProps {
+    group: GroupFilter;
+    index: number;
+    onGroupChange: (index: number, group: GroupFilter) => void;
+    onGroupChangeWithUnwrap?: (index: number, group: GroupFilter) => void;
+    onGroupRemove: (index: number) => void;
+    schema: import('../../shared/types.js').MetaResponse | null;
+    query: CubeQuery;
+    depth: number;
+}
+export interface FilterValueSelectorProps {
+    fieldName: string;
+    operator: FilterOperator;
+    values: any[];
+    onValuesChange: (values: any[]) => void;
+    schema: import('../../shared/types.js').MetaResponse | null;
+}
+export interface DateRangeFilter {
+    id: string;
+    timeDimension: string;
+    rangeType: import('../../shared/types.js').DateRangeType;
+    startDate?: string;
+    endDate?: string;
+}
+export interface DateRangeSelectorProps {
+    timeDimensions: string[];
+    onDateRangeChange: (timeDimension: string, dateRange: string | string[]) => void;
+    onDateRangeRemove: (timeDimension: string) => void;
+    currentDateRanges: Record<string, string | string[]>;
+}
+export interface DateRangeFilterProps {
+    timeDimensions: Array<{
+        dimension: string;
+        granularity?: string;
+        dateRange?: string | string[];
+    }>;
+    onDateRangeChange: (timeDimension: string, dateRange: string | string[]) => void;
+    onDateRangeRemove: (timeDimension: string) => void;
+}

package/dist/cjs/client/components/shared/utils.d.ts

@@ -0,0 +1,71 @@
+import { CubeQuery, Filter, SimpleFilter } from '../../types.js';
+import { MetaField, MetaResponse } from './types.js';
+export { getSortDirection, getSortTooltip, getNextSortDirection, } from './queryFieldUtils.js';
+export type { DatePreset } from './dateRangeUtils.js';
+export { DATE_PRESETS, XTD_OPTIONS, calculateDateRange, formatDateRangeDisplay, detectPresetFromDateRange, } from './dateRangeUtils.js';
+export { formatFilterValueDisplay } from './filterDisplayUtils.js';
+export { isSimpleFilter, isGroupFilter, isAndFilter, isOrFilter, flattenFilters, countFilters, createSimpleFilter, createAndFilter, createOrFilter, cleanupFilters, transformFiltersForServer, transformFiltersFromServer, hasQueryContent, cleanQuery, cleanQueryForServer, transformQueryForUI, getCubeNameFromField, getFieldType, getFieldTitle, getAvailableOperators, getAllFilterableFields, convertDateRangeTypeToValue, requiresNumberInput, formatDateForCube, } from '../../shared/utils.js';
+/**
+ * Check if a field is selected in the current query
+ */
+export declare function isFieldSelected(fieldName: string, fieldType: 'measures' | 'dimensions' | 'timeDimensions', query: CubeQuery): boolean;
+/**
+ * Get all time dimension fields from schema
+ */
+export declare function getTimeDimensionFields(schema: MetaResponse): MetaField[];
+/**
+ * Get all non-time dimension fields from schema
+ */
+export declare function getRegularDimensionFields(schema: MetaResponse): MetaField[];
+/**
+ * Get all measure fields from schema
+ */
+export declare function getMeasureFields(schema: MetaResponse): MetaField[];
+/**
+ * Get count of selected fields across all types
+ */
+export declare function getSelectedFieldsCount(query: CubeQuery): number;
+/**
+ * Group fields by cube name
+ */
+export declare function groupFieldsByCube(fields: MetaField[]): Record<string, MetaField[]>;
+/**
+ * Create an empty query object
+ */
+export declare function createEmptyQuery(): CubeQuery;
+/**
+ * Get all filterable fields from schema (measures, dimensions, and time dimensions)
+ * Returns ALL fields if no query provided, or only query fields if query provided
+ */
+export declare function getFilterableFields(schema: MetaResponse, query?: CubeQuery): MetaField[];
+/**
+ * Get organized filter field options with query fields prioritized at top
+ */
+export declare function getOrganizedFilterFields(schema: MetaResponse, query?: CubeQuery): {
+    queryFields: MetaField[];
+    allFields: MetaField[];
+};
+/**
+ * Validate a filter
+ */
+export declare function validateFilter(filter: SimpleFilter, schema: MetaResponse): {
+    isValid: boolean;
+    errors: string[];
+};
+/**
+ * Clean up filters by removing any that reference fields not in the current query (legacy)
+ * Only used for backward compatibility - filters on non-query fields are now supported
+ */
+export declare function cleanupFiltersLegacy(filters: Filter[], query: CubeQuery): Filter[];
+/**
+ * Get the time dimensions that have date ranges applied
+ */
+export declare function getTimeDimensionsWithDateRanges(query: CubeQuery): Record<string, string | string[]>;
+/**
+ * Check if a query has any time dimensions
+ */
+export declare function hasTimeDimensions(query: CubeQuery): boolean;
+/**
+ * Clean up order object by removing fields that are no longer in the query
+ */
+export declare function cleanupOrder(order: Record<string, 'asc' | 'desc'> | undefined, query: CubeQuery): Record<string, 'asc' | 'desc'> | undefined;

package/dist/cjs/client/components.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Drizzle Cube UI Components
+ *
+ * UI components without charts - for applications that need dashboards,
+ * query builders, and layout components but provide their own charts.
+ */
+export { default as AnalyticsPortlet } from './components/AnalyticsPortlet.js';
+export { default as AnalyticsDashboard } from './components/AnalyticsDashboard.js';
+export { default as DashboardGrid } from './components/DashboardGrid.js';
+export { DashboardProvider, DashboardToolbar, DashboardFilterBar, DashboardGridSurface, DashboardModals, useDashboardContext, } from './components/dashboard/index.js';
+export type { DashboardContextValue, DashboardProviderProps } from './components/dashboard/index.js';
+export { default as PortletContainer } from './components/PortletContainer.js';
+export { default as DashboardEditModal } from './components/DashboardEditModal.js';
+export { default as Modal } from './components/Modal.js';
+export { default as AnalysisDisplayConfigPanel } from './components/AnalysisBuilder/AnalysisDisplayConfigPanel.js';
+export { createDashboardLayout, generateResponsiveLayouts, generatePortletId, findNextPosition, validateCubeQuery, createSamplePortlet } from './utils/index.js';
+export type { PortletConfig, DashboardConfig } from './types.js';

package/dist/cjs/client/hooks/agentChatStream.d.ts

@@ -0,0 +1,39 @@
+import { PortletBlock, MarkdownBlock } from '../stores/notebookStore.js';
+/** Clean up raw API errors into user-friendly messages */
+export declare function formatUserFacingError(message: string): string;
+export interface AgentSSEEvent {
+    type: 'text_delta' | 'tool_use_start' | 'tool_use_result' | 'add_portlet' | 'add_markdown' | 'dashboard_saved' | 'turn_complete' | 'done' | 'error';
+    data: any;
+}
+/** Subset of the hook options that handleAgentEvent dispatches to. */
+export interface AgentEventCallbacks {
+    onAddPortlet: (data: PortletBlock) => void;
+    onAddMarkdown: (data: MarkdownBlock) => void;
+    onDashboardSaved?: (data: {
+        title: string;
+        description?: string;
+        dashboardConfig: any;
+    }) => void;
+    onTextDelta: (text: string) => void;
+    onToolStart: (id: string, name: string, input?: unknown) => void;
+    onToolResult: (id: string, name: string, result?: unknown, isError?: boolean) => void;
+    onDone: (sessionId: string, traceId?: string) => void;
+    onTurnComplete?: () => void;
+    onError: (message: string) => void;
+}
+/** Dispatch a single decoded SSE event to the relevant callback. */
+export declare function handleAgentEvent(event: AgentSSEEvent, cb: AgentEventCallbacks): void;
+/**
+ * Parse one block of SSE text (possibly multi-line) and dispatch each
+ * `data: ` line. Malformed JSON lines are skipped silently.
+ */
+export declare function dispatchSSEBlock(block: string, dispatch: (event: AgentSSEEvent) => void): void;
+export interface AgentRequestHeaderOptions {
+    baseHeaders?: Record<string, string>;
+    agentApiKey?: string;
+    agentProvider?: string;
+    agentModel?: string;
+    agentProviderEndpoint?: string;
+}
+/** Build request headers matching CubeClient's auth pattern plus agent overrides. */
+export declare function buildAgentHeaders(opts: AgentRequestHeaderOptions): Record<string, string>;

package/dist/cjs/client/hooks/analysisQueryExecutionModes.d.ts

@@ -0,0 +1,133 @@
+/**
+ * Pure mode-selection helpers for useAnalysisQueryExecution.
+ *
+ * The hook coordinates five execution modes (retention, flow, funnel, multi,
+ * single). Almost every derived value is "pick the field from whichever mode is
+ * active". These helpers collapse the repeated 5-way ternary chains into a
+ * single normalized per-mode descriptor plus a selector, without changing any
+ * behaviour: the selected values are byte-for-byte equivalent to the original
+ * nested ternaries.
+ */
+/** The active execution mode, in priority order (retention > flow > funnel > multi > single). */
+export type ActiveMode = 'retention' | 'flow' | 'funnel' | 'multi' | 'single';
+export interface ModeFlags {
+    isRetentionMode: boolean | undefined;
+    isFlowMode: boolean | undefined;
+    isFunnelMode: boolean | undefined;
+    isMultiMode: boolean | undefined;
+}
+/**
+ * Resolve the single active mode from the boolean flags, using the same
+ * precedence as the original nested ternaries (retention first, single last).
+ */
+export declare function resolveActiveMode(flags: ModeFlags): ActiveMode;
+/**
+ * A value resolved per-mode. Pass the value each mode contributes; `pickByMode`
+ * returns the one for the active mode. This mirrors the original
+ * `isRetentionMode ? a : isFlowMode ? b : ...` chains exactly. Each field may
+ * have its own type — the return type is the union across all modes.
+ */
+export type PerMode<R extends Record<ActiveMode, unknown>> = R;
+export declare function pickByMode<R extends Record<ActiveMode, unknown>>(mode: ActiveMode, values: R): R[ActiveMode];
+/**
+ * Inputs for deriving the per-mode "debug / server query / chart data" outputs.
+ * Each field is the raw value the corresponding mode hook exposes; the helper
+ * gates it on the matching mode flag (returning null otherwise), exactly as the
+ * original inline `isXMode ? value : null` expressions did.
+ */
+export interface ModeOutputsInput<FunnelExecuted, FunnelServer, FlowServer, FlowChart, RetentionServer, RetentionChart, Debug> {
+    isFunnelMode: boolean | undefined;
+    isFlowMode: boolean;
+    isRetentionMode: boolean;
+    funnelExecutedQueries: FunnelExecuted[] | undefined;
+    funnelServerQuery: FunnelServer;
+    funnelDebugData: Debug;
+    flowServerQuery: FlowServer;
+    flowData: FlowChart;
+    flowDebugData: Debug;
+    retentionServerQuery: RetentionServer;
+    retentionChartData: RetentionChart;
+    retentionDebugData: Debug;
+}
+export interface ModeOutputs<FunnelExecuted, FunnelServer, FlowServer, FlowChart, RetentionServer, RetentionChart, Debug> {
+    funnelExecutedQueries: FunnelExecuted[] | null;
+    funnelServerQuery: FunnelServer | null;
+    funnelDebugData: Debug | null;
+    flowServerQuery: FlowServer | null;
+    flowChartData: FlowChart | null;
+    flowDebugData: Debug | null;
+    retentionServerQuery: RetentionServer | null;
+    retentionChartData: RetentionChart | null;
+    retentionDebugData: Debug | null;
+}
+export declare function deriveModeOutputs<FunnelExecuted, FunnelServer, FlowServer, FlowChart, RetentionServer, RetentionChart, Debug>(input: ModeOutputsInput<FunnelExecuted, FunnelServer, FlowServer, FlowChart, RetentionServer, RetentionChart, Debug>): ModeOutputs<FunnelExecuted, FunnelServer, FlowServer, FlowChart, RetentionServer, RetentionChart, Debug>;
+/** Inputs for computing the per-query-hook `skip` flags. */
+export interface SkipFlagsInput {
+    isValidQuery: boolean;
+    isSingleMode: boolean;
+    isMultiMode: boolean;
+    isFunnelMode: boolean | undefined;
+    isFlowMode: boolean;
+    isRetentionMode: boolean;
+    hasMultiQueryConfig: boolean;
+    hasFunnelConfig: boolean;
+    hasServerFunnelQuery: boolean;
+    hasServerFlowQuery: boolean;
+    hasServerRetentionQuery: boolean;
+}
+export interface SkipFlags {
+    single: boolean;
+    multi: boolean;
+    funnel: boolean;
+    flow: boolean;
+    retention: boolean;
+    dryRun: boolean;
+}
+/**
+ * Compute the `skip` flag for each query hook. Extracted from the inline
+ * boolean expressions so the hook body stays flat. Logic is unchanged.
+ */
+export declare function computeSkipFlags(input: SkipFlagsInput): SkipFlags;
+/** Inputs for the unified execution-status computation. */
+export interface ExecutionStatusInput {
+    hasResults: unknown;
+    initialData: unknown[] | undefined;
+    isValidQuery: boolean;
+    isLoading: boolean;
+    isFetching: boolean;
+    error: unknown;
+}
+/**
+ * Compute the unified execution status. Extracted verbatim from the original
+ * useMemo body to keep the hook flat; the `hasResults` per-mode pick is done by
+ * the caller and passed in.
+ */
+export declare function computeExecutionStatus(input: ExecutionStatusInput): 'idle' | 'loading' | 'refreshing' | 'error' | 'success';
+/** Inputs for computing the unified execution results array. */
+export interface ExecutionResultsInput {
+    isRetentionMode: boolean;
+    isFlowMode: boolean;
+    isFunnelMode: boolean | undefined;
+    isMultiMode: boolean;
+    retentionChartData: {
+        rows: Array<{
+            period: number;
+            retentionRate: number;
+            retainedUsers: number;
+            cohortSize: number;
+            breakdownValue?: string | null;
+        }>;
+    } | null | undefined;
+    flowData: unknown;
+    funnelChartData: unknown[] | null | undefined;
+    multiData: unknown[] | null | undefined;
+    singleRawData: unknown[] | null | undefined;
+    initialData: unknown[] | undefined;
+}
+/**
+ * Compute the unified execution results array. This is a priority cascade
+ * (not a strict per-mode pick): when the active mode has no data yet, it falls
+ * through to lower-priority sources, ending at initialData. Extracted verbatim
+ * from the original useMemo body to preserve behaviour.
+ */
+export declare function computeExecutionResults(input: ExecutionResultsInput): unknown[] | null;

package/dist/cjs/client/hooks/dashboard/layoutUtils.d.ts

@@ -0,0 +1,7 @@
+import { DashboardGridSettings, PortletConfig, RowLayout, RowLayoutColumn } from '../../types.js';
+export declare const createRowId: () => string;
+export declare const equalizeRowColumns: (portletIds: string[], gridSettings: DashboardGridSettings) => RowLayoutColumn[];
+export declare const adjustRowWidths: (columns: RowLayoutColumn[], gridSettings: DashboardGridSettings) => RowLayoutColumn[];
+export declare const convertPortletsToRows: (portlets: PortletConfig[], gridSettings: DashboardGridSettings) => RowLayout[];
+export declare const normalizeRows: (rows: RowLayout[], portlets: PortletConfig[], gridSettings: DashboardGridSettings) => RowLayout[];
+export declare const convertRowsToPortlets: (rows: RowLayout[], portlets: PortletConfig[]) => PortletConfig[];

package/dist/cjs/client/hooks/dashboard/useDashboardController.d.ts

@@ -0,0 +1,53 @@
+import { MutableRefObject, RefObject } from 'react';
+import { StoreApi } from 'zustand';
+import { DashboardConfig, DashboardFilterMapping, DashboardGridSettings, DashboardLayoutMode, PortletConfig, RowLayout, ThumbnailFeatureConfig } from '../../types.js';
+import { DashboardStore, DashboardStoreActions } from '../../stores/dashboardStore.js';
+interface UseDashboardControllerOptions {
+    allowedModes: DashboardLayoutMode[];
+    canChangeLayoutMode: boolean;
+    isResponsiveEditable: boolean;
+    layoutMode: DashboardLayoutMode;
+    resolvedRows: RowLayout[];
+    gridSettings: DashboardGridSettings;
+    thumbnailConfig?: ThumbnailFeatureConfig;
+    dashboardRef?: RefObject<HTMLElement | null>;
+    storeApi: StoreApi<DashboardStore>;
+    storeActions: Pick<DashboardStoreActions, 'setEditMode' | 'exitFilterSelectionMode' | 'openPortletModal' | 'closePortletModal' | 'openTextModal' | 'closeTextModal' | 'openFilterConfigModal' | 'closeFilterConfigModal' | 'openDeleteConfirm' | 'closeDeleteConfirm' | 'setThumbnailDirty'>;
+    configRef: MutableRefObject<DashboardConfig>;
+    onConfigChangeRef: MutableRefObject<((config: DashboardConfig) => void) | undefined>;
+    onSaveRef: MutableRefObject<((config: DashboardConfig) => Promise<void> | void) | undefined>;
+    onSaveThumbnailRef: MutableRefObject<((thumbnailData: string) => Promise<string | void>) | undefined>;
+    updateRowLayout: (rows: RowLayout[], save?: boolean, portletsOverride?: PortletConfig[]) => Promise<void>;
+    portletComponentRefs?: MutableRefObject<Record<string, {
+        refresh: (options?: {
+            bustCache?: boolean;
+        }) => void;
+    } | null>>;
+    onPortletRefresh?: (portletId: string, options?: {
+        bustCache?: boolean;
+    }) => void;
+}
+export declare function useDashboardController({ allowedModes, canChangeLayoutMode, isResponsiveEditable, layoutMode, resolvedRows, gridSettings, thumbnailConfig, dashboardRef, storeApi, storeActions, configRef, onConfigChangeRef, onSaveRef, onSaveThumbnailRef, updateRowLayout, portletComponentRefs, onPortletRefresh, }: UseDashboardControllerOptions): {
+    enterEditMode: () => void;
+    exitEditMode: () => void;
+    toggleEditMode: () => void;
+    selectFilter: (filterId: string | null) => void;
+    openAddPortlet: () => void;
+    openEditPortlet: (portlet: PortletConfig) => void;
+    openAddText: () => void;
+    openEditText: (portlet: PortletConfig) => void;
+    openFilterConfig: (portlet: PortletConfig) => void;
+    handleLayoutModeChange: (mode: DashboardLayoutMode) => Promise<void>;
+    savePortlet: (portletData: PortletConfig | Omit<PortletConfig, "id" | "x" | "y">) => Promise<string | null>;
+    deletePortlet: (portletId: string) => Promise<void>;
+    confirmDelete: () => Promise<void>;
+    duplicatePortlet: (portletId: string) => Promise<string | undefined>;
+    refreshPortlet: (portletId: string, options?: {
+        bustCache?: boolean;
+    }) => void;
+    toggleFilterForPortlet: (portletId: string, filterId: string) => Promise<void>;
+    selectAllForFilter: (filterId: string) => Promise<void>;
+    saveFilterConfig: (mapping: DashboardFilterMapping) => Promise<void>;
+    handlePaletteChange: (paletteName: string) => Promise<void>;
+};
+export {};

package/dist/cjs/client/hooks/dashboard/useGridLayoutEngine.d.ts

@@ -0,0 +1,10 @@
+import { LayoutItem } from 'react-grid-layout';
+import { StoreApi } from 'zustand';
+import { DashboardStore } from '../../stores/dashboardStore.js';
+interface UseGridLayoutEngineOptions {
+    storeApi: StoreApi<DashboardStore>;
+}
+export declare function useGridLayoutEngine({ storeApi }: UseGridLayoutEngineOptions): {
+    hasLayoutActuallyChanged: (newLayout: LayoutItem[]) => boolean;
+};
+export {};

package/dist/cjs/client/hooks/dashboard/useRowLayoutEngine.d.ts

@@ -0,0 +1,18 @@
+import { MutableRefObject } from 'react';
+import { DashboardConfig, DashboardGridSettings, DashboardLayoutMode, PortletConfig, RowLayout } from '../../types.js';
+interface UseRowLayoutEngineOptions {
+    layoutMode: DashboardLayoutMode;
+    draftRows: RowLayout[] | null;
+    config: DashboardConfig;
+    gridSettings: DashboardGridSettings;
+    configRef: MutableRefObject<DashboardConfig>;
+    onConfigChangeRef: MutableRefObject<((config: DashboardConfig) => void) | undefined>;
+    onSaveRef: MutableRefObject<((config: DashboardConfig) => Promise<void> | void) | undefined>;
+    setDraftRows: (rows: RowLayout[] | null) => void;
+    setThumbnailDirty: (dirty: boolean) => void;
+}
+export declare function useRowLayoutEngine({ layoutMode, draftRows, config, gridSettings, configRef, onConfigChangeRef, onSaveRef, setDraftRows, setThumbnailDirty, }: UseRowLayoutEngineOptions): {
+    resolvedRows: RowLayout[];
+    updateRowLayout: (rows: RowLayout[], save?: boolean, portletsOverride?: PortletConfig[]) => Promise<void>;
+};
+export {};

package/dist/cjs/client/hooks/drillNavigation.d.ts

@@ -0,0 +1,25 @@
+import { DrillOption, DrillPathEntry } from '../types/drill.js';
+import { ChartAxisConfig, CubeQuery } from '../types.js';
+/**
+ * Find an existing drill-path level for the given option and compute the
+ * "navigate back" descriptor (the truncated path + the query/chartConfig to
+ * restore). Returns null when there is no matching existing level.
+ *
+ * Used for both time-granularity drilling (matched by `granularity`) and
+ * hierarchy-dimension drilling (matched by `dimension`).
+ */
+export declare function findNavigateBackToExistingLevel(drillPath: DrillPathEntry[], matches: (entry: DrillPathEntry) => boolean): {
+    newPath: DrillPathEntry[];
+    query: CubeQuery;
+    chartConfig: ChartAxisConfig | null;
+} | null;
+/**
+ * Whether selecting this option means returning all the way to the root via the
+ * original time granularity.
+ */
+export declare function isDrillBackToRootGranularity(option: DrillOption, originalGranularity: string | null): boolean;
+/**
+ * Compute the granularity to remember as the "original" when first drilling via
+ * a time-granularity option. Returns null when nothing should be stored.
+ */
+export declare function computeOriginalGranularity(option: DrillOption, query: CubeQuery): string | null;

package/dist/cjs/client/hooks/queries/index.d.ts

@@ -0,0 +1,20 @@
+/**
+ * TanStack Query Hooks - Barrel Export
+ *
+ * These hooks provide TanStack Query-based data fetching for:
+ * - Cube metadata (useCubeMetaQuery)
+ * - Single cube data loading (useCubeLoadQuery)
+ * - Multi-cube data loading (useMultiCubeLoadQuery)
+ * - Dry-run/debug data (useDryRunQuery, useMultiDryRunQueries)
+ *
+ * All hooks include built-in debouncing, caching, and error handling.
+ */
+export { useCubeMetaQuery, prefetchCubeMeta, CUBE_META_QUERY_KEY, type UseCubeMetaQueryOptions, type UseCubeMetaQueryResult, } from './useCubeMetaQuery.js';
+export { useCubeLoadQuery, useCubeLoadQuery as useCubeQuery, createQueryKey, type UseCubeLoadQueryOptions, type UseCubeLoadQueryResult, } from './useCubeLoadQuery.js';
+export { useMultiCubeLoadQuery, createMultiQueryKey, type UseMultiCubeLoadQueryOptions, type UseMultiCubeLoadQueryResult, } from './useMultiCubeLoadQuery.js';
+export { useDryRunQuery, useMultiDryRunQueries, useDryRunQueries, useFunnelDryRunQuery, useFlowDryRunQuery, useRetentionDryRunQuery, createDryRunQueryKey, type DebugDataEntry, type FunnelDebugDataEntry, type FlowDebugDataEntry, type RetentionDebugDataEntry, type UseDryRunQueryOptions, type UseDryRunQueryResult, type UseMultiDryRunQueriesOptions, type UseMultiDryRunQueriesResult, } from './useDryRunQuery.js';
+export { useFunnelQuery, createFunnelQueryKey, } from './useFunnelQuery.js';
+export { useFlowQuery, createFlowQueryKey, type UseFlowQueryOptions, type UseFlowQueryResult, } from './useFlowQuery.js';
+export { useRetentionQuery, type UseRetentionQueryOptions, type UseRetentionQueryResult, } from './useRetentionQuery.js';
+export { useExplainQuery, createExplainQueryKey, type UseExplainQueryOptions, type UseExplainQueryResult, } from './useExplainQuery.js';
+export { useExplainAI, type UseExplainAIOptions, type UseExplainAIResult, } from './useExplainAI.js';

package/dist/cjs/client/hooks/queries/useCubeLoadQuery.d.ts

@@ -0,0 +1,85 @@
+import { CubeQuery, CubeResultSet } from '../../types.js';
+import { QueryWarning } from '../../shared/types.js';
+/**
+ * Create a stable query key from a CubeQuery
+ * The key includes all query parameters to ensure proper caching
+ */
+export declare function createQueryKey(query: CubeQuery | null): readonly unknown[];
+export interface UseCubeLoadQueryOptions {
+    /**
+     * Whether to skip the query
+     * @default false
+     */
+    skip?: boolean;
+    /**
+     * Debounce delay in milliseconds
+     * @default 300
+     */
+    debounceMs?: number;
+    /**
+     * Whether to reset result set when query changes
+     * @default true
+     */
+    resetResultSetOnChange?: boolean;
+    /**
+     * Stale time in milliseconds
+     * @default 60 * 1000 (1 minute)
+     */
+    staleTime?: number;
+    /**
+     * Whether to keep previous data while loading new data
+     * @default true
+     */
+    keepPreviousData?: boolean;
+}
+/** Options for the refetch function */
+export interface RefetchOptions {
+    /** If true, bypasses both client and server caches */
+    bustCache?: boolean;
+}
+export interface UseCubeLoadQueryResult {
+    /** The result set from the query */
+    resultSet: CubeResultSet | null;
+    /** Raw data from the result set */
+    rawData: unknown[] | null;
+    /** Whether the query is loading (initial load) */
+    isLoading: boolean;
+    /** Whether the query is fetching (includes refetch) */
+    isFetching: boolean;
+    /** Whether query is debouncing (waiting for user to stop typing) */
+    isDebouncing: boolean;
+    /** Error if the query failed */
+    error: Error | null;
+    /** The debounced query that was executed */
+    debouncedQuery: CubeQuery | null;
+    /** Whether the current query is valid */
+    isValidQuery: boolean;
+    /** Manually refetch the data. Pass { bustCache: true } to bypass caches. */
+    refetch: (options?: RefetchOptions) => void;
+    /** Clear the query cache */
+    clearCache: () => void;
+    /**
+     * Whether the query needs to be refreshed (manual refresh mode only).
+     * True when the current query config differs from the last executed query.
+     */
+    needsRefresh: boolean;
+    /**
+     * Execute the current query (manual refresh mode only).
+     * In auto-refresh mode, this is the same as refetch().
+     */
+    executeQuery: (options?: RefetchOptions) => void;
+    /** Warnings from query planning (e.g., fan-out without dimensions) */
+    warnings: QueryWarning[] | undefined;
+}
+/**
+ * TanStack Query hook for loading cube data with debouncing
+ *
+ * Usage:
+ * ```tsx
+ * const { resultSet, rawData, isLoading, error } = useCubeLoadQuery(query, {
+ *   debounceMs: 300,
+ *   skip: !isReady
+ * })
+ * ```
+ */
+export declare function useCubeLoadQuery(query: CubeQuery | null, options?: UseCubeLoadQueryOptions): UseCubeLoadQueryResult;