drizzle-cube 0.6.0 → 0.6.2

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

@@ -0,0 +1,12 @@
+import { default as React } from 'react';
+import { MarkdownBlock } from '../../stores/notebookStore.js';
+interface NotebookMarkdownBlockProps {
+    block: MarkdownBlock;
+    onRemove: (id: string) => void;
+    onMoveUp: (id: string) => void;
+    onMoveDown: (id: string) => void;
+    isFirst: boolean;
+    isLast: boolean;
+}
+declare const NotebookMarkdownBlock: React.NamedExoticComponent<NotebookMarkdownBlockProps>;
+export default NotebookMarkdownBlock;

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

@@ -0,0 +1,15 @@
+import { default as React } from 'react';
+import { PortletBlock } from '../../stores/notebookStore.js';
+import { ColorPalette } from '../../utils/colorPalettes.js';
+interface NotebookPortletBlockProps {
+    block: PortletBlock;
+    colorPalette?: ColorPalette;
+    onRemove: (id: string) => void;
+    onMoveUp: (id: string) => void;
+    onMoveDown: (id: string) => void;
+    onEdit: (block: PortletBlock) => void;
+    isFirst: boolean;
+    isLast: boolean;
+}
+declare const NotebookPortletBlock: React.NamedExoticComponent<NotebookPortletBlockProps>;
+export default NotebookPortletBlock;

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

@@ -0,0 +1,34 @@
+import { default as React } from 'react';
+interface ChatPanelFlags {
+    showSaveAsDashboard: boolean;
+    showClear: boolean;
+    showFeedback: boolean;
+    lastScored: boolean;
+}
+interface ChatPanelFlagInput {
+    onDashboardSaved: boolean;
+    onScore: boolean;
+    isStreaming: boolean;
+    portletBlockCount: number;
+    messageCount: number;
+    lastTraceId: string | null;
+    scoredTraceIds: Set<string>;
+}
+/** Derive header/feedback visibility flags for the chat panel. */
+export declare function getChatPanelFlags(i: ChatPanelFlagInput): ChatPanelFlags;
+export declare function ChatHeader({ showSaveAsDashboard, showClear, isStreaming, onSaveAsDashboard, onClear, }: {
+    showSaveAsDashboard: boolean;
+    showClear: boolean;
+    isStreaming: boolean;
+    onSaveAsDashboard: () => void;
+    onClear: () => void;
+}): React.JSX.Element;
+export declare function FeedbackBar({ scored, onScore, }: {
+    scored: boolean;
+    onScore: (value: number) => void;
+}): React.JSX.Element;
+export declare function ThinkingBubble({ loadingComponent }: {
+    loadingComponent?: React.ReactNode;
+}): React.JSX.Element;
+export declare function EmptyState(): React.JSX.Element;
+export {};

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

@@ -0,0 +1,39 @@
+import { default as React } from 'react';
+import { ChatMessage as ChatMessageType, ToolCallRecord } from '../../stores/notebookStore.js';
+/** Simple inline markdown parser for bold, italic, and code in chat text */
+export declare function renderInlineMarkdown(text: string): React.ReactNode[];
+/** Compute the bubble background/text classes for a message. */
+export declare function getBubbleClass(isUser: boolean, hasError: boolean, hasContent: boolean): string;
+export declare function ToolCallIndicator({ toolCall, loadingComponent, }: {
+    toolCall: ToolCallRecord;
+    loadingComponent?: React.ReactNode;
+}): React.JSX.Element;
+/** Error row shown below message text. */
+export declare function MessageError({ error, hasContent }: {
+    error: string;
+    hasContent: boolean;
+}): React.JSX.Element;
+interface MessageFlags {
+    isUser: boolean;
+    hasContent: boolean;
+    hasError: boolean;
+    hasToolCalls: boolean;
+    toolCalls: ToolCallRecord[];
+    /** False for empty assistant messages that should not render. */
+    shouldRender: boolean;
+}
+/** Derive render flags for a chat message. */
+export declare function getMessageFlags(message: ChatMessageType): MessageFlags;
+/** Inner content of a chat bubble: text, error row, and tool calls. */
+export declare function ChatBubbleBody({ message, flags, loadingComponent, }: {
+    message: ChatMessageType;
+    flags: MessageFlags;
+    loadingComponent?: React.ReactNode;
+}): React.JSX.Element;
+/** List of tool-call indicators for a message. */
+export declare function ToolCallList({ toolCalls, loadingComponent, separated, }: {
+    toolCalls: ToolCallRecord[];
+    loadingComponent?: React.ReactNode;
+    separated: boolean;
+}): React.JSX.Element;
+export {};

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

