@graphysdk/react-renderer 0.0.1-experimental.8 → 0.0.1-plugins.1

package/dist/index.d.ts

@@ -1,50 +1,58 @@
+import { AnnotationZOrder } from '@graphysdk/viz-engine';
 import { AppearanceConfig } from '@graphysdk/viz-engine';
+import { CartesianCoordSystem } from '@graphysdk/viz-engine';
 import { Command } from '@graphysdk/viz-engine';
-import { CompiledPanel } from '@graphysdk/viz-engine';
+import { CompiledLayerFor } from '@graphysdk/viz-engine';
 import { CompiledSpec } from '@graphysdk/viz-engine';
 import { CompilerInput } from '@graphysdk/viz-engine';
-import { ComponentType } from 'react';
+import { CoordSystem } from '@graphysdk/viz-engine';
 import { CSSProperties } from 'react';
 import { CustomPalettesInput } from '@graphysdk/viz-engine';
 import { Data } from '@graphysdk/viz-engine';
 import { FontSpec } from '@graphysdk/viz-engine';
-import { FormattedAxis } from '@graphysdk/viz-engine';
-import { FormattedHeadline } from '@graphysdk/viz-engine';
-import { FormattedLegend } from '@graphysdk/viz-engine';
+import { Geom } from '@graphysdk/viz-engine/extensions';
+import { GeomIdentity } from '@graphysdk/viz-engine';
+import { GeomName } from '@graphysdk/viz-engine';
 import { GraphLayout } from '@graphysdk/viz-engine';
 import { GraphTheme } from '@graphysdk/viz-engine';
-import { HeadlineMeasurer } from '@graphysdk/viz-engine';
+import { HighlightStrategy } from '@graphysdk/viz-engine';
+import { HoverHit } from '@graphysdk/viz-engine';
 import { HoverState } from '@graphysdk/viz-engine';
 import { JSX } from 'react/jsx-runtime';
-import { LayoutEdge } from '@graphysdk/viz-engine';
 import { Locale } from '@graphysdk/viz-engine';
 import { MeasuredText } from '@graphysdk/viz-engine';
+import { Observation } from '@graphysdk/viz-engine';
+import { PolarCoordSystem } from '@graphysdk/viz-engine';
 import { ReactNode } from 'react';
-import { Rect } from '@graphysdk/viz-engine';
-import { ResolvedHeadlineSize } from '@graphysdk/viz-engine';
-import { SourceContent } from '@graphysdk/viz-engine';
-import { TextContent } from '@graphysdk/viz-engine';
+import { ResolvedTarget } from '@graphysdk/viz-engine';
 import { TextMeasurer } from '@graphysdk/viz-engine';
 import { TooltipContent } from '@graphysdk/viz-engine';
 
 /**
- * Props for the AxisLabel slot — the axis title of every axis (e.g. "Revenue"). Override via
- * `slots.AxisLabel` on `GraphRenderer`. `labelRects` are SVG-local, keyed by edge; each title string
- * is `formattedAxes[i].label`. The tick band is a separate region — see `AxisTicks`.
+ * The drawing surface a custom annotation paints into (ADR-035): a panel-positioned [0,1] frame.
+ * `targets` are the resolved coordinates in **top-left [0,1]**; `area` carries the panel's pixel size
+ * for the cases [0,1] cannot express (text extents, fixed-length leaders); `params` is the kind's typed
+ * params. The draw function returns static nodes — annotations have no hover or tooltip.
  */
