drizzle-cube 0.6.1 → 0.6.3

package/dist/cjs/client/components/DashboardFilters/DashboardFilterValueInput.d.ts

@@ -0,0 +1,39 @@
+import { ChangeEvent } from 'react';
+import { SimpleFilter } from '../../types.js';
+import { DateRangeType } from '../../shared/types.js';
+type OperatorMeta = {
+    requiresValues?: boolean;
+    valueType?: string;
+    supportsMultipleValues?: boolean;
+} | undefined;
+export interface DashboardFilterValueInputProps {
+    filter: SimpleFilter;
+    operatorMeta: OperatorMeta;
+    shouldShowDateRange: boolean;
+    shouldShowComboBox: boolean;
+    rangeType: DateRangeType;
+    numberValue: number;
+    dateRangeLabel: string;
+    isDateRangeDropdownOpen: boolean;
+    setIsOperatorDropdownOpen: (open: boolean) => void;
+    setIsValueDropdownOpen: (open: boolean) => void;
+    setIsDateRangeDropdownOpen: (open: boolean) => void;
+    handleRangeTypeChange: (rangeType: DateRangeType) => void;
+    handleNumberValueChange: (value: number) => void;
+    handleCustomStartDate: (e: ChangeEvent<HTMLInputElement>) => void;
+    handleCustomEndDate: (e: ChangeEvent<HTMLInputElement>) => void;
+    handleBetweenStartInput: (e: ChangeEvent<HTMLInputElement>) => void;
+    handleBetweenEndInput: (e: ChangeEvent<HTMLInputElement>) => void;
+    handleDateInput: (e: ChangeEvent<HTMLInputElement>) => void;
+    handleDirectInput: (e: ChangeEvent<HTMLInputElement>) => void;
+    isValueDropdownOpen: boolean;
+    distinctValues: unknown[];
+    valuesLoading: boolean;
+    valuesError: unknown;
+    searchText: string;
+    setSearchText: (text: string) => void;
+    handleValueSelect: (value: unknown) => void;
+    handleValueRemove: (value: unknown) => void;
+}
+export default function DashboardFilterValueInput(props: DashboardFilterValueInputProps): import("react").JSX.Element;
+export {};

package/dist/cjs/client/components/DashboardFilters/DatePresetChips.d.ts

@@ -0,0 +1,8 @@
+import { default as React } from 'react';
+interface DatePresetChipsProps {
+    activePreset: string | null;
+    onPresetSelect: (presetValue: string) => void;
+    disabled?: boolean;
+}
+declare const DatePresetChips: React.FC<DatePresetChipsProps>;
+export default DatePresetChips;

package/dist/cjs/client/components/DashboardFilters/EditModeFilterList.d.ts

@@ -0,0 +1,13 @@
+import { default as React } from 'react';
+import { DashboardFilter } from '../../types.js';
+interface EditModeFilterListProps {
+    dashboardFilters: DashboardFilter[];
+    onAddFilter: () => void;
+    onAddTimeFilter: () => void;
+    onEditFilter: (filterId: string) => void;
+    onRemoveFilter: (filterId: string) => void;
+    selectedFilterId?: string | null;
+    onFilterSelect?: (filterId: string) => void;
+}
+declare const EditModeFilterList: React.FC<EditModeFilterListProps>;
+export default EditModeFilterList;

package/dist/cjs/client/components/DashboardFilters/FilterChip.d.ts

@@ -0,0 +1,12 @@
+import { default as React } from 'react';
+import { DashboardFilter, CubeMeta } from '../../types.js';
+interface FilterChipProps {
+    filter: DashboardFilter;
+    schema: CubeMeta | null;
+    isEditMode: boolean;
+    onChange: (updatedFilter: DashboardFilter) => void;
+    onEdit?: () => void;
+    onRemove?: () => void;
+}
+declare const FilterChip: React.FC<FilterChipProps>;
+export default FilterChip;

package/dist/cjs/client/components/DashboardFilters/FilterEditModal.d.ts

