drizzle-cube 0.6.1 → 0.6.2

package/dist/cjs/client/charts/chartComponentRegistry.d.ts

@@ -0,0 +1,46 @@
+import { ComponentType, LazyExoticComponent } from 'react';
+import { BuiltInChartType, ChartType, ChartProps } from '../types.js';
+export type LazyChartComponent = ComponentType<ChartProps>;
+export declare const chartLoaderCache: Map<ChartType, LazyExoticComponent<LazyChartComponent>>;
+export declare const failedChartTypes: Set<ChartType>;
+export declare const customChartMap: Map<string, LazyExoticComponent<LazyChartComponent>>;
+/**
+ * Maps chart types to their optional peer dependencies.
+ * Charts not listed here have no external dependencies (table, KPIs, markdown).
+ */
+export declare const chartDependencyMap: Partial<Record<BuiltInChartType, {
+    packageName: string;
+    installCommand: string;
+}>>;
+/**
+ * Creates a fallback component for an unknown/unregistered chart type.
+ */
+export declare function createUnknownChartFallback(chartType: string): LazyChartComponent;
+/**
+ * Creates a fallback component for a chart type with missing dependencies.
+ */
+export declare function createFallbackComponent(chartType: ChartType): LazyChartComponent;
+/**
+ * Wraps a chart import function with error handling.
+ * If the import fails (e.g., missing dependency), returns a fallback component.
+ */
+export declare function createSafeImport(chartType: ChartType, importFn: () => Promise<{
+    default: LazyChartComponent;
+}>): () => Promise<{
+    default: LazyChartComponent;
+}>;
+/**
+ * Register a custom chart component.
+ * Used by the chart plugin system.
+ */
+export declare function registerChartComponent(type: string, component?: ComponentType<ChartProps>, lazyComponent?: () => Promise<{
+    default: ComponentType<ChartProps>;
+}>, dependencies?: {
+    packageName: string;
+    installCommand: string;
+}): void;
+/**
+ * Unregister a custom chart component.
+ * Used by the chart plugin system.
+ */
+export declare function unregisterChartComponent(type: string): void;

package/dist/cjs/client/charts/chartConfigHelpers.d.ts

@@ -0,0 +1,38 @@
+import { ChartAvailabilityContext, ChartAvailability, DisplayOptionConfig } from './chartConfigs.js';
+/**
+ * Shared building blocks for chart `*.config.ts` files.
+ *
+ * Most chart configs repeated the same `isAvailable` guard and the same
+ * display-option definitions (target line, Y-axis format, stacking, …).
+ * These factories centralise that boilerplate so each chart config only
+ * declares what is genuinely unique to it.
+ */
+/**
+ * Standard availability rule shared by most chart types: at least one measure
+ * and at least one dimension (regular or time) must be selected.
+ */
+export declare function requiresMeasureAndDimension({ measureCount, dimensionCount }: ChartAvailabilityContext): ChartAvailability;
+/**
+ * Availability rule for charts that only need a single measure (KPI-style
+ * charts and gauges): at least one measure, no dimension requirement.
+ */
+export declare function requiresMeasure({ measureCount }: ChartAvailabilityContext): ChartAvailability;
+/** Target-line display option (single value or comma-separated spread). */
+export declare const targetDisplayOption: DisplayOptionConfig;
+/** Connect-nulls toggle for line/area charts. */
+export declare const connectNullsDisplayOption: DisplayOptionConfig;
+/** Left Y-axis numeric format control (dual-axis charts). */
+export declare const leftYAxisFormatDisplayOption: DisplayOptionConfig;
+/** Right Y-axis numeric format control (dual-axis charts). */
+export declare const rightYAxisFormatDisplayOption: DisplayOptionConfig;
+/**
+ * Single value-format control used by charts that only have one numeric scale
+ * (pie, radar, radial bar, treemap). Stored under `leftYAxisFormat` for
+ * backward compatibility with existing saved configs.
+ */
+export declare function valueFormatDisplayOption(description?: string): DisplayOptionConfig;
+/**
+ * Stacking-mode select shared by bar and area charts. `description` differs
+ * per chart (bar vs area series wording).
+ */
+export declare function stackTypeDisplayOption(description: string): DisplayOptionConfig;

