drizzle-cube 0.6.0 → 0.6.2

package/dist/cjs/client/hooks/useDashboardHook.d.ts

@@ -0,0 +1,123 @@
+import { default as React } from 'react';
+import { PortletDebugDataEntry } from '../stores/dashboardStore.js';
+import { LayoutItem } from 'react-grid-layout';
+import { DashboardConfig, PortletConfig, RowLayout, DashboardFilter, DashboardFilterMapping, DashboardGridSettings, DashboardLayoutMode } from '../types.js';
+export interface UseDashboardOptions {
+    /** Dashboard configuration */
+    config: DashboardConfig;
+    /** Whether dashboard is editable */
+    editable?: boolean;
+    /** Dashboard filters */
+    dashboardFilters?: DashboardFilter[];
+    /** Grid settings */
+    gridSettings: DashboardGridSettings;
+    /** Allowed layout modes */
+    allowedModes?: DashboardLayoutMode[];
+    /** Whether responsive mode allows editing (desktop only) */
+    isResponsiveEditable?: boolean;
+    /** Config change handler */
+    onConfigChange?: (config: DashboardConfig) => void;
+    /** Save handler */
+    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>;
+    /** Grid width for row calculations */
+    gridWidth?: number;
+    /** Portlet component refs for refresh functionality */
+    portletComponentRefs?: React.MutableRefObject<Record<string, {
+        refresh: (options?: {
+            bustCache?: boolean;
+        }) => void;
+    } | null>>;
+    /** Portlet refresh handler (external) */
+    onPortletRefresh?: (portletId: string, options?: {
+        bustCache?: boolean;
+    }) => void;
+    /** Ref to the dashboard container element for thumbnail capture */
+    dashboardRef?: React.RefObject<HTMLElement | null>;
+}
+export interface UseDashboardResult {
+    /** Whether dashboard is in edit mode */
+    isEditMode: boolean;
+    /** Selected filter ID for filter assignment mode */
+    selectedFilterId: string | null;
+    /** Whether portlet modal is open */
+    isPortletModalOpen: boolean;
+    /** Portlet being edited */
+    editingPortlet: PortletConfig | null;
+    /** Whether text portlet modal is open */
+    isTextModalOpen: boolean;
+    /** Portlet being edited in text modal */
+    editingTextPortlet: PortletConfig | null;
+    /** Whether filter config modal is open */
+    isFilterConfigModalOpen: boolean;
+    /** Portlet for filter configuration */
+    filterConfigPortlet: PortletConfig | null;
+    /** Portlet ID pending delete confirmation */
+    deleteConfirmPortletId: string | null;
+    /** Draft rows during drag operations */
+    draftRows: RowLayout[] | null;
+    /** Whether a portlet is being dragged */
+    isDraggingPortlet: boolean;
+    /** Last known layout for change detection */
+    lastKnownLayout: LayoutItem[];
+    /** Whether component is initialized */
+    isInitialized: boolean;
+    /** Whether editing is allowed (editable && isEditMode && desktop && !filterMode) */
+    canEdit: boolean;
+    /** Whether layout mode can be changed */
+    canChangeLayoutMode: boolean;
+    /** Currently selected filter object */
+    selectedFilter: DashboardFilter | null;
+    /** Resolved rows for row-based layout */
+    resolvedRows: RowLayout[];
+    /** Current layout mode */
+    layoutMode: DashboardLayoutMode;
+    /** Allowed layout modes */
+    allowedModes: DashboardLayoutMode[];
+    actions: UseDashboardActions;
+}
+export interface UseDashboardActions {
+    enterEditMode: () => void;
+    exitEditMode: () => void;
+    toggleEditMode: () => void;
+    selectFilter: (filterId: string | null) => void;
+    exitFilterSelectionMode: () => void;
+    openAddPortlet: () => void;
+    openEditPortlet: (portlet: PortletConfig) => void;
+    closePortletModal: () => void;
+    openAddText: () => void;
+    openEditText: (portlet: PortletConfig) => void;
+    closeTextModal: () => void;
+    openFilterConfig: (portlet: PortletConfig) => void;
+    closeFilterConfig: () => void;
+    setDraftRows: (rows: RowLayout[] | null) => void;
+    setIsDraggingPortlet: (isDragging: boolean) => void;
+    setLastKnownLayout: (layout: LayoutItem[]) => void;
+    setIsInitialized: (initialized: boolean) => void;
+    setDragState: (state: {
+        rowIndex: number;
+        colIndex: number;
+        portletId: string;
+    } | null) => void;
+    clearDragState: () => void;
+    hasLayoutActuallyChanged: (newLayout: LayoutItem[]) => boolean;
+    updateRowLayout: (rows: RowLayout[], save?: boolean, portletsOverride?: PortletConfig[]) => Promise<void>;
+    handleLayoutModeChange: (mode: DashboardLayoutMode) => Promise<void>;
+    savePortlet: (portletData: PortletConfig | Omit<PortletConfig, 'id' | 'x' | 'y'>) => Promise<string | null>;
+    deletePortlet: (portletId: string) => Promise<void>;
+    duplicatePortlet: (portletId: string) => Promise<string | undefined>;
+    refreshPortlet: (portletId: string, options?: {
+        bustCache?: boolean;
+    }) => void;
+    toggleFilterForPortlet: (portletId: string, filterId: string) => Promise<void>;
+    selectAllForFilter: (filterId: string) => Promise<void>;
+    saveFilterConfig: (mapping: DashboardFilterMapping) => Promise<void>;
+    handlePaletteChange: (paletteName: string) => Promise<void>;
+    openDeleteConfirm: (portletId: string) => void;
+    closeDeleteConfirm: () => void;
+    confirmDelete: () => Promise<void>;
+    setDebugData: (portletId: string, data: PortletDebugDataEntry) => void;
+    clearDebugData: (portletId?: string) => void;
+}
+export declare function useDashboard(options: UseDashboardOptions): UseDashboardResult;

