@texturehq/edges 2.2.7 → 2.3.1

package/dist/index.d.cts

@@ -1,10 +1,10 @@
 import { BreadcrumbProps, BreadcrumbsProps, DateValue, CalendarProps as CalendarProps$1, ValidationResult, DisclosureGroupProps, DisclosurePanelProps, ButtonProps, DisclosureProps, DateRangePickerProps as DateRangePickerProps$1, FormProps, TooltipTriggerComponentProps, TooltipProps as TooltipProps$1, ListBoxProps as ListBoxProps$1, ListBoxItemProps, ModalOverlayProps, Key, PopoverProps as PopoverProps$1, ProgressBarProps as ProgressBarProps$1, RangeCalendarProps as RangeCalendarProps$1, TabProps as TabProps$1, TabListProps as TabListProps$1, TabPanelProps, TabsProps as TabsProps$2 } from 'react-aria-components';
 export { BreadcrumbProps, BreadcrumbsProps, DialogTrigger } from 'react-aria-components';
+import { Virtualizer } from '@tanstack/react-virtual';
 import * as React$1 from 'react';
 import React__default, { RefObject, ComponentType, ReactNode, HTMLAttributes, ComponentProps, CSSProperties, Component, ErrorInfo } from 'react';
-import { U as FieldValue, V as BooleanFormat, W as FormattedValue, X as FieldFormat, Z as CurrentFormat, _ as DateFormat, $ as DistanceFormat, a0 as EnergyUnit, a1 as EnergyFormat, a2 as CurrencyFormat, a3 as NumberFormat, a4 as PhoneFormat, a5 as PowerFormat, a6 as FormatterFunction, a7 as ResistanceFormat, a8 as TemperatureFormat, a9 as TemperatureUnitString, aa as TemperatureUnit, ab as TextFormat, ac as VoltageFormat, d as BaseDataPoint, B as BadgeProps, u as YFormatType, q as TooltipData, ad as DeviceState, ae as GridState, af as ComponentFormatter, ag as LayerSpec, ah as CustomPinsSpec, ai as GeoJsonLayerSpec, aj as RasterLayerSpec, ak as VectorLayerSpec, al as ClusteredVectorLayerSpec } from './colors-DsSW-pdc.cjs';
-export { A as ActionItem, am as ActionMenu, a as ActionMenuProps, an as AppShell, b as AppShellProps, ao as Avatar, c as AvatarProps, ap as Badge, aq as BaseFormat, ar as ChartContext, C as ChartMargin, as as CodeEditor, e as CodeEditorProps, f as CodeLanguage, g as CodeTheme, at as ColorSpec, au as ComponentFormatOptions, av as CurrentUnit, aw as CustomFormat, ax as DEFAULT_MAP_TYPE, ay as DateFormatStyle, az as DistanceUnit, aA as ENTITY_CATEGORY_CONFIG, E as ENTITY_CONFIG, aB as EntityCategory, aC as EntityCategoryConfig, h as EntityConfig, i as EntityType, aD as GRID_STATE_COLORS, aE as GridStateColor, H as Heading, aF as InteractiveMap, aG as InteractiveMapHandle, I as InteractiveMapProps, aH as LayerFeature, aI as LayerStyle, L as Loader, j as Logo, aJ as MAP_TYPES, M as MapPoint, aK as MapType, aL as Meter, k as MeterProps, aM as MetricFormat, aN as PercentageFormat, aO as PowerUnit, aP as RenderType, aQ as ResistanceUnit, S as SegmentOption, aR as SegmentedControl, l as SegmentedControlProps, m as SideNav, n as SideNavItem, o as SideNavProps, aS as StackNav, aT as StackNavGroup, aU as StackNavItem, aV as StackNavLinkComponentProps, aW as StackNavProps, aX as StackNavTheme, aY as StaticMap, p as StaticMapProps, T as TextLink, aZ as TextTransform, a_ as TextTruncatePosition, r as TooltipSeries, s as TopNav, t as TopNavProps, a$ as VoltageUnit, Y as YFormatSettings, b0 as ZoomStops, b1 as activeDeviceStates, b2 as baselineFromPoint, v as clearColorCache, w as createCategoryColorMap, x as createXScale, y as createYScale, z as defaultMargin, b3 as deviceStateLabels, b4 as deviceStateMetricFormats, b5 as formatComponentValue, D as getContrastingTextColor, F as getDefaultChartColor, G as getDefaultColors, b6 as getDeviceStateDisplayLabel, b6 as getDeviceStateLabel, b7 as getEntityCategory, J as getEntityConfig, K as getEntityIcon, N as getEntityLabel, b8 as getGridStateLabel, O as getResolvedColor, P as getThemeCategoricalColors, Q as getYFormatSettings, b9 as gridStateLabels, ba as isActiveDeviceState, ba as isActiveState, R as isLightColor, bb as mapValuesToCategoricalColors, bc as useChartContext, bd as useComponentFormatter } from './colors-DsSW-pdc.cjs';
-import { Virtualizer } from '@tanstack/react-virtual';
+import { U as FieldValue, V as BooleanFormat, W as FormattedValue, X as FieldFormat, Z as CurrentFormat, _ as DateFormat, $ as DistanceFormat, a0 as EnergyUnit, a1 as EnergyFormat, a2 as CurrencyFormat, a3 as NumberFormat, a4 as PhoneFormat, a5 as PowerFormat, a6 as FormatterFunction, a7 as ResistanceFormat, a8 as TemperatureFormat, a9 as TemperatureUnitString, aa as TemperatureUnit, ab as TextFormat, ac as VoltageFormat, B as BadgeProps, d as BaseDataPoint, u as YFormatType, q as TooltipData, ad as DeviceState, ae as GridState, af as ComponentFormatter, ag as LayerSpec, ah as CustomPinsSpec, ai as GeoJsonLayerSpec, aj as RasterLayerSpec, ak as VectorLayerSpec, al as ClusteredVectorLayerSpec } from './colors-AT5gFqGB.cjs';
+export { A as ActionItem, am as ActionMenu, a as ActionMenuProps, an as AppShell, b as AppShellProps, ao as Avatar, c as AvatarProps, ap as Badge, aq as BaseFormat, ar as ChartContext, C as ChartMargin, as as CodeEditor, e as CodeEditorProps, f as CodeLanguage, g as CodeTheme, at as ColorSpec, au as ComponentFormatOptions, av as CurrentUnit, aw as CustomFormat, ax as DEFAULT_MAP_TYPE, ay as DateFormatStyle, az as DistanceUnit, aA as ENTITY_CATEGORY_CONFIG, E as ENTITY_CONFIG, aB as EntityCategory, aC as EntityCategoryConfig, h as EntityConfig, i as EntityType, aD as GRID_STATE_COLORS, aE as GridStateColor, H as Heading, aF as InteractiveMap, aG as InteractiveMapHandle, I as InteractiveMapProps, aH as LayerFeature, aI as LayerStyle, L as Loader, j as Logo, aJ as MAP_TYPES, M as MapPoint, aK as MapType, aL as Meter, k as MeterProps, aM as MetricFormat, aN as PercentageFormat, aO as PowerUnit, aP as RenderType, aQ as ResistanceUnit, S as SegmentOption, aR as SegmentedControl, l as SegmentedControlProps, m as SideNav, n as SideNavItem, o as SideNavProps, aS as StackNav, aT as StackNavGroup, aU as StackNavItem, aV as StackNavLinkComponentProps, aW as StackNavProps, aX as StackNavTheme, aY as StaticMap, p as StaticMapProps, T as TextLink, aZ as TextTransform, a_ as TextTruncatePosition, r as TooltipSeries, s as TopNav, t as TopNavProps, a$ as VoltageUnit, Y as YFormatSettings, b0 as ZoomStops, b1 as activeDeviceStates, b2 as baselineFromPoint, v as clearColorCache, w as createCategoryColorMap, x as createXScale, y as createYScale, z as defaultMargin, b3 as deviceStateLabels, b4 as deviceStateMetricFormats, b5 as formatComponentValue, D as getContrastingTextColor, F as getDefaultChartColor, G as getDefaultColors, b6 as getDeviceStateDisplayLabel, b6 as getDeviceStateLabel, b7 as getEntityCategory, J as getEntityConfig, K as getEntityIcon, N as getEntityLabel, b8 as getGridStateLabel, O as getResolvedColor, P as getThemeCategoricalColors, Q as getYFormatSettings, b9 as gridStateLabels, ba as isActiveDeviceState, ba as isActiveState, R as isLightColor, bb as mapValuesToCategoricalColors, bc as useChartContext, bd as useComponentFormatter } from './colors-AT5gFqGB.cjs';
 import * as react_jsx_runtime from 'react/jsx-runtime';
 import { I as Icon$1, S as Size, d as IconName$2, B as BaseInputProps } from './RichTextEditor-BNXNpG4s.cjs';
 export { e as BaseProps, C as CUSTOM_ICON_REGISTRY, f as ClearButton, g as CustomIconName, a as DateField, D as DateFieldProps, h as Description, i as DescriptionPlacement, j as DescriptionProps, k as FieldError, l as FieldErrorProps, m as FieldGroup, n as FieldGroupProps, b as FileUpload, F as FileUploadProps, o as Input, p as InputProps, q as InputStyleProps, r as InputWrapper, L as Label, s as LabelProps, P as PhosphorIconName, c as RichTextEditor, R as RichTextEditorProps, t as getFieldGroupStyles, u as getInputBackgroundStyles, v as getInputBaseStyles, w as getInputStateStyles, x as useInputFocus } from './RichTextEditor-BNXNpG4s.cjs';
@@ -80,1553 +80,1404 @@ type UseBreakpointReturn = BreakpointState;
 declare function useBreakpoint(defaultBreakpoint?: Breakpoint | "base"): BreakpointState;
 
 /**
- * Boolean formatting utilities
+ * Data Controls Types
+ *
+ * Core type definitions for client-side and server-side data filtering,
+ * sorting, faceting, and search operations.
  */
-
+type FilterOperator = "eq" | "neq" | "in" | "nin" | "gt" | "gte" | "lt" | "lte" | "contains" | "startsWith" | "endsWith";
+interface FilterCondition {
+    /** Field name (supports nested paths like 'user.profile.name') */
+    field: string;
+    /** Comparison operator */
+    operator: FilterOperator;
+    /** Value to compare against */
+    value: string | number | boolean | (string | number)[];
+}
+interface FilterGroup {
+    /** Logical operator combining conditions */
+    logic: "AND" | "OR";
+    /** Conditions or nested filter groups */
+    conditions: (FilterCondition | FilterGroup)[];
+}
+/** Root filter state - can be empty, a single group, or nested groups */
+type FilterState = FilterGroup | null;
+interface SortState {
+    /** Field to sort by (supports nested paths) */
+    field: string;
+    /** Sort direction */
+    direction: "asc" | "desc";
+}
+interface SearchConfig {
+    /** Search query string */
+    query: string;
+    /** Fields to search across */
+    fields: string[];
+    /** Use fuzzy matching (Fuse.js) - default true */
+    fuzzy?: boolean;
+    /** Fuse.js matching threshold (0.0 = perfect, 1.0 = anything) - default 0.3 */
+    threshold?: number;
+}
+type FacetType = "string" | "number" | "boolean" | "date";
+interface FacetConfig {
+    /** Field name to facet on */
+    field: string;
+    /** Display label for the facet */
+    label: string;
+    /** Data type of the field */
+    type?: FacetType;
+    /** Optional: Provide predefined values for the facet (useful for enums) */
+    values?: Array<{
+        value: string | number;
+        label: string;
+    }>;
+    /** Number of options to show before requiring search (default: 10) */
+    searchThreshold?: number;
+    /** Max options to show initially, with "Show all" button for rest (default: 50) */
+    maxVisibleOptions?: number;
+    /** Optional description text to show below the label */
+    description?: string;
+    /** Optional: Custom render function for option labels (e.g., to show Badges) */
+    renderLabel?: (value: string, label: string) => React.ReactNode;
+    /** Optional: Group name for organizing filters in FilterDialog */
+    group?: string;
+}
+interface FacetCounts {
+    [field: string]: {
+        [value: string]: number;
+    };
+}
 /**
- * Format boolean value with custom text
+ * Create a single filter condition
  */
-declare const toBoolean: (value: boolean | null | undefined, trueText?: string, falseText?: string) => string | null;
+declare function createFilter(field: string, operator: FilterOperator, value: string | number | boolean | (string | number)[]): FilterCondition;
 /**
- * Format boolean as enabled/disabled
+ * Create a filter group from multiple conditions with AND logic
  */
-declare const toEnabledDisabled: (value: boolean | null | undefined) => string | null;
+declare function createFilters(conditions: FilterCondition[], logic?: "AND" | "OR"): FilterGroup;
 /**
- * Format boolean as on/off
+ * Create an empty filter state
  */
-declare const toOnOff: (value: boolean | null | undefined) => string | null;
+declare function createEmptyFilter(): FilterGroup;
 /**
- * Format boolean as active/inactive
+ * Check if a filter state is empty (no conditions)
  */
-declare const toActiveInactive: (value: boolean | null | undefined) => string | null;
+declare function isFilterEmpty(filter: FilterState): boolean;
 /**
- * Format boolean as true/false
+ * Convert structured filter state to simple display chips
+ * Used for backward compatibility with existing FilterChips component
  */
-declare const toTrueFalse: (value: boolean | null | undefined) => string | null;
+interface FilterChip {
+    id: string;
+    label: string;
+    value: string;
+}
+declare function filterToChips(filter: FilterState, facetConfigs?: FacetConfig[]): FilterChip[];
 /**
- * Format boolean as checkmark/cross
+ * Add a condition to a filter state
  */
-declare const toCheckmark: (value: boolean | null | undefined) => string | null;
+declare function addFilterCondition(filter: FilterState, condition: FilterCondition): FilterGroup;
 /**
- * Parse various truthy/falsy values to boolean
+ * Remove a condition from a filter state by field
  */
-declare const parseBoolean: (value: FieldValue) => boolean | null;
+declare function removeFilterCondition(filter: FilterState, field: string): FilterGroup;
 /**
- * Format boolean according to BooleanFormat specification
+ * Get all unique fields being filtered on
  */
-declare const formatBoolean: (value: FieldValue, format: BooleanFormat) => FormattedValue;
+declare function getFilterFields(filter: FilterState): string[];
 
+interface UseClientDataControlsOptions<T> {
+    /** Raw data to process */
+    data: T[];
+    /** Filter state */
+    filters?: FilterState;
+    /** Sort state */
+    sort?: SortState | null;
+    /** Search configuration */
+    search?: SearchConfig | null;
+    /** Facet configurations */
+    facetConfigs?: FacetConfig[];
+}
+interface UseClientDataControlsResult<T> {
+    /** Processed data (filtered, sorted, searched) */
+    data: T[];
+    /** Facet counts computed from filtered data */
+    facetCounts: FacetCounts;
+    /** Number of results after filtering/searching */
+    resultCount: number;
+}
 /**
- * Capacity formatting utilities for batteries and energy storage
+ * useClientDataControls
  *
- * Domain-specific formatters for energy capacity (kWh) and power ratings (kW).
- * Auto-scales to appropriate units (MWh, MW for large values).
- */
-/**
- * Format battery capacity (kWh)
+ * Client-side hook for filtering, sorting, searching, and faceting data.
+ * Uses memoization to avoid unnecessary recomputation.
  *
- * @param value - Capacity in kWh
- * @param decimals - Number of decimal places (default: 1)
- * @returns Formatted capacity string or null
+ * Operations are applied in this order:
+ * 1. Search (fuzzy or exact matching)
+ * 2. Filter (structured conditions)
+ * 3. Facet computation (on filtered data)
+ * 4. Sort
  *
  * @example
- * ```typescript
- * formatCapacity(13.5); // "13.5 kWh"
- * formatCapacity(1500); // "1.5 MWh"
- * formatCapacity(null); // null
+ * ```tsx
+ * const { data, facetCounts, resultCount } = useClientDataControls({
+ *   data: rawData,
+ *   filters: createFilters([
+ *     createFilter('department', 'in', ['Engineering', 'Sales'])
+ *   ]),
+ *   sort: { field: 'name', direction: 'asc' },
+ *   search: { query: searchQuery, fields: ['name', 'email'] },
+ *   facetConfigs: [
+ *     { field: 'department', label: 'Department' },
+ *     { field: 'status', label: 'Status' }
+ *   ]
+ * });
  * ```
  */
-declare function formatCapacity(value: number | null | undefined, decimals?: number): string | null;
+declare function useClientDataControls<T>({ data, filters, sort, search, facetConfigs, }: UseClientDataControlsOptions<T>): UseClientDataControlsResult<T>;
+
 /**
- * Format power rating (kW)
+ * useContainerBreakpoint — measures a container element's width and returns
+ * the same BreakpointState shape as useBreakpoint, but derived from the
+ * container, not the window.
  *
- * @param value - Power rating in kW
- * @param decimals - Number of decimal places (default: 1)
- * @returns Formatted power rating string or null
+ * Blocks that need to respond to their render width (not the viewport) should
+ * use this hook instead of useBreakpoint. When rendered inside a
+ * ContainerQueryProvider, the hook reads from context (no ref needed). When
+ * no provider is present, it falls back to measuring its own ref, or
+ * ultimately to window-based breakpoints.
  *
- * @example
- * ```typescript
- * formatPowerRating(5.2); // "5.2 kW"
- * formatPowerRating(2500); // "2.5 MW"
- * formatPowerRating(null); // null
- * ```
+ * @returns BreakpointState — same shape as useBreakpoint
  */
-declare function formatPowerRating(value: number | null | undefined, decimals?: number): string | null;
+declare function useContainerBreakpoint(containerRef?: React.RefObject<HTMLElement | null>): BreakpointState;
 