package/dist/cjs/client/charts/chartConfigRegistry.d.ts

@@ -0,0 +1,15 @@
+import { ChartTypeConfig, ChartConfigRegistry } from './chartConfigs.js';
+/**
+ * Registry of all chart type configurations
+ */
+export declare const chartConfigRegistry: ChartConfigRegistry;
+/**
+ * Register a custom chart config into the registry.
+ * Used by the chart plugin system.
+ */
+export declare function registerChartConfig(type: string, config: ChartTypeConfig): void;
+/**
+ * Unregister a chart config from the registry.
+ * Used by the chart plugin system.
+ */
+export declare function unregisterChartConfig(type: string): void;

package/dist/cjs/client/charts/chartConfigs.d.ts

@@ -0,0 +1,142 @@
+/**
+ * Configuration for a single axis drop zone in the chart configuration UI
+ */
+export interface AxisDropZoneConfig {
+    /** The key to store this field in chartConfig (e.g., 'xAxis', 'yAxis', 'sizeField') */
+    key: string;
+    /** Display label for the drop zone */
+    label: string;
+    /** Optional description/help text shown below the label */
+    description?: string;
+    /** Whether at least one field is required in this drop zone */
+    mandatory?: boolean;
+    /** Maximum number of items allowed in this drop zone */
+    maxItems?: number;
+    /** Which field types this drop zone accepts */
+    acceptTypes?: ('dimension' | 'timeDimension' | 'measure')[];
+    /** Placeholder text when drop zone is empty */
+    emptyText?: string;
+    /** Enable L/R axis toggle for items in this drop zone (for dual Y-axis support) */
+    enableDualAxis?: boolean;
+}
+/**
+ * Configuration for a single display option
+ */
+export interface DisplayOptionConfig {
+    /** The key to store this field in displayConfig */
+    key: string;
+    /** Display label for the option */
+    label: string;
+    /** Type of input control to render */
+    type: 'boolean' | 'string' | 'number' | 'select' | 'color' | 'paletteColor' | 'axisFormat' | 'stringArray' | 'buttonGroup';
+    /** Default value for the option */
+    defaultValue?: any;
+    /** Placeholder text for string/number inputs */
+    placeholder?: string;
+    /** Options for select type */
+    options?: Array<{
+        value: any;
+        label: string;
+    }>;
+    /** Help text shown below the input */
+    description?: string;
+    /** Minimum value for number inputs */
+    min?: number;
+    /** Maximum value for number inputs */
+    max?: number;
+    /** Step value for number inputs */
+    step?: number;
+}
+/**
+ * Whether a chart type can be rendered with the current query shape.
+ * Each chart's .config.ts declares its own `isAvailable` to keep requirements
+ * co-located with the chart itself (rather than in a central switch).
+ */
+export interface ChartAvailability {
+    /** Whether the chart type can be used with the current selections */
+    available: boolean;
+    /** Translation key explaining why the chart is unavailable (for tooltip) */
+    reason?: string;
+}
+/**
+ * Snapshot of the current query shape passed to each chart's `isAvailable`.
+ */
+export interface ChartAvailabilityContext {
+    /** Number of measures selected */
+    measureCount: number;
+    /**
+     * Number of dimension-like breakdowns (regular dimensions + time dimensions).
+     * A time dimension can serve any role a regular dimension does (categories,
+     * axes, heatmap rows/columns, pie slices, etc.), so they are counted together.
+     */
+    dimensionCount: number;
+    /**
+     * Number of time dimensions specifically. Only needed by charts that *require*
+     * a time dimension (e.g. activityGrid).
+     */
+    timeDimensionCount: number;
+}
+/**
+ * Configuration for which elements in a chart support clicking (for drill-down)
+ */
+export interface ClickableElementsConfig {
+    /** Bars in bar charts */
+    bar?: boolean;
+    /** Points/dots in line/scatter charts */
+    point?: boolean;
+    /** Slices in pie/donut charts */
+    slice?: boolean;
+    /** Cells in heatmaps */
+    cell?: boolean;
+    /** Nodes in treemaps, sankey diagrams */
+    node?: boolean;
+    /** Areas in area charts */
+    area?: boolean;
+    /** Rows in data tables */
+    row?: boolean;
+}
+/**
+ * Complete configuration for a chart type
+ */
+export interface ChartTypeConfig {
+    /** Display label for the chart type in the picker (e.g., 'Bar Chart', 'KPI Number') */
+    label?: string;
+    /** Configuration for each drop zone */
+    dropZones: AxisDropZoneConfig[];
+    /** Simple display options (backward compatibility) - rendered as boolean checkboxes */
+    displayOptions?: string[];
+    /** Structured display options with metadata for different input types */
+    displayOptionsConfig?: DisplayOptionConfig[];
+    /** Optional custom validation function */
+    validate?: (config: any) => {
+        isValid: boolean;
+        message?: string;
+    };
+    /** Brief description of the chart */
+    description?: string;
+    /** When to use this chart type */
+    useCase?: string;
+    /** Whether this chart type skips query requirements (for content-based charts like markdown) */
+    skipQuery?: boolean;
+    /** Configuration for which elements support clicking (for drill-down) */
+    clickableElements?: ClickableElementsConfig;
+    /**
+     * Whether this chart type can render with the given query shape.
+     * Omit to mean "always available".
+     */
+    isAvailable?: (ctx: ChartAvailabilityContext) => ChartAvailability;
+}
+/**
+ * Registry of all chart type configurations
+ */
+export interface ChartConfigRegistry {
+    [chartType: string]: ChartTypeConfig;
+}
+/**
+ * Default configuration for charts without specific requirements
+ */
+export declare const defaultChartConfig: ChartTypeConfig;
+/**
+ * Helper function to get configuration for a chart type
+ */
+export declare function getChartConfig(chartType: string, registry: ChartConfigRegistry): ChartTypeConfig;