@@ -0,0 +1,15 @@
+import { default as React } from 'react';
+import { DashboardFilter, CubeMeta, DashboardConfig } from '../../types.js';
+import { MetaResponse } from '../../shared/types.js';
+interface FilterEditModalProps {
+    filter: DashboardFilter;
+    schema: CubeMeta | null;
+    dashboardConfig: DashboardConfig;
+    isOpen: boolean;
+    onSave: (filter: DashboardFilter) => void | Promise<void>;
+    onClose: () => void;
+    onDelete: () => void;
+    convertToMetaResponse: (cubeMeta: CubeMeta | null) => MetaResponse | null;
+}
+declare const FilterEditModal: React.FC<FilterEditModalProps>;
+export default FilterEditModal;

package/dist/cjs/client/components/DashboardFilters/FilterValuePopover.d.ts

@@ -0,0 +1,11 @@
+import { default as React } from 'react';
+import { SimpleFilter, CubeMeta } from '../../types.js';
+interface FilterValuePopoverProps {
+    filter: SimpleFilter;
+    schema: CubeMeta | null;
+    onValuesChange: (values: any[]) => void;
+    onClose: () => void;
+    anchorRef: React.RefObject<HTMLElement>;
+}
+declare const FilterValuePopover: React.FC<FilterValuePopoverProps>;
+export default FilterValuePopover;

package/dist/cjs/client/components/DashboardFilters/ReadOnlyFilterList.d.ts

@@ -0,0 +1,13 @@
+import { default as React } from 'react';
+import { DashboardFilter, CubeMeta } from '../../types.js';
+import { MetaResponse } from '../../shared/types.js';
+interface ReadOnlyFilterListProps {
+    dashboardFilters: DashboardFilter[];
+    schema: CubeMeta | null;
+    onFilterChange: (filterId: string, updatedFilter: DashboardFilter) => void;
+    onDateRangeChange: (filterId: string, dateRange: string | string[]) => void;
+    convertToMetaResponse: (cubeMeta: CubeMeta | null) => MetaResponse | null;
+    isTimeDimensionField: (fieldName: string) => boolean;
+}
+declare const ReadOnlyFilterList: React.FC<ReadOnlyFilterListProps>;
+export default ReadOnlyFilterList;

package/dist/cjs/client/components/DashboardFilters/XTDDropdown.d.ts

@@ -0,0 +1,10 @@
+import { default as React } from 'react';
+interface XTDDropdownProps {
+    isOpen: boolean;
+    onClose: () => void;
+    onSelect: (xtdValue: string) => void;
+    currentXTD?: string | null;
+    anchorRef: React.RefObject<HTMLElement>;
+}
+declare const XTDDropdown: React.FC<XTDDropdownProps>;
+export default XTDDropdown;

package/dist/cjs/client/components/DashboardFilters/dashboardFilterConfigModalUtils.d.ts

@@ -0,0 +1,21 @@
+/**
+ * dashboardFilterConfigModalUtils
+ *
+ * Pure helpers extracted from DashboardFilterConfigModal to keep the component's
+ * effects and handlers flat. Behaviour is identical to the previous inline logic.
+ *
+ * `deriveRangeFromDateRange` lives in the shared `dateRangeUtils` module and is
+ * re-exported here to keep existing import paths stable.
+ */
+export type { DerivedRange } from '../shared/dateRangeUtils.js';
+export { deriveRangeFromDateRange } from '../shared/dateRangeUtils.js';
+/**
+ * Compute the next filter `values` for a direct text/number input change.
+ * Mirrors the previous inline `handleDirectInput` logic exactly:
+ *  - For number-typed operators: keep numeric values, clear on empty/partial sign.
+ *  - For everything else: store the raw string (or clear when empty).
+ *
+ * Returns `null` when the current values should be left untouched (e.g. an
+ * unparseable number that is neither empty nor a lone "-").
+ */
+export declare function computeDirectInputValues(value: string, valueType: string | undefined): unknown[] | null;

package/dist/cjs/client/components/DashboardFilters/useCompactFilterBar.d.ts