@@ -0,0 +1,56 @@
+import { default as React, ReactNode } from 'react';
+import { NotebookConfig } from '../../stores/notebookStore.js';
+import { ColorPalette } from '../../types.js';
+export interface AgenticNotebookProps {
+    /** Initial config to restore (saved notebooks) */
+    config?: NotebookConfig;
+    /** Override default agent endpoint (default: apiUrl + '/agent/chat') */
+    agentEndpoint?: string;
+    /** Client-side API key (for demo/try-site use) */
+    agentApiKey?: string;
+    /** Override LLM provider (anthropic | openai | google) */
+    agentProvider?: string;
+    /** Override LLM model (e.g. 'gpt-4o', 'gemini-2.0-flash') */
+    agentModel?: string;
+    /** Override provider endpoint URL (for OpenAI-compatible services) */
+    agentProviderEndpoint?: string;
+    /** Callback when notebook state changes (for persistence) */
+    onSave?: (config: NotebookConfig) => void | Promise<void>;
+    /** Callback when dirty state changes */
+    onDirtyStateChange?: (isDirty: boolean) => void;
+    /** Color palette for charts */
+    colorPalette?: ColorPalette;
+    /** Called when the agent saves a dashboard. Presence enables the "Save as Dashboard" button. */
+    onDashboardSaved?: (data: {
+        title: string;
+        description?: string;
+        dashboardConfig: any;
+    }) => void;
+    /** Called when user submits feedback (thumbs up/down). Receives traceId from the last agent response. */
+    onScore?: (data: {
+        traceId: string;
+        value: number;
+        comment?: string;
+    }) => void;
+    /** Custom loading indicator for tool call spinners (defaults to LoadingIndicator) */
+    loadingComponent?: ReactNode;
+    /** Additional CSS class name */
+    className?: string;
+    /** Initial prompt to auto-send on mount */
+    initialPrompt?: string;
+}
+/**
+ * AgenticNotebook - AI-powered data analysis notebook
+ *
+ * @example
+ * ```tsx
+ * <CubeProvider apiOptions={{ apiUrl: '/api/cubejs-api/v1' }} token={token}>
+ *   <AgenticNotebook
+ *     agentApiKey="sk-..."
+ *     onSave={(config) => saveToDatabase(config)}
+ *   />
+ * </CubeProvider>
+ * ```
+ */
+declare const AgenticNotebook: React.NamedExoticComponent<AgenticNotebookProps>;
+export default AgenticNotebook;

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

@@ -0,0 +1,25 @@
+import { ChatMessage as ChatMessageType } from '../../stores/notebookStore.js';
+interface UseAgentChatControllerParams {
+    agentEndpoint?: string;
+    agentApiKey?: string;
+    agentProvider?: string;
+    agentModel?: string;
+    agentProviderEndpoint?: string;
+    onDashboardSaved?: (data: {
+        title: string;
+        description?: string;
+        dashboardConfig: any;
+    }) => void;
+    messages: ChatMessageType[];
+    isStreaming: boolean;
+}
+export declare function useAgentChatController({ agentEndpoint, agentApiKey, agentProvider, agentModel, agentProviderEndpoint, onDashboardSaved, messages, isStreaming, }: UseAgentChatControllerParams): {
+    doSend: (content: string) => void;
+    handleStop: () => void;
+    abort: () => void;
+    isThinking: boolean;
+    setIsThinking: import('react').Dispatch<import('react').SetStateAction<boolean>>;
+    lastTraceId: string | null;
+    setLastTraceId: import('react').Dispatch<import('react').SetStateAction<string | null>>;
+};
+export {};

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