package/dist/cjs/client/charts/chartPlugin.d.ts

@@ -0,0 +1,74 @@
+import { ComponentType } from 'react';
+import { ChartProps } from '../types.js';
+import { ChartTypeConfig } from './chartConfigs.js';
+import { IconProps } from '../icons/types.js';
+/**
+ * Complete definition for registering a custom chart type.
+ * Bundles component, config metadata, and optional icon.
+ */
+export interface ChartDefinition {
+    /** Unique chart type identifier (e.g., 'myGantt', 'customBar') */
+    type: string;
+    /** Display label for the chart type picker */
+    label: string;
+    /** Chart type configuration (drop zones, display options, validation) */
+    config: ChartTypeConfig;
+    /** The chart component (eager — loaded immediately) */
+    component?: ComponentType<ChartProps>;
+    /** Lazy-loaded chart component (for code splitting). Use instead of `component`. */
+    lazyComponent?: () => Promise<{
+        default: ComponentType<ChartProps>;
+    }>;
+    /** Optional icon component for the chart type picker */
+    icon?: ComponentType<IconProps>;
+    /** Optional dependency info — shows install instructions if the import fails */
+    dependencies?: {
+        packageName: string;
+        installCommand: string;
+    };
+}
+/**
+ * Central registry for custom chart plugins.
+ *
+ * Coordinates registration across the three internal registries
+ * (config, lazy config cache, chart loader) and provides a
+ * `useSyncExternalStore`-compatible subscription API for React reactivity.
+ */
+declare class ChartPluginRegistry {
+    private customCharts;
+    private builtInBackups;
+    private iconMap;
+    private version;
+    private listeners;
+    /**
+     * Register a custom chart definition.
+     * If `type` matches a built-in chart, the built-in is backed up and can be
+     * restored by calling `unregister()`.
+     */
+    register(definition: ChartDefinition): void;
+    /**
+     * Unregister a custom chart.
+     * If the chart type was a built-in override, the original built-in is restored.
+     */
+    unregister(type: string): void;
+    /** Get the custom icon for a chart type, if registered */
+    getIcon(type: string): ComponentType<IconProps> | undefined;
+    /** Get all registered custom chart type strings */
+    getCustomTypes(): string[];
+    /** Check if a chart type is a custom plugin (not built-in) */
+    isCustom(type: string): boolean;
+    /**
+     * Subscribe to registry changes.
+     * Compatible with React's `useSyncExternalStore`.
+     */
+    subscribe: (listener: () => void) => (() => void);
+    /**
+     * Get a snapshot of the registry version.
+     * Compatible with React's `useSyncExternalStore`.
+     */
+    getSnapshot: () => number;
+    private bump;
+}
+/** Singleton chart plugin registry */
+export declare const chartPluginRegistry: ChartPluginRegistry;
+export {};