@@ -0,0 +1,19 @@
+import { DashboardFilter } from '../../types.js';
+export declare function useCompactFilterBar(dashboardFilters: DashboardFilter[], onDashboardFiltersChange: (filters: DashboardFilter[]) => void): {
+    localFilters: DashboardFilter[];
+    showCustomDropdown: boolean;
+    setShowCustomDropdown: import('react').Dispatch<import('react').SetStateAction<boolean>>;
+    showXTDDropdown: boolean;
+    setShowXTDDropdown: import('react').Dispatch<import('react').SetStateAction<boolean>>;
+    customButtonRef: import('react').RefObject<HTMLButtonElement>;
+    xtdButtonRef: import('react').RefObject<HTMLButtonElement>;
+    currentDateRange: string | any[] | null;
+    activePresetId: string | null;
+    activeXTDId: string | null;
+    nonDateFilters: DashboardFilter[];
+    handlePresetSelect: (presetValue: string) => void;
+    handleXTDSelect: (xtdValue: string) => void;
+    handleCustomDateSelect: (dateRange: string | string[]) => void;
+    handleFilterChange: (filterId: string, updatedFilter: DashboardFilter) => void;
+    dateRangeTooltip: string | null;
+};

package/dist/cjs/client/components/DashboardFilters/useDashboardFilterConfigModal.d.ts

@@ -0,0 +1,69 @@
+import { ChangeEvent } from 'react';
+import { DashboardFilter, SimpleFilter, FilterOperator } from '../../types.js';
+import { MetaResponse, MetaField } from '../../shared/types.js';
+import { FieldType } from '../AnalysisBuilder/types.js';
+interface UseDashboardFilterConfigModalParams {
+    initialFilter: DashboardFilter;
+    fullSchema: MetaResponse | null;
+    filteredSchema: MetaResponse | null;
+    isOpen: boolean;
+    onSave: (filter: DashboardFilter) => void;
+}
+export declare function useDashboardFilterConfigModal({ initialFilter, fullSchema, filteredSchema, isOpen, onSave }: UseDashboardFilterConfigModalParams): {
+    localLabel: string;
+    setLocalLabel: import('react').Dispatch<import('react').SetStateAction<string>>;
+    localFilter: SimpleFilter;
+    showAllFields: boolean;
+    setShowAllFields: import('react').Dispatch<import('react').SetStateAction<boolean>>;
+    showFieldSearch: boolean;
+    setShowFieldSearch: import('react').Dispatch<import('react').SetStateAction<boolean>>;
+    field: {
+        activeSchema: MetaResponse | null;
+        isTimeField: boolean;
+        isMeasureField: boolean;
+        fieldTitle: string;
+        operatorMeta: import('../../shared/types.js').FilterOperatorMeta;
+        availableOperators: {
+            operator: string;
+            label: string;
+        }[];
+        operatorLabel: string;
+        shouldShowDateRange: boolean;
+        shouldShowComboBox: boolean;
+    };
+    dropdowns: {
+        containerRef: import('react').RefObject<HTMLDivElement>;
+        isOperatorDropdownOpen: boolean;
+        setIsOperatorDropdownOpen: import('react').Dispatch<import('react').SetStateAction<boolean>>;
+        isValueDropdownOpen: boolean;
+        setIsValueDropdownOpen: import('react').Dispatch<import('react').SetStateAction<boolean>>;
+        isDateRangeDropdownOpen: boolean;
+        setIsDateRangeDropdownOpen: import('react').Dispatch<import('react').SetStateAction<boolean>>;
+    };
+    values: {
+        searchText: string;
+        setSearchText: import('react').Dispatch<import('react').SetStateAction<string>>;
+        distinctValues: any[];
+        valuesLoading: boolean;
+        valuesError: string | null;
+        handleValueSelect: (value: unknown) => void;
+        handleValueRemove: (valueToRemove: unknown) => void;
+    };
+    dateRange: {
+        dateRangeLabel: string;
+        rangeType: import('../shared/types.js').DateRangeType;
+        numberValue: number;
+        handleRangeTypeChange: (newRangeType: import('../shared/types.js').DateRangeType) => void;
+        handleNumberValueChange: (value: number) => void;
+        handleCustomStartDate: (e: ChangeEvent<HTMLInputElement>) => void;
+        handleCustomEndDate: (e: ChangeEvent<HTMLInputElement>) => void;
+    };
+    handleFieldSelected: (field: MetaField, _fieldType: FieldType) => void;
+    handleOperatorChange: (operator: FilterOperator) => void;
+    handleDirectInput: (e: ChangeEvent<HTMLInputElement>) => void;
+    handleBetweenStartInput: (e: ChangeEvent<HTMLInputElement>) => void;
+    handleBetweenEndInput: (e: ChangeEvent<HTMLInputElement>) => void;
+    handleDateInput: (e: ChangeEvent<HTMLInputElement>) => void;
+    handleSave: () => void;
+};
+export {};