package/dist/cjs/client/hooks/useDataBrowser.d.ts

@@ -0,0 +1,67 @@
+import { CubeQuery } from '../types.js';
+/**
+ * Get field type from metadata
+ */
+export declare function getFieldType(fieldName: string, meta: {
+    cubes: Array<{
+        name: string;
+        dimensions: Array<{
+            name: string;
+            type: string;
+        }>;
+        measures: Array<{
+            name: string;
+            type: string;
+        }>;
+    }>;
+} | null): string;
+/**
+ * Get all browsable columns for a cube (dimensions + ungrouped-compatible measures)
+ */
+export declare function getCubeColumns(cubeName: string, meta: {
+    cubes: Array<{
+        name: string;
+        dimensions: Array<{
+            name: string;
+        }>;
+        measures: Array<{
+            name: string;
+            type: string;
+        }>;
+    }>;
+} | null): {
+    dimensions: string[];
+    measures: string[];
+};
+export declare function useDataBrowser(): {
+    refetch: (options?: import('./queries/useCubeLoadQuery.js').RefetchOptions) => void;
+    selectCube: (cubeName: string, allDimensions: string[]) => void;
+    setVisibleColumns: (columns: string[]) => void;
+    toggleColumn: (column: string) => void;
+    setSort: (column: string) => void;
+    clearSort: () => void;
+    setPage: (page: number) => void;
+    setPageSize: (size: number) => void;
+    setFilters: (filters: import('../types.js').Filter[]) => void;
+    toggleFilterBar: () => void;
+    setShowColumnPicker: (show: boolean) => void;
+    selectedCube: string | null;
+    visibleColumns: string[];
+    sortColumn: string | null;
+    sortDirection: "asc" | "desc";
+    page: number;
+    pageSize: number;
+    filters: import('../types.js').Filter[];
+    showFilterBar: boolean;
+    showColumnPicker: boolean;
+    rawData: unknown[] | null;
+    isLoading: boolean;
+    isFetching: boolean;
+    error: Error | null;
+    query: CubeQuery | null;
+    rowCount: number;
+    hasNextPage: boolean;
+    hasPrevPage: boolean;
+    meta: import('../types.js').CubeMeta | null;
+    getFieldLabel: (fieldName: string) => string;
+};

package/dist/cjs/client/hooks/useDebounce.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Custom hook for debouncing values
+ * Delays updating the value until after the specified delay has passed
+ * since the last change
+ */
+/**
+ * Debounces a value by the specified delay
+ * @param value The value to debounce
+ * @param delay The delay in milliseconds
+ * @returns The debounced value
+ */
+export declare function useDebounce<T>(value: T, delay: number): T;

package/dist/cjs/client/hooks/useDebounceQuery.d.ts