@@ -0,0 +1,12 @@
+import { NotebookConfig } from '../../stores/notebookStore.js';
+interface UseNotebookAutosaveParams {
+    blockCount: number;
+    messageCount: number;
+    isStreaming: boolean;
+    save: () => NotebookConfig;
+    onSave?: (config: NotebookConfig) => void | Promise<void>;
+}
+export declare function useNotebookAutosave({ blockCount, messageCount, isStreaming, save, onSave, }: UseNotebookAutosaveParams): {
+    clearSave: () => void;
+};
+export {};

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

@@ -0,0 +1,25 @@
+/**
+ * AnalysisAIPanel Component
+ *
+ * A collapsible panel for AI-powered query generation.
+ * Appears above the results panel when activated.
+ */
+export interface AnalysisAIPanelProps {
+    /** User's natural language prompt */
+    userPrompt: string;
+    /** Callback when prompt changes */
+    onPromptChange: (prompt: string) => void;
+    /** Whether a query is being generated */
+    isGenerating: boolean;
+    /** Error message from generation */
+    error: string | null;
+    /** Whether the AI has generated a query */
+    hasGeneratedQuery: boolean;
+    /** Callback to generate query */
+    onGenerate: () => void;
+    /** Callback to accept the generated query */
+    onAccept: () => void;
+    /** Callback to cancel and restore previous state */
+    onCancel: () => void;
+}
+export default function AnalysisAIPanel({ userPrompt, onPromptChange, isGenerating, error, hasGeneratedQuery, onGenerate, onAccept, onCancel }: AnalysisAIPanelProps): import("react").JSX.Element;

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

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

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

@@ -0,0 +1,18 @@
+import { ChartType, ChartAxisConfig } from '../../types.js';
+import { MetricItem, BreakdownItem } from './types.js';
+import { ChartAvailabilityMap } from '../../shared/chartDefaults.js';
+import { MetaResponse } from '../../shared/types.js';
+interface AnalysisChartConfigPanelProps {
+    chartType: ChartType;
+    chartConfig: ChartAxisConfig;
+    metrics: MetricItem[];
+    breakdowns: BreakdownItem[];
+    /** 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;
+}
+export default function AnalysisChartConfigPanel({ chartType, chartConfig, metrics, breakdowns, schema, chartAvailability, onChartTypeChange, onChartConfigChange }: AnalysisChartConfigPanelProps): import("react").JSX.Element;
+export {};

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

@@ -0,0 +1,11 @@
+import { ChartType, ChartDisplayConfig, ColorPalette } from '../../types.js';
+interface AnalysisDisplayConfigPanelProps {
+    chartType: ChartType;
+    displayConfig: ChartDisplayConfig;
+    colorPalette?: ColorPalette;
+    onDisplayConfigChange: (config: ChartDisplayConfig) => void;
+    /** Keys to exclude from displayOptionsConfig rendering (e.g., ['content'] when content is managed elsewhere) */
+    excludeKeys?: string[];
+}
+export default function AnalysisDisplayConfigPanel({ chartType, displayConfig, colorPalette, onDisplayConfigChange, excludeKeys, }: AnalysisDisplayConfigPanelProps): import("react").JSX.Element;
+export {};

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

@@ -0,0 +1,20 @@
+import { GroupFilter } from '../../types.js';
+import { MetaResponse } from '../../shared/types.js';
+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.Element;
+export {};

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

@@ -0,0 +1,14 @@
+import { SimpleFilter } from '../../types.js';
+import { MetaResponse } from '../../shared/types.js';
+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;
+}
+export default function AnalysisFilterItem({ filter, schema, onRemove, onUpdate }: AnalysisFilterItemProps): import("react").JSX.Element;
+export {};

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

