drizzle-cube 0.2.5 → 0.2.8

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

@@ -0,0 +1,27 @@
+import { default as React } from 'react';
+import { AxisDropZoneConfig } from '../../charts/chartConfigs';
+interface FieldMeta {
+    title?: string;
+    shortTitle?: string;
+    cubeName: string;
+    type: 'measure' | 'dimension' | 'timeDimension';
+    measureType?: string;
+}
+interface AnalysisAxisDropZoneProps {
+    config: AxisDropZoneConfig;
+    fields: string[];
+    onDrop: (e: React.DragEvent<HTMLDivElement>, toKey: string) => void;
+    onRemove: (field: string, fromKey: string) => void;
+    onDragStart: (e: React.DragEvent<HTMLDivElement>, field: string, fromKey: string, fromIndex?: number) => void;
+    onDragEnd?: (e: React.DragEvent<HTMLDivElement>) => void;
+    onDragOver: (e: React.DragEvent<HTMLDivElement>) => void;
+    onReorder?: (fromIndex: number, toIndex: number, axisKey: string) => void;
+    draggedItem?: {
+        field: string;
+        fromAxis: string;
+        fromIndex?: number;
+    } | null;
+    getFieldMeta?: (field: string) => FieldMeta;
+}
+export default function AnalysisAxisDropZone({ config, fields, onDrop, onRemove, onDragStart, onDragEnd, onDragOver, onReorder, draggedItem, getFieldMeta }: AnalysisAxisDropZoneProps): import("react/jsx-runtime").JSX.Element;
+export {};

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

@@ -0,0 +1,21 @@
+import { ChartType, ChartAxisConfig, ChartDisplayConfig, ColorPalette } from '../../types';
+import { MetricItem, BreakdownItem } from './types';
+import { ChartAvailabilityMap } from '../../shared/chartDefaults';
+import { MetaResponse } from '../../shared/types';
+interface AnalysisChartConfigPanelProps {
+    chartType: ChartType;
+    chartConfig: ChartAxisConfig;
+    displayConfig: ChartDisplayConfig;
+    metrics: MetricItem[];
+    breakdowns: BreakdownItem[];
+    colorPalette?: ColorPalette;
+    /** Schema metadata for resolving field titles */
+    schema?: MetaResponse | null;
+    /** Map of chart type availability for disabling unavailable chart types */
+    chartAvailability?: ChartAvailabilityMap;
+    onChartTypeChange: (type: ChartType) => void;
+    onChartConfigChange: (config: ChartAxisConfig) => void;
+    onDisplayConfigChange: (config: ChartDisplayConfig) => void;
+}
+export default function AnalysisChartConfigPanel({ chartType, chartConfig, displayConfig, metrics, breakdowns, colorPalette, schema, chartAvailability, onChartTypeChange, onChartConfigChange, onDisplayConfigChange }: AnalysisChartConfigPanelProps): import("react/jsx-runtime").JSX.Element;
+export {};

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

@@ -0,0 +1,20 @@
+import { GroupFilter } from '../../types';
+import { MetaResponse } from '../../shared/types';
+interface AnalysisFilterGroupProps {
+    /** The group filter to render */
+    group: GroupFilter;
+    /** Schema for field metadata */
+    schema: MetaResponse | null;
+    /** Callback when group changes */
+    onUpdate: (group: GroupFilter) => void;
+    /** Callback to remove this group */
+    onRemove: () => void;
+    /** Callback to add a new filter - receives path relative to this group */
+    onAddFilter: (relativePath?: number[]) => void;
+    /** Depth level for styling */
+    depth?: number;
+    /** Whether to hide the remove button (for top-level groups) */
+    hideRemoveButton?: boolean;
+}
+export default function AnalysisFilterGroup({ group, schema, onUpdate, onRemove, onAddFilter, depth, hideRemoveButton }: AnalysisFilterGroupProps): import("react/jsx-runtime").JSX.Element;
+export {};

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

@@ -0,0 +1,16 @@
+import { SimpleFilter } from '../../types';
+import { MetaResponse } from '../../shared/types';
+interface AnalysisFilterItemProps {
+    /** The filter to display */
+    filter: SimpleFilter;
+    /** Schema for field metadata */
+    schema: MetaResponse | null;
+    /** Callback to remove this filter */
+    onRemove: () => void;
+    /** Callback to update this filter */
+    onUpdate: (filter: SimpleFilter) => void;
+    /** Optional depth for nested styling */
+    depth?: number;
+}
+export default function AnalysisFilterItem({ filter, schema, onRemove, onUpdate, depth }: AnalysisFilterItemProps): import("react/jsx-runtime").JSX.Element;
+export {};

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

