drizzle-cube 0.6.0 → 0.6.2

package/dist/cjs/client/stores/dashboardStore.d.ts

@@ -0,0 +1,292 @@
+import { ReactNode } from 'react';
+import { StoreApi } from 'zustand';
+import { LayoutItem } from 'react-grid-layout';
+import { PortletConfig, RowLayout, ChartType, ChartAxisConfig, ChartDisplayConfig, CubeQuery } from '../types.js';
+import { FlowChartData } from '../types/flow.js';
+import { RetentionChartData } from '../types/retention.js';
+/**
+ * Debug data entry for a portlet (used by chart inspector)
+ */
+export interface PortletDebugDataEntry {
+    chartConfig: ChartAxisConfig;
+    displayConfig: ChartDisplayConfig;
+    queryObject: CubeQuery | null;
+    data: unknown[] | FlowChartData | RetentionChartData;
+    chartType: ChartType;
+    cacheInfo?: {
+        hit: boolean;
+        cachedAt: string;
+        ttlMs: number;
+        ttlRemainingMs: number;
+    } | null;
+}
+/**
+ * @deprecated Use PortletDebugDataEntry instead. Kept for backward compatibility.
+ */
+export type DebugDataEntry = PortletDebugDataEntry;
+/**
+ * Drag state for row-based layout
+ */
+export interface DragState {
+    rowIndex: number;
+    colIndex: number;
+    portletId: string;
+}
+/**
+ * Complete store state interface
+ */
+export interface DashboardStoreState {
+    /** Whether dashboard is in edit mode */
+    isEditMode: boolean;
+    /** Currently selected filter ID for filter-assignment mode */
+    selectedFilterId: string | null;
+    /** Whether portlet edit modal is open */
+    isPortletModalOpen: boolean;
+    /** Portlet being edited (null = adding new) */
+    editingPortlet: PortletConfig | null;
+    /** Whether filter config modal is open */
+    isFilterConfigModalOpen: boolean;
+    /** Portlet for filter configuration */
+    filterConfigPortlet: PortletConfig | null;
+    /** Portlet ID pending delete confirmation (null = no confirmation active) */
+    deleteConfirmPortletId: string | null;
+    /** Whether text portlet modal is open */
+    isTextModalOpen: boolean;
+    /** Portlet being edited in text modal (null = adding new) */
+    editingTextPortlet: PortletConfig | null;
+    /** Draft row layout during drag operations (rows mode) */
+    draftRows: RowLayout[] | null;
+    /** Whether a portlet is currently being dragged */
+    isDraggingPortlet: boolean;
+    /** Last known layout for change detection */
+    lastKnownLayout: LayoutItem[];
+    /** Whether component has been initialized (prevents saves during load) */
+    isInitialized: boolean;
+    /** Current drag state for row-based layout */
+    dragState: DragState | null;
+    /** Debug data keyed by portlet ID (for chart inspector) */
+    debugData: Record<string, DebugDataEntry>;
+    /** Whether the dashboard has been modified and needs a new thumbnail */
+    thumbnailDirty: boolean;
+}
+/**
+ * Store actions interface
+ */
+export interface DashboardStoreActions {
+    /** Set edit mode */
+    setEditMode: (isEdit: boolean) => void;
+    /** Toggle edit mode */
+    toggleEditMode: () => void;
+    /** Set selected filter ID for filter selection mode */
+    setSelectedFilterId: (filterId: string | null) => void;
+    /** Exit filter selection mode */
+    exitFilterSelectionMode: () => void;
+    /** Open portlet modal (optionally with a portlet to edit) */
+    openPortletModal: (portlet?: PortletConfig | null) => void;
+    /** Close portlet modal */
+    closePortletModal: () => void;
+    /** Open filter config modal for a portlet */
+    openFilterConfigModal: (portlet: PortletConfig) => void;
+    /** Close filter config modal */
+    closeFilterConfigModal: () => void;
+    /** Open text portlet modal (optionally with a portlet to edit) */
+    openTextModal: (portlet?: PortletConfig | null) => void;
+    /** Close text portlet modal */
+    closeTextModal: () => void;
+    /** Open delete confirmation for a portlet */
+    openDeleteConfirm: (portletId: string) => void;
+    /** Close delete confirmation */
+    closeDeleteConfirm: () => void;
+    /** Set draft rows during drag operations */
+    setDraftRows: (rows: RowLayout[] | null) => void;
+    /** Set whether a portlet is being dragged */
+    setIsDraggingPortlet: (isDragging: boolean) => void;
+    /** Set last known layout for change detection */
+    setLastKnownLayout: (layout: LayoutItem[]) => void;
+    /** Set whether component is initialized */
+    setIsInitialized: (initialized: boolean) => void;
+    /** Set drag state */
+    setDragState: (state: DragState | null) => void;
+    /** Clear drag state */
+    clearDragState: () => void;
+    /** Set debug data for a portlet */
+    setDebugData: (portletId: string, data: DebugDataEntry) => void;
+    /** Clear debug data for a portlet (or all if no portletId) */
+    clearDebugData: (portletId?: string) => void;
+    /** Set thumbnail dirty state (needs new capture) */
+    setThumbnailDirty: (dirty: boolean) => void;
+    /** Reset store to initial state */
+    reset: () => void;
+}
+/**
+ * Combined store type
+ */
+export type DashboardStore = DashboardStoreState & DashboardStoreActions;
+/**
+ * Options for creating a store instance
+ */
+export interface CreateDashboardStoreOptions {
+    /** Initial edit mode state */
+    initialEditMode?: boolean;
+}
+/**
+ * Create a new dashboard store instance
+ */
+export declare function createDashboardStore(options?: CreateDashboardStoreOptions): Omit<Omit<StoreApi<DashboardStore>, "setState" | "devtools"> & {
+    setState(partial: DashboardStore | Partial<DashboardStore> | ((state: DashboardStore) => DashboardStore | Partial<DashboardStore>), replace?: false | undefined, action?: (string | {
+        [x: string]: unknown;
+        [x: number]: unknown;
+        [x: symbol]: unknown;
+        type: string;
+    }) | undefined): void;
+    setState(state: DashboardStore | ((state: DashboardStore) => DashboardStore), replace: true, action?: (string | {
+        [x: string]: unknown;
+        [x: number]: unknown;
+        [x: symbol]: unknown;
+        type: string;
+    }) | undefined): void;
+    devtools: {
+        cleanup: () => void;
+    };
+}, "subscribe"> & {
+    subscribe: {
+        (listener: (selectedState: DashboardStore, previousSelectedState: DashboardStore) => void): () => void;
+        <U>(selector: (state: DashboardStore) => U, listener: (selectedState: U, previousSelectedState: U) => void, options?: {
+            equalityFn?: ((a: U, b: U) => boolean) | undefined;
+            fireImmediately?: boolean;
+        } | undefined): () => void;
+    };
+};
+/**
+ * Provider props
+ */
+export interface DashboardStoreProviderProps {
+    children: ReactNode;
+    /** Initial edit mode state */
+    initialEditMode?: boolean;
+}
+/**
+ * Provider component that creates a store instance per Dashboard
+ */
+export declare function DashboardStoreProvider({ children, initialEditMode, }: DashboardStoreProviderProps): import("react").JSX.Element;
+/**
+ * Hook to access the store from context
+ * @throws Error if used outside of provider
+ */
+export declare function useDashboardStore<T>(selector: (state: DashboardStore) => T): T;
+/**
+ * Hook to get the raw store API (for actions that need direct access)
+ */
+export declare function useDashboardStoreApi(): StoreApi<DashboardStore>;
+/**
+ * Optional hook that returns null if used outside provider (for optional store access)
+ * Uses a fallback store to ensure useStore is always called (React hooks rules compliance)
+ */
+export declare function useDashboardStoreOptional<T>(selector: (state: DashboardStore) => T): T | null;
+/**
+ * Select edit mode state
+ */
+export declare const selectEditModeState: (state: DashboardStore) => {
+    isEditMode: boolean;
+    selectedFilterId: string | null;
+};
+/**
+ * Select modal state
+ */
+export declare const selectModalState: (state: DashboardStore) => {
+    isPortletModalOpen: boolean;
+    editingPortlet: PortletConfig | null;
+    isFilterConfigModalOpen: boolean;
+    filterConfigPortlet: PortletConfig | null;
+    isTextModalOpen: boolean;
+    editingTextPortlet: PortletConfig | null;
+};
+/**
+ * Select layout state
+ */
+export declare const selectLayoutState: (state: DashboardStore) => {
+    draftRows: RowLayout[] | null;
+    isDraggingPortlet: boolean;
+    lastKnownLayout: LayoutItem[];
+    isInitialized: boolean;
+    dragState: DragState | null;
+};
+/**
+ * Select debug data
+ */
+export declare const selectDebugData: (state: DashboardStore) => Record<string, PortletDebugDataEntry>;
+/**
+ * Select debug data for a specific portlet
+ */
+export declare const selectPortletDebugData: (portletId: string) => (state: DashboardStore) => PortletDebugDataEntry;
+/**
+ * Select all edit mode actions
+ */
+export declare const selectEditModeActions: (state: DashboardStore) => {
+    setEditMode: (isEdit: boolean) => void;
+    toggleEditMode: () => void;
+    setSelectedFilterId: (filterId: string | null) => void;
+    exitFilterSelectionMode: () => void;
+};
+/**
+ * Select all modal actions
+ */
+export declare const selectModalActions: (state: DashboardStore) => {
+    openPortletModal: (portlet?: PortletConfig | null) => void;
+    closePortletModal: () => void;
+    openTextModal: (portlet?: PortletConfig | null) => void;
+    closeTextModal: () => void;
+    openFilterConfigModal: (portlet: PortletConfig) => void;
+    closeFilterConfigModal: () => void;
+    openDeleteConfirm: (portletId: string) => void;
+    closeDeleteConfirm: () => void;
+};
+/**
+ * Select all layout actions
+ */
+export declare const selectLayoutActions: (state: DashboardStore) => {
+    setDraftRows: (rows: RowLayout[] | null) => void;
+    setIsDraggingPortlet: (isDragging: boolean) => void;
+    setLastKnownLayout: (layout: LayoutItem[]) => void;
+    setIsInitialized: (initialized: boolean) => void;
+    setDragState: (state: DragState | null) => void;
+    clearDragState: () => void;
+};
+/**
+ * Select all debug data actions
+ */
+export declare const selectDebugDataActions: (state: DashboardStore) => {
+    setDebugData: (portletId: string, data: DebugDataEntry) => void;
+    clearDebugData: (portletId?: string) => void;
+};
+/**
+ * Select thumbnail dirty state
+ */
+export declare const selectThumbnailDirty: (state: DashboardStore) => boolean;
+/**
+ * Select all actions
+ */
+export declare const selectAllActions: (state: DashboardStore) => {
+    setEditMode: (isEdit: boolean) => void;
+    toggleEditMode: () => void;
+    setSelectedFilterId: (filterId: string | null) => void;
+    exitFilterSelectionMode: () => void;
+    openPortletModal: (portlet?: PortletConfig | null) => void;
+    closePortletModal: () => void;
+    openTextModal: (portlet?: PortletConfig | null) => void;
+    closeTextModal: () => void;
+    openFilterConfigModal: (portlet: PortletConfig) => void;
+    closeFilterConfigModal: () => void;
+    openDeleteConfirm: (portletId: string) => void;
+    closeDeleteConfirm: () => void;
+    setDraftRows: (rows: RowLayout[] | null) => void;
+    setIsDraggingPortlet: (isDragging: boolean) => void;
+    setLastKnownLayout: (layout: LayoutItem[]) => void;
+    setIsInitialized: (initialized: boolean) => void;
+    setDragState: (state: DragState | null) => void;
+    clearDragState: () => void;
+    setDebugData: (portletId: string, data: DebugDataEntry) => void;
+    clearDebugData: (portletId?: string) => void;
+    setThumbnailDirty: (dirty: boolean) => void;
+    reset: () => void;
+};

