drizzle-cube 0.6.0 → 0.6.2

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

@@ -0,0 +1,51 @@
+import { useQueryClient } from '@tanstack/react-query';
+import { useCubeApi } from '../../providers/CubeApiProvider.js';
+import { CubeMeta, FieldLabelMap } from '../../types.js';
+export declare const CUBE_META_QUERY_KEY: readonly ["cube", "meta"];
+export interface UseCubeMetaQueryOptions {
+    /**
+     * Whether to skip the query (useful for conditional fetching)
+     * @default false
+     */
+    enabled?: boolean;
+    /**
+     * Stale time in milliseconds (how long before data is considered stale)
+     * @default 5 * 60 * 1000 (5 minutes)
+     */
+    staleTime?: number;
+}
+export interface UseCubeMetaQueryResult {
+    /** Cube metadata */
+    meta: CubeMeta | null;
+    /** Field label map for quick lookups */
+    labelMap: FieldLabelMap;
+    /** Whether the query is loading */
+    isLoading: boolean;
+    /** Whether the query is fetching (includes background refetch) */
+    isFetching: boolean;
+    /** Error if the query failed */
+    error: Error | null;
+    /** Manually refetch the metadata */
+    refetch: () => void;
+    /** Get a field's display label */
+    getFieldLabel: (fieldName: string) => string;
+}
+/**
+ * TanStack Query hook for fetching cube metadata
+ *
+ * Usage:
+ * ```tsx
+ * const { meta, labelMap, isLoading, error, refetch } = useCubeMetaQuery()
+ * ```
+ */
+export declare function useCubeMetaQuery(options?: UseCubeMetaQueryOptions): UseCubeMetaQueryResult;
+/**
+ * Prefetch cube metadata - useful for eager loading
+ *
+ * Usage:
+ * ```tsx
+ * const queryClient = useQueryClient()
+ * await prefetchCubeMeta(queryClient, cubeApi)
+ * ```
+ */
+export declare function prefetchCubeMeta(queryClient: ReturnType<typeof useQueryClient>, cubeApi: ReturnType<typeof useCubeApi>['cubeApi']): Promise<void>;

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