package/dist/cjs/client/components/DashboardFilters/useDateRangeState.d.ts

@@ -0,0 +1,19 @@
+import { ChangeEvent } from 'react';
+import { SimpleFilter } from '../../types.js';
+import { DateRangeType } from '../../shared/types.js';
+interface UseDateRangeStateParams {
+    localFilter: SimpleFilter;
+    setLocalFilter: (filter: SimpleFilter) => void;
+    shouldShowDateRange: boolean;
+    setIsDateRangeDropdownOpen: (open: boolean) => void;
+}
+export declare function useDateRangeState({ localFilter, setLocalFilter, shouldShowDateRange, setIsDateRangeDropdownOpen }: UseDateRangeStateParams): {
+    rangeType: DateRangeType;
+    numberValue: number;
+    handleRangeTypeChange: (newRangeType: DateRangeType) => void;
+    handleNumberValueChange: (value: number) => void;
+    handleCustomStartDate: (e: ChangeEvent<HTMLInputElement>) => void;
+    handleCustomEndDate: (e: ChangeEvent<HTMLInputElement>) => void;
+};
+export type UseDateRangeState = ReturnType<typeof useDateRangeState>;
+export {};

package/dist/cjs/client/components/DashboardFilters/useFilterDropdowns.d.ts

@@ -0,0 +1,21 @@
+/**
+ * useFilterDropdowns
+ *
+ * Owns the open/closed state of the three mutually-exclusive popover dropdowns
+ * (operator, value, date-range) plus the click-outside effect that closes them
+ * all. This is the single "which dropdown is open" concern; it exposes the
+ * container ref the effect watches and the individual open flags/setters.
+ *
+ * Behaviour is identical to the previous inline implementation — same effect,
+ * same dependency array, same setters.
+ */
+export declare function useFilterDropdowns(): {
+    containerRef: import('react').RefObject<HTMLDivElement>;
+    isOperatorDropdownOpen: boolean;
+    setIsOperatorDropdownOpen: import('react').Dispatch<import('react').SetStateAction<boolean>>;
+    isValueDropdownOpen: boolean;
+    setIsValueDropdownOpen: import('react').Dispatch<import('react').SetStateAction<boolean>>;
+    isDateRangeDropdownOpen: boolean;
+    setIsDateRangeDropdownOpen: import('react').Dispatch<import('react').SetStateAction<boolean>>;
+};
+export type UseFilterDropdowns = ReturnType<typeof useFilterDropdowns>;

package/dist/cjs/client/components/DashboardFilters/useFilterValueFetch.d.ts