-export declare interface AxisLabelSlotProps {
-    formattedAxes: FormattedAxis[];
-    labelRects: Partial<Record<LayoutEdge, Rect>>;
+declare interface AnnotationDrawInput<TParams extends object = object> {
+    targets: readonly ResolvedTarget[];
+    area: {
+        width: number;
+        height: number;
+    };
+    params: TParams;
 }
 
 /**
- * Props for the AxisTicks slot — the tick marks and tick labels of every axis. Override via
- * `slots.AxisTicks` on `GraphRenderer`. `tickRects` are SVG-local, keyed by edge; `formattedAxes` is
- * the render-ready viz-engine runtime shape. The axis title is a separate region — see `AxisLabel`.
+ * A custom annotation's render half. `type` resolves it for a compiled annotation; `zOrder` is the
+ * kind's default slot (background paints before geoms, foreground after) — overridable per instance;
+ * `draw` is a React render function that may reuse the render kit (theme tokens, `toPercent`, value
+ * readers) but never participates in hover.
  */
-export declare interface AxisTicksSlotProps {
-    formattedAxes: FormattedAxis[];
-    tickRects: Partial<Record<LayoutEdge, Rect>>;
+declare interface AnnotationPlugin {
+    type: string;
+    zOrder: AnnotationZOrder;
+    draw: (input: AnnotationDrawInput) => ReactNode;
 }
 
 /**
@@ -101,25 +109,13 @@ export declare class CanvasTextMeasurer implements TextMeasurer {
     private getEmojiCorrection;
 }
 
-/** vanilla-extract class that binds the dark token values; set it on any ancestor to flip to dark. */
-export declare const darkTheme: string;
-
-/** Default paint for the footer region — caption and source line. */
-export declare const DefaultFooter: ({ ref, footerRect, mode, caption, isCaptionVisible, source, isSourceVisible, }: FooterSlotProps) => JSX.Element | null;
+declare type CoordKind = CoordSystem['type'];
 
-/** Default paint for the grid region — panel border and per-tick gridlines, drawn inside the panel rect. */
-export declare const DefaultGrid: ({ axes, panel, panelRect }: GridSlotProps) => JSX.Element;
+/** Maps a coord-kind discriminator to the corresponding `CoordSystem` member. */
+declare type CoordSystemFor<C extends CoordKind> = C extends 'cartesian' ? CartesianCoordSystem : C extends 'polar' ? PolarCoordSystem : never;
 
-/** Default paint for the header region — title and subtitle. */
-export declare const DefaultHeader: ({ ref, headerRect, mode, title, isTitleVisible, subtitle, isSubtitleVisible, }: HeaderSlotProps) => JSX.Element | null;
-
-/**
- * Presentational tooltip body. Pure function of props — paints the box, header, and rows.
- * Positioning and data wiring live in the {@link Tooltip} wrapper, never here.
- */
-export declare const DefaultTooltip: ({ content, isVisible }: TooltipSlotProps) => JSX.Element | null;
+export declare const darkTheme: string;
 
-/** Dev-only compile-cache inspector; render inside a `<GraphProvider>`. See {@link DevToolsPanelProps}. */
 export declare const DevToolsPanel: ({ width, style, className }?: DevToolsPanelProps) => JSX.Element;
 
 /**
@@ -136,20 +132,55 @@ export declare interface DevToolsPanelProps {
     className?: string;
 }
 
+/** A geom's declared highlight composition strategy, or `null` when it opts out of highlighting. */
+declare type GeomHighlightStrategy = HighlightStrategy | null;
+
 /**
- * Props for the Footer slot. Override via `slots.Footer` on `GraphRenderer`. The content
- * (caption/source + visibility) arrives as props; in-place caption editing in `editable` mode is
- * internal to this default — an override replacing the region opts out of that editing.
+ * Self-contained module owning everything a single `(geom, coord)` composition needs to paint
+ * and respond to hover. Plugins are dispatched via the registry keyed on `(geom, coord)` —
+ * the registry guarantees the input shapes match the plugin's identity.
+ *
+ * Generic by default: a plugin parameterised as `GeomPlugin<'bar', 'cartesian'>` declares
+ * narrow input types so its handlers receive `CompiledLayerFor<'bar'>` /
+ * `CartesianCoordSystem` directly, no runtime checks. Use {@link defineGeomPlugin} to build
+ * one — the helper centralizes the variance cast so individual plugin files stay free of
+ * `as` assertions.
+ *
+ * The public shape is a flat `NoOverlayAnchor | OverlayAnchor` union so call sites can
+ * invoke `plugin.render(...)` against `CompiledLayerFor<GeomIdentity>` without each call site
+ * having to discriminate. Per-plugin enforcement of `getOverlayAnchor` happens at the
+ * {@link defineGeomPlugin} boundary via {@link GeomPluginForStrategy}, keyed on the plugin's own
+ * declared `highlightStrategy` — so a custom geom is gated by what it declares, not a name lookup.
  */
-export declare interface FooterSlotProps {
-    /** Forward this to the region's outer element — the layout measures the rendered DOM to reserve its space. */
-    ref?: React.Ref<HTMLDivElement>;
-    footerRect: Rect;
-    mode?: GraphMode;
-    caption: TextContent | null;
-    isCaptionVisible: boolean;
-    source: SourceContent | null;
-    isSourceVisible: boolean;
+declare type GeomPlugin<G extends string = GeomIdentity, C extends CoordKind = CoordKind> = NoOverlayAnchorGeomPlugin<G, C, GeomHighlightStrategy, PluginParams<G>> | OverlayAnchorGeomPlugin<G, C, GeomHighlightStrategy, PluginParams<G>>;
+
+declare interface GeomPluginBase<G extends string, C extends CoordKind, S extends GeomHighlightStrategy, TParams> {
+    geom: G;
+    coord: C;
+    /**
+     * The geom's highlight composition strategy — the same value its compile-half declares. Drives the
+     * `getOverlayAnchor` requirement at the {@link defineGeomPlugin} boundary, so the render contract is
+     * derived from a declared strategy rather than a closed geom-name lookup.
+     */
+    highlightStrategy: S;
+    guideMode: HoverGuideMode | null;
+    render: (input: GeomRenderInput<G, C, TParams>) => ReactNode;
+    renderHover: (input: HoverRenderInput<G, C, TParams>) => ReactNode;
+    renderHoverCompanions: (input: HoverCompanionsRenderInput<G, TParams>) => ReactNode;
+    /**
+     * Optional: paints the tooltip body when one of this geom's observations is the primary hit. The
+     * renderer keeps the positioned, themed card and calls this for its contents only; returning `null`
+     * falls through to the default body. The input carries the engine-built {@link TooltipContent} (feed
+     * it to `TooltipBody` to reproduce the default) and the raw `primary.observation`.
+     */
+    renderTooltip?: (input: TooltipRenderInput<G, C, TParams>) => ReactNode;
+}
+
+declare interface GeomRenderInput<G extends string = GeomName, C extends CoordKind = CoordKind, TParams = PluginParams<G>> {
+    layer: CompiledLayerFor<G, TParams>;
+    coordSystem: CoordSystemFor<C>;
+    isAnimated: boolean;
+    formattingLocale: Locale;
 }
 
 /**
@@ -163,7 +194,7 @@ export declare type GraphMode = 'readonly' | 'editable';
  * Owns the compiled spec for a graph and exposes it via {@link useCompiledSpec}, plus a
  * `dispatch` for applying {@link Command}s.
  */
-export declare const GraphProvider: ({ data, input, formattingLocale, onChange, customPalettes, theme, themeOverrides: themeOverridesInput, children, }: GraphProviderProps) => JSX.Element;
+export declare const GraphProvider: ({ data, input, formattingLocale, onChange, customPalettes, theme, themeOverrides: themeOverridesInput, geoms, plugins, annotationPlugins, children, }: GraphProviderProps) => JSX.Element;
 
 declare interface GraphProviderProps {
     data: Data;
@@ -173,6 +204,12 @@ declare interface GraphProviderProps {
     theme?: GraphTheme;
     themeOverrides?: ThemeOverrides;
     customPalettes?: CustomPalettesInput;
+    /** Custom geom definitions, injected per-instance into the compiler (override built-ins by name). */
+    geoms?: readonly Geom[];
+    /** Custom geom render plugins, injected per-instance (override built-ins by `(geom, coord)`). */
+    plugins?: readonly GeomPlugin[];
+    /** Custom annotation render plugins, injected per-instance and resolved by annotation `type` (ADR-035). */
+    annotationPlugins?: readonly AnnotationPlugin[];
     children: ReactNode;
 }
 
@@ -182,106 +219,23 @@ declare interface GraphProviderProps {
  * no `config` prop: every consumer must wrap with `<GraphProvider>` so commands can operate
  * on the live spec.
  */
-export declare const GraphRenderer: ({ slots, sizing, onResize, ...props }: GraphRendererProps) => JSX.Element;
+export declare const GraphRenderer: (props: GraphRendererProps) => JSX.Element;
 
-/** Props for {@link GraphRenderer}: container sizing, interaction toggles, and per-region slot overrides. */
 export declare interface GraphRendererProps {
-    /** Controls how the graph responds to its container size. Defaults to filling the parent container. */
-    sizing?: GraphSizing;
-    /** Callback invoked when the graph's container is resized. Fires in every sizing mode. */
-    onResize?: ResizeObserverOnResize;
+    width: number;
+    height: number;
     isAnimated?: boolean;
     showTooltips?: boolean;
     mode?: GraphMode;
-    /** Per-region component overrides. Unspecified regions render their default. */
-    slots?: GraphSlots;
-}
-
-/** Controls how the graph claims space in its container. */
-export declare type GraphSizing = {
-    mode: 'responsive';
-} | {
-    mode: 'fixed';
-    width: number;
-    height: number;
-} | {
-    mode: 'keepAspectRatio';
-    intrinsicWidth: number;
-    intrinsicHeight: number;
-} | {
-    mode: 'keepAspectRatio';
-    intrinsicWidth: number;
-    aspectRatio: number;
-} | {
-    mode: 'keepAspectRatio';
-    intrinsicHeight: number;
-    aspectRatio: number;
-};
-
-/**
- * Region overrides for `GraphRenderer`. Each slot replaces how one region paints; the viz-engine
- * `Spec` stays the source of truth for whether a region exists and what data it receives. An
- * override is handed the same render-ready props as its default.
- *
- * Layout-safe regions (`Header`, `Footer`, `Tooltip`, `Grid`) are bare components — their size is
- * measured from the rendered DOM, or they reserve no edge space, so the layout never reads them
- * ahead of paint. Layout-coupled regions (`AxisTicks`, `AxisLabel`, `Legend`, `Headline`) are
- * {@link SlotOverride}s: a custom renderer must also declare its reserved size via `measure`,
- * otherwise paint and the reserved band would desync.
- *
- * Each slot owns exactly one region the layout reserves — the axis tick band (`AxisTicks`) and the
- * axis-title band (`AxisLabel`) are separate, mirroring the engine's own split (`GraphLayout.axes`
- * vs `GraphLayout.axisLabels`). Override one and the other keeps its default paint + reservation, so
- * a custom tick band never leaves the title band an unpainted gap.
- */
-export declare interface GraphSlots {
-    Header?: ComponentType<HeaderSlotProps>;
-    Footer?: ComponentType<FooterSlotProps>;
-    Tooltip?: ComponentType<TooltipSlotProps>;
-    Grid?: ComponentType<GridSlotProps>;
-    Legend?: SlotOverride<LegendSlotProps, (legend: FormattedLegend, ctx: SlotMeasureContext) => number>;
-    Headline?: SlotOverride<HeadlineSlotProps, HeadlineMeasurer>;
-    AxisTicks?: SlotOverride<AxisTicksSlotProps, (axis: FormattedAxis, ctx: SlotMeasureContext) => number>;
-    AxisLabel?: SlotOverride<AxisLabelSlotProps, (axis: FormattedAxis, ctx: SlotMeasureContext) => number>;
-}
-
-/**
- * Props for the Grid slot. Override via `slots.Grid` on `GraphRenderer`. `panelRect` is in
- * SVG-local coordinates; `axes` and `panel` are render-ready viz-engine runtime shapes.
- */
-export declare interface GridSlotProps {
-    axes: FormattedAxis[];
-    panel: CompiledPanel;
-    panelRect: GraphLayout['panel'];
 }
 
-/**
- * Props for the Header slot. Override via `slots.Header` on `GraphRenderer`. The content
- * (title/subtitle + visibility) arrives as props; in-place title editing in `editable` mode is
- * internal to this default — an override replacing the region opts out of that editing.
- */
-export declare interface HeaderSlotProps {
-    /** Forward this to the region's outer element — the layout measures the rendered DOM to reserve its space. */
-    ref?: React.Ref<HTMLDivElement>;
-    headerRect: Rect;
-    mode?: GraphMode;
-    title: TextContent | null;
-    isTitleVisible: boolean;
-    subtitle: TextContent | null;
-    isSubtitleVisible: boolean;
+declare interface HoverCompanionsRenderInput<G extends string = GeomName, TParams = PluginParams<G>> {
+    layer: CompiledLayerFor<G, TParams>;
+    primary: HoverHit;
+    related: HoverHit[];
 }
 
-/**
- * Props for the Headline slot. Override via `slots.Headline` on `GraphRenderer`; the data is
- * render-ready, formatted by the viz-engine runtime.
- */
-export declare interface HeadlineSlotProps {
-    headline: FormattedHeadline;
-    rect: Rect;
-    resolvedSize: ResolvedHeadlineSize;
-    /** Leading strip items to paint; the rest are hidden because they would overflow the band. */
-    visibleItemCount: number;
-}
+declare type HoverGuideMode = 'continuous' | 'bar';
 
 /**
  * Hosts the hover store + engine for the surrounding `<GraphProvider>`. Subscribes only to the
@@ -294,72 +248,67 @@ declare interface HoverProviderProps {
     children: ReactNode;
 }
 
+declare interface HoverRenderInput<G extends string = GeomName, C extends CoordKind = CoordKind, TParams = PluginParams<G>> {
+    layer: CompiledLayerFor<G, TParams>;
+    coordSystem: CoordSystemFor<C>;
+    primary: HoverHit;
+    group: HoverHit[];
+    related: HoverHit[];
+    panelRect: GraphLayout['panel'];
+}
+
 declare interface HoverSlice {
     hover: HoverState;
+    /**
+     * Whether the pointer is over the chart's interactive surface. Drives the tooltip's open/close at
+     * the enter/leave boundary. Held as state (not a ref) because that transition must re-render the
+     * tooltip; the cursor *position* stays a ref (see `HoverContextValue.cursorRef`) so pointer-rate
+     * moves reposition through floating-ui without re-rendering.
+     */
+    isPointerInside: boolean;
 }
 
 declare interface HoverStoreActions {
     setHoverState: (next: HoverState) => void;
+    setPointerInside: (value: boolean) => void;
 }
 
-/** State of the hover store: the current {@link HoverState} plus its setter. */
 declare type HoverStoreState = HoverSlice & HoverStoreActions;
 
-/**
- * Props for the Legend slot. Override via `slots.Legend` on `GraphRenderer`; the data is
- * render-ready, formatted by the viz-engine runtime.
- */
-export declare interface LegendSlotProps {
-    formattedLegends: FormattedLegend[];
-    rects: Partial<Record<LayoutEdge, Rect>>;
-    textScale: number;
-}
-
-/** vanilla-extract class that binds the light token values; the default theme. */
 export declare const lightTheme: string;
 
-export declare type ResizeObserverOnResize = (state: ResizeObserverState) => void;
-
-export declare interface ResizeObserverState {
-    width: number;
-    height: number;
-    /** True until the first ResizeObserver measurement lands. */
-    isDefault: boolean;
-}
-
 /**
- * Passed as the second argument to a layout-coupled slot's `measure`. Exposes the renderer's own
- * text measurer — the same Canvas-backed instance the built-in measurers use — and the active
- * text-scale, so a `measure` can size its band from real text metrics without constructing its own
- * measurer or guessing the font size. A `measure` whose size is unrelated to text can ignore it.
+ * Plugin shape for geoms that don't compute an overlay anchor — either `'observation-rerender'`
+ * geoms (matched rows re-render in place) or geoms that opt out of highlighting entirely
+ * (`null` strategy). The renderer never asks these plugins for an anchor, so the property is forbidden.
  */
-export declare interface SlotMeasureContext {
-    /** Measures a string at a given font; returns `{ width, height, ascent, descent }` in CSS pixels. */
-    measureText: TextMeasurer['measureText'];
-    /** Active text-scale multiplier; multiply an em size by this to get the pixel size to measure at. */
-    textScale: number;
+declare interface NoOverlayAnchorGeomPlugin<G extends string, C extends CoordKind, S extends GeomHighlightStrategy, TParams> extends GeomPluginBase<G, C, S, TParams> {
+    getOverlayAnchor?: never;
 }
 
 /**
- * A layout-coupled slot: pairs the region's renderer with the measurer the layout uses to reserve
- * its space. `measure` mirrors the matching `LayoutMeasurer` method, so an override supplies exactly
- * the function the engine would have used — paint and reserved space derive from one source and
- * cannot disagree.
- *
- * Give `measure` a stable reference (module scope, or `useCallback`'d). The measurer it feeds is
- * built once per chart for layout stability, so a `measure` whose identity changes every render is
- * still read on the next paint but does not by itself retrigger a layout pass.
+ * Anchor point in normalized [0,1] coord-space where a highlight overlay marker
+ * should be painted for one observation. Renderer turns [0,1] into pixels.
  */
-export declare interface SlotOverride<Props, Measure> {
-    /** The component that paints the region. */
-    render: ComponentType<Props>;
-    /**
-     * Returns the region's reserved size. Receives the region's formatted data plus a
-     * {@link SlotMeasureContext} (`measureText`, `textScale`) for sizing from real text metrics.
-     */
-    measure: Measure;
+declare interface OverlayAnchor {
+    x: number;
+    y: number;
+}
+
+declare interface OverlayAnchorGeomPlugin<G extends string, C extends CoordKind, S extends GeomHighlightStrategy, TParams> extends GeomPluginBase<G, C, S, TParams> {
+    /** Returns the panel-space anchor for a matched observation. */
+    getOverlayAnchor: (input: OverlayAnchorInput<G, C, TParams>) => OverlayAnchor | null;
+}
+
+declare interface OverlayAnchorInput<G extends string = GeomName, C extends CoordKind = CoordKind, TParams = PluginParams<G>> {
+    layer: CompiledLayerFor<G, TParams>;
+    coordSystem: CoordSystemFor<C>;
+    observation: Observation;
 }
 
+/** The compiled-layer params a plugin's handlers see — built-ins default from the geom name; a custom geom supplies its own. */
+declare type PluginParams<G extends string> = CompiledLayerFor<G>['params'];
+
 /**
  * Creates a font-ready, cached text measurer and shares it with descendants via context.
  * Renders nothing until the measurer resolves, so consumers reading the context always
@@ -384,13 +333,10 @@ declare interface TextMeasurerProviderProps {
     measurer?: TextMeasurer;
 }
 
-/** The name of a single theme token. */
 export declare type ThemeKey = keyof ThemeValues;
 
-/** A partial set of token values layered over a base theme — the shape of the `themeOverrides` prop. */
 export declare type ThemeOverrides = Partial<ThemeValues>;
 
-/** Resolves the base theme plus per-chart `themeOverrides` into token values and publishes them to the subtree. */
 export declare const ThemeProvider: ({ theme, themeOverrides, appearance, children }: ThemeProviderProps) => JSX.Element;
 
 declare interface ThemeProviderProps {
@@ -400,14 +346,21 @@ declare interface ThemeProviderProps {
     children: ReactNode;
 }
 
-/** Every theme token mapped to its resolved CSS string value. */
 export declare type ThemeValues = Record<keyof typeof vars, string>;
 
-export declare interface TooltipSlotProps {
-    /** Render-ready tooltip body, already formatted by the viz-engine runtime. */
+/**
+ * Input a plugin's {@link GeomPluginBase.renderTooltip} receives when one of its observations is the
+ * primary hit. `content` is the body the built-in tooltip would render — feed it to `TooltipBody` to
+ * reproduce the default — while `primary.observation` carries the geom's own columns for a bespoke
+ * layout. The card around the body (positioning, theme) stays the renderer's.
+ */
+declare interface TooltipRenderInput<G extends string = GeomName, C extends CoordKind = CoordKind, TParams = PluginParams<G>> {
     content: TooltipContent;
-    /** Whether the tooltip is currently shown. The wrapper only mounts the slot while open. */
-    isVisible: boolean;
+    layer: CompiledLayerFor<G, TParams>;
+    coordSystem: CoordSystemFor<C>;
+    primary: HoverHit;
+    group: HoverHit[];
+    related: ReadonlyMap<string, HoverHit[]>;
 }
 
 /**
@@ -423,7 +376,6 @@ export declare interface TooltipSlotProps {
  */
 export declare const useCompiledSelector: <Selected>(selector: (compiled: CompiledSpec) => Selected) => Selected;
 
-/** Returns the dispatcher for applying {@link Command}s to the provider's live spec. */
 export declare const useGraphCommandDispatcher: () => ((command: Command) => void);
 
 /**
@@ -431,10 +383,8 @@ export declare const useGraphCommandDispatcher: () => ((command: Command) => voi
  */
 export declare function useHoverState<T>(selector: (state: HoverStoreState) => T): T;
 
-/** Returns the {@link TextMeasurer} from context; throws outside a `<TextMeasurerProvider>`. */
 export declare const useTextMeasurer: () => TextMeasurer;
 
-/** CSS custom-property references for every theme token; read at paint sites as `vars.tooltipBackground`, etc. */
 export declare const vars: {
     white: `var(--${string})`;
     black: `var(--${string})`;
@@ -504,25 +454,6 @@ export declare const vars: {
     annotationMenuTriggerIconColor: `var(--${string})`;
     heatmapEmptyTileBackground: `var(--${string})`;
     dataLabelOutsideBackground: `var(--${string})`;
-    graphPadding: `var(--${string})`;
-    gridLineWidth: `var(--${string})`;
-    gridLineDash: `var(--${string})`;
-    tooltipBorderRadius: `var(--${string})`;
-    tooltipBorderWidth: `var(--${string})`;
-    tooltipPaddingBlock: `var(--${string})`;
-    tooltipPaddingInline: `var(--${string})`;
-    tooltipRowGap: `var(--${string})`;
-    tooltipShadow: `var(--${string})`;
-    tickLabelOffset: `var(--${string})`;
-    legendItemGap: `var(--${string})`;
-    legendSwatchGap: `var(--${string})`;
-    legendSwatchWidth: `var(--${string})`;
-    legendSwatchHeight: `var(--${string})`;
-    legendPillPaddingInline: `var(--${string})`;
-    legendPillPaddingBlock: `var(--${string})`;
-    legendPillBorderWidth: `var(--${string})`;
-    headlineRowGap: `var(--${string})`;
-    headlineItemGap: `var(--${string})`;
     canvasDefault: `var(--${string})`;
     canvasBlue: `var(--${string})`;
     canvasCyan: `var(--${string})`;