@@ -0,0 +1,153 @@
+import { CubeQuery } from '../../types.js';
+import { QueryAnalysis } from '../../components/AnalysisBuilder/types.js';
+export type DryRunMode = 'regular' | 'comparison' | 'funnel' | 'flow' | 'retention';
+/**
+ * Debug data entry for a single query
+ */
+export interface DebugDataEntry {
+    /** Generated SQL and parameters */
+    sql: {
+        sql: string;
+        params: unknown[];
+    } | null;
+    /** Query analysis (dimensions, measures, complexity, etc.) */
+    analysis: QueryAnalysis | null;
+    /** Server-reported dry-run mode */
+    mode?: DryRunMode | null;
+    /** Query type label from server */
+    queryType?: string | null;
+    /** Join strategy label from server */
+    joinType?: string | null;
+    /** Referenced cubes from server */
+    cubesUsed?: string[];
+    /** Mode-specific metadata (replaces funnel/flow/retention split) */
+    modeMetadata?: unknown;
+    /** Whether this entry is loading */
+    loading: boolean;
+    /** Error if fetch failed */
+    error: Error | null;
+}
+/**
+ * Create a stable query key for dry-run
+ */
+export declare function createDryRunQueryKey(query: CubeQuery | null): readonly unknown[];
+export interface UseDryRunQueryOptions {
+    /**
+     * Whether to skip the query
+     * @default false
+     */
+    skip?: boolean;
+    /**
+     * Stale time in milliseconds
+     * @default 5 * 60 * 1000 (5 minutes)
+     */
+    staleTime?: number;
+}
+export interface UseDryRunQueryResult {
+    /** Debug data for the query */
+    debugData: DebugDataEntry;
+    /** Manually refetch */
+    refetch: () => void;
+}
+/**
+ * TanStack Query hook for single query dry-run (debug) data
+ *
+ * Usage:
+ * ```tsx
+ * const { debugData } = useDryRunQuery(query, { skip: !isValidQuery })
+ * ```
+ */
+export declare function useDryRunQuery(query: CubeQuery | null, options?: UseDryRunQueryOptions): UseDryRunQueryResult;
+export interface UseMultiDryRunQueriesOptions {
+    /**
+     * Whether to skip all queries
+     * @default false
+     */
+    skip?: boolean;
+    /**
+     * Stale time in milliseconds
+     * @default 5 * 60 * 1000 (5 minutes)
+     */
+    staleTime?: number;
+}
+export interface UseMultiDryRunQueriesResult {
+    /** Debug data for each query */
+    debugDataPerQuery: DebugDataEntry[];
+    /** Whether any query is loading */
+    isLoading: boolean;
+    /** Manually refetch all */
+    refetchAll: () => void;
+}
+/**
+ * TanStack Query hook for multiple query dry-runs (debug) data
+ *
+ * Fetches debug data for multiple queries in parallel.
+ *
+ * Usage:
+ * ```tsx
+ * const { debugDataPerQuery, isLoading } = useMultiDryRunQueries(queries, {
+ *   skip: !isMultiQueryMode
+ * })
+ * ```
+ */
+export declare function useMultiDryRunQueries(queries: CubeQuery[], options?: UseMultiDryRunQueriesOptions): UseMultiDryRunQueriesResult;
+/**
+ * Combined hook for single or multi-query dry-run based on mode
+ *
+ * This is a convenience wrapper that automatically chooses between
+ * single and multi-query dry-run based on the number of queries.
+ *
+ * Usage:
+ * ```tsx
+ * const { debugDataPerQuery } = useDryRunQueries({
+ *   queries: isMultiQueryMode ? allQueries : [currentQuery],
+ *   isMultiQueryMode,
+ *   skip: !isValidQuery
+ * })
+ * ```
+ */
+export declare function useDryRunQueries(options: {
+    queries: CubeQuery[];
+    isMultiQueryMode: boolean;
+    skip?: boolean;
+    staleTime?: number;
+}): UseMultiDryRunQueriesResult;
+export type FunnelDebugDataEntry = DebugDataEntry;
+/**
+ * TanStack Query hook for funnel query dry-run (debug) data
+ *
+ * Usage:
+ * ```tsx
+ * const { debugData } = useFunnelDryRunQuery(serverQuery, { skip: !isFunnelMode })
+ * ```
+ */
+export declare function useFunnelDryRunQuery(serverQuery: unknown | null, options?: UseDryRunQueryOptions): {
+    debugData: FunnelDebugDataEntry;
+    refetch: () => void;
+};
+export type FlowDebugDataEntry = DebugDataEntry;
+/**
+ * TanStack Query hook for flow query dry-run (debug) data
+ *
+ * Usage:
+ * ```tsx
+ * const { debugData } = useFlowDryRunQuery(serverQuery, { skip: !isFlowMode })
+ * ```
+ */
+export declare function useFlowDryRunQuery(serverQuery: unknown | null, options?: UseDryRunQueryOptions): {
+    debugData: FlowDebugDataEntry;
+    refetch: () => void;
+};
+export type RetentionDebugDataEntry = DebugDataEntry;
+/**
+ * TanStack Query hook for retention query dry-run (debug) data
+ *
+ * Usage:
+ * ```tsx
+ * const { debugData } = useRetentionDryRunQuery(serverQuery, { skip: !isRetentionMode })
+ * ```
+ */
+export declare function useRetentionDryRunQuery(serverQuery: unknown | null, options?: UseDryRunQueryOptions): {
+    debugData: RetentionDebugDataEntry;
+    refetch: () => void;
+};

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