package/dist/cjs/client/stores/dataBrowserStore.d.ts

@@ -0,0 +1,34 @@
+import { ReactNode } from 'react';
+import { Filter } from '../types.js';
+export interface DataBrowserStore {
+    selectedCube: string | null;
+    visibleColumns: string[];
+    sortColumn: string | null;
+    sortDirection: 'asc' | 'desc';
+    page: number;
+    pageSize: number;
+    filters: Filter[];
+    showFilterBar: boolean;
+    showColumnPicker: boolean;
+    columnWidths: Record<string, number>;
+    selectCube: (cubeName: string, allDimensions: string[]) => void;
+    setVisibleColumns: (columns: string[]) => void;
+    toggleColumn: (column: string) => void;
+    setSort: (column: string) => void;
+    clearSort: () => void;
+    setPage: (page: number) => void;
+    setPageSize: (size: number) => void;
+    setFilters: (filters: Filter[]) => void;
+    toggleFilterBar: () => void;
+    setShowColumnPicker: (show: boolean) => void;
+    setColumnWidth: (column: string, width: number) => void;
+    setColumnWidths: (widths: Record<string, number>) => void;
+}
+export interface DataBrowserStoreProviderProps {
+    children: ReactNode;
+    defaultPageSize?: number;
+    defaultCube?: string;
+    defaultColumns?: string[];
+}
+export declare function DataBrowserStoreProvider({ children, defaultPageSize, defaultCube, defaultColumns, }: DataBrowserStoreProviderProps): import("react").JSX.Element;
+export declare function useDataBrowserStore<T>(selector: (state: DataBrowserStore) => T): T;