package/dist/cjs/client/charts/lazyChartConfigRegistry.d.ts

@@ -0,0 +1,100 @@
+import { ChartType } from '../types.js';
+import { ChartTypeConfig, ChartConfigRegistry } from './chartConfigs.js';
+/**
+ * Get a chart config asynchronously
+ *
+ * @param chartType The chart type to load config for
+ * @returns The chart type config, or null if not found
+ *
+ * @example
+ * ```typescript
+ * const config = await getChartConfigAsync('bar')
+ * console.log(config?.dropZones)
+ * ```
+ */
+export declare function getChartConfigAsync(chartType: ChartType): Promise<ChartTypeConfig | null>;
+/**
+ * Get a chart config synchronously from cache
+ *
+ * Returns the cached config if available, otherwise returns the default config.
+ * Use this when you need sync access and have already preloaded the config.
+ *
+ * @param chartType The chart type to get config for
+ * @returns The chart type config (from cache or default)
+ */
+export declare function getChartConfigSync(chartType: ChartType): ChartTypeConfig;
+/**
+ * Check if a chart config is already loaded
+ */
+export declare function isChartConfigLoaded(chartType: ChartType): boolean;
+/**
+ * React hook for using chart config
+ *
+ * Loads the chart config asynchronously and caches it.
+ * Returns the default config while loading.
+ *
+ * @param chartType The chart type to load config for
+ * @returns Object with config, loading state, and loaded flag
+ *
+ * @example
+ * ```tsx
+ * function ChartSetup({ chartType }) {
+ *   const { config, loading } = useChartConfig(chartType)
+ *
+ *   if (loading) return <Spinner />
+ *   return <ConfigForm config={config} />
+ * }
+ * ```
+ */
+export declare function useChartConfig(chartType: ChartType | undefined): {
+    config: ChartTypeConfig;
+    loading: boolean;
+    loaded: boolean;
+};
+/**
+ * Preload a chart config
+ *
+ * Triggers the async import without needing to use the config immediately.
+ * Useful for prefetching configs that will likely be needed.
+ *
+ * @param chartType The chart type to preload config for
+ */
+export declare function preloadChartConfig(chartType: ChartType): Promise<void>;
+/**
+ * Preload multiple chart configs
+ *
+ * @param chartTypes Array of chart types to preload
+ */
+export declare function preloadChartConfigs(chartTypes: ChartType[]): Promise<void>;
+/**
+ * Load all chart configs and return as a registry
+ *
+ * Useful for SSR or when you need all configs upfront.
+ * After calling this, all configs are cached and available synchronously.
+ *
+ * @returns Complete chart config registry
+ *
+ * @example
+ * ```typescript
+ * // On server or during initialization
+ * const registry = await loadAllChartConfigs()
+ * // Now all configs are cached and getChartConfigSync works for all types
+ * ```
+ */
+export declare function loadAllChartConfigs(): Promise<ChartConfigRegistry>;
+/**
+ * Clear the config cache
+ *
+ * Useful for testing or when configs need to be reloaded.
+ */
+export declare function clearChartConfigCache(): void;
+/**
+ * Register a custom chart config directly into the cache.
+ * Used by the chart plugin system.
+ */
+export declare function registerConfigToCache(type: string, config: ChartTypeConfig): void;
+/**
+ * Remove a custom chart config from the cache.
+ * Used by the chart plugin system.
+ */
+export declare function unregisterConfigFromCache(type: string): void;

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