@@ -0,0 +1,62 @@
+import { ExplainResult, AIExplainAnalysis } from '../../types.js';
+export interface UseExplainAIOptions {
+    /**
+     * Custom AI endpoint for explain analysis
+     * @default '/api/ai/explain/analyze'
+     */
+    aiEndpoint?: string;
+}
+export interface UseExplainAIResult {
+    /** The AI analysis result */
+    analysis: AIExplainAnalysis | null;
+    /** Whether AI analysis is in progress */
+    isAnalyzing: boolean;
+    /** Error if AI analysis failed */
+    error: Error | null;
+    /**
+     * Trigger AI analysis of an explain result
+     * @param explainResult - The EXPLAIN result to analyze
+     * @param query - The original semantic query
+     */
+    analyze: (explainResult: ExplainResult, query: unknown) => void;
+    /** Clear the analysis result */
+    clearAnalysis: () => void;
+}
+/**
+ * Query key for AI explain analysis
+ */
+export declare const EXPLAIN_AI_QUERY_KEY: readonly ["cube", "explain", "ai"];
+/**
+ * TanStack Query hook for AI analysis of EXPLAIN plans
+ *
+ * This hook uses useMutation to call the AI endpoint and analyze execution plans,
+ * providing actionable recommendations for performance improvement.
+ *
+ * Recommendations focus on what users CAN control:
+ * - Index creation (with CREATE INDEX statements)
+ * - Table structure changes
+ * - Cube definition improvements (segments, pre-aggregations, joins)
+ *
+ * Usage:
+ * ```tsx
+ * const { analysis, isAnalyzing, analyze } = useExplainAI()
+ *
+ * // After running EXPLAIN
+ * if (explainResult) {
+ *   <button onClick={() => analyze(explainResult, query)}>
+ *     {isAnalyzing ? 'Analyzing...' : 'Analyze with AI'}
+ *   </button>
+ * }
+ *
+ * // Display recommendations
+ * {analysis?.recommendations.map(rec => (
+ *   <div key={rec.title}>
+ *     <h4>{rec.title}</h4>
+ *     <p>{rec.description}</p>
+ *     {rec.sql && <pre>{rec.sql}</pre>}
+ *     {rec.cubeCode && <pre>{rec.cubeCode}</pre>}
+ *   </div>
+ * ))}
+ * ```
+ */
+export declare function useExplainAI(options?: UseExplainAIOptions): UseExplainAIResult;

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

@@ -0,0 +1,62 @@
+import { CubeQuery, ExplainResult, ExplainOptions } from '../../types.js';
+/**
+ * Query type that can be explained - includes standard queries, funnel queries, flow queries, and retention queries
+ */
+export type ExplainableQuery = CubeQuery | {
+    funnel: unknown;
+} | {
+    flow: unknown;
+} | {
+    retention: unknown;
+} | unknown;
+/**
+ * Create a stable query key for explain
+ */
+export declare function createExplainQueryKey(query: ExplainableQuery | null, options?: ExplainOptions): readonly unknown[];
+export interface UseExplainQueryOptions {
+    /**
+     * Whether to skip the query (prevent execution even when triggered)
+     * @default false
+     */
+    skip?: boolean;
+}
+export interface UseExplainQueryResult {
+    /** The explain result from the server */
+    explainResult: ExplainResult | null;
+    /** Whether the explain query is loading */
+    isLoading: boolean;
+    /** Whether an explain has been triggered */
+    hasRun: boolean;
+    /** Error if explain failed */
+    error: Error | null;
+    /**
+     * Manually trigger the explain query
+     * @param options - Optional explain options (e.g., { analyze: true } for actual timing)
+     */
+    runExplain: (options?: ExplainOptions) => void;
+    /** Clear the explain result */
+    clearExplain: () => void;
+}
+/**
+ * TanStack Query hook for EXPLAIN PLAN execution
+ *
+ * Unlike useDryRunQuery, this hook is manually triggered via `runExplain()`.
+ * This is intentional because:
+ * 1. EXPLAIN queries have performance overhead
+ * 2. EXPLAIN ANALYZE actually executes the query
+ * 3. Users should explicitly choose when to run explain
+ *
+ * Supports standard queries, funnel queries, and flow queries.
+ *
+ * Usage:
+ * ```tsx
+ * const { explainResult, isLoading, runExplain } = useExplainQuery(query, { skip: !isValidQuery })
+ *
+ * // Trigger explain
+ * <button onClick={() => runExplain()}>Explain Plan</button>
+ *
+ * // Trigger explain with timing
+ * <button onClick={() => runExplain({ analyze: true })}>Explain with Timing</button>
+ * ```
+ */
+export declare function useExplainQuery(query: ExplainableQuery | null, options?: UseExplainQueryOptions): UseExplainQueryResult;

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