@@ -0,0 +1,48 @@
+/**
+ * useDebounceQuery - Shared debounce logic for query hooks
+ *
+ * This hook encapsulates the common debouncing pattern used by
+ * useCubeLoadQuery and useMultiCubeLoadQuery to prevent excessive API calls
+ * when users are actively editing queries.
+ *
+ * Features:
+ * - Debounces value changes with configurable delay
+ * - Handles skip-to-unskip transitions (e.g., portlet becoming visible)
+ * - Clears debounced value when invalid or skipped
+ * - Provides isDebouncing state for UI feedback
+ */
+export interface UseDebounceQueryOptions {
+    /**
+     * Whether the value is valid (has required fields)
+     */
+    isValid: boolean;
+    /**
+     * Whether to skip the debounced value
+     * @default false
+     */
+    skip?: boolean;
+    /**
+     * Debounce delay in milliseconds
+     * @default 300
+     */
+    debounceMs?: number;
+}
+export interface UseDebounceQueryResult<T> {
+    /** The debounced value (null if skipped or invalid) */
+    debouncedValue: T | null;
+    /** Whether the hook is currently debouncing (waiting for timer) */
+    isDebouncing: boolean;
+}
+/**
+ * Hook for debouncing query values with skip and validity support
+ *
+ * Usage:
+ * ```tsx
+ * const { debouncedValue, isDebouncing } = useDebounceQuery(query, {
+ *   isValid: isValidCubeQuery(query),
+ *   skip: !isReady,
+ *   debounceMs: 300
+ * })
+ * ```
+ */
+export declare function useDebounceQuery<T>(value: T | null, options: UseDebounceQueryOptions): UseDebounceQueryResult<T>;

package/dist/cjs/client/hooks/useDirtyStateTracking.d.ts

@@ -0,0 +1,37 @@
+/**
+ * useDirtyStateTracking - Track configuration changes and dirty state
+ *
+ * Extracts dirty state tracking logic from AnalyticsDashboard:
+ * - Tracks initial config to prevent saves during initial load
+ * - Detects meaningful changes from initial state
+ * - Manages dirty state through onDirtyStateChange callback
+ *
+ * @example
+ * const { handleConfigChange, handleSave } = useDirtyStateTracking({
+ *   initialConfig: config,
+ *   onConfigChange,
+ *   onSave,
+ *   onDirtyStateChange,
+ * })
+ */
+export interface UseDirtyStateTrackingOptions<T> {
+    /** Initial configuration to compare against */
+    initialConfig: T;
+    /** Original config change handler */
+    onConfigChange?: (config: T) => void;
+    /** Original save handler */
+    onSave?: (config: T) => Promise<void> | void;
+    /** Dirty state change callback */
+    onDirtyStateChange?: (isDirty: boolean) => void;
+}
+export interface UseDirtyStateTrackingResult<T> {
+    /** Wrapped config change handler that tracks dirty state */
+    handleConfigChange: (config: T) => void;
+    /** Wrapped save handler that tracks dirty state */
+    handleSave: (config: T) => Promise<void>;
+    /** Whether config has changed from initial */
+    hasChanged: () => boolean;
+    /** Reset the initial config reference (e.g., after external config update) */
+    resetInitialConfig: (config: T) => void;
+}
+export declare function useDirtyStateTracking<T>({ initialConfig, onConfigChange, onSave, onDirtyStateChange, }: UseDirtyStateTrackingOptions<T>): UseDirtyStateTrackingResult<T>;

package/dist/cjs/client/hooks/useDragAutoScroll.d.ts

@@ -0,0 +1,18 @@
+import { RefObject } from 'react';
+interface UseDragAutoScrollOptions {
+    /** Distance from edge that triggers scrolling (default: 80px) */
+    edgeThreshold?: number;
+    /** Maximum scroll speed in pixels per frame (default: 15) */
+    maxScrollSpeed?: number;
+    /** Whether auto-scroll is currently enabled */
+    enabled?: boolean;
+}
+/**
+ * Hook to enable auto-scrolling when dragging near the edges of a scroll container.
+ * Works with HTML5 native drag-and-drop API by listening to dragover events.
+ *
+ * @param scrollContainerRef - Ref to the scrollable container element
+ * @param options - Configuration options
+ */
+export declare function useDragAutoScroll(scrollContainerRef: RefObject<HTMLElement | null>, options?: UseDragAutoScrollOptions): void;
+export {};

package/dist/cjs/client/hooks/useDrillInteraction.d.ts

@@ -0,0 +1,9 @@
+import { DrillInteraction, UseDrillInteractionOptions } from '../types/drill.js';
+/**
+ * Hook for managing drill-down interaction
+ *
+ * @param options - Configuration options
+ * @returns DrillInteraction object with handlers and state
+ */
+export declare function useDrillInteraction(options: UseDrillInteractionOptions): DrillInteraction;
+export default useDrillInteraction;