@@ -0,0 +1,23 @@
+import { SimpleFilter } from '../../types.js';
+interface OperatorMetaLike {
+    supportsMultipleValues?: boolean;
+}
+interface UseFilterValueFetchParams {
+    localFilter: SimpleFilter;
+    setLocalFilter: (filter: SimpleFilter) => void;
+    operatorMeta: OperatorMetaLike | undefined;
+    shouldShowComboBox: boolean;
+    isValueDropdownOpen: boolean;
+    setIsValueDropdownOpen: (open: boolean) => void;
+}
+export declare function useFilterValueFetch({ localFilter, setLocalFilter, operatorMeta, shouldShowComboBox, isValueDropdownOpen, setIsValueDropdownOpen }: UseFilterValueFetchParams): {
+    searchText: string;
+    setSearchText: import('react').Dispatch<import('react').SetStateAction<string>>;
+    distinctValues: any[];
+    valuesLoading: boolean;
+    valuesError: string | null;
+    handleValueSelect: (value: unknown) => void;
+    handleValueRemove: (valueToRemove: unknown) => void;
+};
+export type UseFilterValueFetch = ReturnType<typeof useFilterValueFetch>;
+export {};

package/dist/cjs/client/components/DashboardGrid.d.ts

@@ -0,0 +1,22 @@
+import { ReactNode } from 'react';
+import { ColorPalette } from '../utils/colorPalettes.js';
+import { DashboardConfig, DashboardFilter, CubeMeta, DashboardLayoutMode } from '../types.js';
+interface DashboardGridProps {
+    config: DashboardConfig;
+    editable?: boolean;
+    dashboardFilters?: DashboardFilter[];
+    loadingComponent?: ReactNode;
+    onConfigChange?: (config: DashboardConfig) => void;
+    onPortletRefresh?: (portletId: string) => void;
+    onSave?: (config: DashboardConfig) => Promise<void> | void;
+    /** Callback to save thumbnail separately - called on edit mode exit when thumbnail feature is enabled */
+    onSaveThumbnail?: (thumbnailData: string) => Promise<string | void>;
+    colorPalette?: ColorPalette;
+    schema?: CubeMeta | null;
+    onDashboardFiltersChange?: (filters: DashboardFilter[]) => void;
+    dashboardModes?: DashboardLayoutMode[];
+    /** When true, no toolbar is rendered (neither the top edit bar nor the floating toolbar) */
+    hideToolbar?: boolean;
+}
+export default function DashboardGrid(props: DashboardGridProps): import("react").JSX.Element;
+export {};

package/dist/cjs/client/components/DashboardPortletCard.d.ts

@@ -0,0 +1,4 @@
+import { default as React } from 'react';
+import { DashboardPortletCardProps } from './dashboardPortletCard/propsEqual.js';
+declare const DashboardPortletCard: React.NamedExoticComponent<DashboardPortletCardProps>;
+export default DashboardPortletCard;

package/dist/cjs/client/components/DashboardThumbnailPlaceholder.d.ts

@@ -0,0 +1,13 @@
+/**
+ * DashboardThumbnailPlaceholder
+ *
+ * A placeholder component shown when a dashboard thumbnail doesn't exist
+ * but the thumbnail feature is enabled. Displays a simple grid icon
+ * with "No preview" text.
+ */
+export interface DashboardThumbnailPlaceholderProps {
+    /** Additional CSS classes */
+    className?: string;
+}
+export declare function DashboardThumbnailPlaceholder({ className }: DashboardThumbnailPlaceholderProps): import("react").JSX.Element;
+export default DashboardThumbnailPlaceholder;

package/dist/cjs/client/components/DataBrowser/DataBrowserSidebar.d.ts

@@ -0,0 +1,16 @@
+/**
+ * DataBrowserSidebar
+ *
+ * Left panel showing a searchable list of cubes.
+ * Clicking a cube loads its dimensions into the table view.
+ */
+interface DataBrowserSidebarProps {
+    cubes: Array<{
+        name: string;
+        title: string;
+    }>;
+    selectedCube: string | null;
+    onSelectCube: (cubeName: string) => void;
+}
+export default function DataBrowserSidebar({ cubes, selectedCube, onSelectCube, }: DataBrowserSidebarProps): import("react").JSX.Element;
+export {};

package/dist/cjs/client/components/DataBrowser/DataBrowserTable.d.ts