@@ -0,0 +1,72 @@
+import { ServerFlowQuery, FlowChartData } from '../../types/flow.js';
+/**
+ * Options for useFlowQuery hook
+ */
+export interface UseFlowQueryOptions {
+    /** Skip query execution */
+    skip?: boolean;
+    /** Debounce delay in milliseconds */
+    debounceMs?: number;
+    /** Callback when query completes successfully */
+    onComplete?: (data: FlowChartData) => void;
+    /** Callback when query fails */
+    onError?: (error: Error) => void;
+}
+/**
+ * Result from useFlowQuery hook
+ */
+export interface UseFlowQueryResult {
+    /** Transformed flow chart data (nodes and links) */
+    data: FlowChartData | null;
+    /** Raw data from server */
+    rawData: unknown[] | null;
+    /** Cache metadata when served from cache */
+    cacheInfo?: {
+        hit: true;
+        cachedAt: string;
+        ttlMs: number;
+        ttlRemainingMs: number;
+    } | null;
+    /** Is initial load in progress */
+    isLoading: boolean;
+    /** Is refetch in progress */
+    isFetching: boolean;
+    /** Is waiting for debounce */
+    isDebouncing: boolean;
+    /** Is executing (loading or fetching) */
+    isExecuting: boolean;
+    /** Error if query failed */
+    error: Error | null;
+    /** Refetch the query. Pass { bustCache: true } to bypass client and server caches. */
+    refetch: (options?: {
+        bustCache?: boolean;
+    }) => void;
+    /** Reset the query cache */
+    reset: () => void;
+    /** The server query being executed */
+    serverQuery: ServerFlowQuery | null;
+    /**
+     * Whether the query needs to be refreshed (manual refresh mode only).
+     * True when the current flow config differs from the last executed query.
+     */
+    needsRefresh: boolean;
+}
+/**
+ * Hook for server-side flow query execution
+ *
+ * Usage:
+ * ```tsx
+ * const { data, isLoading, error } = useFlowQuery(serverFlowQuery, {
+ *   debounceMs: 300,
+ *   skip: !isConfigured
+ * })
+ *
+ * // Results available after single server request
+ * <SankeyChart data={data} />
+ * ```
+ */
+export declare function useFlowQuery(query: ServerFlowQuery | null, options?: UseFlowQueryOptions): UseFlowQueryResult;
+/**
+ * Create a stable query key for flow queries
+ */
+export declare function createFlowQueryKey(query: ServerFlowQuery | null): readonly unknown[];

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

@@ -0,0 +1,20 @@
+import { FunnelConfig, UseFunnelQueryOptions, UseFunnelQueryResult } from '../../types/funnel.js';
+/**
+ * Hook for server-side funnel query execution
+ *
+ * Usage:
+ * ```tsx
+ * const { chartData, isExecuting, error } = useFunnelQuery(config, {
+ *   debounceMs: 300,
+ *   skip: !hasBindingKey
+ * })
+ *
+ * // Results available after single server request
+ * <FunnelChart data={chartData} />
+ * ```
+ */
+export declare function useFunnelQuery(config: FunnelConfig | null, options?: UseFunnelQueryOptions): UseFunnelQueryResult;
+/**
+ * Create a stable query key for funnel queries
+ */
+export declare function createFunnelQueryKey(config: FunnelConfig | null): readonly unknown[];

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