@@ -0,0 +1,12 @@
+import { Filter } from '../../types';
+import { MetaResponse } from '../../shared/types';
+interface AnalysisFilterSectionProps {
+    /** Current filters */
+    filters: Filter[];
+    /** Schema for field metadata */
+    schema: MetaResponse | null;
+    /** Callback when filters change */
+    onFiltersChange: (filters: Filter[]) => void;
+}
+export default function AnalysisFilterSection({ filters, schema, onFiltersChange }: AnalysisFilterSectionProps): import("react/jsx-runtime").JSX.Element;
+export {};

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

@@ -0,0 +1,10 @@
+import { AnalysisQueryPanelProps } from './types';
+/**
+ * AnalysisQueryPanel displays the right-side query builder with:
+ * - Query/Chart tab switcher
+ * - Metrics section (measures)
+ * - Filter section
+ * - Breakdown section (dimensions)
+ * - Chart configuration (in Chart tab)
+ */
+export default function AnalysisQueryPanel({ metrics, breakdowns, filters, schema, activeTab, onActiveTabChange, onAddMetric, onRemoveMetric, onAddBreakdown, onRemoveBreakdown, onBreakdownGranularityChange, onFiltersChange, order, onOrderChange, chartType, chartConfig, displayConfig, chartAvailability, onChartTypeChange, onChartConfigChange, onDisplayConfigChange }: AnalysisQueryPanelProps): import("react/jsx-runtime").JSX.Element;

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

@@ -0,0 +1,12 @@
+import { AnalysisResultsPanelProps } from './types';
+/**
+ * AnalysisResultsPanel displays query results with chart/table toggle.
+ *
+ * Features:
+ * - Chart visualization with LazyChart
+ * - Table view with DataTable
+ * - Loading, error, and empty states
+ * - Stale results indicator
+ * - Display limit control for tables
+ */
+export default function AnalysisResultsPanel({ executionStatus, executionResults, executionError, totalRowCount, resultsStale, chartType, chartConfig, displayConfig, query, activeView, onActiveViewChange, displayLimit, onDisplayLimitChange, hasMetrics, debugQuery, debugSql, debugAnalysis, debugLoading, debugError }: AnalysisResultsPanelProps): import("react/jsx-runtime").JSX.Element;

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

@@ -0,0 +1,10 @@
+import { BreakdownItemCardProps } from './types';
+/**
+ * BreakdownItemCard displays a selected breakdown with:
+ * - Field icon (dimension or time dimension)
+ * - Field title or full name
+ * - Granularity dropdown (for time dimensions)
+ * - Sort toggle button (visible on hover, or always visible when sorted)
+ * - Remove button (visible on hover)
+ */
+export default function BreakdownItemCard({ breakdown, fieldMeta, onRemove, onGranularityChange, sortDirection, sortPriority, onToggleSort }: BreakdownItemCardProps): import("react/jsx-runtime").JSX.Element;

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

@@ -0,0 +1,8 @@
+import { BreakdownSectionProps } from './types';
+/**
+ * BreakdownSection displays a collapsible section with:
+ * - Header with title and add button
+ * - List of selected breakdowns (using BreakdownItemCard)
+ * - Empty state with add button
+ */
+export default function BreakdownSection({ breakdowns, schema, onAdd, onRemove, onGranularityChange, order, onOrderChange }: BreakdownSectionProps): import("react/jsx-runtime").JSX.Element;

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

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

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

@@ -0,0 +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;
+declare const _default: import('react').MemoExoticComponent<typeof FieldSearchItem>;
+export default _default;

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

@@ -0,0 +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;

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

@@ -0,0 +1,9 @@
+import { MetricItemCardProps } from './types';
+/**
+ * MetricItemCard displays a selected metric with:
+ * - Field icon based on measure type
+ * - Field title or full name
+ * - Sort toggle button (visible on hover, or always visible when sorted)
+ * - Remove button (visible on hover)
+ */
+export default function MetricItemCard({ metric, fieldMeta, onRemove, sortDirection, sortPriority, onToggleSort }: MetricItemCardProps): import("react/jsx-runtime").JSX.Element;

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

