@texturehq/edges 5.21.0 → 5.22.1

package/dist/index.d.ts

@@ -1,15 +1,15 @@
 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, Focusable } from 'react-aria-components';
-import { au as LoadingState, B as BadgeProps, av as FilterState, aw as SortState, ax as SearchConfig, ay as FacetConfig, az as FacetCounts, aA as Column, aB as CellEmphasis, aC as FieldValue, aD as BooleanFormat, aE as FormattedValue, aF as FieldFormat, aG as CurrentFormat, aH as DateFormat, aI as DistanceFormat, aJ as EnergyUnit, aK as EnergyFormat, aL as CurrencyFormat, aM as NumberFormat, aN as PhoneFormat, aO as PowerFormat, aP as FormatterFunction, aQ as ResistanceFormat, aR as TemperatureFormat, aS as TemperatureUnitString, aT as TemperatureUnit, aU as TextFormat, aV as VoltageFormat, e as BaseDataPoint, $ as YFormatType, R as TooltipData, aW as CellComponentProps, aX as CellAlignment, aY as LinkBehavior, D as DeviceState, s as GridState, aZ as ComponentFormatter, a_ as DataTableProps, a$ as LayerSpec, b0 as CustomPinsSpec, b1 as GeoJsonLayerSpec, b2 as RasterLayerSpec, b3 as VectorLayerSpec, b4 as ClusteredVectorLayerSpec, b5 as ColorSpec } from './colors-FpM-WXGA.js';
-export { A as ABSENT_GRID_FIELDS, a as ActionItem, b6 as ActionMenu, b as ActionMenuProps, b7 as AppShell, c as AppShellProps, b8 as Avatar, d as AvatarProps, b9 as Badge, ba as BaseFormat, C as CATEGORY_COLOR_TOKENS, f as CATEGORY_NEUTRAL_COLOR, bb as CellComponent, bc as CellContext, bd as ChartContext, g as ChartMargin, be as CodeEditor, h as CodeEditorProps, i as CodeLanguage, j as CodeTheme, bf as ComponentFormatOptions, bg as CurrentUnit, bh as CustomFormat, bi as DEFAULT_MAP_TYPE, bj as DateFormatStyle, bk as DistanceUnit, bl as ENTITY_CATEGORY_CONFIG, E as ENTITY_CONFIG, k as EntityArchetype, bm as EntityCategory, bn as EntityCategoryConfig, l as EntityConfig, m as EntityStateRule, n as EntityType, bo as FacetType, bp as FilterChip, bq as FilterCondition, br as FilterGroup, bs as FilterOperator, G as GRID_ELEMENT_TYPE_BY_ENTITY, bt as GRID_STATE_COLORS, o as GRID_STAT_LIST, bu as GRID_STAT_LIST_CAPACITOR_PER_PHASE_KVAR, bv as GRID_STAT_LIST_CAPACITOR_TOTAL_KVAR, p as GridElementSourceType, q as GridStatField, r as GridStatFieldFormat, bw as GridStateColor, H as HEADLINE_METRIC_BOUNDS, t as Heading, u as HeadlineMetric, bx as InteractiveMap, by as InteractiveMapHandle, I as InteractiveMapProps, bz as LayerCheckState, bA as LayerFeature, bB as LayerSelection, bC as LayerStyle, bD as LayerTreeNode, bE as LayerVisibilityPatch, L as Loader, v as Logo, bF as MAP_TYPES, M as MapPoint, bG as MapType, bH as Meter, w as MeterProps, x as MetricFormat, y as MetricSource, bI as MobileBreakpoint, bJ as MobileConfig, bK as MobileRenderer, bL as PercentBarCell, bM as PercentBarCellProps, P as PercentThresholdLevel, z as PercentThresholds, bN as PercentageFormat, bO as PowerUnit, bP as RenderType, bQ as ResistanceUnit, S as SegmentOption, bR as SegmentedControl, F as SegmentedControlProps, J as SerializableFieldFormat, K as SideNav, N as SideNavItem, O as SideNavProps, bS as SortConfig, bT as SortDirection, bU as StackNav, bV as StackNavGroup, bW as StackNavItem, bX as StackNavLinkComponentProps, bY as StackNavProps, bZ as StackNavRenderRow, b_ as StackNavRowRenderProps, b$ as StackNavTheme, c0 as StaticMap, Q as StaticMapProps, c1 as TableDensity, c2 as TableLayout, c3 as TableWidth, T as TextLink, c4 as TextTransform, c5 as TextTruncatePosition, U as TooltipSeries, V as TopNav, W as TopNavProps, X as UNARY_FILTER_OPERATORS, Y as UNARY_OPERATOR_LABELS, c6 as UNVERIFIED_VOLTAGE_UNIT_ROWS, Z as UnaryFilterOperator, c7 as UseInfiniteScrollOptions, c8 as UseInfiniteScrollReturn, c9 as VoltageUnit, _ as YFormatSettings, ca as ZoomStops, a0 as activeDeviceStates, cb as addFilterCondition, a1 as archetypeFor, cc as baselineFromPoint, a2 as clearColorCache, a3 as createCategoryColorMap, cd as createEmptyFilter, ce as createFilter, cf as createFilters, a4 as createXScale, a5 as createYScale, a6 as defaultMargin, a7 as deviceStateLabels, a8 as deviceStateMetricFormats, a9 as entityHasDetailPage, aa as entityHasStatList, ab as entityShowsNow, cg as filterToChips, ch as formatComponentValue, ac as getContrastingTextColor, ad as getDefaultChartColor, ae as getDefaultColors, af as getDeviceStateDisplayLabel, af as getDeviceStateLabel, ci as getEntityCategory, ag as getEntityConfig, ah as getEntityIcon, ai as getEntityLabel, aj as getEntityStatList, cj as getFilterFields, ak as getGridStateLabel, al as getResolvedColor, am as getThemeCategoricalColors, an as getYFormatSettings, ao as gridEntityTypeKeys, ap as gridStateLabels, aq as isActiveDeviceState, aq as isActiveState, ck as isFilterEmpty, ar as isGridEntityTypeKey, as as isLightColor, at as isUnaryFilterOperator, cl as mapValuesToCategoricalColors, cm as percentThresholdLevel, cn as removeFilterCondition, co as useChartContext, cp as useComponentFormatter, cq as useInfiniteScroll } from './colors-FpM-WXGA.js';
+import { au as LoadingState, B as BadgeProps, av as FilterState, aw as SortState, ax as SearchConfig, ay as FacetConfig, az as FacetCounts, aA as Column, aB as CellEmphasis, aC as FieldValue, aD as BooleanFormat, aE as FormattedValue, aF as FieldFormat, aG as CurrentFormat, aH as DateFormat, aI as DistanceFormat, aJ as EnergyUnit, aK as EnergyFormat, aL as CurrencyFormat, aM as NumberFormat, aN as PhoneFormat, aO as PowerFormat, aP as FormatterFunction, aQ as ResistanceFormat, aR as TemperatureFormat, aS as TemperatureUnitString, aT as TemperatureUnit, aU as TextFormat, aV as VoltageFormat, e as BaseDataPoint, $ as YFormatType, R as TooltipData, aW as CellComponentProps, aX as CellAlignment, aY as LinkBehavior, D as DeviceState, s as GridState, aZ as ComponentFormatter, a_ as DataTableProps, a$ as TableDensity, b0 as DataTablePagination, b1 as LayerSpec, b2 as CustomPinsSpec, b3 as GeoJsonLayerSpec, b4 as RasterLayerSpec, b5 as VectorLayerSpec, b6 as ClusteredVectorLayerSpec, b7 as ColorSpec } from './colors-C4MlTwKS.js';
+export { A as ABSENT_GRID_FIELDS, a as ActionItem, b8 as ActionMenu, b as ActionMenuProps, b9 as AppShell, c as AppShellProps, ba as Avatar, d as AvatarProps, bb as Badge, bc as BaseFormat, C as CATEGORY_COLOR_TOKENS, f as CATEGORY_NEUTRAL_COLOR, bd as CellComponent, be as CellContext, bf as ChartContext, g as ChartMargin, bg as CodeEditor, h as CodeEditorProps, i as CodeLanguage, j as CodeTheme, bh as ComponentFormatOptions, bi as CurrentUnit, bj as CustomFormat, bk as DEFAULT_MAP_TYPE, bl as DateFormatStyle, bm as DistanceUnit, bn as ENTITY_CATEGORY_CONFIG, E as ENTITY_CONFIG, k as EntityArchetype, bo as EntityCategory, bp as EntityCategoryConfig, l as EntityConfig, m as EntityStateRule, n as EntityType, bq as FacetType, br as FilterChip, bs as FilterCondition, bt as FilterGroup, bu as FilterOperator, G as GRID_ELEMENT_TYPE_BY_ENTITY, bv as GRID_STATE_COLORS, o as GRID_STAT_LIST, bw as GRID_STAT_LIST_CAPACITOR_PER_PHASE_KVAR, bx as GRID_STAT_LIST_CAPACITOR_TOTAL_KVAR, p as GridElementSourceType, q as GridStatField, r as GridStatFieldFormat, by as GridStateColor, H as HEADLINE_METRIC_BOUNDS, t as Heading, u as HeadlineMetric, bz as InteractiveMap, bA as InteractiveMapHandle, I as InteractiveMapProps, bB as LayerCheckState, bC as LayerFeature, bD as LayerSelection, bE as LayerStyle, bF as LayerTreeNode, bG as LayerVisibilityPatch, L as Loader, v as Logo, bH as MAP_TYPES, M as MapPoint, bI as MapType, bJ as Meter, w as MeterProps, x as MetricFormat, y as MetricSource, bK as MobileBreakpoint, bL as MobileConfig, bM as MobileRenderer, bN as PercentBarCell, bO as PercentBarCellProps, P as PercentThresholdLevel, z as PercentThresholds, bP as PercentageFormat, bQ as PowerUnit, bR as RenderType, bS as ResistanceUnit, S as SegmentOption, bT as SegmentedControl, F as SegmentedControlProps, J as SerializableFieldFormat, K as SideNav, N as SideNavItem, O as SideNavProps, bU as SortConfig, bV as SortDirection, bW as StackNav, bX as StackNavGroup, bY as StackNavItem, bZ as StackNavLinkComponentProps, b_ as StackNavProps, b$ as StackNavRenderRow, c0 as StackNavRowRenderProps, c1 as StackNavTheme, c2 as StaticMap, Q as StaticMapProps, c3 as TableLayout, c4 as TableWidth, T as TextLink, c5 as TextTransform, c6 as TextTruncatePosition, U as TooltipSeries, V as TopNav, W as TopNavProps, X as UNARY_FILTER_OPERATORS, Y as UNARY_OPERATOR_LABELS, c7 as UNVERIFIED_VOLTAGE_UNIT_ROWS, Z as UnaryFilterOperator, c8 as UseInfiniteScrollOptions, c9 as UseInfiniteScrollReturn, ca as VoltageUnit, _ as YFormatSettings, cb as ZoomStops, a0 as activeDeviceStates, cc as addFilterCondition, a1 as archetypeFor, cd as baselineFromPoint, a2 as clearColorCache, a3 as createCategoryColorMap, ce as createEmptyFilter, cf as createFilter, cg as createFilters, a4 as createXScale, a5 as createYScale, a6 as defaultMargin, a7 as deviceStateLabels, a8 as deviceStateMetricFormats, a9 as entityHasDetailPage, aa as entityHasStatList, ab as entityShowsNow, ch as filterToChips, ci as formatComponentValue, ac as getContrastingTextColor, ad as getDefaultChartColor, ae as getDefaultColors, af as getDeviceStateDisplayLabel, af as getDeviceStateLabel, cj as getEntityCategory, ag as getEntityConfig, ah as getEntityIcon, ai as getEntityLabel, aj as getEntityStatList, ck as getFilterFields, ak as getGridStateLabel, al as getResolvedColor, am as getThemeCategoricalColors, an as getYFormatSettings, ao as gridEntityTypeKeys, ap as gridStateLabels, aq as isActiveDeviceState, aq as isActiveState, cl as isFilterEmpty, ar as isGridEntityTypeKey, as as isLightColor, at as isUnaryFilterOperator, cm as mapValuesToCategoricalColors, cn as percentThresholdLevel, co as removeFilterCondition, cp as useChartContext, cq as useComponentFormatter, cr as useInfiniteScroll } from './colors-C4MlTwKS.js';
 import * as react_jsx_runtime from 'react/jsx-runtime';
 import * as React$1 from 'react';
 import React__default, { ReactNode, HTMLAttributes, ComponentProps, CSSProperties, Component, ErrorInfo } from 'react';
-import { I as Icon$1, S as Size, d as IconName$2, B as BaseInputProps } from './RichTextEditor-B_GaE_Yf.js';
-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-B_GaE_Yf.js';
+import { I as Icon$1, S as Size, d as IconName$2, B as BaseInputProps } from './RichTextEditor-tUSSVqwi.js';
+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-tUSSVqwi.js';
 import { D as DialogAction, a as DialogHeaderConfig, b as DialogFooterConfig } from './index-dofSwYId.js';
 export { c as Dialog, d as DialogForm, e as DialogProps, f as Drawer, g as DrawerForm, h as DrawerProps, F as FormActions, i as FormDivider, j as FormGrid, k as FormSection, l as FormStepper, S as SaveBar, U as UnsavedChangesPrompt, u as useWizard } from './index-dofSwYId.js';
-export { A as Autocomplete, B as Button, h as ButtonProps, C as Checkbox, a as CheckboxGroup, b as ColorField, i as ColorFieldProps, M as MultiSelect, j as MultiSelectMatcher, c as MultiSelectOption, k as MultiSelectProps, l as MultiSelectSelectionEntry, N as NumberField, m as Radio, n as RadioCard, R as RadioCardGroup, o as RadioCardGroupProps, p as RadioCardProps, d as RadioGroup, S as Select, q as SelectItem, e as Switch, T as TextArea, f as TextField, r as TimeField, s as defaultMultiSelectMatcher, t as filterMultiSelectOptions, u as multiSelectSearchKeys, v as multiSelectSelectionEntries, w as shouldOfferLiteralOption } from './TimeField-B6DyOZXU.js';
+export { A as Autocomplete, B as Button, h as ButtonProps, C as Checkbox, a as CheckboxGroup, b as ColorField, i as ColorFieldProps, M as MultiSelect, j as MultiSelectMatcher, c as MultiSelectOption, k as MultiSelectProps, l as MultiSelectSelectionEntry, N as NumberField, m as Radio, n as RadioCard, R as RadioCardGroup, o as RadioCardGroupProps, p as RadioCardProps, d as RadioGroup, S as Select, q as SelectItem, e as Switch, T as TextArea, f as TextField, r as TimeField, s as defaultMultiSelectMatcher, t as filterMultiSelectOptions, u as multiSelectSearchKeys, v as multiSelectSelectionEntries, w as shouldOfferLiteralOption } from './TimeField-CVfhh7Rc.js';
 import { ScaleTime, ScaleLinear, ScaleBand } from 'd3-scale';
 import { Icon } from '@phosphor-icons/react';
 import { Map } from 'mapbox-gl';