@@ -0,0 +1,70 @@
+import { MultiQueryConfig, CubeResultSet } from '../../types.js';
+/**
+ * Create a stable query key for multi-query
+ */
+export declare function createMultiQueryKey(config: MultiQueryConfig | null): readonly unknown[];
+export interface UseMultiCubeLoadQueryOptions {
+    /**
+     * 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;
+}
+export interface UseMultiCubeLoadQueryResult {
+    /** Merged data from all queries */
+    data: unknown[] | null;
+    /** Individual result sets from each query */
+    resultSets: (CubeResultSet | null)[] | null;
+    /** Per-query raw data */
+    perQueryData: (unknown[] | null)[] | null;
+    /** Whether any query is still loading (initial load) */
+    isLoading: boolean;
+    /** Whether any query is fetching (includes refetch) */
+    isFetching: boolean;
+    /** Whether query is debouncing (waiting for user to stop typing) */
+    isDebouncing: boolean;
+    /** First error encountered */
+    error: Error | null;
+    /** Per-query errors */
+    errors: (Error | null)[];
+    /** The debounced config that was executed */
+    debouncedConfig: MultiQueryConfig | null;
+    /** Whether the current config is valid */
+    isValidConfig: boolean;
+    /** Manually refetch the data. Pass { bustCache: true } to bypass client and server caches. */
+    refetch: (options?: {
+        bustCache?: boolean;
+    }) => void;
+}
+/**
+ * TanStack Query hook for loading multi-cube data with debouncing
+ *
+ * Usage:
+ * ```tsx
+ * const { data, isLoading, error } = useMultiCubeLoadQuery(config, {
+ *   debounceMs: 300,
+ *   skip: !isMultiQueryMode
+ * })
+ * ```
+ */
+export declare function useMultiCubeLoadQuery(config: MultiQueryConfig | null, options?: UseMultiCubeLoadQueryOptions): UseMultiCubeLoadQueryResult;

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

@@ -0,0 +1,67 @@
+import { ServerRetentionQuery, RetentionChartData, RetentionResultRow } from '../../types/retention.js';
+/**
+ * Options for retention query hook
+ */
+export interface UseRetentionQueryOptions {
+    /** Skip execution */
+    skip?: boolean;
+    /** Debounce delay in milliseconds */
+    debounceMs?: number;
+    /** Callback when query completes */
+    onComplete?: (result: RetentionChartData) => void;
+    /** Callback when query fails */
+    onError?: (error: Error) => void;
+    /** Function to resolve field names to human-readable display labels */
+    getFieldLabel?: (fieldName: string) => string;
+}
+/**
+ * Result from retention query hook
+ */
+export interface UseRetentionQueryResult {
+    /** Retention chart data */
+    chartData: RetentionChartData | null;
+    /** Raw data rows from server */
+    rawData: RetentionResultRow[] | null;
+    /** Current execution status */
+    status: 'idle' | 'loading' | 'success' | 'error';
+    /** Whether currently loading */
+    isLoading: boolean;
+    /** Whether fetching (includes refetch) */
+    isFetching: boolean;
+    /** Whether waiting for debounce */
+    isDebouncing: boolean;
+    /** Error if execution failed */
+    error: Error | null;
+    /** Cache metadata when served from cache */
+    cacheInfo?: {
+        hit: true;
+        cachedAt: string;
+        ttlMs: number;
+        ttlRemainingMs: number;
+    } | null;
+    /** Execute the query (for manual refresh mode) */
+    execute: (options?: {
+        bustCache?: boolean;
+    }) => Promise<RetentionChartData | null>;
+    /** Refetch the query */
+    refetch: () => 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;
+}
+/**
+ * Hook for server-side retention query execution
+ *
+ * Usage:
+ * ```tsx
+ * const { chartData, isLoading, error } = useRetentionQuery(serverQuery, {
+ *   debounceMs: 300,
+ *   skip: !hasRequiredFields
+ * })
+ *
+ * <RetentionHeatmap data={chartData} />
+ * ```
+ */
+export declare function useRetentionQuery(serverQuery: ServerRetentionQuery | null, options?: UseRetentionQueryOptions): UseRetentionQueryResult;

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