@@ -0,0 +1,8 @@
+import { MetricsSectionProps } from './types';
+/**
+ * MetricsSection displays a collapsible section with:
+ * - Header with title and add button
+ * - List of selected metrics (using MetricItemCard)
+ * - Empty state with add button
+ */
+export default function MetricsSection({ metrics, schema, onAdd, onRemove, order, onOrderChange }: MetricsSectionProps): import("react/jsx-runtime").JSX.Element;

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

@@ -0,0 +1,3 @@
+import { AnalysisBuilderProps, AnalysisBuilderRef } from './types';
+declare const AnalysisBuilder: import('react').ForwardRefExoticComponent<AnalysisBuilderProps & import('react').RefAttributes<AnalysisBuilderRef>>;
+export default AnalysisBuilder;

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

@@ -0,0 +1,366 @@
+import { default as React } from 'react';
+import { CubeQuery, Filter, ChartType, ChartAxisConfig, ChartDisplayConfig } from '../../types';
+import { MetaResponse, MetaField, MetaCube, QueryAnalysis } from '../../shared/types';
+import { ChartAvailabilityMap } from '../../shared/chartDefaults';
+export type { MetaResponse, MetaField, MetaCube, QueryAnalysis };
+/**
+ * A selected metric (measure) with a letter label (A, B, C, ...)
+ */
+export interface MetricItem {
+    /** Unique identifier for this metric selection */
+    id: string;
+    /** Full field name, e.g., "Employees.count" */
+    field: string;
+    /** Display label (A, B, C, ...) */
+    label: string;
+}
+/**
+ * A selected breakdown (dimension or time dimension)
+ */
+export interface BreakdownItem {
+    /** Unique identifier for this breakdown selection */
+    id: string;
+    /** Full field name, e.g., "Employees.departmentName" */
+    field: string;
+    /** Granularity for time dimensions (day, week, month, quarter, year) */
+    granularity?: string;
+    /** Whether this is a time dimension */
+    isTimeDimension: boolean;
+}
+/** Validation status for query building */
+export type ValidationStatus = 'idle' | 'validating' | 'valid' | 'invalid';
+/** Execution status for query results */
+export type ExecutionStatus = 'idle' | 'loading' | 'refreshing' | 'success' | 'error';
+/**
+ * Main state for the AnalysisBuilder component
+ */
+export interface AnalysisBuilderState {
+    /** Selected metrics (measures) */
+    metrics: MetricItem[];
+    /** Selected breakdowns (dimensions and time dimensions) */
+    breakdowns: BreakdownItem[];
+    /** Applied filters */
+    filters: Filter[];
+    validationStatus: ValidationStatus;
+    validationError: string | null;
+    executionStatus: ExecutionStatus;
+    executionResults: any[] | null;
+    executionError: string | null;
+    totalRowCount: number | null;
+    resultsStale: boolean;
+}
+/**
+ * Mode for the field search modal - determines which field types are shown
+ */
+export type FieldSearchMode = 'metrics' | 'breakdown' | 'filter';
+/**
+ * Field type categorization
+ */
+export type FieldType = 'measure' | 'dimension' | 'timeDimension';
+/**
+ * A field option for display in the search modal
+ */
+export interface FieldOption {
+    /** Full field name, e.g., "Employees.count" */
+    name: string;
+    /** Display title */
+    title: string;
+    /** Short title for compact display */
+    shortTitle: string;
+    /** Field type (count, sum, avg, string, time, number, etc.) */
+    type: string;
+    /** Optional description */
+    description?: string;
+    /** Parent cube name */
+    cubeName: string;
+    /** Categorized field type */
+    fieldType: FieldType;
+}
+/**
+ * Props for the FieldSearchModal component
+ */
+export interface FieldSearchModalProps {
+    /** Whether the modal is open */
+    isOpen: boolean;
+    /** Callback to close the modal */
+    onClose: () => void;
+    /** Callback when a field is selected. keepOpen=true when shift-click multi-selecting */
+    onSelect: (field: MetaField, fieldType: FieldType, cubeName: string, keepOpen?: boolean) => void;
+    /** Mode determines which field types to show */
+    mode: FieldSearchMode;
+    /** Schema metadata */
+    schema: MetaResponse | null;
+    /** Already selected field names (to show checkmarks) */
+    selectedFields: string[];
+    /** Recently used field names */
+    recentFields?: string[];
+}
+/**
+ * Props for the FieldSearchItem component
+ */
+export interface FieldSearchItemProps {
+    /** Field data */
+    field: FieldOption;
+    /** Whether this field is selected */
+    isSelected: boolean;
+    /** Whether this field is focused/highlighted */
+    isFocused: boolean;
+    /** Click handler - receives mouse event for shift-click multi-select */
+    onClick: (e: React.MouseEvent) => void;
+    /** Mouse enter handler (for detail panel) */
+    onMouseEnter: () => void;
+}
+/**
+ * Props for the FieldDetailPanel component
+ */
+export interface FieldDetailPanelProps {
+    /** Field to display details for */
+    field: FieldOption | null;
+}
+/**
+ * Tab options for the query panel
+ */
+export type QueryPanelTab = 'query' | 'chart';
+/**
+ * Props for the AnalysisQueryPanel component
+ */
+export interface AnalysisQueryPanelProps {
+    /** Selected metrics */
+    metrics: MetricItem[];
+    /** Selected breakdowns */
+    breakdowns: BreakdownItem[];
+    /** Applied filters */
+    filters: Filter[];
+    /** Schema metadata */
+    schema: MetaResponse | null;
+    /** Currently active tab */
+    activeTab: QueryPanelTab;
+    /** Callback when active tab changes */
+    onActiveTabChange: (tab: QueryPanelTab) => void;
+    onAddMetric: () => void;
+    onRemoveMetric: (id: string) => void;
+    onAddBreakdown: () => void;
+    onRemoveBreakdown: (id: string) => void;
+    onBreakdownGranularityChange: (id: string, granularity: string) => void;
+    onFiltersChange: (filters: Filter[]) => void;
+    /** Current sort order */
+    order?: Record<string, 'asc' | 'desc'>;
+    /** Callback when sort order changes */
+    onOrderChange: (fieldName: string, direction: 'asc' | 'desc' | null) => void;
+    chartType: ChartType;
+    chartConfig: ChartAxisConfig;
+    displayConfig: ChartDisplayConfig;
+    /** Map of chart type availability for disabling unavailable chart types */
+    chartAvailability?: ChartAvailabilityMap;
+    onChartTypeChange: (type: ChartType) => void;
+    onChartConfigChange: (config: ChartAxisConfig) => void;
+    onDisplayConfigChange: (config: ChartDisplayConfig) => void;
+    validationStatus: ValidationStatus;
+    validationError: string | null;
+}
+/**
+ * Props for the AnalysisResultsPanel component
+ */
+export interface AnalysisResultsPanelProps {
+    /** Current execution status */
+    executionStatus: ExecutionStatus;
+    /** Execution results (raw data) */
+    executionResults: any[] | null;
+    /** Execution error message */
+    executionError: string | null;
+    /** Total row count (before limit) */
+    totalRowCount: number | null;
+    /** Whether results are stale (query changed) */
+    resultsStale: boolean;
+    /** Chart type for visualization */
+    chartType: ChartType;
+    /** Chart axis configuration */
+    chartConfig: ChartAxisConfig;
+    /** Chart display configuration */
+    displayConfig: ChartDisplayConfig;
+    /** Current query object (for annotation/metadata) */
+    query: CubeQuery;
+    /** Schema metadata */
+    schema: MetaResponse | null;
+    /** Active view (table or chart) */
+    activeView: 'table' | 'chart';
+    /** Callback when active view changes */
+    onActiveViewChange: (view: 'table' | 'chart') => void;
+    /** Display limit for table */
+    displayLimit: number;
+    /** Callback when display limit changes */
+    onDisplayLimitChange: (limit: number) => void;
+    /** Whether the query has metrics (measures) - needed to enable/disable chart view */
+    hasMetrics: boolean;
+    debugQuery?: CubeQuery | null;
+    debugSql?: {
+        sql: string;
+        params: any[];
+    } | null;
+    debugAnalysis?: QueryAnalysis | null;
+    debugLoading?: boolean;
+    debugError?: string | null;
+}
+/**
+ * Props for the MetricsSection component
+ */
+export interface MetricsSectionProps {
+    /** Selected metrics */
+    metrics: MetricItem[];
+    /** Schema for resolving field titles */
+    schema: MetaResponse | null;
+    /** Add metric handler */
+    onAdd: () => void;
+    /** Remove metric handler */
+    onRemove: (id: string) => void;
+    /** Whether the section is expanded */
+    isExpanded?: boolean;
+    /** Toggle expansion */
+    onToggleExpanded?: () => void;
+    /** Current sort order */
+    order?: Record<string, 'asc' | 'desc'>;
+    /** Callback when sort order changes */
+    onOrderChange?: (fieldName: string, direction: 'asc' | 'desc' | null) => void;
+}
+/**
+ * Props for the BreakdownSection component
+ */
+export interface BreakdownSectionProps {
+    /** Selected breakdowns */
+    breakdowns: BreakdownItem[];
+    /** Schema for resolving field titles */
+    schema: MetaResponse | null;
+    /** Add breakdown handler */
+    onAdd: () => void;
+    /** Remove breakdown handler */
+    onRemove: (id: string) => void;
+    /** Change granularity for time dimension */
+    onGranularityChange: (id: string, granularity: string) => void;
+    /** Whether the section is expanded */
+    isExpanded?: boolean;
+    /** Toggle expansion */
+    onToggleExpanded?: () => void;
+    /** Current sort order */
+    order?: Record<string, 'asc' | 'desc'>;
+    /** Callback when sort order changes */
+    onOrderChange?: (fieldName: string, direction: 'asc' | 'desc' | null) => void;
+}
+/**
+ * Props for MetricItemCard component
+ */
+export interface MetricItemCardProps {
+    /** Metric item data */
+    metric: MetricItem;
+    /** Field metadata (for title, description) */
+    fieldMeta: MetaField | null;
+    /** Remove handler */
+    onRemove: () => void;
+    /** Current sort direction for this field */
+    sortDirection?: 'asc' | 'desc' | null;
+    /** Sort priority (1, 2, 3...) if sorted */
+    sortPriority?: number;
+    /** Toggle sort handler */
+    onToggleSort?: () => void;
+}
+/**
+ * Props for BreakdownItemCard component
+ */
+export interface BreakdownItemCardProps {
+    /** Breakdown item data */
+    breakdown: BreakdownItem;
+    /** Field metadata (for title, description) */
+    fieldMeta: MetaField | null;
+    /** Remove handler */
+    onRemove: () => void;
+    /** Granularity change handler (for time dimensions) */
+    onGranularityChange?: (granularity: string) => void;
+    /** Current sort direction for this field */
+    sortDirection?: 'asc' | 'desc' | null;
+    /** Sort priority (1, 2, 3...) if sorted */
+    sortPriority?: number;
+    /** Toggle sort handler */
+    onToggleSort?: () => void;
+}
+/**
+ * Props for the main AnalysisBuilder component
+ */
+export interface AnalysisBuilderProps {
+    /** Additional CSS classes */
+    className?: string;
+    /** Maximum height for the component (e.g., '800px', '100vh', 'calc(100vh - 64px)') */
+    maxHeight?: string;
+    /** Initial query to load */
+    initialQuery?: CubeQuery;
+    /** Disable localStorage persistence */
+    disableLocalStorage?: boolean;
+    /** Hide settings button */
+    hideSettings?: boolean;
+    /** Callback when query changes (for modal integration) */
+    onQueryChange?: (query: CubeQuery) => void;
+    /** Callback when chart config changes */
+    onChartConfigChange?: (config: {
+        chartType: ChartType;
+        chartConfig: ChartAxisConfig;
+        displayConfig: ChartDisplayConfig;
+    }) => void;
+}
+/**
+ * Ref interface for AnalysisBuilder (for external access)
+ */
+export interface AnalysisBuilderRef {
+    /** Get the current query object */
+    getCurrentQuery: () => CubeQuery;
+    /** Get current chart configuration */
+    getChartConfig: () => {
+        chartType: ChartType;
+        chartConfig: ChartAxisConfig;
+        displayConfig: ChartDisplayConfig;
+    };
+    /** Execute the current query */
+    executeQuery: () => void;
+    /** Clear the current query */
+    clearQuery: () => void;
+}
+/**
+ * Local storage state shape for persistence
+ */
+export interface AnalysisBuilderStorageState {
+    metrics: MetricItem[];
+    breakdowns: BreakdownItem[];
+    filters: Filter[];
+    order?: Record<string, 'asc' | 'desc'>;
+    chartType: ChartType;
+    chartConfig: ChartAxisConfig;
+    displayConfig: ChartDisplayConfig;
+    activeView: 'table' | 'chart';
+}
+/**
+ * Recent fields storage shape
+ */
+export interface RecentFieldsStorage {
+    metrics: string[];
+    breakdowns: string[];
+}
+/**
+ * Time granularity options
+ */
+export declare const TIME_GRANULARITIES: readonly [{
+    readonly value: "hour";
+    readonly label: "Hour";
+}, {
+    readonly value: "day";
+    readonly label: "Day";
+}, {
+    readonly value: "week";
+    readonly label: "Week";
+}, {
+    readonly value: "month";
+    readonly label: "Month";
+}, {
+    readonly value: "quarter";
+    readonly label: "Quarter";
+}, {
+    readonly value: "year";
+    readonly label: "Year";
+}];
+export type TimeGranularity = typeof TIME_GRANULARITIES[number]['value'];

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