package/dist/cjs/client/hooks/useElementVisibility.d.ts

@@ -0,0 +1,30 @@
+import { RefObject } from 'react';
+interface UseElementVisibilityOptions {
+    /** Threshold in pixels - element considered out of view when this much scrolls past top */
+    threshold?: number;
+    /** Debounce delay in milliseconds */
+    debounceMs?: number;
+    /** Custom scroll container ref (uses viewport if not provided) */
+    containerRef?: RefObject<HTMLElement | null>;
+    /** Optional state value to trigger re-initialization when container is found */
+    container?: HTMLElement | null;
+}
+/**
+ * Hook to detect whether an element is visible in the viewport/container
+ *
+ * @param elementRef - Ref to the element to track
+ * @param options - Configuration options
+ * @returns Boolean indicating if the element is visible (true when in view, false when scrolled out)
+ *
+ * @example
+ * const editBarRef = useRef<HTMLDivElement>(null)
+ * const isEditBarVisible = useElementVisibility(editBarRef, {
+ *   threshold: 80,
+ *   containerRef: scrollContainerRef
+ * })
+ *
+ * // Show floating toolbar when edit bar scrolls out of view
+ * {!isEditBarVisible && <FloatingToolbar />}
+ */
+export declare function useElementVisibility(elementRef: RefObject<HTMLElement | null>, { threshold, debounceMs, containerRef, container }?: UseElementVisibilityOptions): boolean;
+export {};

package/dist/cjs/client/hooks/useFilterValues.d.ts

@@ -0,0 +1,19 @@
+/**
+ * Hook for fetching distinct field values for filter dropdowns
+ * Uses TanStack Query via useCubeLoadQuery for data fetching
+ */
+interface UseFilterValuesResult {
+    values: any[];
+    loading: boolean;
+    error: string | null;
+    refetch: () => void;
+    searchValues: (searchTerm: string, force?: boolean) => void;
+}
+/**
+ * Custom hook to fetch distinct values for a field
+ *
+ * Uses TanStack Query for server state (data fetching, caching, loading).
+ * Values are derived via useMemo from query results - NOT stored in useState.
+ */
+export declare function useFilterValues(fieldName: string | null, enabled?: boolean): UseFilterValuesResult;
+export {};

package/dist/cjs/client/hooks/useNotebookLayout.d.ts

@@ -0,0 +1,8 @@
+import { RefCallback } from 'react';
+export type NotebookLayoutMode = 'wide' | 'narrow';
+export interface UseNotebookLayoutResult {
+    containerRef: RefCallback<HTMLDivElement>;
+    layoutMode: NotebookLayoutMode;
+    containerWidth: number;
+}
+export declare function useNotebookLayout(): UseNotebookLayoutResult;

package/dist/cjs/client/hooks/useResponsiveDashboard.d.ts

@@ -0,0 +1,16 @@
+import { RefCallback } from 'react';
+export type DashboardDisplayMode = 'desktop' | 'scaled' | 'mobile';
+export interface UseResponsiveDashboardResult {
+    containerRef: RefCallback<HTMLDivElement>;
+    containerWidth: number;
+    displayMode: DashboardDisplayMode;
+    scaleFactor: number;
+    isEditable: boolean;
+    designWidth: number;
+}
+/**
+ * Hook for managing responsive dashboard layouts
+ * Uses ResizeObserver for accurate width detection and calculates
+ * the appropriate display mode and scale factor
+ */
+export declare function useResponsiveDashboard(): UseResponsiveDashboardResult;

package/dist/cjs/client/hooks/useScrollDetection.d.ts

@@ -0,0 +1,29 @@
+import { RefObject } from 'react';
+interface UseScrollDetectionOptions {
+    /** Scroll threshold in pixels (default: 20) */
+    threshold?: number;
+    /** Debounce delay in milliseconds (default: 150) */
+    debounceMs?: number;
+    /** Optional container state to trigger re-initialization when found */
+    container?: HTMLElement | null;
+}
+/**
+ * Hook to detect scroll position in a container
+ *
+ * @param containerRef - Ref to the scrollable container element
+ * @param options - Configuration options for threshold and debounce
+ * @returns Boolean indicating if scrolled past threshold
+ *
+ * @example
+ * const scrollContainerRef = useRef<HTMLDivElement>(null)
+ * const isScrolled = useScrollDetection(scrollContainerRef, {
+ *   threshold: 20,
+ *   debounceMs: 150
+ * })
+ *
+ * <div ref={scrollContainerRef} className="overflow-y-auto">
+ *   {isScrolled && <div>Shadow visible</div>}
+ * </div>
+ */
+export declare function useScrollDetection(containerRef: RefObject<HTMLElement | null>, { threshold, debounceMs, container }?: UseScrollDetectionOptions): boolean;
+export {};

