@opendata-ai/openchart-core 2.0.0

package/dist/index.d.ts

@@ -0,0 +1,2030 @@
+/**
+ * Responsive breakpoints and layout strategies.
+ *
+ * Three breakpoints based on container width:
+ * - compact: < 400px (mobile, small embeds)
+ * - medium: 400-700px (tablet, sidebars)
+ * - full: > 700px (desktop, full-width)
+ */
+/** Responsive breakpoint based on container width. */
+type Breakpoint = 'compact' | 'medium' | 'full';
+/**
+ * Determine the breakpoint for a given container width.
+ */
+declare function getBreakpoint(width: number): Breakpoint;
+/** Label display mode at a given breakpoint. */
+type LabelMode = 'all' | 'important' | 'none';
+/** Legend position at a given breakpoint. */
+type LegendPosition = 'top' | 'right' | 'bottom' | 'bottom-right' | 'inline';
+/** Annotation position strategy. */
+type AnnotationPosition = 'inline' | 'tooltip-only';
+/** Axis label density (controls tick count reduction). */
+type AxisLabelDensity = 'full' | 'reduced' | 'minimal';
+/**
+ * Layout strategy defining how the visualization adapts to available space.
+ * Returned by getLayoutStrategy() based on the current breakpoint.
+ */
+interface LayoutStrategy {
+    /** How data labels are displayed. */
+    labelMode: LabelMode;
+    /** Where the legend is positioned. */
+    legendPosition: LegendPosition;
+    /** How annotations are displayed. */
+    annotationPosition: AnnotationPosition;
+    /** Axis tick density. */
+    axisLabelDensity: AxisLabelDensity;
+}
+/**
+ * Get the layout strategy for a given breakpoint.
+ *
+ * Compact: minimal chrome, no inline labels, legend on top, reduced axes.
+ * Medium: moderate labels, legend on top, reduced axes.
+ * Full: all labels, legend on right, full axes.
+ */
+declare function getLayoutStrategy(breakpoint: Breakpoint): LayoutStrategy;
+
+/**
+ * Table column configuration types.
+ *
+ * These types define how individual columns in a TableSpec are displayed,
+ * formatted, and enhanced with visual features like heatmaps, bars,
+ * sparklines, images, and category colors.
+ */
+/** Heatmap coloring configuration for a table column. */
+interface HeatmapColumnConfig {
+    /**
+     * Color palette name or array of color stops.
+     * Uses sequential palette from theme if a string name is provided.
+     */
+    palette?: string | string[];
+    /** Explicit domain [min, max] for the color scale. Auto-derived from data if omitted. */
+    domain?: [number, number];
+    /**
+     * Use a different field's values for coloring while displaying this column's values.
+     * Useful for coloring a label column based on a numeric column.
+     */
+    colorByField?: string;
+}
+/** Inline bar configuration for a table column. */
+interface BarColumnConfig {
+    /** Maximum value for the bar scale. Auto-derived from data if omitted. */
+    maxValue?: number;
+    /** Bar fill color. Uses the first categorical palette color if omitted. */
+    color?: string;
+}
+/** Inline sparkline configuration for a table column. */
+interface SparklineColumnConfig {
+    /** Sparkline chart type. Defaults to "line". */
+    type?: 'line' | 'bar' | 'column';
+    /** Field containing the array of values to plot. */
+    valuesField?: string;
+    /** Sparkline color. Uses the first categorical palette color if omitted. */
+    color?: string;
+}
+/** Image cell configuration for a table column. */
+interface ImageColumnConfig {
+    /** Image width in pixels. Defaults to 24. */
+    width?: number;
+    /** Image height in pixels. Defaults to 24. */
+    height?: number;
+    /** Whether to apply border-radius for rounded/circular images. */
+    rounded?: boolean;
+}
+/** Category color mapping for a table column. Maps category values to CSS colors. */
+type CategoryColorsConfig = Record<string, string>;
+/**
+ * Configuration for a single table column.
+ *
+ * At minimum, `key` identifies the data field. All other properties
+ * control display, sorting, formatting, and visual features.
+ *
+ * Only one visual feature (heatmap, bar, sparkline, image, flag, categoryColors)
+ * should be active per column. If multiple are provided, the engine picks
+ * the first one in this precedence order: sparkline > bar > heatmap > image > flag > categoryColors.
+ */
+interface ColumnConfig {
+    /** Data field key (must match a key in the data rows). */
+    key: string;
+    /** Display label for the column header. Defaults to the key if omitted. */
+    label?: string;
+    /** Whether this column is sortable. Defaults to true. */
+    sortable?: boolean;
+    /** Text alignment in the column. Defaults to "left" for text, "right" for numbers. */
+    align?: 'left' | 'center' | 'right';
+    /** Explicit column width (CSS value like "200px" or "20%"). Auto-sized if omitted. */
+    width?: string;
+    /**
+     * Number/date format string (d3-format or d3-time-format).
+     * Applied to the raw value before display. e.g. ",.0f" or "%Y-%m-%d".
+     */
+    format?: string;
+    /** Heatmap: color the cell background based on numeric value. */
+    heatmap?: HeatmapColumnConfig;
+    /** Inline bar: render a proportional bar in the cell. */
+    bar?: BarColumnConfig;
+    /** Sparkline: render a mini line/bar chart in the cell. */
+    sparkline?: SparklineColumnConfig;
+    /** Image: render the cell value as an image URL. */
+    image?: ImageColumnConfig;
+    /** Flag: render the cell value as a country flag emoji or image. */
+    flag?: boolean;
+    /** Category colors: color-code the cell based on its categorical value. */
+    categoryColors?: CategoryColorsConfig;
+}
+
+/**
+ * Spec types: the user-facing input contract.
+ *
+ * These types define what a user (or Claude) writes to describe a visualization.
+ * The engine validates, normalizes, and compiles specs into layout objects.
+ *
+ * Encoding vocabulary follows Vega-Lite conventions (field/type/aggregate)
+ * with editorial extensions for chrome, annotations, responsive, and dark mode.
+ */
+
+/** Supported chart types. Graph is separate since it uses nodes/edges, not data + encoding. */
+type ChartType = 'line' | 'area' | 'bar' | 'column' | 'pie' | 'donut' | 'dot' | 'scatter';
+/** Data field type, following Vega-Lite conventions. */
+type FieldType = 'quantitative' | 'temporal' | 'nominal' | 'ordinal';
+/** Aggregate function applied to a field before encoding. */
+type AggregateOp = 'count' | 'sum' | 'mean' | 'median' | 'min' | 'max';
+/** Axis configuration for an encoding channel. */
+interface AxisConfig {
+    /** Axis label text. If omitted, the field name is used. */
+    label?: string;
+    /** Number format string (d3-format). e.g. ",.0f" for comma-separated integers. */
+    format?: string;
+    /** Override tick count. Engine picks a sensible default if omitted. */
+    tickCount?: number;
+    /** Whether to show gridlines for this axis. */
+    grid?: boolean;
+}
+/** Scale configuration for an encoding channel. */
+interface ScaleConfig {
+    /** Explicit domain override. Auto-derived from data if omitted. */
+    domain?: [number, number] | string[];
+    /** Scale type override. Usually inferred from field type. */
+    type?: 'linear' | 'log' | 'time' | 'band' | 'point' | 'ordinal';
+    /** Whether to nice-ify the domain for clean tick values. Defaults to true. */
+    nice?: boolean;
+    /** Whether the domain should include zero. Defaults to true for quantitative. */
+    zero?: boolean;
+}
+/**
+ * A single encoding channel mapping a data field to a visual property.
+ *
+ * Follows the Vega-Lite encoding model: field identifies the column,
+ * type determines how the engine interprets values, aggregate applies
+ * a transformation before encoding.
+ */
+interface EncodingChannel {
+    /** Data field name (column in the data array). */
+    field: string;
+    /**
+     * How to interpret the field values.
+     * - quantitative: continuous numbers (scale: linear)
+     * - temporal: dates/times (scale: time)
+     * - nominal: unordered categories (scale: ordinal)
+     * - ordinal: ordered categories (scale: ordinal)
+     */
+    type: FieldType;
+    /** Optional aggregate to apply before encoding. */
+    aggregate?: AggregateOp;
+    /** Axis configuration. Only relevant for x and y channels. */
+    axis?: AxisConfig;
+    /** Scale configuration. */
+    scale?: ScaleConfig;
+}
+/**
+ * Encoding object mapping visual channels to data fields.
+ * Which channels are required depends on the chart type.
+ * See ChartEncodingRules in encoding.ts for per-type requirements.
+ */
+interface Encoding {
+    /** Horizontal position channel. */
+    x?: EncodingChannel;
+    /** Vertical position channel. */
+    y?: EncodingChannel;
+    /** Color channel (series differentiation or heatmap). */
+    color?: EncodingChannel;
+    /** Size channel (bubble charts, dot plots). */
+    size?: EncodingChannel;
+    /** Detail channel (group without encoding to a visual property). */
+    detail?: EncodingChannel;
+}
+/** Encoding channel for graph nodes and edges. Same structure as EncodingChannel. */
+interface GraphEncodingChannel {
+    /** Data field name on the node/edge object. */
+    field: string;
+    /** How to interpret the field values. */
+    type?: FieldType;
+}
+/** Graph-specific encoding mapping visual properties to node/edge data fields. */
+interface GraphEncoding {
+    /** Color mapping for nodes. */
+    nodeColor?: GraphEncodingChannel;
+    /** Size mapping for nodes. */
+    nodeSize?: GraphEncodingChannel;
+    /** Color mapping for edges. */
+    edgeColor?: GraphEncodingChannel;
+    /** Width mapping for edges. */
+    edgeWidth?: GraphEncodingChannel;
+    /** Label field for nodes. */
+    nodeLabel?: GraphEncodingChannel;
+}
+/** Layout algorithm for graph visualization. */
+interface GraphLayoutConfig {
+    /** Layout algorithm type. */
+    type: 'force' | 'radial' | 'hierarchical';
+    /** Optional clustering configuration. */
+    clustering?: {
+        /** Field to group nodes by for cluster forces. */
+        field: string;
+    };
+    /** Charge strength for force layout. Negative values create repulsion. */
+    chargeStrength?: number;
+    /** Target distance between linked nodes. */
+    linkDistance?: number;
+}
+/** Style overrides for a chrome text element. */
+interface ChromeTextStyle {
+    /** Font size in pixels. */
+    fontSize?: number;
+    /** Font weight (400 = normal, 600 = semibold, 700 = bold). */
+    fontWeight?: number;
+    /** Font family override. */
+    fontFamily?: string;
+    /** Text color (CSS color string). */
+    color?: string;
+}
+/** A chrome text element with optional style overrides. */
+interface ChromeText {
+    /** The text content to display. */
+    text: string;
+    /** Optional style overrides. Theme defaults are used for any omitted property. */
+    style?: ChromeTextStyle;
+    /** Pixel offset for fine-tuning position. */
+    offset?: AnnotationOffset;
+}
+/**
+ * Editorial chrome elements: title, subtitle, source attribution, byline, footer.
+ * These are first-class structural elements, not string-only afterthoughts.
+ * Each element can be a simple string or a ChromeText object with style overrides.
+ */
+interface Chrome {
+    /** Main title displayed above the visualization. */
+    title?: string | ChromeText;
+    /** Subtitle displayed below the title, typically providing context. */
+    subtitle?: string | ChromeText;
+    /** Data source attribution, displayed below the chart area. */
+    source?: string | ChromeText;
+    /** Author or organization byline. */
+    byline?: string | ChromeText;
+    /** Footer text, displayed at the very bottom. */
+    footer?: string | ChromeText;
+}
+/** Pixel offset for fine-grained annotation positioning. */
+interface AnnotationOffset {
+    /** Horizontal pixel offset. */
+    dx?: number;
+    /** Vertical pixel offset. */
+    dy?: number;
+}
+/** Anchor direction for annotation label placement relative to the data point. */
+type AnnotationAnchor = 'top' | 'bottom' | 'left' | 'right' | 'auto';
+/** Base properties shared by all annotation types. */
+interface AnnotationBase {
+    /** Human-readable label for the annotation. */
+    label?: string;
+    /** Fill color for the annotation element. */
+    fill?: string;
+    /** Stroke color for the annotation element. */
+    stroke?: string;
+    /** Opacity from 0 to 1. */
+    opacity?: number;
+    /** Z-index for render ordering. Higher values render on top. */
+    zIndex?: number;
+}
+/**
+ * Text annotation positioned at a data coordinate.
+ * Shows a callout label at a specific point in the chart.
+ */
+interface TextAnnotation extends AnnotationBase {
+    type: 'text';
+    /** X-axis data value or position. */
+    x: string | number;
+    /** Y-axis data value or position. */
+    y: string | number;
+    /** The annotation text. Required for text annotations. */
+    text: string;
+    /** Font size override. */
+    fontSize?: number;
+    /** Font weight override. */
+    fontWeight?: number;
+    /** Pixel offset from the computed position. */
+    offset?: AnnotationOffset;
+    /** Anchor direction for label placement relative to the data point. */
+    anchor?: AnnotationAnchor;
+    /**
+     * Connector from label to anchor point.
+     * - `true` (default): straight line
+     * - `'curve'`: curved arrow with arrowhead
+     * - `false`: no connector
+     */
+    connector?: boolean | 'curve';
+    /** Per-endpoint offsets for the connector line. Allows fine-tuning where the connector starts and ends. */
+    connectorOffset?: {
+        /** Offset for the label-end of the connector. */
+        from?: AnnotationOffset;
+        /** Offset for the data-point-end of the connector. */
+        to?: AnnotationOffset;
+    };
+    /** Background color behind the text. Useful for readability over chart lines. */
+    background?: string;
+}
+/**
+ * Range annotation highlighting a region of the chart.
+ * Defined by x1/x2 (vertical band) or y1/y2 (horizontal band) or both (rectangle).
+ */
+interface RangeAnnotation extends AnnotationBase {
+    type: 'range';
+    /** Start of the range on the x-axis. */
+    x1?: string | number;
+    /** End of the range on the x-axis. */
+    x2?: string | number;
+    /** Start of the range on the y-axis. */
+    y1?: string | number;
+    /** End of the range on the y-axis. */
+    y2?: string | number;
+    /** Pixel offset for the range label. */
+    labelOffset?: AnnotationOffset;
+    /** Anchor direction for the range label. */
+    labelAnchor?: AnnotationAnchor;
+}
+/**
+ * Reference line annotation: a horizontal or vertical line at a data value.
+ * Useful for baselines (zero), targets, or thresholds.
+ */
+interface RefLineAnnotation extends AnnotationBase {
+    type: 'refline';
+    /** X-axis value for a vertical reference line. */
+    x?: string | number;
+    /** Y-axis value for a horizontal reference line. */
+    y?: string | number;
+    /** Line style. */
+    style?: 'solid' | 'dashed' | 'dotted';
+    /** Line width in pixels. */
+    strokeWidth?: number;
+    /** Pixel offset for the reference line label. */
+    labelOffset?: AnnotationOffset;
+    /** Anchor direction for the reference line label. */
+    labelAnchor?: AnnotationAnchor;
+}
+/** Discriminated union of all annotation types. */
+type Annotation = TextAnnotation | RangeAnnotation | RefLineAnnotation;
+/**
+ * Dark mode behavior.
+ * - "auto": respect system preference (prefers-color-scheme)
+ * - "force": always render in dark mode
+ * - "off": always render in light mode (default)
+ */
+type DarkMode = 'auto' | 'force' | 'off';
+/**
+ * User-facing theme configuration for overriding defaults.
+ * All fields are optional. The engine deep-merges these onto the default theme.
+ */
+interface ThemeConfig {
+    /** Color palette overrides. */
+    colors?: {
+        /** Categorical palette for nominal data (array of CSS color strings). */
+        categorical?: string[];
+        /** Sequential palettes keyed by name. Each is an array of color stops. */
+        sequential?: Record<string, string[]>;
+        /** Diverging palettes keyed by name. Each is an array of color stops with a neutral midpoint. */
+        diverging?: Record<string, string[]>;
+        /** Background color. */
+        background?: string;
+        /** Default text color. */
+        text?: string;
+        /** Gridline color. */
+        gridline?: string;
+        /** Axis line and tick color. */
+        axis?: string;
+    };
+    /** Font overrides. */
+    fonts?: {
+        /** Primary font family. */
+        family?: string;
+        /** Monospace font family (for tabular numbers). */
+        mono?: string;
+    };
+    /** Spacing overrides in pixels. */
+    spacing?: {
+        /** Padding inside the chart container. */
+        padding?: number;
+        /** Gap between chrome elements (title to subtitle, etc.). */
+        chromeGap?: number;
+    };
+    /** Border radius for chart container and tooltips. */
+    borderRadius?: number;
+}
+/**
+ * Label density mode controlling how many data labels are shown.
+ * - 'all': show every label, skip collision detection
+ * - 'auto': show labels with collision detection (default)
+ * - 'endpoints': show only first and last per series (useful for line charts)
+ * - 'none': hide all labels (rely on tooltips and legend)
+ */
+type LabelDensity = 'all' | 'auto' | 'endpoints' | 'none';
+/** Label display configuration for chart data labels. */
+interface LabelConfig {
+    /** How many labels to show. Defaults to 'auto'. */
+    density?: LabelDensity;
+    /** Number format override for label values (d3-format string, e.g. ",.0f"). */
+    format?: string;
+    /** Per-series pixel offsets for fine-tuning label positions, keyed by series name. */
+    offsets?: Record<string, AnnotationOffset>;
+}
+/** Legend display configuration. Overrides the responsive-default position. */
+interface LegendConfig {
+    /** Override the legend position. If omitted, the responsive strategy decides. */
+    position?: LegendPosition;
+    /** Pixel offset for fine-tuning legend position. */
+    offset?: AnnotationOffset;
+}
+/** Data row: a plain object with string keys. */
+type DataRow = Record<string, unknown>;
+/**
+ * Chart specification: the primary input for standard chart types.
+ *
+ * Combines a chart type with data, encoding channels, editorial chrome,
+ * annotations, and configuration. The engine validates, normalizes, and
+ * compiles this into a ChartLayout.
+ */
+interface ChartSpec {
+    /** The chart type to render. */
+    type: ChartType;
+    /** Data array: each element is a row with field values. */
+    data: DataRow[];
+    /** Encoding mapping data fields to visual channels. */
+    encoding: Encoding;
+    /** Editorial chrome (title, subtitle, source, etc.). */
+    chrome?: Chrome;
+    /** Data annotations (text callouts, highlighted ranges, reference lines). */
+    annotations?: Annotation[];
+    /** Label display configuration (density, format). */
+    labels?: LabelConfig;
+    /** Legend display configuration (position override). */
+    legend?: LegendConfig;
+    /** Whether the chart adapts to container width. Defaults to true. */
+    responsive?: boolean;
+    /** Theme configuration overrides. */
+    theme?: ThemeConfig;
+    /** Dark mode behavior. Defaults to "off". */
+    darkMode?: DarkMode;
+}
+/**
+ * Table specification: input for data table visualizations.
+ *
+ * Tables are a visualization type, not just an HTML grid. They support
+ * heatmap coloring, inline sparklines, sorted columns, search, and pagination.
+ */
+interface TableSpec {
+    /** Discriminant: always "table". */
+    type: 'table';
+    /** Data array: each element is a row. */
+    data: DataRow[];
+    /** Column definitions controlling display, sorting, formatting, and mini-charts. */
+    columns: ColumnConfig[];
+    /** Optional field to use as a unique row identifier. */
+    rowKey?: string;
+    /** Editorial chrome. */
+    chrome?: Chrome;
+    /** Theme configuration overrides. */
+    theme?: ThemeConfig;
+    /** Dark mode behavior. */
+    darkMode?: DarkMode;
+    /** Enable client-side search/filter. */
+    search?: boolean;
+    /** Pagination configuration. True for defaults, or an object with pageSize. */
+    pagination?: boolean | {
+        pageSize: number;
+    };
+    /** Whether to stick the first column during horizontal scroll. */
+    stickyFirstColumn?: boolean;
+    /** Compact mode: reduced padding and font sizes. */
+    compact?: boolean;
+    /** Whether the table adapts to container width. Defaults to true. */
+    responsive?: boolean;
+}
+/** Graph node: must have an id, plus arbitrary data fields. */
+interface GraphNode {
+    /** Unique identifier for the node. */
+    id: string;
+    /** Arbitrary data fields. */
+    [key: string]: unknown;
+}
+/** Graph edge: connects two nodes by id. */
+interface GraphEdge {
+    /** Source node id. */
+    source: string;
+    /** Target node id. */
+    target: string;
+    /** Arbitrary data fields (weight, type, confidence, etc.). */
+    [key: string]: unknown;
+}
+/**
+ * Graph specification: input for network/relationship visualizations.
+ *
+ * Uses a nodes + edges data model instead of the flat data + encoding model
+ * used by chart types. The graph type is defined here for forward compatibility
+ * but rendering is deferred to a future phase.
+ */
+interface GraphSpec {
+    /** Discriminant: always "graph". */
+    type: 'graph';
+    /** Node array. Each node must have an id field. */
+    nodes: GraphNode[];
+    /** Edge array. Each edge connects source and target node ids. */
+    edges: GraphEdge[];
+    /** Graph-specific encoding mapping visual properties to node/edge fields. */
+    encoding?: GraphEncoding;
+    /** Layout algorithm configuration. */
+    layout?: GraphLayoutConfig;
+    /** Editorial chrome. */
+    chrome?: Chrome;
+    /** Annotations. */
+    annotations?: Annotation[];
+    /** Theme configuration overrides. */
+    theme?: ThemeConfig;
+    /** Dark mode behavior. */
+    darkMode?: DarkMode;
+}
+/**
+ * Top-level visualization spec: discriminated union on the `type` field.
+ *
+ * This is the primary API contract. Users (and Claude) write VizSpec objects,
+ * the engine validates and compiles them into layout objects for rendering.
+ */
+type VizSpec = ChartSpec | TableSpec | GraphSpec;
+/** Chart spec without runtime data, for persistence/storage. */
+type ChartSpecWithoutData = Omit<ChartSpec, 'data'>;
+/** Table spec without runtime data and columns, for persistence/storage. Columns can be auto-generated via dataTable(). */
+type TableSpecWithoutData = Omit<TableSpec, 'data' | 'columns'>;
+/** Graph spec without runtime data, for persistence/storage. */
+type GraphSpecWithoutData = Omit<GraphSpec, 'nodes' | 'edges'>;
+/** Union of data-stripped spec types for persistence/storage. */
+type StoredVizSpec = ChartSpecWithoutData | TableSpecWithoutData | GraphSpecWithoutData;
+/** All valid chart type strings for runtime checking. */
+declare const CHART_TYPES: ReadonlySet<string>;
+/** Check if a spec is a ChartSpec (any standard chart type). */
+declare function isChartSpec(spec: VizSpec): spec is ChartSpec;
+/** Check if a spec is a TableSpec. */
+declare function isTableSpec(spec: VizSpec): spec is TableSpec;
+/** Check if a spec is a GraphSpec. */
+declare function isGraphSpec(spec: VizSpec): spec is GraphSpec;
+/** Check if an annotation is a TextAnnotation. */
+declare function isTextAnnotation(annotation: Annotation): annotation is TextAnnotation;
+/** Check if an annotation is a RangeAnnotation. */
+declare function isRangeAnnotation(annotation: Annotation): annotation is RangeAnnotation;
+/** Check if an annotation is a RefLineAnnotation. */
+declare function isRefLineAnnotation(annotation: Annotation): annotation is RefLineAnnotation;
+
+/**
+ * Per-chart-type encoding validation rules.
+ *
+ * Defines which encoding channels are required vs optional for each chart type.
+ * The engine compiler uses these rules to validate specs at runtime (TypeScript
+ * catches compile-time errors; these catch runtime JSON from Claude or APIs).
+ */
+
+/** Constraint on what field types are valid for an encoding channel. */
+interface ChannelRule {
+    /** Whether this channel is required for the chart type. */
+    required: boolean;
+    /** Allowed field types. If empty, any field type is accepted. */
+    allowedTypes: FieldType[];
+}
+/** Encoding rules for a single chart type: which channels are required/optional. */
+interface EncodingRule {
+    x: ChannelRule;
+    y: ChannelRule;
+    color: ChannelRule;
+    size: ChannelRule;
+    detail: ChannelRule;
+}
+/**
+ * Encoding rules per chart type.
+ *
+ * Defines which channels are required and what field types they accept.
+ * The compiler uses this map to validate user specs at runtime.
+ *
+ * Key design decisions:
+ * - line/area: x is temporal/ordinal (the axis), y is quantitative (the value)
+ * - bar: horizontal bars, so y is the category axis, x is the value
+ * - column: vertical columns, so x is the category axis, y is the value
+ * - pie/donut: no x axis; y is the value (quantitative), color is the category
+ * - dot: y is the category, x is quantitative
+ * - scatter: both axes are quantitative
+ */
+declare const CHART_ENCODING_RULES: Record<ChartType, EncodingRule>;
+/** Encoding rule for a single graph visual channel. */
+interface GraphChannelRule {
+    /** Whether this channel is required. */
+    required: boolean;
+    /** Allowed field types. Empty means any type. */
+    allowedTypes: FieldType[];
+}
+/**
+ * Encoding rules for graph visualizations.
+ *
+ * All graph encoding channels are optional since a graph can be rendered
+ * with just nodes and edges (uniform appearance). Encoding channels add
+ * visual differentiation based on data fields.
+ */
+declare const GRAPH_ENCODING_RULES: Record<string, GraphChannelRule>;
+
+/**
+ * Chart interaction event types.
+ *
+ * These types define the callback signatures for user interactions with
+ * chart elements: clicking marks, hovering, legend toggles, and annotation clicks.
+ *
+ * Event handlers are optional and passed through MountOptions (vanilla) or
+ * ChartProps (React). The vanilla adapter wires DOM event listeners to
+ * mark elements and constructs these typed events from the raw browser events.
+ */
+
+/** Identifies a specific chrome text element (title, subtitle, source, byline, footer). */
+type ChromeKey = 'title' | 'subtitle' | 'source' | 'byline' | 'footer';
+/**
+ * Discriminated union of all element edit events.
+ * Fired by the `onEdit` callback when any editable chart element is repositioned.
+ */
+type ElementEdit = {
+    type: 'annotation';
+    annotation: TextAnnotation;
+    offset: AnnotationOffset;
+} | {
+    type: 'annotation-connector';
+    annotation: TextAnnotation;
+    endpoint: 'from' | 'to';
+    offset: AnnotationOffset;
+} | {
+    type: 'range-label';
+    annotation: RangeAnnotation;
+    labelOffset: AnnotationOffset;
+} | {
+    type: 'refline-label';
+    annotation: RefLineAnnotation;
+    labelOffset: AnnotationOffset;
+} | {
+    type: 'chrome';
+    key: ChromeKey;
+    text: string;
+    offset: AnnotationOffset;
+} | {
+    type: 'series-label';
+    series: string;
+    offset: AnnotationOffset;
+} | {
+    type: 'legend';
+    offset: AnnotationOffset;
+};
+/**
+ * Event fired when a user interacts with a data mark (bar, point, line segment, etc.).
+ *
+ * Contains the underlying data row, the series it belongs to (if multi-series),
+ * the position within the chart container, and the raw browser MouseEvent.
+ */
+interface MarkEvent {
+    /** The data row associated with the mark that was interacted with. */
+    datum: DataRow;
+    /** Series identifier, if the chart has multiple series (e.g. multi-line). */
+    series?: string;
+    /** Position of the interaction relative to the chart container. */
+    position: {
+        x: number;
+        y: number;
+    };
+    /** The raw browser MouseEvent. */
+    event: MouseEvent;
+}
+/**
+ * Event handler callbacks for chart interactions.
+ *
+ * All handlers are optional. Pass these through MountOptions (vanilla adapter)
+ * or ChartProps (React component) to receive interaction callbacks.
+ */
+interface ChartEventHandlers {
+    /** Called when a data mark is clicked. */
+    onMarkClick?: (event: MarkEvent) => void;
+    /** Called when the mouse enters a data mark. */
+    onMarkHover?: (event: MarkEvent) => void;
+    /** Called when the mouse leaves a data mark. */
+    onMarkLeave?: () => void;
+    /** Called when a legend entry is toggled (clicked to show/hide a series). */
+    onLegendToggle?: (series: string, visible: boolean) => void;
+    /** Called when an annotation element is clicked. */
+    onAnnotationClick?: (annotation: Annotation, event: MouseEvent) => void;
+    /** Called when a text annotation label is dragged to a new position. */
+    onAnnotationEdit?: (annotation: TextAnnotation, updatedOffset: AnnotationOffset) => void;
+    /** Unified edit callback. Fires for any editable chart element (annotations, chrome, legend, series labels). */
+    onEdit?: (edit: ElementEdit) => void;
+}
+
+/**
+ * Theme types: color palettes, typography, spacing, and chrome defaults.
+ *
+ * Theme is the user-facing partial config (all optional).
+ * ResolvedTheme is the engine-internal fully resolved version (no optionals).
+ */
+/** Color palettes for the visualization. */
+interface ThemeColors {
+    /** Categorical palette for nominal data. Array of CSS color strings. */
+    categorical: string[];
+    /** Sequential palettes keyed by name. Each is an array of color stops from light to dark. */
+    sequential: Record<string, string[]>;
+    /** Diverging palettes keyed by name. Each is an array of color stops with a neutral midpoint. */
+    diverging: Record<string, string[]>;
+    /** Background color for the visualization container. */
+    background: string;
+    /** Default text color. */
+    text: string;
+    /** Gridline color. */
+    gridline: string;
+    /** Axis line and tick color. */
+    axis: string;
+    /** Annotation fill color. */
+    annotationFill: string;
+    /** Annotation text color. */
+    annotationText: string;
+}
+/** Font size presets for the typography scale. */
+interface ThemeFontSizes {
+    /** Title font size in pixels. */
+    title: number;
+    /** Subtitle font size in pixels. */
+    subtitle: number;
+    /** Body/label font size in pixels. */
+    body: number;
+    /** Small text (source, footer) font size in pixels. */
+    small: number;
+    /** Axis tick label font size in pixels. */
+    axisTick: number;
+}
+/** Font weight presets. */
+interface ThemeFontWeights {
+    /** Normal text weight. */
+    normal: number;
+    /** Medium text weight (subtitles). */
+    medium: number;
+    /** Semibold text weight (titles). */
+    semibold: number;
+    /** Bold text weight. */
+    bold: number;
+}
+/** Complete typography configuration. */
+interface ThemeFonts {
+    /** Primary font family. */
+    family: string;
+    /** Monospace font family (for tabular numbers). */
+    mono: string;
+    /** Font sizes. */
+    sizes: ThemeFontSizes;
+    /** Font weights. */
+    weights: ThemeFontWeights;
+}
+/** Spacing configuration in pixels. */
+interface ThemeSpacing {
+    /** Padding inside the visualization container (all sides). */
+    padding: number;
+    /** Gap between chrome elements (title to subtitle, subtitle to chart, etc.). */
+    chromeGap: number;
+    /** Gap between the last chrome element and the chart area. */
+    chromeToChart: number;
+    /** Gap between chart area and source/footer below. */
+    chartToFooter: number;
+    /** Internal padding within the chart area (axes margins). */
+    axisMargin: number;
+}
+/** Default style configuration for a chrome text element. */
+interface ChromeDefaults {
+    /** Font size in pixels. */
+    fontSize: number;
+    /** Font weight. */
+    fontWeight: number;
+    /** Text color (CSS color string). */
+    color: string;
+    /** Line height multiplier. */
+    lineHeight: number;
+}
+/** Default chrome styles for each element type. */
+interface ThemeChromeDefaults {
+    title: ChromeDefaults;
+    subtitle: ChromeDefaults;
+    source: ChromeDefaults;
+    byline: ChromeDefaults;
+    footer: ChromeDefaults;
+}
+/**
+ * Complete theme interface. Used internally after merging user overrides
+ * onto defaults. All fields are required here (this is what the engine
+ * works with).
+ *
+ * Users provide ThemeConfig (from spec.ts) which is the partial/optional
+ * version. The theme resolver deep-merges ThemeConfig onto the default Theme
+ * to produce a ResolvedTheme.
+ */
+interface Theme {
+    /** Color palettes. */
+    colors: ThemeColors;
+    /** Typography settings. */
+    fonts: ThemeFonts;
+    /** Spacing values in pixels. */
+    spacing: ThemeSpacing;
+    /** Border radius for containers and tooltips. */
+    borderRadius: number;
+    /** Default chrome text styles. */
+    chrome: ThemeChromeDefaults;
+}
+/**
+ * Fully resolved theme with no optional fields.
+ *
+ * This is the result of resolveTheme(): the default theme with user
+ * overrides deep-merged in. Every property is guaranteed to have a value.
+ * The engine uses ResolvedTheme internally so it never needs null checks.
+ *
+ * Structurally identical to Theme (both have all required fields), but
+ * exists as a separate type for semantic clarity: Theme is the default
+ * definition, ResolvedTheme is the runtime-resolved instance.
+ */
+interface ResolvedTheme extends Theme {
+    /** Whether dark mode adaptations have been applied to this theme. */
+    isDark: boolean;
+}
+
+/** A rectangle defined by position and dimensions. */
+interface Rect {
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+}
+/** Margins around a region (top, right, bottom, left). */
+interface Margins {
+    top: number;
+    right: number;
+    bottom: number;
+    left: number;
+}
+/** A 2D point. */
+interface Point {
+    x: number;
+    y: number;
+}
+/** Resolved text style with all computed values. */
+interface TextStyle {
+    /** Font family. */
+    fontFamily: string;
+    /** Font size in pixels. */
+    fontSize: number;
+    /** Font weight. */
+    fontWeight: number;
+    /** Text color (CSS color string). */
+    fill: string;
+    /** Line height multiplier. */
+    lineHeight: number;
+    /** Text anchor for SVG: start, middle, or end. */
+    textAnchor?: 'start' | 'middle' | 'end';
+    /** Dominant baseline for SVG text vertical alignment. */
+    dominantBaseline?: 'auto' | 'hanging' | 'central' | 'text-after-edge';
+    /** Font variant (e.g. "tabular-nums" for fixed-width digits). */
+    fontVariant?: string;
+}
+/** Cell style for table cells. */
+interface CellStyle {
+    /** Background color. */
+    backgroundColor?: string;
+    /** Text color. */
+    color?: string;
+    /** Font weight. */
+    fontWeight?: number;
+    /** Font variant. */
+    fontVariant?: string;
+}
+/** A single resolved chrome text element with computed position and style. */
+interface ResolvedChromeElement {
+    /** The text content. */
+    text: string;
+    /** X position in the layout coordinate system. */
+    x: number;
+    /** Y position (baseline) in the layout coordinate system. */
+    y: number;
+    /** Maximum width for line wrapping. */
+    maxWidth: number;
+    /** Computed text style. */
+    style: TextStyle;
+}
+/**
+ * Fully resolved chrome with computed positions for all elements.
+ * Only present elements are included (no undefined checks needed at render time).
+ */
+interface ResolvedChrome {
+    /** Total height consumed by chrome elements above the chart area. */
+    topHeight: number;
+    /** Total height consumed by chrome elements below the chart area. */
+    bottomHeight: number;
+    /** Resolved chrome elements. Only present if specified in the spec. */
+    title?: ResolvedChromeElement;
+    subtitle?: ResolvedChromeElement;
+    source?: ResolvedChromeElement;
+    byline?: ResolvedChromeElement;
+    footer?: ResolvedChromeElement;
+}
+/** A single axis tick with computed position and formatted label. */
+interface AxisTick {
+    /** The raw data value at this tick. */
+    value: unknown;
+    /** Pixel position along the axis. */
+    position: number;
+    /** Formatted label string for display. */
+    label: string;
+}
+/** A single gridline with computed positions. */
+interface Gridline {
+    /** Pixel position along the axis. */
+    position: number;
+    /** Whether this is a major or minor gridline. */
+    major: boolean;
+}
+/** Resolved axis layout with computed tick positions and labels. */
+interface AxisLayout {
+    /** Axis ticks with positions and labels. */
+    ticks: AxisTick[];
+    /** Gridlines at tick positions. */
+    gridlines: Gridline[];
+    /** Axis label text (e.g. "GDP Growth (%)"). */
+    label?: string;
+    /** Label style. */
+    labelStyle?: TextStyle;
+    /** Tick label style. */
+    tickLabelStyle: TextStyle;
+    /** Axis line start position. */
+    start: Point;
+    /** Axis line end position. */
+    end: Point;
+}
+/** Accessibility attributes for a mark. */
+interface MarkAria {
+    /** ARIA label for the mark. */
+    label: string;
+    /** Optional longer description. */
+    description?: string;
+    /** ARIA role override. */
+    role?: string;
+}
+/**
+ * Line mark: a series of connected points.
+ * Used by line charts and area chart boundaries.
+ */
+interface LineMark {
+    type: 'line';
+    /** Ordered array of points defining the line path. */
+    points: Point[];
+    /** Pre-computed SVG path string (D3 monotone curve). When present, renderers
+     *  should use this instead of reconstructing straight M/L segments from points. */
+    path?: string;
+    /** Stroke color. */
+    stroke: string;
+    /** Stroke width in pixels. */
+    strokeWidth: number;
+    /** Line dash pattern (empty for solid). */
+    strokeDasharray?: string;
+    /** Series identifier (for multi-series charts). */
+    seriesKey?: string;
+    /** Original data rows for this series. */
+    data: Record<string, unknown>[];
+    /** Resolved label after collision detection. */
+    label?: ResolvedLabel;
+    /** Accessibility attributes. */
+    aria: MarkAria;
+}
+/**
+ * Area mark: a filled region bounded by a top line and a baseline.
+ * Used by area charts.
+ */
+interface AreaMark {
+    type: 'area';
+    /** Upper boundary points. */
+    topPoints: Point[];
+    /** Lower boundary points (baseline, usually y=0). */
+    bottomPoints: Point[];
+    /** SVG path string for the complete area shape. */
+    path: string;
+    /** SVG path string for just the top boundary (for stroking the data line only). */
+    topPath: string;
+    /** Fill color. */
+    fill: string;
+    /** Fill opacity. */
+    fillOpacity: number;
+    /** Optional stroke for the top boundary. */
+    stroke?: string;
+    /** Stroke width. */
+    strokeWidth?: number;
+    /** Series identifier. */
+    seriesKey?: string;
+    /** Original data rows. */
+    data: Record<string, unknown>[];
+    /** Accessibility attributes. */
+    aria: MarkAria;
+}
+/**
+ * Rect mark: a rectangle.
+ * Used by bar charts, column charts, and heatmap cells.
+ */
+interface RectMark {
+    type: 'rect';
+    /** X position. */
+    x: number;
+    /** Y position. */
+    y: number;
+    /** Width. */
+    width: number;
+    /** Height. */
+    height: number;
+    /** Fill color. */
+    fill: string;
+    /** Stroke color. */
+    stroke?: string;
+    /** Stroke width. */
+    strokeWidth?: number;
+    /** Corner radius. */
+    cornerRadius?: number;
+    /** Original data row. */
+    data: Record<string, unknown>;
+    /** Resolved label. */
+    label?: ResolvedLabel;
+    /** Accessibility attributes. */
+    aria: MarkAria;
+}
+/**
+ * Arc mark: a pie/donut slice.
+ * Used by pie and donut charts.
+ */
+interface ArcMark {
+    type: 'arc';
+    /** SVG path string for the arc. */
+    path: string;
+    /** Centroid point (center of the arc, for label positioning). */
+    centroid: Point;
+    /** Center of the pie/donut chart (for SVG translate). */
+    center: Point;
+    /** Inner radius (0 for pie, >0 for donut). */
+    innerRadius: number;
+    /** Outer radius. */
+    outerRadius: number;
+    /** Start angle in radians. */
+    startAngle: number;
+    /** End angle in radians. */
+    endAngle: number;
+    /** Fill color. */
+    fill: string;
+    /** Stroke color (usually white for slice separation). */
+    stroke: string;
+    /** Stroke width. */
+    strokeWidth: number;
+    /** Original data row. */
+    data: Record<string, unknown>;
+    /** Resolved label. */
+    label?: ResolvedLabel;
+    /** Accessibility attributes. */
+    aria: MarkAria;
+}
+/**
+ * Point mark: a circle or dot.
+ * Used by scatter/bubble charts and dot plots.
+ */
+interface PointMark {
+    type: 'point';
+    /** Center x position. */
+    cx: number;
+    /** Center y position. */
+    cy: number;
+    /** Radius in pixels. */
+    r: number;
+    /** Fill color. */
+    fill: string;
+    /** Stroke color. */
+    stroke: string;
+    /** Stroke width. */
+    strokeWidth: number;
+    /** Fill opacity. */
+    fillOpacity?: number;
+    /** Original data row. */
+    data: Record<string, unknown>;
+    /** Resolved label. */
+    label?: ResolvedLabel;
+    /** Accessibility attributes. */
+    aria: MarkAria;
+}
+/** Discriminated union of all mark types. */
+type Mark = LineMark | AreaMark | RectMark | ArcMark | PointMark;
+/**
+ * A resolved label: text with a computed position after collision detection.
+ * The collision engine determines whether labels are visible or demoted to tooltip-only.
+ */
+interface ResolvedLabel {
+    /** Label text content. */
+    text: string;
+    /** Computed x position. */
+    x: number;
+    /** Computed y position (baseline). */
+    y: number;
+    /** Text style. */
+    style: TextStyle;
+    /** Whether this label is visible or was demoted to tooltip-only by collision detection. */
+    visible: boolean;
+    /** If not at the anchor point, draw a connector line from label to anchor. */
+    connector?: {
+        /** Connector start (at the label). */
+        from: Point;
+        /** Connector end (at the data point). */
+        to: Point;
+        /** Connector line color. */
+        stroke: string;
+        /** Connector style: straight line, curved arrow, or directional caret. */
+        style: 'straight' | 'curve' | 'caret';
+    };
+    /** Background color behind the label text. */
+    background?: string;
+}
+/** A resolved annotation with computed pixel positions. */
+interface ResolvedAnnotation {
+    /** Original annotation type. */
+    type: 'text' | 'range' | 'refline';
+    /** Label text (if any). */
+    label?: ResolvedLabel;
+    /** For range: the highlighted rectangle in pixel coordinates. */
+    rect?: Rect;
+    /** For refline: the line start and end in pixel coordinates. */
+    line?: {
+        start: Point;
+        end: Point;
+    };
+    /** Fill color. */
+    fill?: string;
+    /** Stroke color. */
+    stroke?: string;
+    /** Opacity. */
+    opacity?: number;
+    /** Line dash pattern for reflines. */
+    strokeDasharray?: string;
+    /** Stroke width. */
+    strokeWidth?: number;
+    /** Z-index for render ordering. Higher values render on top. */
+    zIndex?: number;
+}
+/** A single entry in the legend. */
+interface LegendEntry {
+    /** The label text (category name or range description). */
+    label: string;
+    /** The color swatch. */
+    color: string;
+    /** Shape of the swatch (matches the mark type). */
+    shape: 'circle' | 'square' | 'line';
+    /** Whether this entry is currently highlighted/active. */
+    active?: boolean;
+}
+/** Resolved legend layout with position and entries. */
+interface LegendLayout {
+    /** Where the legend is positioned relative to the chart area. */
+    position: 'top' | 'right' | 'bottom' | 'bottom-right' | 'inline';
+    /** Legend entries. */
+    entries: LegendEntry[];
+    /** Bounding box for the legend (pixel coordinates). */
+    bounds: Rect;
+    /** Entry label style. */
+    labelStyle: TextStyle;
+    /** Swatch size in pixels. */
+    swatchSize: number;
+    /** Gap between swatch and label. */
+    swatchGap: number;
+    /** Gap between entries. */
+    entryGap: number;
+}
+/** A single field-value pair in a tooltip. */
+interface TooltipField {
+    /** Field label (e.g. "GDP Growth"). */
+    label: string;
+    /** Formatted value (e.g. "4.2%"). */
+    value: string;
+    /** Optional color swatch for series identification. */
+    color?: string;
+}
+/** Tooltip content descriptor for a data point. */
+interface TooltipContent {
+    /** Title line (e.g. the x-axis value like "2020-Q1"). */
+    title?: string;
+    /** Field-value pairs to display. */
+    fields: TooltipField[];
+}
+/** Accessibility metadata for the entire visualization. */
+interface A11yMetadata {
+    /** Generated alt text describing the visualization. */
+    altText: string;
+    /** Tabular data fallback for screen readers. Each inner array is a row. */
+    dataTableFallback: unknown[][];
+    /** ARIA role for the visualization root element. */
+    role: string;
+    /** Whether the visualization is keyboard-navigable. */
+    keyboardNavigable: boolean;
+}
+/**
+ * ChartLayout: the complete engine output for chart visualizations.
+ *
+ * Contains everything an adapter needs to render the chart: dimensions,
+ * chrome text, axes, data marks, annotations, legend, tooltip descriptors,
+ * and accessibility metadata. All values are fully computed pixel positions
+ * and resolved colors.
+ */
+interface ChartLayout {
+    /** The chart drawing area (after chrome, axes, and legend are subtracted). */
+    area: Rect;
+    /** Resolved chrome text elements with positions and styles. */
+    chrome: ResolvedChrome;
+    /** Resolved axis layouts. */
+    axes: {
+        x?: AxisLayout;
+        y?: AxisLayout;
+    };
+    /** Data marks: the visual representation of data points. */
+    marks: Mark[];
+    /** Resolved annotations with pixel positions. */
+    annotations: ResolvedAnnotation[];
+    /** Legend layout (position, entries, bounds). */
+    legend: LegendLayout;
+    /** Tooltip descriptors keyed by a mark identifier. */
+    tooltipDescriptors: Map<string, TooltipContent>;
+    /** Accessibility metadata. */
+    a11y: A11yMetadata;
+    /** The resolved theme used for rendering. */
+    theme: ResolvedTheme;
+    /** Total SVG dimensions. */
+    dimensions: {
+        width: number;
+        height: number;
+    };
+}
+/** A resolved column definition with computed properties. */
+interface ResolvedColumn {
+    /** Column key (data field name). */
+    key: string;
+    /** Display label. */
+    label: string;
+    /** Computed width in pixels. */
+    width: number;
+    /** Whether sorting is enabled. */
+    sortable: boolean;
+    /** Text alignment. */
+    align: 'left' | 'center' | 'right';
+    /** Column cell type (determines rendering strategy). */
+    cellType: 'text' | 'heatmap' | 'category' | 'bar' | 'sparkline' | 'image' | 'flag';
+}
+/** Base properties for all table cell types. */
+interface TableCellBase {
+    /** Raw value from the data. */
+    value: unknown;
+    /** Formatted display value. */
+    formattedValue: string;
+    /** Computed cell style. */
+    style: CellStyle;
+    /** ARIA label for the cell. */
+    aria?: string;
+}
+/** Plain text cell. */
+interface TextTableCell extends TableCellBase {
+    cellType: 'text';
+}
+/** Heatmap-colored cell. */
+interface HeatmapTableCell extends TableCellBase {
+    cellType: 'heatmap';
+}
+/** Category-colored cell. */
+interface CategoryTableCell extends TableCellBase {
+    cellType: 'category';
+}
+/** Cell with an inline bar visualization. */
+interface BarTableCell extends TableCellBase {
+    cellType: 'bar';
+    /** Bar width as a proportion (0 to 1) of available cell width. */
+    barWidth: number;
+    /** Bar left-edge offset as a proportion (0 to 1). 0 = left edge. */
+    barOffset: number;
+    /** Bar fill color. */
+    barColor: string;
+    /** Whether this bar represents a negative value. */
+    isNegative: boolean;
+}
+/** Normalized sparkline data ready for rendering. */
+interface SparklineData {
+    /** Sparkline type. */
+    type: 'line' | 'bar' | 'column';
+    /** Normalized points in 0-1 range (for line type: x/y coordinates). */
+    points: Array<{
+        x: number;
+        y: number;
+    }>;
+    /** For bar/column: widths or heights as 0-1 proportions. */
+    bars: number[];
+    /** Sparkline stroke/fill color. */
+    color: string;
+    /** Number of data points. */
+    count: number;
+    /** Raw value of the first data point. */
+    startValue: number;
+    /** Raw value of the last data point. */
+    endValue: number;
+}
+/** Cell with an inline sparkline. */
+interface SparklineTableCell extends TableCellBase {
+    cellType: 'sparkline';
+    /** Sparkline rendering data (normalized points, color, type). Null when no valid data. */
+    sparklineData: SparklineData | null;
+}
+/** Cell with an image. */
+interface ImageTableCell extends TableCellBase {
+    cellType: 'image';
+    /** Image URL. */
+    src: string;
+    /** Image width. */
+    imageWidth: number;
+    /** Image height. */
+    imageHeight: number;
+    /** Whether to apply rounded styling. */
+    rounded: boolean;
+}
+/** Cell displaying a flag. */
+interface FlagTableCell extends TableCellBase {
+    cellType: 'flag';
+    /** Country code or flag identifier. */
+    countryCode: string;
+}
+/** Discriminated union of all table cell types. */
+type TableCell = TextTableCell | HeatmapTableCell | CategoryTableCell | BarTableCell | SparklineTableCell | ImageTableCell | FlagTableCell;
+/** A resolved table row. */
+interface TableRow {
+    /** Unique row identifier. */
+    id: string;
+    /** Resolved cells in column order. */
+    cells: TableCell[];
+    /** Original data row. */
+    data: Record<string, unknown>;
+}
+/** Pagination state for the table. */
+interface PaginationState {
+    /** Current page (0-indexed). */
+    page: number;
+    /** Rows per page. */
+    pageSize: number;
+    /** Total number of rows. */
+    totalRows: number;
+    /** Total number of pages. */
+    totalPages: number;
+}
+/** Sort state for the table. */
+interface SortState {
+    /** Column key being sorted. */
+    column: string;
+    /** Sort direction. */
+    direction: 'asc' | 'desc';
+}
+/**
+ * TableLayout: the complete engine output for table visualizations.
+ *
+ * Contains resolved columns, rows with computed cell values and styles,
+ * pagination, sort, search state, and accessibility metadata.
+ */
+interface TableLayout {
+    /** Resolved chrome text elements. */
+    chrome: ResolvedChrome;
+    /** Resolved column definitions. */
+    columns: ResolvedColumn[];
+    /** Resolved table rows with computed cell values and styles. */
+    rows: TableRow[];
+    /** Current sort state. */
+    sort?: SortState;
+    /** Pagination state. */
+    pagination?: PaginationState;
+    /** Whether search is enabled. */
+    search: {
+        enabled: boolean;
+        placeholder: string;
+        query: string;
+    };
+    /** Whether the first column is sticky. */
+    stickyFirstColumn: boolean;
+    /** Whether compact mode is active. */
+    compact: boolean;
+    /** Accessibility metadata. */
+    a11y: {
+        caption: string;
+        summary: string;
+    };
+    /** The resolved theme. */
+    theme: ResolvedTheme;
+}
+/** A resolved graph node with computed position and visual properties. */
+interface GraphNodeLayout {
+    /** Node id. */
+    id: string;
+    /** Computed x position. */
+    x: number;
+    /** Computed y position. */
+    y: number;
+    /** Node radius in pixels. */
+    radius: number;
+    /** Fill color. */
+    fill: string;
+    /** Stroke color. */
+    stroke: string;
+    /** Stroke width. */
+    strokeWidth: number;
+    /** Node label. */
+    label?: ResolvedLabel;
+    /** Original node data. */
+    data: Record<string, unknown>;
+    /** Community/cluster identifier (from clustering config). */
+    community?: string;
+    /** Accessibility attributes. */
+    aria: MarkAria;
+}
+/** A resolved graph edge with computed positions and visual properties. */
+interface GraphEdgeLayout {
+    /** Source node id. */
+    source: string;
+    /** Target node id. */
+    target: string;
+    /** Source x position. */
+    x1: number;
+    /** Source y position. */
+    y1: number;
+    /** Target x position. */
+    x2: number;
+    /** Target y position. */
+    y2: number;
+    /** Stroke color. */
+    stroke: string;
+    /** Stroke width. */
+    strokeWidth: number;
+    /** Line style. */
+    style: 'solid' | 'dashed' | 'dotted';
+    /** Original edge data. */
+    data: Record<string, unknown>;
+}
+/**
+ * GraphLayout: the complete engine output for network graph visualizations.
+ *
+ * Note: GraphLayout is defined here for forward compatibility but the engine
+ * won't produce it until the graph renderer is implemented in a future phase.
+ */
+interface GraphLayout {
+    /** The graph drawing area. */
+    area: Rect;
+    /** Resolved chrome text. */
+    chrome: ResolvedChrome;
+    /** Resolved node positions and visual properties. */
+    nodes: GraphNodeLayout[];
+    /** Resolved edge positions and visual properties. */
+    edges: GraphEdgeLayout[];
+    /** Legend layout. */
+    legend: LegendLayout;
+    /** Tooltip descriptors. */
+    tooltipDescriptors: Map<string, TooltipContent>;
+    /** Accessibility metadata. */
+    a11y: A11yMetadata;
+    /** The resolved theme. */
+    theme: ResolvedTheme;
+    /** Total dimensions. */
+    dimensions: {
+        width: number;
+        height: number;
+    };
+}
+/** Function signature for text measurement provided by adapters. */
+type MeasureTextFn = (text: string, fontSize: number, fontWeight?: number) => {
+    width: number;
+    height: number;
+};
+/**
+ * Options passed to the engine's compile functions.
+ *
+ * Width and height define the total available space. The engine subtracts
+ * chrome, axes, and legend to compute the chart drawing area.
+ */
+interface CompileOptions {
+    /** Total available width in pixels. */
+    width: number;
+    /** Total available height in pixels. */
+    height: number;
+    /** Theme overrides. */
+    theme?: ThemeConfig;
+    /**
+     * Resolved dark mode boolean.
+     *
+     * Note: this is a boolean, not the DarkMode union ("auto" | "force" | "off").
+     * Adapters resolve "auto" by checking window.matchMedia('(prefers-color-scheme: dark)')
+     * before calling compile. The engine always receives a resolved boolean.
+     */
+    darkMode?: boolean;
+    /**
+     * Real text measurement function provided by the adapter.
+     * Uses a hidden canvas or DOM element for accurate text dimensions.
+     * If not provided, the engine falls back to heuristic estimation.
+     */
+    measureText?: MeasureTextFn;
+}
+/** Extended compile options for table visualizations. */
+interface CompileTableOptions extends CompileOptions {
+    /** Current sort state to apply. */
+    sort?: SortState;
+    /** Search query to filter rows. */
+    search?: string;
+    /** Current page (0-indexed). */
+    page?: number;
+    /** Rows per page. */
+    pageSize?: number;
+}
+
+/**
+ * Color blindness simulation and palette distinguishability checks.
+ *
+ * Uses Brettel, Vienot, and Mollon (1997) simulation matrices for
+ * protanopia, deuteranopia, and tritanopia.
+ *
+ * These are approximations suitable for checking palette accessibility,
+ * not medical-grade simulations.
+ */
+/** The three common types of color vision deficiency. */
+type ColorBlindnessType = 'protanopia' | 'deuteranopia' | 'tritanopia';
+/**
+ * Simulate how a color appears under a given color blindness type.
+ * Returns a hex color string.
+ */
+declare function simulateColorBlindness(color: string, type: ColorBlindnessType): string;
+/**
+ * Check if colors in a palette are distinguishable under a given
+ * color blindness type.
+ *
+ * Uses a minimum perceptual distance threshold in simulated space.
+ * Returns true if all pairs of colors are sufficiently different.
+ */
+declare function checkPaletteDistinguishability(colors: string[], type: ColorBlindnessType, minDistance?: number): boolean;
+
+/**
+ * WCAG contrast ratio utilities.
+ *
+ * Uses d3-color for color space parsing and manipulation.
+ * All functions accept CSS color strings (hex, rgb, hsl, named colors).
+ */
+/**
+ * Compute the WCAG contrast ratio between two colors.
+ * Returns a value between 1 (identical) and 21 (black on white).
+ */
+declare function contrastRatio(fg: string, bg: string): number;
+/**
+ * Check if two colors meet WCAG AA contrast requirements.
+ * Normal text: 4.5:1, large text (18px+ bold or 24px+): 3:1.
+ */
+declare function meetsAA(fg: string, bg: string, largeText?: boolean): boolean;
+/**
+ * Find an accessible variant of `baseColor` against `bg`.
+ *
+ * Preserves the hue and saturation of baseColor but adjusts lightness
+ * until the target contrast ratio is met. Returns the original color
+ * if it already meets the target.
+ */
+declare function findAccessibleColor(baseColor: string, bg: string, targetRatio?: number): string;
+
+/**
+ * Color palettes for @opendata-ai.
+ *
+ * Categorical palette is Infrographic-influenced with WCAG AA contrast
+ * for large text (3:1 ratio) on both light (#ffffff) and dark (#1a1a2e)
+ * backgrounds. Several colors do not meet the stricter 4.5:1 ratio
+ * required for normal-sized body text. This is acceptable because chart
+ * marks (bars, lines, areas, points) are large visual elements.
+ *
+ * Sequential palettes: 5-7 stops from light to dark.
+ * Diverging palettes: 7 stops with a neutral midpoint.
+ */
+/**
+ * Default categorical palette. 10 visually distinct colors that meet
+ * WCAG AA contrast for large text (3:1) on both white and near-black
+ * backgrounds. Some colors fall below the 4.5:1 threshold for normal
+ * body text. Influenced by Infrographic's editorial palette with tweaks
+ * for accessibility and colorblind distinguishability.
+ */
+declare const CATEGORICAL_PALETTE: readonly ["#1b7fa3", "#c44e52", "#6a9f58", "#d47215", "#507e79", "#9a6a8d", "#c4636b", "#9c755f", "#a88f22", "#858078"];
+type CategoricalPalette = typeof CATEGORICAL_PALETTE;
+/** Sequential palette definition: an array of color stops from light to dark. */
+interface SequentialPalette {
+    readonly name: string;
+    readonly stops: readonly string[];
+}
+/** All sequential palettes keyed by name. */
+declare const SEQUENTIAL_PALETTES: Record<string, string[]>;
+/** Diverging palette definition: an array of color stops with a neutral midpoint. */
+interface DivergingPalette {
+    readonly name: string;
+    readonly stops: readonly string[];
+}
+/** All diverging palettes keyed by name. */
+declare const DIVERGING_PALETTES: Record<string, string[]>;
+
+/**
+ * Dark mode theme adaptation.
+ *
+ * Preserves hue of colors while adjusting lightness and saturation
+ * to maintain the same relative contrast ratios on a dark background.
+ */
+
+/**
+ * Adapt a single color for dark mode.
+ *
+ * Preserves the hue and adjusts lightness/saturation so the adapted
+ * color has the same contrast ratio against darkBg as the original
+ * had against lightBg.
+ */
+declare function adaptColorForDarkMode(color: string, lightBg: string, darkBg: string): string;
+/**
+ * Adapt an entire resolved theme for dark mode.
+ *
+ * Swaps background/text, adapts categorical and annotation colors,
+ * adjusts gridline and axis colors for the dark background.
+ */
+declare function adaptTheme(theme: ResolvedTheme): ResolvedTheme;
+
+/**
+ * Default theme definition.
+ *
+ * Tuned to match Infrographic's visual weight and editorial style.
+ * Inter font family, typography hierarchy for chrome, and color
+ * palettes from the colors module.
+ */
+
+/**
+ * The default theme. All fields are required and fully specified.
+ * resolveTheme() deep-merges user overrides onto this base.
+ */
+declare const DEFAULT_THEME: Theme;
+
+/**
+ * Theme resolver: deep-merges user overrides onto default theme.
+ *
+ * Produces a ResolvedTheme where every property is guaranteed to have
+ * a value. The engine uses ResolvedTheme internally so it never needs
+ * null checks on theme properties.
+ *
+ * Auto-detects dark backgrounds and adapts chrome text colors so
+ * custom themes with dark canvases are readable without explicitly
+ * enabling darkMode.
+ */
+
+/**
+ * Resolve a theme by deep-merging user overrides onto a base theme.
+ *
+ * Auto-detects dark backgrounds: if the resolved background color is
+ * perceptually dark and chrome text colors are still the light-mode
+ * defaults, they're adapted for readability.
+ *
+ * @param userTheme - Optional partial theme overrides from the spec.
+ * @param base - Base theme to merge onto. Defaults to DEFAULT_THEME.
+ * @returns A ResolvedTheme with all properties guaranteed.
+ */
+declare function resolveTheme(userTheme?: ThemeConfig, base?: Theme): ResolvedTheme;
+
+/**
+ * Chrome layout computation.
+ *
+ * Takes a Chrome spec + resolved theme and produces a ResolvedChrome
+ * with computed text positions, styles, and total chrome heights.
+ */
+
+/**
+ * Compute resolved chrome layout from a Chrome spec and resolved theme.
+ *
+ * Produces positioned text elements and total chrome heights (top and bottom).
+ * Top chrome: title, subtitle. Bottom chrome: source, byline, footer.
+ *
+ * @param chrome - The Chrome spec from the user's VizSpec.
+ * @param theme - The fully resolved theme.
+ * @param width - Total available width in pixels.
+ * @param measureText - Optional real text measurement function from the adapter.
+ */
+declare function computeChrome(chrome: Chrome | undefined, theme: ResolvedTheme, width: number, measureText?: MeasureTextFn): ResolvedChrome;
+
+/**
+ * Heuristic text measurement for environments without a DOM.
+ *
+ * These are intentionally approximate. Adapters can provide a real
+ * measureText function via CompileOptions for higher accuracy.
+ * The engine uses the real function when available, falls back to
+ * these heuristics when not.
+ */
+/**
+ * Estimate the rendered width of a text string.
+ *
+ * Uses a per-character average width based on font size, adjusted
+ * for font weight. Accurate to within ~20% for Latin text in Inter.
+ *
+ * @param text - The text string to measure.
+ * @param fontSize - Font size in pixels.
+ * @param fontWeight - Font weight (100-900). Defaults to 400.
+ */
+declare function estimateTextWidth(text: string, fontSize: number, fontWeight?: number): number;
+
+/**
+ * Label collision detection and resolution.
+ *
+ * Greedy algorithm: sort by priority, place in order, try offset
+ * positions for conflicts, demote to tooltip-only if no position works.
+ * Targeting ~60% of Infrographic quality for Phase 0.
+ */
+
+/** Priority levels for label placement. Data labels win over annotations which win over axes. */
+type LabelPriority = 'data' | 'annotation' | 'axis';
+/**
+ * A label candidate for collision resolution.
+ * The collision engine decides its final position and visibility.
+ */
+interface LabelCandidate {
+    /** The label text. */
+    text: string;
+    /** Preferred anchor position (before collision resolution). */
+    anchorX: number;
+    /** Preferred anchor position (before collision resolution). */
+    anchorY: number;
+    /** Estimated width of the label text. */
+    width: number;
+    /** Estimated height of the label text. */
+    height: number;
+    /** Label priority for collision resolution. */
+    priority: LabelPriority;
+    /** Text style to apply. */
+    style: TextStyle;
+}
+/**
+ * Resolve label collisions using a greedy placement algorithm.
+ *
+ * Sorts labels by priority (data > annotation > axis), then places
+ * each label at its preferred position. If it collides with an already-placed
+ * label, tries offset positions. If no position works, the label is
+ * demoted to tooltip-only (visible: false).
+ *
+ * @param labels - Array of label candidates to position.
+ * @returns Array of resolved labels with computed positions and visibility.
+ */
+declare function resolveCollisions(labels: LabelCandidate[]): ResolvedLabel[];
+
+/**
+ * Locale-aware number and date formatting utilities.
+ *
+ * Uses d3-format and d3-time-format for formatting,
+ * with convenience wrappers for common patterns.
+ */
+/**
+ * Format a number with locale-appropriate separators.
+ *
+ * Uses d3-format under the hood. Default format: comma-separated
+ * with auto-precision (e.g. 1500000 -> "1,500,000").
+ *
+ * @param value - The number to format.
+ * @param locale - Locale string (currently unused, reserved for i18n).
+ */
+declare function formatNumber(value: number, _locale?: string): string;
+/**
+ * Abbreviate a large number with a suffix.
+ *
+ * Examples:
+ * - 1500000 -> "1.5M"
+ * - 2300 -> "2.3K"
+ * - 42 -> "42"
+ * - 1000000000 -> "1B"
+ */
+declare function abbreviateNumber(value: number): string;
+/** Granularity levels for date formatting. */
+type DateGranularity = 'year' | 'quarter' | 'month' | 'week' | 'day' | 'hour' | 'minute';
+/**
+ * Format a date value for display.
+ *
+ * @param value - Date object, ISO string, or timestamp number.
+ * @param locale - Locale string (currently unused, reserved for i18n).
+ * @param granularity - Time granularity for format selection.
+ */
+declare function formatDate(value: Date | string | number, _locale?: string, granularity?: DateGranularity): string;
+
+/**
+ * Automatic alt text generation for chart accessibility.
+ *
+ * Produces human-readable descriptions of chart content for screen readers
+ * and a tabular fallback for data access.
+ */
+
+/**
+ * Generate alt text describing a chart's content.
+ *
+ * Produces a description like:
+ * "Line chart showing GDP Growth Rate from 2020 to 2024 with 2 series (US, UK)"
+ *
+ * @param spec - The chart spec.
+ * @param data - The data array.
+ */
+declare function generateAltText(spec: ChartSpec, data: DataRow[]): string;
+/**
+ * Generate a tabular data fallback for screen readers.
+ *
+ * Returns a 2D array where the first row is headers and subsequent
+ * rows are data values. Only includes fields referenced in the encoding.
+ *
+ * @param spec - The chart spec.
+ * @param data - The data array.
+ */
+declare function generateDataTable(spec: ChartSpec, data: DataRow[]): unknown[][];
+
+/**
+ * ARIA label generation for individual marks.
+ *
+ * Produces per-mark labels for screen reader navigation, enabling
+ * users to explore data points individually.
+ */
+
+/**
+ * Generate ARIA labels for a set of marks.
+ *
+ * Returns a Map keyed by a mark identifier (index-based) with
+ * descriptive labels like "Data point: US GDP 42 in 2020-01".
+ *
+ * @param marks - Array of mark objects from the compiled chart layout.
+ */
+declare function generateAriaLabels(marks: Mark[]): Map<string, string>;
+
+/**
+ * Spec construction helpers: typed builder functions for common chart types.
+ *
+ * These builders reduce boilerplate when creating specs programmatically.
+ * They accept field names as strings (simple case) or full EncodingChannel
+ * objects (when you need to customize type, aggregate, axis, or scale).
+ *
+ * Type inference: when a string field name is provided, the builder samples
+ * data values to infer the encoding type (quantitative, temporal, nominal).
+ */
+
+/** A field reference: either a plain string (field name) or a full EncodingChannel. */
+type FieldRef = string | EncodingChannel;
+/** Common options shared by all chart builder functions. */
+interface ChartBuilderOptions {
+    /** Color encoding: field name or full channel config for series differentiation. */
+    color?: FieldRef;
+    /** Size encoding: field name or full channel config. */
+    size?: FieldRef;
+    /** Editorial chrome (title, subtitle, source, etc.). */
+    chrome?: Chrome;
+    /** Data annotations. */
+    annotations?: Annotation[];
+    /** Whether the chart adapts to container width. Defaults to true. */
+    responsive?: boolean;
+    /** Theme configuration overrides. */
+    theme?: ThemeConfig;
+    /** Dark mode behavior. */
+    darkMode?: DarkMode;
+}
+/** Options for the dataTable builder. */
+interface TableBuilderOptions {
+    /** Column definitions. Auto-generated from data keys if omitted. */
+    columns?: ColumnConfig[];
+    /** Field to use as a unique row identifier. */
+    rowKey?: string;
+    /** Editorial chrome. */
+    chrome?: Chrome;
+    /** Theme configuration overrides. */
+    theme?: ThemeConfig;
+    /** Dark mode behavior. */
+    darkMode?: DarkMode;
+    /** Enable client-side search/filter. */
+    search?: boolean;
+    /** Pagination configuration. */
+    pagination?: boolean | {
+        pageSize: number;
+    };
+    /** Stick the first column during horizontal scroll. */
+    stickyFirstColumn?: boolean;
+    /** Compact mode. */
+    compact?: boolean;
+    /** Whether the table adapts to container width. */
+    responsive?: boolean;
+}
+/**
+ * Infer the encoding field type from data values.
+ *
+ * Samples up to 20 values from the data array for the given field.
+ * - If all sampled values are numbers (or null/undefined), returns "quantitative".
+ * - If all sampled string values match ISO date patterns, returns "temporal".
+ * - Otherwise returns "nominal".
+ */
+declare function inferFieldType(data: DataRow[], field: string): FieldType;
+/**
+ * Create a line chart spec.
+ *
+ * @param data - Array of data rows.
+ * @param x - X-axis field (typically temporal or ordinal).
+ * @param y - Y-axis field (typically quantitative).
+ * @param options - Optional color, size, chrome, annotations, theme, etc.
+ */
+declare function lineChart(data: DataRow[], x: FieldRef, y: FieldRef, options?: ChartBuilderOptions): ChartSpec;
+/**
+ * Create a bar chart spec (horizontal bars).
+ *
+ * Convention: category goes on y-axis, value on x-axis.
+ * The `category` param maps to y, `value` maps to x.
+ *
+ * @param data - Array of data rows.
+ * @param category - Category field (y-axis, nominal/ordinal).
+ * @param value - Value field (x-axis, quantitative).
+ * @param options - Optional color, size, chrome, annotations, theme, etc.
+ */
+declare function barChart(data: DataRow[], category: FieldRef, value: FieldRef, options?: ChartBuilderOptions): ChartSpec;
+/**
+ * Create a column chart spec (vertical columns).
+ *
+ * @param data - Array of data rows.
+ * @param x - X-axis field (category or temporal).
+ * @param y - Y-axis field (quantitative value).
+ * @param options - Optional color, size, chrome, annotations, theme, etc.
+ */
+declare function columnChart(data: DataRow[], x: FieldRef, y: FieldRef, options?: ChartBuilderOptions): ChartSpec;
+/**
+ * Create a pie chart spec.
+ *
+ * Convention: category maps to the color channel, value maps to y.
+ * Pie charts have no x-axis.
+ *
+ * @param data - Array of data rows.
+ * @param category - Category field (color channel, nominal).
+ * @param value - Value field (y channel, quantitative).
+ * @param options - Optional chrome, annotations, theme, etc.
+ *                  Note: color option is ignored since category is used for color.
+ */
+declare function pieChart(data: DataRow[], category: FieldRef, value: FieldRef, options?: ChartBuilderOptions): ChartSpec;
+/**
+ * Create an area chart spec.
+ *
+ * @param data - Array of data rows.
+ * @param x - X-axis field (typically temporal or ordinal).
+ * @param y - Y-axis field (typically quantitative).
+ * @param options - Optional color, size, chrome, annotations, theme, etc.
+ */
+declare function areaChart(data: DataRow[], x: FieldRef, y: FieldRef, options?: ChartBuilderOptions): ChartSpec;
+/**
+ * Create a donut chart spec.
+ *
+ * Convention: category maps to the color channel, value maps to y.
+ * Donut charts have no x-axis.
+ *
+ * @param data - Array of data rows.
+ * @param category - Category field (color channel, nominal).
+ * @param value - Value field (y channel, quantitative).
+ * @param options - Optional chrome, annotations, theme, etc.
+ *                  Note: color option is ignored since category is used for color.
+ */
+declare function donutChart(data: DataRow[], category: FieldRef, value: FieldRef, options?: ChartBuilderOptions): ChartSpec;
+/**
+ * Create a dot chart spec (strip plot / dot plot).
+ *
+ * @param data - Array of data rows.
+ * @param x - X-axis field (quantitative or temporal).
+ * @param y - Y-axis field (nominal/categorical grouping).
+ * @param options - Optional color, size, chrome, annotations, theme, etc.
+ */
+declare function dotChart(data: DataRow[], x: FieldRef, y: FieldRef, options?: ChartBuilderOptions): ChartSpec;
+/**
+ * Create a scatter chart spec.
+ *
+ * @param data - Array of data rows.
+ * @param x - X-axis field (quantitative).
+ * @param y - Y-axis field (quantitative).
+ * @param options - Optional color, size, chrome, annotations, theme, etc.
+ */
+declare function scatterChart(data: DataRow[], x: FieldRef, y: FieldRef, options?: ChartBuilderOptions): ChartSpec;
+/**
+ * Create a data table spec.
+ *
+ * If no columns are specified, auto-generates column configs from the
+ * keys of the first data row.
+ *
+ * @param data - Array of data rows.
+ * @param options - Column definitions, chrome, pagination, search, etc.
+ */
+declare function dataTable(data: DataRow[], options?: TableBuilderOptions): TableSpec;
+
+export { type A11yMetadata, type AggregateOp, type Annotation, type AnnotationAnchor, type AnnotationOffset, type AnnotationPosition, type ArcMark, type AreaMark, type AxisConfig, type AxisLabelDensity, type AxisLayout, type AxisTick, type BarColumnConfig, type BarTableCell, type Breakpoint, CATEGORICAL_PALETTE, CHART_ENCODING_RULES, CHART_TYPES, type CategoricalPalette, type CategoryColorsConfig, type CategoryTableCell, type CellStyle, type ChannelRule, type ChartBuilderOptions, type ChartEventHandlers, type ChartLayout, type ChartSpec, type ChartSpecWithoutData, type ChartType, type Chrome, type ChromeDefaults, type ChromeKey, type ChromeText, type ChromeTextStyle, type ColorBlindnessType, type ColumnConfig, type CompileOptions, type CompileTableOptions, DEFAULT_THEME, DIVERGING_PALETTES, type DarkMode, type DataRow, type DateGranularity, type DivergingPalette, type ElementEdit, type Encoding, type EncodingChannel, type EncodingRule, type FieldRef, type FieldType, type FlagTableCell, GRAPH_ENCODING_RULES, type GraphChannelRule, type GraphEdge, type GraphEdgeLayout, type GraphEncoding, type GraphEncodingChannel, type GraphLayout, type GraphLayoutConfig, type GraphNode, type GraphNodeLayout, type GraphSpec, type GraphSpecWithoutData, type Gridline, type HeatmapColumnConfig, type HeatmapTableCell, type ImageColumnConfig, type ImageTableCell, type LabelCandidate, type LabelConfig, type LabelDensity, type LabelMode, type LabelPriority, type LayoutStrategy, type LegendConfig, type LegendEntry, type LegendLayout, type LegendPosition, type LineMark, type Margins, type Mark, type MarkAria, type MarkEvent, type MeasureTextFn, type PaginationState, type Point, type PointMark, type RangeAnnotation, type Rect, type RectMark, type RefLineAnnotation, type ResolvedAnnotation, type ResolvedChrome, type ResolvedChromeElement, type ResolvedColumn, type ResolvedLabel, type ResolvedTheme, SEQUENTIAL_PALETTES, type ScaleConfig, type SequentialPalette, type SortState, type SparklineColumnConfig, type SparklineData, type SparklineTableCell, type StoredVizSpec, type TableBuilderOptions, type TableCell, type TableCellBase, type TableLayout, type TableRow, type TableSpec, type TableSpecWithoutData, type TextAnnotation, type TextStyle, type TextTableCell, type Theme, type ThemeChromeDefaults, type ThemeColors, type ThemeConfig, type ThemeFontSizes, type ThemeFontWeights, type ThemeFonts, type ThemeSpacing, type TooltipContent, type TooltipField, type VizSpec, abbreviateNumber, adaptColorForDarkMode, adaptTheme, areaChart, barChart, checkPaletteDistinguishability, columnChart, computeChrome, contrastRatio, dataTable, donutChart, dotChart, estimateTextWidth, findAccessibleColor, formatDate, formatNumber, generateAltText, generateAriaLabels, generateDataTable, getBreakpoint, getLayoutStrategy, inferFieldType, isChartSpec, isGraphSpec, isRangeAnnotation, isRefLineAnnotation, isTableSpec, isTextAnnotation, lineChart, meetsAA, pieChart, resolveCollisions, resolveTheme, scatterChart, simulateColorBlindness };