@@ -0,0 +1,103 @@
+import { MetricItem, BreakdownItem, FieldOption, FieldType, RecentFieldsStorage } from './types';
+import { MetaResponse, MetaField } from '../../shared/types';
+import { CubeQuery, Filter } from '../../types';
+/**
+ * Generate a unique ID for items
+ */
+export declare function generateId(): string;
+/**
+ * Generate letter label for metrics (A, B, C, ..., AA, AB, ...)
+ */
+export declare function generateMetricLabel(index: number): string;
+/**
+ * Convert metrics and breakdowns to CubeQuery format
+ */
+export declare function buildCubeQuery(metrics: MetricItem[], breakdowns: BreakdownItem[], filters: Filter[]): CubeQuery;
+/**
+ * Check if a query has any content
+ */
+export declare function hasQueryContent(metrics: MetricItem[], breakdowns: BreakdownItem[], filters: Filter[]): boolean;
+/**
+ * Get cube name from a field name (e.g., "Employees.count" -> "Employees")
+ */
+export declare function getCubeNameFromField(fieldName: string): string;
+/**
+ * Get field short name from full name (e.g., "Employees.count" -> "count")
+ */
+export declare function getFieldShortName(fieldName: string): string;
+/**
+ * Find field metadata from schema
+ */
+export declare function findFieldInSchema(fieldName: string, schema: MetaResponse | null): {
+    field: MetaField;
+    cubeName: string;
+    fieldType: FieldType;
+} | null;
+/**
+ * Get display title for a field
+ */
+export declare function getFieldTitle(fieldName: string, schema: MetaResponse | null): string;
+/**
+ * Determine field type from metadata
+ */
+export declare function getFieldType(field: MetaField): FieldType;
+/**
+ * Convert schema to flat list of field options
+ */
+export declare function schemaToFieldOptions(schema: MetaResponse | null, mode: 'metrics' | 'breakdown' | 'filter'): FieldOption[];
+/**
+ * Filter field options by search term
+ */
+export declare function filterFieldOptions(options: FieldOption[], searchTerm: string, selectedCube?: string | null): FieldOption[];
+/**
+ * Group field options by cube
+ */
+export declare function groupFieldsByCube(options: FieldOption[]): Map<string, FieldOption[]>;
+/**
+ * Get recent fields from localStorage
+ */
+export declare function getRecentFields(): RecentFieldsStorage;
+/**
+ * Add a field to recent fields
+ */
+export declare function addRecentField(fieldName: string, mode: 'metrics' | 'breakdowns'): void;
+/**
+ * Get recent field options from schema
+ */
+export declare function getRecentFieldOptions(schema: MetaResponse | null, mode: 'metrics' | 'breakdown' | 'filter', recentFieldNames: string[]): FieldOption[];
+/**
+ * Get list of cube names from schema
+ */
+export declare function getCubeNames(schema: MetaResponse | null): string[];
+/**
+ * Get cube title by name
+ */
+export declare function getCubeTitle(cubeName: string, schema: MetaResponse | null): string;
+/**
+ * Save state to localStorage
+ */
+export declare function saveStateToStorage(state: {
+    metrics: MetricItem[];
+    breakdowns: BreakdownItem[];
+    filters: Filter[];
+    chartType: string;
+    chartConfig: object;
+    displayConfig: object;
+    activeView: string;
+}): void;
+/**
+ * Load state from localStorage
+ */
+export declare function loadStateFromStorage(): {
+    metrics: MetricItem[];
+    breakdowns: BreakdownItem[];
+    filters: Filter[];
+    chartType: string;
+    chartConfig: object;
+    displayConfig: object;
+    activeView: string;
+} | null;
+/**
+ * Clear state from localStorage
+ */
+export declare function clearStateFromStorage(): void;