package/dist/cjs/client/hooks/useTheme.d.ts

@@ -0,0 +1,11 @@
+import { Theme } from '../theme/index.js';
+/**
+ * Hook to access and update theme
+ *
+ * Returns current theme and a setter function.
+ * Only components using this hook will re-render on theme changes.
+ */
+export declare function useTheme(): {
+    theme: Theme;
+    setTheme: (newTheme: Theme) => void;
+};

package/dist/cjs/client/hooks/useTranslation.d.ts

@@ -0,0 +1,21 @@
+import { TranslationParams } from '../../i18n/types.js';
+/**
+ * Hook to access translations within React components.
+ *
+ * @param namespace - Optional namespace prefix for scoped translations.
+ *   When provided, keys are prefixed: `useTranslation('chart.bar')` →
+ *   `t('label')` resolves to `chart.bar.label`.
+ *
+ * @example
+ * ```tsx
+ * const { t, locale } = useTranslation()
+ * t('common.actions.save') // → "Save"
+ *
+ * const { t } = useTranslation('chart.bar')
+ * t('label') // → "Bar Chart"
+ * ```
+ */
+export declare function useTranslation(namespace?: string): {
+    t: (key: string, params?: TranslationParams) => string;
+    locale: string;
+};

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

@@ -0,0 +1,17 @@
+/**
+ * Drizzle Cube React Hooks
+ *
+ * React hooks only - for applications that need data fetching hooks
+ * without UI components.
+ */
+export { useCubeMetaQuery, useCubeLoadQuery, useCubeQuery, useMultiCubeLoadQuery, useDryRunQuery, useMultiDryRunQueries, useDryRunQueries, useFunnelQuery, createFunnelQueryKey, useFlowQuery, createFlowQueryKey, useRetentionQuery, useExplainQuery, createExplainQueryKey, useExplainAI, } from './hooks/queries/index.js';
+export type { UseCubeMetaQueryOptions, UseCubeMetaQueryResult, UseCubeLoadQueryOptions, UseCubeLoadQueryResult, UseMultiCubeLoadQueryOptions, UseMultiCubeLoadQueryResult, DebugDataEntry, UseDryRunQueryOptions, UseDryRunQueryResult, UseMultiDryRunQueriesOptions, UseMultiDryRunQueriesResult, UseFlowQueryOptions, UseFlowQueryResult, UseRetentionQueryOptions, UseRetentionQueryResult, UseExplainQueryOptions, UseExplainQueryResult, UseExplainAIOptions, UseExplainAIResult, } from './hooks/queries/index.js';
+export { useDebounce } from './hooks/useDebounce.js';
+export { useDirtyStateTracking } from './hooks/useDirtyStateTracking.js';
+export type { UseDirtyStateTrackingOptions, UseDirtyStateTrackingResult } from './hooks/useDirtyStateTracking.js';
+export { useFilterValues } from './hooks/useFilterValues.js';
+export { useResponsiveDashboard } from './hooks/useResponsiveDashboard.js';
+export type { DashboardDisplayMode, UseResponsiveDashboardResult } from './hooks/useResponsiveDashboard.js';
+export { useNotebookLayout } from './hooks/useNotebookLayout.js';
+export type { NotebookLayoutMode, UseNotebookLayoutResult } from './hooks/useNotebookLayout.js';
+export type { CubeQuery, CubeQueryOptions, CubeResultSet, CubeApiOptions } from './types.js';

package/dist/cjs/client/icons/customIcons.d.ts

@@ -0,0 +1,22 @@
+import { IconifyIcon } from '@iconify/types';
+/**
+ * Custom Flow/Sankey icon
+ * Nodes connected by flowing S-curve paths representing user journey flows
+ * Shows data flowing between stages with branching paths
+ * 24x24 viewBox, stroke-width 1.5 for clean appearance
+ */
+export declare const flowIcon: IconifyIcon;
+/**
+ * Custom Funnel icon
+ * Horizontal bars that progressively narrow, showing conversion stages
+ * Connected by angled lines showing flow between stages
+ * 24x24 viewBox, stroke-width 1.5 for clean appearance
+ */
+export declare const funnelIcon: IconifyIcon;
+/**
+ * Custom Retention icon
+ * Grid/heatmap pattern representing cohort retention matrix
+ * Shows users tracked across time periods with varying intensity cells
+ * 24x24 viewBox, stroke-width 1.5 for clean appearance
+ */
+export declare const retentionIcon: IconifyIcon;