@@ -0,0 +1,16 @@
+import { default as React } from 'react';
+interface DataBrowserTableProps {
+    data: unknown[] | null;
+    columns: string[];
+    sortColumn: string | null;
+    sortDirection: 'asc' | 'desc';
+    onSort: (column: string) => void;
+    getFieldLabel: (field: string) => string;
+    meta: any;
+    isLoading: boolean;
+    isFetching: boolean;
+    selectedCube: string | null;
+    loadingComponent?: React.ReactNode;
+}
+declare const _default: React.NamedExoticComponent<DataBrowserTableProps>;
+export default _default;

package/dist/cjs/client/components/DataBrowser/DataBrowserToolbar.d.ts

@@ -0,0 +1,22 @@
+/**
+ * DataBrowserToolbar
+ *
+ * Top toolbar with filter toggle, column picker, row count, and pagination.
+ */
+interface DataBrowserToolbarProps {
+    showFilterBar: boolean;
+    filterCount: number;
+    onToggleFilterBar: () => void;
+    onToggleColumnPicker: () => void;
+    page: number;
+    pageSize: number;
+    rowCount: number;
+    hasNextPage: boolean;
+    hasPrevPage: boolean;
+    onPageChange: (page: number) => void;
+    onPageSizeChange: (size: number) => void;
+    isFetching: boolean;
+    onRefresh: () => void;
+}
+export default function DataBrowserToolbar({ showFilterBar, filterCount, onToggleFilterBar, onToggleColumnPicker, page, pageSize, rowCount, hasNextPage, hasPrevPage, onPageChange, onPageSizeChange, isFetching, onRefresh, }: DataBrowserToolbarProps): import("react").JSX.Element;
+export {};

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

@@ -0,0 +1,28 @@
+/**
+ * DataBrowser Component
+ *
+ * A Neon-style full-page data browser for exploring raw cube data.
+ * Uses ungrouped queries to display row-level data with:
+ * - Cube list sidebar (left)
+ * - Sortable data table (right)
+ * - Filter bar and column picker
+ * - Server-side pagination
+ *
+ * Must be wrapped in a CubeProvider.
+ */
+export interface DataBrowserProps {
+    /** Additional CSS classes */
+    className?: string;
+    /** Initially selected cube */
+    defaultCube?: string;
+    /** Default page size (default: 20) */
+    defaultPageSize?: number;
+    /** Max height for the component (default: '100vh') */
+    maxHeight?: string;
+    /** Custom loading indicator (defaults to LoadingIndicator) */
+    loadingComponent?: import('react').ReactNode;
+}
+/**
+ * DataBrowser — standalone data browsing component
+ */
+export default function DataBrowser({ className, defaultCube, defaultPageSize, maxHeight, loadingComponent, }: DataBrowserProps): import("react").JSX.Element;

package/dist/cjs/client/components/DataHistogram.d.ts

@@ -0,0 +1,27 @@
+interface DataHistogramProps {
+    /** Array of numeric values to create histogram from */
+    values: number[];
+    /** Minimum value in the dataset */
+    min: number;
+    /** Maximum value in the dataset */
+    max: number;
+    /** Color for the histogram bars */
+    color?: string;
+    /** Number of buckets/bars to create (default: 12) */
+    bucketCount?: number;
+    /** Height of the histogram in pixels (default: 32) */
+    height?: number;
+    /** Format function for min/max labels */
+    formatValue?: (value: number) => string;
+    /** Width of the histogram to match text above */
+    width?: number;
+    /** Whether to show average indicator line (default: true) */
+    showAverageIndicator?: boolean;
+    /** Target value to show as green line */
+    targetValue?: number;
+}
+/**
+ * Reusable histogram component that shows the distribution of actual data values
+ */
+export default function DataHistogram({ values, min, max, color, bucketCount, height, formatValue, width, showAverageIndicator, targetValue }: DataHistogramProps): import("react").JSX.Element;
+export {};

package/dist/cjs/client/components/DebugModal.d.ts