+interface ServerDataState {
+    filters: FilterState;
+    sort: SortState | null;
+    search: SearchConfig | null;
+}
+interface UseServerDataControlsOptions {
+    /** Filter state */
+    filters: FilterState;
+    /** Sort state */
+    sort: SortState | null;
+    /** Search configuration */
+    search: SearchConfig | null;
+    /** Callback when state changes (debounced for search) */
+    onStateChange: (state: ServerDataState) => void;
+    /** Search debounce delay in ms (default: 300) */
+    searchDebounce?: number;
+}
 /**
- * Shared CSV export helpers for unit-bearing FieldFormats.
+ * useServerDataControls
  *
- * CSV columns need one unit for the whole column, not per-row auto-scaling. The
- * on-screen display can happily render "12 kV" one row and "500 mV" the next
- * because a human reads them in context, but in a spreadsheet that mixes
- * magnitudes in a single column and makes the data unusable.
+ * Server-side hook that notifies the parent when filter/sort/search state changes.
+ * Search queries are debounced to avoid excessive API calls.
  *
- * These helpers pick a stable column-wide unit for a given FieldFormat and
- * return the bare number that matches that unit:
+ * This hook doesn't manipulate data - it just provides a clean way to:
+ * 1. Debounce search input
+ * 2. Notify when any state changes
+ * 3. Trigger server refetch
  *
- *   - `csvUnitFor(format)`   → the unit string to show in the column header,
- *     or null when the format has no meaningful unit (text, number, date, …).
- *   - `csvValueFor(raw, format)` → the bare-number string for a cell in that
- *     column. Returns null for non-numeric formats (caller falls back to the
- *     regular display formatter), and "" when the display would be blank
- *     (hideWhenNull / hideWhenZero / null value).
+ * @example
+ * ```tsx
+ * const [filters, setFilters] = useState(null);
+ * const [sort, setSort] = useState({ field: 'name', direction: 'asc' });
+ * const [search, setSearch] = useState({ query: '', fields: ['name'] });
  *
- * Consumers:
- *   - `apps/dashboard/components/Explorer/tables/deviceFieldExport.ts` (Explore CSV)
- *   - `packages/edges/src/utils/chartExport.ts` (chart CSV export)
+ * useServerDataControls({
+ *   filters,
+ *   sort,
+ *   search,
+ *   onStateChange: (state) => {
+ *     // Refetch data with new parameters
+ *     refetch({
+ *       filters: state.filters,
+ *       sort: state.sort,
+ *       search: state.search?.query
+ *     });
+ *   }
+ * });
+ * ```
  */
+declare function useServerDataControls({ filters, sort, search, onStateChange, searchDebounce, }: UseServerDataControlsOptions): void;
 
+interface UseDataControlsClientOptions<T> {
+    mode: "client";
+    /** Raw data to process (required in client mode) */
+    data: T[];
+    /** Filter state */
+    filters?: FilterState;
+    /** Sort state */
+    sort?: SortState | null;
+    /** Search configuration */
+    search?: SearchConfig | null;
+    /** Facet configurations */
+    facetConfigs?: FacetConfig[];
+}
+interface UseDataControlsServerOptions<T> {
+    mode: "server";
+    /** Data from server (already filtered/sorted) */
+    data: T[];
+    /** Filter state */
+    filters: FilterState;
+    /** Sort state */
+    sort: SortState | null;
+    /** Search configuration */
+    search: SearchConfig | null;
+    /** Callback when state changes (required in server mode) */
+    onStateChange: (state: ServerDataState) => void;
+    /** Search debounce delay in ms (default: 300) */
+    searchDebounce?: number;
+    /** Result count from server */
+    resultCount?: number;
+    /** Facet counts from server */
+    facetCounts?: FacetCounts;
+}
+type UseDataControlsOptions<T> = UseDataControlsClientOptions<T> | UseDataControlsServerOptions<T>;
+interface UseDataControlsResult<T> {
+    /** Processed data (client mode) or server data (server mode) */
+    data: T[];
+    /** Facet counts (computed in client mode, passed through in server mode) */
+    facetCounts: FacetCounts;
+    /** Result count (computed in client mode, passed through in server mode) */
+    resultCount: number;
+}
 /**
- * Pick the CSV column unit for a FieldFormat.
- *
- * Rules:
- * - Explicit `unit` on the format wins.
- * - Otherwise fall back to the format's canonical base unit
- *   (`DEFAULT_BASE_UNIT` lookup) so every row in the column shares one unit
- *   even if the on-screen display would auto-scale.
- * - Energy honours `sourceUnit` (e.g. meter consumption is stored in kWh) as
- *   the natural stable unit when neither `unit` nor a base fallback would fit.
- * - Temperature symbols are normalised from `"C"`/`"CELSIUS"` etc. to `"°C"`.
- * - Formats with no meaningful unit (text, number, date, boolean, currency,
- *   phone, custom) return null.
- */
-declare function csvUnitFor(format: FieldFormat | undefined | null): string | null;
-/**
- * Convert a raw value to a bare-number CSV string in the same unit
- * `csvUnitFor` reports.
- *
- * Returns:
- *  - `null` when the format is non-numeric (caller falls back to the display
- *    formatter, e.g. text/date/enum).
- *  - `""` when the display would suppress the value (hideWhenNull / hideWhenZero).
- *  - a bare number string otherwise, with the trailing unit stripped so the
- *    cell can be summed / charted in the spreadsheet.
- */
-declare function csvValueFor(raw: unknown, format: FieldFormat): string | null;
-
-/**
- * Electrical current formatting utilities (flow of electric charge)
- */
-
-/**
- * Format as milliamps
- */
-declare const toMilliamps: (value: number | null | undefined, decimals?: number) => string | null;
-/**
- * Format as amperes
- */
-declare const toAmps: (value: number | null | undefined, decimals?: number) => string | null;
-/**
- * Format as kiloamps (rarely used but included for completeness)
- */
-declare const toKiloamps: (value: number | null | undefined, decimals?: number) => string | null;
-/**
- * Auto-scale current to the most appropriate unit
- */
-declare const autoScaleCurrent: (value: number | null | undefined, decimals?: number) => string | null;
-/**
- * Format current according to CurrentFormat specification
+ * useDataControls
+ *
+ * Unified hook for managing data filtering, sorting, searching, and faceting.
+ * Supports both client-side and server-side modes.
+ *
+ * **Client Mode:**
+ * - Processes data locally using pure functions
+ * - Computes facet counts automatically
+ * - Best for datasets < 5000 rows
+ *
+ * **Server Mode:**
+ * - Notifies parent when state changes (debounced for search)
+ * - Passes through server-provided data and counts
+ * - Best for large datasets or complex queries
+ *
+ * @example Client Mode
+ * ```tsx
+ * const { data, facetCounts, resultCount } = useDataControls({
+ *   mode: 'client',
+ *   data: rawData,
+ *   filters: createFilters([...]),
+ *   sort: { field: 'name', direction: 'asc' },
+ *   search: { query: searchQuery, fields: ['name', 'email'] },
+ *   facetConfigs: [{ field: 'department', label: 'Department' }]
+ * });
+ * ```
+ *
+ * @example Server Mode
+ * ```tsx
+ * const { data, facetCounts, resultCount } = useDataControls({
+ *   mode: 'server',
+ *   data: serverData, // Already filtered
+ *   filters,
+ *   sort,
+ *   search,
+ *   resultCount: totalCount,
+ *   facetCounts: serverFacets,
+ *   onStateChange: (state) => refetch(state)
+ * });
+ * ```
  */
-declare const formatCurrent: (value: FieldValue, format: CurrentFormat) => FormattedValue;
-declare const toMA: (value: number | null | undefined, decimals?: number) => string | null;
-declare const toA: (value: number | null | undefined, decimals?: number) => string | null;
-declare const toKA: (value: number | null | undefined, decimals?: number) => string | null;
+declare function useDataControls<T>(options: UseDataControlsOptions<T>): UseDataControlsResult<T>;
 
-/**
- * Date formatting utilities using Luxon
- */
+declare function useDebounce<T>(value: T, delay?: number): T;
 
+interface ElementSize {
+    width: number;
+    height: number;
+}
+interface UseElementSizeResult<T extends HTMLElement = HTMLElement> {
+    ref: (node: T | null) => void;
+    width: number;
+    height: number;
+}
 /**
- * Format date to a localized string with optional time and timezone.
+ * useElementSize
  *
- * @param value - Date value (string, Date object, or timestamp)
- * @param showTime - Whether to include time in the output (default: false)
- * @param timezone - Optional timezone for display (e.g., "America/New_York")
- * @returns Formatted date string or null
+ * A performant hook that tracks the dimensions of a DOM element using ResizeObserver.
+ * Returns a callback ref to attach to the element and its current width/height.
+ *
+ * Performance optimizations:
+ * - Uses ResizeObserver for efficient resize detection
+ * - Debounces updates using requestAnimationFrame
+ * - Cleans up observer on unmount
  *
  * @example
- * ```typescript
- * toDateString(new Date()); // "12/25/2023"
- * toDateString(new Date(), true); // "12/25/2023, 3:30 PM"
- * toDateString("2023-12-25T15:30:00Z", true, "America/New_York"); // "12/25/2023, 10:30 AM"
+ * ```tsx
+ * const { ref, width, height } = useElementSize();
+ *
+ * return (
+ *   <div ref={ref}>
+ *     Width: {width}px, Height: {height}px
+ *   </div>
+ * );
  * ```
  */
-declare const toDateString: (value: string | Date | number | null | undefined, showTime?: boolean, timezone?: string) => string | null;
+declare function useElementSize<T extends HTMLElement = HTMLElement>(): UseElementSizeResult<T>;
+
+type LoadingState = "idle" | "loading" | "loading-more" | "error";
+interface UseInfiniteScrollOptions<T = unknown> {
+    /** Array of items being displayed */
+    items: T[];
+    /** Callback to load more items (optional - if not provided, no infinite scroll) */
+    onLoadMore?: () => void | Promise<void>;
+    /** Whether there are more items to load */
+    hasMore?: boolean;
+    /** Auto-detects initial vs loading-more from items.length */
+    isLoading?: boolean;
+    /** Explicit loading state override (takes precedence) */
+    loadingState?: LoadingState;
+    /** Enable virtualization (default: true for 100+ items) */
+    enableVirtualization?: boolean;
+    /** Estimated size of each item in pixels */
+    estimatedItemSize?: number;
+    /** Number of items to render outside viewport */
+    overscan?: number;
+    /** Custom scroll element (defaults to parent) */
+    scrollElement?: HTMLElement | null;
+    /** Distance from bottom in pixels to trigger load */
+    loadMoreThreshold?: number;
+}
+interface UseInfiniteScrollReturn {
+    virtualizer: Virtualizer<HTMLElement, Element> | null;
+    virtualItems: ReturnType<Virtualizer<HTMLElement, Element>["getVirtualItems"]>;
+    computedLoadingState: LoadingState;
+    isInitialLoad: boolean;
+    isLoadingMore: boolean;
+    scrollRef: RefObject<HTMLDivElement | null>;
+    loadMoreRef: RefObject<HTMLDivElement | null>;
+    scrollToIndex: (index: number, options?: {
+        align?: "start" | "center" | "end";
+    }) => void;
+    scrollToTop: () => void;
+}
 /**
- * Format date to relative time (e.g., "2 hours ago", "in 3 days").
- * Automatically chooses the most appropriate unit.
+ * useInfiniteScroll
  *
- * @param value - Date value (string, Date object, or timestamp)
- * @returns Relative time string or null
+ * Hook for implementing infinite scroll with optional virtualization.
+ * Intelligently detects initial vs loading-more states from context.
+ *
+ * Features:
+ * - Smart loading state detection (initial vs loading-more)
+ * - Optional explicit state control
+ * - TanStack Virtual integration for performance
+ * - Intersection Observer for load triggering
+ * - Configurable virtualization threshold
  *
  * @example
- * ```typescript
- * toRelativeTime(new Date(Date.now() - 3600000)); // "1 hour ago"
- * toRelativeTime(new Date(Date.now() + 86400000)); // "in 1 day"
- * toRelativeTime(new Date()); // "now"
+ * ```tsx
+ * const { scrollRef, computedLoadingState, isLoadingMore } = useInfiniteScroll({
+ *   items,
+ *   onLoadMore: fetchNextPage,
+ *   hasMore: hasNextPage,
+ *   isLoading: isFetching,
+ * });
  * ```
  */
-declare const toRelativeTime: (value: string | Date | number | null | undefined) => string | null;
-/**
- * Format date with full date and time including weekday
- */
-declare const toFullDateTime: (value: string | Date | number | null | undefined, timezone?: string) => string | null;
-/**
- * Format date to ISO string
- */
-declare const toISOString: (value: string | Date | number | null | undefined) => string | null;
-/**
- * Format date with custom format string
- */
-declare const toCustomDateFormat: (value: string | Date | number | null | undefined, format: string, timezone?: string) => string | null;
-/**
- * Get formatted date parts
- */
-declare const getDateParts: (value: string | Date | number | null | undefined) => {
-    year: number;
-    month: number;
-    day: number;
-    weekday: number;
-    hour: number;
-    minute: number;
-    second: number;
-    millisecond: number;
-    weekdayShort: string | null;
-    weekdayLong: string | null;
-    monthShort: string | null;
-    monthLong: string | null;
-} | null;
+declare function useInfiniteScroll<T = unknown>({ items, onLoadMore, hasMore, isLoading, loadingState, enableVirtualization, estimatedItemSize, overscan, scrollElement, loadMoreThreshold, }: UseInfiniteScrollOptions<T>): UseInfiniteScrollReturn;
+
 /**
- * Format date according to DateFormat specification
+ * Hook for managing localStorage values with React state synchronization
+ * @param key - The localStorage key
+ * @param initialValue - The initial value if nothing is stored
+ * @returns [value, setValue, removeValue] - Current value, setter function, and remove function
  */
-declare const formatDate: (value: FieldValue, format: DateFormat) => FormattedValue;
+declare function useLocalStorage<T>(key: string, initialValue: T): [T, (value: T | ((val: T) => T)) => void, () => void];
 
 /**
- * Distance and length formatting utilities
+ * Hook to check if a media query matches the current viewport
+ *
+ * @param query - A CSS media query string (e.g., "(min-width: 768px)")
+ * @param defaultValue - The default value to return during SSR or before the first render
+ * @returns A boolean indicating whether the media query matches
+ *
+ * @example
+ * ```tsx
+ * const isMobile = useMediaQuery('(max-width: 767px)');
+ * const prefersReducedMotion = useMediaQuery('(prefers-reduced-motion: reduce)');
+ * const isLandscape = useMediaQuery('(orientation: landscape)');
+ * ```
  */
+declare function useMediaQuery(query: string, defaultValue?: boolean): boolean;
+
+type SortDirection = "asc" | "desc";
+type CellAlignment = "left" | "center" | "right";
+type TableDensity = "compact" | "default" | "relaxed";
+type CellEmphasis = "strong" | "high" | "normal" | "low";
+type LinkBehavior = "none" | "hover" | "visible";
+type TableLayout = "auto" | "fixed" | "responsive";
+type TableWidth = "full" | "auto" | "contained";
+type MobileRenderer = "auto" | "cards" | "custom" | "none";
+type MobileBreakpoint = "sm" | "md" | "lg" | "xl";
+interface SortConfig {
+    columnId: string;
+    direction: SortDirection;
+}
+interface CellContext {
+    isLoading: boolean;
+    isSelected?: boolean;
+    isHovered?: boolean;
+    rowIndex: number;
+    columnIndex: number;
+    density: TableDensity;
+}
+interface CellComponentProps<T = any> {
+    value: any;
+    row: T;
+    context: CellContext;
+    [key: string]: any;
+}
+type CellComponent<T = any> = ComponentType<CellComponentProps<T>>;
+interface MobileConfig {
+    priority?: 1 | 2 | 3;
+    format?: "primary" | "secondary" | "badge" | "inline";
+    label?: boolean;
+    icon?: string;
+}
+interface Column<T> {
+    id: string;
+    label: string;
+    accessor?: keyof T | ((row: T) => any);
+    align?: CellAlignment;
+    width?: string | number;
+    minWidth?: string | number;
+    maxWidth?: string | number;
+    flex?: number;
+    cell?: CellComponent<T>;
+    cellProps?: Record<string, any> | ((value: any, row: T) => Record<string, any>);
+    render?: (value: any, row: T, context: CellContext) => ReactNode;
+    sortable?: boolean;
+    /**
+     * Whether this column can be reordered via drag-and-drop.
+     * Defaults to true. Set to false to lock a column in place (e.g., sticky first column).
+     */
+    reorderable?: boolean;
+    noCellPadding?: boolean;
+    mobile?: MobileConfig | false;
+    popover?: string | ((value: unknown, row: T) => ReactNode) | {
+        content: string | ((value: unknown, row: T) => ReactNode);
+        placement?: "top" | "bottom" | "left" | "right";
+        showArrow?: boolean;
+        trigger?: "hover" | "click";
+    };
+    /** Label to use for this column in CSV export headers. Falls back to `label` if not provided. */
+    exportLabel?: string;
+    /**
+     * Custom function to transform the cell value for export.
+     * If not provided, uses the raw accessor value converted to string.
+     * @param value - The raw cell value from the accessor
+     * @param row - The full row data
+     * @returns The value to export (will be converted to string)
+     */
+    exportValue?: (value: unknown, row: T) => string | number | boolean | null;
+    /**
+     * Whether to include this column in CSV exports.
+     * Defaults to true. Set to false to exclude columns like action buttons.
+     */
+    exportable?: boolean;
+}
+interface DataTableProps<T> {
+    columns: Column<T>[];
+    data: T[];
+    className?: string;
+    density?: TableDensity;
+    width?: TableWidth;
+    height?: string | number;
+    maxHeight?: string | number;
+    layout?: TableLayout;
+    mobileRenderer?: MobileRenderer;
+    customMobileRowRender?: (row: T, index: number) => ReactNode;
+    mobileBreakpoint?: MobileBreakpoint;
+    isLoading?: boolean;
+    loadingState?: LoadingState;
+    loadingRowCount?: number;
+    onLoadMore?: () => void | Promise<void>;
+    hasMore?: boolean;
+    enableVirtualization?: boolean;
+    estimatedRowHeight?: number;
+    loadingIndicator?: ReactNode;
+    stickyHeader?: boolean;
+    /** Make the first column sticky on horizontal scroll */
+    stickyFirstColumn?: boolean;
+    onRowClick?: (row: T) => void;
+    getRowId?: (row: T) => string;
+    hideHeader?: boolean;
+    /** Controlled sort configuration - when provided, DataTable becomes controlled */
+    sortConfig?: SortConfig | null;
+    onSort?: (sortConfig: SortConfig | null) => void;
+    "aria-label"?: string;
+    /**
+     * Enable drag-and-drop column reordering (like Notion tables).
+     * When enabled, users can drag column headers to reorder columns.
+     */
+    enableColumnReorder?: boolean;
+    /**
+     * Controlled column order - array of column IDs in display order.
+     * When provided, DataTable uses this order instead of the columns array order.
+     * Use with onColumnOrderChange for controlled behavior.
+     */
+    columnOrder?: string[];
+    /**
+     * Callback fired when column order changes via drag-and-drop.
+     * Receives the new array of column IDs in their new order.
+     */
+    onColumnOrderChange?: (columnOrder: string[]) => void;
+}
 
 /**
- * Format as meters
- */
-declare const toMeters: (value: number | null | undefined, decimals?: number) => string | null;
-/**
- * Format as centimeters
- */
-declare const toCentimeters: (value: number | null | undefined, decimals?: number) => string | null;
-/**
- * Format as millimeters
+ * Table export utilities for CSV format
+ * Provides export functionality for DataTable data
  */