package/dist/cjs/client/stores/index.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Zustand Stores - Barrel Export
+ *
+ * Centralized state management stores for the drizzle-cube client.
+ *
+ * ARCHITECTURE: Instance-based stores
+ * - Each AnalysisBuilder/Dashboard gets its own Zustand store instance via Context
+ * - Use `*StoreProvider` to wrap components that need store access
+ * - Use `use*Store` hook to access state (must be inside provider)
+ */
+export { AnalysisBuilderStoreProvider, useAnalysisBuilderStore, useAnalysisBuilderStoreApi, createAnalysisBuilderStore, selectCurrentState, selectMetrics, selectBreakdowns, selectFilters, selectChartConfig, selectUIState, selectMultiQueryState, type AnalysisBuilderStore, type AnalysisBuilderStoreState, type AnalysisBuilderStoreActions, type FieldModalMode, type CreateStoreOptions, type AnalysisBuilderStoreProviderProps, type InitialFunnelState, type InitialFlowState, } from './analysisBuilderStore.js';
+export { DashboardStoreProvider, useDashboardStore, useDashboardStoreApi, useDashboardStoreOptional, createDashboardStore, selectEditModeState, selectModalState, selectLayoutState, selectDebugData, selectPortletDebugData, selectEditModeActions, selectModalActions, selectLayoutActions, selectDebugDataActions, selectAllActions, type DashboardStore, type DashboardStoreState, type DashboardStoreActions, type PortletDebugDataEntry, type DebugDataEntry as DashboardDebugDataEntry, // Alias to avoid conflict with hooks/queries
+type DragState, type CreateDashboardStoreOptions, type DashboardStoreProviderProps, } from './dashboardStore.js';