@@ -0,0 +1,17 @@
+import { FlowChartData } from '../types/flow.js';
+import { RetentionChartData } from '../types/retention.js';
+interface DebugModalProps {
+    chartConfig: any;
+    displayConfig: any;
+    queryObject: any;
+    data: any[] | FlowChartData | RetentionChartData;
+    chartType: string;
+    cacheInfo?: {
+        hit: true;
+        cachedAt: string;
+        ttlMs: number;
+        ttlRemainingMs: number;
+    } | null;
+}
+export default function DebugModal({ chartConfig, displayConfig, queryObject, data, chartType, cacheInfo }: DebugModalProps): import("react").JSX.Element;
+export {};

package/dist/cjs/client/components/DrillBreadcrumb.d.ts

@@ -0,0 +1,7 @@
+import { default as React } from 'react';
+import { DrillBreadcrumbProps } from '../types/drill.js';
+/**
+ * DrillBreadcrumb component
+ */
+export declare function DrillBreadcrumb({ path, onNavigate, onLevelClick }: DrillBreadcrumbProps): React.JSX.Element | null;
+export default DrillBreadcrumb;

package/dist/cjs/client/components/DrillMenu.d.ts

@@ -0,0 +1,8 @@
+import { default as React } from 'react';
+import { DrillMenuProps } from '../types/drill.js';
+/**
+ * DrillMenu component
+ * Uses createPortal to render directly to document.body, avoiding stacking context issues
+ */
+export declare function DrillMenu({ options, position, onSelect, onClose }: DrillMenuProps): React.ReactPortal | null;
+export default DrillMenu;

package/dist/cjs/client/components/FloatingEditToolbar.d.ts

@@ -0,0 +1,30 @@
+import { default as React } from 'react';
+import { DashboardLayoutMode } from '../types.js';
+interface FloatingEditToolbarProps {
+    /** Whether the static edit bar is visible (toolbar hidden when true) */
+    isEditBarVisible: boolean;
+    /** Position of the floating toolbar */
+    position: 'left' | 'right';
+    /** Whether currently in edit mode */
+    isEditMode: boolean;
+    /** Toggle edit mode on/off */
+    onEditModeToggle: () => void;
+    /** Current layout mode */
+    layoutMode: DashboardLayoutMode;
+    /** Change layout mode */
+    onLayoutModeChange: (mode: DashboardLayoutMode) => void;
+    /** Available layout modes */
+    allowedModes: DashboardLayoutMode[];
+    /** Whether layout mode can be changed */
+    canChangeLayoutMode: boolean;
+    /** Current color palette name */
+    currentPalette: string;
+    /** Change color palette */
+    onPaletteChange: (palette: string) => void;
+    /** Add new portlet */
+    onAddPortlet: () => void;
+    /** Add new text portlet */
+    onAddText?: () => void;
+}
+export default function FloatingEditToolbar({ isEditBarVisible, position, isEditMode, onEditModeToggle, layoutMode, onLayoutModeChange, allowedModes, canChangeLayoutMode, currentPalette, onPaletteChange, onAddPortlet, onAddText }: FloatingEditToolbarProps): React.ReactPortal | null;
+export {};

package/dist/cjs/client/components/LoadingIndicator.d.ts

@@ -0,0 +1,16 @@
+/**
+ * LoadingIndicator Component
+ *
+ * A centralized, theme-aware loading spinner that uses CSS variables
+ * for consistent styling across all drizzle-cube components.
+ *
+ * Can be overridden at the Dashboard or Portlet level by passing a
+ * custom loadingComponent prop.
+ */
+export interface LoadingIndicatorProps {
+    /** Size variant: 'xs' (12px), 'sm' (24px), 'md' (32px), 'lg' (48px) */
+    size?: 'xs' | 'sm' | 'md' | 'lg';
+    /** Additional CSS classes */
+    className?: string;
+}
+export default function LoadingIndicator({ size, className }: LoadingIndicatorProps): import("react").JSX.Element;

package/dist/cjs/client/components/MobileStackedLayout.d.ts