-declare const toMillimeters: (value: number | null | undefined, decimals?: number) => string | null;
+
+interface TableExportMetadata {
+    /** Base filename for the exported file (without extension) */
+    filename?: string;
+    /** Whether to include timestamp in filename. Defaults to true */
+    timestamp?: boolean;
+}
+interface TableExportOptions<T> {
+    /** Column definitions for the table */
+    columns: Column<T>[];
+    /** Data rows to export */
+    data: T[];
+    /** Export metadata */
+    metadata?: TableExportMetadata;
+}
 /**
- * Format as kilometers
+ * Export table data as CSV
+ *
+ * @param options - Export configuration
+ * @returns Promise that resolves when export is complete
+ *
+ * @example
+ * ```typescript
+ * await exportTableAsCSV({
+ *   columns: tableColumns,
+ *   data: tableData,
+ *   metadata: {
+ *     filename: "devices-export",
+ *     timestamp: true
+ *   }
+ * });
+ * ```
  */
-declare const toKilometers: (value: number | null | undefined, decimals?: number) => string | null;
+declare function exportTableAsCSV<T>(options: TableExportOptions<T>): Promise<void>;
 /**
- * Format as feet
+ * Prepare table data for export (without triggering download)
+ * Useful for server-side export where you need the transformed data
+ *
+ * @param options - Export configuration
+ * @returns Array of row objects ready for CSV generation
  */
-declare const toFeet: (value: number | null | undefined, decimals?: number) => string | null;
+declare function prepareTableDataForExport<T>(options: Omit<TableExportOptions<T>, "metadata">): Record<string, string | number | boolean>[];
 /**
- * Format as inches
+ * Get column headers for export
+ * Useful for generating CSV headers on the server
  */
-declare const toInches: (value: number | null | undefined, decimals?: number) => string | null;
+declare function getExportHeaders<T>(columns: Column<T>[]): string[];
+
+interface UseTableExportOptions<T> {
+    /** Column definitions for the table */
+    columns: Column<T>[];
+    /** Data rows to export */
+    data: T[];
+    /** Export metadata */
+    metadata?: TableExportMetadata;
+}
+interface UseTableExportReturn {
+    /** Trigger CSV export of the table data */
+    exportCSV: () => Promise<void>;
+    /** Whether export is available (has data and exportable columns) */
+    canExport: boolean;
+}
 /**
- * Format as miles
+ * Hook for exporting DataTable data as CSV.
+ * Provides a stable callback for triggering exports with memoized dependencies.
+ *
+ * For client-side DataTables where all data is in the browser.
+ * For server-side exports, use the `onExport` callback pattern instead.
+ *
+ * @param options - Configuration for table export
+ * @returns Object with export function and status
+ *
+ * @example
+ * ```tsx
+ * const { exportCSV, canExport } = useTableExport({
+ *   columns: deviceColumns,
+ *   data: devices,
+ *   metadata: {
+ *     filename: "devices",
+ *     timestamp: true
+ *   }
+ * });
+ *
+ * // In your DataControls actions
+ * <DataControls
+ *   actions={{
+ *     items: [
+ *       {
+ *         id: "export",
+ *         label: "Export CSV",
+ *         icon: "Export",
+ *         onClick: exportCSV,
+ *         disabled: !canExport
+ *       }
+ *     ]
+ *   }}
+ * />
+ * ```
  */
-declare const toMiles: (value: number | null | undefined, decimals?: number) => string | null;
+declare function useTableExport<T>({ columns, data, metadata }: UseTableExportOptions<T>): UseTableExportReturn;
+
 /**
- * Format as yards
+ * Data Operations Utilities
+ *
+ * Pure functions for filtering, sorting, searching, and faceting data.
+ * These functions are used by useClientDataControls but can also be used standalone.
  */
-declare const toYards: (value: number | null | undefined, decimals?: number) => string | null;
-/**
- * Format as nautical miles
- */
-declare const toNauticalMiles: (value: number | null | undefined, decimals?: number) => string | null;
-/**
- * Conversion utilities
- */
-declare const metersToFeet: (meters: number) => number;
-declare const feetToMeters: (feet: number) => number;
-declare const milesToKilometers: (miles: number) => number;
-declare const kilometersToMiles: (km: number) => number;
-declare const feetToMiles: (feet: number) => number;
-declare const milesToFeet: (miles: number) => number;
-declare const metersToMiles: (meters: number) => number;
-declare const milesToMeters: (miles: number) => number;
-declare const yardsToMeters: (yards: number) => number;
-declare const metersToYards: (meters: number) => number;
-declare const inchesToCentimeters: (inches: number) => number;
-declare const centimetersToInches: (cm: number) => number;
-/**
- * Auto-scale distance to the most appropriate unit
- */
-declare const autoScaleDistance: (value: number | null | undefined, metric?: boolean, decimals?: number) => string | null;
+
+interface ApplyDataOperationsOptions<T> {
+    data: T[];
+    filters?: FilterState;
+    sort?: SortState | null;
+    search?: SearchConfig | null;
+    facetConfigs?: FacetConfig[];
+}
+interface ApplyDataOperationsResult<T> {
+    data: T[];
+    facetCounts: FacetCounts;
+    resultCount: number;
+}
 /**
- * Format distance according to DistanceFormat specification
+ * Apply all data operations in the correct order:
+ * 1. Search
+ * 2. Filter
+ * 3. Compute facets (on filtered data)
+ * 4. Sort
  */
-declare const formatDistance: (value: FieldValue, format: DistanceFormat) => FormattedValue;
+declare function applyDataOperations<T>({ data, filters, sort, search, facetConfigs, }: ApplyDataOperationsOptions<T>): ApplyDataOperationsResult<T>;
 
 /**
- * Energy formatting utilities (stored or consumed energy)
- * For power (rate of energy), use power.ts
- * For electrical units (voltage, current), use voltage.ts and current.ts
+ * Boolean formatting utilities
  */
 
 /**
- * Format as Watt-hours
+ * Format boolean value with custom text
  */
-declare const toWh: (value: number | null | undefined, decimals?: number) => string | null;
+declare const toBoolean: (value: boolean | null | undefined, trueText?: string, falseText?: string) => string | null;
 /**
- * Format as kilowatt-hours
+ * Format boolean as enabled/disabled
  */
-declare const tokWh: (value: number | null | undefined, decimals?: number) => string | null;
+declare const toEnabledDisabled: (value: boolean | null | undefined) => string | null;
 /**
- * Format as megawatt-hours
+ * Format boolean as on/off
  */
-declare const toMWh: (value: number | null | undefined, decimals?: number) => string | null;
+declare const toOnOff: (value: boolean | null | undefined) => string | null;
 /**
- * Format as gigawatt-hours
+ * Format boolean as active/inactive
  */
-declare const toGWh: (value: number | null | undefined, decimals?: number) => string | null;
+declare const toActiveInactive: (value: boolean | null | undefined) => string | null;
 /**
- * Pick the display unit auto-scaling would choose for a Wh magnitude.
+ * Format boolean as true/false
  */
-declare const pickEnergyUnit: (whValue: number) => EnergyUnit;
+declare const toTrueFalse: (value: boolean | null | undefined) => string | null;
 /**
- * Auto-scale energy to the most appropriate unit
+ * Format boolean as checkmark/cross
  */
-declare const autoScaleEnergy: (value: number | null | undefined, decimals?: number) => string | null;
+declare const toCheckmark: (value: boolean | null | undefined) => string | null;
 /**
- * Format energy according to EnergyFormat specification
+ * Parse various truthy/falsy values to boolean
  */
+declare const parseBoolean: (value: FieldValue) => boolean | null;
 /**
- * Multiplier from the named energy unit to Wh — the formatter's internal
- * reference unit. Keep in sync with `EnergyUnit`.
+ * Format boolean according to BooleanFormat specification
  */
-declare const SOURCE_UNIT_TO_WH: Record<EnergyUnit, number>;
-declare const formatEnergy: (value: FieldValue, format: EnergyFormat) => FormattedValue;
+declare const formatBoolean: (value: FieldValue, format: BooleanFormat) => FormattedValue;
 
 /**
- * `formatFieldValue` dispatcher — extracted from `./index.ts` into its own
- * leaf module so downstream helpers (notably `csvUnit.ts`) can depend on the
- * dispatcher without pulling the whole formatting barrel (and any of its
- * transitively-imported React/PostHog side-effects) into a test setup.
+ * Capacity formatting utilities for batteries and energy storage
  *
- * `./index.ts` re-exports this module so the public API is unchanged.
+ * Domain-specific formatters for energy capacity (kWh) and power ratings (kW).
+ * Auto-scales to appropriate units (MWh, MW for large values).
  */
-
 /**
- * Main formatting function that routes to the appropriate formatter based on
- * the format type. See `./index.ts` for the fuller doc comment.
+ * Format battery capacity (kWh)
+ *
+ * @param value - Capacity in kWh
+ * @param decimals - Number of decimal places (default: 1)
+ * @returns Formatted capacity string or null
+ *
+ * @example
+ * ```typescript
+ * formatCapacity(13.5); // "13.5 kWh"
+ * formatCapacity(1500); // "1.5 MWh"
+ * formatCapacity(null); // null
+ * ```
  */
-declare const formatFieldValue: (value: FieldValue, format: FieldFormat) => FormattedValue;
-
+declare function formatCapacity(value: number | null | undefined, decimals?: number): string | null;
 /**
- * Number and currency formatting utilities
+ * Format power rating (kW)
+ *
+ * @param value - Power rating in kW
+ * @param decimals - Number of decimal places (default: 1)
+ * @returns Formatted power rating string or null
+ *
+ * @example
+ * ```typescript
+ * formatPowerRating(5.2); // "5.2 kW"
+ * formatPowerRating(2500); // "2.5 MW"
+ * formatPowerRating(null); // null
+ * ```
  */
+declare function formatPowerRating(value: number | null | undefined, decimals?: number): string | null;
 
 /**
- * Check if a value is null or undefined
- */
-declare const isNil: (value: unknown) => value is null | undefined;
-/**
- * Format as percentage
- */
-declare const toPercentage: (value: number | null | undefined, decimals?: number) => string | null;
-/**
- * Format percentage (simple wrapper for consistency with other formatters)
+ * Shared CSV export helpers for unit-bearing FieldFormats.
  *
- * @param value - Numeric value (0-100 range)
- * @param precision - Number of decimal places (default: 0)
- * @returns Formatted percentage string with % symbol
+ * CSV columns need one unit for the whole column, not per-row auto-scaling. The
+ * on-screen display can happily render "12 kV" one row and "500 mV" the next
+ * because a human reads them in context, but in a spreadsheet that mixes
+ * magnitudes in a single column and makes the data unusable.
+ *
+ * These helpers pick a stable column-wide unit for a given FieldFormat and
+ * return the bare number that matches that unit:
+ *
+ *   - `csvUnitFor(format)`   → the unit string to show in the column header,
+ *     or null when the format has no meaningful unit (text, number, date, …).
+ *   - `csvValueFor(raw, format)` → the bare-number string for a cell in that
+ *     column. Returns null for non-numeric formats (caller falls back to the
+ *     regular display formatter), and "" when the display would be blank
+ *     (hideWhenNull / hideWhenZero / null value).
+ *
+ * Consumers:
+ *   - `apps/dashboard/components/Explorer/tables/deviceFieldExport.ts` (Explore CSV)
+ *   - `packages/edges/src/utils/chartExport.ts` (chart CSV export)
  */
-declare const formatPercent: (value: number | null | undefined, precision?: number) => string;
+
 /**
- * Format as integer
+ * Pick the CSV column unit for a FieldFormat.
+ *
+ * Rules:
+ * - Explicit `unit` on the format wins.
+ * - Otherwise fall back to the format's canonical base unit
+ *   (`DEFAULT_BASE_UNIT` lookup) so every row in the column shares one unit
+ *   even if the on-screen display would auto-scale.
+ * - Energy honours `sourceUnit` (e.g. meter consumption is stored in kWh) as
+ *   the natural stable unit when neither `unit` nor a base fallback would fit.
+ * - Temperature symbols are normalised from `"C"`/`"CELSIUS"` etc. to `"°C"`.
+ * - Formats with no meaningful unit (text, number, date, boolean, currency,
+ *   phone, custom) return null.
  */
-declare const toInteger: (value: number | null | undefined) => string | null;
+declare function csvUnitFor(format: FieldFormat | undefined | null): string | null;
 /**
- * Format as float with specified decimals
+ * Convert a raw value to a bare-number CSV string in the same unit
+ * `csvUnitFor` reports.
+ *
+ * Returns:
+ *  - `null` when the format is non-numeric (caller falls back to the display
+ *    formatter, e.g. text/date/enum).
+ *  - `""` when the display would suppress the value (hideWhenNull / hideWhenZero).
+ *  - a bare number string otherwise, with the trailing unit stripped so the
+ *    cell can be summed / charted in the spreadsheet.
  */
-declare const toFloat: (value: number | null | undefined, decimals?: number) => string | null;
+declare function csvValueFor(raw: unknown, format: FieldFormat): string | null;
+
 /**
- * Format number with thousands separator
+ * Electrical current formatting utilities (flow of electric charge)
  */
-declare const toFormattedNumber: (value: number | null | undefined, decimals?: number, thousandsSeparator?: boolean) => string | null;
+
 /**
- * Format number with compact notation (1K, 1M, etc.)
+ * Format as milliamps
  */
-declare const toCompactNumber: (value: number | null | undefined, display?: "short" | "long") => string | null;
+declare const toMilliamps: (value: number | null | undefined, decimals?: number) => string | null;
 /**
- * Format number with scientific notation
+ * Format as amperes
  */
-declare const toScientificNotation: (value: number | null | undefined, decimals?: number) => string | null;
+declare const toAmps: (value: number | null | undefined, decimals?: number) => string | null;
 /**
- * Format as currency
+ * Format as kiloamps (rarely used but included for completeness)
  */
-declare const toCurrency: (value: number | null | undefined, currency?: string, options?: Partial<CurrencyFormat>) => string | null;
+declare const toKiloamps: (value: number | null | undefined, decimals?: number) => string | null;
 /**
- * Format number according to NumberFormat specification
+ * Auto-scale current to the most appropriate unit
  */
-declare const formatNumber: (value: FieldValue, format: NumberFormat) => FormattedValue;
+declare const autoScaleCurrent: (value: number | null | undefined, decimals?: number) => string | null;
 /**
- * Format currency according to CurrencyFormat specification
+ * Format current according to CurrentFormat specification
  */
-declare const formatCurrency: (value: FieldValue, format: CurrencyFormat) => FormattedValue;
+declare const formatCurrent: (value: FieldValue, format: CurrentFormat) => FormattedValue;
+declare const toMA: (value: number | null | undefined, decimals?: number) => string | null;
+declare const toA: (value: number | null | undefined, decimals?: number) => string | null;
+declare const toKA: (value: number | null | undefined, decimals?: number) => string | null;
 
 /**
- * Phone number formatting utilities
+ * Date formatting utilities using Luxon
  */
 
 /**
- * Format US phone number
+ * Format date to a localized string with optional time and timezone.
+ *
+ * @param value - Date value (string, Date object, or timestamp)
+ * @param showTime - Whether to include time in the output (default: false)
+ * @param timezone - Optional timezone for display (e.g., "America/New_York")
+ * @returns Formatted date string or null
+ *
+ * @example
+ * ```typescript
+ * toDateString(new Date()); // "12/25/2023"
+ * toDateString(new Date(), true); // "12/25/2023, 3:30 PM"
+ * toDateString("2023-12-25T15:30:00Z", true, "America/New_York"); // "12/25/2023, 10:30 AM"
+ * ```
  */
-declare const formatUSPhone: (phone: string | null | undefined) => string | null;
+declare const toDateString: (value: string | Date | number | null | undefined, showTime?: boolean, timezone?: string) => string | null;
 /**
- * Format international phone number
+ * Format date to relative time (e.g., "2 hours ago", "in 3 days").
+ * Automatically chooses the most appropriate unit.
+ *
+ * @param value - Date value (string, Date object, or timestamp)
+ * @returns Relative time string or null
+ *
+ * @example
+ * ```typescript
+ * toRelativeTime(new Date(Date.now() - 3600000)); // "1 hour ago"
+ * toRelativeTime(new Date(Date.now() + 86400000)); // "in 1 day"
+ * toRelativeTime(new Date()); // "now"
+ * ```
  */
-declare const formatInternationalPhone: (phone: string | null | undefined) => string | null;
+declare const toRelativeTime: (value: string | Date | number | null | undefined) => string | null;
 /**
- * Format phone number with basic formatting
+ * Format date with full date and time including weekday
  */
-declare const formatPhoneNumber: (phone: string | null | undefined) => string | null;
+declare const toFullDateTime: (value: string | Date | number | null | undefined, timezone?: string) => string | null;
 /**
- * Format phone according to PhoneFormat specification
+ * Format date to ISO string
  */
-declare const formatPhone: (value: FieldValue, format: PhoneFormat) => FormattedValue;
-
+declare const toISOString: (value: string | Date | number | null | undefined) => string | null;
 /**
- * Power formatting utilities (rate of energy transfer)
+ * Format date with custom format string
  */