@@ -0,0 +1,17 @@
+/**
+ * Drizzle Cube Chart Components
+ *
+ * Chart components only - optimized for applications that only need charts
+ * without the full dashboard or query builder functionality.
+ *
+ * For code splitting, use LazyChart instead of direct chart imports:
+ *   import { LazyChart, preloadCharts } from 'drizzle-cube/client/charts'
+ */
+export { RechartsBarChart, RechartsLineChart, RechartsAreaChart, RechartsPieChart, RechartsScatterChart, RechartsRadarChart, RechartsRadialBarChart, RechartsTreeMapChart, FunnelChart, DataTable } from './components/charts/index.js';
+export { LazyChart, preloadChart, preloadCharts, isValidChartType, getAvailableChartTypes, isChartTypeAvailable, getUnavailableChartTypes } from './charts/ChartLoader.js';
+export type { LazyChartProps } from './charts/ChartLoader.js';
+export { getChartConfigAsync, getChartConfigSync, useChartConfig, isChartConfigLoaded, preloadChartConfig, preloadChartConfigs, loadAllChartConfigs, clearChartConfigCache } from './charts/lazyChartConfigRegistry.js';
+export { formatChartData } from './utils/index.js';
+export { CHART_COLORS, POSITIVE_COLOR, NEGATIVE_COLOR, CHART_MARGINS } from './utils/chartConstants.js';
+export type { ChartType, ChartAxisConfig, ChartDisplayConfig } from './types.js';
+export type { ChartTypeConfig, DisplayOptionConfig, AxisDropZoneConfig } from './charts/chartConfigs.js';

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

@@ -0,0 +1,38 @@
+import { CubeQuery, CubeResultSet } from '../types.js';
+/**
+ * BatchCoordinator collects queries triggered in the same render cycle
+ * and sends them as a single batch request to minimize network overhead.
+ *
+ * Uses a configurable delay (default 100ms) to batch queries from lazy-loaded
+ * portlets that become visible during the same scroll action.
+ */
+export declare class BatchCoordinator {
+    private queue;
+    private flushScheduled;
+    private batchExecutor;
+    private delayMs;
+    constructor(batchExecutor: (queries: CubeQuery[]) => Promise<CubeResultSet[]>, delayMs?: number);
+    /**
+     * Register a query to be batched. Returns a promise that resolves
+     * when the batch is executed and this specific query's result is available.
+     */
+    register(query: CubeQuery): Promise<CubeResultSet>;
+    /**
+     * Schedule a flush after a short delay to collect multiple queries.
+     * The delay allows queries from lazy-loaded portlets that become visible
+     * during the same scroll action to be batched together.
+     */
+    private scheduleFlush;
+    /**
+     * Execute all queued queries as a batch and resolve individual promises
+     */
+    private flush;
+    /**
+     * Get current queue size (useful for debugging)
+     */
+    getQueueSize(): number;
+    /**
+     * Clear the queue (useful for testing/cleanup)
+     */
+    clear(): void;
+}

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