package/dist/cjs/client/stores/notebookStore.d.ts

@@ -0,0 +1,157 @@
+import { ReactNode } from 'react';
+import { StoreApi } from 'zustand';
+import { ChartType, ChartAxisConfig, ChartDisplayConfig } from '../types.js';
+/**
+ * A portlet block in the notebook
+ */
+export interface PortletBlock {
+    id: string;
+    type: 'portlet';
+    title: string;
+    query: string;
+    chartType: ChartType;
+    chartConfig?: ChartAxisConfig;
+    displayConfig?: ChartDisplayConfig;
+}
+/**
+ * A markdown text block in the notebook
+ */
+export interface MarkdownBlock {
+    id: string;
+    type: 'markdown';
+    title?: string;
+    content: string;
+}
+/**
+ * A block in the notebook canvas
+ */
+export type NotebookBlock = PortletBlock | MarkdownBlock;
+/**
+ * A tool call record for display in chat messages
+ */
+export interface ToolCallRecord {
+    id: string;
+    name: string;
+    input?: unknown;
+    result?: unknown;
+    status: 'running' | 'complete' | 'error';
+}
+/**
+ * A chat message
+ */
+export interface ChatMessage {
+    id: string;
+    role: 'user' | 'assistant';
+    content: string;
+    error?: string;
+    toolCalls?: ToolCallRecord[];
+    timestamp: number;
+}
+/**
+ * Serializable notebook config for save/load
+ */
+export interface NotebookConfig {
+    blocks: NotebookBlock[];
+    messages: ChatMessage[];
+}
+export interface NotebookStoreState {
+    /** Ordered array of notebook blocks */
+    blocks: NotebookBlock[];
+    /** Chat message history */
+    messages: ChatMessage[];
+    /** Whether the agent is currently streaming a response */
+    isStreaming: boolean;
+    /** Agent SDK session ID for multi-turn conversations */
+    sessionId: string | null;
+    /** Chat input value */
+    inputValue: string;
+}
+export interface NotebookStoreActions {
+    addBlock: (block: NotebookBlock) => void;
+    removeBlock: (id: string) => void;
+    moveBlock: (id: string, direction: 'up' | 'down') => void;
+    updateBlock: (id: string, updates: Partial<Omit<PortletBlock, 'id' | 'type'>>) => void;
+    addMessage: (message: ChatMessage) => void;
+    appendToLastAssistantMessage: (text: string) => void;
+    setLastAssistantError: (error: string) => void;
+    addToolCallToLastAssistant: (toolCall: ToolCallRecord) => void;
+    updateLastToolCall: (update: Partial<ToolCallRecord>) => void;
+    setIsStreaming: (streaming: boolean) => void;
+    setSessionId: (id: string | null) => void;
+    setInputValue: (value: string) => void;
+    save: () => NotebookConfig;
+    load: (config: NotebookConfig) => void;
+    reset: () => void;
+}
+/**
+ * Combined store type
+ */
+export type NotebookStore = NotebookStoreState & NotebookStoreActions;
+/**
+ * Create a new notebook store instance
+ */
+export declare function createNotebookStore(): Omit<Omit<StoreApi<NotebookStore>, "setState" | "devtools"> & {
+    setState(partial: NotebookStore | Partial<NotebookStore> | ((state: NotebookStore) => NotebookStore | Partial<NotebookStore>), replace?: false | undefined, action?: (string | {
+        [x: string]: unknown;
+        [x: number]: unknown;
+        [x: symbol]: unknown;
+        type: string;
+    }) | undefined): void;
+    setState(state: NotebookStore | ((state: NotebookStore) => NotebookStore), replace: true, action?: (string | {
+        [x: string]: unknown;
+        [x: number]: unknown;
+        [x: symbol]: unknown;
+        type: string;
+    }) | undefined): void;
+    devtools: {
+        cleanup: () => void;
+    };
+}, "subscribe"> & {
+    subscribe: {
+        (listener: (selectedState: NotebookStore, previousSelectedState: NotebookStore) => void): () => void;
+        <U>(selector: (state: NotebookStore) => U, listener: (selectedState: U, previousSelectedState: U) => void, options?: {
+            equalityFn?: ((a: U, b: U) => boolean) | undefined;
+            fireImmediately?: boolean;
+        } | undefined): () => void;
+    };
+};
+export interface NotebookStoreProviderProps {
+    children: ReactNode;
+    /** Initial config to load */
+    initialConfig?: NotebookConfig;
+}
+/**
+ * Provider component that creates a store instance per AgenticNotebook
+ */
+export declare function NotebookStoreProvider({ children, initialConfig, }: NotebookStoreProviderProps): import("react").JSX.Element;
+/**
+ * Hook to access the notebook store from context
+ * @throws Error if used outside of provider
+ */
+export declare function useNotebookStore<T>(selector: (state: NotebookStore) => T): T;
+export declare const selectBlocks: (state: NotebookStore) => NotebookBlock[];
+export declare const selectMessages: (state: NotebookStore) => ChatMessage[];
+export declare const selectIsStreaming: (state: NotebookStore) => boolean;
+export declare const selectSessionId: (state: NotebookStore) => string | null;
+export declare const selectInputValue: (state: NotebookStore) => string;
+export declare const selectChatState: (state: NotebookStore) => {
+    messages: ChatMessage[];
+    isStreaming: boolean;
+    inputValue: string;
+};
+export declare const selectChatActions: (state: NotebookStore) => {
+    addMessage: (message: ChatMessage) => void;
+    appendToLastAssistantMessage: (text: string) => void;
+    setLastAssistantError: (error: string) => void;
+    addToolCallToLastAssistant: (toolCall: ToolCallRecord) => void;
+    updateLastToolCall: (update: Partial<ToolCallRecord>) => void;
+    setIsStreaming: (streaming: boolean) => void;
+    setInputValue: (value: string) => void;
+    setSessionId: (id: string | null) => void;
+};
+export declare const selectBlockActions: (state: NotebookStore) => {
+    addBlock: (block: NotebookBlock) => void;
+    removeBlock: (id: string) => void;
+    moveBlock: (id: string, direction: "up" | "down") => void;
+    updateBlock: (id: string, updates: Partial<Omit<PortletBlock, "id" | "type">>) => void;
+};