-
+declare const toCustomDateFormat: (value: string | Date | number | null | undefined, format: string, timezone?: string) => string | null;
 /**
- * Format as Watts
+ * Get formatted date parts
  */
-declare const toWatts: (value: number | null | undefined, decimals?: number) => string | null;
+declare const getDateParts: (value: string | Date | number | null | undefined) => {
+    year: number;
+    month: number;
+    day: number;
+    weekday: number;
+    hour: number;
+    minute: number;
+    second: number;
+    millisecond: number;
+    weekdayShort: string | null;
+    weekdayLong: string | null;
+    monthShort: string | null;
+    monthLong: string | null;
+} | null;
 /**
- * Format as kilowatts
+ * Format date according to DateFormat specification
  */
-declare const toKilowatts: (value: number | null | undefined, decimals?: number) => string | null;
+declare const formatDate: (value: FieldValue, format: DateFormat) => FormattedValue;
+
 /**
- * Format as megawatts
+ * Distance and length formatting utilities
  */
-declare const toMegawatts: (value: number | null | undefined, decimals?: number) => string | null;
+
 /**
- * Format as gigawatts
+ * Format as meters
  */
-declare const toGigawatts: (value: number | null | undefined, decimals?: number) => string | null;
+declare const toMeters: (value: number | null | undefined, decimals?: number) => string | null;
 /**
- * Auto-scale power to the most appropriate unit
+ * Format as centimeters
  */
-declare const autoScalePower: (value: number | null | undefined, decimals?: number) => string | null;
+declare const toCentimeters: (value: number | null | undefined, decimals?: number) => string | null;
 /**
- * Format power according to PowerFormat specification
+ * Format as millimeters
  */
-declare const formatPower: (value: FieldValue, format: PowerFormat) => FormattedValue;
-declare const toW: (value: number | null | undefined, decimals?: number) => string | null;
-declare const toKW: (value: number | null | undefined, decimals?: number) => string | null;
-declare const toMW: (value: number | null | undefined, decimals?: number) => string | null;
-declare const toGW: (value: number | null | undefined, decimals?: number) => string | null;
-
+declare const toMillimeters: (value: number | null | undefined, decimals?: number) => string | null;
 /**
- * FormatRegistry - A singleton pattern for managing formatters
- * Allows registration and retrieval of formatting functions by key
+ * Format as kilometers
  */
-
-declare class FormatRegistryClass {
-    private formatters;
-    /**
-     * Register a new formatter
-     * @param key - Unique identifier for the formatter
-     * @param formatter - The formatting function
-     */
-    register(key: string, formatter: FormatterFunction): void;
-    /**
-     * Format a value using a registered formatter
-     * @param key - The formatter key
-     * @param value - The value to format
-     * @param args - Additional arguments to pass to the formatter
-     * @returns The formatted value or null
-     */
-    format(key: string, value: FieldValue, ...args: unknown[]): FormattedValue;
-    /**
-     * Check if a formatter is registered
-     * @param key - The formatter key
-     * @returns True if the formatter exists
-     */
-    has(key: string): boolean;
-    /**
-     * Get all registered formatter keys
-     * @returns Array of formatter keys
-     */
-    keys(): string[];
-    /**
-     * Remove a formatter
-     * @param key - The formatter key to remove
-     */
-    unregister(key: string): void;
-    /**
-     * Clear all registered formatters
-     */
-    clear(): void;
-}
-declare const FormatRegistry: FormatRegistryClass;
-
+declare const toKilometers: (value: number | null | undefined, decimals?: number) => string | null;
 /**
- * Electrical resistance formatting utilities
+ * Format as feet
  */
-
+declare const toFeet: (value: number | null | undefined, decimals?: number) => string | null;
 /**
- * Format as milliohms
+ * Format as inches
  */
-declare const toMilliohms: (value: number | null | undefined, decimals?: number) => string | null;
+declare const toInches: (value: number | null | undefined, decimals?: number) => string | null;
 /**
- * Format as ohms
+ * Format as miles
  */
-declare const toOhms: (value: number | null | undefined, decimals?: number) => string | null;
+declare const toMiles: (value: number | null | undefined, decimals?: number) => string | null;
 /**
- * Format as kilohms
+ * Format as yards
  */
-declare const toKilohms: (value: number | null | undefined, decimals?: number) => string | null;
+declare const toYards: (value: number | null | undefined, decimals?: number) => string | null;
 /**
- * Format as megohms
+ * Format as nautical miles
  */
-declare const toMegohms: (value: number | null | undefined, decimals?: number) => string | null;
+declare const toNauticalMiles: (value: number | null | undefined, decimals?: number) => string | null;
 /**
- * Auto-scale resistance to the most appropriate unit
+ * Conversion utilities
  */
-declare const autoScaleResistance: (value: number | null | undefined, decimals?: number) => string | null;
+declare const metersToFeet: (meters: number) => number;
+declare const feetToMeters: (feet: number) => number;
+declare const milesToKilometers: (miles: number) => number;
+declare const kilometersToMiles: (km: number) => number;
+declare const feetToMiles: (feet: number) => number;
+declare const milesToFeet: (miles: number) => number;
+declare const metersToMiles: (meters: number) => number;
+declare const milesToMeters: (miles: number) => number;
+declare const yardsToMeters: (yards: number) => number;
+declare const metersToYards: (meters: number) => number;
+declare const inchesToCentimeters: (inches: number) => number;
+declare const centimetersToInches: (cm: number) => number;
 /**
- * Format resistance according to ResistanceFormat specification
+ * Auto-scale distance to the most appropriate unit
  */
-declare const formatResistance: (value: FieldValue, format: ResistanceFormat) => FormattedValue;
-
+declare const autoScaleDistance: (value: number | null | undefined, metric?: boolean, decimals?: number) => string | null;
 /**
- * Temperature formatting utilities
+ * Format distance according to DistanceFormat specification
  */
+declare const formatDistance: (value: FieldValue, format: DistanceFormat) => FormattedValue;
 
 /**
- * Convert temperature unit string to symbol
- */
-declare const temperatureStringToSymbol: (unit: TemperatureUnitString) => TemperatureUnit;
-/**
- * Format as Fahrenheit
+ * Energy formatting utilities (stored or consumed energy)
+ * For power (rate of energy), use power.ts
+ * For electrical units (voltage, current), use voltage.ts and current.ts
  */
-declare const toFahrenheit: (value: number | null | undefined, decimals?: number) => string | null;
+
 /**
- * Format as Celsius
+ * Format as Watt-hours
  */
-declare const toCelsius: (value: number | null | undefined, fromFahrenheit?: boolean, decimals?: number) => string | null;
+declare const toWh: (value: number | null | undefined, decimals?: number) => string | null;
 /**
- * Format as Kelvin
+ * Format as kilowatt-hours
  */
-declare const toKelvin: (value: number | null | undefined, fromFahrenheit?: boolean, decimals?: number) => string | null;
+declare const tokWh: (value: number | null | undefined, decimals?: number) => string | null;
 /**
- * Convert Celsius to Fahrenheit
+ * Format as megawatt-hours
  */
-declare const celsiusToFahrenheit: (celsius: number) => number;
+declare const toMWh: (value: number | null | undefined, decimals?: number) => string | null;
 /**
- * Convert Fahrenheit to Celsius
+ * Format as gigawatt-hours
  */
-declare const fahrenheitToCelsius: (fahrenheit: number) => number;
+declare const toGWh: (value: number | null | undefined, decimals?: number) => string | null;
 /**
- * Convert Celsius to Kelvin
+ * Pick the display unit auto-scaling would choose for a Wh magnitude.
  */
-declare const celsiusToKelvin: (celsius: number) => number;
+declare const pickEnergyUnit: (whValue: number) => EnergyUnit;
 /**
- * Convert Kelvin to Celsius
+ * Auto-scale energy to the most appropriate unit
  */
-declare const kelvinToCelsius: (kelvin: number) => number;
+declare const autoScaleEnergy: (value: number | null | undefined, decimals?: number) => string | null;
 /**
- * Convert Fahrenheit to Kelvin
+ * Format energy according to EnergyFormat specification
  */
-declare const fahrenheitToKelvin: (fahrenheit: number) => number;
 /**
- * Convert Kelvin to Fahrenheit
+ * Multiplier from the named energy unit to Wh — the formatter's internal
+ * reference unit. Keep in sync with `EnergyUnit`.
  */
-declare const kelvinToFahrenheit: (kelvin: number) => number;
+declare const SOURCE_UNIT_TO_WH: Record<EnergyUnit, number>;
+declare const formatEnergy: (value: FieldValue, format: EnergyFormat) => FormattedValue;
+
 /**
- * Format temperature with specified unit
+ * `formatFieldValue` dispatcher — extracted from `./index.ts` into its own
+ * leaf module so downstream helpers (notably `csvUnit.ts`) can depend on the
+ * dispatcher without pulling the whole formatting barrel (and any of its
+ * transitively-imported React/PostHog side-effects) into a test setup.
+ *
+ * `./index.ts` re-exports this module so the public API is unchanged.
  */
-declare const toTemperature: (value: number | null | undefined, unit?: TemperatureUnit | TemperatureUnitString, decimals?: number) => string | null;
+
 /**
- * Format temperature according to TemperatureFormat specification
+ * Main formatting function that routes to the appropriate formatter based on
+ * the format type. See `./index.ts` for the fuller doc comment.
  */
-declare const formatTemperature: (value: FieldValue, format: TemperatureFormat) => FormattedValue;
+declare const formatFieldValue: (value: FieldValue, format: FieldFormat) => FormattedValue;
 
 /**
- * Text formatting utilities
+ * Number and currency formatting utilities
  */
 
 /**
- * Convert text to uppercase
+ * Check if a value is null or undefined
  */
-declare const toUpperCase: (text: string | null | undefined) => string;
+declare const isNil: (value: unknown) => value is null | undefined;
 /**
- * Convert text to lowercase
+ * Format as percentage
  */
-declare const toLowerCase: (text: string | null | undefined) => string;
+declare const toPercentage: (value: number | null | undefined, decimals?: number) => string | null;
 /**
- * Convert text to sentence case (first letter capitalized, rest lowercase).
- *
- * @param text - Text to convert
- * @returns Sentence-cased text
+ * Format percentage (simple wrapper for consistency with other formatters)
  *
- * @example
- * ```typescript
- * toSentenceCase("HELLO WORLD"); // "Hello world"
- * toSentenceCase("hello world"); // "Hello world"
- * ```
+ * @param value - Numeric value (0-100 range)
+ * @param precision - Number of decimal places (default: 0)
+ * @returns Formatted percentage string with % symbol
  */
-declare const toSentenceCase: (text: string | null | undefined) => string;
+declare const formatPercent: (value: number | null | undefined, precision?: number) => string;
 /**
- * Convert text to title case with proper handling of articles and prepositions.
- * Capitalizes the first letter of each word except common articles/prepositions
- * (unless they're the first word).
- *
- * @param text - Text to convert
- * @returns Title-cased text
- *
- * @example
- * ```typescript
- * toTitleCase("the quick brown fox"); // "The Quick Brown Fox"
- * toTitleCase("war and peace"); // "War and Peace"
- * toTitleCase("to be or not to be"); // "To Be or Not to Be"
- * ```
+ * Format as integer
  */
-declare const toTitleCase: (text: string | null | undefined) => string;
+declare const toInteger: (value: number | null | undefined) => string | null;
 /**
- * Capitalize first letter of each word
+ * Format as float with specified decimals
  */
-declare const capitalize: (text: string | null | undefined) => string;
+declare const toFloat: (value: number | null | undefined, decimals?: number) => string | null;
 /**
- * Uppercase first letter only
+ * Format number with thousands separator
  */
-declare const ucFirst: (text: string | null | undefined) => string;
+declare const toFormattedNumber: (value: number | null | undefined, decimals?: number, thousandsSeparator?: boolean) => string | null;
 /**
- * Convert camelCase to words
+ * Format number with compact notation (1K, 1M, etc.)
  */
-declare const camelCaseToWords: (text: string | null | undefined) => string;
+declare const toCompactNumber: (value: number | null | undefined, display?: "short" | "long") => string | null;
 /**
- * Convert snake_case to words
+ * Format number with scientific notation
  */
-declare const snakeCaseToWords: (text: string | null | undefined) => string;
+declare const toScientificNotation: (value: number | null | undefined, decimals?: number) => string | null;
 /**
- * Convert enum-style text to sentence case
+ * Format as currency
  */
-declare const enumToSentenceCase: (text: string | null | undefined) => string;
+declare const toCurrency: (value: number | null | undefined, currency?: string, options?: Partial<CurrencyFormat>) => string | null;
 /**
- * Truncate text in the middle
+ * Format number according to NumberFormat specification
  */
-declare const truncateMiddle: (value: string | null | undefined, length?: number) => string;
+declare const formatNumber: (value: FieldValue, format: NumberFormat) => FormattedValue;
 /**
- * Truncate text at the start
- */
-declare const truncateStart: (value: string | null | undefined, length?: number) => string;
-/**
- * Truncate text at the end
- */
-declare const truncateEnd: (value: string | null | undefined, length?: number, ellipsis?: string) => string;
-/**
- * Mask sensitive text (e.g., secrets, API keys)
- */
-declare const toSecret: (value: string | null | undefined) => string;
-/**
- * Format text according to TextFormat specification
- */
-declare const formatText: (value: FieldValue, format: TextFormat) => FormattedValue;
-
-/**
- * Voltage formatting utilities (electrical potential)
- */
-
-/**
- * Format as millivolts
- */
-declare const toMillivolts: (value: number | null | undefined, decimals?: number) => string | null;
-/**
- * Format as volts
- */
-declare const toVolts: (value: number | null | undefined, decimals?: number) => string | null;
-/**
- * Format as kilovolts
- */
-declare const toKilovolts: (value: number | null | undefined, decimals?: number) => string | null;
-/**
- * Auto-scale voltage to the most appropriate unit
- */
-declare const autoScaleVoltage: (value: number | null | undefined, decimals?: number) => string | null;
-/**
- * Format voltage according to VoltageFormat specification
- */
-declare const formatVoltage: (value: FieldValue, format: VoltageFormat) => FormattedValue;
-declare const toMV: (value: number | null | undefined, decimals?: number) => string | null;
-declare const toV: (value: number | null | undefined, decimals?: number) => string | null;
-declare const toKV: (value: number | null | undefined, decimals?: number) => string | null;
-
-/**
- * Comprehensive formatting utilities for the Edges design system
- *
- * This module provides a unified formatting system with support for:
- * - Text formatting (case conversion, truncation, etc.)
- * - Number formatting (decimals, thousands separators, compact notation)
- * - Currency formatting (multiple currencies and display options)
- * - Date formatting (relative time, custom formats, timezones)
- * - Boolean formatting (custom true/false text)
- * - Energy units (Wh, kWh, MWh, GWh with auto-scaling)
- * - Temperature units (Celsius, Fahrenheit, Kelvin)
- * - Distance units (meters, kilometers, miles, feet)
- * - Phone number formatting (US and international)
- * - Custom formatters via the FormatRegistry
- */
-
-/**
- * Convenience function to create a format object
- *
- * @example
- * ```typescript
- * const currencyFormat = createFormat("currency", { currency: "EUR" });
- * const dateFormat = createFormat("date", { relative: true });
- * ```
- */
-declare const createFormat: <T extends FieldFormat["type"]>(type: T, options?: Omit<Extract<FieldFormat, {
-    type: T;
-}>, "type">) => Extract<FieldFormat, {
-    type: T;
-}>;
-
-/**
- * Chart export utilities for CSV, SVG, and PNG formats
- * Provides comprehensive export functionality for chart visualizations
+ * Format currency according to CurrencyFormat specification
  */
+declare const formatCurrency: (value: FieldValue, format: CurrencyFormat) => FormattedValue;
 
-type ExportType = "csv" | "svg" | "png";
-interface ChartExportMetadata {
-    xLabel?: string;
-    yLabel?: string;
-    seriesLabels?: string[];
-    filename?: string;
-    timestamp?: boolean;
-    /**
-     * Optional FieldFormat for the y-axis. When present, the CSV export:
-     *   - suffixes every series header with the format's stable column unit
-     *     (e.g. "Consumption (kWh)", "Voltage (V)"), and
-     *   - writes bare numbers in that unit into the cells (no per-row auto-scale).
-     *
-     * This keeps chart CSVs consistent with the Explore table CSV (BOLT-1431):
-     * unit in the header, bare numbers in the cells.
-     */
-    yFormat?: FieldFormat;
-}
-/**
- * Main export function that handles all chart export types.
- * Supports CSV, SVG, and PNG formats with automatic filename generation.
- *
- * @param type - Export format: "csv", "svg", or "png"
- * @param datasets - Chart data as single array or array of arrays for multi-series
- * @param metadata - Export metadata including labels and filename options
- * @param svgRef - Reference to the chart's SVG element
- * @returns Promise that resolves when export is complete
- *
- * @example
- * ```typescript
- * // Export single series as CSV
- * await exportChart("csv", data, {
- *   xLabel: "Date",
- *   yLabel: "Value",
- *   filename: "sales-data"
- * }, svgRef);
- *
- * // Export multi-series chart as PNG
- * await exportChart("png", [series1, series2], {
- *   seriesLabels: ["Revenue", "Profit"],
- *   timestamp: false
- * }, svgRef);
- * ```
- */
-declare function exportChart(type: ExportType, datasets: BaseDataPoint[][] | BaseDataPoint[], metadata: ChartExportMetadata | undefined, svgRef: React__default.RefObject<SVGSVGElement | null>): Promise<void>;
-/**
- * Utility to check if export is supported in the current environment
- */
-declare function isExportSupported(type: ExportType): boolean;
 /**
- * Get human-readable export format name
+ * Phone number formatting utilities
  */