package/dist/cjs/client/icons/defaultIcons.d.ts

@@ -0,0 +1,5 @@
+import { IconRegistry } from './types.js';
+/**
+ * Default icon registry with all icons used in drizzle-cube
+ */
+export declare const DEFAULT_ICONS: IconRegistry;

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

@@ -0,0 +1,22 @@
+/**
+ * Drizzle Cube Icon System
+ *
+ * Centralized, configurable icon registry following the theme pattern.
+ * All icons can be overridden by users with their own implementations.
+ *
+ * @example
+ * ```typescript
+ * // Get an icon component
+ * import { getIcon } from 'drizzle-cube/client/icons'
+ * const CloseIcon = getIcon('close')
+ * <CloseIcon className="w-4 h-4" />
+ *
+ * // Override icons at app initialization
+ * import { registerIcons } from 'drizzle-cube/client/icons'
+ * import myCloseIcon from '@iconify-icons/mdi/close'
+ * registerIcons({ close: myCloseIcon })
+ * ```
+ */
+export type { IconCategory, IconProps, IconComponent, IconDefinition, IconRegistry, IconName, PartialIconRegistry } from './types.js';
+export { getIconRegistry, getIcon, getIconData, setIcon, registerIcons, resetIcons, getIconsByCategory, getMeasureTypeIcon, getChartTypeIcon, getFieldTypeIcon } from './registry.js';
+export { DEFAULT_ICONS } from './defaultIcons.js';

package/dist/cjs/client/icons/registry.d.ts

@@ -0,0 +1,64 @@
+import { IconifyIcon } from '@iconify/types';
+import { ComponentType } from 'react';
+import { IconRegistry, IconName, IconCategory, IconProps, PartialIconRegistry } from './types.js';
+/**
+ * Set a custom icon resolver for chart plugin types.
+ * Called by chartPlugin.ts during initialization.
+ * @internal
+ */
+export declare function setCustomChartIconResolver(resolver: (chartType: string) => ComponentType<IconProps> | undefined): void;
+/**
+ * Get the full icon registry
+ */
+export declare function getIconRegistry(): IconRegistry;
+/**
+ * Get a specific icon as a React component
+ * @param name The icon name from the registry
+ * @returns A React component that renders the icon (cached for stable references)
+ */
+export declare function getIcon(name: IconName): ComponentType<IconProps>;
+/**
+ * Get icon data directly (for use with Iconify's Icon component)
+ * @param name The icon name from the registry
+ * @returns The IconifyIcon data
+ */
+export declare function getIconData(name: IconName): IconifyIcon;
+/**
+ * Override a single icon in the registry
+ * @param name The icon name to override
+ * @param icon The new IconifyIcon data
+ */
+export declare function setIcon(name: IconName, icon: IconifyIcon): void;
+/**
+ * Register multiple icon overrides at once
+ * @param overrides Partial registry with icons to override
+ */
+export declare function registerIcons(overrides: PartialIconRegistry): void;
+/**
+ * Reset the registry to default icons
+ */
+export declare function resetIcons(): void;
+/**
+ * Get all icons in a specific category
+ * @param category The icon category to filter by
+ * @returns Record of icon names to their components
+ */
+export declare function getIconsByCategory(category: IconCategory): Record<string, ComponentType<IconProps>>;
+/**
+ * Helper to get measure type icon component
+ * @param measureType The measure type (count, avg, sum, etc.)
+ * @returns React component for the icon
+ */
+export declare function getMeasureTypeIcon(measureType: string | undefined): ComponentType<IconProps>;
+/**
+ * Helper to get chart type icon component
+ * @param chartType The chart type (bar, line, pie, etc.)
+ * @returns React component for the icon
+ */
+export declare function getChartTypeIcon(chartType: string): ComponentType<IconProps>;
+/**
+ * Helper to get field type icon component
+ * @param fieldType The field type (measure, dimension, timeDimension)
+ * @returns React component for the icon
+ */
+export declare function getFieldTypeIcon(fieldType: string): ComponentType<IconProps>;