@prismiq/react 0.1.0

package/dist/DashboardDialog-LHmrtNQU.d.cts

@@ -0,0 +1,1106 @@
+import * as react from 'react';
+import { HTMLAttributes, ReactNode } from 'react';
+import { a as QueryDefinition, Q as QueryResult, D as DatabaseSchema, d as Dashboard$2, e as DashboardCreate, f as DashboardUpdate } from './types-WrCbOeAV.cjs';
+
+/**
+ * Dashboard type definitions for Prismiq.
+ *
+ * These types define dashboards, widgets, and filters.
+ */
+
+/**
+ * Supported widget types.
+ */
+type WidgetType = 'metric' | 'bar_chart' | 'line_chart' | 'area_chart' | 'pie_chart' | 'scatter_chart' | 'table' | 'text';
+/**
+ * Widget position and size in the grid layout.
+ */
+interface WidgetPosition {
+    /** X coordinate (column position). */
+    x: number;
+    /** Y coordinate (row position). */
+    y: number;
+    /** Width in grid units. */
+    w: number;
+    /** Height in grid units. */
+    h: number;
+    /** Minimum width constraint. */
+    minW?: number;
+    /** Minimum height constraint. */
+    minH?: number;
+    /** Maximum width constraint. */
+    maxW?: number;
+    /** Maximum height constraint. */
+    maxH?: number;
+}
+/**
+ * Cross-filter widget configuration.
+ */
+interface WidgetCrossFilterConfig {
+    /** Enable cross-filtering on this widget. */
+    enabled: boolean;
+    /** Column to filter on (defaults to x_axis). */
+    column?: string;
+    /** Table for the filter (optional). */
+    table?: string;
+}
+/**
+ * A reference line (threshold/goal) for charts.
+ */
+interface ReferenceLine {
+    /** Y-axis value where line should appear. */
+    value: number;
+    /** Optional label displayed on the line. */
+    label?: string;
+    /** Line color (hex). */
+    color?: string;
+    /** Line style. */
+    lineStyle?: 'solid' | 'dashed' | 'dotted';
+}
+/**
+ * Widget-specific configuration options.
+ */
+interface WidgetConfig {
+    /** Column to use for X axis. */
+    x_axis?: string;
+    /** Columns to use for Y axis (supports multiple for multi-series). */
+    y_axis?: string[];
+    /** Column that defines series for multi-series charts (e.g., category column in long-format data). */
+    series_column?: string;
+    /** Maximum number of series to display (top N by total value). Useful for charts with many series. */
+    max_series?: number;
+    /** Chart orientation for bar charts. */
+    orientation?: 'vertical' | 'horizontal';
+    /** Whether to stack series. */
+    stacked?: boolean;
+    /** Whether to show the legend. */
+    show_legend?: boolean;
+    /** Whether to show data labels on chart elements. */
+    show_data_labels?: boolean;
+    /** Custom color palette for the chart. */
+    colors?: string[];
+    /** Value format for chart axes (e.g., 'currency', 'percent'). */
+    valueFormat?: 'number' | 'currency' | 'percent' | 'compact';
+    /** Currency symbol when valueFormat is 'currency'. */
+    currencySymbol?: string;
+    /** Compact notation mode (K for thousands, M for millions, etc.). Null means no compacting. */
+    compactNotation?: 'K' | 'M' | 'B' | 'T' | null;
+    /** Number of decimal digits to show. */
+    decimalDigits?: number;
+    /** Reference lines for charts (thresholds, goals). */
+    referenceLines?: ReferenceLine[];
+    /** Cross-filter configuration for this widget. */
+    cross_filter?: WidgetCrossFilterConfig;
+    /** Number format for metric display. */
+    format?: 'number' | 'currency' | 'percent' | 'compact';
+    /** Column to use for trend comparison (deprecated, use trendDateColumn). */
+    trend_comparison?: string;
+    /** Whether to show trend indicator. */
+    showTrend?: boolean;
+    /** Comparison period for trend calculation. */
+    trendPeriod?: 'previous_period' | 'previous_year' | 'previous_month' | 'previous_week';
+    /** Date column to use for trend comparison. */
+    trendDateColumn?: string;
+    /** Number of rows per page. */
+    page_size?: number;
+    /** Whether table columns are sortable. */
+    sortable?: boolean;
+    /** Column to pivot (for pivot tables). Unique values become columns. */
+    pivot_column?: string;
+    /** Column containing values to distribute across pivoted columns. */
+    value_column?: string;
+    /** Date format strings for datetime columns (column name -> date-fns format string). Used by tables and chart axes. */
+    dateFormats?: Record<string, string>;
+    /** Text content for text widgets. */
+    content?: string;
+    /** Whether to render content as markdown. */
+    markdown?: boolean;
+    /** Text alignment for text widgets. */
+    alignment?: 'Left' | 'Center' | 'Right';
+    /** Font size for text widgets. */
+    fontSize?: 'Small' | 'Normal' | 'Large' | 'XLarge';
+}
+/**
+ * Widget hyperlink configuration for linking to external URLs.
+ */
+interface WidgetHyperlink {
+    /** URL to navigate to. */
+    url: string;
+    /** Link title/tooltip. */
+    title?: string;
+    /** Target window (_blank for new tab, _self for same tab). */
+    target?: '_blank' | '_self';
+}
+/**
+ * A widget in a dashboard.
+ */
+interface Widget$1 {
+    /** Unique widget identifier. */
+    id: string;
+    /** Widget type determines rendering. */
+    type: WidgetType;
+    /** Widget display title. */
+    title: string;
+    /** Query to execute for widget data (null for text widgets). */
+    query: QueryDefinition | null;
+    /** Position and size in the grid. */
+    position: WidgetPosition;
+    /** Widget-specific configuration. */
+    config: WidgetConfig;
+    /** Optional hyperlink to external URL (displayed as link icon in header). */
+    hyperlink?: WidgetHyperlink;
+    /** Data source mode last used when editing this widget. */
+    dataSourceMode?: 'guided' | 'advanced' | 'saved';
+    /** Creation timestamp (ISO string). */
+    created_at?: string;
+    /** Last update timestamp (ISO string). */
+    updated_at?: string;
+}
+/**
+ * Supported dashboard filter types.
+ */
+type DashboardFilterType = 'date_range' | 'select' | 'multi_select' | 'text' | 'number_range';
+/**
+ * Filter option for select/multi-select filters.
+ */
+interface FilterOption {
+    /** Option value. */
+    value: string;
+    /** Display label. */
+    label: string;
+}
+/**
+ * A dashboard filter definition.
+ */
+interface DashboardFilter {
+    /** Unique filter identifier. */
+    id: string;
+    /** Filter type determines the input component. */
+    type: DashboardFilterType;
+    /** Display label for the filter. */
+    label: string;
+    /** Column name this filter applies to. */
+    field: string;
+    /** Table name if filter targets a specific table. */
+    table?: string;
+    /** Default value for the filter. */
+    default_value?: unknown;
+    /** Available options for select/multi-select filters. */
+    options?: FilterOption[];
+    /** Date preset for date_range filters (e.g., 'last_7_days'). */
+    date_preset?: string;
+    /**
+     * Whether to dynamically load options from the database.
+     * When true, options are fetched from the table's column using getColumnSample.
+     * Requires `table` and `field` to be set.
+     */
+    dynamic?: boolean;
+}
+/**
+ * A filter value set by the user.
+ */
+interface FilterValue {
+    /** ID of the filter this value belongs to. */
+    filter_id: string;
+    /** The filter value. */
+    value: unknown;
+}
+/**
+ * Date range value for date_range filters.
+ */
+interface DateRangeValue {
+    /** Start date (ISO string). */
+    start: string;
+    /** End date (ISO string). */
+    end: string;
+}
+/**
+ * Number range value for number_range filters.
+ */
+interface NumberRangeValue {
+    /** Minimum value. */
+    min: number | null;
+    /** Maximum value. */
+    max: number | null;
+}
+/**
+ * Dashboard layout configuration.
+ */
+interface DashboardLayout$1 {
+    /** Number of columns in the grid. */
+    columns: number;
+    /** Height of a single row in pixels. */
+    row_height: number;
+    /** Margin between widgets [horizontal, vertical]. */
+    margin: [number, number];
+    /** Compact type for auto-arranging widgets. */
+    compact_type: 'vertical' | 'horizontal' | null;
+}
+/**
+ * A complete dashboard definition.
+ */
+interface Dashboard$1 {
+    /** Unique dashboard identifier. */
+    id: string;
+    /** Dashboard name. */
+    name: string;
+    /** Optional description. */
+    description?: string;
+    /** Grid layout configuration. */
+    layout: DashboardLayout$1;
+    /** Widgets in the dashboard. */
+    widgets: Widget$1[];
+    /** Dashboard-level filters. */
+    filters: DashboardFilter[];
+    /** Whether the dashboard is publicly accessible. */
+    is_public: boolean;
+    /** Owner user ID. */
+    owner_id?: string | null;
+    /** List of user IDs with view access. */
+    allowed_viewers?: string[];
+    /** Creation timestamp (ISO string). */
+    created_at?: string;
+    /** Last update timestamp (ISO string). */
+    updated_at?: string;
+}
+/**
+ * Configuration for scroll-based lazy loading of widgets.
+ */
+interface LazyLoadingConfig {
+    /** Whether lazy loading is enabled (default: true). */
+    enabled?: boolean;
+    /** Root margin for prefetching - loads widgets before visible (default: "200px"). */
+    rootMargin?: string;
+}
+/**
+ * Dashboard context value for read-only mode.
+ */
+interface DashboardContextValue {
+    /** Current dashboard (null while loading). */
+    dashboard: Dashboard$1 | null;
+    /** Whether the dashboard is loading. */
+    isLoading: boolean;
+    /** Error if dashboard failed to load. */
+    error: Error | null;
+    /** Current filter values. */
+    filterValues: FilterValue[];
+    /** Query results keyed by widget ID. */
+    widgetResults: Record<string, QueryResult>;
+    /** Query errors keyed by widget ID. */
+    widgetErrors: Record<string, Error>;
+    /** Loading state keyed by widget ID. */
+    widgetLoading: Record<string, boolean>;
+    /** Unix timestamps when each widget was last refreshed. */
+    widgetRefreshTimes: Record<string, number>;
+    /** Set of widget IDs currently being refreshed (force refresh). */
+    refreshingWidgets: Set<string>;
+    /** Set a filter value. */
+    setFilterValue: (filterId: string, value: unknown) => void;
+    /** Refresh all widgets (with batching). */
+    refreshDashboard: () => Promise<void>;
+    /** Refresh a single widget (bypasses cache). */
+    refreshWidget: (widgetId: string) => Promise<void>;
+    /** Refresh all widgets with configurable batch size. */
+    refreshAll: (batchSize?: number) => Promise<void>;
+    /** Get oldest widget refresh timestamp (for dashboard-level indicator). */
+    getOldestRefreshTime: () => number | null;
+    /** Register a widget's visibility state (for lazy loading). */
+    registerVisibility: (widgetId: string, isVisible: boolean) => void;
+    /** Unregister a widget when unmounted (for lazy loading). */
+    unregisterVisibility: (widgetId: string) => void;
+    /** Whether lazy loading is enabled. */
+    lazyLoadingEnabled: boolean;
+}
+/**
+ * Dashboard context value for editor mode.
+ * Extends the read-only context with editing capabilities.
+ */
+interface DashboardEditorContextValue extends DashboardContextValue {
+    /** Whether the dashboard is in edit mode. */
+    isEditing: boolean;
+    /** Whether there are unsaved changes. */
+    hasChanges: boolean;
+    /** Add a new widget. */
+    addWidget: (widget: Omit<Widget$1, 'id'>) => void;
+    /** Update an existing widget. */
+    updateWidget: (widgetId: string, updates: Partial<Widget$1>) => void;
+    /** Remove a widget. */
+    removeWidget: (widgetId: string) => void;
+    /** Duplicate a widget. */
+    duplicateWidget: (widgetId: string) => void;
+    /** Update widget positions after layout change. */
+    updateLayout: (positions: Record<string, WidgetPosition>) => void;
+    /** Save the dashboard. */
+    save: () => Promise<void>;
+    /** Cancel editing and revert changes. */
+    cancel: () => void;
+}
+/**
+ * Props for DashboardProvider.
+ */
+interface DashboardProviderProps {
+    /** Dashboard ID to load. */
+    dashboardId: string;
+    /**
+     * @deprecated Auto-refresh is no longer supported. Use manual refresh via refreshAll().
+     */
+    refreshInterval?: number;
+    /** Number of widgets to load in each batch (default: 8). */
+    batchSize?: number;
+    /** Lazy loading configuration (default: enabled with 200px margin). */
+    lazyLoading?: LazyLoadingConfig;
+    /** Children to render. */
+    children: React.ReactNode;
+}
+/**
+ * Props for Dashboard component.
+ */
+interface DashboardProps {
+    /** Dashboard ID to display. */
+    id: string;
+    /** Whether to show the filter bar. */
+    showFilters?: boolean;
+    /** Whether to show the dashboard title. */
+    showTitle?: boolean;
+    /** Auto-refresh interval in milliseconds. */
+    refreshInterval?: number;
+    /** Number of widgets to load in each batch (default: 8). */
+    batchSize?: number;
+    /** Lazy loading configuration (default: enabled with 200px margin). */
+    lazyLoading?: LazyLoadingConfig;
+    /** Callback when a widget is clicked. */
+    onWidgetClick?: (widget: Widget$1, result: QueryResult) => void;
+    /** Additional CSS class. */
+    className?: string;
+}
+/**
+ * Props for DashboardEditor component.
+ */
+interface DashboardEditorProps {
+    /** Dashboard ID to edit (omit for new dashboard). */
+    dashboardId?: string;
+    /** Callback when dashboard is saved. */
+    onSave?: (dashboard: Dashboard$1) => void;
+    /** Callback when editing is cancelled. */
+    onCancel?: () => void;
+    /** Number of widgets to load in each batch (default: 4). */
+    batchSize?: number;
+    /** Additional CSS class. */
+    className?: string;
+}
+/**
+ * Props for DashboardLayout component.
+ */
+interface DashboardLayoutProps {
+    /** Widgets to display. */
+    widgets: Widget$1[];
+    /** Layout configuration. */
+    layout: DashboardLayout$1;
+    /** Whether the layout is editable. */
+    editable?: boolean;
+    /** Callback when layout changes. */
+    onLayoutChange?: (positions: Record<string, WidgetPosition>) => void;
+    /** Render function for each widget. */
+    renderWidget: (widget: Widget$1) => React.ReactNode;
+    /** Additional CSS class. */
+    className?: string;
+}
+/**
+ * Props for Widget component.
+ */
+interface WidgetProps {
+    /** Widget to display. */
+    widget: Widget$1;
+    /** Query result for the widget. */
+    result: QueryResult | null;
+    /** Whether the widget is loading. */
+    isLoading?: boolean;
+    /** Error if query failed. */
+    error?: Error | null;
+    /** Additional CSS class. */
+    className?: string;
+    /** Unix timestamp when widget was last refreshed. */
+    lastRefreshed?: number;
+    /** Whether the widget is currently being refreshed (force refresh). */
+    isRefreshing?: boolean;
+    /** Callback to trigger widget refresh. */
+    onRefresh?: () => void;
+}
+/**
+ * Props for WidgetHeader component.
+ */
+interface WidgetHeaderProps {
+    /** Widget title. */
+    title: string;
+    /** Optional hyperlink for the widget (shows link icon in header). */
+    hyperlink?: WidgetHyperlink;
+    /** Unix timestamp when widget was last refreshed. */
+    lastRefreshed?: number;
+    /** Whether the widget is currently being refreshed (force refresh). */
+    isRefreshing?: boolean;
+    /** Callback to trigger widget refresh. */
+    onRefresh?: () => void;
+}
+/**
+ * Props for FilterBar component.
+ */
+interface FilterBarProps {
+    /** Filters to display. */
+    filters: DashboardFilter[];
+    /** Current filter values. */
+    values: FilterValue[];
+    /** Callback when a filter value changes. */
+    onChange: (filterId: string, value: unknown) => void;
+    /** Callback to reset all filters. */
+    onReset?: () => void;
+    /** Additional CSS class. */
+    className?: string;
+}
+/**
+ * Props for DateRangeFilter component.
+ */
+interface DateRangeFilterProps {
+    /** Filter definition. */
+    filter: DashboardFilter;
+    /** Current value (DateRangeValue or preset string). */
+    value: DateRangeValue | string | null;
+    /** Callback when value changes. */
+    onChange: (value: DateRangeValue | string) => void;
+}
+/**
+ * Props for SelectFilter component.
+ */
+interface SelectFilterProps {
+    /** Filter definition. */
+    filter: DashboardFilter;
+    /** Current value. */
+    value: string | null;
+    /** Callback when value changes. */
+    onChange: (value: string | null) => void;
+}
+/**
+ * Props for MultiSelectFilter component.
+ */
+interface MultiSelectFilterProps {
+    /** Filter definition. */
+    filter: DashboardFilter;
+    /** Current values. */
+    value: string[];
+    /** Callback when values change. */
+    onChange: (value: string[]) => void;
+}
+/**
+ * Props for TextFilter component.
+ */
+interface TextFilterProps {
+    /** Filter definition. */
+    filter: DashboardFilter;
+    /** Current value. */
+    value: string;
+    /** Callback when value changes. */
+    onChange: (value: string) => void;
+    /** Debounce delay in milliseconds. */
+    debounceMs?: number;
+}
+/**
+ * Props for WidgetPalette component.
+ */
+interface WidgetPaletteProps {
+    /** Callback when a widget type is selected. */
+    onAddWidget: (type: WidgetType) => void;
+}
+/**
+ * Props for WidgetEditor component.
+ */
+interface WidgetEditorProps {
+    /** Widget to edit. */
+    widget: Widget$1;
+    /** Database schema for column selection. */
+    schema: DatabaseSchema;
+    /** Callback when widget is saved. */
+    onSave: (widget: Widget$1) => void;
+    /** Callback when editing is cancelled. */
+    onCancel: () => void;
+}
+
+/**
+ * Dashboard context.
+ */
+declare const DashboardContext: react.Context<DashboardContextValue | null>;
+/**
+ * Provider component for dashboard state management.
+ */
+declare function DashboardProvider({ dashboardId, batchSize, lazyLoading, children, }: DashboardProviderProps): JSX.Element;
+
+/**
+ * Hook to access dashboard context.
+ */
+
+/**
+ * Hook to access the full dashboard context.
+ *
+ * Must be used within a DashboardProvider.
+ *
+ * @returns Dashboard context value
+ * @throws Error if used outside DashboardProvider
+ *
+ * @example
+ * ```tsx
+ * function DashboardHeader() {
+ *   const { dashboard, isLoading, refreshDashboard } = useDashboard();
+ *
+ *   if (isLoading) return <Spinner />;
+ *
+ *   return (
+ *     <header>
+ *       <h1>{dashboard?.name}</h1>
+ *       <button onClick={refreshDashboard}>Refresh</button>
+ *     </header>
+ *   );
+ * }
+ * ```
+ */
+declare function useDashboard(): DashboardContextValue;
+
+/**
+ * Hook to manage dashboard filter state.
+ */
+
+/**
+ * Result of the useDashboardFilters hook.
+ */
+interface UseDashboardFiltersResult {
+    /** All dashboard filters. */
+    filters: DashboardFilter[];
+    /** Current filter values. */
+    values: FilterValue[];
+    /** Set a filter value. */
+    setValue: (filterId: string, value: unknown) => void;
+    /** Reset all filters to defaults. */
+    resetAll: () => void;
+    /** Reset a single filter to its default. */
+    resetFilter: (filterId: string) => void;
+    /** Get the current value for a filter. */
+    getValue: (filterId: string) => unknown;
+}
+/**
+ * Hook to manage dashboard filter state.
+ *
+ * Provides convenient methods for working with dashboard filters.
+ *
+ * @returns Filter management utilities
+ *
+ * @example
+ * ```tsx
+ * function FilterControls() {
+ *   const { filters, values, setValue, resetAll, getValue } = useDashboardFilters();
+ *
+ *   return (
+ *     <div>
+ *       {filters.map((filter) => (
+ *         <FilterInput
+ *           key={filter.id}
+ *           filter={filter}
+ *           value={getValue(filter.id)}
+ *           onChange={(v) => setValue(filter.id, v)}
+ *         />
+ *       ))}
+ *       <button onClick={resetAll}>Reset</button>
+ *     </div>
+ *   );
+ * }
+ * ```
+ */
+declare function useDashboardFilters(): UseDashboardFiltersResult;
+
+/**
+ * Hook to access a single widget's state.
+ */
+
+/**
+ * Result of the useWidget hook.
+ */
+interface UseWidgetResult {
+    /** The widget definition. */
+    widget: Widget$1;
+    /** Query result for this widget (null if not yet loaded or text widget). */
+    result: QueryResult | null;
+    /** Whether the widget query is loading. */
+    isLoading: boolean;
+    /** Error if the query failed. */
+    error: Error | null;
+    /** Refresh this widget's data. */
+    refresh: () => Promise<void>;
+}
+/**
+ * Hook to access a single widget's state.
+ *
+ * Provides the widget definition, query result, loading state, and refresh function.
+ *
+ * @param widgetId - ID of the widget to access
+ * @returns Widget state and refresh function
+ * @throws Error if widget not found
+ *
+ * @example
+ * ```tsx
+ * function WidgetDisplay({ widgetId }: { widgetId: string }) {
+ *   const { widget, result, isLoading, error, refresh } = useWidget(widgetId);
+ *
+ *   if (isLoading) return <Spinner />;
+ *   if (error) return <Error message={error.message} />;
+ *
+ *   return (
+ *     <div>
+ *       <h3>{widget.title}</h3>
+ *       <Chart type={widget.type} data={result} />
+ *       <button onClick={refresh}>Refresh</button>
+ *     </div>
+ *   );
+ * }
+ * ```
+ */
+declare function useWidget(widgetId: string): UseWidgetResult;
+
+/**
+ * Hook for auto-refreshing dashboard data.
+ */
+/**
+ * Options for useAutoRefresh hook.
+ */
+interface UseAutoRefreshOptions {
+    /** Refresh callback to execute. */
+    onRefresh: () => Promise<void>;
+    /** Interval in milliseconds. Set to 0 to disable. */
+    intervalMs: number;
+    /** Whether to start paused. */
+    startPaused?: boolean;
+}
+/**
+ * Result of useAutoRefresh hook.
+ */
+interface UseAutoRefreshResult {
+    /** Whether auto-refresh is currently active. */
+    isActive: boolean;
+    /** Time until next refresh in milliseconds. */
+    timeUntilRefresh: number;
+    /** Pause auto-refresh. */
+    pause: () => void;
+    /** Resume auto-refresh. */
+    resume: () => void;
+    /** Toggle auto-refresh. */
+    toggle: () => void;
+    /** Trigger an immediate refresh. */
+    refreshNow: () => Promise<void>;
+}
+/**
+ * Hook for auto-refreshing data at a specified interval.
+ *
+ * @example
+ * ```tsx
+ * const { isActive, timeUntilRefresh, pause, resume, refreshNow } = useAutoRefresh({
+ *   onRefresh: async () => {
+ *     await fetchData();
+ *   },
+ *   intervalMs: 30000, // 30 seconds
+ * });
+ *
+ * return (
+ *   <div>
+ *     <button onClick={refreshNow}>Refresh Now</button>
+ *     <button onClick={isActive ? pause : resume}>
+ *       {isActive ? 'Pause' : 'Resume'}
+ *     </button>
+ *     <span>Next refresh in: {Math.round(timeUntilRefresh / 1000)}s</span>
+ *   </div>
+ * );
+ * ```
+ */
+declare function useAutoRefresh({ onRefresh, intervalMs, startPaused, }: UseAutoRefreshOptions): UseAutoRefreshResult;
+
+/**
+ * Hook for managing fullscreen mode.
+ */
+/**
+ * Result of useFullscreen hook.
+ */
+interface UseFullscreenResult {
+    /** Whether fullscreen mode is currently active. */
+    isFullscreen: boolean;
+    /** Enter fullscreen mode. */
+    enterFullscreen: () => Promise<void>;
+    /** Exit fullscreen mode. */
+    exitFullscreen: () => Promise<void>;
+    /** Toggle fullscreen mode. */
+    toggleFullscreen: () => Promise<void>;
+    /** Ref to attach to the element that should become fullscreen. */
+    ref: React.RefObject<HTMLDivElement>;
+}
+/**
+ * Hook for managing fullscreen mode on an element.
+ *
+ * @example
+ * ```tsx
+ * function Dashboard() {
+ *   const { isFullscreen, toggleFullscreen, ref } = useFullscreen();
+ *
+ *   return (
+ *     <div ref={ref}>
+ *       <button onClick={toggleFullscreen}>
+ *         {isFullscreen ? 'Exit Fullscreen' : 'Fullscreen'}
+ *       </button>
+ *       <DashboardContent />
+ *     </div>
+ *   );
+ * }
+ * ```
+ */
+declare function useFullscreen(): UseFullscreenResult;
+
+/**
+ * Main Dashboard component for embedding.
+ */
+
+/**
+ * Dashboard component for embedding.
+ *
+ * @example
+ * ```tsx
+ * <AnalyticsProvider endpoint="https://api.example.com">
+ *   <Dashboard
+ *     id="my-dashboard"
+ *     showFilters={true}
+ *     refreshInterval={60000}
+ *   />
+ * </AnalyticsProvider>
+ * ```
+ */
+declare function Dashboard({ id, showFilters, showTitle, refreshInterval, batchSize, lazyLoading, className, }: DashboardProps): JSX.Element;
+
+/**
+ * Dashboard grid layout component using react-grid-layout.
+ * Supports responsive breakpoints for mobile-friendly layouts.
+ */
+
+/**
+ * Dashboard grid layout component.
+ *
+ * Uses react-grid-layout to provide a responsive, draggable and resizable grid.
+ * Supports multiple breakpoints for mobile-friendly layouts.
+ *
+ * @example
+ * ```tsx
+ * <DashboardLayout
+ *   widgets={widgets}
+ *   layout={dashboardLayout}
+ *   editable={true}
+ *   onLayoutChange={(positions) => updatePositions(positions)}
+ *   renderWidget={(widget) => <Widget widget={widget} />}
+ * />
+ * ```
+ */
+declare function DashboardLayout({ widgets, layout, editable, onLayoutChange, renderWidget, className, }: DashboardLayoutProps): JSX.Element;
+
+/**
+ * Widget container component.
+ */
+
+/**
+ * Widget container with header and content.
+ *
+ * @example
+ * ```tsx
+ * <Widget
+ *   widget={widget}
+ *   result={queryResult}
+ *   isLoading={false}
+ *   lastRefreshed={1706123456}
+ *   isRefreshing={false}
+ *   onRefresh={() => refreshWidget(widget.id)}
+ * />
+ * ```
+ */
+declare function Widget({ widget, result, isLoading, error, className, lastRefreshed, isRefreshing, onRefresh, }: WidgetProps): JSX.Element;
+
+/**
+ * Widget header component with title, refresh button, and actions.
+ */
+
+/**
+ * Widget header with title, refresh timestamp, and optional hyperlink.
+ */
+declare function WidgetHeader({ title, hyperlink, lastRefreshed, isRefreshing, onRefresh, }: WidgetHeaderProps): JSX.Element;
+
+/**
+ * Widget content renderer that displays the appropriate chart or component.
+ */
+
+/**
+ * Props for WidgetContent.
+ */
+interface WidgetContentProps {
+    /** Widget to render. */
+    widget: Widget$1;
+    /** Query result data. */
+    result: QueryResult | null;
+    /** Whether data is loading. */
+    isLoading?: boolean;
+    /** Error if query failed. */
+    error?: Error | null;
+    /** Whether widget is being force-refreshed (shows spinner overlay). */
+    isRefreshing?: boolean;
+}
+/**
+ * Widget content renderer.
+ *
+ * Renders the appropriate visualization based on widget type.
+ */
+declare function WidgetContent({ widget, result, isLoading, error, isRefreshing, }: WidgetContentProps): JSX.Element;
+
+/**
+ * Filter bar component for dashboard filters.
+ */
+
+/**
+ * FilterBar component displays all dashboard filters.
+ */
+declare function FilterBar({ filters, values, onChange, onReset, className, }: FilterBarProps): JSX.Element | null;
+
+/**
+ * Date range filter component.
+ */
+
+/**
+ * Date range filter with start/end date inputs.
+ */
+declare function DateRangeFilter({ filter, value, onChange, }: DateRangeFilterProps): JSX.Element;
+
+/**
+ * Select filter component with dynamic option loading.
+ */
+
+/**
+ * Single select dropdown filter.
+ *
+ * Supports dynamic option loading when filter.dynamic is true.
+ */
+declare function SelectFilter({ filter, value, onChange, }: SelectFilterProps): JSX.Element;
+
+/**
+ * Multi-select filter component with dynamic option loading.
+ *
+ * Features:
+ * - "All" option at top (visually selects/deselects all options)
+ * - Deferred apply (changes only apply on "Apply" button click)
+ * - Search functionality
+ * - Item count display
+ * - "clear all" link
+ */
+
+/**
+ * Multi-select dropdown filter with deferred apply.
+ *
+ * Supports dynamic option loading when filter.dynamic is true.
+ *
+ * Note: External value [] means "no filter" (show all data).
+ * Internally, we track actual selections. When all options are selected,
+ * we send [] to the backend (no filter needed).
+ */
+declare function MultiSelectFilter({ filter, value, onChange, }: MultiSelectFilterProps): JSX.Element;
+
+/**
+ * Text filter component with debouncing.
+ */
+
+/**
+ * Text input filter with debounced updates.
+ */
+declare function TextFilter({ filter, value, onChange, debounceMs, }: TextFilterProps): JSX.Element;
+
+/**
+ * Dashboard editor component for creating and editing dashboards.
+ */
+
+declare function DashboardEditor({ dashboardId, onSave, onCancel, batchSize, className, }: DashboardEditorProps): JSX.Element;
+
+/**
+ * Dashboard editor toolbar component.
+ */
+/**
+ * Props for EditorToolbar component.
+ */
+interface EditorToolbarProps {
+    /** Dashboard name. */
+    dashboardName: string;
+    /** Callback when dashboard name changes. */
+    onNameChange?: (name: string) => void;
+    /** Whether there are unsaved changes. */
+    hasChanges: boolean;
+    /** Whether save is in progress. */
+    isSaving: boolean;
+    /** Callback when add widget is clicked. */
+    onAddWidget: () => void;
+    /** Callback when edit filters is clicked. */
+    onEditFilters?: () => void;
+    /** Callback when settings is clicked. */
+    onSettings?: () => void;
+    /** Callback when save is clicked. */
+    onSave: () => void;
+    /** Callback when cancel is clicked. */
+    onCancel: () => void;
+}
+/**
+ * Editor toolbar with actions for dashboard editing.
+ */
+declare function EditorToolbar({ dashboardName, onNameChange, hasChanges, isSaving, onAddWidget, onEditFilters, onSettings, onSave, onCancel, }: EditorToolbarProps): JSX.Element;
+
+/**
+ * Widget palette for adding new widgets to the dashboard.
+ */
+
+/**
+ * Widget palette for selecting widget types to add.
+ */
+declare function WidgetPalette({ onAddWidget, }: WidgetPaletteProps): JSX.Element;
+
+/**
+ * Widget editor modal for configuring widget properties.
+ */
+
+/**
+ * Widget editor for configuring widget properties.
+ */
+declare function WidgetEditor({ widget, schema, onSave, onCancel, }: WidgetEditorProps): JSX.Element;
+
+interface DashboardCardProps extends Omit<HTMLAttributes<HTMLDivElement>, 'onClick'> {
+    /** The dashboard to display. */
+    dashboard: Dashboard$2;
+    /** Called when the card is clicked. */
+    onClick?: (dashboard: Dashboard$2) => void;
+    /** Called when edit is requested. */
+    onEdit?: (dashboard: Dashboard$2) => void;
+    /** Called when delete is requested. */
+    onDelete?: (dashboard: Dashboard$2) => void;
+    /** Called when duplicate is requested. */
+    onDuplicate?: (dashboard: Dashboard$2) => void;
+    /** Whether the card is selected. */
+    selected?: boolean;
+    /** Whether actions are disabled. */
+    actionsDisabled?: boolean;
+    /** Custom action buttons. */
+    actions?: ReactNode;
+}
+/**
+ * Dashboard card component for displaying dashboard summary.
+ *
+ * @example
+ * ```tsx
+ * <DashboardCard
+ *   dashboard={dashboard}
+ *   onClick={(d) => navigate(`/dashboard/${d.id}`)}
+ *   onEdit={(d) => openEditDialog(d)}
+ *   onDelete={(d) => confirmDelete(d)}
+ * />
+ * ```
+ */
+declare const DashboardCard: react.ForwardRefExoticComponent<DashboardCardProps & react.RefAttributes<HTMLDivElement>>;
+
+interface DashboardListProps extends HTMLAttributes<HTMLDivElement> {
+    /** List of dashboards to display. */
+    dashboards: Dashboard$2[] | null;
+    /** Whether the list is loading. */
+    isLoading?: boolean;
+    /** Error that occurred during fetch. */
+    error?: Error | null;
+    /** Called when a dashboard card is clicked. */
+    onDashboardClick?: (dashboard: Dashboard$2) => void;
+    /** Called when edit is requested for a dashboard. */
+    onEdit?: (dashboard: Dashboard$2) => void;
+    /** Called when delete is requested for a dashboard. */
+    onDelete?: (dashboard: Dashboard$2) => void;
+    /** Called when duplicate is requested for a dashboard. */
+    onDuplicate?: (dashboard: Dashboard$2) => void;
+    /** Called when create new dashboard is requested. */
+    onCreate?: () => void;
+    /** Number of columns in the grid. */
+    columns?: 1 | 2 | 3 | 4;
+    /** ID of the currently selected dashboard. */
+    selectedId?: string;
+    /** Whether actions are disabled. */
+    actionsDisabled?: boolean;
+    /** Custom empty state content. */
+    emptyState?: ReactNode;
+    /** Custom card render function. */
+    renderCard?: (dashboard: Dashboard$2, props: DashboardCardProps) => ReactNode;
+}
+/**
+ * Dashboard list component for displaying all dashboards.
+ *
+ * @example
+ * ```tsx
+ * function DashboardsPage() {
+ *   const { data, isLoading, error } = useDashboards();
+ *   const { createDashboard } = useDashboardMutations();
+ *
+ *   return (
+ *     <DashboardList
+ *       dashboards={data}
+ *       isLoading={isLoading}
+ *       error={error}
+ *       onDashboardClick={(d) => navigate(`/dashboard/${d.id}`)}
+ *       onCreate={() => setShowCreateDialog(true)}
+ *     />
+ *   );
+ * }
+ * ```
+ */
+declare const DashboardList: react.ForwardRefExoticComponent<DashboardListProps & react.RefAttributes<HTMLDivElement>>;
+
+interface DashboardDialogProps {
+    /** Whether the dialog is open. */
+    open: boolean;
+    /** Called when the dialog should close. */
+    onClose: () => void;
+    /** Called when the form is submitted. */
+    onSubmit: (data: DashboardCreate | DashboardUpdate) => Promise<void>;
+    /** Dashboard to edit (null for create mode). */
+    dashboard?: Dashboard$2 | null;
+    /** Whether the submit action is loading. */
+    isLoading?: boolean;
+    /** Error message to display. */
+    error?: string | null;
+}
+/**
+ * Dialog for creating or editing a dashboard.
+ *
+ * @example
+ * ```tsx
+ * function DashboardsPage() {
+ *   const [dialogOpen, setDialogOpen] = useState(false);
+ *   const [editingDashboard, setEditingDashboard] = useState<Dashboard | null>(null);
+ *   const { createDashboard, updateDashboard, state } = useDashboardMutations();
+ *
+ *   const handleSubmit = async (data: DashboardCreate | DashboardUpdate) => {
+ *     if (editingDashboard) {
+ *       await updateDashboard(editingDashboard.id, data);
+ *     } else {
+ *       await createDashboard(data as DashboardCreate);
+ *     }
+ *     setDialogOpen(false);
+ *   };
+ *
+ *   return (
+ *     <DashboardDialog
+ *       open={dialogOpen}
+ *       onClose={() => setDialogOpen(false)}
+ *       onSubmit={handleSubmit}
+ *       dashboard={editingDashboard}
+ *       isLoading={state.isLoading}
+ *       error={state.error?.message}
+ *     />
+ *   );
+ * }
+ * ```
+ */
+declare const DashboardDialog: react.ForwardRefExoticComponent<DashboardDialogProps & react.RefAttributes<HTMLDivElement>>;
+
+export { TextFilter as $, useWidget as A, type UseWidgetResult as B, useAutoRefresh as C, type DashboardLayout$1 as D, type UseAutoRefreshOptions as E, type FilterOption as F, type UseAutoRefreshResult as G, useFullscreen as H, type UseFullscreenResult as I, Dashboard as J, DashboardLayout as K, type LazyLoadingConfig as L, type MultiSelectFilterProps as M, type NumberRangeValue as N, Widget as O, WidgetHeader as P, WidgetContent as Q, type ReferenceLine as R, type SelectFilterProps as S, type TextFilterProps as T, type UseDashboardFiltersResult as U, type WidgetContentProps as V, type Widget$1 as W, FilterBar as X, DateRangeFilter as Y, SelectFilter as Z, MultiSelectFilter as _, type WidgetPosition as a, DashboardEditor as a0, EditorToolbar as a1, WidgetPalette as a2, WidgetEditor as a3, type EditorToolbarProps as a4, DashboardList as a5, DashboardCard as a6, DashboardDialog as a7, type DashboardListProps as a8, type DashboardCardProps as a9, type DashboardDialogProps as aa, type WidgetType as b, type WidgetConfig as c, type WidgetCrossFilterConfig as d, type WidgetHyperlink as e, type DashboardFilterType as f, type DashboardFilter as g, type FilterValue as h, type DateRangeValue as i, type Dashboard$1 as j, type DashboardContextValue as k, type DashboardEditorContextValue as l, type DashboardProviderProps as m, type DashboardProps as n, type DashboardEditorProps as o, type DashboardLayoutProps as p, type WidgetProps as q, type WidgetHeaderProps as r, type FilterBarProps as s, type DateRangeFilterProps as t, type WidgetPaletteProps as u, type WidgetEditorProps as v, DashboardProvider as w, DashboardContext as x, useDashboard as y, useDashboardFilters as z };