@@ -0,0 +1,14 @@
+import { DashboardFilter, DashboardConfig } from '../types.js';
+import { ColorPalette } from '../utils/colorPalettes.js';
+interface MobileStackedLayoutProps {
+    config: DashboardConfig;
+    colorPalette?: ColorPalette;
+    dashboardFilters?: DashboardFilter[];
+    onPortletRefresh?: (portletId: string) => void;
+}
+/**
+ * Mobile-optimized stacked layout for dashboard portlets
+ * Renders portlets in a single column, sorted by grid position
+ */
+export default function MobileStackedLayout({ config, colorPalette, dashboardFilters, onPortletRefresh }: MobileStackedLayoutProps): import("react").JSX.Element;
+export {};

package/dist/cjs/client/components/Modal.d.ts

@@ -0,0 +1,16 @@
+import { default as React } from 'react';
+export interface ModalProps {
+    isOpen: boolean;
+    onClose: () => void;
+    title?: string;
+    size?: 'sm' | 'md' | 'lg' | 'xl' | 'xxl' | 'full' | 'fullscreen' | 'fullscreen-mobile';
+    closeOnBackdropClick?: boolean;
+    closeOnEscape?: boolean;
+    showCloseButton?: boolean;
+    className?: string;
+    children: React.ReactNode;
+    footer?: React.ReactNode;
+    noPadding?: boolean;
+}
+declare const Modal: React.FC<ModalProps>;
+export default Modal;

package/dist/cjs/client/components/PortletAnalysisModal.d.ts

@@ -0,0 +1,27 @@
+import { PortletConfig, ColorPalette, DashboardFilter } from '../types.js';
+interface PortletAnalysisModalProps {
+    isOpen: boolean;
+    onClose: () => void;
+    onSave: (portlet: PortletConfig | Omit<PortletConfig, 'id' | 'x' | 'y'>) => void;
+    portlet?: PortletConfig | null;
+    /** Initial data to display (avoids re-fetching when editing) */
+    initialData?: any[];
+    title: string;
+    submitText: string;
+    colorPalette?: ColorPalette;
+    /** @deprecated Dashboard filters are no longer merged into the editor - they are applied at execution time */
+    dashboardFilters?: DashboardFilter[];
+}
+/**
+ * PortletAnalysisModal - A modal wrapper around AnalysisBuilder for portlet editing
+ *
+ * This replaces PortletEditModal with the modern AnalysisBuilder interface.
+ * Features:
+ * - Two-panel layout with results and query builder
+ * - Auto-execution of queries
+ * - Smart chart defaults
+ * - Title input in header
+ * - Initial data support (no re-fetch when editing)
+ */
+export default function PortletAnalysisModal({ isOpen, onClose, onSave, portlet, initialData, title: modalTitle, submitText, colorPalette }: PortletAnalysisModalProps): import("react").JSX.Element;
+export {};

package/dist/cjs/client/components/PortletContainer.d.ts

@@ -0,0 +1,10 @@
+import { PortletConfig } from '../types.js';
+interface PortletContainerProps {
+    portlet: PortletConfig;
+    editable?: boolean;
+    onEdit?: (portlet: PortletConfig) => void;
+    onDelete?: (portletId: string) => void;
+    onRefresh?: (portletId: string) => void;
+}
+export default function PortletContainer({ portlet, editable, onEdit, onDelete, onRefresh }: PortletContainerProps): import("react").JSX.Element;
+export {};

package/dist/cjs/client/components/PortletFilterConfigModal.d.ts

@@ -0,0 +1,13 @@
+import { DashboardFilter, DashboardFilterMapping, CubeMeta, PortletConfig } from '../types.js';
+interface PortletFilterConfigModalProps {
+    isOpen: boolean;
+    onClose: () => void;
+    dashboardFilters: DashboardFilter[];
+    currentMapping: DashboardFilterMapping;
+    onSave: (mapping: DashboardFilterMapping) => void;
+    portletTitle: string;
+    schema?: CubeMeta | null;
+    portlet?: PortletConfig | null;
+}
+export default function PortletFilterConfigModal({ isOpen, onClose, dashboardFilters, currentMapping, onSave, portletTitle, schema, portlet }: PortletFilterConfigModalProps): import("react").JSX.Element | null;
+export {};