@@ -0,0 +1,32 @@
+import { CubeQuery, CubeApiOptions, CubeResultSet, ExplainResult, ExplainOptions } from '../types.js';
+export declare class CubeClient {
+    private apiUrl;
+    private headers;
+    private credentials;
+    constructor(token?: string, options?: CubeApiOptions);
+    load(query: CubeQuery, options?: {
+        bustCache?: boolean;
+    }): Promise<CubeResultSet>;
+    meta(): Promise<any>;
+    sql(query: CubeQuery): Promise<any>;
+    dryRun(query: CubeQuery): Promise<any>;
+    /**
+     * Execute EXPLAIN on a query to get the execution plan
+     * Returns normalized plan across PostgreSQL, MySQL, and SQLite
+     * Accepts standard queries, funnel queries ({ funnel: {...} }), or flow queries ({ flow: {...} })
+     */
+    explain(query: CubeQuery | unknown, options?: ExplainOptions): Promise<ExplainResult>;
+    /**
+     * Execute multiple queries in a single batch request
+     * Used by BatchCoordinator to optimize network requests
+     * Pass { bustCache: true } to bypass server-side cache
+     */
+    batchLoad(queries: CubeQuery[], options?: {
+        bustCache?: boolean;
+    }): Promise<CubeResultSet[]>;
+}
+/**
+ * Factory function to create a cube client
+ */
+export declare function createCubeClient(token?: string, options?: CubeApiOptions): CubeClient;
+export declare function cube(token?: string, options?: CubeApiOptions): CubeClient;

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

@@ -0,0 +1,11 @@
+/**
+ * Constants for AI Assistant
+ */
+export declare const AI_PROXY_BASE_URL = "/api/ai";
+export declare const GEMINI_MODEL = "gemini-2.0-flash";
+export declare const DEFAULT_SYSTEM_PROMPT_TEMPLATE = "You are a SQL query builder assistant for a semantic layer using Cube.js format.\n\nAvailable cube schema (JSON):\n{CUBE_SCHEMA}\n\nA valid Cube schema can contain things such as below (this is only an example of possible options):\n\n{\n  \"measures\": [\"stories.count\"],\n  \"dimensions\": [\"stories.category\"],\n  \"filters\": [\n    {\n      \"member\": \"stories.isDraft\",\n      \"operator\": \"equals\",\n      \"values\": [\"No\"]\n    }\n  ],\n  \"timeDimensions\": [\n    {\n      \"dimension\": \"stories.time\",\n      \"dateRange\": [\"2015-01-01\", \"2015-12-31\"],\n      \"granularity\": \"month\"\n    }\n  ],\n  \"limit\": 100,\n  \"offset\": 50,\n  \"order\": {\n    \"stories.time\": \"asc\",\n    \"stories.count\": \"desc\"\n  }\n}\n\nUser request: {USER_PROMPT}\n\nCRITICAL: You MUST only use field names that exist in the schema above. Do NOT create or invent field names.\n\nGenerate a JSON query object with this structure:\n{\n  \"measures\": [\"CubeName.measureName\"],\n  \"dimensions\": [\"CubeName.dimensionName\"], \n  \"timeDimensions\": [{\n    \"dimension\": \"CubeName.timeDimensionName\",\n    \"granularity\": \"hour|day|week|month|quarter|year\",\n    \"dateRange\": \"last 30 days\"\n  }],\n  \"filters\": [{\n    \"member\": \"CubeName.fieldName\",\n    \"operator\": \"equals|contains|gt|gte|lt|lte|inDateRange\",\n    \"values\": [\"value1\", \"value2\"]\n  }]\n}\n\nRules:\n1. Only use cube names, measure names, and dimension names from the schema\n2. All field references must be in \"CubeName.fieldName\" format\n3. Verify every field exists in the provided schema before using it\n\nRespond with only the JSON query object, no explanation, no markdown formatting, no code blocks, no backtick wrapper.";
+export declare const AI_STORAGE_KEY = "drizzle-cube-ai-config";
+export declare const DEFAULT_AI_CONFIG: {
+    provider: "gemini";
+    apiKey: string;
+};

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

@@ -0,0 +1,10 @@
+/**
+ * AI Assistant utilities export
+ *
+ * Note: AIAssistantModal has been deprecated and removed.
+ * The inline AI panel in AnalysisBuilder uses useAnalysisAI hook which
+ * depends on these utilities.
+ */
+export * from './types.js';
+export * from './constants.js';
+export * from './utils.js';

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