-declare function getExportFormatName(type: ExportType): string;
 
 /**
- * Data Controls Types
- *
- * Core type definitions for client-side and server-side data filtering,
- * sorting, faceting, and search operations.
- */
-type FilterOperator = "eq" | "neq" | "in" | "nin" | "gt" | "gte" | "lt" | "lte" | "contains" | "startsWith" | "endsWith";
-interface FilterCondition {
-    /** Field name (supports nested paths like 'user.profile.name') */
-    field: string;
-    /** Comparison operator */
-    operator: FilterOperator;
-    /** Value to compare against */
-    value: string | number | boolean | (string | number)[];
-}
-interface FilterGroup {
-    /** Logical operator combining conditions */
-    logic: "AND" | "OR";
-    /** Conditions or nested filter groups */
-    conditions: (FilterCondition | FilterGroup)[];
-}
-/** Root filter state - can be empty, a single group, or nested groups */
-type FilterState = FilterGroup | null;
-interface SortState {
-    /** Field to sort by (supports nested paths) */
-    field: string;
-    /** Sort direction */
-    direction: "asc" | "desc";
-}
-interface SearchConfig {
-    /** Search query string */
-    query: string;
-    /** Fields to search across */
-    fields: string[];
-    /** Use fuzzy matching (Fuse.js) - default true */
-    fuzzy?: boolean;
-    /** Fuse.js matching threshold (0.0 = perfect, 1.0 = anything) - default 0.3 */
-    threshold?: number;
-}
-type FacetType = "string" | "number" | "boolean" | "date";
-interface FacetConfig {
-    /** Field name to facet on */
-    field: string;
-    /** Display label for the facet */
-    label: string;
-    /** Data type of the field */
-    type?: FacetType;
-    /** Optional: Provide predefined values for the facet (useful for enums) */
-    values?: Array<{
-        value: string | number;
-        label: string;
-    }>;
-    /** Number of options to show before requiring search (default: 10) */
-    searchThreshold?: number;
-    /** Max options to show initially, with "Show all" button for rest (default: 50) */
-    maxVisibleOptions?: number;
-    /** Optional description text to show below the label */
-    description?: string;
-    /** Optional: Custom render function for option labels (e.g., to show Badges) */
-    renderLabel?: (value: string, label: string) => React.ReactNode;
-    /** Optional: Group name for organizing filters in FilterDialog */
-    group?: string;
-}
-interface FacetCounts {
-    [field: string]: {
-        [value: string]: number;
-    };
-}
-/**
- * Create a single filter condition
- */
-declare function createFilter(field: string, operator: FilterOperator, value: string | number | boolean | (string | number)[]): FilterCondition;
-/**
- * Create a filter group from multiple conditions with AND logic
- */
-declare function createFilters(conditions: FilterCondition[], logic?: "AND" | "OR"): FilterGroup;
-/**
- * Create an empty filter state
- */
-declare function createEmptyFilter(): FilterGroup;
-/**
- * Check if a filter state is empty (no conditions)
- */
-declare function isFilterEmpty(filter: FilterState): boolean;
-/**
- * Convert structured filter state to simple display chips
- * Used for backward compatibility with existing FilterChips component
- */
-interface FilterChip {
-    id: string;
-    label: string;
-    value: string;
-}
-declare function filterToChips(filter: FilterState, facetConfigs?: FacetConfig[]): FilterChip[];
-/**
- * Add a condition to a filter state
+ * Format US phone number
  */
-declare function addFilterCondition(filter: FilterState, condition: FilterCondition): FilterGroup;
+declare const formatUSPhone: (phone: string | null | undefined) => string | null;
 /**
- * Remove a condition from a filter state by field
+ * Format international phone number
  */
-declare function removeFilterCondition(filter: FilterState, field: string): FilterGroup;
+declare const formatInternationalPhone: (phone: string | null | undefined) => string | null;
 /**
- * Get all unique fields being filtered on
+ * Format phone number with basic formatting
  */
-declare function getFilterFields(filter: FilterState): string[];
-
-interface UseClientDataControlsOptions<T> {
-    /** Raw data to process */
-    data: T[];
-    /** Filter state */
-    filters?: FilterState;
-    /** Sort state */
-    sort?: SortState | null;
-    /** Search configuration */
-    search?: SearchConfig | null;
-    /** Facet configurations */
-    facetConfigs?: FacetConfig[];
-}
-interface UseClientDataControlsResult<T> {
-    /** Processed data (filtered, sorted, searched) */
-    data: T[];
-    /** Facet counts computed from filtered data */
-    facetCounts: FacetCounts;
-    /** Number of results after filtering/searching */
-    resultCount: number;
-}
+declare const formatPhoneNumber: (phone: string | null | undefined) => string | null;
 /**
- * useClientDataControls
- *
- * Client-side hook for filtering, sorting, searching, and faceting data.
- * Uses memoization to avoid unnecessary recomputation.
- *
- * Operations are applied in this order:
- * 1. Search (fuzzy or exact matching)
- * 2. Filter (structured conditions)
- * 3. Facet computation (on filtered data)
- * 4. Sort
- *
- * @example
- * ```tsx
- * const { data, facetCounts, resultCount } = useClientDataControls({
- *   data: rawData,
- *   filters: createFilters([
- *     createFilter('department', 'in', ['Engineering', 'Sales'])
- *   ]),
- *   sort: { field: 'name', direction: 'asc' },
- *   search: { query: searchQuery, fields: ['name', 'email'] },
- *   facetConfigs: [
- *     { field: 'department', label: 'Department' },
- *     { field: 'status', label: 'Status' }
- *   ]
- * });
- * ```
+ * Format phone according to PhoneFormat specification
  */
-declare function useClientDataControls<T>({ data, filters, sort, search, facetConfigs, }: UseClientDataControlsOptions<T>): UseClientDataControlsResult<T>;
+declare const formatPhone: (value: FieldValue, format: PhoneFormat) => FormattedValue;
 
-interface ServerDataState {
-    filters: FilterState;
-    sort: SortState | null;
-    search: SearchConfig | null;
-}
-interface UseServerDataControlsOptions {
-    /** Filter state */
-    filters: FilterState;
-    /** Sort state */
-    sort: SortState | null;
-    /** Search configuration */
-    search: SearchConfig | null;
-    /** Callback when state changes (debounced for search) */
-    onStateChange: (state: ServerDataState) => void;
-    /** Search debounce delay in ms (default: 300) */
-    searchDebounce?: number;
-}
 /**
- * useServerDataControls
- *
- * Server-side hook that notifies the parent when filter/sort/search state changes.
- * Search queries are debounced to avoid excessive API calls.
- *
- * This hook doesn't manipulate data - it just provides a clean way to:
- * 1. Debounce search input
- * 2. Notify when any state changes
- * 3. Trigger server refetch
- *
- * @example
- * ```tsx
- * const [filters, setFilters] = useState(null);
- * const [sort, setSort] = useState({ field: 'name', direction: 'asc' });
- * const [search, setSearch] = useState({ query: '', fields: ['name'] });
- *
- * useServerDataControls({
- *   filters,
- *   sort,
- *   search,
- *   onStateChange: (state) => {
- *     // Refetch data with new parameters
- *     refetch({
- *       filters: state.filters,
- *       sort: state.sort,
- *       search: state.search?.query
- *     });
- *   }
- * });
- * ```
+ * Power formatting utilities (rate of energy transfer)
  */
-declare function useServerDataControls({ filters, sort, search, onStateChange, searchDebounce, }: UseServerDataControlsOptions): void;
 
-interface UseDataControlsClientOptions<T> {
-    mode: "client";
-    /** Raw data to process (required in client mode) */
-    data: T[];
-    /** Filter state */
-    filters?: FilterState;
-    /** Sort state */
-    sort?: SortState | null;
-    /** Search configuration */
-    search?: SearchConfig | null;
-    /** Facet configurations */
-    facetConfigs?: FacetConfig[];
-}
-interface UseDataControlsServerOptions<T> {
-    mode: "server";
-    /** Data from server (already filtered/sorted) */
-    data: T[];
-    /** Filter state */
-    filters: FilterState;
-    /** Sort state */
-    sort: SortState | null;
-    /** Search configuration */
-    search: SearchConfig | null;
-    /** Callback when state changes (required in server mode) */
-    onStateChange: (state: ServerDataState) => void;
-    /** Search debounce delay in ms (default: 300) */
-    searchDebounce?: number;
-    /** Result count from server */
-    resultCount?: number;
-    /** Facet counts from server */
-    facetCounts?: FacetCounts;
-}
-type UseDataControlsOptions<T> = UseDataControlsClientOptions<T> | UseDataControlsServerOptions<T>;
-interface UseDataControlsResult<T> {
-    /** Processed data (client mode) or server data (server mode) */
-    data: T[];
-    /** Facet counts (computed in client mode, passed through in server mode) */
-    facetCounts: FacetCounts;
-    /** Result count (computed in client mode, passed through in server mode) */
-    resultCount: number;
-}
 /**
- * useDataControls
- *
- * Unified hook for managing data filtering, sorting, searching, and faceting.
- * Supports both client-side and server-side modes.
- *
- * **Client Mode:**
- * - Processes data locally using pure functions
- * - Computes facet counts automatically
- * - Best for datasets < 5000 rows
- *
- * **Server Mode:**
- * - Notifies parent when state changes (debounced for search)
- * - Passes through server-provided data and counts
- * - Best for large datasets or complex queries
- *
- * @example Client Mode
- * ```tsx
- * const { data, facetCounts, resultCount } = useDataControls({
- *   mode: 'client',
- *   data: rawData,
- *   filters: createFilters([...]),
- *   sort: { field: 'name', direction: 'asc' },
- *   search: { query: searchQuery, fields: ['name', 'email'] },
- *   facetConfigs: [{ field: 'department', label: 'Department' }]
- * });
- * ```
- *
- * @example Server Mode
- * ```tsx
- * const { data, facetCounts, resultCount } = useDataControls({
- *   mode: 'server',
- *   data: serverData, // Already filtered
- *   filters,
- *   sort,
- *   search,
- *   resultCount: totalCount,
- *   facetCounts: serverFacets,
- *   onStateChange: (state) => refetch(state)
- * });
- * ```
+ * Format as Watts
  */
-declare function useDataControls<T>(options: UseDataControlsOptions<T>): UseDataControlsResult<T>;
-
-declare function useDebounce<T>(value: T, delay?: number): T;
-
-interface ElementSize {
-    width: number;
-    height: number;
-}
-interface UseElementSizeResult<T extends HTMLElement = HTMLElement> {
-    ref: (node: T | null) => void;
-    width: number;
-    height: number;
-}
+declare const toWatts: (value: number | null | undefined, decimals?: number) => string | null;
 /**
- * useElementSize
- *
- * A performant hook that tracks the dimensions of a DOM element using ResizeObserver.
- * Returns a callback ref to attach to the element and its current width/height.
- *
- * Performance optimizations:
- * - Uses ResizeObserver for efficient resize detection
- * - Debounces updates using requestAnimationFrame
- * - Cleans up observer on unmount
- *
- * @example
- * ```tsx
- * const { ref, width, height } = useElementSize();
- *
- * return (
- *   <div ref={ref}>
- *     Width: {width}px, Height: {height}px
- *   </div>
- * );
- * ```
+ * Format as kilowatts
  */
-declare function useElementSize<T extends HTMLElement = HTMLElement>(): UseElementSizeResult<T>;
-
-type LoadingState = "idle" | "loading" | "loading-more" | "error";
-interface UseInfiniteScrollOptions<T = unknown> {
-    /** Array of items being displayed */
-    items: T[];
-    /** Callback to load more items (optional - if not provided, no infinite scroll) */
-    onLoadMore?: () => void | Promise<void>;
-    /** Whether there are more items to load */
-    hasMore?: boolean;
-    /** Auto-detects initial vs loading-more from items.length */
-    isLoading?: boolean;
-    /** Explicit loading state override (takes precedence) */
-    loadingState?: LoadingState;
-    /** Enable virtualization (default: true for 100+ items) */
-    enableVirtualization?: boolean;
-    /** Estimated size of each item in pixels */
-    estimatedItemSize?: number;
-    /** Number of items to render outside viewport */
-    overscan?: number;
-    /** Custom scroll element (defaults to parent) */
-    scrollElement?: HTMLElement | null;
-    /** Distance from bottom in pixels to trigger load */
-    loadMoreThreshold?: number;
-}
-interface UseInfiniteScrollReturn {
-    virtualizer: Virtualizer<HTMLElement, Element> | null;
-    virtualItems: ReturnType<Virtualizer<HTMLElement, Element>["getVirtualItems"]>;
-    computedLoadingState: LoadingState;
-    isInitialLoad: boolean;
-    isLoadingMore: boolean;
-    scrollRef: RefObject<HTMLDivElement | null>;
-    loadMoreRef: RefObject<HTMLDivElement | null>;
-    scrollToIndex: (index: number, options?: {
-        align?: "start" | "center" | "end";
-    }) => void;
-    scrollToTop: () => void;
-}
-/**
- * useInfiniteScroll
- *
- * Hook for implementing infinite scroll with optional virtualization.
- * Intelligently detects initial vs loading-more states from context.
- *
- * Features:
- * - Smart loading state detection (initial vs loading-more)
- * - Optional explicit state control
- * - TanStack Virtual integration for performance
- * - Intersection Observer for load triggering
- * - Configurable virtualization threshold
- *
- * @example
- * ```tsx
- * const { scrollRef, computedLoadingState, isLoadingMore } = useInfiniteScroll({
- *   items,
- *   onLoadMore: fetchNextPage,
- *   hasMore: hasNextPage,
- *   isLoading: isFetching,
- * });
- * ```
+declare const toKilowatts: (value: number | null | undefined, decimals?: number) => string | null;
+/**
+ * Format as megawatts
  */
-declare function useInfiniteScroll<T = unknown>({ items, onLoadMore, hasMore, isLoading, loadingState, enableVirtualization, estimatedItemSize, overscan, scrollElement, loadMoreThreshold, }: UseInfiniteScrollOptions<T>): UseInfiniteScrollReturn;
-
+declare const toMegawatts: (value: number | null | undefined, decimals?: number) => string | null;
 /**
- * Hook for managing localStorage values with React state synchronization
- * @param key - The localStorage key
- * @param initialValue - The initial value if nothing is stored
- * @returns [value, setValue, removeValue] - Current value, setter function, and remove function
+ * Format as gigawatts
  */
-declare function useLocalStorage<T>(key: string, initialValue: T): [T, (value: T | ((val: T) => T)) => void, () => void];
+declare const toGigawatts: (value: number | null | undefined, decimals?: number) => string | null;
+/**
+ * Auto-scale power to the most appropriate unit
+ */
+declare const autoScalePower: (value: number | null | undefined, decimals?: number) => string | null;
+/**
+ * Format power according to PowerFormat specification
+ */
+declare const formatPower: (value: FieldValue, format: PowerFormat) => FormattedValue;
+declare const toW: (value: number | null | undefined, decimals?: number) => string | null;
+declare const toKW: (value: number | null | undefined, decimals?: number) => string | null;
+declare const toMW: (value: number | null | undefined, decimals?: number) => string | null;
+declare const toGW: (value: number | null | undefined, decimals?: number) => string | null;
 
 /**
- * Hook to check if a media query matches the current viewport
- *
- * @param query - A CSS media query string (e.g., "(min-width: 768px)")
- * @param defaultValue - The default value to return during SSR or before the first render
- * @returns A boolean indicating whether the media query matches
- *
- * @example
- * ```tsx
- * const isMobile = useMediaQuery('(max-width: 767px)');
- * const prefersReducedMotion = useMediaQuery('(prefers-reduced-motion: reduce)');
- * const isLandscape = useMediaQuery('(orientation: landscape)');
- * ```
+ * FormatRegistry - A singleton pattern for managing formatters
+ * Allows registration and retrieval of formatting functions by key
  */
-declare function useMediaQuery(query: string, defaultValue?: boolean): boolean;
 