package/dist/cjs/client/stores/optionsToAnalysisConfig.d.ts

@@ -0,0 +1,17 @@
+import { CubeQuery, MultiQueryConfig } from '../types.js';
+import { AnalysisBuilderState } from '../components/AnalysisBuilder/types.js';
+import { AnalysisConfig } from '../types/analysisConfig.js';
+import { CreateStoreOptions } from './analysisBuilderStore.js';
+/**
+ * Convert CubeQuery to AnalysisBuilderState
+ */
+export declare function queryToState(query: CubeQuery): AnalysisBuilderState;
+/**
+ * Check if config is MultiQueryConfig
+ */
+export declare function isMultiQueryConfig(config: CubeQuery | MultiQueryConfig): config is MultiQueryConfig;
+/**
+ * Convert store creation options to AnalysisConfig.
+ * Returns null if no meaningful options are provided (use defaults).
+ */
+export declare function optionsToAnalysisConfig(options: CreateStoreOptions): AnalysisConfig | null;

package/dist/cjs/client/stores/slices/coreSlice.d.ts

@@ -0,0 +1,96 @@
+import { StateCreator } from 'zustand';
+import { AnalysisBuilderStore } from '../analysisBuilderStore.js';
+import { AnalysisConfig, AnalysisType, ChartConfig, AnalysisWorkspace } from '../../types/analysisConfig.js';
+import { ChartType, ChartAxisConfig, ChartDisplayConfig } from '../../types.js';
+/**
+ * Core slice state
+ */
+export interface CoreSliceState {
+    /** Current analysis mode */
+    analysisType: AnalysisType;
+    /**
+     * Per-mode chart configuration map.
+     * Each mode owns its own chart settings.
+     * Phase 4: This is now the source of truth for all chart configuration.
+     */
+    charts: {
+        [K in AnalysisType]?: ChartConfig;
+    };
+    /**
+     * Per-mode active view (table or chart) map.
+     * Each mode owns its own view preference.
+     * This preserves view preference when switching between modes.
+     */
+    activeViews: {
+        [K in AnalysisType]?: 'table' | 'chart';
+    };
+    /** Whether user manually selected a chart type */
+    userManuallySelectedChart: boolean;
+    /** Color palette name */
+    localPaletteName: string;
+}
+/**
+ * Core slice actions
+ */
+export interface CoreSliceActions {
+    /** Set the analysis type (switches between Query/Funnel modes) */
+    setAnalysisType: (type: AnalysisType) => void;
+    /** Set chart type for current mode */
+    setChartType: (type: ChartType) => void;
+    /** Set chart type with manual selection flag */
+    setChartTypeManual: (type: ChartType) => void;
+    /** Set chart config for current mode */
+    setChartConfig: (config: ChartAxisConfig) => void;
+    /** Set display config for current mode */
+    setDisplayConfig: (config: ChartDisplayConfig) => void;
+    /** Set color palette name */
+    setLocalPaletteName: (name: string) => void;
+    /** Set user manually selected chart flag */
+    setUserManuallySelectedChart: (value: boolean) => void;
+    /**
+     * @deprecated Use setChartType() instead - works for any mode via charts map.
+     * This setter is kept for backward compatibility but will be removed in a future version.
+     */
+    setFunnelChartType: (type: ChartType) => void;
+    /**
+     * @deprecated Use setChartConfig() instead - works for any mode via charts map.
+     * This setter is kept for backward compatibility but will be removed in a future version.
+     */
+    setFunnelChartConfig: (config: ChartAxisConfig) => void;
+    /**
+     * @deprecated Use setDisplayConfig() instead - works for any mode via charts map.
+     * This setter is kept for backward compatibility but will be removed in a future version.
+     */
+    setFunnelDisplayConfig: (config: ChartDisplayConfig) => void;
+    /**
+     * Save current state to AnalysisConfig format.
+     * Delegates to the appropriate adapter based on analysisType.
+     * Use for share URLs and portlets (single-mode).
+     */
+    save: () => AnalysisConfig;
+    /**
+     * Load state from AnalysisConfig.
+     * Delegates to the appropriate adapter based on config.analysisType.
+     * Use for share URLs and portlets (single-mode).
+     */
+    load: (config: AnalysisConfig) => void;
+    /**
+     * Save ALL modes to AnalysisWorkspace format.
+     * Used for localStorage persistence to preserve state across mode switches.
+     */
+    saveWorkspace: () => AnalysisWorkspace;
+    /**
+     * Load ALL modes from AnalysisWorkspace.
+     * Used for localStorage persistence to restore state for all modes.
+     */
+    loadWorkspace: (workspace: AnalysisWorkspace) => void;
+}
+export type CoreSlice = CoreSliceState & CoreSliceActions;
+export declare const createInitialCoreState: () => CoreSliceState;
+/**
+ * Create the core slice.
+ * Uses StateCreator pattern for composability with other slices.
+ */
+export declare const createCoreSlice: StateCreator<AnalysisBuilderStore, [
+], [
+], CoreSlice>;