@@ -0,0 +1,49 @@
+/**
+ * Types for AI Assistant functionality
+ */
+export interface AIQueryRequest {
+    text: string;
+}
+export interface GeminiMessageResponse {
+    candidates: Array<{
+        content: {
+            parts: Array<{
+                text: string;
+            }>;
+        };
+        finishReason: string;
+        index: number;
+    }>;
+    usageMetadata: {
+        promptTokenCount: number;
+        candidatesTokenCount: number;
+        totalTokenCount: number;
+    };
+}
+export interface AIQueryResponse {
+    query: string;
+    rateLimit?: {
+        usingServerKey: boolean;
+        dailyLimit: number;
+    };
+}
+export interface AIConfig {
+    provider: 'gemini';
+    apiKey: string;
+}
+export interface AIAssistantState {
+    step: 'api-key' | 'query';
+    apiKey: string;
+    systemPromptTemplate: string;
+    userPrompt: string;
+    isSubmitting: boolean;
+    response: string | null;
+    responseError: string | null;
+    isValidating: boolean;
+    validationResult: 'valid' | 'invalid' | null;
+    validationError: string | null;
+}
+export interface SystemPromptVariables {
+    CUBE_SCHEMA: string;
+    USER_PROMPT: string;
+}

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

@@ -0,0 +1,17 @@
+import { AIQueryResponse, AIConfig } from './types.js';
+/**
+ * Send a user prompt to AI proxy (server builds system prompt)
+ */
+export declare function sendGeminiMessage(apiKey: string, userPrompt: string, endpoint?: string, providerHeaders?: Record<string, string>): Promise<AIQueryResponse>;
+/**
+ * Save AI configuration to localStorage
+ */
+export declare function saveAIConfig(config: AIConfig): void;
+/**
+ * Load AI configuration from localStorage
+ */
+export declare function loadAIConfig(): AIConfig;
+/**
+ * Extract query text from simplified AI response and clean up formatting
+ */
+export declare function extractTextFromResponse(response: AIQueryResponse): string;

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

@@ -0,0 +1,27 @@
+import { default as React } from 'react';
+interface AgentChatPanelProps {
+    agentEndpoint?: string;
+    agentApiKey?: string;
+    agentProvider?: string;
+    agentModel?: string;
+    agentProviderEndpoint?: string;
+    onClear?: () => void;
+    /** 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) */
+    onScore?: (data: {
+        traceId: string;
+        value: number;
+        comment?: string;
+    }) => void;
+    /** Custom loading indicator for tool call spinners */
+    loadingComponent?: React.ReactNode;
+    /** Initial prompt to auto-send on mount */
+    initialPrompt?: string;
+}
+declare const AgentChatPanel: React.NamedExoticComponent<AgentChatPanelProps>;
+export default AgentChatPanel;

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

@@ -0,0 +1,14 @@
+import { default as React } from 'react';
+interface ChatInputProps {
+    value: string;
+    onChange: (value: string) => void;
+    onSend: () => void;
+    onStop?: () => void;
+    onContinue?: () => void;
+    isStreaming?: boolean;
+    showContinue?: boolean;
+    disabled?: boolean;
+    placeholder?: string;
+}
+declare const ChatInput: React.NamedExoticComponent<ChatInputProps>;
+export default ChatInput;

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

@@ -0,0 +1,9 @@
+import { default as React } from 'react';
+import { ChatMessage as ChatMessageType } from '../../stores/notebookStore.js';
+interface ChatMessageProps {
+    message: ChatMessageType;
+    /** Custom loading indicator for tool call spinners */
+    loadingComponent?: React.ReactNode;
+}
+declare const ChatMessage: React.NamedExoticComponent<ChatMessageProps>;
+export default ChatMessage;

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

@@ -0,0 +1,6 @@
+import { default as React } from 'react';
+import { ColorPalette } from '../../utils/colorPalettes.js';
+declare const NotebookCanvas: React.NamedExoticComponent<{
+    colorPalette?: ColorPalette;
+}>;
+export default NotebookCanvas;