@@ -0,0 +1,60 @@
+import { PortletBlock, MarkdownBlock } from '../stores/notebookStore.js';
+export interface UseAgentChatOptions {
+    /** 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;
+    /** Called when agent adds a portlet to the notebook */
+    onAddPortlet: (data: PortletBlock) => void;
+    /** Called when agent adds a markdown block to the notebook */
+    onAddMarkdown: (data: MarkdownBlock) => void;
+    /** Called when the agent saves a dashboard configuration */
+    onDashboardSaved?: (data: {
+        title: string;
+        description?: string;
+        dashboardConfig: any;
+    }) => void;
+    /** Called when streaming text arrives */
+    onTextDelta: (text: string) => void;
+    /** Called when a tool call starts */
+    onToolStart: (id: string, name: string, input?: unknown) => void;
+    /** Called when a tool call completes */
+    onToolResult: (id: string, name: string, result?: unknown, isError?: boolean) => void;
+    /** Called when the agent completes with session ID and optional trace ID */
+    onDone: (sessionId: string, traceId?: string) => void;
+    /** Called when a turn completes (between agentic turns) */
+    onTurnComplete?: () => void;
+    /** Called on error */
+    onError: (message: string) => void;
+}
+/** Simplified message format for sending conversation history */
+export interface AgentHistoryMessage {
+    role: 'user' | 'assistant';
+    content: string;
+    toolCalls?: Array<{
+        id: string;
+        name: string;
+        input?: unknown;
+        result?: unknown;
+        status: 'running' | 'complete' | 'error';
+    }>;
+}
+export interface UseAgentChatResult {
+    /** Send a message to the agent, optionally with prior conversation history */
+    sendMessage: (content: string, sessionId?: string | null, history?: AgentHistoryMessage[]) => Promise<void>;
+    /** Whether the agent is currently streaming */
+    isStreaming: boolean;
+    /** Abort the current stream */
+    abort: () => void;
+}
+/**
+ * Hook for streaming chat with the agentic notebook backend.
+ * Uses fetch() with ReadableStream to consume SSE events.
+ */
+export declare function useAgentChat(options: UseAgentChatOptions): UseAgentChatResult;

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

@@ -0,0 +1,56 @@
+import { AnalysisBuilderState, AIState } from '../components/AnalysisBuilder/types.js';
+import { ChartType, ChartAxisConfig, ChartDisplayConfig } from '../types.js';
+import { ServerFunnelQuery } from '../types/funnel.js';
+import { AnalysisType, AnalysisConfig } from '../types/analysisConfig.js';
+interface UseAnalysisAIOptions {
+    /** Current state for snapshotting */
+    state: AnalysisBuilderState;
+    /** Set state function for applying AI-generated queries */
+    setState: (updater: (prev: AnalysisBuilderState) => AnalysisBuilderState) => void;
+    /** Current chart type */
+    chartType: ChartType;
+    /** Set chart type */
+    setChartType: (type: ChartType) => void;
+    /** Current chart config */
+    chartConfig: ChartAxisConfig;
+    /** Set chart config */
+    setChartConfig: (config: ChartAxisConfig) => void;
+    /** Current display config */
+    displayConfig: ChartDisplayConfig;
+    /** Set display config */
+    setDisplayConfig: (config: ChartDisplayConfig) => void;
+    /** Set whether user manually selected chart */
+    setUserManuallySelectedChart: (value: boolean) => void;
+    /** Set active view */
+    setActiveView: (view: 'table' | 'chart') => void;
+    /** AI endpoint URL */
+    aiEndpoint?: string;
+    /** Current analysis type */
+    analysisType?: AnalysisType;
+    /** Set analysis type (for switching to funnel mode) */
+    setAnalysisType?: (type: AnalysisType) => void;
+    /** Load funnel config from ServerFunnelQuery */
+    loadFunnelFromServerQuery?: (query: ServerFunnelQuery) => void;
+    /** Get full AnalysisConfig for snapshotting (for complete undo) */
+    getFullConfig?: () => AnalysisConfig;
+    /** Load full AnalysisConfig (for restoring on cancel) */
+    loadFullConfig?: (config: AnalysisConfig) => void;
+}
+interface UseAnalysisAIResult {
+    /** Current AI state */
+    aiState: AIState;
+    /** Open the AI panel */
+    handleOpenAI: () => void;
+    /** Close the AI panel */
+    handleCloseAI: () => void;
+    /** Update the AI prompt */
+    handleAIPromptChange: (prompt: string) => void;
+    /** Generate query from AI */
+    handleGenerateAI: () => Promise<void>;
+    /** Accept the AI-generated query */
+    handleAcceptAI: () => void;
+    /** Cancel and restore previous state */
+    handleCancelAI: () => void;
+}
+export declare function useAnalysisAI({ state, setState, chartType, setChartType, chartConfig, setChartConfig, displayConfig, setDisplayConfig, setUserManuallySelectedChart, setActiveView, aiEndpoint, analysisType, setAnalysisType, loadFunnelFromServerQuery, getFullConfig, loadFullConfig }: UseAnalysisAIOptions): UseAnalysisAIResult;
+export {};