package/dist/cjs/client/stores/slices/flowSlice.d.ts

@@ -0,0 +1,69 @@
+import { StateCreator } from 'zustand';
+import { AnalysisBuilderStore } from '../analysisBuilderStore.js';
+import { Filter, FunnelBindingKey } from '../../types.js';
+import { ServerFlowQuery, FlowStartingStep } from '../../types/flow.js';
+/**
+ * Flow slice state
+ */
+export interface FlowSliceState {
+    /** Selected cube for flow mode (must be an eventStream cube) */
+    flowCube: string | null;
+    /** Binding key that links events to entities */
+    flowBindingKey: FunnelBindingKey | null;
+    /** Time dimension for event ordering */
+    flowTimeDimension: string | null;
+    /** Starting step configuration (anchor point for exploration) */
+    startingStep: FlowStartingStep;
+    /** Number of steps to explore before starting step (0-5) */
+    stepsBefore: number;
+    /** Number of steps to explore after starting step (0-5) */
+    stepsAfter: number;
+    /** Event dimension that categorizes events (node labels) */
+    eventDimension: string | null;
+    /** Join strategy for flow execution */
+    joinStrategy: 'auto' | 'lateral' | 'window';
+}
+/**
+ * Flow slice actions
+ */
+export interface FlowSliceActions {
+    /** Set the flow cube (clears binding key/time dimension) */
+    setFlowCube: (cube: string | null) => void;
+    /** Set the flow binding key */
+    setFlowBindingKey: (key: FunnelBindingKey | null) => void;
+    /** Set the flow time dimension */
+    setFlowTimeDimension: (dim: string | null) => void;
+    /** Set the event dimension */
+    setEventDimension: (dim: string | null) => void;
+    /** Set the starting step name */
+    setStartingStepName: (name: string) => void;
+    /** Set all starting step filters at once */
+    setStartingStepFilters: (filters: Filter[]) => void;
+    /** Add a filter to the starting step */
+    addStartingStepFilter: (filter: Filter) => void;
+    /** Remove a filter from the starting step by index */
+    removeStartingStepFilter: (index: number) => void;
+    /** Update a filter in the starting step by index */
+    updateStartingStepFilter: (index: number, filter: Filter) => void;
+    /** Set the number of steps to explore before starting step */
+    setStepsBefore: (count: number) => void;
+    /** Set the number of steps to explore after starting step */
+    setStepsAfter: (count: number) => void;
+    /** Set the join strategy */
+    setJoinStrategy: (strategy: 'auto' | 'lateral' | 'window') => void;
+    /** Check if in flow mode (analysisType === 'flow') */
+    isFlowMode: () => boolean;
+    /** Check if flow mode is properly configured and ready for execution */
+    isFlowModeEnabled: () => boolean;
+    /** Build ServerFlowQuery from flow state */
+    buildFlowQuery: () => ServerFlowQuery | null;
+}
+export type FlowSlice = FlowSliceState & FlowSliceActions;
+export declare const createInitialFlowState: () => FlowSliceState;
+/**
+ * Create the flow slice.
+ * Uses StateCreator pattern for composability.
+ */
+export declare const createFlowSlice: StateCreator<AnalysisBuilderStore, [
+], [
+], FlowSlice>;