@prismiq/react 0.1.0

package/dist/index.d.ts

@@ -0,0 +1,1435 @@
+import { D as DatabaseSchema, c as TableSchema, a as QueryDefinition, V as ValidationResult, Q as QueryResult, S as SQLValidationResult, d as Dashboard, e as DashboardCreate, f as DashboardUpdate, W as WidgetCreate, g as Widget, h as WidgetUpdate, i as WidgetPositionUpdate, j as SavedQuery, k as SavedQueryCreate, l as SavedQueryUpdate, P as PinnedDashboard, m as PinnedDashboardsResponse, R as Relationship, n as WidgetPosition } from './types-WrCbOeAV.js';
+export { A as AggregationType, o as ColumnSchema, q as ColumnSelection, u as DashboardPinContextsResponse, E as ExecuteSQLRequest, r as FilterDefinition, F as FilterOperator, G as GroupByDefinition, J as JoinDefinition, p as JoinType, b as QueryTable, t as SortDefinition, s as SortDirection } from './types-WrCbOeAV.js';
+import { P as PrismiqTheme, T as ThemeMode, D as DeepPartial, a as ThemeContextValue, C as ChartDataOptions, b as ChartDataResult } from './index-rPc7ijt8.js';
+export { A as AreaChart, F as AreaChartProps, v as AxisFormat, B as BarChart, y as BarChartProps, r as BaseChartProps, u as ChartClickParams, o as ChartDataPoint, p as ChartSeries, Q as ChartSuggestion, O as ChartType, E as EChartWrapper, x as EChartWrapperProps, w as LegendPosition, L as LineChart, z as LineChartProps, M as MetricCard, J as MetricCardProps, d as PieChart, G as PieChartProps, R as ReferenceLineConfig, e as ScatterChart, H as ScatterChartProps, S as Sparkline, N as SparklineProps, I as TrendConfig, c as TrendIndicator, K as TrendIndicatorProps, h as applyThemeToOption, g as createChartTheme, m as createGradientColor, f as dataPointsToChartData, i as formatAxisLabel, j as formatCompact, k as formatMetricValue, l as getChartColors, n as isChartDataEmpty, q as queryResultToChartData, s as suggestChartType, t as toChartData } from './index-rPc7ijt8.js';
+import { ReactNode, CSSProperties } from 'react';
+export { ai as AggregationPicker, aj as AggregationPickerProps, a as Badge, m as BadgeProps, B as Button, h as ButtonProps, C as Checkbox, l as CheckboxProps, a0 as ColumnNode, a3 as ColumnNodeProps, a4 as ColumnSelector, a6 as ColumnSelectorProps, aD as CustomSQLEditor, aE as CustomSQLEditorProps, e as Dialog, g as DialogFooter, v as DialogFooterProps, f as DialogHeader, u as DialogHeaderProps, t as DialogProps, D as Dropdown, b as DropdownItem, p as DropdownItemProps, o as DropdownProps, c as DropdownSeparator, q as DropdownSeparatorProps, U as EmptyDashboard, Z as EmptyDashboardProps, P as EmptyState, V as EmptyStateProps, K as ErrorBoundary, M as ErrorBoundaryProps, L as ErrorFallback, N as ErrorFallbackProps, a8 as FilterBuilder, ab as FilterBuilderProps, a9 as FilterRow, ac as FilterRowProps, aa as FilterValueInput, ad as FilterValueInputProps, d as Icon, s as IconName, r as IconProps, I as Input, i as InputProps, Q as NoData, X as NoDataProps, R as NoResults, Y as NoResultsProps, ao as Pagination, at as PaginationProps, au as QueryBuilder, ax as QueryBuilderProps, ay as QueryBuilderState, av as QueryBuilderToolbar, az as QueryBuilderToolbarProps, aw as QueryPreview, aA as QueryPreviewProps, ak as ResultsTable, ap as ResultsTableProps, aB as SavedQueryPicker, aC as SavedQueryPickerProps, _ as SchemaExplorer, a1 as SchemaExplorerProps, S as Select, k as SelectOption, j as SelectProps, a5 as SelectedColumn, a7 as SelectedColumnProps, w as Skeleton, y as SkeletonChart, G as SkeletonChartProps, A as SkeletonMetricCard, J as SkeletonMetricCardProps, E as SkeletonProps, z as SkeletonTable, H as SkeletonTableProps, x as SkeletonText, F as SkeletonTextProps, ae as SortBuilder, ag as SortBuilderProps, af as SortRow, ah as SortRowProps, an as TableCell, as as TableCellProps, al as TableHeader, aq as TableHeaderProps, $ as TableNode, a2 as TableNodeProps, am as TableRow, ar as TableRowProps, T as Tooltip, n as TooltipProps, W as WidgetErrorBoundary, O as WidgetErrorBoundaryProps } from './CustomSQLEditor-DYeId0Gp.js';
+export { ExcelCellStyle, ExcelExportOptions, ExportData, ExportOptions, UseExportOptions, UseExportResult, downloadFile, exportMultipleSheets, exportToCSV, exportToExcel, generateCSV, useExport } from './export/index.js';
+export { J as Dashboard, a6 as DashboardCard, a9 as DashboardCardProps, x as DashboardContext, k as DashboardContextValue, j as DashboardDefinition, a7 as DashboardDialog, aa as DashboardDialogProps, a0 as DashboardEditor, l as DashboardEditorContextValue, o as DashboardEditorProps, g as DashboardFilter, f as DashboardFilterType, D as DashboardLayout, K as DashboardLayoutComponent, p as DashboardLayoutProps, a5 as DashboardList, a8 as DashboardListProps, n as DashboardProps, w as DashboardProvider, m as DashboardProviderProps, Y as DateRangeFilter, t as DateRangeFilterProps, i as DateRangeValue, a1 as EditorToolbar, a4 as EditorToolbarProps, X as FilterBar, s as FilterBarProps, F as FilterOption, h as FilterValue, _ as MultiSelectFilter, M as MultiSelectFilterProps, N as NumberRangeValue, Z as SelectFilter, S as SelectFilterProps, $ as TextFilter, T as TextFilterProps, E as UseAutoRefreshOptions, G as UseAutoRefreshResult, U as UseDashboardFiltersResult, I as UseFullscreenResult, B as UseWidgetResult, O as Widget, c as WidgetConfig, Q as WidgetContent, V as WidgetContentProps, W as WidgetDefinition, a3 as WidgetEditor, v as WidgetEditorProps, P as WidgetHeader, r as WidgetHeaderProps, a2 as WidgetPalette, u as WidgetPaletteProps, a as WidgetPosition, q as WidgetProps, b as WidgetType, C as useAutoRefresh, y as useDashboard, z as useDashboardFilters, H as useFullscreen, A as useWidget } from './DashboardDialog-B3vYC5Gs.js';
+export { A as ArrowNavigationOptions, F as FocusTrapOptions, S as SkipLinkProps, g as UseArrowNavigationResult, U as UseFocusTrapResult, d as announceToScreenReader, f as focusVisibleStyles, e as skipLinkFocusStyles, s as skipLinkStyles, a as useArrowNavigation, u as useFocusTrap, c as useFocusVisible, b as useRovingTabIndex } from './accessibility-2yy5yqRR.js';
+export { BREAKPOINTS, Breakpoint, ClientOnly, ClientOnlyProps, WindowSize, getLocalStorage, getWindowHeight, getWindowWidth, isBrowser, isServer, removeLocalStorage, setLocalStorage, useBreakpoint, useIsBreakpoint, useIsClient, useMediaQuery, useWindowSize } from './ssr/index.js';
+
+/**
+ * Prismiq API Client.
+ *
+ * Typed HTTP client for communicating with the Prismiq backend.
+ */
+
+/**
+ * Configuration for the Prismiq client.
+ */
+interface ClientConfig {
+    /** Base URL of the Prismiq API endpoint. */
+    endpoint: string;
+    /**
+     * Tenant ID for multi-tenant isolation.
+     * All API calls will include this in the X-Tenant-ID header.
+     * Required for production use.
+     */
+    tenantId: string;
+    /**
+     * User ID for ownership and permissions.
+     * Included in X-User-ID header when provided.
+     * Used for dashboard ownership and access control.
+     */
+    userId?: string;
+    /**
+     * PostgreSQL schema name for per-tenant schema isolation.
+     * Included in X-Schema-Name header when provided.
+     * Used when each tenant has their own PostgreSQL schema (e.g., "org_123").
+     */
+    schemaName?: string;
+    /**
+     * Custom headers to include with every request.
+     * Useful for application-specific headers like row-level security filters.
+     * Keys are header names, values are header values.
+     */
+    customHeaders?: Record<string, string>;
+    /** Optional function to get an authentication token. */
+    getToken?: () => Promise<string> | string;
+}
+/**
+ * Base error class for Prismiq API errors.
+ */
+declare class PrismiqError extends Error {
+    readonly statusCode?: number | undefined;
+    constructor(message: string, statusCode?: number | undefined);
+}
+/**
+ * HTTP client for the Prismiq backend API.
+ *
+ * @example
+ * ```typescript
+ * const client = new PrismiqClient({
+ *   endpoint: 'https://api.example.com/analytics',
+ *   getToken: () => authService.getToken(),
+ * });
+ *
+ * const schema = await client.getSchema();
+ * const result = await client.executeQuery(query);
+ * ```
+ */
+declare class PrismiqClient {
+    private readonly endpoint;
+    private readonly tenantId;
+    private readonly userId?;
+    private readonly schemaName?;
+    private readonly customHeaders?;
+    private readonly getToken?;
+    constructor(config: ClientConfig);
+    /**
+     * Make an authenticated request to the API.
+     */
+    private request;
+    /**
+     * Make a GET request to the API.
+     *
+     * @param path - API path (starting with /)
+     * @returns Response data
+     */
+    get<T>(path: string): Promise<T>;
+    /**
+     * Make a POST request to the API.
+     *
+     * @param path - API path (starting with /)
+     * @param body - Request body (will be JSON stringified)
+     * @returns Response data
+     */
+    post<T>(path: string, body?: unknown): Promise<T>;
+    /**
+     * Make a PUT request to the API.
+     *
+     * @param path - API path (starting with /)
+     * @param body - Request body (will be JSON stringified)
+     * @returns Response data
+     */
+    put<T>(path: string, body?: unknown): Promise<T>;
+    /**
+     * Make a PATCH request to the API.
+     *
+     * @param path - API path (starting with /)
+     * @param body - Request body (will be JSON stringified)
+     * @returns Response data
+     */
+    patch<T>(path: string, body?: unknown): Promise<T>;
+    /**
+     * Make a DELETE request to the API.
+     *
+     * @param path - API path (starting with /)
+     * @returns Response data
+     */
+    delete<T>(path: string): Promise<T>;
+    /**
+     * Get the complete database schema.
+     *
+     * @returns The database schema including all tables and relationships.
+     */
+    getSchema(): Promise<DatabaseSchema>;
+    /**
+     * Get a list of available table names.
+     *
+     * @returns Array of table names.
+     */
+    getTables(): Promise<string[]>;
+    /**
+     * Get schema information for a specific table.
+     *
+     * @param tableName - The name of the table.
+     * @returns The table schema including columns.
+     */
+    getTable(tableName: string): Promise<TableSchema>;
+    /**
+     * Get sample values from a column for data preview.
+     *
+     * @param tableName - The name of the table.
+     * @param columnName - The name of the column.
+     * @param limit - Maximum number of distinct values to return (default: 5).
+     * @returns Array of sample values.
+     */
+    getColumnSample(tableName: string, columnName: string, limit?: number): Promise<unknown[]>;
+    /**
+     * Validate a query without executing it.
+     *
+     * @param query - The query definition to validate.
+     * @returns Validation result with any errors.
+     */
+    validateQuery(query: QueryDefinition): Promise<ValidationResult>;
+    /**
+     * Generate SQL from a query definition without executing.
+     *
+     * @param query - The query definition.
+     * @returns The generated SQL string.
+     */
+    generateSql(query: QueryDefinition): Promise<string>;
+    /**
+     * Execute a query and return the full result.
+     *
+     * @param query - The query definition to execute.
+     * @param bypassCache - If true, bypass cache and re-execute query.
+     * @returns The query result with all rows and cache metadata.
+     */
+    executeQuery(query: QueryDefinition, bypassCache?: boolean): Promise<QueryResult>;
+    /**
+     * Execute a query with a limited result set for previewing.
+     *
+     * @param query - The query definition to execute.
+     * @param limit - Maximum number of rows to return (default: 100).
+     * @returns The query result with limited rows.
+     */
+    previewQuery(query: QueryDefinition, limit?: number): Promise<QueryResult>;
+    /**
+     * Validate a raw SQL query without executing it.
+     *
+     * Checks that the SQL is a valid SELECT statement and only
+     * references tables visible in the schema.
+     *
+     * @param sql - Raw SQL query to validate.
+     * @returns Validation result with any errors and referenced tables.
+     */
+    validateSQL(sql: string): Promise<SQLValidationResult>;
+    /**
+     * Execute a raw SQL query.
+     *
+     * Only SELECT statements are allowed. Queries are restricted
+     * to tables visible in the schema.
+     *
+     * @param sql - Raw SQL query (SELECT only).
+     * @param params - Optional named parameters for the query.
+     * @returns The query result with all rows.
+     */
+    executeSQL(sql: string, params?: Record<string, unknown>): Promise<QueryResult>;
+    /**
+     * List all dashboards accessible to the current user.
+     *
+     * @returns Array of dashboards.
+     */
+    listDashboards(): Promise<Dashboard[]>;
+    /**
+     * Get a specific dashboard by ID.
+     *
+     * @param id - The dashboard ID.
+     * @returns The dashboard with all widgets.
+     */
+    getDashboard(id: string): Promise<Dashboard>;
+    /**
+     * Create a new dashboard.
+     *
+     * @param data - Dashboard creation data.
+     * @returns The created dashboard.
+     */
+    createDashboard(data: DashboardCreate): Promise<Dashboard>;
+    /**
+     * Update an existing dashboard.
+     *
+     * @param id - The dashboard ID.
+     * @param data - Dashboard update data.
+     * @returns The updated dashboard.
+     */
+    updateDashboard(id: string, data: DashboardUpdate): Promise<Dashboard>;
+    /**
+     * Delete a dashboard.
+     *
+     * @param id - The dashboard ID.
+     */
+    deleteDashboard(id: string): Promise<void>;
+    /**
+     * Add a widget to a dashboard.
+     *
+     * @param dashboardId - The dashboard ID.
+     * @param data - Widget creation data.
+     * @returns The created widget.
+     */
+    addWidget(dashboardId: string, data: WidgetCreate): Promise<Widget>;
+    /**
+     * Update a widget.
+     *
+     * @param dashboardId - The dashboard ID.
+     * @param widgetId - The widget ID.
+     * @param data - Widget update data.
+     * @returns The updated widget.
+     */
+    updateWidget(dashboardId: string, widgetId: string, data: WidgetUpdate): Promise<Widget>;
+    /**
+     * Delete a widget from a dashboard.
+     *
+     * @param dashboardId - The dashboard ID.
+     * @param widgetId - The widget ID.
+     */
+    deleteWidget(dashboardId: string, widgetId: string): Promise<void>;
+    /**
+     * Update the layout (positions) of multiple widgets.
+     *
+     * @param dashboardId - The dashboard ID.
+     * @param positions - Array of widget position updates.
+     * @returns The updated dashboard.
+     */
+    updateLayout(dashboardId: string, positions: WidgetPositionUpdate[]): Promise<Dashboard>;
+    /**
+     * List all saved queries accessible to the current user.
+     *
+     * @returns Array of saved queries.
+     */
+    listSavedQueries(): Promise<SavedQuery[]>;
+    /**
+     * Get a specific saved query by ID.
+     *
+     * @param id - The saved query ID.
+     * @returns The saved query.
+     */
+    getSavedQuery(id: string): Promise<SavedQuery>;
+    /**
+     * Create a new saved query.
+     *
+     * @param data - Saved query creation data.
+     * @returns The created saved query.
+     */
+    createSavedQuery(data: SavedQueryCreate): Promise<SavedQuery>;
+    /**
+     * Update an existing saved query.
+     *
+     * @param id - The saved query ID.
+     * @param data - Saved query update data.
+     * @returns The updated saved query.
+     */
+    updateSavedQuery(id: string, data: SavedQueryUpdate): Promise<SavedQuery>;
+    /**
+     * Delete a saved query.
+     *
+     * @param id - The saved query ID.
+     */
+    deleteSavedQuery(id: string): Promise<void>;
+    /**
+     * Pin a dashboard to a context.
+     *
+     * @param dashboardId - The dashboard ID to pin.
+     * @param context - The context to pin to (e.g., "accounts", "dashboard").
+     * @param position - Optional position in the list (appends at end if not provided).
+     * @returns The created pin entry.
+     */
+    pinDashboard(dashboardId: string, context: string, position?: number): Promise<PinnedDashboard>;
+    /**
+     * Unpin a dashboard from a context.
+     *
+     * @param dashboardId - The dashboard ID to unpin.
+     * @param context - The context to unpin from.
+     */
+    unpinDashboard(dashboardId: string, context: string): Promise<void>;
+    /**
+     * Get all dashboards pinned to a context.
+     *
+     * @param context - The context to get pins for (e.g., "accounts", "dashboard").
+     * @returns Response with dashboards and pin metadata.
+     */
+    getPinnedDashboards(context: string): Promise<PinnedDashboardsResponse>;
+    /**
+     * Get all contexts where a dashboard is pinned.
+     *
+     * @param dashboardId - The dashboard ID.
+     * @returns List of context names.
+     */
+    getDashboardPinContexts(dashboardId: string): Promise<string[]>;
+    /**
+     * Reorder pinned dashboards within a context.
+     *
+     * @param context - The context to reorder pins in.
+     * @param dashboardIds - Ordered list of dashboard IDs (new order).
+     */
+    reorderPins(context: string, dashboardIds: string[]): Promise<void>;
+}
+
+/**
+ * Default theme definitions for Prismiq.
+ */
+
+/**
+ * Light theme - the default Prismiq theme.
+ */
+declare const lightTheme: PrismiqTheme;
+/**
+ * Dark theme for Prismiq.
+ */
+declare const darkTheme: PrismiqTheme;
+
+interface ThemeProviderProps {
+    /** Child components. */
+    children: ReactNode;
+    /** Initial theme mode. If not set, uses stored mode or system preference. */
+    defaultMode?: ThemeMode;
+    /** Custom theme overrides for light mode. */
+    lightTheme?: DeepPartial<PrismiqTheme>;
+    /** Custom theme overrides for dark mode. */
+    darkTheme?: DeepPartial<PrismiqTheme>;
+    /** Custom class name for the wrapper element. */
+    className?: string;
+}
+/**
+ * Theme provider that manages theme mode and injects CSS variables.
+ *
+ * @example
+ * ```tsx
+ * function App() {
+ *   return (
+ *     <ThemeProvider defaultMode="system">
+ *       <Dashboard />
+ *     </ThemeProvider>
+ *   );
+ * }
+ * ```
+ */
+declare function ThemeProvider({ children, defaultMode, lightTheme: customLightTheme, darkTheme: customDarkTheme, className, }: ThemeProviderProps): JSX.Element;
+
+/**
+ * useTheme hook.
+ *
+ * Provides access to the current theme and mode.
+ */
+
+/**
+ * Hook to access the theme context.
+ *
+ * Must be used within a ThemeProvider.
+ *
+ * @throws Error if used outside of ThemeProvider.
+ *
+ * @example
+ * ```tsx
+ * function ThemeToggle() {
+ *   const { mode, setMode, resolvedMode } = useTheme();
+ *
+ *   return (
+ *     <button onClick={() => setMode(mode === 'dark' ? 'light' : 'dark')}>
+ *       Current: {resolvedMode}
+ *     </button>
+ *   );
+ * }
+ * ```
+ */
+declare function useTheme(): ThemeContextValue;
+
+/**
+ * Analytics Provider and Context.
+ *
+ * Provides the Prismiq client and schema to React components.
+ */
+
+/**
+ * Value provided by the AnalyticsContext.
+ */
+interface AnalyticsContextValue {
+    /** The Prismiq API client instance. */
+    client: PrismiqClient;
+    /** The database schema, or null if not yet loaded. */
+    schema: DatabaseSchema | null;
+    /** Whether the schema is currently loading. */
+    isLoading: boolean;
+    /** Error that occurred during schema loading, if any. */
+    error: Error | null;
+    /** Function to manually refresh the schema. */
+    refetchSchema: () => Promise<void>;
+    /** Current tenant ID for multi-tenant isolation. */
+    tenantId: string;
+    /** Current user ID for ownership and permissions. */
+    userId?: string;
+    /** PostgreSQL schema name for per-tenant schema isolation. */
+    schemaName?: string;
+}
+/**
+ * Props for the AnalyticsProvider component.
+ */
+interface AnalyticsProviderProps {
+    /** Configuration for the Prismiq client. tenantId, userId, schemaName are provided via separate props. */
+    config: Omit<ClientConfig, 'tenantId' | 'userId' | 'schemaName'>;
+    /**
+     * Tenant ID for multi-tenant isolation.
+     * All API calls will include this in the X-Tenant-ID header.
+     * Required for production use.
+     */
+    tenantId: string;
+    /**
+     * User ID for ownership and permissions.
+     * Included in X-User-ID header when provided.
+     * Used for dashboard ownership and access control.
+     */
+    userId?: string;
+    /**
+     * PostgreSQL schema name for per-tenant schema isolation.
+     * Included in X-Schema-Name header when provided.
+     * Used when each tenant has their own PostgreSQL schema (e.g., "org_123").
+     */
+    schemaName?: string;
+    /** Callback when a query is executed successfully. */
+    onQueryExecute?: (query: QueryDefinition, result: QueryResult) => void;
+    /** Callback when a query execution fails. */
+    onQueryError?: (query: QueryDefinition, error: Error) => void;
+    /** Callback when schema is loaded successfully. */
+    onSchemaLoad?: (schema: DatabaseSchema) => void;
+    /** Callback when schema loading fails. */
+    onSchemaError?: (error: Error) => void;
+    /** Child components that will have access to the analytics context. */
+    children: ReactNode;
+}
+interface AnalyticsCallbacks {
+    onQueryExecute?: (query: QueryDefinition, result: QueryResult) => void;
+    onQueryError?: (query: QueryDefinition, error: Error) => void;
+}
+/**
+ * Hook to access analytics callbacks.
+ * For internal use by components that need to fire callbacks.
+ */
+declare function useAnalyticsCallbacks(): AnalyticsCallbacks;
+declare function AnalyticsProvider({ config, tenantId, userId, schemaName, onQueryExecute, onQueryError, onSchemaLoad, onSchemaError, children, }: AnalyticsProviderProps): JSX.Element;
+/**
+ * Hook to access the analytics context.
+ *
+ * Must be used within an AnalyticsProvider.
+ *
+ * @throws Error if used outside of AnalyticsProvider.
+ *
+ * @example
+ * ```tsx
+ * function Dashboard() {
+ *   const { client, schema, isLoading, error } = useAnalytics();
+ *
+ *   if (isLoading) return <Loading />;
+ *   if (error) return <Error message={error.message} />;
+ *
+ *   return <TableList tables={schema?.tables ?? []} />;
+ * }
+ * ```
+ */
+declare function useAnalytics(): AnalyticsContextValue;
+
+/**
+ * useSchema hook.
+ *
+ * Provides convenient access to database schema with helper methods.
+ */
+
+/**
+ * Result of the useSchema hook.
+ */
+interface UseSchemaResult {
+    /** The complete database schema, or null if not yet loaded. */
+    schema: DatabaseSchema | null;
+    /** List of tables in the schema. */
+    tables: TableSchema[];
+    /** List of relationships between tables. */
+    relationships: Relationship[];
+    /** Whether the schema is currently loading. */
+    isLoading: boolean;
+    /** Error that occurred during schema loading, if any. */
+    error: Error | null;
+    /** Get a table by name. */
+    getTable: (name: string) => TableSchema | undefined;
+}
+/**
+ * Hook for accessing the database schema.
+ *
+ * Provides the schema from the AnalyticsProvider context with
+ * convenient helper methods for working with tables.
+ *
+ * @example
+ * ```tsx
+ * function TableExplorer() {
+ *   const { tables, isLoading, getTable } = useSchema();
+ *
+ *   if (isLoading) return <Loading />;
+ *
+ *   const usersTable = getTable('users');
+ *
+ *   return (
+ *     <ul>
+ *       {tables.map(table => (
+ *         <li key={table.name}>{table.name}</li>
+ *       ))}
+ *     </ul>
+ *   );
+ * }
+ * ```
+ */
+declare function useSchema(): UseSchemaResult;
+
+/**
+ * useQuery hook.
+ *
+ * Executes queries against the Prismiq backend with caching and cancellation.
+ */
+
+/**
+ * Options for the useQuery hook.
+ */
+interface UseQueryOptions {
+    /**
+     * Whether the query should be executed.
+     * Set to false to disable automatic execution.
+     * @default true
+     */
+    enabled?: boolean;
+    /**
+     * Whether to use the preview endpoint (limited results).
+     * @default false
+     */
+    preview?: boolean;
+    /**
+     * Maximum number of rows to return when using preview.
+     * @default 100
+     */
+    previewLimit?: number;
+}
+/**
+ * Result of the useQuery hook.
+ */
+interface UseQueryResult {
+    /** The query result data, or null if not yet loaded. */
+    data: QueryResult | null;
+    /** Whether the query is currently loading. */
+    isLoading: boolean;
+    /** Error that occurred during query execution, if any. */
+    error: Error | null;
+    /** Function to manually re-execute the query. */
+    refetch: () => Promise<void>;
+}
+/**
+ * Hook for executing queries against the Prismiq backend.
+ *
+ * The query is automatically executed when:
+ * - The query definition changes
+ * - enabled is true
+ * - The query is not null
+ *
+ * Supports cancellation when the component unmounts or the query changes.
+ *
+ * @param query - The query definition to execute, or null to skip.
+ * @param options - Configuration options.
+ *
+ * @example
+ * ```tsx
+ * function QueryResults() {
+ *   const query: QueryDefinition = {
+ *     tables: [{ id: 't1', name: 'users' }],
+ *     columns: [
+ *       { table_id: 't1', column: 'name', aggregation: 'none' },
+ *     ],
+ *   };
+ *
+ *   const { data, isLoading, error } = useQuery(query, { preview: true });
+ *
+ *   if (isLoading) return <Loading />;
+ *   if (error) return <Error message={error.message} />;
+ *
+ *   return (
+ *     <table>
+ *       <thead>
+ *         <tr>
+ *           {data?.columns.map(col => <th key={col}>{col}</th>)}
+ *         </tr>
+ *       </thead>
+ *       <tbody>
+ *         {data?.rows.map((row, i) => (
+ *           <tr key={i}>
+ *             {row.map((cell, j) => <td key={j}>{String(cell)}</td>)}
+ *           </tr>
+ *         ))}
+ *       </tbody>
+ *     </table>
+ *   );
+ * }
+ * ```
+ */
+declare function useQuery(query: QueryDefinition | null, options?: UseQueryOptions): UseQueryResult;
+
+/**
+ * Hook for transforming QueryResult to chart-ready format.
+ */
+
+/**
+ * Transforms a QueryResult into chart-ready data format.
+ *
+ * Features:
+ * - Extracts categories and series from query result
+ * - Supports grouping by column for multi-series
+ * - Sorting by X or Y values
+ * - Limiting number of data points
+ * - Memoized for performance
+ *
+ * @example
+ * ```tsx
+ * const { categories, series, isEmpty } = useChartData(queryResult, {
+ *   xColumn: 'month',
+ *   yColumns: ['revenue', 'cost'],
+ *   sortBy: 'y',
+ *   sortDirection: 'desc',
+ *   limit: 10,
+ * });
+ * ```
+ */
+declare function useChartData(result: QueryResult | null, options: ChartDataOptions): ChartDataResult;
+
+/**
+ * useDashboards hook.
+ *
+ * Fetches and manages the list of dashboards from the Prismiq backend.
+ */
+
+/**
+ * Options for the useDashboards hook.
+ */
+interface UseDashboardsOptions {
+    /**
+     * Whether to automatically fetch dashboards on mount.
+     * @default true
+     */
+    enabled?: boolean;
+}
+/**
+ * Result of the useDashboards hook.
+ */
+interface UseDashboardsResult {
+    /** The list of dashboards, or null if not yet loaded. */
+    data: Dashboard[] | null;
+    /** Whether the dashboards are currently loading. */
+    isLoading: boolean;
+    /** Error that occurred during fetch, if any. */
+    error: Error | null;
+    /** Function to manually refresh the dashboard list. */
+    refetch: () => Promise<void>;
+}
+/**
+ * Hook for fetching the list of dashboards.
+ *
+ * @param options - Configuration options.
+ *
+ * @example
+ * ```tsx
+ * function DashboardList() {
+ *   const { data, isLoading, error } = useDashboards();
+ *
+ *   if (isLoading) return <Loading />;
+ *   if (error) return <Error message={error.message} />;
+ *
+ *   return (
+ *     <ul>
+ *       {data?.map(dashboard => (
+ *         <li key={dashboard.id}>{dashboard.name}</li>
+ *       ))}
+ *     </ul>
+ *   );
+ * }
+ * ```
+ */
+declare function useDashboards(options?: UseDashboardsOptions): UseDashboardsResult;
+
+/**
+ * useDashboard hook.
+ *
+ * Fetches a single dashboard by ID from the Prismiq backend.
+ */
+
+/**
+ * Options for the useDashboard hook.
+ */
+interface UseDashboardOptions {
+    /**
+     * Whether to automatically fetch the dashboard on mount.
+     * @default true
+     */
+    enabled?: boolean;
+}
+/**
+ * Result of the useDashboard hook.
+ */
+interface UseDashboardResult {
+    /** The dashboard data, or null if not yet loaded. */
+    data: Dashboard | null;
+    /** Whether the dashboard is currently loading. */
+    isLoading: boolean;
+    /** Error that occurred during fetch, if any. */
+    error: Error | null;
+    /** Function to manually refresh the dashboard. */
+    refetch: () => Promise<void>;
+    /**
+     * Optimistically update widget positions.
+     * Updates local state immediately without waiting for API.
+     */
+    optimisticUpdatePositions: (positions: Record<string, WidgetPosition> | WidgetPositionUpdate[]) => void;
+}
+/**
+ * Hook for fetching a single dashboard by ID.
+ *
+ * @param dashboardId - The ID of the dashboard to fetch, or null to skip.
+ * @param options - Configuration options.
+ *
+ * @example
+ * ```tsx
+ * function DashboardView({ id }: { id: string }) {
+ *   const { data, isLoading, error } = useDashboard(id);
+ *
+ *   if (isLoading) return <Loading />;
+ *   if (error) return <Error message={error.message} />;
+ *   if (!data) return null;
+ *
+ *   return (
+ *     <div>
+ *       <h1>{data.name}</h1>
+ *       <p>{data.description}</p>
+ *       {data.widgets.map(widget => (
+ *         <Widget key={widget.id} widget={widget} />
+ *       ))}
+ *     </div>
+ *   );
+ * }
+ * ```
+ */
+declare function useDashboard(dashboardId: string | null, options?: UseDashboardOptions): UseDashboardResult;
+
+/**
+ * useDashboardMutations hook.
+ *
+ * Provides mutation functions for creating, updating, and deleting dashboards and widgets.
+ */
+
+/**
+ * State for a mutation operation.
+ */
+interface MutationState {
+    /** Whether a mutation is in progress. */
+    isLoading: boolean;
+    /** Error from the last mutation, if any. */
+    error: Error | null;
+}
+/**
+ * Result of the useDashboardMutations hook.
+ */
+interface UseDashboardMutationsResult {
+    /** Current mutation state. */
+    state: MutationState;
+    /** Create a new dashboard. */
+    createDashboard: (data: DashboardCreate) => Promise<Dashboard>;
+    /** Update an existing dashboard. */
+    updateDashboard: (id: string, data: DashboardUpdate) => Promise<Dashboard>;
+    /** Delete a dashboard. */
+    deleteDashboard: (id: string) => Promise<void>;
+    /** Add a widget to a dashboard. */
+    addWidget: (dashboardId: string, data: WidgetCreate) => Promise<Widget>;
+    /** Update a widget. */
+    updateWidget: (dashboardId: string, widgetId: string, data: WidgetUpdate) => Promise<Widget>;
+    /** Delete a widget. */
+    deleteWidget: (dashboardId: string, widgetId: string) => Promise<void>;
+    /** Update widget positions in a dashboard. */
+    updateLayout: (dashboardId: string, positions: WidgetPositionUpdate[]) => Promise<Dashboard>;
+}
+/**
+ * Hook for dashboard and widget mutations.
+ *
+ * All mutation functions return promises and update the shared loading/error state.
+ *
+ * @example
+ * ```tsx
+ * function DashboardActions() {
+ *   const { state, createDashboard, deleteDashboard } = useDashboardMutations();
+ *   const { refetch } = useDashboards();
+ *
+ *   const handleCreate = async () => {
+ *     try {
+ *       await createDashboard({ name: 'New Dashboard' });
+ *       await refetch();
+ *     } catch (error) {
+ *       // Error is also available in state.error
+ *       console.error('Failed to create dashboard:', error);
+ *     }
+ *   };
+ *
+ *   return (
+ *     <button onClick={handleCreate} disabled={state.isLoading}>
+ *       {state.isLoading ? 'Creating...' : 'Create Dashboard'}
+ *     </button>
+ *   );
+ * }
+ * ```
+ */
+declare function useDashboardMutations(): UseDashboardMutationsResult;
+
+/**
+ * useSavedQueries hook.
+ *
+ * Fetches and manages saved queries from the Prismiq backend.
+ */
+
+/**
+ * Options for the useSavedQueries hook.
+ */
+interface UseSavedQueriesOptions {
+    /**
+     * Whether to automatically fetch saved queries on mount.
+     * @default true
+     */
+    enabled?: boolean;
+}
+/**
+ * Result of the useSavedQueries hook.
+ */
+interface UseSavedQueriesResult {
+    /** The list of saved queries, or null if not yet loaded. */
+    data: SavedQuery[] | null;
+    /** Whether the saved queries are currently loading. */
+    isLoading: boolean;
+    /** Error that occurred during fetch, if any. */
+    error: Error | null;
+    /** Function to manually refresh the saved query list. */
+    refetch: () => Promise<void>;
+    /** Function to create a new saved query. */
+    createQuery: (data: SavedQueryCreate) => Promise<SavedQuery>;
+    /** Function to update an existing saved query. */
+    updateQuery: (id: string, data: SavedQueryUpdate) => Promise<SavedQuery>;
+    /** Function to delete a saved query. */
+    deleteQuery: (id: string) => Promise<void>;
+}
+/**
+ * Hook for fetching and managing saved queries.
+ *
+ * @param options - Configuration options.
+ *
+ * @example
+ * ```tsx
+ * function SavedQueryList() {
+ *   const { data, isLoading, error, createQuery } = useSavedQueries();
+ *
+ *   if (isLoading) return <Loading />;
+ *   if (error) return <Error message={error.message} />;
+ *
+ *   return (
+ *     <ul>
+ *       {data?.map(query => (
+ *         <li key={query.id}>{query.name}</li>
+ *       ))}
+ *     </ul>
+ *   );
+ * }
+ * ```
+ */
+declare function useSavedQueries(options?: UseSavedQueriesOptions): UseSavedQueriesResult;
+
+/**
+ * useCustomSQL hook.
+ *
+ * Executes raw SQL queries against the Prismiq backend with validation.
+ */
+
+/**
+ * Options for the useCustomSQL hook.
+ */
+interface UseCustomSQLOptions {
+    /**
+     * Whether the query should be executed.
+     * Set to false to disable automatic execution.
+     * @default true
+     */
+    enabled?: boolean;
+    /**
+     * Named parameters for the query.
+     */
+    params?: Record<string, unknown>;
+    /**
+     * Whether to validate before executing.
+     * When true, validates first and only executes if valid.
+     * @default true
+     */
+    validateFirst?: boolean;
+}
+/**
+ * Result of the useCustomSQL hook.
+ */
+interface UseCustomSQLResult {
+    /** The query result data, or null if not yet loaded. */
+    data: QueryResult | null;
+    /** Whether the query is currently loading. */
+    isLoading: boolean;
+    /** Error that occurred during query execution, if any. */
+    error: Error | null;
+    /** Validation result from the last validation check. */
+    validation: SQLValidationResult | null;
+    /** Whether the SQL is currently being validated. */
+    isValidating: boolean;
+    /** Function to manually re-execute the query. */
+    refetch: () => Promise<void>;
+    /** Function to manually validate the SQL without executing. */
+    validate: () => Promise<SQLValidationResult>;
+}
+/**
+ * Hook for executing raw SQL queries against the Prismiq backend.
+ *
+ * Only SELECT statements are allowed. Queries are restricted
+ * to tables visible in the schema.
+ *
+ * @param sql - The SQL query to execute, or null to skip.
+ * @param options - Configuration options.
+ *
+ * @example
+ * ```tsx
+ * function SQLResults() {
+ *   const sql = "SELECT name, email FROM users WHERE status = 'active'";
+ *   const { data, isLoading, error, validation } = useCustomSQL(sql);
+ *
+ *   if (isLoading) return <Loading />;
+ *   if (error) return <Error message={error.message} />;
+ *   if (validation && !validation.valid) {
+ *     return <ValidationErrors errors={validation.errors} />;
+ *   }
+ *
+ *   return (
+ *     <table>
+ *       <thead>
+ *         <tr>
+ *           {data?.columns.map(col => <th key={col}>{col}</th>)}
+ *         </tr>
+ *       </thead>
+ *       <tbody>
+ *         {data?.rows.map((row, i) => (
+ *           <tr key={i}>
+ *             {row.map((cell, j) => <td key={j}>{String(cell)}</td>)}
+ *           </tr>
+ *         ))}
+ *       </tbody>
+ *     </table>
+ *   );
+ * }
+ * ```
+ */
+declare function useCustomSQL(sql: string | null, options?: UseCustomSQLOptions): UseCustomSQLResult;
+
+/**
+ * usePinnedDashboards hook.
+ *
+ * Fetches dashboards pinned to a specific context.
+ */
+
+/**
+ * Options for the usePinnedDashboards hook.
+ */
+interface UsePinnedDashboardsOptions {
+    /**
+     * Context to get pinned dashboards for (e.g., "accounts", "dashboard").
+     */
+    context: string;
+    /**
+     * Whether to automatically fetch on mount.
+     * @default true
+     */
+    enabled?: boolean;
+}
+/**
+ * Result of the usePinnedDashboards hook.
+ */
+interface UsePinnedDashboardsResult {
+    /** The list of pinned dashboards, or null if not yet loaded. */
+    dashboards: Dashboard[] | null;
+    /** Pin metadata for each dashboard. */
+    pins: PinnedDashboard[] | null;
+    /** Whether the data is currently loading. */
+    isLoading: boolean;
+    /** Error that occurred during fetch, if any. */
+    error: Error | null;
+    /** Function to manually refresh the pinned dashboards. */
+    refetch: () => Promise<void>;
+}
+/**
+ * Hook for fetching dashboards pinned to a context.
+ *
+ * @param options - Configuration options including the context.
+ *
+ * @example
+ * ```tsx
+ * function AccountsPinnedDashboards() {
+ *   const { dashboards, isLoading, error } = usePinnedDashboards({
+ *     context: 'accounts',
+ *   });
+ *
+ *   if (isLoading) return <Loading />;
+ *   if (error) return <Error message={error.message} />;
+ *
+ *   return (
+ *     <ul>
+ *       {dashboards?.map(d => (
+ *         <li key={d.id}>{d.name}</li>
+ *       ))}
+ *     </ul>
+ *   );
+ * }
+ * ```
+ */
+declare function usePinnedDashboards(options: UsePinnedDashboardsOptions): UsePinnedDashboardsResult;
+
+/**
+ * usePinMutations hook.
+ *
+ * Provides functions for pin/unpin/reorder operations.
+ */
+
+/**
+ * Mutation state for pin operations.
+ */
+interface PinMutationState {
+    /** Whether a mutation is in progress. */
+    isLoading: boolean;
+    /** Error that occurred during the last mutation, if any. */
+    error: Error | null;
+}
+/**
+ * Result of the usePinMutations hook.
+ */
+interface UsePinMutationsResult {
+    /** Current mutation state. */
+    state: PinMutationState;
+    /**
+     * Pin a dashboard to a context.
+     * @param dashboardId - Dashboard ID to pin.
+     * @param context - Context to pin to (e.g., "accounts").
+     * @param position - Optional position in the list.
+     * @returns The created pin entry.
+     */
+    pin: (dashboardId: string, context: string, position?: number) => Promise<PinnedDashboard>;
+    /**
+     * Unpin a dashboard from a context.
+     * @param dashboardId - Dashboard ID to unpin.
+     * @param context - Context to unpin from.
+     */
+    unpin: (dashboardId: string, context: string) => Promise<void>;
+    /**
+     * Reorder pinned dashboards in a context.
+     * @param context - Context to reorder pins in.
+     * @param dashboardIds - Ordered list of dashboard IDs.
+     */
+    reorder: (context: string, dashboardIds: string[]) => Promise<void>;
+    /** Clear the error state. */
+    clearError: () => void;
+}
+/**
+ * Hook for pin/unpin/reorder operations.
+ *
+ * @example
+ * ```tsx
+ * function PinButton({ dashboardId }: { dashboardId: string }) {
+ *   const { pin, unpin, state } = usePinMutations();
+ *   const [isPinned, setIsPinned] = useState(false);
+ *
+ *   const handleClick = async () => {
+ *     if (isPinned) {
+ *       await unpin(dashboardId, 'accounts');
+ *       setIsPinned(false);
+ *     } else {
+ *       await pin(dashboardId, 'accounts');
+ *       setIsPinned(true);
+ *     }
+ *   };
+ *
+ *   return (
+ *     <button onClick={handleClick} disabled={state.isLoading}>
+ *       {isPinned ? 'Unpin' : 'Pin'}
+ *     </button>
+ *   );
+ * }
+ * ```
+ */
+declare function usePinMutations(): UsePinMutationsResult;
+
+/**
+ * useDashboardPinStatus hook.
+ *
+ * Fetches the pin status of a dashboard across contexts.
+ */
+/**
+ * Options for the useDashboardPinStatus hook.
+ */
+interface UseDashboardPinStatusOptions {
+    /**
+     * Dashboard ID to check pin status for.
+     */
+    dashboardId: string;
+    /**
+     * Optional list of contexts to filter results by.
+     * When provided, pinnedContexts will only include contexts from this list.
+     * This is useful when you only care about specific contexts.
+     */
+    contexts?: string[];
+    /**
+     * Whether to automatically fetch on mount.
+     * @default true
+     */
+    enabled?: boolean;
+}
+/**
+ * Result of the useDashboardPinStatus hook.
+ */
+interface UseDashboardPinStatusResult {
+    /** List of contexts where the dashboard is pinned, or null if not yet loaded. */
+    pinnedContexts: string[] | null;
+    /**
+     * Check if the dashboard is pinned to a specific context.
+     * @param context - Context to check.
+     * @returns true if pinned to the context, false otherwise.
+     */
+    isPinned: (context: string) => boolean;
+    /** Whether the data is currently loading. */
+    isLoading: boolean;
+    /** Error that occurred during fetch, if any. */
+    error: Error | null;
+    /** Function to manually refresh the pin status. */
+    refetch: () => Promise<void>;
+}
+/**
+ * Hook for checking the pin status of a dashboard.
+ *
+ * @param options - Configuration options including the dashboard ID.
+ *
+ * @example
+ * ```tsx
+ * function DashboardPinMenu({ dashboardId }: { dashboardId: string }) {
+ *   const { pinnedContexts, isPinned, isLoading } = useDashboardPinStatus({
+ *     dashboardId,
+ *   });
+ *
+ *   if (isLoading) return <Loading />;
+ *
+ *   return (
+ *     <ul>
+ *       <li>
+ *         <Checkbox checked={isPinned('accounts')} />
+ *         Accounts
+ *       </li>
+ *       <li>
+ *         <Checkbox checked={isPinned('dashboard')} />
+ *         Dashboard
+ *       </li>
+ *     </ul>
+ *   );
+ * }
+ * ```
+ */
+declare function useDashboardPinStatus(options: UseDashboardPinStatusOptions): UseDashboardPinStatusResult;
+
+/**
+ * PinButton component.
+ *
+ * A button to pin/unpin a dashboard to a specific context.
+ */
+
+interface PinButtonProps {
+    /** Dashboard ID to pin/unpin. */
+    dashboardId: string;
+    /** Context to pin to (e.g., "accounts", "dashboard"). */
+    context: string;
+    /** Label text (default: "Pin"). */
+    label?: string;
+    /** Label when pinned (default: "Unpin"). */
+    unpinLabel?: string;
+    /** Show as icon only (no label). */
+    iconOnly?: boolean;
+    /** Size variant. */
+    size?: 'sm' | 'md' | 'lg';
+    /** Called after pin/unpin completes. */
+    onPinChange?: (isPinned: boolean) => void;
+    /** Custom class name. */
+    className?: string;
+    /** Custom styles. */
+    style?: CSSProperties;
+}
+/**
+ * Button to pin/unpin a dashboard to a context.
+ *
+ * @example
+ * ```tsx
+ * // Basic usage
+ * <PinButton dashboardId={dashboard.id} context="accounts" />
+ *
+ * // Icon only with custom label
+ * <PinButton
+ *   dashboardId={dashboard.id}
+ *   context="dashboard"
+ *   iconOnly
+ *   onPinChange={(isPinned) => console.log('Pinned:', isPinned)}
+ * />
+ * ```
+ */
+declare function PinButton({ dashboardId, context, label, unpinLabel, iconOnly, size, onPinChange, className, style, }: PinButtonProps): ReactNode;
+
+/**
+ * PinMenu component.
+ *
+ * A dropdown menu showing multiple pin contexts with checkboxes.
+ */
+
+/** Configuration for a pin context option. */
+interface PinContextOption {
+    /** Unique context identifier (e.g., "accounts", "dashboard"). */
+    id: string;
+    /** Display label for the context. */
+    label: string;
+    /** Optional icon to display. */
+    icon?: ReactNode;
+}
+interface PinMenuProps {
+    /** Dashboard ID to pin/unpin. */
+    dashboardId: string;
+    /** Available contexts to pin to. */
+    contexts: PinContextOption[];
+    /** Called after pin state changes. */
+    onPinChange?: (context: string, isPinned: boolean) => void;
+    /** Custom class name. */
+    className?: string;
+    /** Custom styles. */
+    style?: CSSProperties;
+}
+/**
+ * Dropdown menu showing multiple pin contexts with checkboxes.
+ *
+ * @example
+ * ```tsx
+ * const PIN_CONTEXTS = [
+ *   { id: 'dashboard', label: 'Dashboard' },
+ *   { id: 'accounts', label: 'Accounts' },
+ * ];
+ *
+ * <PinMenu
+ *   dashboardId={dashboard.id}
+ *   contexts={PIN_CONTEXTS}
+ *   onPinChange={(ctx, pinned) => console.log(ctx, pinned)}
+ * />
+ * ```
+ */
+declare function PinMenu({ dashboardId, contexts, onPinChange, className, style, }: PinMenuProps): ReactNode;
+
+/**
+ * PinnedDashboardList component.
+ *
+ * Displays a list of dashboards pinned to a context.
+ */
+
+/** Props for custom rendering of a list item. */
+interface PinnedDashboardItemActions {
+    /** Unpin this dashboard from the context. Returns a promise. */
+    unpin: () => Promise<void>;
+}
+interface PinnedDashboardListProps {
+    /** Context to show pins for (e.g., "accounts", "dashboard"). */
+    context: string;
+    /** Called when user selects a dashboard. */
+    onSelect: (dashboard: Dashboard) => void;
+    /** Custom empty state element. */
+    emptyState?: ReactNode;
+    /** Custom render function for each item. */
+    renderItem?: (dashboard: Dashboard, actions: PinnedDashboardItemActions) => ReactNode;
+    /** Custom class name. */
+    className?: string;
+    /** Custom styles. */
+    style?: CSSProperties;
+}
+/**
+ * List of dashboards pinned to a context.
+ *
+ * @example
+ * ```tsx
+ * function AccountsDashboards() {
+ *   const [selected, setSelected] = useState<Dashboard | null>(null);
+ *
+ *   return (
+ *     <PinnedDashboardList
+ *       context="accounts"
+ *       onSelect={setSelected}
+ *       emptyState={<p>No pinned dashboards</p>}
+ *     />
+ *   );
+ * }
+ * ```
+ */
+declare function PinnedDashboardList({ context, onSelect, emptyState, renderItem, className, style, }: PinnedDashboardListProps): ReactNode;
+
+/**
+ * PinnedDashboardView component.
+ *
+ * Full view with pinned dashboard list and selected dashboard display.
+ */
+
+interface PinnedDashboardViewProps {
+    /** Context this view is for (for unpin action). */
+    context: string;
+    /** Dashboard to display (null = show list). */
+    selectedDashboard: Dashboard | null;
+    /** Called when user clicks back or closes. */
+    onBack: () => void;
+    /** Called when user selects from list. */
+    onSelect: (dashboard: Dashboard) => void;
+    /** Show unpin button in header. */
+    showUnpin?: boolean;
+    /** Custom back button label. */
+    backLabel?: string;
+    /** Custom empty state for list. */
+    emptyState?: ReactNode;
+    /** Custom class name. */
+    className?: string;
+    /** Custom styles. */
+    style?: CSSProperties;
+}
+/**
+ * Full view with pinned dashboard list and dashboard display.
+ *
+ * When no dashboard is selected, shows the list. When a dashboard
+ * is selected, shows the dashboard with a back button.
+ *
+ * @example
+ * ```tsx
+ * function AccountsDashboardSection() {
+ *   const [selected, setSelected] = useState<Dashboard | null>(null);
+ *
+ *   return (
+ *     <PinnedDashboardView
+ *       context="accounts"
+ *       selectedDashboard={selected}
+ *       onSelect={setSelected}
+ *       onBack={() => setSelected(null)}
+ *       backLabel="Back to Accounts"
+ *       emptyState={<p>Pin dashboards from Analytics.</p>}
+ *     />
+ *   );
+ * }
+ * ```
+ */
+declare function PinnedDashboardView({ context, selectedDashboard, onBack, onSelect, showUnpin, backLabel, emptyState, className, style, }: PinnedDashboardViewProps): ReactNode;
+
+/**
+ * @prismiq/react - React SDK for Prismiq embedded analytics
+ *
+ * @example
+ * ```tsx
+ * import {
+ *   AnalyticsProvider,
+ *   ThemeProvider,
+ *   QueryBuilder,
+ *   BarChart,
+ *   Dashboard,
+ *   useQuery
+ * } from '@prismiq/react';
+ *
+ * function App() {
+ *   return (
+ *     <ThemeProvider>
+ *       <AnalyticsProvider config={{ endpoint: 'https://api.example.com' }}>
+ *         <Dashboard id="my-dashboard" />
+ *       </AnalyticsProvider>
+ *     </ThemeProvider>
+ *   );
+ * }
+ * ```
+ *
+ * For modular imports (smaller bundle size):
+ * ```tsx
+ * import { BarChart } from '@prismiq/react/charts';
+ * import { Dashboard } from '@prismiq/react/dashboard';
+ * import { useIsClient } from '@prismiq/react/ssr';
+ * import { useFocusTrap } from '@prismiq/react/utils';
+ * import { exportToCSV } from '@prismiq/react/export';
+ * ```
+ */
+
+declare const VERSION = "0.1.0";
+
+export { type AnalyticsCallbacks, type AnalyticsContextValue, AnalyticsProvider, type AnalyticsProviderProps, ChartDataOptions, ChartDataResult, type ClientConfig, DashboardCreate, DashboardUpdate, DatabaseSchema, DeepPartial, type MutationState, PinButton, type PinButtonProps, type PinContextOption, PinMenu, type PinMenuProps, type PinMutationState, PinnedDashboard, type PinnedDashboardItemActions, PinnedDashboardList, type PinnedDashboardListProps, PinnedDashboardView, type PinnedDashboardViewProps, PinnedDashboardsResponse, PrismiqClient, PrismiqError, PrismiqTheme, QueryDefinition, QueryResult, Relationship, SQLValidationResult, SavedQuery, SavedQueryCreate, SavedQueryUpdate, TableSchema, ThemeContextValue, ThemeMode, ThemeProvider, type ThemeProviderProps, type UseCustomSQLOptions, type UseCustomSQLResult, type UseDashboardMutationsResult, type UseDashboardOptions, type UseDashboardPinStatusOptions, type UseDashboardPinStatusResult, type UseDashboardResult, type UseDashboardsOptions, type UseDashboardsResult, type UsePinMutationsResult, type UsePinnedDashboardsOptions, type UsePinnedDashboardsResult, type UseQueryOptions, type UseQueryResult, type UseSavedQueriesOptions, type UseSavedQueriesResult, type UseSchemaResult, VERSION, ValidationResult, darkTheme, lightTheme, useAnalytics, useAnalyticsCallbacks, useChartData, useCustomSQL, useDashboard as useDashboardData, useDashboardMutations, useDashboardPinStatus, useDashboards, usePinMutations, usePinnedDashboards, useQuery, useSavedQueries, useSchema, useTheme };