-type SortDirection = "asc" | "desc";
-type CellAlignment = "left" | "center" | "right";
-type TableDensity = "compact" | "default" | "relaxed";
-type CellEmphasis = "strong" | "high" | "normal" | "low";
-type LinkBehavior = "none" | "hover" | "visible";
-type TableLayout = "auto" | "fixed" | "responsive";
-type TableWidth = "full" | "auto" | "contained";
-type MobileRenderer = "auto" | "cards" | "custom" | "none";
-type MobileBreakpoint = "sm" | "md" | "lg" | "xl";
-interface SortConfig {
-    columnId: string;
-    direction: SortDirection;
-}
-interface CellContext {
-    isLoading: boolean;
-    isSelected?: boolean;
-    isHovered?: boolean;
-    rowIndex: number;
-    columnIndex: number;
-    density: TableDensity;
-}
-interface CellComponentProps<T = any> {
-    value: any;
-    row: T;
-    context: CellContext;
-    [key: string]: any;
-}
-type CellComponent<T = any> = ComponentType<CellComponentProps<T>>;
-interface MobileConfig {
-    priority?: 1 | 2 | 3;
-    format?: "primary" | "secondary" | "badge" | "inline";
-    label?: boolean;
-    icon?: string;
-}
-interface Column<T> {
-    id: string;
-    label: string;
-    accessor?: keyof T | ((row: T) => any);
-    align?: CellAlignment;
-    width?: string | number;
-    minWidth?: string | number;
-    maxWidth?: string | number;
-    flex?: number;
-    cell?: CellComponent<T>;
-    cellProps?: Record<string, any> | ((value: any, row: T) => Record<string, any>);
-    render?: (value: any, row: T, context: CellContext) => ReactNode;
-    sortable?: boolean;
+declare class FormatRegistryClass {
+    private formatters;
     /**
-     * Whether this column can be reordered via drag-and-drop.
-     * Defaults to true. Set to false to lock a column in place (e.g., sticky first column).
+     * Register a new formatter
+     * @param key - Unique identifier for the formatter
+     * @param formatter - The formatting function
      */
-    reorderable?: boolean;
-    noCellPadding?: boolean;
-    mobile?: MobileConfig | false;
-    popover?: string | ((value: unknown, row: T) => ReactNode) | {
-        content: string | ((value: unknown, row: T) => ReactNode);
-        placement?: "top" | "bottom" | "left" | "right";
-        showArrow?: boolean;
-        trigger?: "hover" | "click";
-    };
-    /** Label to use for this column in CSV export headers. Falls back to `label` if not provided. */
-    exportLabel?: string;
+    register(key: string, formatter: FormatterFunction): void;
     /**
-     * Custom function to transform the cell value for export.
-     * If not provided, uses the raw accessor value converted to string.
-     * @param value - The raw cell value from the accessor
-     * @param row - The full row data
-     * @returns The value to export (will be converted to string)
+     * Format a value using a registered formatter
+     * @param key - The formatter key
+     * @param value - The value to format
+     * @param args - Additional arguments to pass to the formatter
+     * @returns The formatted value or null
      */
-    exportValue?: (value: unknown, row: T) => string | number | boolean | null;
+    format(key: string, value: FieldValue, ...args: unknown[]): FormattedValue;
     /**
-     * Whether to include this column in CSV exports.
-     * Defaults to true. Set to false to exclude columns like action buttons.
+     * Check if a formatter is registered
+     * @param key - The formatter key
+     * @returns True if the formatter exists
      */
-    exportable?: boolean;
-}
-interface DataTableProps<T> {
-    columns: Column<T>[];
-    data: T[];
-    className?: string;
-    density?: TableDensity;
-    width?: TableWidth;
-    height?: string | number;
-    maxHeight?: string | number;
-    layout?: TableLayout;
-    mobileRenderer?: MobileRenderer;
-    customMobileRowRender?: (row: T, index: number) => ReactNode;
-    mobileBreakpoint?: MobileBreakpoint;
-    isLoading?: boolean;
-    loadingState?: LoadingState;
-    loadingRowCount?: number;
-    onLoadMore?: () => void | Promise<void>;
-    hasMore?: boolean;
-    enableVirtualization?: boolean;
-    estimatedRowHeight?: number;
-    loadingIndicator?: ReactNode;
-    stickyHeader?: boolean;
-    /** Make the first column sticky on horizontal scroll */
-    stickyFirstColumn?: boolean;
-    onRowClick?: (row: T) => void;
-    getRowId?: (row: T) => string;
-    hideHeader?: boolean;
-    /** Controlled sort configuration - when provided, DataTable becomes controlled */
-    sortConfig?: SortConfig | null;
-    onSort?: (sortConfig: SortConfig | null) => void;
-    "aria-label"?: string;
+    has(key: string): boolean;
     /**
-     * Enable drag-and-drop column reordering (like Notion tables).
-     * When enabled, users can drag column headers to reorder columns.
+     * Get all registered formatter keys
+     * @returns Array of formatter keys
      */
-    enableColumnReorder?: boolean;
+    keys(): string[];
     /**
-     * Controlled column order - array of column IDs in display order.
-     * When provided, DataTable uses this order instead of the columns array order.
-     * Use with onColumnOrderChange for controlled behavior.
+     * Remove a formatter
+     * @param key - The formatter key to remove
      */
-    columnOrder?: string[];
+    unregister(key: string): void;
     /**
-     * Callback fired when column order changes via drag-and-drop.
-     * Receives the new array of column IDs in their new order.
+     * Clear all registered formatters
      */
-    onColumnOrderChange?: (columnOrder: string[]) => void;
+    clear(): void;
 }
+declare const FormatRegistry: FormatRegistryClass;
+
+/**
+ * Electrical resistance formatting utilities
+ */
+
+/**
+ * Format as milliohms
+ */
+declare const toMilliohms: (value: number | null | undefined, decimals?: number) => string | null;
+/**
+ * Format as ohms
+ */
+declare const toOhms: (value: number | null | undefined, decimals?: number) => string | null;
+/**
+ * Format as kilohms
+ */
+declare const toKilohms: (value: number | null | undefined, decimals?: number) => string | null;
+/**
+ * Format as megohms
+ */
+declare const toMegohms: (value: number | null | undefined, decimals?: number) => string | null;
+/**
+ * Auto-scale resistance to the most appropriate unit
+ */
+declare const autoScaleResistance: (value: number | null | undefined, decimals?: number) => string | null;
+/**
+ * Format resistance according to ResistanceFormat specification
+ */
+declare const formatResistance: (value: FieldValue, format: ResistanceFormat) => FormattedValue;
+
+/**
+ * Temperature formatting utilities
+ */
+
+/**
+ * Convert temperature unit string to symbol
+ */
+declare const temperatureStringToSymbol: (unit: TemperatureUnitString) => TemperatureUnit;
+/**
+ * Format as Fahrenheit
+ */
+declare const toFahrenheit: (value: number | null | undefined, decimals?: number) => string | null;
+/**
+ * Format as Celsius
+ */
+declare const toCelsius: (value: number | null | undefined, fromFahrenheit?: boolean, decimals?: number) => string | null;
+/**
+ * Format as Kelvin
+ */
+declare const toKelvin: (value: number | null | undefined, fromFahrenheit?: boolean, decimals?: number) => string | null;
+/**
+ * Convert Celsius to Fahrenheit
+ */
+declare const celsiusToFahrenheit: (celsius: number) => number;
+/**
+ * Convert Fahrenheit to Celsius
+ */
+declare const fahrenheitToCelsius: (fahrenheit: number) => number;
+/**
+ * Convert Celsius to Kelvin
+ */
+declare const celsiusToKelvin: (celsius: number) => number;
+/**
+ * Convert Kelvin to Celsius
+ */
+declare const kelvinToCelsius: (kelvin: number) => number;
+/**
+ * Convert Fahrenheit to Kelvin
+ */
+declare const fahrenheitToKelvin: (fahrenheit: number) => number;
+/**
+ * Convert Kelvin to Fahrenheit
+ */
+declare const kelvinToFahrenheit: (kelvin: number) => number;
+/**
+ * Format temperature with specified unit
+ */
+declare const toTemperature: (value: number | null | undefined, unit?: TemperatureUnit | TemperatureUnitString, decimals?: number) => string | null;
+/**
+ * Format temperature according to TemperatureFormat specification
+ */
+declare const formatTemperature: (value: FieldValue, format: TemperatureFormat) => FormattedValue;
 
 /**
- * Table export utilities for CSV format
- * Provides export functionality for DataTable data
+ * Text formatting utilities
  */
 
-interface TableExportMetadata {
-    /** Base filename for the exported file (without extension) */
-    filename?: string;
-    /** Whether to include timestamp in filename. Defaults to true */
-    timestamp?: boolean;
-}
-interface TableExportOptions<T> {
-    /** Column definitions for the table */
-    columns: Column<T>[];
-    /** Data rows to export */
-    data: T[];
-    /** Export metadata */
-    metadata?: TableExportMetadata;
-}
 /**
- * Export table data as CSV
+ * Convert text to uppercase
+ */
+declare const toUpperCase: (text: string | null | undefined) => string;
+/**
+ * Convert text to lowercase
+ */
+declare const toLowerCase: (text: string | null | undefined) => string;
+/**
+ * Convert text to sentence case (first letter capitalized, rest lowercase).
  *
- * @param options - Export configuration
- * @returns Promise that resolves when export is complete
+ * @param text - Text to convert
+ * @returns Sentence-cased text
  *
  * @example
  * ```typescript
- * await exportTableAsCSV({
- *   columns: tableColumns,
- *   data: tableData,
- *   metadata: {
- *     filename: "devices-export",
- *     timestamp: true
- *   }
- * });
+ * toSentenceCase("HELLO WORLD"); // "Hello world"
+ * toSentenceCase("hello world"); // "Hello world"
  * ```
  */
-declare function exportTableAsCSV<T>(options: TableExportOptions<T>): Promise<void>;
+declare const toSentenceCase: (text: string | null | undefined) => string;
 /**
- * Prepare table data for export (without triggering download)
- * Useful for server-side export where you need the transformed data
+ * Convert text to title case with proper handling of articles and prepositions.
+ * Capitalizes the first letter of each word except common articles/prepositions
+ * (unless they're the first word).
  *
- * @param options - Export configuration
- * @returns Array of row objects ready for CSV generation
+ * @param text - Text to convert
+ * @returns Title-cased text
+ *
+ * @example
+ * ```typescript
+ * toTitleCase("the quick brown fox"); // "The Quick Brown Fox"
+ * toTitleCase("war and peace"); // "War and Peace"
+ * toTitleCase("to be or not to be"); // "To Be or Not to Be"
+ * ```
  */
-declare function prepareTableDataForExport<T>(options: Omit<TableExportOptions<T>, "metadata">): Record<string, string | number | boolean>[];
+declare const toTitleCase: (text: string | null | undefined) => string;
 /**
- * Get column headers for export
- * Useful for generating CSV headers on the server
+ * Capitalize first letter of each word
  */
-declare function getExportHeaders<T>(columns: Column<T>[]): string[];
-
-interface UseTableExportOptions<T> {
-    /** Column definitions for the table */
-    columns: Column<T>[];
-    /** Data rows to export */
-    data: T[];
-    /** Export metadata */
-    metadata?: TableExportMetadata;
-}
-interface UseTableExportReturn {
-    /** Trigger CSV export of the table data */
-    exportCSV: () => Promise<void>;
-    /** Whether export is available (has data and exportable columns) */
-    canExport: boolean;
-}
+declare const capitalize: (text: string | null | undefined) => string;
 /**
- * Hook for exporting DataTable data as CSV.
- * Provides a stable callback for triggering exports with memoized dependencies.
- *
- * For client-side DataTables where all data is in the browser.
- * For server-side exports, use the `onExport` callback pattern instead.
- *
- * @param options - Configuration for table export
- * @returns Object with export function and status
- *
- * @example
- * ```tsx
- * const { exportCSV, canExport } = useTableExport({
- *   columns: deviceColumns,
- *   data: devices,
- *   metadata: {
- *     filename: "devices",
- *     timestamp: true
- *   }
- * });
- *
- * // In your DataControls actions
- * <DataControls
- *   actions={{
- *     items: [
- *       {
- *         id: "export",
- *         label: "Export CSV",
- *         icon: "Export",
- *         onClick: exportCSV,
- *         disabled: !canExport
- *       }
- *     ]
- *   }}
- * />
- * ```
+ * Uppercase first letter only
  */
-declare function useTableExport<T>({ columns, data, metadata }: UseTableExportOptions<T>): UseTableExportReturn;
-
-/** The camera: the visible time window, absolute epoch ms. */
-type Viewport = {
-    startMs: number;
-    endMs: number;
-};
-/** One rung of the resolution ladder. */
-type Tier = {
-    id: string;
-    bucketMs: number;
-    tileSpanMs: number;
-};
-type ResolutionLadder = Tier[];
-/** A fixed-grid data slice: tile `index` at `tierId`, covering [startMs, endMs). */
-type TileRef = {
-    tierId: string;
-    index: number;
-    startMs: number;
-    endMs: number;
-};
-/** Data a tile carries. `band` optional → engine is metric-agnostic. */
-type TileData = {
-    line: BaseDataPoint[];
-    band?: BaseDataPoint[];
-};
-/** Injected loader: one tile = one bounded fetch. */
-type FetchTile = (tier: Tier, startMs: number, endMs: number, signal: AbortSignal) => Promise<TileData>;
-declare const tileKey: (tierId: string, index: number) => string;
-
-type TileStatus = "loading" | "loaded" | "empty" | "error";
-type TileEntry = {
-    status: TileStatus;
-    data?: TileData;
-    error?: Error;
-};
-type TileStore = ReadonlyMap<string, TileEntry>;
-type TileAction = {
-    type: "request";
-    ids: string[];
-} | {
-    type: "fulfilled";
-    id: string;
-    data: TileData;
-} | {
-    type: "failed";
-    id: string;
-    error: Error;
-} | {
-    type: "reset";
-};
-declare const emptyStore: TileStore;
-declare function tileReducer(store: TileStore, action: TileAction): TileStore;
+declare const ucFirst: (text: string | null | undefined) => string;
+/**
+ * Convert camelCase to words
+ */
+declare const camelCaseToWords: (text: string | null | undefined) => string;
+/**
+ * Convert snake_case to words
+ */
+declare const snakeCaseToWords: (text: string | null | undefined) => string;
+/**
+ * Convert enum-style text to sentence case
+ */
+declare const enumToSentenceCase: (text: string | null | undefined) => string;
+/**
+ * Truncate text in the middle
+ */
+declare const truncateMiddle: (value: string | null | undefined, length?: number) => string;
+/**
+ * Truncate text at the start
+ */
+declare const truncateStart: (value: string | null | undefined, length?: number) => string;
+/**
+ * Truncate text at the end
+ */
+declare const truncateEnd: (value: string | null | undefined, length?: number, ellipsis?: string) => string;
+/**
+ * Mask sensitive text (e.g., secrets, API keys)
+ */
+declare const toSecret: (value: string | null | undefined) => string;
+/**
+ * Format text according to TextFormat specification
+ */
+declare const formatText: (value: FieldValue, format: TextFormat) => FormattedValue;
 
-type Coverage = {
-    earliestMs?: number;
-    latestMs?: number;
-    erroredTiles: number;
-};
-type AssembledSeries = {
-    line: BaseDataPoint[];
-    band: BaseDataPoint[];
-    renderTier: Tier | null;
-    targetTier: Tier;
-    isFallback: boolean;
-    isStale: boolean;
-    coverage: Coverage;
-};
-type AssembleSeriesArgs = {
-    viewport: Viewport;
-    targetTier: Tier;
-    ladder: ResolutionLadder;
-    store: TileStore;
-    overscanTiles: number;
-    prev?: AssembledSeries | null;
-};
-declare function assembleSeries({ viewport, targetTier, ladder, store, overscanTiles, prev, }: AssembleSeriesArgs): AssembledSeries;
+/**
+ * Voltage formatting utilities (electrical potential)
+ */
 
-interface UseTiledTimeSeriesArgs {
-    fetchTile: FetchTile;
-    ladder: ResolutionLadder;
-    nativeMs: number;
-    initialViewport: Viewport;
-    widthPx: number;
-    maxFutureMs?: number;
-    targetPointsPerPx?: number;
-    concurrency?: number;
-    /**
-     * Approximate backend row multiplier for one bucket, used by the cost guard.
-     * Defaults to the voltage envelope's three fetched series (avg/min/max) to
-     * preserve the current behaviour; a single-series source can pass 1.
-     */
-    tileCostSeriesCount?: number;
-    /** Changing this aborts in-flight fetches and clears the store (e.g. a new meter). */
-    resetKey?: string;
-}
-interface UseTiledTimeSeriesResult {
-    viewport: Viewport;
-    onViewportChange(v: Viewport): void;
-    jumpTo(w: Viewport): void;
-    tier: Tier;
-    series: AssembledSeries;
-    loading: boolean;
-    atDataStart: boolean;
-}
-declare function useTiledTimeSeries(args: UseTiledTimeSeriesArgs): UseTiledTimeSeriesResult;
+/**
+ * Format as millivolts
+ */
+declare const toMillivolts: (value: number | null | undefined, decimals?: number) => string | null;
+/**
+ * Format as volts
+ */
+declare const toVolts: (value: number | null | undefined, decimals?: number) => string | null;
+/**
+ * Format as kilovolts
+ */
+declare const toKilovolts: (value: number | null | undefined, decimals?: number) => string | null;
+/**
+ * Auto-scale voltage to the most appropriate unit
+ */
+declare const autoScaleVoltage: (value: number | null | undefined, decimals?: number) => string | null;
+/**
+ * Format voltage according to VoltageFormat specification
+ */
+declare const formatVoltage: (value: FieldValue, format: VoltageFormat) => FormattedValue;
+declare const toMV: (value: number | null | undefined, decimals?: number) => string | null;
+declare const toV: (value: number | null | undefined, decimals?: number) => string | null;
+declare const toKV: (value: number | null | undefined, decimals?: number) => string | null;
 
 /**
- * Data Operations Utilities
+ * Comprehensive formatting utilities for the Edges design system
  *
- * Pure functions for filtering, sorting, searching, and faceting data.
- * These functions are used by useClientDataControls but can also be used standalone.
+ * This module provides a unified formatting system with support for:
+ * - Text formatting (case conversion, truncation, etc.)
+ * - Number formatting (decimals, thousands separators, compact notation)
+ * - Currency formatting (multiple currencies and display options)
+ * - Date formatting (relative time, custom formats, timezones)
+ * - Boolean formatting (custom true/false text)
+ * - Energy units (Wh, kWh, MWh, GWh with auto-scaling)
+ * - Temperature units (Celsius, Fahrenheit, Kelvin)
+ * - Distance units (meters, kilometers, miles, feet)
+ * - Phone number formatting (US and international)
+ * - Custom formatters via the FormatRegistry
  */
 
-interface ApplyDataOperationsOptions<T> {
-    data: T[];
-    filters?: FilterState;
-    sort?: SortState | null;
-    search?: SearchConfig | null;
-    facetConfigs?: FacetConfig[];
-}
-interface ApplyDataOperationsResult<T> {
-    data: T[];
-    facetCounts: FacetCounts;
-    resultCount: number;
-}
 /**
- * Apply all data operations in the correct order:
- * 1. Search
- * 2. Filter
- * 3. Compute facets (on filtered data)
- * 4. Sort
+ * Convenience function to create a format object
+ *
+ * @example
+ * ```typescript
+ * const currencyFormat = createFormat("currency", { currency: "EUR" });
+ * const dateFormat = createFormat("date", { relative: true });
+ * ```
  */
-declare function applyDataOperations<T>({ data, filters, sort, search, facetConfigs, }: ApplyDataOperationsOptions<T>): ApplyDataOperationsResult<T>;
+declare const createFormat: <T extends FieldFormat["type"]>(type: T, options?: Omit<Extract<FieldFormat, {
+    type: T;
+}>, "type">) => Extract<FieldFormat, {
+    type: T;
+}>;
 
 /**
  * Semantic typography role classes generated by @texturehq/edges-tokens.
@@ -2515,6 +2366,21 @@ interface ContactMetaDisplayProps {
  */
 declare function ContactMetaDisplay({ firstName, lastName, email, avatarUrl, layout, size, href, LinkComponent, linkVariant, emphasis, showEmail, badge, avatarShape, isLoading, className, piiEntity, }: ContactMetaDisplayProps): react_jsx_runtime.JSX.Element;
 
+/**
+ * ContainerQueryProvider — measures its own width via ResizeObserver and
+ * provides breakpoint state to all descendant blocks via context.
+ *
+ * Wrap block previews (or board surfaces) in this provider so blocks that
+ * use `useContainerBreakpoint` respond to their actual render width, not
+ * the browser viewport.
+ *
+ * Renders a transparent div wrapper — apply className to control layout.
+ */
+declare function ContainerQueryProvider({ children, className }: {
+    children: React.ReactNode;
+    className?: string;
+}): react_jsx_runtime.JSX.Element;
+
 interface CopyToClipboardProps {
     /**
      * The value to copy to clipboard. If not provided, will use the text content of children
@@ -2705,6 +2571,65 @@ declare const ChartAxis: {
     NumericBottom: React__default.FC<NumericAxisBottomProps>;
 };
 
+/**
+ * Chart export utilities for CSV, SVG, and PNG formats
+ * Provides comprehensive export functionality for chart visualizations
+ */
+
+type ExportType = "csv" | "svg" | "png";
+interface ChartExportMetadata {
+    xLabel?: string;
+    yLabel?: string;
+    seriesLabels?: string[];
+    filename?: string;
+    timestamp?: boolean;
+    /**
+     * Optional FieldFormat for the y-axis. When present, the CSV export:
+     *   - suffixes every series header with the format's stable column unit
+     *     (e.g. "Consumption (kWh)", "Voltage (V)"), and
+     *   - writes bare numbers in that unit into the cells (no per-row auto-scale).
+     *
+     * This keeps chart CSVs consistent with the Explore table CSV (BOLT-1431):
+     * unit in the header, bare numbers in the cells.
+     */
+    yFormat?: FieldFormat;
+}
+/**
+ * Main export function that handles all chart export types.
+ * Supports CSV, SVG, and PNG formats with automatic filename generation.
+ *
+ * @param type - Export format: "csv", "svg", or "png"
+ * @param datasets - Chart data as single array or array of arrays for multi-series
+ * @param metadata - Export metadata including labels and filename options
+ * @param svgRef - Reference to the chart's SVG element
+ * @returns Promise that resolves when export is complete
+ *
+ * @example
+ * ```typescript
+ * // Export single series as CSV
+ * await exportChart("csv", data, {
+ *   xLabel: "Date",
+ *   yLabel: "Value",
+ *   filename: "sales-data"
+ * }, svgRef);
+ *
+ * // Export multi-series chart as PNG
+ * await exportChart("png", [series1, series2], {
+ *   seriesLabels: ["Revenue", "Profit"],
+ *   timestamp: false
+ * }, svgRef);
+ * ```
+ */
+declare function exportChart(type: ExportType, datasets: BaseDataPoint[][] | BaseDataPoint[], metadata: ChartExportMetadata | undefined, svgRef: React__default.RefObject<SVGSVGElement | null>): Promise<void>;
+/**
+ * Utility to check if export is supported in the current environment
+ */
+declare function isExportSupported(type: ExportType): boolean;
+/**
+ * Get human-readable export format name
+ */
+declare function getExportFormatName(type: ExportType): string;
+
 interface ChartBottomBarProps {
     items: LegendItem[];
     onExport: (type: ExportType) => void | Promise<void>;
@@ -3049,6 +2974,20 @@ interface LineSeriesProps {
  */
 declare const LineSeries: React__default.FC<LineSeriesProps>;
 
+type TiledCameraPreviewDomain = [number, number] | null;
+interface TiledCameraSyncGroup {
+    publish(source: object, preview: TiledCameraPreviewDomain): void;
+    subscribe(source: object, onPreview: (preview: TiledCameraPreviewDomain) => void): () => void;
+}
+/**
+ * Shared camera for a set of TiledTimeSeriesCharts: pass one group to each
+ * chart's `cameraSync` prop and an in-progress pan/zoom on any chart previews
+ * live on the others, frame-by-frame. Purely imperative — sibling charts apply
+ * the previewed domain as a plot-group transform and axis re-tick, so nothing
+ * re-renders through React until the gesture settles.
+ */
+declare function createTiledCameraSyncGroup(): TiledCameraSyncGroup;
+
 interface TiledTimeSeriesChartViewport {
     startMs: number;
     endMs: number;
@@ -3073,6 +3012,12 @@ interface TiledTimeSeriesChartProps {
         label?: string;
         color?: string;
     }[];
+    /**
+     * Shared camera group (see `createTiledCameraSyncGroup`). While a gesture is
+     * in progress on any chart in the group, the others mirror its live camera
+     * frame-by-frame; the settled commit still arrives via `onViewportChange`.
+     */
+    cameraSync?: TiledCameraSyncGroup;
     parentWidth?: number;
     parentHeight?: number;
 }
@@ -3090,6 +3035,34 @@ declare const TiledTimeSeriesChart: React__default.FC<Omit<TiledTimeSeriesChartP
     parentHeight?: number;
 }>;
 
+/** The camera: the visible time window, absolute epoch ms. */
+type Viewport = {
+    startMs: number;
+    endMs: number;
+};
+/** One rung of the resolution ladder. */
+type Tier = {
+    id: string;
+    bucketMs: number;
+    tileSpanMs: number;
+};
+type ResolutionLadder = Tier[];
+/** A fixed-grid data slice: tile `index` at `tierId`, covering [startMs, endMs). */
+type TileRef = {
+    tierId: string;
+    index: number;
+    startMs: number;
+    endMs: number;
+};
+/** Data a tile carries. `band` optional → engine is metric-agnostic. */
+type TileData = {
+    line: BaseDataPoint[];
+    band?: BaseDataPoint[];
+};
+/** Injected loader: one tile = one bounded fetch. */
+type FetchTile = (tier: Tier, startMs: number, endMs: number, signal: AbortSignal) => Promise<TileData>;
+declare const tileKey: (tierId: string, index: number) => string;
+
 /**
  * Pick the finest tier whose bucket is coarse enough to hit ~targetPointsPerPx
  * across the chart and is not finer than the series' native cadence.
@@ -3099,6 +3072,54 @@ declare function tierForViewport(spanMs: number, widthPx: number, ladder: Resolu
     nativeMs: number;
 }): Tier;
 
+type TileStatus = "loading" | "loaded" | "empty" | "error";
+type TileEntry = {
+    status: TileStatus;
+    data?: TileData;
+    error?: Error;
+};
+type TileStore = ReadonlyMap<string, TileEntry>;
+type TileAction = {
+    type: "request";
+    ids: string[];
+} | {
+    type: "fulfilled";
+    id: string;
+    data: TileData;
+} | {
+    type: "failed";
+    id: string;
+    error: Error;
+} | {
+    type: "reset";
+};
+declare const emptyStore: TileStore;
+declare function tileReducer(store: TileStore, action: TileAction): TileStore;
+
+type Coverage = {
+    earliestMs?: number;
+    latestMs?: number;
+    erroredTiles: number;
+};
+type AssembledSeries = {
+    line: BaseDataPoint[];
+    band: BaseDataPoint[];
+    renderTier: Tier | null;
+    targetTier: Tier;
+    isFallback: boolean;
+    isStale: boolean;
+    coverage: Coverage;
+};
+type AssembleSeriesArgs = {
+    viewport: Viewport;
+    targetTier: Tier;
+    ladder: ResolutionLadder;
+    store: TileStore;
+    overscanTiles: number;
+    prev?: AssembledSeries | null;
+};
+declare function assembleSeries({ viewport, targetTier, ladder, store, overscanTiles, prev, }: AssembleSeriesArgs): AssembledSeries;
+
 declare function tileIndexAt(tsMs: number, tier: Tier): number;
 declare function tilesForViewport(viewport: Viewport, tier: Tier, overscanTiles: number): TileRef[];
 
@@ -6213,8 +6234,8 @@ declare namespace PageLayout {
     var Header: typeof Header;
     var Tabs: typeof Tabs$1;
     var Content: typeof Content;
-    var Aside: typeof Aside$1;
-    var ScrollableContent: typeof ScrollableContent;
+    var Aside: typeof Aside;
+    var ScrollableContent: ({ children, className }: PageScrollableContentProps) => react_jsx_runtime.JSX.Element;
 }
 type PageHeaderProps = {
     title: React__default.ReactNode;
@@ -6282,29 +6303,11 @@ type PageAsideProps = {
     sticky?: boolean;
     className?: string;
 };
-declare function Aside$1({ children, sticky, className }: PageAsideProps): react_jsx_runtime.JSX.Element;
+declare function Aside({ children, sticky, className }: PageAsideProps): react_jsx_runtime.JSX.Element;
 type PageScrollableContentProps = {
     children: React__default.ReactNode;
     className?: string;
 };
-/**
- * ScrollableContent
- *
- * Helper component for creating scrollable content areas within PageLayout.
- * Commonly used with sticky headers and controls for data-heavy pages.
- *
- * Example usage:
- * ```tsx
- * <PageLayout className="flex flex-col h-screen">
- *   <PageLayout.Header sticky={true} />
- *   <DataControls sticky={true} stickyTop="120px" />
- *   <PageLayout.ScrollableContent>
- *     <DataTable data={data} columns={columns} />
- *   </PageLayout.ScrollableContent>
- * </PageLayout>
- * ```
- */
-declare function ScrollableContent({ children, className }: PageScrollableContentProps): react_jsx_runtime.JSX.Element;
 
 interface Place {
     id: string;
@@ -6964,11 +6967,9 @@ interface SplitPanePanelProps {
 }
 declare function SplitPane({ asideWidth, asideHeight, minAsideWidth, minAsideHeight, minMainWidth, minMainHeight, orientation, resizable, onAsideResize, onResizeStart, onResizeEnd, className, dividerClassName, children, }: SplitPaneProps): react_jsx_runtime.JSX.Element;
 declare namespace SplitPane {
-    var Main: typeof Main;
-    var Aside: typeof Aside;
+    var Main: ({ className, children }: SplitPanePanelProps) => react_jsx_runtime.JSX.Element;
+    var Aside: ({ className, children }: SplitPanePanelProps) => react_jsx_runtime.JSX.Element;
 }
-declare function Main({ className, children }: SplitPanePanelProps): react_jsx_runtime.JSX.Element;
-declare function Aside({ className, children }: SplitPanePanelProps): react_jsx_runtime.JSX.Element;
 
 /**
  * StatList — Compact key-value statistics display
@@ -7292,6 +7293,42 @@ declare namespace Tray {
     var displayName: string;
 }
 
+interface UseTileWindowArgs {
+    fetchTile: FetchTile;
+    ladder: ResolutionLadder;
+    nativeMs: number;
+    /** Caller-owned camera. The window re-tiles as this changes. */
+    viewport: Viewport;
+    widthPx: number;
+    maxFutureMs?: number;
+    targetPointsPerPx?: number;
+    concurrency?: number;
+    /**
+     * Approximate backend row multiplier for one bucket, used by the cost guard.
+     * Defaults to the voltage envelope's three fetched series (avg/min/max) to
+     * preserve the current behaviour; a single-series source can pass 1.
+     */
+    tileCostSeriesCount?: number;
+    /** Changing this aborts in-flight fetches and clears the store (e.g. a new meter). */
+    resetKey?: string;
+}
+interface UseTileWindowResult {
+    tier: Tier;
+    series: AssembledSeries;
+    loading: boolean;
+    atDataStart: boolean;
+}
+interface UseTiledTimeSeriesArgs extends Omit<UseTileWindowArgs, "viewport"> {
+    initialViewport: Viewport;
+}
+interface UseTiledTimeSeriesResult extends UseTileWindowResult {
+    viewport: Viewport;
+    onViewportChange(v: Viewport): void;
+    jumpTo(w: Viewport): void;
+}
+declare function useTileWindow(args: UseTileWindowArgs): UseTileWindowResult;
+declare function useTiledTimeSeries(args: UseTiledTimeSeriesArgs): UseTiledTimeSeriesResult;
+
 /**
  * CSS variable overrides for white-labeling.
  *
@@ -7430,4 +7467,4 @@ declare function getStateTone(state: DeviceState): StatTone;
  */
 type LinkComponentType = React.ComponentType<any>;
 
-export { type Action, ActionCell, type ActionCellProps, ActivityFeed, ActivityFeedGroup, type ActivityFeedGroupProps, type ActivityFeedProps, type ActivityFeedSize, type ActivityFeedVariant, ActivityItem, type ActivityItemProps, type ActivityItemSurface, type ActivityItemTone, Alert, type AlertProps, type ApplyDataOperationsOptions, type ApplyDataOperationsResult, AreaSeries, type AssembleSeriesArgs, type AssembledSeries, AutoMobileRenderer, BREAKPOINTS, BadgeCell, type BadgeCellProps, BadgeProps, Banner, type BannerAction, type BannerAppearance, type BannerProps, type BannerVariant, BarSeries, BaseDataPoint, BaseInputProps, BooleanCell, type BooleanCellProps, BooleanFormat, BrandProvider, type BrandProviderProps, type BrandVariables, BreadcrumbItem, type BreadcrumbItemProps, Breadcrumbs, type Breakpoint, type BreakpointState, Calendar, Card, CardContent, type CardContentProps, CardFooter, type CardFooterProps, CardHeader, type CardHeaderProps, CardMedia, type CardMediaProps, CardMobileRenderer, type CardProps, type CardVariant, CarouselAutoplayTrigger, CarouselControl, type CarouselControlProps, CarouselIndicator, CarouselIndicatorGroup, type CarouselIndicatorProps, CarouselItem, CarouselItemGroup, type CarouselItemGroupProps, type CarouselItemProps, CarouselNextTrigger, CarouselPrevTrigger, CarouselProgressText, CarouselRoot, type CarouselRootProps, type CarouselTriggerProps, CategoryBarChart, type CategoryDataPoint as CategoryBarChartDataPoint, type CategoryBarChartProps, type CategoryDataPoint, type CellAlignment, type CellComponent, type CellComponentProps, type CellContext, type CellEmphasis, ChartAxis, ChartBottomBar, ChartContainer, ChartEventMarkers, type ChartEventMarkersProps, ChartEventSpans, type ChartEventSpansProps, type ChartExportMetadata, ChartTooltip, Chip, ChipInputField, type ChipInputFieldProps, Collapse, CollapseContent, type CollapseContentProps, type CollapseDensity, CollapseHeader, type CollapseHeaderProps, CollapseItem, type CollapseItemProps, type CollapseProps, type CollapseVariant, ColorModeProvider, type Column, CommandPalette, type CommandPaletteProps, ComponentFormatter, Confirm, type ConfirmProps, ConnectionStatusBadge, type ConnectionStatusBadgeProps, ContactCard, type ContactCardProps, ContactMetaCell, ContactMetaDisplay, type ContactMetaDisplayProps, CopyToClipboard, type Coverage, CurrencyFormat, CurrentFormat, CustomCell, type CustomCellProps, CustomPinsSpec, DataControls, type Filter as DataControlsFilter, type DataControlsProps, type SortOption as DataControlsSortOption, DataTable, type DataTableProps, DateCell, type DateCellProps, DateFormat, DateRangePicker, DeviceHealthBadge, type DeviceHealthBadgeProps, DeviceMetaCell, type DeviceMetaCellProps, DeviceMetaDisplay, type DeviceMetaDisplayProps, DeviceState, DeviceStateBadge, type DeviceStateBadgeProps, DeviceStateCell, type DeviceStateCellProps, DeviceStateWithMetric, type DeviceStateWithMetricProps, type DeviceType, DeviceTypeIcon, type DeviceTypeIconProps, DialogAction, DialogFooterConfig, DialogHeader, DialogHeaderConfig, type DialogHeaderProps, DistanceFormat, type ElementSize, EmptyState, type EmptyStateAction, type EmptyStateAlignment, type EmptyStateProps, type EmptyStateSize, EnergyFormat, EnergyUnit, type EnrollmentStatus, EnrollmentStatusBadge, type EnrollmentStatusBadgeProps, ErrorBoundary, type EventMarker, type EventMarkerType, type EventSpan, type ExportType, type FacetConfig, type FacetCounts, type FacetType, type FetchTile, FieldFormat, FieldValue, type FilterChip, FilterChips, type FilterChipsProps, type FilterCondition, FilterDialog, type FilterDialogProps, type FilterGroup, type FilterOperator, type FilterState, FirmwareVersionBadge, type FirmwareVersionBadgeProps, Form, FormatRegistry, FormattedCell, FormattedValue, FormatterFunction, FunnelSeries, type FunnelSeriesProps, type FunnelStage as FunnelSeriesStage, GeoJsonLayerSpec, GlobalSearch, type GlobalSearchProps, Grid, type GridAlign, type GridCols, type GridFlow, type GridGap, type GridItemProps, type GridJustify, type GridProps, type GridSpan, GridState, GridStateBadge, type GridStateBadgeProps, type HealthStatus, HierarchyExplorer, type HierarchyExplorerProps, type HierarchyNode, HorizontalBarCell, type HorizontalBarCellProps, HoverCard, type HoverCardContentProps, type HoverCardRootProps, Icon$1 as Icon, IconName$2 as IconName, InfiniteScrollIndicator, type InfiniteScrollIndicatorProps, Kpi, KpiGroup, type KpiGroupAlign, type KpiGroupCols, type KpiGroupGap, type KpiGroupProps, type KpiOrientation, type KpiProps, type KpiSize, type KpiStatus, LayerSpec, LineSeries, type LinkBehavior, type LinkComponentType, List, ListBox, ListBoxItem, ListItem, type ListItemProps, ListPane, type ListPaneProps, type ListProps, type LoadingState, MiniBarCell, type MiniBarCellProps, type MobileBreakpoint, type MobileConfig, type MobileRenderer, ModalBackdrop, type ModalBackdropProps, type NodeState, Notice, NoticeContainer, type NoticeContainerProps, type NoticeOptions, type NoticeProps, NoticeProvider, type NoticeProviderProps, type NoticeVariant, NumberCell, type NumberCellProps, NumberFormat, type PageAsideProps, PageBanner, type PageBannerProps, type PageBreadcrumbItem, type PageContentProps, type PageHeaderProps, PageLayout, type PageLayoutProps, type PageScrollableContentProps, PercentBarCell, type PercentBarCellProps, PhoneFormat, type Place, PlaceSearch, type PlaceSearchProps, Popover, PowerFormat, type PresetRange, ProgressBar, Prose, type ProseProps, type ProseSize, type ProseTone, RangeCalendar, RasterLayerSpec, type RegisterPhosphorIconOptions, ResistanceFormat, type ResolutionLadder, type ResponsiveValue, ResultsCount, type ResultsCountProps, SKELETON_SIZES, SOURCE_UNIT_TO_WH, type SearchConfig, SearchControl, type SearchControlProps, SearchEmptyState, type SearchEmptyStateProps, SearchLoadingState, type SearchLoadingStateProps, SearchResultGroup, type SearchResultGroupProps, SearchResultItem, type SearchResultItemProps, SearchResultsList, type SearchResultsListProps, SearchTrigger, type SearchTriggerProps, Section, SectionNav, type SectionNavItem, type SectionNavOrientation, type SectionNavProps, type SectionProps, type SectionSpacing, type SectionVariant, SelectCell, type SelectCellProps, SiteCard, type SiteCardProps, SiteContactCard, type SiteContactCardProps, SiteMetaCell, SiteMetaDisplay, type SiteMetaDisplayProps, Skeleton, Slider, type SortConfig, SortControl, type SortControlProps, type SortDirection, type SortState, SparklineCell, type SparklineCellProps, SplitPane, type SplitPaneOrientation, type SplitPanePanelProps, type SplitPaneProps, type StatAlign, type StatFormatter, type StatItem, type StatLayout, StatList, type StatListProps, type StatThreshold, type StatTone$1 as StatTone, type StatValue, Tab, TabList, TabPanel, type TableDensity, type TableExportMetadata, type TableExportOptions, type TableLayout, type TableWidth, Tabs, type TabsProps$1 as TabsProps, TemperatureFormat, TemperatureUnit, TemperatureUnitString, TextAreaWithChips, TextCell, type TextCellProps, TextFormat, type Tier, type TileAction, type TileData, type TileEntry, type TileRef, type TileStatus, type TileStore, TiledTimeSeriesChart, type TiledTimeSeriesChartProps, type TiledTimeSeriesChartViewport, TiledTimeSeriesExplorer, type TiledTimeSeriesExplorerProps, type TiledTimeSeriesSource, TimeControls, type TimeControlsProps, type TimeRange, Timeline, TimelineItem, type TimelineItemProps, type TimelineItemVariant, ToggleButton, Tooltip, TooltipData, Tray, type TrayProps, type TrendPoint, type TypographyRole, type UseBreakpointReturn, type UseClientDataControlsOptions, type UseClientDataControlsResult, type UseDataControlsClientOptions, type UseDataControlsOptions, type UseDataControlsResult, type UseDataControlsServerOptions, type UseElementSizeResult, type UseInfiniteScrollOptions, type UseInfiniteScrollReturn, type UseServerDataControlsOptions, type UseTableExportOptions, type UseTableExportReturn, type UseTiledTimeSeriesArgs, type UseTiledTimeSeriesResult, VectorLayerSpec, type Viewport, VoltageFormat, type WindowSize, type WindowSizeOption, YFormatType, addFilterCondition, applyDataOperations, assembleSeries, autoScaleCurrent, autoScaleDistance, autoScaleEnergy, autoScalePower, autoScaleResistance, autoScaleVoltage, camelCaseToWords, capitalize, celsiusToFahrenheit, celsiusToKelvin, centimetersToInches, createEmptyFilter, createFilter, createFilters, createFormat, createTextureIcon, csvUnitFor, csvValueFor, emptyStore, enumToSentenceCase, exportChart, exportTableAsCSV, fahrenheitToCelsius, fahrenheitToKelvin, feetToMeters, feetToMiles, filterToChips, formatBoolean, formatCapacity, formatCurrency, formatCurrent, formatDate, formatDistance, formatEmptyValue, formatEnergy, formatFieldValue, formatInternationalPhone, formatNumber, formatPercent, formatPhone, formatPhoneNumber, formatPower, formatPowerRating, formatResistance, formatTemperature, formatText, formatUSPhone, formatVoltage, getBadgeClasses, getBooleanBadgeVariant, getCellAlignmentClasses, getCellContainerClasses, getCellTextClasses, getDateParts, getEventColor, getExportFormatName, getExportHeaders, getFilterFields, getLinkClasses, getNumericColorClasses, getSkeletonSize, getStateTone, inchesToCentimeters, isCustomPinsLayer, isExportSupported, isFilterEmpty, isGeoJsonLayer, isNil, isRasterLayer, isVectorLayer, kelvinToCelsius, kelvinToFahrenheit, kilometersToMiles, layer, metersToFeet, metersToMiles, metersToYards, milesToFeet, milesToKilometers, milesToMeters, parseBoolean, pickEnergyUnit, prepareTableDataForExport, registerPhosphorIcon, removeFilterCondition, resolveValue, snakeCaseToWords, temperatureStringToSymbol, tierForViewport, tileIndexAt, tileKey, tileReducer, tilesForViewport, toA, toActiveInactive, toAmps, toBoolean, toCelsius, toCentimeters, toCheckmark, toCompactNumber, toCurrency, toCustomDateFormat, toDateString, toEnabledDisabled, toFahrenheit, toFeet, toFloat, toFormattedNumber, toFullDateTime, toGW, toGWh, toGigawatts, toISOString, toInches, toInteger, toKA, toKV, toKW, toKelvin, toKiloamps, toKilohms, toKilometers, toKilovolts, toKilowatts, toLowerCase, toMA, toMV, toMW, toMWh, toMegawatts, toMegohms, toMeters, toMiles, toMilliamps, toMillimeters, toMilliohms, toMillivolts, toNauticalMiles, toOhms, toOnOff, toPercentage, toRelativeTime, toScientificNotation, toSecret, toSentenceCase, toTemperature, toTitleCase, toTrueFalse, toUpperCase, toV, toVolts, toW, toWatts, toWh, toYards, tokWh, truncateEnd, truncateMiddle, truncateStart, typeRole, typographyRole, ucFirst, useBreakpoint, useClientDataControls, useColorMode, useDataControls, useDebounce, useElementSize, useInfiniteScroll, useLocalStorage, useMediaQuery, useNotice, useServerDataControls, useTableExport, useTiledTimeSeries, wrapWithLink, yardsToMeters };
+export { type Action, ActionCell, type ActionCellProps, ActivityFeed, ActivityFeedGroup, type ActivityFeedGroupProps, type ActivityFeedProps, type ActivityFeedSize, type ActivityFeedVariant, ActivityItem, type ActivityItemProps, type ActivityItemSurface, type ActivityItemTone, Alert, type AlertProps, type ApplyDataOperationsOptions, type ApplyDataOperationsResult, AreaSeries, type AssembleSeriesArgs, type AssembledSeries, AutoMobileRenderer, BREAKPOINTS, BadgeCell, type BadgeCellProps, BadgeProps, Banner, type BannerAction, type BannerAppearance, type BannerProps, type BannerVariant, BarSeries, BaseDataPoint, BaseInputProps, BooleanCell, type BooleanCellProps, BooleanFormat, BrandProvider, type BrandProviderProps, type BrandVariables, BreadcrumbItem, type BreadcrumbItemProps, Breadcrumbs, type Breakpoint, type BreakpointState, Calendar, Card, CardContent, type CardContentProps, CardFooter, type CardFooterProps, CardHeader, type CardHeaderProps, CardMedia, type CardMediaProps, CardMobileRenderer, type CardProps, type CardVariant, CarouselAutoplayTrigger, CarouselControl, type CarouselControlProps, CarouselIndicator, CarouselIndicatorGroup, type CarouselIndicatorProps, CarouselItem, CarouselItemGroup, type CarouselItemGroupProps, type CarouselItemProps, CarouselNextTrigger, CarouselPrevTrigger, CarouselProgressText, CarouselRoot, type CarouselRootProps, type CarouselTriggerProps, CategoryBarChart, type CategoryDataPoint as CategoryBarChartDataPoint, type CategoryBarChartProps, type CategoryDataPoint, type CellAlignment, type CellComponent, type CellComponentProps, type CellContext, type CellEmphasis, ChartAxis, ChartBottomBar, ChartContainer, ChartEventMarkers, type ChartEventMarkersProps, ChartEventSpans, type ChartEventSpansProps, type ChartExportMetadata, ChartTooltip, Chip, ChipInputField, type ChipInputFieldProps, Collapse, CollapseContent, type CollapseContentProps, type CollapseDensity, CollapseHeader, type CollapseHeaderProps, CollapseItem, type CollapseItemProps, type CollapseProps, type CollapseVariant, ColorModeProvider, type Column, CommandPalette, type CommandPaletteProps, ComponentFormatter, Confirm, type ConfirmProps, ConnectionStatusBadge, type ConnectionStatusBadgeProps, ContactCard, type ContactCardProps, ContactMetaCell, ContactMetaDisplay, type ContactMetaDisplayProps, ContainerQueryProvider, CopyToClipboard, type Coverage, CurrencyFormat, CurrentFormat, CustomCell, type CustomCellProps, CustomPinsSpec, DataControls, type Filter as DataControlsFilter, type DataControlsProps, type SortOption as DataControlsSortOption, DataTable, type DataTableProps, DateCell, type DateCellProps, DateFormat, DateRangePicker, DeviceHealthBadge, type DeviceHealthBadgeProps, DeviceMetaCell, type DeviceMetaCellProps, DeviceMetaDisplay, type DeviceMetaDisplayProps, DeviceState, DeviceStateBadge, type DeviceStateBadgeProps, DeviceStateCell, type DeviceStateCellProps, DeviceStateWithMetric, type DeviceStateWithMetricProps, type DeviceType, DeviceTypeIcon, type DeviceTypeIconProps, DialogAction, DialogFooterConfig, DialogHeader, DialogHeaderConfig, type DialogHeaderProps, DistanceFormat, type ElementSize, EmptyState, type EmptyStateAction, type EmptyStateAlignment, type EmptyStateProps, type EmptyStateSize, EnergyFormat, EnergyUnit, type EnrollmentStatus, EnrollmentStatusBadge, type EnrollmentStatusBadgeProps, ErrorBoundary, type EventMarker, type EventMarkerType, type EventSpan, type ExportType, type FacetConfig, type FacetCounts, type FacetType, type FetchTile, FieldFormat, FieldValue, type FilterChip, FilterChips, type FilterChipsProps, type FilterCondition, FilterDialog, type FilterDialogProps, type FilterGroup, type FilterOperator, type FilterState, FirmwareVersionBadge, type FirmwareVersionBadgeProps, Form, FormatRegistry, FormattedCell, FormattedValue, FormatterFunction, FunnelSeries, type FunnelSeriesProps, type FunnelStage as FunnelSeriesStage, GeoJsonLayerSpec, GlobalSearch, type GlobalSearchProps, Grid, type GridAlign, type GridCols, type GridFlow, type GridGap, type GridItemProps, type GridJustify, type GridProps, type GridSpan, GridState, GridStateBadge, type GridStateBadgeProps, type HealthStatus, HierarchyExplorer, type HierarchyExplorerProps, type HierarchyNode, HorizontalBarCell, type HorizontalBarCellProps, HoverCard, type HoverCardContentProps, type HoverCardRootProps, Icon$1 as Icon, IconName$2 as IconName, InfiniteScrollIndicator, type InfiniteScrollIndicatorProps, Kpi, KpiGroup, type KpiGroupAlign, type KpiGroupCols, type KpiGroupGap, type KpiGroupProps, type KpiOrientation, type KpiProps, type KpiSize, type KpiStatus, LayerSpec, LineSeries, type LinkBehavior, type LinkComponentType, List, ListBox, ListBoxItem, ListItem, type ListItemProps, ListPane, type ListPaneProps, type ListProps, type LoadingState, MiniBarCell, type MiniBarCellProps, type MobileBreakpoint, type MobileConfig, type MobileRenderer, ModalBackdrop, type ModalBackdropProps, type NodeState, Notice, NoticeContainer, type NoticeContainerProps, type NoticeOptions, type NoticeProps, NoticeProvider, type NoticeProviderProps, type NoticeVariant, NumberCell, type NumberCellProps, NumberFormat, type PageAsideProps, PageBanner, type PageBannerProps, type PageBreadcrumbItem, type PageContentProps, type PageHeaderProps, PageLayout, type PageLayoutProps, type PageScrollableContentProps, PercentBarCell, type PercentBarCellProps, PhoneFormat, type Place, PlaceSearch, type PlaceSearchProps, Popover, PowerFormat, type PresetRange, ProgressBar, Prose, type ProseProps, type ProseSize, type ProseTone, RangeCalendar, RasterLayerSpec, type RegisterPhosphorIconOptions, ResistanceFormat, type ResolutionLadder, type ResponsiveValue, ResultsCount, type ResultsCountProps, SKELETON_SIZES, SOURCE_UNIT_TO_WH, type SearchConfig, SearchControl, type SearchControlProps, SearchEmptyState, type SearchEmptyStateProps, SearchLoadingState, type SearchLoadingStateProps, SearchResultGroup, type SearchResultGroupProps, SearchResultItem, type SearchResultItemProps, SearchResultsList, type SearchResultsListProps, SearchTrigger, type SearchTriggerProps, Section, SectionNav, type SectionNavItem, type SectionNavOrientation, type SectionNavProps, type SectionProps, type SectionSpacing, type SectionVariant, SelectCell, type SelectCellProps, SiteCard, type SiteCardProps, SiteContactCard, type SiteContactCardProps, SiteMetaCell, SiteMetaDisplay, type SiteMetaDisplayProps, Skeleton, Slider, type SortConfig, SortControl, type SortControlProps, type SortDirection, type SortState, SparklineCell, type SparklineCellProps, SplitPane, type SplitPaneOrientation, type SplitPanePanelProps, type SplitPaneProps, type StatAlign, type StatFormatter, type StatItem, type StatLayout, StatList, type StatListProps, type StatThreshold, type StatTone$1 as StatTone, type StatValue, Tab, TabList, TabPanel, type TableDensity, type TableExportMetadata, type TableExportOptions, type TableLayout, type TableWidth, Tabs, type TabsProps$1 as TabsProps, TemperatureFormat, TemperatureUnit, TemperatureUnitString, TextAreaWithChips, TextCell, type TextCellProps, TextFormat, type Tier, type TileAction, type TileData, type TileEntry, type TileRef, type TileStatus, type TileStore, type TiledCameraPreviewDomain, type TiledCameraSyncGroup, TiledTimeSeriesChart, type TiledTimeSeriesChartProps, type TiledTimeSeriesChartViewport, TiledTimeSeriesExplorer, type TiledTimeSeriesExplorerProps, type TiledTimeSeriesSource, TimeControls, type TimeControlsProps, type TimeRange, Timeline, TimelineItem, type TimelineItemProps, type TimelineItemVariant, ToggleButton, Tooltip, TooltipData, Tray, type TrayProps, type TrendPoint, type TypographyRole, type UseBreakpointReturn, type UseClientDataControlsOptions, type UseClientDataControlsResult, type UseDataControlsClientOptions, type UseDataControlsOptions, type UseDataControlsResult, type UseDataControlsServerOptions, type UseElementSizeResult, type UseInfiniteScrollOptions, type UseInfiniteScrollReturn, type UseServerDataControlsOptions, type UseTableExportOptions, type UseTableExportReturn, type UseTileWindowArgs, type UseTileWindowResult, type UseTiledTimeSeriesArgs, type UseTiledTimeSeriesResult, VectorLayerSpec, type Viewport, VoltageFormat, type WindowSize, type WindowSizeOption, YFormatType, addFilterCondition, applyDataOperations, assembleSeries, autoScaleCurrent, autoScaleDistance, autoScaleEnergy, autoScalePower, autoScaleResistance, autoScaleVoltage, camelCaseToWords, capitalize, celsiusToFahrenheit, celsiusToKelvin, centimetersToInches, createEmptyFilter, createFilter, createFilters, createFormat, createTextureIcon, createTiledCameraSyncGroup, csvUnitFor, csvValueFor, emptyStore, enumToSentenceCase, exportChart, exportTableAsCSV, fahrenheitToCelsius, fahrenheitToKelvin, feetToMeters, feetToMiles, filterToChips, formatBoolean, formatCapacity, formatCurrency, formatCurrent, formatDate, formatDistance, formatEmptyValue, formatEnergy, formatFieldValue, formatInternationalPhone, formatNumber, formatPercent, formatPhone, formatPhoneNumber, formatPower, formatPowerRating, formatResistance, formatTemperature, formatText, formatUSPhone, formatVoltage, getBadgeClasses, getBooleanBadgeVariant, getCellAlignmentClasses, getCellContainerClasses, getCellTextClasses, getDateParts, getEventColor, getExportFormatName, getExportHeaders, getFilterFields, getLinkClasses, getNumericColorClasses, getSkeletonSize, getStateTone, inchesToCentimeters, isCustomPinsLayer, isExportSupported, isFilterEmpty, isGeoJsonLayer, isNil, isRasterLayer, isVectorLayer, kelvinToCelsius, kelvinToFahrenheit, kilometersToMiles, layer, metersToFeet, metersToMiles, metersToYards, milesToFeet, milesToKilometers, milesToMeters, parseBoolean, pickEnergyUnit, prepareTableDataForExport, registerPhosphorIcon, removeFilterCondition, resolveValue, snakeCaseToWords, temperatureStringToSymbol, tierForViewport, tileIndexAt, tileKey, tileReducer, tilesForViewport, toA, toActiveInactive, toAmps, toBoolean, toCelsius, toCentimeters, toCheckmark, toCompactNumber, toCurrency, toCustomDateFormat, toDateString, toEnabledDisabled, toFahrenheit, toFeet, toFloat, toFormattedNumber, toFullDateTime, toGW, toGWh, toGigawatts, toISOString, toInches, toInteger, toKA, toKV, toKW, toKelvin, toKiloamps, toKilohms, toKilometers, toKilovolts, toKilowatts, toLowerCase, toMA, toMV, toMW, toMWh, toMegawatts, toMegohms, toMeters, toMiles, toMilliamps, toMillimeters, toMilliohms, toMillivolts, toNauticalMiles, toOhms, toOnOff, toPercentage, toRelativeTime, toScientificNotation, toSecret, toSentenceCase, toTemperature, toTitleCase, toTrueFalse, toUpperCase, toV, toVolts, toW, toWatts, toWh, toYards, tokWh, truncateEnd, truncateMiddle, truncateStart, typeRole, typographyRole, ucFirst, useBreakpoint, useClientDataControls, useColorMode, useContainerBreakpoint, useDataControls, useDebounce, useElementSize, useInfiniteScroll, useLocalStorage, useMediaQuery, useNotice, useServerDataControls, useTableExport, useTileWindow, useTiledTimeSeries, wrapWithLink, yardsToMeters };