@@ -1275,6 +1275,8 @@ interface ContactMetaDisplayProps {
      * When provided, adds data-pii-* attributes for the Curtain extension
      */
     piiEntity?: string;
+    /** PII type of the primary label when an email stands in for a missing name. */
+    piiPrimaryTextType?: "full-name" | "email";
 }
 /**
  * ContactMetaDisplay
@@ -1311,7 +1313,7 @@ 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;
+declare function ContactMetaDisplay({ firstName, lastName, email, avatarUrl, layout, size, href, LinkComponent, linkVariant, emphasis, showEmail, badge, avatarShape, isLoading, className, piiEntity, piiPrimaryTextType, }: ContactMetaDisplayProps): react_jsx_runtime.JSX.Element;
 
 /**
  * ContainerQueryProvider — measures its own width via ResizeObserver and
@@ -2067,9 +2069,142 @@ declare const createFormat: <T extends FieldFormat["type"]>(type: T, options?: O
     type: T;
 }>;
 
+/** 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.
+ * `lines` carries additional named series (e.g. export/net flows) that
+ * stitch with the same dedup-by-timestamp semantics as `line`. */
+type TileData = {
+    line: BaseDataPoint[];
+    band?: BaseDataPoint[];
+    lines?: Record<string, BaseDataPoint[]>;
+};
+/** Injected loader: one tile = one bounded fetch. */
+type FetchTileContext = {
+    reason: "load" | "refresh";
+    /** Check before adapter side effects such as shared-cache writes. */
+    isCurrent?: () => boolean;
+};
+type FetchTile = (tier: Tier, startMs: number, endMs: number, signal: AbortSignal, context?: FetchTileContext) => Promise<TileData>;
+declare const tileKey: (tierId: string, index: number) => string;
+declare const hasTileData: (data?: TileData) => boolean;
+
+/**
+ * Pick the finest tier whose bucket is coarse enough to hit ~targetPointsPerPx
+ * across the chart and is not finer than the series' native cadence.
+ */
+declare function tierForViewport(spanMs: number, widthPx: number, ladder: ResolutionLadder, opts: {
+    targetPointsPerPx: number;
+    nativeMs: number;
+}): Tier;
+
+type TileStatus = "loading" | "loaded" | "empty" | "error";
+type TileEntry = {
+    status: TileStatus;
+    data?: TileData;
+    error?: Error;
+    refreshing?: boolean;
+    revision?: number;
+    revalidated?: boolean;
+};
+type TileStore = ReadonlyMap<string, TileEntry>;
+type TileAction = {
+    type: "request";
+    ids: string[];
+    refresh?: boolean;
+} | {
+    type: "cancel";
+    ids: string[];
+} | {
+    type: "fulfilled";
+    id: string;
+    data: TileData;
+    refresh?: boolean;
+} | {
+    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[];
+    lines: Record<string, 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;
+    prevViewport?: Viewport | null;
+    maxFutureMs?: number;
+};
+declare function assembleSeries({ viewport, targetTier, ladder, store, overscanTiles, prev, prevViewport, maxFutureMs, }: AssembleSeriesArgs): AssembledSeries;
+
+declare function tileIndexAt(tsMs: number, tier: Tier): number;
+declare function tilesForViewport(viewport: Viewport, tier: Tier, overscanTiles: number): TileRef[];
+
 type AreaSeriesBaseline = number | ((point: BaseDataPoint, index: number) => number);
 interface AreaSeriesProps {
-    data: BaseDataPoint[];
+    /**
+     * The points to draw.
+     *
+     * Optional ONLY inside a streaming chart, where the points do not exist until
+     * the reader looks at a window: there the child names its stream with
+     * `seriesKey` and the chart supplies `data` before this component renders. In
+     * an ordinary chart it is required in practice — a series with neither is
+     * skipped rather than drawn.
+     */
+    data?: BaseDataPoint[];
+    /**
+     * Which stream this series draws, in a chart with a streaming `source`.
+     *
+     * Defaults to `"line"`, the primary stream. Ignored entirely by a chart that
+     * holds its own data, so the same `<AreaSeries>` serves both sources.
+     */
+    seriesKey?: string;
+    /**
+     * Relabel this series once its points arrive, in a streaming chart.
+     *
+     * Declared here rather than only on the chart because the element carrying it
+     * is this one; the streaming branch reads it, resolves it against every
+     * assembled stream, and passes the result down as `label`. This component
+     * never calls it — by the time it renders, `label` is already the answer.
+     */
+    labelFromData?: (plotted: BaseDataPoint[], series: AssembledSeries) => string;
     color?: string;
     label?: string;
     categoryColors?: Record<string, string>;
@@ -2117,7 +2252,24 @@ interface AreaSeriesProps {
 declare const AreaSeries: React__default.FC<AreaSeriesProps>;
 
 interface BarSeriesProps {
-    data: BaseDataPoint[];
+    /**
+     * The points to draw.
+     *
+     * Optional ONLY inside a streaming chart, where the points do not exist until
+     * the reader looks at a window: there the child names its stream with
+     * `seriesKey` and the chart supplies `data` before this component renders. In
+     * an ordinary chart it is required in practice — a series with neither
+     * renders nothing rather than throwing.
+     */
+    data?: BaseDataPoint[];
+    /**
+     * Which stream this series draws, in a chart with a streaming `source`.
+     *
+     * Defaults to `"line"`, the primary stream — the same default `AreaSeries`
+     * and `LineSeries` use, so the same child serves both sources. Ignored
+     * entirely by a chart that holds its own data.
+     */
+    seriesKey?: string;
     color?: string;
     label?: string;
     opacity?: number;
@@ -2147,6 +2299,8 @@ interface CategoryBarChartProps {
     width?: number;
     /** Height of the chart (auto-resizes to container if not provided) */
     height?: number;
+    /** Scale the fixed coordinate system to the container width for static displays. Requires both width and height; otherwise uses normal responsive sizing. Disables tooltips when active. */
+    scaleToFit?: boolean;
     /** Margin around the chart area */
     margin?: {
         top: number;
@@ -2199,16 +2353,22 @@ interface AxisBottomProps {
     width: number;
 }
 interface AxisLeftProps {
+    /** Optional start-aligned label position relative to the axis. */
+    labelLeft?: number;
     left: number;
     scale: ScaleLinear<number, number>;
     yFormatter: YFormatType;
     height?: number;
 }
+/** Space for the widest formatted numeric tick plus its gap to the plot. */
+declare function getNumericAxisGutter(scale: ScaleLinear<number, number>, yFormatter: YFormatType, height?: number): number;
 interface CategoryAxisBottomProps {
     top: number;
     scale: ScaleBand<string>;
 }
 interface CategoryAxisLeftProps {
+    /** Label start relative to the axis; omitted preserves end-aligned ticks. */
+    labelLeft?: number;
     left: number;
     scale: ScaleBand<string>;
     /**
@@ -2320,6 +2480,15 @@ interface ChartBottomBarProps {
     isZoomed?: boolean;
     onResetZoom?: () => void;
     onLegendItemToggle?: (category: string) => void;
+    /**
+     * Drop the Export control, keeping the legend. Distinct from `hideBottomBar` on the engines,
+     * which removes both — a chart can want the legend and not the export affordance.
+     *
+     * Scoped to Export alone: it shares a row with Reset Zoom, which is not an export affordance and
+     * appears only while a chart IS zoomed. Hiding it alongside Export stranded the reader in a
+     * zoomed view with no way back.
+     */
+    hideExport?: boolean;
 }
 interface LegendItem {
     category: string;
@@ -2350,947 +2519,1605 @@ declare const LegendItem: React__default.FC<{
  */
 declare const ChartBottomBar: React__default.FC<ChartBottomBarProps>;
 
-interface ChartContainerProps {
-    children: React__default.ReactNode;
-    parentWidth: number;
-    parentHeight: number;
+/**
+ * Which plotted series the readout should inspect.
+ *
+ * ── Why a named kind and not a function ───────────────────────────────────────
+ * A streaming chart can be driven from stored JSON, and a render-prop is exactly
+ * what such a caller cannot hold. The set of things worth reading "latest data"
+ * out of is small and closed — a single plotted series, a net band plus its
+ * average line, or an import/export pair — so naming them costs nothing and buys
+ * the whole affordance for a declarative caller.
+ *
+ * `single` is the general case and the others are named for the shape they read,
+ * not for the domain that happens to use them: this file knows nothing about
+ * meters.
+ */
+type LatestDataReadoutKind = "single" | "band" | "pair";
+
+interface TiledTimeSeriesLiveControl {
+    label: string;
+    checked: boolean;
+    onChange: (checked: boolean) => void;
+    /** Healthy requires a delivered signal and current measurement evidence where available. */
+    status: "live" | "connecting" | "reconnecting" | "stale" | "delayed" | "refresh-failed";
+    disabledReason?: string | undefined;
+    /** Optional cadence context owned by the consumer, shown while waiting for an update. */
+    waitingDescription?: string | undefined;
+}
+
+/**
+ * Window size for data aggregation
+ * Matches GraphQL WindowSize enum, plus the telemetry-only rungs below it:
+ * FIVE_MINUTES and ONE_MINUTE are `TelemetryBucketSize` capabilities that no
+ * metrics query offers. ONE_MINUTE is served only by a power-quality sensor —
+ * meters report at 5m or coarser — so a chart offering it must say so with its
+ * own `windowSizeOptions` rather than relying on the defaults below.
+ */
+type WindowSize = "ONE_MINUTE" | "FIVE_MINUTES" | "FIFTEEN_MINUTES" | "HOUR" | "DAY" | "WEEK" | "MONTH" | "YEAR";
+/**
+ * Date range with native Date objects
+ */
+interface TimeRange {
+    after: Date;
+    before: Date;
+}
+/**
+ * Preset range option
+ */
+interface PresetRange {
+    id: string;
+    label: string;
+    getRange: () => TimeRange;
+}
+/**
+ * Window size option
+ */
+interface WindowSizeOption {
+    id: WindowSize;
+    label: string;
+}
+/**
+ * Props for TimeControls component
+ */
+interface TimeControlsProps {
     /**
-     * Accessible name for the chart, rendered as the SVG `<title>`. Required so
-     * that screen readers announce what each chart shows; every chart needs its
-     * own, and there is deliberately no default to fall back to.
+     * Current date range
      */
-    title: string;
+    dateRange: TimeRange;
     /**
-     * Y-axis formatter using the main formatting system
-     * Accepts ComponentFormatter types (string shorthand or full options)
-     * @example "energy", "currency", { type: "temperature", unit: "F" }
+     * Callback when date range changes. `meta.presetId` is set when the change
+     * came from choosing a preset (vs. the calendar picker).
      */
-    yFormatter?: YFormatType;
+    onDateRangeChange: (range: TimeRange, meta?: {
+        presetId?: string;
+    }) => void;
     /**
-     * Explicit y-axis domain `[min, max]`. Overrides the default behavior of
-     * anchoring the axis at zero for all-positive data. Use for deviation-style
-     * metrics (voltage ~240V, frequency ~60Hz, power factor ~1.0) where the
-     * signal is variation around a nominal value, not magnitude from zero.
+     * Current window size (optional)
      */
-    yDomain?: [number, number];
+    windowSize?: WindowSize;
     /**
-     * Horizontal reference lines drawn across the plot at fixed y-values — e.g.
-     * regulatory limits (ANSI voltage bounds), targets, or thresholds. Rendered
-     * as dashed lines with an optional right-aligned label.
+     * Callback when window size changes (optional)
      */
-    referenceLines?: {
-        value: number;
-        label?: string;
-        color?: string;
-    }[];
-    isLoading?: boolean;
-    /** Enable scroll-to-zoom and pan on main chart */
-    enableZoom?: boolean;
-    /** Show brush overview chart below */
-    enableBrush?: boolean;
-    /** Height of brush chart (default: 60px) */
-    brushHeight?: number;
+    onWindowSizeChange?: (size: WindowSize) => void;
     /**
-     * Notification callback when the zoom range changes.
-     *
-     * Fires on every transition, including the initial `null` render. Use this
-     * for one-way "observe the zoom" plumbing (e.g. driving an external panel
-     * showing the current window).
-     *
-     * In controlled-zoom mode (when the `zoomDomain` prop is provided), this is
-     * ALSO the change callback the parent uses to update its own state —
-     * mirroring the `onHiddenSeriesChange` pattern. The parent should treat the
-     * incoming `domain` argument as the next value to commit to its state.
+     * Whether to show window size selector
+     * @default true
      */
-    onZoomChange?: (domain: [Date, Date] | null) => void;
+    showWindowSize?: boolean;
     /**
-     * Controlled zoom domain. When provided, ChartContainer uses this value
-     * instead of its internal useState (controlled mode). Mirrors the
-     * `hiddenSeriesLabels` pattern — useful when an inline + dialog instance
-     * pair need to share zoom state (see BOLT-1160 Phase 3 / SiteEnergyCharts).
-     *
-     * Pass `null` for "full domain, no zoom". Omit entirely to use the default
-     * uncontrolled behaviour (ChartContainer manages its own zoom state).
-     *
-     * When controlled, the visx Zoom transform is kept in sync with the
-     * incoming prop via an internal effect, so brush + scroll-zoom + reset
-     * all continue to work — they just route the new domain through
-     * `onZoomChange` to the parent, which echoes it back via the prop.
+     * Auto-adjust window size based on date range
+     * @default false
      */
-    zoomDomain?: [Date, Date] | null;
+    autoAdjustWindowSize?: boolean;
     /**
-     * Controlled set of hidden series labels. When provided, ChartContainer
-     * uses this value instead of its internal useState (controlled mode).
-     * Omit to use the default uncontrolled behaviour.
+     * Whether to show range selector presets
+     * @default true
      */
-    hiddenSeriesLabels?: Set<string>;
+    showRangeSelector?: boolean;
     /**
-     * Called when the user toggles a legend item in controlled mode.
-     * Accepts either the next Set directly or a functional updater
-     * `(prev: Set<string>) => Set<string>` — the latter lets parents compose
-     * rapid sequential toggles correctly (each sees the latest prev rather than
-     * the stale render-closure value). Only called when `hiddenSeriesLabels`
-     * prop is provided.
-     */
-    onHiddenSeriesChange?: (updater: Set<string> | ((prev: Set<string>) => Set<string>)) => void;
-    /**
-     * Hide the bottom bar (legend + export button). Useful for small/embedded
-     * charts — e.g. inline sparklines — where the legend and export affordance
-     * add unwanted chrome. Defaults to false (bottom bar shown) to preserve
-     * existing behavior for all current consumers.
-     */
-    hideBottomBar?: boolean;
-    /** Trailing actions rendered in the `ChartHeader`, opposite the title. */
-    headerActions?: React__default.ReactNode;
-    /** Control cluster rendered in the `ChartHeader` — `TimeControls` today. */
-    headerControls?: React__default.ReactNode;
-}
-/**
- * Default plot-body height for a chart block, in px. Pairs with `CHART_HEADER_HEIGHT`.
- *
- * It lives here rather than in each block because four blocks had four private copies of `280`
- * that happened to agree, with nothing enforcing the agreement — a design change to chart height
- * was a four-file diff where three files could be forgotten and nothing failed. This is `P10 R-23`.
- *
- * A block that needs a different body height passes its own; this is the value it starts from.
- */
-declare const DEFAULT_CHART_HEIGHT = 280;
-/**
- * ChartContainer
- *
- * Main chart wrapper component that provides context and layout for chart visualizations.
- * Handles scaling, tooltips, axes, and data management for area, line, and bar charts.
- */
-declare const ChartContainer: React__default.FC<Omit<ChartContainerProps, "parentWidth" | "parentHeight"> & {
-    parentWidth?: number;
-    parentHeight?: number;
-}>;
-
-/**
- * Event marker type — shared by ChartEventMarkers and ChartEventSpans.
- */
-type EventMarkerType = "command" | "alert" | "info" | "success" | "warning" | "error";
-/**
- * Get the resolved color for a given event marker type.
- * Uses getResolvedColor to ensure CSS variables work in SVG context.
- */
-declare function getEventColor(type: EventMarkerType | undefined): string;
-
-/**
- * Event marker data point
- */
-interface EventMarker {
-    /**
-     * Event timestamp
+     * Whether to show calendar date picker button
+     * @default false
      */
-    timestamp: Date;
+    allowDatePicker?: boolean;
     /**
-     * Event label/name
+     * Whether window size is locked (read-only)
+     * @default false
      */
-    label: string;
+    lockWindowSize?: boolean;
     /**
-     * Optional event type for styling
+     * Whether to show the built-in Reset button beside the calendar picker. It
+     * returns to the first preset. Turn off in views that own their own reset
+     * with different semantics (e.g. pan/zoom explorers returning to the last
+     * explicit selection).
+     * @default true
      */
-    type?: EventMarkerType;
+    showReset?: boolean;
     /**
-     * Optional per-marker color override; takes precedence over the component-level color prop
+     * Restrict to single day selection (uses Calendar instead of RangeCalendar)
+     * @default false
      */
-    color?: string;
+    restrictToSingleDay?: boolean;
     /**
-     * Optional metadata to display in tooltip
+     * Available preset range options
      */
-    metadata?: Record<string, string | number>;
-}
-interface ChartEventMarkersProps {
+    presetRanges?: PresetRange[];
     /**
-     * Array of event markers to display
+     * Available window size options
      */
-    events: EventMarker[];
+    windowSizeOptions?: WindowSizeOption[];
     /**
-     * Marker color for every event that does not carry its own `color`
-     * (defaults to a theme-aware color per event `type`)
+     * Control size, matching the shared `Button` / `Select` scale.
+     *
+     * Defaults to `md`, which is what this component always rendered. `sm` exists
+     * for a caller placing these beside smaller controls — a chart header, where
+     * `md` here stood 39px next to 33px selects and read as a mismatch rather
+     * than a hierarchy.
      */
-    color?: string;
+    size?: "sm" | "md";
     /**
-     * Whether to show labels above markers
-     * @default false
+     * Additional CSS classes
      */
-    showLabels?: boolean;
+    className?: string;
 }
 /**
- * ChartEventMarkers
+ * TimeControls
  *
- * Renders vertical lines with markers for events (e.g., commands) on a chart.
- * Must be used as a child of ChartContainer to access chart context.
+ * Sophisticated time control component with responsive behavior and calendar integration.
+ * Features preset ranges, custom date picker, and window size selection.
+ *
+ * **Responsive Behavior:**
+ * - < 600px: Compact mode with Select dropdowns
+ * - ≥ 600px: Expanded mode with ToggleButton group for presets
  *
  * @example
  * ```tsx
- * <ChartContainer title="Device power">
- *   <AreaSeries data={data} label="Power" />
- *   <ChartEventMarkers
- *     events={[
- *       { timestamp: new Date('2024-01-01T10:00:00Z'), label: 'Command sent', type: 'command' },
- *       { timestamp: new Date('2024-01-01T12:00:00Z'), label: 'Alert triggered', type: 'alert' }
- *     ]}
- *   />
- * </ChartContainer>
+ * const [dateRange, setDateRange] = useState({
+ *   after: subDays(new Date(), 7),
+ *   before: new Date()
+ * });
+ * const [windowSize, setWindowSize] = useState<WindowSize>("HOUR");
+ *
+ * <TimeControls
+ *   dateRange={dateRange}
+ *   onDateRangeChange={setDateRange}
+ *   windowSize={windowSize}
+ *   onWindowSizeChange={setWindowSize}
+ *   presetRanges={presetRanges}
+ *   allowDatePicker
+ * />
  * ```
  */
-declare function ChartEventMarkers({ events, color, showLabels }: ChartEventMarkersProps): react_jsx_runtime.JSX.Element | null;
+declare function TimeControls({ dateRange, onDateRangeChange, windowSize, onWindowSizeChange, showWindowSize, showRangeSelector, allowDatePicker, lockWindowSize, showReset, restrictToSingleDay, presetRanges, windowSizeOptions, autoAdjustWindowSize, size, className, }: TimeControlsProps): react_jsx_runtime.JSX.Element;
 
+type ClassicPresetId = "day" | "week" | "month";
 /**
- * A time span to render as a translucent highlight band on a chart.
+ * The standard ladder for classic (non-tiled) charts. Labels are supplied by the
+ * caller rather than baked in, because consumers localize them — edges owns the
+ * ids and ranges, which is the part that was duplicated per chart and drifted.
  */
-interface EventSpan {
-    /** Start of the span */
-    start: Date;
-    /** End of the span */
-    end: Date;
-    /** Human-readable label shown in tooltip */
-    label: string;
-    /** Optional type for color coding */
-    type?: EventMarkerType;
-    /** Optional per-span color override; takes precedence over the component-level color prop */
-    color?: string;
-    /** Optional metadata to display in tooltip */
-    metadata?: Record<string, string | number>;
+declare function classicPresetRanges(labels: Record<ClassicPresetId, string>, getAnchorEndMs?: () => number): PresetRange[];
+/**
+ * The standard telemetry time-range ladder. `getAnchorEndMs` is called at press
+ * time, not build time, so a long-lived view jumps to a fresh "now" (or stays
+ * pinned to a scrubbed instant under time travel).
+ */
+declare function telemetryPresetRanges(getAnchorEndMs?: () => number): PresetRange[];
+
+type TiledCameraPreviewDomain = [number, number] | null;
+interface TiledCameraSyncGroup {
+    publish(source: object, preview: TiledCameraPreviewDomain): void;
+    subscribe(source: object, onPreview: (preview: TiledCameraPreviewDomain) => void): () => void;
 }
-interface ChartEventSpansProps {
+/**
+ * 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;
+}
+interface TiledTimeSeriesChartProps {
+    /** Drop the Export control while keeping the legend. See `ChartBottomBarProps.hideExport`. */
+    hideExport?: boolean;
     /**
-     * Array of event spans to render as translucent bands.
+     * Series labels the legend shows struck through and the plot omits. Controlled only — the
+     * caller owns the set, because the thing a reader toggles is usually a group of series (every
+     * signal on one phase) rather than the one label they clicked.
      */
-    spans: EventSpan[];
+    hiddenSeriesLabels?: ReadonlySet<string>;
+    /** Makes the legend clickable. Receives the label of the item pressed. */
+    onLegendItemToggle?: (label: string) => void;
     /**
-     * Override fill opacity (default 0.25). Hover state doubles this up to a cap.
+     * Legend entries to show INSTEAD of one per series.
+     *
+     * For a chart whose series are a cross-product the reader does not think in: three phases × three
+     * signals is nine lines, but the questions are "which phases?" and "which signals?" — six
+     * entries, not nine. The caller maps an entry back to the series it governs and answers with
+     * `hiddenSeriesLabels`, so this prop is presentation only; it never decides what is drawn.
+     */
+    legend?: {
+        category: string;
+        fill: string;
+        isHidden?: boolean;
+    }[];
+    /**
+     * Moments worth flagging on the time axis.
+     *
+     * `point` is the reading that caused the mark. Hovering shows that one value, not the series the
+     * plot happens to be drawing — the mark exists because of a single sample, and answering with
+     * five other numbers makes the reader hunt for the one that crossed. It is shown even when that
+     * series is hidden, since the mark is the only trace of it left on screen.
      */
-    opacity?: number;
+    xMarkers?: {
+        timeMs: number;
+        label: string;
+        color?: string;
+        point?: {
+            label: string;
+            value: number;
+        };
+    }[];
+    /** AreaSeries / LineSeries children. */
+    children: React__default.ReactNode;
     /**
-     * Override fill color for all spans (defaults to getEventColor(span.type)).
+     * Accessible name for the chart, rendered as the SVG `<title>`. Required so
+     * that screen readers announce what each chart shows; every chart needs its
+     * own, and there is deliberately no default to fall back to.
      */
-    color?: string;
+    title: string;
+    /** Trailing actions rendered in the `ChartHeader`, opposite the title. */
+    headerActions?: React__default.ReactNode;
+    /** Control cluster rendered in the `ChartHeader` — `TimeControls` today. */
+    headerControls?: React__default.ReactNode;
+    /** The camera. Drives the x-scale directly, decoupled from the data extent. */
+    viewport: TiledTimeSeriesChartViewport;
+    /** Optional clamp for pan gestures. New viewports stay within these bounds. */
+    panBounds?: TiledTimeSeriesChartViewport;
+    /** Resolve current pan bounds at gesture commit without updating the plotted viewport. */
+    getPanBounds?: (() => TiledTimeSeriesChartViewport) | undefined;
+    /** Committed once per settled gesture (drag/wheel), with the new ms viewport. */
+    onViewportChange: (viewport: TiledTimeSeriesChartViewport) => void;
+    /** Measured PLOT width (after margins), for level-of-detail / tile resolution. */
+    onPlotWidthChange?: (widthPx: number) => void;
+    yFormatter?: YFormatType;
+    /** Explicit bounds or a domain derived from visible geometry, including connected bracketing samples. */
+    yDomain?: [number, number] | ((data: BaseDataPoint[]) => [number, number]);
+    /** Horizontal reference lines (regulatory limits, thresholds). */
+    referenceLines?: {
+        value: number;
+        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;
 }
 /**
- * ChartEventSpans
- *
- * Renders translucent rectangular bands representing time spans (e.g., scheduled command windows)
- * on a chart. Must be used as a child of ChartContainer to access chart context.
- *
- * Renders BEFORE ChartEventMarkers so the vertical marker lines appear on top of the span bands.
+ * TiledTimeSeriesChart
  *
- * @example
- * ```tsx
- * <ChartContainer title="Device power">
- *   <LineSeries data={data} label="Power" />
- *   <ChartEventSpans
- *     spans={[
- *       { start: new Date('2024-01-01T12:00:00Z'), end: new Date('2024-01-01T14:00:00Z'), label: 'Scheduled window', type: 'command' }
- *     ]}
- *   />
- *   <ChartEventMarkers events={markers} />
- * </ChartContainer>
- * ```
+ * Camera-mode time-series chart for the meter telemetry explorer. A parent-owned
+ * `viewport` (ms) drives the x-scale directly — decoupled from the loaded data
+ * extent — and pan/zoom gestures commit a new viewport once per settled gesture.
+ * The data is assumed pre-bounded to the viewport (± overscan) upstream, so the
+ * series group is wrapped in a plot-area clip and series animation is disabled.
  */
-declare function ChartEventSpans({ spans, opacity, color }: ChartEventSpansProps): react_jsx_runtime.JSX.Element | null;
-
-/**
- * The height the header is assumed to claim before it has been measured, in px.
+declare const TiledTimeSeriesChart: React__default.FC<Omit<TiledTimeSeriesChartProps, "parentWidth" | "parentHeight"> & {
+    parentWidth?: number;
+    parentHeight?: number;
+}>;
+
+interface TiledTimeSeriesSource {
+    fetchTile: FetchTile;
+    ladder: ResolutionLadder;
+    nativeMs: number;
+    resetKey: string;
+    /** Revalidate visible tiles without discarding the plot. */
+    refreshKey?: string | undefined;
+    /** Cancel automatic refreshes while preserving manual navigation. */
+    refreshEnabled?: boolean | undefined;
+    tileCostSeriesCount: number;
+}
+interface TiledTimeSeriesView {
+    targetTierId: string;
+    renderedTierId: string | null;
+    viewport: {
+        startMs: number;
+        endMs: number;
+    };
+    followingLatest: boolean;
+    /** Relative Now navigation intent, independent of whether live updates are enabled. */
+    atLiveEdge?: boolean | undefined;
+}
+/**
+ * One additional plot drawn on this explorer's camera.
  *
- * This was once the whole story — a constant both engines subtracted from the
- * measured parent height. `TimeControls` ended that: it is `w-full flex-wrap`,
- * so a header hosting it is two rows at narrow widths and one row at wide ones.
- * No constant describes that, and a constant that disagrees with the render is
- * exactly the drift this component exists to remove.
+ * ── 🔴 Why panels rather than N explorers ────────────────────────────────────
+ * A stack of telemetry panels is ONE view of one node: the reader picks a
+ * window once and every metric answers for that window. N explorers would mean
+ * N control bars stacked down the page, each able to disagree with the others —
+ * a reader could put Voltage on last week and Current on today and have no
+ * indication the two plots no longer describe the same moment.
  *
- * It survives as the first-paint estimate. Without it the header reserves zero
- * until the observer fires and every chart on the page visibly reflows.
+ * So the camera, the controls, the resolution ladder and the reset button stay
+ * singular, and a panel contributes only its own stream and its own plot. This
+ * is the shape `TiledGridTelemetryView` already ships by hand in the Explore
+ * drawer; `panels` is that arrangement made reachable from a declaration.
+ *
+ * Each panel owns a separate `useTileWindow`, exactly as the drawer does — the
+ * streams have different cadences and different tile costs, and merging them
+ * into one window would make the coarsest metric dictate the resolution of the
+ * finest.
  */
-declare const CHART_HEADER_HEIGHT = 48;
+interface TiledTimeSeriesPanel {
+    /** Stable identity. Also the React key, so it must not be positional. */
+    key: string;
+    /** Accessible name for this plot's SVG `<title>`, and its heading. */
+    title: string;
+    /** Where this panel's points come from. Its own ladder and cost. */
+    source: TiledTimeSeriesSource;
+    yFormatter?: YFormatType | undefined;
+    yDomain?: TiledTimeSeriesChartProps["yDomain"] | undefined;
+    referenceLines?: {
+        value: number;
+        label?: string;
+        color?: string;
+    }[] | undefined;
+    /** Plot height in px. Panels are shorter than a lone chart by default. */
+    height?: number | undefined;
+    /** See `ChartBottomBarProps.hideExport`. Defaults to the explorer's own setting. */
+    hideExport?: boolean | undefined;
+    /** See `TiledTimeSeriesChartProps.legend`. A panel's legend is its own — it draws its own series. */
+    legend?: TiledTimeSeriesChartProps["legend"] | undefined;
+    /** See `TiledTimeSeriesChartProps.hiddenSeriesLabels`. */
+    hiddenSeriesLabels?: ReadonlySet<string> | undefined;
+    /** See `TiledTimeSeriesChartProps.onLegendItemToggle`. */
+    onLegendItemToggle?: ((label: string) => void) | undefined;
+    /** This panel's series children, given its own assembled streams. */
+    children: (args: {
+        series: AssembledSeries;
+        gapMs: number;
+    }) => ReactNode;
+}
+interface TiledTimeSeriesExplorerProps {
+    source: TiledTimeSeriesSource;
+    /** Accessible name for the chart. Forwarded to the underlying tiled chart's SVG `<title>`. */
+    title: string;
+    liveControl?: TiledTimeSeriesLiveControl | undefined;
+    initialRange?: {
+        days: number;
+    } | undefined;
+    viewportEnd?: Date | undefined;
+    yFormatter?: YFormatType | undefined;
+    yDomain?: TiledTimeSeriesChartProps["yDomain"] | undefined;
+    referenceLines?: {
+        value: number;
+        label?: string;
+        color?: string;
+    }[] | undefined;
+    emptyState: {
+        title: string;
+        description: string;
+    };
+    presetRanges?: PresetRange[] | undefined;
+    tierToWindow: Record<string, WindowSize>;
+    windowSizeOptions: WindowSizeOption[];
+    height?: number | undefined;
+    /**
+     * Fill the parent's height instead of the fixed `height`.
+     *
+     * For a caller that has already reserved a box — a block inside a card, a
+     * dashboard tile — where the fixed 360px plot PLUS this component's controls
+     * would overflow whatever was reserved. Uses the same `min-h-0 flex-1` the
+     * expanded view uses, so the plot takes what is left after the controls
+     * rather than adding to them.
+     */
+    fitParent?: boolean | undefined;
+    /** ReactNode, not just a string, so a caller can emphasise the gesture names inside it. */
+    hint?: ReactNode | undefined;
+    dataBounds?: {
+        startMs?: number;
+        endMs?: number;
+    } | undefined;
+    /** Reports committed camera/tier state, including while rendered tiles fall back. */
+    onViewChange?: ((view: TiledTimeSeriesView) => void) | undefined;
+    /** Advance unanchored views at Now. Historical navigation pauses following. */
+    followLatest?: boolean | undefined;
+    /** Change to explicitly resume a navigation-paused view at Now, preserving its span. */
+    followLatestKey?: string | number | undefined;
+    /** Metadata for the accepted plotted data and visible window, shared with expanded view.
+     * Render only; publish state through onViewChange instead. Series may include overscan.
+     * maxDataTimeMs is the inclusive fetch cutoff; viewport.endMs is exclusive. */
+    /**
+     * A built-in "latest data in view" readout, for callers that cannot pass a
+     * function.
+     *
+     * The declarative counterpart of `renderMetadata`: same slot, same rule,
+     * selected by name. A caller that can hold a function may keep using
+     * `renderMetadata`; one driven from stored JSON gets the affordance too.
+     * Passing both renders both, which is a caller error rather than something to
+     * silently resolve here.
+     */
+    latestDataReadout?: LatestDataReadoutKind | undefined;
+    /** Which streams `latestDataReadout` inspects, when its defaults do not fit. */
+    latestDataSeriesKeys?: string[] | undefined;
+    renderMetadata?: ((args: {
+        series: AssembledSeries;
+        viewport: {
+            startMs: number;
+            endMs: number;
+        };
+        maxDataTimeMs: number;
+    }) => ReactNode) | undefined;
+    children: (args: {
+        series: AssembledSeries;
+        gapMs: number;
+    }) => ReactNode;
+    /**
+     * Extra plots stacked below the primary one, on this same camera.
+     *
+     * Omit it and this is exactly the single-plot explorer it has always been —
+     * no sync group is created and nothing about the existing path changes. See
+     * {@link TiledTimeSeriesPanel}.
+     */
+    /** Drop the Export control while keeping the legend. See `ChartBottomBarProps.hideExport`. */
+    hideExport?: boolean | undefined;
+    /**
+     * Caller controls over what the plot draws, on their own row above the time controls.
+     *
+     * 🔴 Inside the explorer, not above it in the caller's own markup: the expanded view re-renders
+     * THIS component inside a dialog, so anything the caller renders as a sibling is left behind on
+     * the page and the control disappears exactly when the chart gets big enough to need it.
+     */
+    leadingControls?: ReactNode | undefined;
+    /**
+     * Caller controls that belong under the plot, right-aligned on the hint's row.
+     *
+     * Right rather than leading: the hint is prose and reads from the plot's left edge, and the
+     * control set varies per view — leading it, the sentence started at a different x every time
+     * the view changed.
+     */
+    trailingControls?: ReactNode | undefined;
+    /**
+     * Drop the "Window … · Resolution …" readout and the "no earlier data loaded" note, keeping the
+     * rest of that row — partial-coverage and refresh errors, which report something a reader cannot
+     * see for themselves. For a caller whose controls already state the window and the resolution.
+     */
+    hideWindowSummary?: boolean | undefined;
+    /**
+     * See `TiledTimeSeriesChartProps.xMarkers`. The function form is resolved against the assembled
+     * series, for markers that are a property of the data rather than of the caller's config.
+     */
+    xMarkers?: TiledTimeSeriesChartProps["xMarkers"] | ((series: AssembledSeries) => TiledTimeSeriesChartProps["xMarkers"]) | undefined;
+    /** See `TiledTimeSeriesChartProps.legend`. */
+    legend?: TiledTimeSeriesChartProps["legend"] | undefined;
+    /** See `TiledTimeSeriesChartProps.hiddenSeriesLabels`. */
+    hiddenSeriesLabels?: ReadonlySet<string> | undefined;
+    /** See `TiledTimeSeriesChartProps.onLegendItemToggle`. */
+    onLegendItemToggle?: ((label: string) => void) | undefined;
+    panels?: TiledTimeSeriesPanel[] | undefined;
+}
+declare function TiledTimeSeriesExplorer({ source, hideExport, hideWindowSummary, leadingControls, trailingControls, xMarkers, legend, hiddenSeriesLabels, onLegendItemToggle, title, liveControl, initialRange, viewportEnd, yFormatter, yDomain, referenceLines, emptyState, presetRanges, tierToWindow, windowSizeOptions, height, fitParent, hint, dataBounds, onViewChange, followLatest, followLatestKey, children, latestDataReadout, latestDataSeriesKeys, renderMetadata, panels, }: TiledTimeSeriesExplorerProps): react_jsx_runtime.JSX.Element;
+
 /**
- * Width of the enclosing `ChartHeader`, or `null` outside one / before it is
- * measured. See {@link ChartHeaderWidthContext}.
+ * JSON-safe recursive types.
+ *
+ * `source.ref` is serialized to storage — a BigInt, function, or cyclic
+ * reference there would throw at persist time, far from the block that caused
+ * it. These types enforce JSON-safety at the type level.
  */
-declare function useChartHeaderWidth(): number | null;
+type JsonValue = string | number | boolean | null | JsonValue[] | {
+    [key: string]: JsonValue;
+};
+type JsonObject = {
+    [key: string]: JsonValue;
+};
 /**
- * Marks a subtree as already carrying a visible label, so charts inside it do
- * not render their own title. Wrap the body of a titled section or card.
+ * WHERE a chart's data comes from.
+ *
+ * ── Why this union exists ─────────────────────────────────────────────────────
+ * A chart either holds its data or streams it. Until now those were two
+ * different COMPONENTS — `ChartContainer` for the first, `TiledTimeSeriesChart`
+ * for the second — which meant the choice was made when you picked an import,
+ * and a block (whose props must be JSON) could only ever reach the first.
+ *
+ * Loading strategy is not a kind of chart. It is a property OF one. So it moves
+ * into a prop, and the two cases become one component with two sources.
+ *
+ * Modelled on `MapDataSource` in `@texturehq/edges-blocks-maps`, which made the
+ * same call for geometry: `{ kind: "inline" } | { kind: "tileset" }`, with the
+ * fetching itself left to the runtime. One idea, two media.
+ *
+ * ── The serialization rule ────────────────────────────────────────────────────
+ * Everything here is JSON-safe on purpose, because that is what lets a BLOCK
+ * declare it: block props are stringified into `data-composition-schema`, and a
+ * function there blanks the page. So this union says WHICH series to draw and at
+ * what resolutions — never HOW to fetch them. The fetcher is supplied separately
+ * at the render site (see `ChartSourceResolver`), exactly as the maps blocks
+ * declare a tileset and let the host attach `createAuthenticatedTileTransform`.
  */
-declare function ChartLabelledBy({ children }: {
-    children: ReactNode;
-}): react_jsx_runtime.JSX.Element;
+type ChartSource = InlineChartSource | StreamingChartSource;
 /**
- * Marks a subtree as unlabelled, so charts inside it own their title. Use where
- * a chart stands on its own with no section or card heading above it.
+ * Data the caller already has. The default, and what every chart does today —
+ * series children carry their own `data` arrays.
+ *
+ * Declared explicitly (rather than inferred from the absence of a source) so a
+ * composition can say "inline" out loud, and so a schema can reject a block that
+ * sets both `series` and a streaming source.
  */
-declare function ChartOwnsItsTitle({ children }: {
-    children: ReactNode;
-}): react_jsx_runtime.JSX.Element;
+interface InlineChartSource {
+    kind: "inline";
+}
 /**
- * The height the header claims here, and the ref that establishes it.
+ * Data fetched as the reader moves through it.
  *
- * Both engines subtract `headerHeight` from the measured parent height before
- * sizing the plot, and pass `headerRef` to the `ChartHeader` they render. The
- * reserve is therefore the render, measured — not a second statement of it that
- * someone has to keep in agreement.
+ * The chart requests slices as the camera pans and re-requests at a coarser or
+ * finer resolution as it zooms. Which slices, and how they are cached, is the
+ * renderer's business — a caller describes the SHAPE of the history and nothing
+ * else.
  *
- * Returns 0 when the header will render nothing, so a chart that is already
- * labelled and has no slots filled loses no plot height to empty chrome.
+ * `ref` is the part a host resolves. It is deliberately opaque here: edges
+ * cannot know what a "meter demand series" is, and should not learn. The app
+ * maps it to a real fetcher (see `ChartSourceResolver`), which is what keeps
+ * this package free of GraphQL and any app dependency.
  */
-declare function useChartHeaderMetrics(hasActions: boolean, hasControls: boolean): {
-    headerRef: (node: HTMLDivElement | null) => void;
-    headerHeight: number;
-};
-/** Returns `true` when the chart should render its own visible title. */
-declare function useChartOwnsItsTitle(): boolean;
-interface ChartHeaderProps {
+interface StreamingChartSource {
+    kind: "streaming";
     /**
-     * The chart's title. Both engines pass the same string they render as the SVG
-     * `<title>`, so the accessible name and the visible heading cannot drift
-     * apart (ALL-2539). Shown only when nothing above already labels the chart.
+     * Opaque, serializable descriptor of WHICH series to stream — resolved by the
+     * host. In the dashboard this is a `Binding`; edges never inspects it.
      */
-    title: string;
+    ref: JsonObject;
     /**
-     * Control cluster — `TimeControls` today.
-     *
-     * Separate from `actions` because it is not a trailing icon: it is full-width
-     * and it wraps, which is the whole reason this header measures itself rather
-     * than reserving a constant.
+     * Resolutions this history can be drawn at, coarsest to finest, with the span
+     * of one fetched slice at each. Plain data — `[{ id: "1h", bucketMs, tileSpanMs }]`.
+     */
+    ladder: ResolutionLadder;
+    /**
+     * The finest spacing the underlying data actually has, in ms.
      *
-     * Belongs here when it governs exactly this chart. Controls that govern a
-     * composed panel stay at panel level: `SiteEnergyCharts` pairs them with a KPI
-     * strip and expands the whole body as one unit, `Dnp3TelemetryChartsSection`
-     * drives a grid of charts from one cluster, and `TiledTimeSeriesExplorer`
-     * swaps its chart for an `EmptyState` — moving those controls inside the chart
-     * would reorder them, or make them vanish exactly when the window needs
-     * changing.
+     * Optional because it is frequently NOT known up front: a source that probes
+     * its own cadence discovers this after its first response, and the renderer
+     * already handles it arriving late. Pass it when the value is known
+     * statically; otherwise let the resolver report it.
      */
-    controls?: ReactNode;
-    /** Trailing action slot — expand first, more later. */
-    actions?: ReactNode;
-    /** Measurement ref from `useChartHeaderMetrics`. */
-    containerRef?: (node: HTMLDivElement | null) => void;
+    nativeMs?: number;
+    /** The window to open on. Defaults to the last 30 days. */
+    initialRange?: {
+        days: number;
+    };
     /**
-     * Horizontal insets, in px. Both default to 0 and no engine passes them.
+     * The instant this chart is pinned to, as an ISO-8601 string.
      *
-     * They exist for a caller that genuinely needs the header indented, NOT for
-     * aligning with the plot. Both engines used to pass the plot's own
-     * `dynamicMargin.right` here, which put the expand action 8px in from the card
-     * edge while the title stayed flush left — a lopsided header, visible on every
-     * chart in the app. That margin is axis padding, so a point at the domain max
-     * does not sit on the plot border; it describes the PLOT, and the header is
-     * chrome that shares the card's edges with everything else in it.
+     * ── What it is ────────────────────────────────────────────────────────────
+     * Time travel. A surface showing a historical moment — Explore's scrubber,
+     * a match event under DER detection — pins every panel to the same instant,
+     * and this is how a streaming chart joins that. `initialRange` says how WIDE
+     * the opening window is; this says where its right edge sits. Panning and
+     * zooming stay unrestricted from there.
+     *
+     * ── 🔴 An anchored chart must not go live ─────────────────────────────────
+     * The two are mutually exclusive, and the failure is the quiet kind: a chart
+     * that kept refreshing while pinned would advance to now while the rest of
+     * the panel stayed in the past, so the page would show two different
+     * instants and look entirely normal doing it. The renderer already declines
+     * to follow when this is set (`canFollow`, `atLiveEdge`), and a host that
+     * offers a live control is expected to withhold it for the same reason.
+     *
+     * A STRING rather than a `Date`, because this declaration is stored: a board
+     * tile or a composition carries it as JSON, and `Date` does not survive that
+     * round trip. The renderer parses it once.
      */
-    marginLeft?: number;
-    marginRight?: number;
-}
-declare function ChartHeader({ title, controls, actions, containerRef, marginLeft, marginRight, }: ChartHeaderProps): react_jsx_runtime.JSX.Element | null;
-
-interface ExpandedSize {
-    width: number;
-    height: number;
-}
-interface ChartExpand {
-    isExpanded: boolean;
-    /** The expand control, for `ChartHeader`'s action slot. */
-    action: ReactNode;
+    viewportEnd?: string;
     /**
-     * Dimensions to render at. `null` inline, where the `withParentSize` HOC's
-     * own measurements apply.
+     * Changing this discards fetched data and starts over — use it when the
+     * IDENTITY of what is plotted changes (a different device, a different
+     * workspace). Panning and zooming do not need it.
      */
-    expandedSize: ExpandedSize | null;
-    /** Wraps the chart body: inline it passes through, expanded it opens a Dialog. */
-    present: (body: ReactNode) => ReactNode;
-}
-/** Marks a subtree whose expand is owned by an ancestor. */
-declare function ChartExpandOwnedByAncestor({ children }: {
-    children: ReactNode;
-}): react_jsx_runtime.JSX.Element;
-declare function useChartExpand(title: string): ChartExpand;
-
-interface ChartTooltipProps {
-    data: TooltipData | null;
-    formatter: YFormatType;
-    /** Optional label to display instead of formatting xValue (for categorical charts) */
-    label?: string;
-    /** Optional category labels override (for standalone usage without ChartContext) */
-    categoryLabels?: Record<string, string>;
+    resetKey?: string;
+    /**
+     * Changing this re-validates what is on screen WITHOUT clearing the plot, so
+     * a refresh does not blank the chart. Use it for live updates.
+     */
+    refreshKey?: string;
 }
 /**
- * ChartTooltip
+ * The runtime half of a streaming source: turns the serializable `ref` into
+ * something that can actually fetch.
  *
- * Interactive tooltip component for charts.
- * Displays formatted data values at hover position with automatic positioning and animations.
- * Uses the main formatting system for consistency with Kpi, StatList, and DataTable.
+ * This is a FUNCTION and therefore never a block prop. It is supplied once at
+ * the render site — a provider near the top of the app — so that every chart
+ * below it can stream without any of them importing a data client. Mirrors how
+ * the maps blocks declare a tileset in props while the host attaches tile
+ * authentication at the `<Map>` itself.
  *
- * Can be used standalone (with label prop) or within ChartContext (for time-series charts).
+ * Returning `null` means "I do not know this ref" — the chart then renders its
+ * empty state rather than throwing, which is the right behaviour for a board
+ * tile whose source is no longer registered.
  */
-declare const ChartTooltip: React__default.FC<ChartTooltipProps>;
-
-interface FunnelStage {
-    id: string;
-    /** Label for the stage (e.g., "Product Viewed") */
-    label: string;
-    /** Numeric value for this stage */
-    value: number;
-    /** Optional secondary value (e.g., "+12% MoM") */
-    secondaryValue?: string;
-    /** Optional annotation badge */
-    annotation?: string;
-    /** Override color for this stage */
-    color?: string;
-}
-interface FunnelSeriesProps {
-    /** Array of funnel stages ordered from top to bottom */
-    data: FunnelStage[];
-    /** Width of the chart */
-    width?: number;
-    /** Height of the chart */
-    height?: number;
-    /** Padding around the chart area */
-    padding?: number;
-    /** Gap between bars */
-    barGap?: number;
-    /** Format function for values */
-    formatValue?: (value: number) => string;
-    /** Format function for percentages */
-    formatPercentage?: (value: number) => string;
-    /** Single color to use for all bars (uses theme color if not provided) */
-    color?: string;
-    /** Show percentage scale on left */
-    showScale?: boolean;
-    /** Show overall conversion rate at top */
-    showOverallConversion?: boolean;
-    /** Label text for overall conversion (for internationalization) */
-    overallConversionLabel?: string;
-    /** Optional external active stage identifier */
-    activeStageId?: string | null;
-    /** Callback when a stage is clicked */
-    onStageClick?: (stage: FunnelStage) => void;
-    /** Callback when a stage is hovered */
-    onStageHover?: (stage: FunnelStage | null) => void;
-    /** Additional className */
-    className?: string;
-    /** Inline styles */
-    style?: React__default.CSSProperties;
-    /** Accessible label */
-    "aria-label"?: string;
-}
-declare const FunnelSeries: React__default.FC<FunnelSeriesProps>;
-
-interface LineSeriesProps {
-    data: BaseDataPoint[];
-    color?: string;
-    label?: string;
-    strokeWidth?: number;
-    /** CSS stroke-dasharray value (e.g. "4 2" for dotted, "8 4" for dashed) */
-    strokeDasharray?: string;
-    categoryColors?: Record<string, string>;
-    categoryLabels?: Record<string, string>;
-    /**
-     * When set, break the line wherever consecutive points are spaced more than
-     * this many ms apart (missing buckets / outages). Omit to connect across gaps.
-     */
-    maxGapMs?: number;
-    animate?: boolean;
-}
+type ChartSourceResolver = (source: StreamingChartSource) => ResolvedChartSource | null;
 /**
- * LineSeries
- *
- * Chart component for rendering line charts.
- * Displays data as a continuous line with customizable stroke width, color, and dash patterns.
- * When categoryColors are provided, contiguous line segments are colored by each segment
- * start point category while preserving tooltip and legend metadata from ChartContainer.
+ * What a resolver hands back: the fetcher, plus anything it learned about the
+ * data that the declaration could not state up front.
  */
-declare const LineSeries: React__default.FC<LineSeriesProps>;
-
-interface PieDataPoint {
-    /** Category label */
-    label: string;
-    /** Numeric value. Non-positive values take no arc — see `shareOf`. */
-    value: number;
-    /** Optional color override for this slice */
-    color?: string;
-}
-interface PieChartProps {
-    /** Array of data points with labels and values */
-    data: PieDataPoint[];
-    /** Width of the chart (auto-resizes to container if not provided) */
-    width?: number;
-    /** Height of the chart (auto-resizes to container if not provided) */
-    height?: number;
+interface ResolvedChartSource {
     /**
-     * Hole radius as a fraction of the outer radius. `0` (the default) is a pie;
-     * `0.6` is a donut. Values outside 0–0.95 are clamped.
+     * Fetches one slice. The renderer owns when and how often this is called.
+     *
+     * Typed structurally rather than as `FetchTile` so this file stays free of
+     * the tile vocabulary in its public surface; it is the same function.
      */
-    innerRadiusRatio?: number;
-    /** Formatter for slice values (uses the standard chart formatting system) */
-    yFormatter?: YFormatType;
-    /** Show the label/value/share legend beside the pie (default true) */
-    showLegend?: boolean;
-    /** Show tooltip on hover (default true) */
-    showTooltip?: boolean;
+    fetchSlice: FetchTile;
     /**
-     * Callback when a slice is clicked. Supplying it turns every slice into a
-     * focusable, named control that answers Enter and Space, and the drawing's
-     * role from `img` to `group` — an `img` hides the controls inside it.
+     * The finest real spacing of the data, if the resolver discovered it.
+     *
+     * 🔴 This is an OUTPUT, not an input, and that is load-bearing. A source that
+     * probes its own cadence only learns it after a response, and the renderer
+     * deliberately re-picks its resolution when this arrives late — without that,
+     * a chart stays pinned to the resolution its fallback guessed. Overrides
+     * `StreamingChartSource.nativeMs` when both are present.
      */
-    onSliceClick?: (dataPoint: PieDataPoint, index: number) => void;
-    /** Callback when a slice is hovered */
-    onSliceHover?: (dataPoint: PieDataPoint | null, index: number | null) => void;
-    /** Additional className */
-    className?: string;
-    /** Inline styles */
-    style?: React__default.CSSProperties;
+    nativeMs?: number;
     /**
-     * The chart's accessible name. Required, not optional-with-a-default, for the
-     * reason `CategoryBarChart` states: a default means every chart of this kind
-     * announces identically to a screen reader (ALL-2539, ALL-2715).
+     * How many backend series one slice costs, for the renderer's fetch budget.
+     * Defaults to the renderer's own default when omitted.
      */
-    "aria-label": string;
+    costSeriesCount?: number;
+    /**
+     * How many underlying REQUESTS one `fetchSlice` call issues. Defaults to 1.
+     *
+     * 🔴 Distinct from `costSeriesCount`, and the two answer different questions.
+     * That one is about volume — how much data a tier costs — and feeds the
+     * overscan guard inside a single chart's ladder. This one is about
+     * CONCURRENCY: how many requests hit the wire at once, which is what the
+     * page-wide ceiling counts.
+     *
+     * They come apart wherever a resolver merges several loaders into one slice.
+     * The grid cohort's role-split slice fetches net, consumption and generation
+     * — three requests, charged one permit unless it says so, and twelve such
+     * slices would then run 36 requests under a ceiling reporting 12.
+     *
+     * Only a resolver that fans out needs to set it; a slice that makes one
+     * request should leave it alone.
+     */
+    fetchesPerSlice?: number;
+    /**
+     * The Live/Static affordance, when this source can serve live updates.
+     *
+     * Omit it and no control renders at all — which is the correct reading of a
+     * meter that is not in the live pilot, rather than a disabled button whose
+     * reason nobody can act on.
+     */
+    liveControl?: TiledTimeSeriesLiveControl;
+    /**
+     * The reader's committed camera position, reported as it changes.
+     *
+     * This is the upward half of the loop: a host discovering the meter's real
+     * cadence needs to know which window is on screen and whether it is pinned to
+     * the live edge, because the answer decides what it may probe for and whether
+     * a refresh is even meaningful.
+     */
+    onViewChange?: (view: TiledTimeSeriesView) => void;
+    /** Keep an unanchored view advancing at Now. */
+    followLatest?: boolean;
+    /** Change to resume a navigation-paused view at Now, preserving its span. */
+    followLatestKey?: string | number;
+    /**
+     * Whether automatic refreshes may run at all.
+     *
+     * 🔴 Defaults to TRUE when omitted, which is why a host that offers a
+     * Live/Static control MUST set it. "Static" that still refreshes in the
+     * background is the quiet kind of wrong: the button reads paused, the data
+     * keeps moving, and nothing errors.
+     */
+    refreshEnabled?: boolean;
+    /**
+     * Re-validate what is on screen without clearing the plot.
+     *
+     * Overrides `StreamingChartSource.refreshKey` when present, because a live
+     * host derives this from a delivered signal rather than from the declaration.
+     */
+    refreshKey?: string;
 }
 /**
- * PieChart
- *
- * Part-of-whole mark for categorical data: one slice per category, sized by its
- * share of the total, with a legend carrying the value and the percentage. Pass
- * `innerRadiusRatio` for a donut.
+ * The same job as `ChartSourceResolver`, for sources that cannot be a function.
+ *
+ * ── Why this exists alongside the resolver ────────────────────────────────────
+ * A resolver is called from inside a `useMemo`, which means it may not call
+ * hooks. Most sources do not care. But a source that PROBES ITS OWN CADENCE
+ * does: discovering the finest real spacing of a meter's data takes a query,
+ * that query's result arrives after the first render, and `nativeMs` therefore
+ * has to be able to change over the life of the chart. In the dashboard that
+ * logic is already a hook (`useMeterUsageTileSource`) and is several hundred
+ * lines of Apollo queries, abort handling and settle-state — none of which can
+ * be flattened into a synchronous call, and none of which should be rewritten
+ * to satisfy a type.
+ *
+ * So a host is a COMPONENT rather than a function. It renders, which is exactly
+ * what buys it the right to hold hooks, and it hands back what it resolved
+ * through a child function. The chart does not care which half of the contract
+ * answered it.
+ *
+ * 🔴 This is a COMPONENT TYPE. `StreamingChart` renders it as `<Host …>`, and
+ * that is load-bearing rather than stylistic: a host invoked as a plain function
+ * would have its hooks counted against the CALLER's hook list, and since a host
+ * is optional that list would change length whenever one is installed or
+ * removed. Holding hooks is the whole job here, so the host must own a fiber.
+ * Do not "simplify" the render back into a call.
+ *
+ * 🔴 The two "no answer yet" cases are signalled DIFFERENTLY, and conflating
+ * them is a real bug:
+ *   - **still resolving** → render nothing (return `null`) WITHOUT calling
+ *     `children`. The chart keeps its own loading state.
+ *   - **not my ref** → call `children(null)`. The chart falls through to any
+ *     plain resolver installed alongside, then to its empty state.
+ *
+ * A probing source that used `children(null)` for "still resolving" would flash
+ * "No data source" for the length of its first query before drawing.
+ */
+type ChartSourceHost = (props: {
+    source: StreamingChartSource;
+    children: (resolved: ResolvedChartSource | null) => React$1.ReactNode;
+}) => React$1.ReactNode;
+/** Narrowing helper — a source that streams rather than carrying its data. */
+declare function isStreamingSource(source: ChartSource | undefined): source is StreamingChartSource;
+/**
+ * One ISO-8601 instant, or `null`.
+ *
+ * ── 🔴 Why `Date.parse` alone is not enough ───────────────────────────────────
+ * Three of its behaviours are wrong for a STORED anchor, and all three fail
+ * quietly:
+ *
+ *   - **A missing timezone is read as the VIEWER's.** `"2026-09-01T12:00:00"`
+ *     parses to a different real instant in every timezone, so one saved
+ *     composition anchors two readers to two different moments — and each sees
+ *     a chart that looks entirely correct.
+ *   - **Impossible dates are normalised.** `"2026-02-30"` silently becomes
+ *     March 2 rather than failing.
+ *   - **Non-ISO strings are accepted.** `"March 1 2026"` parses fine, so a
+ *     declaration can drift from the format the contract promises.
+ *
+ * An absolute instant has to be unambiguous, so this requires an explicit `Z`
+ * or numeric offset and rejects anything the calendar does not contain. Shared
+ * by the renderer, the block schema and the host so all three agree on what
+ * counts as an anchor — a value one accepted and another rejected would pin the
+ * chart while leaving live mode on, which is the worst of both.
+ */
+declare function parseInstant(value: unknown): Date | null;
+
+interface StreamingChartProps {
+    source: StreamingChartSource;
+    title: string;
+    children: ReactNode;
+    yFormatter?: React.ComponentProps<typeof TiledTimeSeriesExplorer>["yFormatter"];
+    yDomain?: React.ComponentProps<typeof TiledTimeSeriesExplorer>["yDomain"];
+    referenceLines?: React.ComponentProps<typeof TiledTimeSeriesExplorer>["referenceLines"];
+    headerActions?: ReactNode;
+    height?: number;
+    hint?: string;
+    emptyState?: {
+        title: string;
+        description: string;
+    };
+    tierToWindow?: React.ComponentProps<typeof TiledTimeSeriesExplorer>["tierToWindow"];
+    windowSizeOptions?: React.ComponentProps<typeof TiledTimeSeriesExplorer>["windowSizeOptions"];
+    presetRanges?: React.ComponentProps<typeof TiledTimeSeriesExplorer>["presetRanges"];
+    /** Built-in "latest data in view" readout, selected by name. */
+    latestDataReadout?: React.ComponentProps<typeof TiledTimeSeriesExplorer>["latestDataReadout"];
+    /** Which streams that readout inspects, when the defaults do not fit. */
+    latestDataSeriesKeys?: string[];
+    /**
+     * Extra plots stacked below this one, sharing its camera and its controls.
+     *
+     * Each declares its OWN streaming source — a different ref, a different
+     * ladder, its own cost — and each resolves through the same host, because a
+     * stack of telemetry panels is several streams of one node rather than
+     * several series of one stream.
+     *
+     * Omit it and this is the single-plot chart it has always been.
+     */
+    panels?: StreamingChartPanel[];
+}
+/**
+ * One extra plot in a streaming stack, declared the same way the primary is.
  *
- * Input order is preserved — slices are not re-sorted by value, so a producer
- * that ordered its categories deliberately (severity, lifecycle stage) keeps
- * that order.
+ * `children` is the same `seriesKey`-naming form the primary takes, for the
+ * same reason: a block carries JSON, so a panel names its streams rather than
+ * holding a render-prop.
  *
- * @example
- * ```tsx
- * <PieChart
- *   data={[
- *     { label: "Online", value: 127 },
- *     { label: "Offline", value: 23 },
- *   ]}
- *   aria-label="Devices by status"
- * />
- * ```
+ * Module-private: callers reach this shape through
+ * `ChartContainer`'s `streaming.panels`, which derives it from
+ * `ComponentProps<typeof StreamingChart>`. An exported name nothing imports is
+ * what knip fails CI on, and the derivation means there is nothing to import.
  */
-declare const PieChart: React__default.FC<PieChartProps>;
-
-type TiledCameraPreviewDomain = [number, number] | null;
-interface TiledCameraSyncGroup {
-    publish(source: object, preview: TiledCameraPreviewDomain): void;
-    subscribe(source: object, onPreview: (preview: TiledCameraPreviewDomain) => void): () => void;
+interface StreamingChartPanel {
+    key: string;
+    title: string;
+    source: StreamingChartSource;
+    children: ReactNode;
+    yFormatter?: React.ComponentProps<typeof TiledTimeSeriesExplorer>["yFormatter"];
+    yDomain?: React.ComponentProps<typeof TiledTimeSeriesExplorer>["yDomain"];
+    referenceLines?: React.ComponentProps<typeof TiledTimeSeriesExplorer>["referenceLines"];
+    height?: number;
 }
 /**
- * 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.
+ * Draws a chart whose data streams in as the reader moves through it.
+ *
+ * ── What this is, and what it is not ──────────────────────────────────────────
+ * This is the streaming BRANCH of `ChartContainer`, not a component callers
+ * reach for directly. `ChartContainer` picks it when handed a streaming source,
+ * which is the whole point: the choice of loading strategy stops being a choice
+ * of import.
+ *
+ * It delegates to `TiledTimeSeriesExplorer` rather than reimplementing it. That
+ * engine already owns the camera, the resolution ladder, the fetch budget and
+ * the slice cache, and all of that is correct — the problem was never its
+ * behaviour, only that it was reachable by one import and not by a prop. So this
+ * file is an adapter, deliberately thin, and the convergence of the two render
+ * engines is a later step that this one does not prejudge.
+ *
+ * ── The one translation it performs ───────────────────────────────────────────
+ * The explorer takes a render-prop (`{series} => ReactNode`) — a function, which
+ * is exactly what a block cannot express. So series children name their stream
+ * with `seriesKey` and this clones them with the resolved points. Declarative in,
+ * render-prop out, with the function living here instead of at every call site.
  */
-declare function createTiledCameraSyncGroup(): TiledCameraSyncGroup;
+declare function StreamingChart(props: StreamingChartProps): react_jsx_runtime.JSX.Element;
 
-interface TiledTimeSeriesChartViewport {
-    startMs: number;
-    endMs: number;
-}
-interface TiledTimeSeriesChartProps {
-    /** AreaSeries / LineSeries children. */
+interface ChartContainerProps {
     children: React__default.ReactNode;
+    parentWidth: number;
+    parentHeight: number;
     /**
      * Accessible name for the chart, rendered as the SVG `<title>`. Required so
      * that screen readers announce what each chart shows; every chart needs its
      * own, and there is deliberately no default to fall back to.
      */
     title: string;
-    /** Trailing actions rendered in the `ChartHeader`, opposite the title. */
-    headerActions?: React__default.ReactNode;
-    /** Control cluster rendered in the `ChartHeader` — `TimeControls` today. */
-    headerControls?: React__default.ReactNode;
-    /** The camera. Drives the x-scale directly, decoupled from the data extent. */
-    viewport: TiledTimeSeriesChartViewport;
-    /** Optional clamp for pan gestures. New viewports stay within these bounds. */
-    panBounds?: TiledTimeSeriesChartViewport;
-    /** Resolve current pan bounds at gesture commit without updating the plotted viewport. */
-    getPanBounds?: (() => TiledTimeSeriesChartViewport) | undefined;
-    /** Committed once per settled gesture (drag/wheel), with the new ms viewport. */
-    onViewportChange: (viewport: TiledTimeSeriesChartViewport) => void;
-    /** Measured PLOT width (after margins), for level-of-detail / tile resolution. */
-    onPlotWidthChange?: (widthPx: number) => void;
+    /**
+     * Y-axis formatter using the main formatting system
+     * Accepts ComponentFormatter types (string shorthand or full options)
+     * @example "energy", "currency", { type: "temperature", unit: "F" }
+     */
     yFormatter?: YFormatType;
-    /** Explicit bounds or a domain derived from visible geometry, including connected bracketing samples. */
-    yDomain?: [number, number] | ((data: BaseDataPoint[]) => [number, number]);
-    /** Horizontal reference lines (regulatory limits, thresholds). */
+    /**
+     * Explicit y-axis domain `[min, max]`. Overrides the default behavior of
+     * anchoring the axis at zero for all-positive data. Use for deviation-style
+     * metrics (voltage ~240V, frequency ~60Hz, power factor ~1.0) where the
+     * signal is variation around a nominal value, not magnitude from zero.
+     */
+    yDomain?: [number, number];
+    /**
+     * Horizontal reference lines drawn across the plot at fixed y-values — e.g.
+     * regulatory limits (ANSI voltage bounds), targets, or thresholds. Rendered
+     * as dashed lines with an optional right-aligned label.
+     */
     referenceLines?: {
         value: number;
         label?: string;
         color?: string;
     }[];
+    isLoading?: boolean;
+    /** Enable scroll-to-zoom and pan on main chart */
+    enableZoom?: boolean;
+    /** Show brush overview chart below */
+    enableBrush?: boolean;
+    /** Height of brush chart (default: 60px) */
+    brushHeight?: number;
     /**
-     * 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`.
+     * Notification callback when the zoom range changes.
+     *
+     * Fires on every transition, including the initial `null` render. Use this
+     * for one-way "observe the zoom" plumbing (e.g. driving an external panel
+     * showing the current window).
+     *
+     * In controlled-zoom mode (when the `zoomDomain` prop is provided), this is
+     * ALSO the change callback the parent uses to update its own state —
+     * mirroring the `onHiddenSeriesChange` pattern. The parent should treat the
+     * incoming `domain` argument as the next value to commit to its state.
      */
-    cameraSync?: TiledCameraSyncGroup;
-    parentWidth?: number;
-    parentHeight?: number;
-}
-/**
- * TiledTimeSeriesChart
- *
- * Camera-mode time-series chart for the meter telemetry explorer. A parent-owned
- * `viewport` (ms) drives the x-scale directly — decoupled from the loaded data
- * extent — and pan/zoom gestures commit a new viewport once per settled gesture.
- * The data is assumed pre-bounded to the viewport (± overscan) upstream, so the
- * series group is wrapped in a plot-area clip and series animation is disabled.
- */
-declare const TiledTimeSeriesChart: React__default.FC<Omit<TiledTimeSeriesChartProps, "parentWidth" | "parentHeight"> & {
-    parentWidth?: number;
-    parentHeight?: number;
-}>;
-
-interface TiledTimeSeriesLiveControl {
-    label: string;
-    checked: boolean;
-    onChange: (checked: boolean) => void;
-    /** Healthy requires a delivered signal and current measurement evidence where available. */
-    status: "live" | "connecting" | "reconnecting" | "stale" | "delayed" | "refresh-failed";
-    disabledReason?: string | undefined;
-    /** Optional cadence context owned by the consumer, shown while waiting for an update. */
-    waitingDescription?: string | undefined;
-}
-
-/** 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.
- * `lines` carries additional named series (e.g. export/net flows) that
- * stitch with the same dedup-by-timestamp semantics as `line`. */
-type TileData = {
-    line: BaseDataPoint[];
-    band?: BaseDataPoint[];
-    lines?: Record<string, BaseDataPoint[]>;
-};
-/** Injected loader: one tile = one bounded fetch. */
-type FetchTileContext = {
-    reason: "load" | "refresh";
-    /** Check before adapter side effects such as shared-cache writes. */
-    isCurrent?: () => boolean;
-};
-type FetchTile = (tier: Tier, startMs: number, endMs: number, signal: AbortSignal, context?: FetchTileContext) => Promise<TileData>;
-declare const tileKey: (tierId: string, index: number) => string;
-declare const hasTileData: (data?: TileData) => boolean;
-
+    onZoomChange?: (domain: [Date, Date] | null) => void;
+    /**
+     * Controlled zoom domain. When provided, ChartContainer uses this value
+     * instead of its internal useState (controlled mode). Mirrors the
+     * `hiddenSeriesLabels` pattern — useful when an inline + dialog instance
+     * pair need to share zoom state (see BOLT-1160 Phase 3 / SiteEnergyCharts).
+     *
+     * Pass `null` for "full domain, no zoom". Omit entirely to use the default
+     * uncontrolled behaviour (ChartContainer manages its own zoom state).
+     *
+     * When controlled, the visx Zoom transform is kept in sync with the
+     * incoming prop via an internal effect, so brush + scroll-zoom + reset
+     * all continue to work — they just route the new domain through
+     * `onZoomChange` to the parent, which echoes it back via the prop.
+     */
+    zoomDomain?: [Date, Date] | null;
+    /**
+     * Controlled set of hidden series labels. When provided, ChartContainer
+     * uses this value instead of its internal useState (controlled mode).
+     * Omit to use the default uncontrolled behaviour.
+     */
+    hiddenSeriesLabels?: Set<string>;
+    /**
+     * Called when the user toggles a legend item in controlled mode.
+     * Accepts either the next Set directly or a functional updater
+     * `(prev: Set<string>) => Set<string>` — the latter lets parents compose
+     * rapid sequential toggles correctly (each sees the latest prev rather than
+     * the stale render-closure value). Only called when `hiddenSeriesLabels`
+     * prop is provided.
+     */
+    onHiddenSeriesChange?: (updater: Set<string> | ((prev: Set<string>) => Set<string>)) => void;
+    /**
+     * Hide the bottom bar (legend + export button). Useful for small/embedded
+     * charts — e.g. inline sparklines — where the legend and export affordance
+     * add unwanted chrome. Defaults to false (bottom bar shown) to preserve
+     * existing behavior for all current consumers.
+     */
+    hideBottomBar?: boolean;
+    /** Trailing actions rendered in the `ChartHeader`, opposite the title. */
+    headerActions?: React__default.ReactNode;
+    /** Control cluster rendered in the `ChartHeader` — `TimeControls` today. */
+    headerControls?: React__default.ReactNode;
+}
 /**
- * Pick the finest tier whose bucket is coarse enough to hit ~targetPointsPerPx
- * across the chart and is not finer than the series' native cadence.
+ * Default plot-body height for a chart block, in px. Pairs with `CHART_HEADER_HEIGHT`.
+ *
+ * It lives here rather than in each block because four blocks had four private copies of `280`
+ * that happened to agree, with nothing enforcing the agreement — a design change to chart height
+ * was a four-file diff where three files could be forgotten and nothing failed. This is `P10 R-23`.
+ *
+ * A block that needs a different body height passes its own; this is the value it starts from.
  */
-declare function tierForViewport(spanMs: number, widthPx: number, ladder: ResolutionLadder, opts: {
-    targetPointsPerPx: number;
-    nativeMs: number;
-}): Tier;
-
-type TileStatus = "loading" | "loaded" | "empty" | "error";
-type TileEntry = {
-    status: TileStatus;
-    data?: TileData;
-    error?: Error;
-    refreshing?: boolean;
-    revision?: number;
-    revalidated?: boolean;
-};
-type TileStore = ReadonlyMap<string, TileEntry>;
-type TileAction = {
-    type: "request";
-    ids: string[];
-    refresh?: boolean;
-} | {
-    type: "cancel";
-    ids: string[];
-} | {
-    type: "fulfilled";
-    id: string;
-    data: TileData;
-    refresh?: boolean;
-} | {
-    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[];
-    lines: Record<string, BaseDataPoint[]>;
-    renderTier: Tier | null;
-    targetTier: Tier;
-    isFallback: boolean;
-    isStale: boolean;
-    coverage: Coverage;
+declare const DEFAULT_CHART_HEIGHT = 280;
+type ChartContainerWithSourceProps = Omit<ChartContainerProps, "parentWidth" | "parentHeight" | "yDomain"> & {
+    parentWidth?: number;
+    parentHeight?: number;
+    /**
+     * Explicit y-axis domain — a fixed `[min, max]`, or, while STREAMING, a
+     * function of the points currently loaded.
+     *
+     * ── 🔴 Why streaming needs the callback form ──────────────────────────────
+     * A fed chart's caller knows every value it is about to draw, so a tuple is
+     * a complete answer. A streaming chart's caller knows NONE of them: its
+     * points do not exist until the reader looks at a window. A tuple computed
+     * from what the declaration could see — thresholds and bounds, since
+     * `series` is empty by construction — is then treated as authoritative by
+     * `TiledTimeSeriesChart`, and every fetched value outside it is clipped to
+     * the plot edge rather than widening the axis.
+     *
+     * That failure is the quiet kind: the chart draws, the threshold line sits
+     * where it should, and an overload above it is simply not visible. Which is
+     * the exact reading a threshold exists to prevent.
+     *
+     * `TiledTimeSeriesChart` has always accepted the callback; only this type
+     * kept it out of reach. The fed engine below still takes the tuple alone —
+     * see the guard in `ChartContainer` — because its own scaling already sees
+     * all of the data.
+     */
+    yDomain?: [number, number] | ((data: BaseDataPoint[]) => [number, number]);
+    /**
+     * Where the data comes from. Omit it — or pass `{ kind: "inline" }` — and this
+     * is the chart it has always been, drawing the `data` its series children
+     * carry. Pass a streaming source and the same children instead name which
+     * stream each draws, and the chart fetches history as the reader moves.
+     *
+     * See `ChartSource`. The declaration is JSON, so a BLOCK can carry it; the
+     * fetcher comes from `ChartSourceProvider` at the render site.
+     */
+    source?: ChartSource;
+    /**
+     * Chart configuration that only means anything while streaming.
+     *
+     * ── 🔴 Why these are grouped rather than flattened ────────────────────────────
+     * A resolution ladder, a window-size picker and a preset list describe a chart
+     * that GOES AND GETS more data as you move. A fed chart has one window — the
+     * one its caller handed it — so on the inline path these props have no
+     * meaning at all, not merely no effect. Hoisting them onto
+     * `ChartContainerProps` would put six inert options on every chart in the
+     * platform and invite exactly the bug this grouping prevents: setting
+     * `windowSizeOptions` on a fed chart and wondering why the picker never
+     * appears.
+     *
+     * Grouping also keeps the split honest in the other direction. `hint` and
+     * `height` DO have inline meanings elsewhere in the codebase (a block's
+     * caption, a reserved box), and flattening them here would silently overload
+     * one name with two behaviours depending on a sibling prop. Under `streaming`
+     * they are unambiguous: `streaming.hint` is the explorer's how-to-drive line,
+     * `streaming.height` is the explorer's plot height.
+     *
+     * Everything here is JSON-safe, so a block can declare it — which is the
+     * point. Without it a streaming block draws with a generic window ladder and
+     * no meaningful presets: a chart that renders, looks plausible, and is wrong
+     * at exactly the zoom levels people use.
+     */
+    streaming?: StreamingChartConfig;
 };
-type AssembleSeriesArgs = {
-    viewport: Viewport;
-    targetTier: Tier;
-    ladder: ResolutionLadder;
-    store: TileStore;
-    overscanTiles: number;
-    prev?: AssembledSeries | null;
-    prevViewport?: Viewport | null;
-    maxFutureMs?: number;
+/**
+ * The streaming-only half of a chart's configuration.
+ *
+ * Every field is optional and JSON-safe. `StreamingChart` already accepts all
+ * of them; this type is what lets a caller — and therefore a block — express
+ * them through `ChartContainer` rather than by importing the tiled engine
+ * directly.
+ */
+type StreamingChartConfig = {
+    /** Which window size each resolution tier maps to, e.g. `{ "5m": "FIVE_MINUTES" }`. */
+    tierToWindow?: React__default.ComponentProps<typeof StreamingChart>["tierToWindow"];
+    /** The window sizes offered in the picker, in ladder order. */
+    windowSizeOptions?: React__default.ComponentProps<typeof StreamingChart>["windowSizeOptions"];
+    /** Jump-to-window presets, e.g. Last 24 hours / Last 7 days. */
+    presetRanges?: React__default.ComponentProps<typeof StreamingChart>["presetRanges"];
+    /**
+     * How to DRIVE the chart, shown under the plot — panning, zooming, presets.
+     * Distinct from a block's `description`, which says what is plotted.
+     */
+    hint?: string;
+    /** Shown when the source returns no readings for the visible window. */
+    emptyState?: {
+        title: string;
+        description: string;
+    };
+    /**
+     * Plot height in px. Omit to fill the box the caller reserved, which is what
+     * a block inside a card wants; see the `fitParent` note in `StreamingChart`.
+     */
+    height?: number;
+    /**
+     * Show a built-in "latest data in view" readout beside the resolution line.
+     *
+     * Named rather than rendered, so a chart driven from stored JSON can have it:
+     * `single` reads the primary stream, `band` a net band plus its average line,
+     * `pair` an import/export pair.
+     */
+    latestDataReadout?: React__default.ComponentProps<typeof StreamingChart>["latestDataReadout"];
+    /** Which streams that readout inspects, when the per-kind defaults do not fit. */
+    latestDataSeriesKeys?: string[];
+    /**
+     * Extra plots stacked below this chart, on its camera and its controls.
+     *
+     * For a view that is several streams of ONE thing — a node's SCADA metric
+     * groups, say — where the reader picks a window once and every metric answers
+     * for that window. Each panel names its own source and its own series; the
+     * window, presets, resolution and reset stay singular above them.
+     *
+     * Streaming only, like everything else in this group: a fed chart has one
+     * window handed to it, so there is no shared camera for panels to share.
+     */
+    panels?: React__default.ComponentProps<typeof StreamingChart>["panels"];
 };
-declare function assembleSeries({ viewport, targetTier, ladder, store, overscanTiles, prev, prevViewport, maxFutureMs, }: AssembleSeriesArgs): AssembledSeries;
-
-declare function tileIndexAt(tsMs: number, tier: Tier): number;
-declare function tilesForViewport(viewport: Viewport, tier: Tier, overscanTiles: number): TileRef[];
+/**
+ * Main chart wrapper. Provides context and layout for chart visualizations, and
+ * — since the `source` prop — owns the choice between holding data and
+ * streaming it.
+ *
+ * ── 🔴 Why the streaming branch is a sibling, not a mode ──────────────────────
+ * `VisXChartContainer` below reads `child.props.data` synchronously while it
+ * renders, and its whole 1,300 lines are built on the data already being there.
+ * Threading async loading THROUGH that would put every chart in the platform on
+ * a changed code path to serve the few that stream — and the failure that
+ * invites is the quiet kind: charts still render, just subtly wrong.
+ *
+ * So the branch is here, ABOVE the measured component, and it is exhaustive: a
+ * chart with no streaming source never reaches a line of new code. That is a
+ * property a reviewer can check by reading this function rather than trusting a
+ * test, and it is deliberately structural rather than conventional.
+ *
+ * Folding the two engines together is worth doing, but it is a separate change
+ * with its own risk; this one only makes both reachable through one prop.
+ */
+declare const ChartContainer: React__default.FC<ChartContainerWithSourceProps>;
 
 /**
- * Window size for data aggregation
- * Matches GraphQL WindowSize enum
+ * Event marker type — shared by ChartEventMarkers and ChartEventSpans.
  */
-type WindowSize = "FIVE_MINUTES" | "FIFTEEN_MINUTES" | "HOUR" | "DAY" | "WEEK" | "MONTH" | "YEAR";
+type EventMarkerType = "command" | "alert" | "info" | "success" | "warning" | "error";
 /**
- * Date range with native Date objects
+ * Get the resolved color for a given event marker type.
+ * Uses getResolvedColor to ensure CSS variables work in SVG context.
  */
-interface TimeRange {
-    after: Date;
-    before: Date;
-}
+declare function getEventColor(type: EventMarkerType | undefined): string;
+
 /**
- * Preset range option
+ * Event marker data point
  */
-interface PresetRange {
-    id: string;
+interface EventMarker {
+    /**
+     * Event timestamp
+     */
+    timestamp: Date;
+    /**
+     * Event label/name
+     */
     label: string;
-    getRange: () => TimeRange;
+    /**
+     * Optional event type for styling
+     */
+    type?: EventMarkerType;
+    /**
+     * Optional per-marker color override; takes precedence over the component-level color prop
+     */
+    color?: string;
+    /**
+     * Optional metadata to display in tooltip
+     */
+    metadata?: Record<string, string | number>;
+}
+interface ChartEventMarkersProps {
+    /**
+     * Array of event markers to display
+     */
+    events: EventMarker[];
+    /**
+     * Marker color for every event that does not carry its own `color`
+     * (defaults to a theme-aware color per event `type`)
+     */
+    color?: string;
+    /**
+     * Whether to show labels above markers
+     * @default false
+     */
+    showLabels?: boolean;
 }
 /**
- * Window size option
+ * ChartEventMarkers
+ *
+ * Renders vertical lines with markers for events (e.g., commands) on a chart.
+ * Must be used as a child of ChartContainer to access chart context.
+ *
+ * @example
+ * ```tsx
+ * <ChartContainer title="Device power">
+ *   <AreaSeries data={data} label="Power" />
+ *   <ChartEventMarkers
+ *     events={[
+ *       { timestamp: new Date('2024-01-01T10:00:00Z'), label: 'Command sent', type: 'command' },
+ *       { timestamp: new Date('2024-01-01T12:00:00Z'), label: 'Alert triggered', type: 'alert' }
+ *     ]}
+ *   />
+ * </ChartContainer>
+ * ```
  */
-interface WindowSizeOption {
-    id: WindowSize;
-    label: string;
-}
+declare function ChartEventMarkers({ events, color, showLabels }: ChartEventMarkersProps): react_jsx_runtime.JSX.Element | null;
+
 /**
- * Props for TimeControls component
+ * A time span to render as a translucent highlight band on a chart.
  */
-interface TimeControlsProps {
+interface EventSpan {
+    /** Start of the span */
+    start: Date;
+    /** End of the span */
+    end: Date;
+    /** Human-readable label shown in tooltip */
+    label: string;
+    /** Optional type for color coding */
+    type?: EventMarkerType;
+    /** Optional per-span color override; takes precedence over the component-level color prop */
+    color?: string;
+    /** Optional metadata to display in tooltip */
+    metadata?: Record<string, string | number>;
+}
+interface ChartEventSpansProps {
     /**
-     * Current date range
+     * Array of event spans to render as translucent bands.
      */
-    dateRange: TimeRange;
+    spans: EventSpan[];
     /**
-     * Callback when date range changes. `meta.presetId` is set when the change
-     * came from choosing a preset (vs. the calendar picker).
+     * Override fill opacity (default 0.25). Hover state doubles this up to a cap.
      */
-    onDateRangeChange: (range: TimeRange, meta?: {
-        presetId?: string;
-    }) => void;
+    opacity?: number;
     /**
-     * Current window size (optional)
+     * Override fill color for all spans (defaults to getEventColor(span.type)).
      */
-    windowSize?: WindowSize;
+    color?: string;
+}
+/**
+ * ChartEventSpans
+ *
+ * Renders translucent rectangular bands representing time spans (e.g., scheduled command windows)
+ * on a chart. Must be used as a child of ChartContainer to access chart context.
+ *
+ * Renders BEFORE ChartEventMarkers so the vertical marker lines appear on top of the span bands.
+ *
+ * @example
+ * ```tsx
+ * <ChartContainer title="Device power">
+ *   <LineSeries data={data} label="Power" />
+ *   <ChartEventSpans
+ *     spans={[
+ *       { start: new Date('2024-01-01T12:00:00Z'), end: new Date('2024-01-01T14:00:00Z'), label: 'Scheduled window', type: 'command' }
+ *     ]}
+ *   />
+ *   <ChartEventMarkers events={markers} />
+ * </ChartContainer>
+ * ```
+ */
+declare function ChartEventSpans({ spans, opacity, color }: ChartEventSpansProps): react_jsx_runtime.JSX.Element | null;
+
+/**
+ * The height the header is assumed to claim before it has been measured, in px.
+ *
+ * This was once the whole story — a constant both engines subtracted from the
+ * measured parent height. `TimeControls` ended that: it is `w-full flex-wrap`,
+ * so a header hosting it is two rows at narrow widths and one row at wide ones.
+ * No constant describes that, and a constant that disagrees with the render is
+ * exactly the drift this component exists to remove.
+ *
+ * It survives as the first-paint estimate. Without it the header reserves zero
+ * until the observer fires and every chart on the page visibly reflows.
+ */
+declare const CHART_HEADER_HEIGHT = 48;
+/**
+ * Width of the enclosing `ChartHeader`, or `null` outside one / before it is
+ * measured. See {@link ChartHeaderWidthContext}.
+ */
+declare function useChartHeaderWidth(): number | null;
+/**
+ * Marks a subtree as already carrying a visible label, so charts inside it do
+ * not render their own title. Wrap the body of a titled section or card.
+ */
+declare function ChartLabelledBy({ children }: {
+    children: ReactNode;
+}): react_jsx_runtime.JSX.Element;
+/**
+ * Marks a subtree as unlabelled, so charts inside it own their title. Use where
+ * a chart stands on its own with no section or card heading above it.
+ */
+declare function ChartOwnsItsTitle({ children }: {
+    children: ReactNode;
+}): react_jsx_runtime.JSX.Element;
+/**
+ * The height the header claims here, and the ref that establishes it.
+ *
+ * Both engines subtract `headerHeight` from the measured parent height before
+ * sizing the plot, and pass `headerRef` to the `ChartHeader` they render. The
+ * reserve is therefore the render, measured — not a second statement of it that
+ * someone has to keep in agreement.
+ *
+ * Returns 0 when the header will render nothing, so a chart that is already
+ * labelled and has no slots filled loses no plot height to empty chrome.
+ */
+declare function useChartHeaderMetrics(hasActions: boolean, hasControls: boolean): {
+    headerRef: (node: HTMLDivElement | null) => void;
+    headerHeight: number;
+};
+/** Returns `true` when the chart should render its own visible title. */
+declare function useChartOwnsItsTitle(): boolean;
+interface ChartHeaderProps {
     /**
-     * Callback when window size changes (optional)
+     * The chart's title. Both engines pass the same string they render as the SVG
+     * `<title>`, so the accessible name and the visible heading cannot drift
+     * apart (ALL-2539). Shown only when nothing above already labels the chart.
      */
-    onWindowSizeChange?: (size: WindowSize) => void;
+    title: string;
     /**
-     * Whether to show window size selector
-     * @default true
+     * Control cluster — `TimeControls` today.
+     *
+     * Separate from `actions` because it is not a trailing icon: it is full-width
+     * and it wraps, which is the whole reason this header measures itself rather
+     * than reserving a constant.
+     *
+     * Belongs here when it governs exactly this chart. Controls that govern a
+     * composed panel stay at panel level: `SiteEnergyCharts` pairs them with a KPI
+     * strip and expands the whole body as one unit, `Dnp3TelemetryChartsSection`
+     * drives a grid of charts from one cluster, and `TiledTimeSeriesExplorer`
+     * swaps its chart for an `EmptyState` — moving those controls inside the chart
+     * would reorder them, or make them vanish exactly when the window needs
+     * changing.
      */
-    showWindowSize?: boolean;
+    controls?: ReactNode;
+    /** Trailing action slot — expand first, more later. */
+    actions?: ReactNode;
+    /** Measurement ref from `useChartHeaderMetrics`. */
+    containerRef?: (node: HTMLDivElement | null) => void;
     /**
-     * Auto-adjust window size based on date range
-     * @default false
+     * Horizontal insets, in px. Both default to 0 and no engine passes them.
+     *
+     * They exist for a caller that genuinely needs the header indented, NOT for
+     * aligning with the plot. Both engines used to pass the plot's own
+     * `dynamicMargin.right` here, which put the expand action 8px in from the card
+     * edge while the title stayed flush left — a lopsided header, visible on every
+     * chart in the app. That margin is axis padding, so a point at the domain max
+     * does not sit on the plot border; it describes the PLOT, and the header is
+     * chrome that shares the card's edges with everything else in it.
      */
-    autoAdjustWindowSize?: boolean;
+    marginLeft?: number;
+    marginRight?: number;
+}
+declare function ChartHeader({ title, controls, actions, containerRef, marginLeft, marginRight, }: ChartHeaderProps): react_jsx_runtime.JSX.Element | null;
+
+interface ExpandedSize {
+    width: number;
+    height: number;
+}
+interface ChartExpand {
+    isExpanded: boolean;
+    /** The expand control, for `ChartHeader`'s action slot. */
+    action: ReactNode;
     /**
-     * Whether to show range selector presets
-     * @default true
+     * Dimensions to render at. `null` inline, where the `withParentSize` HOC's
+     * own measurements apply.
      */
-    showRangeSelector?: boolean;
+    expandedSize: ExpandedSize | null;
+    /** Wraps the chart body: inline it passes through, expanded it opens a Dialog. */
+    present: (body: ReactNode) => ReactNode;
+}
+/** Marks a subtree whose expand is owned by an ancestor. */
+declare function ChartExpandOwnedByAncestor({ children }: {
+    children: ReactNode;
+}): react_jsx_runtime.JSX.Element;
+declare function useChartExpand(title: string): ChartExpand;
+
+interface ChartSourceProviderProps {
     /**
-     * Whether to show calendar date picker button
-     * @default false
+     * Turns a serializable source descriptor into a fetcher. Keep it stable
+     * (`useCallback`) — a new identity on every render re-resolves every chart
+     * beneath it.
      */
-    allowDatePicker?: boolean;
+    resolve?: ChartSourceResolver;
+    /**
+     * The component form of `resolve`, for sources whose resolution needs hooks
+     * (see `ChartSourceHost`). Consulted FIRST when both are installed, because a
+     * host is the more capable half — an app registering both means the host
+     * knows refs the plain resolver cannot answer, and a host that does not
+     * recognise a ref falls through to `resolve` below.
+     */
+    host?: ChartSourceHost;
+    /**
+     * Ceiling on tile fetches in flight across every chart below this provider.
+     *
+     * Omit it for the default. It exists as an override mainly so a test can set
+     * a ceiling small enough to observe — the product has no reason to vary it.
+     */
+    maxConcurrentFetches?: number;
+    children: ReactNode;
+}
+/**
+ * Supplies the runtime half of streaming chart sources.
+ *
+ * ── Why a provider and not a prop ─────────────────────────────────────────────
+ * The fetcher is a function, so it cannot ride in a block's props — those are
+ * serialized into `data-composition-schema`, and a function there blanks the
+ * page. But the chart still needs one. A provider resolves that: the block
+ * declares WHICH data it wants in JSON, and the app answers HOW to get it once,
+ * above the whole tree, instead of at every call site.
+ *
+ * This is the same division the maps blocks already use, where a block declares
+ * a tileset in props and the host attaches tile authentication at the map
+ * itself — *"render-time concerns owned by the runtime, not props on this union."*
+ *
+ * ── Why it lives in `edges` ───────────────────────────────────────────────────
+ * So the charts can stay ignorant of where data comes from. `edges` has no
+ * GraphQL client and must not grow one; the app installs a resolver that closes
+ * over its own. That keeps the dependency pointing one way — the app knows
+ * about charts, charts never know about the app.
+ *
+ * Mount it once, near the top:
+ *
+ * ```tsx
+ * <ChartSourceProvider resolve={dashboardChartSources}>
+ *   <App />
+ * </ChartSourceProvider>
+ * ```
+ */
+declare function ChartSourceProvider({ resolve, host, maxConcurrentFetches, children }: ChartSourceProviderProps): react_jsx_runtime.JSX.Element;
+/**
+ * The installed resolver, or `null` when no provider is mounted.
+ *
+ * `null` is a legitimate state, not an error: a chart with a streaming source
+ * rendered outside a provider shows its empty state. That is what makes a
+ * component library safe to render in a test, a docs page, or a screenshot
+ * harness with no data layer attached — and it is why this returns rather than
+ * throws.
+ */
+declare function useChartSourceResolver(): ChartSourceResolver | null;
+/**
+ * The installed host, or `null` when none is mounted.
+ *
+ * Separate hook rather than a merged return so a chart can tell the two apart:
+ * a host has to be RENDERED to answer, and picking that path is a decision about
+ * component structure, not a value to read.
+ */
+declare function useChartSourceHost(): ChartSourceHost | null;
+
+interface ChartTooltipProps {
+    data: TooltipData | null;
+    formatter: YFormatType;
+    /** Optional label to display instead of formatting xValue (for categorical charts) */
+    label?: string;
+    /** Optional category labels override (for standalone usage without ChartContext) */
+    categoryLabels?: Record<string, string>;
+}
+/**
+ * ChartTooltip
+ *
+ * Interactive tooltip component for charts.
+ * Displays formatted data values at hover position with automatic positioning and animations.
+ * Uses the main formatting system for consistency with Kpi, StatList, and DataTable.
+ *
+ * Can be used standalone (with label prop) or within ChartContext (for time-series charts).
+ */
+declare const ChartTooltip: React__default.FC<ChartTooltipProps>;
+
+interface FunnelStage {
+    id: string;
+    /** Label for the stage (e.g., "Product Viewed") */
+    label: string;
+    /** Numeric value for this stage */
+    value: number;
+    /** Optional secondary value (e.g., "+12% MoM") */
+    secondaryValue?: string;
+    /** Optional annotation badge */
+    annotation?: string;
+    /** Override color for this stage */
+    color?: string;
+}
+interface FunnelSeriesProps {
+    /** Array of funnel stages ordered from top to bottom */
+    data: FunnelStage[];
+    /** Width of the chart */
+    width?: number;
+    /** Height of the chart */
+    height?: number;
+    /** Padding around the chart area */
+    padding?: number;
+    /** Gap between bars */
+    barGap?: number;
+    /** Format function for values */
+    formatValue?: (value: number) => string;
+    /** Format function for percentages */
+    formatPercentage?: (value: number) => string;
+    /** Single color to use for all bars (uses theme color if not provided) */
+    color?: string;
+    /** Show percentage scale on left */
+    showScale?: boolean;
+    /** Show overall conversion rate at top */
+    showOverallConversion?: boolean;
+    /** Label text for overall conversion (for internationalization) */
+    overallConversionLabel?: string;
+    /** Optional external active stage identifier */
+    activeStageId?: string | null;
+    /** Callback when a stage is clicked */
+    onStageClick?: (stage: FunnelStage) => void;
+    /** Callback when a stage is hovered */
+    onStageHover?: (stage: FunnelStage | null) => void;
+    /** Additional className */
+    className?: string;
+    /** Inline styles */
+    style?: React__default.CSSProperties;
+    /** Accessible label */
+    "aria-label"?: string;
+}
+declare const FunnelSeries: React__default.FC<FunnelSeriesProps>;
+
+interface LineSeriesProps {
     /**
-     * Whether window size is locked (read-only)
-     * @default false
+     * The points to draw.
+     *
+     * Optional ONLY inside a streaming chart, where the points do not exist until
+     * the reader looks at a window: there the child names its stream with
+     * `seriesKey` and the chart supplies `data` before this component renders. In
+     * an ordinary chart it is required in practice — a series with neither is
+     * skipped rather than drawn.
      */
-    lockWindowSize?: boolean;
+    data?: BaseDataPoint[];
     /**
-     * Whether to show the built-in Reset button beside the calendar picker. It
-     * returns to the first preset. Turn off in views that own their own reset
-     * with different semantics (e.g. pan/zoom explorers returning to the last
-     * explicit selection).
-     * @default true
+     * Which stream this series draws, in a chart with a streaming `source`.
+     *
+     * Defaults to `"line"`, the primary stream. Ignored entirely by a chart that
+     * holds its own data, so the same `<AreaSeries>` serves both sources.
      */
-    showReset?: boolean;
+    seriesKey?: string;
     /**
-     * Restrict to single day selection (uses Calendar instead of RangeCalendar)
-     * @default false
+     * Relabel this series once its points arrive, in a streaming chart.
+     *
+     * Declared here rather than only on the chart because the element carrying it
+     * is this one; the streaming branch reads it, resolves it against every
+     * assembled stream, and passes the result down as `label`. This component
+     * never calls it — by the time it renders, `label` is already the answer.
      */
-    restrictToSingleDay?: boolean;
+    labelFromData?: (plotted: BaseDataPoint[], series: AssembledSeries) => string;
+    color?: string;
+    label?: string;
+    strokeWidth?: number;
+    /** CSS stroke-dasharray value (e.g. "4 2" for dotted, "8 4" for dashed) */
+    strokeDasharray?: string;
+    categoryColors?: Record<string, string>;
+    categoryLabels?: Record<string, string>;
     /**
-     * Available preset range options
+     * When set, break the line wherever consecutive points are spaced more than
+     * this many ms apart (missing buckets / outages). Omit to connect across gaps.
      */
-    presetRanges?: PresetRange[];
+    maxGapMs?: number;
+    animate?: boolean;
+}
+/**
+ * LineSeries
+ *
+ * Chart component for rendering line charts.
+ * Displays data as a continuous line with customizable stroke width, color, and dash patterns.
+ * When categoryColors are provided, contiguous line segments are colored by each segment
+ * start point category while preserving tooltip and legend metadata from ChartContainer.
+ */
+declare const LineSeries: React__default.FC<LineSeriesProps>;
+
+interface PieDataPoint {
+    /** Category label */
+    label: string;
+    /** Numeric value. Non-positive values take no arc — see `shareOf`. */
+    value: number;
+    /** Optional color override for this slice */
+    color?: string;
+}
+interface PieChartProps {
+    /** Array of data points with labels and values */
+    data: PieDataPoint[];
+    /** Width of the chart (auto-resizes to container if not provided) */
+    width?: number;
+    /** Height of the chart (auto-resizes to container if not provided) */
+    height?: number;
     /**
-     * Available window size options
+     * Hole radius as a fraction of the outer radius. `0` (the default) is a pie;
+     * `0.6` is a donut. Values outside 0–0.95 are clamped.
      */
-    windowSizeOptions?: WindowSizeOption[];
+    innerRadiusRatio?: number;
+    /** Formatter for slice values (uses the standard chart formatting system) */
+    yFormatter?: YFormatType;
+    /** Show the label/value/share legend beside the pie (default true) */
+    showLegend?: boolean;
+    /** Show tooltip on hover (default true) */
+    showTooltip?: boolean;
     /**
-     * Control size, matching the shared `Button` / `Select` scale.
-     *
-     * Defaults to `md`, which is what this component always rendered. `sm` exists
-     * for a caller placing these beside smaller controls — a chart header, where
-     * `md` here stood 39px next to 33px selects and read as a mismatch rather
-     * than a hierarchy.
+     * Callback when a slice is clicked. Supplying it turns every slice into a
+     * focusable, named control that answers Enter and Space, and the drawing's
+     * role from `img` to `group` — an `img` hides the controls inside it.
      */
-    size?: "sm" | "md";
+    onSliceClick?: (dataPoint: PieDataPoint, index: number) => void;
+    /** Callback when a slice is hovered */
+    onSliceHover?: (dataPoint: PieDataPoint | null, index: number | null) => void;
+    /** Additional className */
+    className?: string;
+    /** Inline styles */
+    style?: React__default.CSSProperties;
     /**
-     * Additional CSS classes
+     * The chart's accessible name. Required, not optional-with-a-default, for the
+     * reason `CategoryBarChart` states: a default means every chart of this kind
+     * announces identically to a screen reader (ALL-2539, ALL-2715).
      */
-    className?: string;
+    "aria-label": string;
 }
 /**
- * TimeControls
+ * PieChart
  *
- * Sophisticated time control component with responsive behavior and calendar integration.
- * Features preset ranges, custom date picker, and window size selection.
+ * Part-of-whole mark for categorical data: one slice per category, sized by its
+ * share of the total, with a legend carrying the value and the percentage. Pass
+ * `innerRadiusRatio` for a donut.
  *
- * **Responsive Behavior:**
- * - < 600px: Compact mode with Select dropdowns
- * - ≥ 600px: Expanded mode with ToggleButton group for presets
+ * Input order is preserved — slices are not re-sorted by value, so a producer
+ * that ordered its categories deliberately (severity, lifecycle stage) keeps
+ * that order.
  *
  * @example
  * ```tsx
- * const [dateRange, setDateRange] = useState({
- *   after: subDays(new Date(), 7),
- *   before: new Date()
- * });
- * const [windowSize, setWindowSize] = useState<WindowSize>("HOUR");
- *
- * <TimeControls
- *   dateRange={dateRange}
- *   onDateRangeChange={setDateRange}
- *   windowSize={windowSize}
- *   onWindowSizeChange={setWindowSize}
- *   presetRanges={presetRanges}
- *   allowDatePicker
+ * <PieChart
+ *   data={[
+ *     { label: "Online", value: 127 },
+ *     { label: "Offline", value: 23 },
+ *   ]}
+ *   aria-label="Devices by status"
  * />
  * ```
  */
-declare function TimeControls({ dateRange, onDateRangeChange, windowSize, onWindowSizeChange, showWindowSize, showRangeSelector, allowDatePicker, lockWindowSize, showReset, restrictToSingleDay, presetRanges, windowSizeOptions, autoAdjustWindowSize, size, className, }: TimeControlsProps): react_jsx_runtime.JSX.Element;
-
-type ClassicPresetId = "day" | "week" | "month";
-/**
- * The standard ladder for classic (non-tiled) charts. Labels are supplied by the
- * caller rather than baked in, because consumers localize them — edges owns the
- * ids and ranges, which is the part that was duplicated per chart and drifted.
- */
-declare function classicPresetRanges(labels: Record<ClassicPresetId, string>, getAnchorEndMs?: () => number): PresetRange[];
-/**
- * The standard telemetry time-range ladder. `getAnchorEndMs` is called at press
- * time, not build time, so a long-lived view jumps to a fresh "now" (or stays
- * pinned to a scrubbed instant under time travel).
- */
-declare function telemetryPresetRanges(getAnchorEndMs?: () => number): PresetRange[];
-
-interface TiledTimeSeriesSource {
-    fetchTile: FetchTile;
-    ladder: ResolutionLadder;
-    nativeMs: number;
-    resetKey: string;
-    /** Revalidate visible tiles without discarding the plot. */
-    refreshKey?: string | undefined;
-    /** Cancel automatic refreshes while preserving manual navigation. */
-    refreshEnabled?: boolean | undefined;
-    tileCostSeriesCount: number;
-}
-interface TiledTimeSeriesView {
-    targetTierId: string;
-    renderedTierId: string | null;
-    viewport: {
-        startMs: number;
-        endMs: number;
-    };
-    followingLatest: boolean;
-    /** Relative Now navigation intent, independent of whether live updates are enabled. */
-    atLiveEdge?: boolean | undefined;
-}
-interface TiledTimeSeriesExplorerProps {
-    source: TiledTimeSeriesSource;
-    /** Accessible name for the chart. Forwarded to the underlying tiled chart's SVG `<title>`. */
-    title: string;
-    liveControl?: TiledTimeSeriesLiveControl | undefined;
-    initialRange?: {
-        days: number;
-    } | undefined;
-    viewportEnd?: Date | undefined;
-    yFormatter?: YFormatType | undefined;
-    yDomain?: TiledTimeSeriesChartProps["yDomain"] | undefined;
-    referenceLines?: {
-        value: number;
-        label?: string;
-        color?: string;
-    }[] | undefined;
-    emptyState: {
-        title: string;
-        description: string;
-    };
-    presetRanges?: PresetRange[] | undefined;
-    tierToWindow: Record<string, WindowSize>;
-    windowSizeOptions: WindowSizeOption[];
-    height?: number | undefined;
-    hint?: string | undefined;
-    dataBounds?: {
-        startMs?: number;
-        endMs?: number;
-    } | undefined;
-    /** Reports committed camera/tier state, including while rendered tiles fall back. */
-    onViewChange?: ((view: TiledTimeSeriesView) => void) | undefined;
-    /** Advance unanchored views at Now. Historical navigation pauses following. */
-    followLatest?: boolean | undefined;
-    /** Change to explicitly resume a navigation-paused view at Now, preserving its span. */
-    followLatestKey?: string | number | undefined;
-    /** Metadata for the accepted plotted data and visible window, shared with expanded view.
-     * Render only; publish state through onViewChange instead. Series may include overscan.
-     * maxDataTimeMs is the inclusive fetch cutoff; viewport.endMs is exclusive. */
-    renderMetadata?: ((args: {
-        series: AssembledSeries;
-        viewport: {
-            startMs: number;
-            endMs: number;
-        };
-        maxDataTimeMs: number;
-    }) => ReactNode) | undefined;
-    children: (args: {
-        series: AssembledSeries;
-        gapMs: number;
-    }) => ReactNode;
-}
-declare function TiledTimeSeriesExplorer({ source, title, liveControl, initialRange, viewportEnd, yFormatter, yDomain, referenceLines, emptyState, presetRanges, tierToWindow, windowSizeOptions, height, hint, dataBounds, onViewChange, followLatest, followLatestKey, children, renderMetadata, }: TiledTimeSeriesExplorerProps): react_jsx_runtime.JSX.Element;
+declare const PieChart: React__default.FC<PieChartProps>;
 
 interface Filter {
     id: string;
@@ -4162,7 +4989,7 @@ declare function DeltaCell<T = any>({ value, row, context, direction, tone, form
 /**
  * Device type classification
  */
-type DeviceType = "battery" | "charger" | "thermostat" | "inverter" | "vehicle" | "water_heater" | "meter" | "gateway" | "other" | "unknown";
+type DeviceType = "battery" | "charger" | "thermostat" | "inverter" | "vehicle" | "water_heater" | "meter" | "sensor" | "gateway" | "other" | "unknown";
 
 interface DeviceMetaCellProps<T = unknown> extends CellComponentProps<T> {
     /** Device manufacturer name (can be a function to extract from row) */
@@ -4844,7 +5671,7 @@ declare function TextCell<T = any>({ value, row, context, prefix, suffix, emptyT
  * Supports custom cell renderers, column configurations, multiple display densities,
  * and virtualization for large datasets.
  */
-declare function DataTable<T extends Record<string, unknown>>({ columns, data, className, density, width, height, maxHeight, layout, mobileRenderer, customMobileRowRender, mobileBreakpoint, isLoading, loadingState, loadingRowCount, onLoadMore, hasMore, enableVirtualization, estimatedRowHeight, loadingIndicator, stickyHeader, stickyFirstColumn, onRowClick, getRowId, selectedRowIds, onSelectionChange, selectionMode, hideHeader, sortConfig: controlledSortConfig, onSort, sortNote, "aria-label": ariaLabel, enableColumnReorder, columnOrder: controlledColumnOrder, onColumnOrderChange, }: DataTableProps<T>): react_jsx_runtime.JSX.Element;
+declare function DataTable<T extends Record<string, unknown>>({ columns, data: allData, className, density, width, height, maxHeight, layout, mobileRenderer, customMobileRowRender, mobileBreakpoint, isLoading, loadingState, loadingRowCount, onLoadMore, hasMore, enableVirtualization, estimatedRowHeight, loadingIndicator, stickyHeader, stickyFirstColumn, onRowClick, getRowId, selectedRowIds, onSelectionChange, selectionMode, hideHeader, sortConfig: controlledSortConfig, onSort, sortNote, "aria-label": ariaLabel, enableColumnReorder, columnOrder: controlledColumnOrder, onColumnOrderChange, pagination, }: DataTableProps<T>): react_jsx_runtime.JSX.Element;
 
 interface MobileRowProps<T> {
     row: T;
@@ -4863,6 +5690,87 @@ declare function AutoMobileRenderer<T>({ row, columns, density, isLoading, onCli
  */
 declare function CardMobileRenderer<T>({ row, columns, density, isLoading, onClick }: MobileRowProps<T>): react_jsx_runtime.JSX.Element;
 
+/**
+ * Rows per page when `pagination` is `true` or omits `pageSize`.
+ *
+ * 10 rather than 25: the default exists for tables embedded in a page, and a page
+ * of 10 is about a screen of rows on a laptop without pushing the footer — and the
+ * control that follows it — below the fold. A caller showing a denser table says so.
+ */
+declare const DEFAULT_PAGE_SIZE = 10;
+/**
+ * Upper bound on a page, mirroring the row budget a bounded table already honours.
+ *
+ * A page is a viewport's worth of rows, and it renders unvirtualized — so an
+ * unbounded `pageSize` reintroduces exactly the mount cost paging is meant to
+ * avoid. Clamped rather than defaulted, because "show 2,000" is a legible intent
+ * expressed in a field that cannot carry it; the nearest honest answer is the
+ * largest page there is.
+ */
+declare const MAX_PAGE_SIZE = 200;
+/** What a render needs once the paging policy has been resolved against the data. */
+interface ResolvedPagination {
+    /** 0-based page being shown, clamped into range. */
+    page: number;
+    /** Total pages, always at least 1 so an empty table still reads "1 / 1". */
+    pageCount: number;
+    /** Index of the first row on this page, for slicing. */
+    start: number;
+    /** Index past the last row on this page, for slicing. */
+    end: number;
+    /** 1-based inclusive ordinal of the first row shown, or 0 when there are none. */
+    from: number;
+    /** 1-based inclusive ordinal of the last row shown. */
+    to: number;
+    /** Rows across every page. */
+    total: number;
+}
+/**
+ * Resolve a paging policy against the row count actually in play.
+ *
+ * `page` is the value to clamp — whichever of the controlled prop or the table's
+ * own state is in force. Clamping here rather than at the call site is what keeps
+ * a shrinking dataset from stranding a live page: a refetch returning fewer rows
+ * under page 4 of 2 renders page 2, not an empty table under a lying footer.
+ */
+declare function resolvePagination(pagination: DataTablePagination | boolean | undefined, rowCount: number, page: number): ResolvedPagination;
+interface PaginationFooterProps extends ResolvedPagination {
+    density: TableDensity;
+    onPageChange: (next: number) => void;
+    /** Labels the control for assistive tech, e.g. "Commands pagination". */
+    label?: string;
+}
+/**
+ * Page controls, and the range they are moving through.
+ *
+ * ── What the layout is doing ─────────────────────────────────────────────────
+ *
+ * The range ("9–16 of 312") is the load-bearing half and the arrows are the cheap
+ * half: a paged table's real job is telling you how much there IS, which is the
+ * one thing a scrollbar communicates badly.
+ *
+ * ── Mobile ───────────────────────────────────────────────────────────────────
+ *
+ * Three things change below `sm`, and each is a thumb problem rather than a width
+ * problem:
+ *
+ *   - The buttons carry their labels ("Previous" / "Next") instead of bare carets.
+ *     A 32px caret is under the 44px touch target every mobile guideline asks for,
+ *     and it is the only control on the row — there is room to say what it does.
+ *   - They sit at the EDGES of the row, thumb-reachable, with the range centred
+ *     between them. On desktop the pair stays grouped at the right, where a mouse
+ *     is already heading after a sort or a row click.
+ *   - The range says "9–16 of 312" on both, but the page counter ("2 / 32") is
+ *     desktop-only: on a phone it is a third number competing with the two that
+ *     matter, and the arrows already say where you can go.
+ *
+ * Container queries rather than viewport breakpoints (`@sm:` off the table's own
+ * wrapper), because the table is a block that gets placed in panes narrower than
+ * the window — a 380px side panel on a 1440px monitor is mobile for this control
+ * even though the viewport says otherwise.
+ */
+declare function PaginationFooter({ page, pageCount, from, to, total, density, onPageChange, label, }: PaginationFooterProps): react_jsx_runtime.JSX.Element;
+
 /**
  * DateRangePicker
  *
@@ -7036,6 +7944,11 @@ declare function RangeCalendar<T extends DateValue>({ errorMessage, ...props }:
  * </Section>
  * ```
  */
+/**
+ * Dispatched on `window` by `SectionNav` before it scrolls to a section, with the target element's DOM id as
+ * `detail.id`. A collapsed `Section` with that id opens itself, so the rail never scrolls to a closed body.
+ */
+declare const SECTION_NAVIGATE_EVENT = "edges:section-navigate";
 type SectionVariant = "plain" | "contained" | "bordered";
 type SectionSpacing = "none" | "sm" | "md" | "lg";
 interface SectionProps {
@@ -7061,8 +7974,14 @@ interface SectionProps {
     children?: React__default.ReactNode;
     /** Label used by in-page navigation (PageLayout.Content with withSectionNav). Falls back to title when omitted */
     navLabel?: string;
-}
-declare function Section({ id, title, description, actions, variant, spacing, withDivider, headingAs, className, children, }: SectionProps): react_jsx_runtime.JSX.Element;
+    /** Lets the reader fold the body away; the title becomes the toggle */
+    collapsible?: boolean;
+    /** Initial state of a collapsible section. A collapsed body is not mounted */
+    defaultCollapsed?: boolean;
+    /** Short trailing marker beside a collapsible title, e.g. a count */
+    badge?: React__default.ReactNode;
+}
+declare function Section({ id, title, description, actions, variant, spacing, withDivider, headingAs, className, children, collapsible, defaultCollapsed, badge, }: SectionProps): react_jsx_runtime.JSX.Element;
 declare namespace Section {
     var displayName: string;
 }
@@ -8084,4 +9003,4 @@ declare function voltageYDomain(data: readonly VoltageValues[], nominalVoltage:
  */
 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, type AgentCellConfigOf, type AgentCellValueOf, type AgentSerializable, 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, CATEGORICAL_RAMP, CHART_HEADER_HEIGHT, COLOR_RAMPS, 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, CategoryCell, type CategoryCellProps, type CategoryDataPoint, CellAlignment, CellComponentProps, type CellConfigOf, CellEmphasis, type CellValueOf, ChartAxis, ChartBottomBar, ChartContainer, ChartEventMarkers, type ChartEventMarkersProps, ChartEventSpans, type ChartEventSpansProps, type ChartExpand, ChartExpandOwnedByAncestor, type ChartExportMetadata, ChartHeader, type ChartHeaderProps, ChartLabelledBy, ChartOwnsItsTitle, ChartTooltip, Chip, ChipInputField, type ChipInputFieldProps, type ClassicPresetId, Collapse, CollapseContent, type CollapseContentProps, type CollapseDensity, CollapseHeader, type CollapseHeaderProps, CollapseItem, type CollapseItemProps, type CollapseProps, type CollapseVariant, ColorModeProvider, type ColorRampInput, type ColorRampKind, type ColorRampOption, ColorSpec, Column, CommandPalette, type CommandPaletteProps, ComponentFormatter, Confirm, type ConfirmProps, ConnectionStatusBadge, type ConnectionStatusBadgeProps, ContactCard, type ContactCardProps, ContactMetaCell, type ContactMetaCellProps, ContactMetaDisplay, type ContactMetaDisplayProps, ContainerQueryProvider, CopyToClipboard, type Coverage, CurrencyFormat, CurrentFormat, CustomCell, type CustomCellProps, CustomPinsSpec, DEFAULT_CHART_HEIGHT, DIVERGING_RAMPS, DataControls, type Filter as DataControlsFilter, type DataControlsProps, type SortOption as DataControlsSortOption, DataTable, DataTableProps, DateCell, type DateCellProps, DateFormat, DateRangePicker, DeltaCell, type DeltaCellProps, type DeltaDirection, type DeltaFormat, type DeltaTone, 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, FacetConfig, FacetCounts, type FetchTile, type FetchTileContext, FieldFormat, FieldValue, FilterChips, type FilterChipsProps, FilterDialog, type FilterDialogProps, FilterState, FirmwareVersionBadge, type FirmwareVersionBadgeProps, Form, FormatRegistry, FormattedCell, type FormattedCellProps, 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, IndexCell, type IndexCellProps, InfiniteScrollIndicator, type InfiniteScrollIndicatorProps, Kpi, KpiGroup, type KpiGroupAlign, type KpiGroupCols, type KpiGroupGap, type KpiGroupProps, type KpiOrientation, type KpiProps, type KpiSize, type KpiStatus, LayerSpec, LineSeries, LinkBehavior, type LinkComponentType, List, ListBox, ListBoxItem, ListItem, type ListItemProps, ListPane, type ListPaneProps, type ListProps, LoadingState, MapStyleProvider, MiniBarCell, type MiniBarCellProps, ModalBackdrop, type ModalBackdropProps, type NodeState, type NonSerializableCellProp, 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, PhoneFormat, PieChart, type PieChartProps, type PieDataPoint, type Place, PlaceSearch, type PlaceSearchProps, Popover, PowerFormat, type PresetRange, ProgressBar, Prose, type ProseProps, type ProseSize, type ProseTone, RangeCalendar, RangeCell, type RangeCellProps, RasterLayerSpec, type RegisterPhosphorIconOptions, ResistanceFormat, type ResolutionLadder, type ResponsiveValue, ResultsCount, type ResultsCountProps, SEQUENTIAL_RAMPS, SKELETON_SIZES, SOURCE_UNIT_TO_WH, 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, type Serializable, SiteCard, type SiteCardProps, SiteContactCard, type SiteContactCardProps, SiteMetaCell, type SiteMetaCellProps, SiteMetaDisplay, type SiteMetaDisplayProps, Skeleton, Slider, SortControl, type SortControlProps, 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 TableExportMetadata, type TableExportOptions, 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 TiledTimeSeriesLiveControl, type TiledTimeSeriesSource, type TiledTimeSeriesView, 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 UseServerDataControlsOptions, type UseTableExportOptions, type UseTableExportReturn, type UseTileWindowArgs, type UseTileWindowResult, type UseTiledTimeSeriesArgs, type UseTiledTimeSeriesResult, VectorLayerSpec, type Viewport, VoltageFormat, type WindowSize, type WindowSizeOption, YFormatType, applyDataOperations, assembleSeries, autoScaleCurrent, autoScaleDistance, autoScaleEnergy, autoScalePower, autoScaleResistance, autoScaleVoltage, camelCaseToWords, capitalize, celsiusToFahrenheit, celsiusToKelvin, centimetersToInches, classicPresetRanges, createFormat, createTextureIcon, createTiledCameraSyncGroup, csvUnitFor, csvValueFor, deltaDirectionFromValue, emptyStore, enumToSentenceCase, exportChart, exportTableAsCSV, fahrenheitToCelsius, fahrenheitToKelvin, feetToMeters, feetToMiles, 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, getColorRamp, getColorRampsByKind, getDateParts, getEventColor, getExportFormatName, getExportHeaders, getLinkClasses, getNumericColorClasses, getSkeletonSize, getStateTone, hasTileData, inchesToCentimeters, isCustomPinsLayer, isExportSupported, isGeoJsonLayer, isNil, isRasterLayer, isVectorLayer, kelvinToCelsius, kelvinToFahrenheit, kilometersToMiles, layer, metersToFeet, metersToMiles, metersToYards, milesToFeet, milesToKilometers, milesToMeters, parseBoolean, pickEnergyUnit, prepareTableDataForExport, registerPhosphorIcon, resolveValue, snakeCaseToWords, telemetryPresetRanges, 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, useChartExpand, useChartHeaderMetrics, useChartHeaderWidth, useChartOwnsItsTitle, useClientDataControls, useColorMode, useContainerBreakpoint, useDataControls, useDebounce, useElementSize, useLocalStorage, useMapStyleOverride, useMediaQuery, useNotice, useServerDataControls, useTableExport, useTileWindow, useTiledTimeSeries, voltageReferenceLines, voltageYDomain, 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, type AgentCellConfigOf, type AgentCellValueOf, type AgentSerializable, 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, CATEGORICAL_RAMP, CHART_HEADER_HEIGHT, COLOR_RAMPS, 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, CategoryCell, type CategoryCellProps, type CategoryDataPoint, CellAlignment, CellComponentProps, type CellConfigOf, CellEmphasis, type CellValueOf, ChartAxis, ChartBottomBar, ChartContainer, type ChartContainerWithSourceProps, ChartEventMarkers, type ChartEventMarkersProps, ChartEventSpans, type ChartEventSpansProps, type ChartExpand, ChartExpandOwnedByAncestor, type ChartExportMetadata, ChartHeader, type ChartHeaderProps, ChartLabelledBy, ChartOwnsItsTitle, type ChartSource, type ChartSourceHost, ChartSourceProvider, type ChartSourceProviderProps, type ChartSourceResolver, ChartTooltip, Chip, ChipInputField, type ChipInputFieldProps, type ClassicPresetId, Collapse, CollapseContent, type CollapseContentProps, type CollapseDensity, CollapseHeader, type CollapseHeaderProps, CollapseItem, type CollapseItemProps, type CollapseProps, type CollapseVariant, ColorModeProvider, type ColorRampInput, type ColorRampKind, type ColorRampOption, ColorSpec, Column, CommandPalette, type CommandPaletteProps, ComponentFormatter, Confirm, type ConfirmProps, ConnectionStatusBadge, type ConnectionStatusBadgeProps, ContactCard, type ContactCardProps, ContactMetaCell, type ContactMetaCellProps, ContactMetaDisplay, type ContactMetaDisplayProps, ContainerQueryProvider, CopyToClipboard, type Coverage, CurrencyFormat, CurrentFormat, CustomCell, type CustomCellProps, CustomPinsSpec, DEFAULT_CHART_HEIGHT, DEFAULT_PAGE_SIZE, DIVERGING_RAMPS, DataControls, type Filter as DataControlsFilter, type DataControlsProps, type SortOption as DataControlsSortOption, DataTable, DataTablePagination, DataTableProps, DateCell, type DateCellProps, DateFormat, DateRangePicker, DeltaCell, type DeltaCellProps, type DeltaDirection, type DeltaFormat, type DeltaTone, 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, FacetConfig, FacetCounts, type FetchTile, type FetchTileContext, FieldFormat, FieldValue, FilterChips, type FilterChipsProps, FilterDialog, type FilterDialogProps, FilterState, FirmwareVersionBadge, type FirmwareVersionBadgeProps, Form, FormatRegistry, FormattedCell, type FormattedCellProps, 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, IndexCell, type IndexCellProps, InfiniteScrollIndicator, type InfiniteScrollIndicatorProps, type InlineChartSource, Kpi, KpiGroup, type KpiGroupAlign, type KpiGroupCols, type KpiGroupGap, type KpiGroupProps, type KpiOrientation, type KpiProps, type KpiSize, type KpiStatus, type LatestDataReadoutKind, LayerSpec, LineSeries, LinkBehavior, type LinkComponentType, List, ListBox, ListBoxItem, ListItem, type ListItemProps, ListPane, type ListPaneProps, type ListProps, LoadingState, MAX_PAGE_SIZE, MapStyleProvider, MiniBarCell, type MiniBarCellProps, ModalBackdrop, type ModalBackdropProps, type NodeState, type NonSerializableCellProp, 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, PaginationFooter, PhoneFormat, PieChart, type PieChartProps, type PieDataPoint, type Place, PlaceSearch, type PlaceSearchProps, Popover, PowerFormat, type PresetRange, ProgressBar, Prose, type ProseProps, type ProseSize, type ProseTone, RangeCalendar, RangeCell, type RangeCellProps, RasterLayerSpec, type RegisterPhosphorIconOptions, ResistanceFormat, type ResolutionLadder, type ResolvedChartSource, type ResponsiveValue, ResultsCount, type ResultsCountProps, SECTION_NAVIGATE_EVENT, SEQUENTIAL_RAMPS, SKELETON_SIZES, SOURCE_UNIT_TO_WH, 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, type Serializable, SiteCard, type SiteCardProps, SiteContactCard, type SiteContactCardProps, SiteMetaCell, type SiteMetaCellProps, SiteMetaDisplay, type SiteMetaDisplayProps, Skeleton, Slider, SortControl, type SortControlProps, 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, StreamingChart, type StreamingChartConfig, type StreamingChartProps, type StreamingChartSource, Tab, TabList, TabPanel, TableDensity, type TableExportMetadata, type TableExportOptions, 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 TiledTimeSeriesLiveControl, type TiledTimeSeriesPanel, type TiledTimeSeriesSource, type TiledTimeSeriesView, 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 UseServerDataControlsOptions, type UseTableExportOptions, type UseTableExportReturn, type UseTileWindowArgs, type UseTileWindowResult, type UseTiledTimeSeriesArgs, type UseTiledTimeSeriesResult, VectorLayerSpec, type Viewport, VoltageFormat, type WindowSize, type WindowSizeOption, YFormatType, applyDataOperations, assembleSeries, autoScaleCurrent, autoScaleDistance, autoScaleEnergy, autoScalePower, autoScaleResistance, autoScaleVoltage, camelCaseToWords, capitalize, celsiusToFahrenheit, celsiusToKelvin, centimetersToInches, classicPresetRanges, createFormat, createTextureIcon, createTiledCameraSyncGroup, csvUnitFor, csvValueFor, deltaDirectionFromValue, emptyStore, enumToSentenceCase, exportChart, exportTableAsCSV, fahrenheitToCelsius, fahrenheitToKelvin, feetToMeters, feetToMiles, 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, getColorRamp, getColorRampsByKind, getDateParts, getEventColor, getExportFormatName, getExportHeaders, getLinkClasses, getNumericAxisGutter, getNumericColorClasses, getSkeletonSize, getStateTone, hasTileData, inchesToCentimeters, isCustomPinsLayer, isExportSupported, isGeoJsonLayer, isNil, isRasterLayer, isStreamingSource, isVectorLayer, kelvinToCelsius, kelvinToFahrenheit, kilometersToMiles, layer, metersToFeet, metersToMiles, metersToYards, milesToFeet, milesToKilometers, milesToMeters, parseBoolean, parseInstant, pickEnergyUnit, prepareTableDataForExport, registerPhosphorIcon, resolvePagination, resolveValue, snakeCaseToWords, telemetryPresetRanges, 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, useChartExpand, useChartHeaderMetrics, useChartHeaderWidth, useChartOwnsItsTitle, useChartSourceHost, useChartSourceResolver, useClientDataControls, useColorMode, useContainerBreakpoint, useDataControls, useDebounce, useElementSize, useLocalStorage, useMapStyleOverride, useMediaQuery, useNotice, useServerDataControls, useTableExport, useTileWindow, useTiledTimeSeries, voltageReferenceLines, voltageYDomain, wrapWithLink, yardsToMeters };