@@ -0,0 +1,16 @@
+import { Filter } from '../../types.js';
+import { MetaResponse } from '../../shared/types.js';
+interface AnalysisFilterSectionProps {
+    /** Current filters */
+    filters: Filter[];
+    /** Schema for field metadata */
+    schema: MetaResponse | null;
+    /** Callback when filters change */
+    onFiltersChange: (filters: Filter[]) => void;
+    /** Callback when a field is dropped from another section */
+    onFieldDropped?: (field: string) => void;
+    /** 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.Element;
+export {};

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

@@ -0,0 +1,27 @@
+import { default as React, Component, ReactNode } from 'react';
+import { AnalysisType } from '../../types.js';
+interface Props {
+    children: ReactNode;
+    /** Current analysis type (for error messages) */
+    analysisType: AnalysisType;
+    /** Callback to switch to a safe mode (query) on error */
+    onSwitchToSafeMode?: () => void;
+}
+interface State {
+    hasError: boolean;
+    error: Error | null;
+}
+/**
+ * Error boundary for mode switching in AnalysisBuilder.
+ * If an adapter throws during load/validate/save, this catches it
+ * and offers to switch back to query mode.
+ */
+export declare class AnalysisModeErrorBoundary extends Component<Props, State> {
+    constructor(props: Props);
+    static getDerivedStateFromError(error: Error): State;
+    componentDidCatch(error: Error, errorInfo: React.ErrorInfo): void;
+    handleReset: () => void;
+    handleSwitchToSafeMode: () => void;
+    render(): string | number | boolean | Iterable<React.ReactNode> | React.JSX.Element | null | undefined;
+}
+export default AnalysisModeErrorBoundary;

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

@@ -0,0 +1,12 @@
+import { default as React } from 'react';
+import { AnalysisQueryPanelProps } from './types.js';
+/**
+ * AnalysisQueryPanel displays the right-side query builder with:
+ * - Query/Chart tab switcher (with multi-query support)
+ * - Metrics section (measures)
+ * - Filter section
+ * - Breakdown section (dimensions)
+ * - Chart configuration (in Chart tab)
+ */
+declare const AnalysisQueryPanel: React.NamedExoticComponent<AnalysisQueryPanelProps>;
+export default AnalysisQueryPanel;

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

@@ -0,0 +1,64 @@
+import { default as React } from 'react';
+import { AnalysisQueryPanelProps, BreakdownItem } from './types.js';
+import { MetaField } from '../../shared/types.js';
+import { QueryMergeStrategy } from '../../types.js';
+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/cjs/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/cjs/client/components/AnalysisBuilder/AnalysisResultsPanel.d.ts

@@ -0,0 +1,14 @@
+import { default as React } from 'react';
+import { AnalysisResultsPanelProps } from './types.js';
+/**
+ * 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
+ */
+declare const AnalysisResultsPanel: React.NamedExoticComponent<AnalysisResultsPanelProps>;
+export default AnalysisResultsPanel;

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

@@ -0,0 +1,17 @@
+import { default as React } from 'react';
+import { AnalysisType, CubeMeta } from '../../types.js';
+interface AnalysisTypeSelectorProps {
+    /** Currently selected analysis type */
+    value: AnalysisType;
+    /** Called when analysis type changes */
+    onChange: (type: AnalysisType) => void;
+    /** Disable the selector */
+    disabled?: boolean;
+    /** Cube metadata for eventStream detection */
+    schema?: CubeMeta | null;
+}
+/**
+ * AnalysisTypeSelector - Horizontal tabs for analysis type selection
+ */
+declare const AnalysisTypeSelector: React.NamedExoticComponent<AnalysisTypeSelectorProps>;
+export default AnalysisTypeSelector;

package/dist/cjs/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/cjs/client/components/AnalysisBuilder/BreakdownItemCard.d.ts

@@ -0,0 +1,12 @@
+import { BreakdownItemCardProps } from './types.js';
+/**
+ * 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)
+ * - Drag handle for reordering
+ */
+declare const BreakdownItemCard: import('react').NamedExoticComponent<BreakdownItemCardProps>;
+export default BreakdownItemCard;

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

@@ -0,0 +1,26 @@
+import { DragEvent } from 'react';
+import { MetaField } from '../../shared/types.js';
+import { BreakdownItem } from './types.js';
+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/cjs/client/components/AnalysisBuilder/BreakdownSection.d.ts

@@ -0,0 +1,9 @@
+import { BreakdownSectionProps } from './types.js';
+/**
+ * BreakdownSection displays a collapsible section with:
+ * - Header with title and add button
+ * - List of selected breakdowns (using BreakdownItemCard)
+ * - Drag/drop reordering support
+ */
+declare const BreakdownSection: import('react').NamedExoticComponent<BreakdownSectionProps>;
+export default BreakdownSection;

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

@@ -0,0 +1,10 @@
+import { ChartDisplayConfig, ColorPalette } from '../../types.js';
+import { DisplayOptionConfig } from '../../charts/chartConfigs.js';
+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 {};