@graphysdk/viz-engine 0.0.1-plugins.0 → 0.0.1-plugins.10

package/dist/extensions.d.ts

@@ -1,1283 +0,0 @@
-import { internal } from 'arquero';
-
-declare interface AesMapping {
-    x?: AestheticValue;
-    y?: AestheticValue;
-    label?: AestheticValue;
-    color?: AestheticValue;
-    size?: AestheticValue;
-    alpha?: AestheticValue;
-    group?: AestheticValue;
-    strokeWidth?: AestheticValue;
-    lineType?: AestheticValue;
-}
-
-export declare type AestheticKey = keyof AesMapping;
-
-/**
- * Aesthetic value can be:
- * - string (shorthand for { variable: string })
- * - { variable: string } (explicit variable mapping)
- * - { value: DataValue } (constant value applied to every observation)
- */
-declare type AestheticValue = string | VariableMapping | ValueMapping;
-
-/***************************************************************
- * Aggregate Transform
- ***************************************************************/
-declare interface AggregateOperation {
-    /** The aggregation function to apply. */
-    op: AggregationFunction;
-    /** The variable to aggregate. */
-    variableName: VariableName;
-    /** The name of the output variable. */
-    as: VariableName;
-}
-
-declare interface AggregateOptions {
-    /** Variables to group by before aggregating. */
-    groupby: VariableName[];
-    /** Aggregation operations to apply per group. */
-    operations: AggregateOperation[];
-}
-
-declare interface AggregateTransformInput {
-    type: 'transform';
-    transformType: 'aggregate';
-    options: AggregateOptions;
-}
-
-/** A function that aggregates a variable's values. */
-declare type AggregationFunction = 'count' | 'sum' | 'mean' | 'median' | 'mode' | 'min' | 'max';
-
-/** A record of variable names and their aggregations. */
-declare type AggregationInput = Record<VariableName, {
-    variableName: VariableName;
-    aggregation: AggregationFunction;
-}>;
-
-/**
- * Where an annotation anchored to an observation sits, in normalised panel space `[0, 1]²`, plus the
- * render discriminant the annotation renderer dispatches on. A geom computes this from an observation
- * under a coord system (`Geom.resolveAnchorPosition`); the annotations compiler resolves anchors through
- * the definition rather than branching on geom name.
- */
-declare interface AnchorPosition {
-    x: number;
-    y: number;
-    geom: 'bar' | 'line' | 'polar-bar';
-}
-
-/**
- * The compile-half definition of a custom annotation kind (ADR-035).
- *
- * It carries **no compile logic** — coordinate resolution is generic for every kind — and exists only
- * so the registration-typed builder (`createGraphyBuilder({ annotations })`) can type `annotation.<kind>({
- * params })` from `TParams`, merge `defaultParams`, and enforce the optional coordinate arity. The
- * render-half `draw` lives in the renderer and binds to this definition by import (`defineAnnotationRenderer`).
- */
-/** Optional coordinate-count guardrail enforced by the builder; unbounded when omitted. */
-export declare interface AnnotationArity {
-    min?: number;
-    max?: number;
-}
-
-/**
- * A single coordinate for a custom annotation (ADR-035). One of three whole-coordinate modes — a
- * data-domain value scaled through the chart's scales, a raw [0,1] unit fraction of the panel, or a
- * snap to an existing observation. Per-axis mixing (x in one mode, y in another) is a deliberate
- * non-goal until a consumer needs it.
- */
-export declare type AnnotationCoordinateInput = {
-    data: {
-        x: DataValue;
-        y: DataValue;
-    };
-} | {
-    unit: {
-        x: number;
-        y: number;
-    };
-} | {
-    observation: ObservationAnchorInput;
-};
-
-export declare interface AnnotationDef<TParams extends object = object, TType extends string = string> {
-    type: TType;
-    /** Carrier that lets the builder recover `TParams` and merge defaults before a param reaches `draw`. */
-    defaultParams: TParams;
-    coordinates?: AnnotationArity;
-}
-
-/** Whether a custom annotation paints behind the geoms (background) or on top (foreground). */
-export declare type AnnotationZOrder = 'background' | 'foreground';
-
-/**
- * Area-specific parameters (same rendering knobs as line, but fills under the curve)
- */
-declare interface AreaGeomParams {
-    lineWidth: number | 'auto';
-    interpolate: InterpolateType;
-    missingValues: MissingValuesType;
-}
-
-/**
- * Maps each positional aesthetic to its axis orientation.
- * The guide compiler uses this to determine where axes are placed
- * and what geometry they use (e.g., linear vs circular grid lines).
- */
-declare interface AxisMapping {
-    x: {
-        position: AxisPosition;
-        geometry: GuideGeometry;
-    };
-    y: {
-        position: AxisPosition;
-        geometry: GuideGeometry;
-    };
-}
-
-declare type AxisPosition = 'left' | 'right' | 'top' | 'bottom';
-
-/**
- * Bar/Column-specific parameters
- */
-declare type BarGeomParams = Record<string, never>;
-
-/**
- * Discriminated union of the built-in resolved layer specs, keyed on `geom`. All properties are fully
- * resolved — no optionals. The `Extract`-based per-geom params views read from this closed union.
- */
-declare type BuiltinLayerSpec = {
-    [G in GeomName]: LayerSpecOf<G>;
-}[GeomName];
-
-/**
- * Cartesian coordinate system - standard x/y plot. Also used for flipped coordinates (flip is
- * an axis-assignment variant, not a different geometric paradigm).
- */
-declare interface CartesianCoordSystem {
-    type: 'cartesian';
-    /**
-     * The data-space axis that is the main (independent) one. `'x'` for standard cartesian (bars
-     * rise, X ticks on the horizontal axis); `'y'` for `coord.flip()` (bars extend, Y ticks on the
-     * horizontal axis). Consumers that need to branch on flip read this; the runtime `coord/axes`
-     * helpers turn it into main/cross accessors so the branch lives in one place.
-     */
-    mainAxis: MainAxis;
-    /** Axis orientation metadata for the guide compiler */
-    axisMapping: AxisMapping;
-}
-
-declare interface CategoricalValueFormat {
-    type: 'text';
-}
-
-/**
- * The spatial axis a position channel binds to. Selects the scale (`x` → the x scale, `y` → the
- * primary or secondary y scale) and is the axis flip swaps and polar projects.
- */
-declare type ChannelAxis = 'x' | 'y';
-
-/** Comparison operators for declarative filtering. */
-declare type ComparisonOperator = 'eq' | 'neq' | 'gt' | 'gte' | 'lt' | 'lte';
-
-export declare interface CompiledGeom {
-    /** The reparameterized dataset (may have new computed variables) */
-    data: Dataset;
-    /** Any mapping overrides produced by the geom */
-    mapping: AesMapping;
-    /**
-     * Extra single-observation tooltip rows this geom contributes (e.g. OHLC). The compiler derives
-     * each row's display format from its column and the renderer materialises the values for the
-     * hovered observation. Omit when the geom adds no detail rows; the standard one-row-per-series
-     * tooltip applies.
-     */
-    tooltipRows?: GeomTooltipRow[];
-}
-
-/***************************************************************
- * Constant Transform
- ***************************************************************/
-declare interface ConstantOptions {
-    /** The name of the new variable. */
-    variableName: VariableName;
-    /** The type of the new variable. */
-    type: DataType;
-    /** The constant value to assign to every observation. */
-    value: DataValue;
-}
-
-declare interface ConstantTransformInput {
-    type: 'transform';
-    transformType: 'constant';
-    options: ConstantOptions;
-}
-
-/**
- * Render-ready coordinate system (discriminated union).
- * Discriminates on geometric paradigm: cartesian plane vs polar projection.
- */
-declare type CoordSystem = CartesianCoordSystem | PolarCoordSystem;
-
-/**
- * Coordinate system type for transforming geometric positions.
- *
- * - `'cartesian'` — Standard x/y Cartesian plane
- * - `'polar'` — Polar coordinates for pie, radar, and radial charts
- * - `'flip'` — Cartesian with x and y axes swapped
- */
-export declare type CoordType = 'cartesian' | 'polar' | 'flip';
-
-/**
- * Resolved count stat spec.
- */
-declare interface CountStatSpec {
-    type: 'count';
-}
-
-/** Opens a {@link MarkTable} builder for a heterogeneous, kind-tagged Tier-C dataset. */
-export declare function createMarkTable(): MarkTable;
-
-/** Three letter ISO string representing the currency */
-declare type CurrencyIso = 'aed' | 'aud' | 'bdt' | 'bhd' | 'brl' | 'cad' | 'chf' | 'clp' | 'cny' | 'cop' | 'czk' | 'dkk' | 'egp' | 'eur' | 'gbp' | 'hkd' | 'huf' | 'idr' | 'ils' | 'inr' | 'jpy' | 'krw' | 'kwd' | 'mxn' | 'myr' | 'ngn' | 'nok' | 'nzd' | 'php' | 'pkr' | 'pln' | 'qar' | 'ron' | 'rub' | 'sar' | 'sek' | 'sgd' | 'thb' | 'try' | 'twd' | 'usd' | 'vnd' | 'zar';
-
-declare interface CurrencyValueFormat {
-    type: 'currency';
-    iso: CurrencyIso;
-}
-
-/**
- * A custom (registered) annotation instance. `type` names the registered kind (resolves the render-side
- * `draw`); `coordinates` resolve to targets at compile time; `params` is opaque at the spec level — the
- * registration-typed builder types it from the annotation definition. `zOrder` overrides the kind's
- * declared default.
- */
-export declare interface CustomAnnotationInput {
-    id?: string;
-    type: string;
-    coordinates: AnnotationCoordinateInput[];
-    params?: Record<string, unknown>;
-    zOrder?: AnnotationZOrder;
-}
-
-/** A resolved layer spec for a custom-registered geom — the generic resolver's output shape. */
-declare interface CustomLayerSpec extends LayerSpecBase {
-    geom: string;
-    params: Record<string, unknown>;
-}
-
-/**
- * Resolved data-labels config carried per-layer.
- */
-declare interface DataLabelsConfig {
-    /**
-     * Whether to show data labels on the layer.
-     * @default false
-     */
-    showDataLabels: boolean;
-    /**
-     * The format to use for the data labels.
-     * @default 'absolute'
-     */
-    format: 'absolute' | 'percentage';
-    /**
-     * Whether to show stack totals on the layer.
-     * @default false
-     */
-    showStackTotals: boolean;
-    /**
-     * Whether to show category labels on the layer.
-     * @default false
-     */
-    showCategoryLabels: boolean;
-    /**
-     * The source of the data labels.
-     * @default { variable: POSITION_VARIABLES.yRaw }
-     */
-    labelSource: AestheticValue;
-}
-
-/**
- * An immutable, columnar dataset. Uses Arquero internally for filtering, grouping and aggregation.
- *
- * Data is organised as **variables** (columns) and **observations** (rows). The values of each variable are typed and must match the variable's {@link DataType}. Missing values are represented as `null`.
- *
- * All transformation methods (filter, orderBy, addVariable etc.) return a new instance.
- *
- * @example
- * const data = new Dataset({
- *   age: { type: 'numeric', values: [25, 30, 35, null] },
- *   name: { type: 'categorical', values: ['John', 'Jane', 'Jim', 'Joanna'] },
- * });
- *
- * data.filter('age', 'gt', 30).print();
- */
-export declare class Dataset {
-    private table;
-    private variableMetadata;
-    /**
-     * Constructs a new dataset from typed columnar input.
-     * @param variables - A record mapping variable names to their type and values.
-     *
-     * @example
-     * const data = new Dataset({
-     *   age: { type: 'numeric', values: [25, 30, 35] },
-     *   name: { type: 'categorical', values: ['John', 'Jane', 'Jim'] },
-     * });
-     */
-    constructor(variables?: VariableMap);
-    /* Excluded from this release type: fromTrusted */
-    /**
-     * Returns the number of observations in the dataset.
-     */
-    size(): number;
-    /**
-     * Returns the names of all variables in the dataset.
-     */
-    getVariableNames(): VariableName[];
-    /**
-     * Returns true if the dataset has the given variable.
-     */
-    hasVariable(variable: VariableName): boolean;
-    /**
-     * Adds a new variable to the dataset. The variable's `valueFormat` is resolved in this order:
-     *  1. explicit `valueFormat` argument,
-     *  2. the existing variable's format (when overwriting an existing variable — e.g. a stack
-     *     position adjuster rewriting the user's y),
-     *  3. a type-based default (`numeric → decimal`, `categorical → text`, `temporal → date`).
-     */
-    addVariable(variable: VariableName, type: DataType, values: DataValue[], valueFormat?: ValueFormat): Dataset;
-    /**
-     * Adds a new constant variable to the dataset. Format resolution follows {@link addVariable}.
-     */
-    addConstantVariable(variable: VariableName, type: DataType, value: DataValue, valueFormat?: ValueFormat): Dataset;
-    /**
-     * Derives a new variable based on existing variables, using a table expression. If `valueFormat`
-     * is omitted, a type-based default is used.
-     */
-    deriveVariable(variable: VariableName, type: DataType, expression: (observation: Observation, rowIndex: number) => DataValue, valueFormat?: ValueFormat): Dataset;
-    /**
-     * Renames a variable.
-     */
-    renameVariable(oldName: VariableName, newName: VariableName): Dataset;
-    /**
-     * Selects a subset of variables from the dataset.
-     */
-    selectVariables(...variables: VariableName[]): Dataset;
-    /**
-     * Returns the type of a variable.
-     */
-    getType(variable: VariableName): DataType;
-    /**
-     * Returns the value format of a variable. Every variable carries a format — either explicitly
-     * supplied at construction (via `Variable.valueFormat` or an `addVariable`-family `valueFormat`
-     * argument) or a type-based default.
-     */
-    getValueFormat(variable: VariableName): ValueFormat;
-    /**
-     * Groups the variable names by their type.
-     */
-    groupVariableNamesByType(): GroupedVariableNames;
-    /**
-     * Returns the values of a given variable.
-     *
-     * @param options.type - The expected type of the values. If provided, the return type is narrowed to the matching concrete type and a runtime check ensures the variable actually carries that type.
-     * @param options.skipNulls - Whether to skip null values. Defaults to `false`.
-     * @param options.distinct - Whether to remove duplicate values from the result. Defaults to `false`.
-     */
-    getValues(variable: VariableName, options: GetValuesOptions & {
-        type: 'numeric';
-        skipNulls?: false;
-    }): Array<number | null>;
-    getValues(variable: VariableName, options: GetValuesOptions & {
-        type: 'categorical';
-        skipNulls?: false;
-    }): Array<string | null>;
-    getValues(variable: VariableName, options: GetValuesOptions & {
-        type: 'temporal';
-        skipNulls?: false;
-    }): Array<Date | null>;
-    getValues(variable: VariableName, options: GetValuesOptions & {
-        type: 'numeric';
-        skipNulls: true;
-    }): number[];
-    getValues(variable: VariableName, options: GetValuesOptions & {
-        type: 'categorical';
-        skipNulls: true;
-    }): string[];
-    getValues(variable: VariableName, options: GetValuesOptions & {
-        type: 'temporal';
-        skipNulls: true;
-    }): Date[];
-    getValues(variable: VariableName, options?: GetValuesOptions): DataValue[];
-    /**
-     * Filters the dataset using a declarative predicate.
-     */
-    filter(variableName: VariableName, operator: ComparisonOperator, value: DataValue): Dataset;
-    /**
-     * Returns a dataset filtered to rows where `mask[i] === 1`. Underlying column
-     * storage is shared with the parent — values are not copied. The mask length
-     * must equal `size()`.
-     */
-    filterByMask(mask: Uint8Array): Dataset;
-    /**
-     * Orders the dataset by a variable, in ascending (default) or descending order.
-     */
-    orderBy(variable: VariableName, direction?: 'asc' | 'desc'): Dataset;
-    /**
-     * Returns the first observation in the dataset.
-     */
-    getFirst(): Observation | null;
-    /**
-     * Returns the last observation in the dataset.
-     */
-    getLast(): Observation | null;
-    /**
-     * Returns the last observation matching a predicate, scanning backwards from the end.
-     */
-    findLast(predicate: (observation: Observation) => boolean): Observation | null;
-    /**
-     * Groups the dataset by one or more variables.
-     */
-    groupBy(...variables: VariableName[]): GroupBy;
-    /**
-     * Aggregates the dataset.
-     */
-    rollup(aggregations: AggregationInput): Dataset;
-    /**
-     * Reshapes data from wide to long format by collapsing multiple numeric variables
-     * into key–value pairs.
-     *
-     * ```
-     * ┌─────────┬──────┬──────┬──────┐        ┌─────────┬──────┬─────┐
-     * │ country │ 2020 │ 2021 │ 2022 │        │ country │ year │ gdp │
-     * ├─────────┼──────┼──────┼──────┤  ───►  ├─────────┼──────┼─────┤
-     * │ US      │  100 │  110 │  120 │        │ US      │ 2020 │ 100 │
-     * │ UK      │  200 │  210 │  220 │        │ US      │ 2021 │ 110 │
-     * └─────────┴──────┴──────┴──────┘        │ US      │ 2022 │ 120 │
-     *                                         │ UK      │ 2020 │ 200 │
-     *                                         │ UK      │ 2021 │ 210 │
-     *                                         │ UK      │ 2022 │ 220 │
-     *                                         └─────────┴──────┴─────┘
-     * ```
-     *
-     * @param keep - Variables to carry through unchanged. Defaults to all
-     *   categorical and temporal variables.
-     * @param reshape - Numeric variables to collapse into rows. Defaults to all
-     *   numeric variables.
-     * @param keyName - Name of the new variable whose values are the
-     *   original variable names (default: 'key').
-     * @param valueName - Name of the new variable whose values are the
-     *   original values of the variables to reshape (default: 'value').
-     * @throws If `keyName` or `valueName` conflicts with a variable in `keep`.
-     * @throws If any variable in `reshape` is not numeric.
-     *
-     * @example
-     * const reshaped = data.reshapeFromWideToLong({
-     *   keep: ['country'],
-     *   reshape: ['2020', '2021'],
-     *   keyName: 'year',
-     *   valueName: 'gdp',
-     * });
-     */
-    reshapeFromWideToLong({ keep, reshape, keyName, valueName, }?: {
-        keep?: VariableName[];
-        reshape?: VariableName[];
-        keyName?: VariableName;
-        valueName?: VariableName;
-    }): Dataset;
-    /**
-     * Prints the dataset to the console.
-     */
-    print(): void;
-    /**
-     * Returns an iterator over the observations in the dataset.
-     */
-    [Symbol.iterator](): Iterator<Observation>;
-    /**
-     * Resolves a freshly-added variable's `valueFormat`: explicit > existing (overwrite) > type-default.
-     */
-    private resolveAddedVariableFormat;
-    /**
-     * Parses the variable map into a table and variable metadata.
-     */
-    private parseVariableMap;
-    /**
-     * Normalizes raw values into typed values.
-     */
-    private normalizeRawValues;
-    /**
-     * Skips nulls when retrieving values from a variable.
-     */
-    private skipNulls;
-    /**
-     * Returns distinct values.
-     */
-    private getDistinctValues;
-}
-
-/** The type of a variable's values. Internally, numeric values are stored as numbers, dates as Date objects and categorical values as strings. */
-declare type DataType = 'numeric' | 'categorical' | 'temporal';
-
-/** The smallest unit of data in the dataset. `null` represents a missing value. */
-declare type DataValue = number | string | Date | null;
-
-/**
- * `TType` is a `const` type parameter so the literal kind name (`'calloutBox'`) survives to the type
- * level — the registration-typed builder keys `annotation.<kind>(...)` off it, the same way
- * `createGraphyBuilder` captures a geom's name. `TParams` is recovered from `defaultParams`; annotate or
- * cast it (`defaultParams: {...} as CalloutBoxParams`) when a param's literal union would otherwise widen.
- */
-export declare function defineAnnotation<const TType extends string, TParams extends object = object>(def: {
-    type: TType;
-    defaultParams?: TParams;
-    coordinates?: AnnotationArity;
-}): AnnotationDef<TParams, TType>;
-
-/** A value format with no inner lookups. Lookup cases and fallbacks are constrained to this so a `lookup` cannot nest another `lookup` at the type level. */
-declare type ExplicitValueFormat = TemporalValueFormat | NumericValueFormat | CurrencyValueFormat | CategoricalValueFormat;
-
-/**
- * Extracts the constant value from a `{ value }` mapping. Returns undefined for variable mappings.
- */
-export declare function extractConstantValue(aestheticValue: AestheticValue | undefined): DataValue | undefined;
-
-/**
- * Extracts the variable name from an AestheticValue.
- * Returns the variable name for string shorthands and { variable } mappings.
- * Returns null for constant { value } mappings or undefined values.
- */
-export declare function extractVariableName(aestheticValue: AestheticValue | undefined): VariableName | null;
-
-/***************************************************************
- * Filter Transform
- ***************************************************************/
-declare interface FilterOptions {
-    /** The variable to filter on. */
-    variableName: VariableName;
-    /** The comparison operator. */
-    operator: ComparisonOperator;
-    /** The value to compare against. */
-    value: DataValue;
-}
-
-declare interface FilterTransformInput {
-    type: 'transform';
-    transformType: 'filter';
-    options: FilterOptions;
-}
-
-/**
- * Base class for geoms that turn observations into visual marks (points, bars, lines etc).
- *
- * `TParams` is the geom's parameter type — the single source of truth the registration-typed builder
- * reads to type `geom.<name>({ params })` and to default missing params. Built-ins leave it at the
- * empty default and keep their typed params through the spec builder's static surface; a custom geom
- * names its params type and declares matching {@link defaultParams}.
- */
-export declare abstract class Geom<TParams extends object = object> {
-    /**
-     * The aesthetics an author must map for this geom. Built-ins list closed aesthetic keys
-     * (`['x','y']`); a custom geom may also list open channel names (a box plot's `min`/`q1`/…) that it
-     * binds to scales through its {@link positionChannels}, so the registration-typed builder accepts and
-     * types them as `aes` keys instead of forcing the bindings into `params`.
-     */
-    readonly requiredAesthetics: readonly string[];
-    /**
-     * The params merged in by the registration-typed builder before a missing key would reach the geom.
-     * The default is empty; a custom geom overrides it with its definition's defaults, which doubles as
-     * the carrier that lets the builder recover `TParams` from the registered instance.
-     */
-    readonly defaultParams: TParams;
-    /**
-     * The position channels this geom produces. The position mapper and coord projection iterate this
-     * manifest instead of a hardcoded column set, so a geom's geometry is described by what it declares.
-     */
-    readonly positionChannels: readonly PositionChannel[];
-    /**
-     * The visual aesthetics this geom encodes (color, size, …). The visual mapper and legend iterate
-     * this declaration instead of a hardcoded set, so a geom's visual surface is described by what it
-     * declares. The default is the full vocabulary; a geom narrows it to the aesthetics it actually
-     * paints, and a custom aesthetic extends it (decision 10).
-     */
-    readonly visualAesthetics: readonly ScaledVisualAestheticKey[];
-    /**
-     * The swatch shape that evokes this geom's on-canvas mark in the legend and tooltip — its
-     * cartesian-natural shape. A polar coord refines a `square` mark to a `slice` (pie/donut wedge)
-     * at read time. Decoupled from `GeomName` so guides paint by what a geom declares, not its name.
-     */
-    readonly swatchShape: SwatchShape;
-    /**
-     * How this geom composes highlight matches above its base render, or `null` to opt out of
-     * highlighting. Read at layer compile and stamped onto `CompiledLayer.highlight.strategy`.
-     * Declared per geom so core resolves it from the definition, not a geom-keyed lookup.
-     */
-    readonly highlightStrategy: HighlightStrategy | null;
-    /**
-     * The spatial structure this geom's marks present for hit-testing — its cartesian-natural kind.
-     * Stamped onto `CompiledLayer.spatialMap`; a polar coord refines it to `arcs`. Declared per geom
-     * so the runtime builds the matching index from data, not by branching on the geom name.
-     */
-    readonly spatialKind: SpatialIndexKind;
-    /**
-     * Positions for which this geom supports direct (inline) series labels in the legend. Empty when
-     * the geom never shows them. The legend reads this from the definition, not a geom-keyed lookup.
-     */
-    readonly directLabelPositions: readonly PositionType[];
-    /**
-     * Grid/border visibility overrides this geom requests per coord type (e.g. a bar hides the
-     * categorical-axis grid). Empty when the geom imposes none. The axis guide reads these.
-     */
-    readonly gridPolicies: Partial<Record<CoordType, GridPolicy>>;
-    /**
-     * How this geom derives each observation's stable identity key: `'index'` (position by row, so
-     * marks morph smoothly on enter/exit) or `'fields'` (x value plus resolved series). The identity
-     * compiler reads this from the definition, not a geom-name check.
-     */
-    readonly identityKeyStrategy: 'index' | 'fields';
-    /**
-     * The coord types under which this geom has meaningful semantics. The layer validator rejects a
-     * layer whose coord is absent from this set (e.g. a rule has no polar interpretation). Declared per
-     * geom so the validator resolves support from the definition, not a geom-name check.
-     */
-    readonly supportedCoordTypes: readonly CoordType[];
-    /**
-     * Whether a non-stacked layer of this geom carries a layer-wide grand total (the signed sum of `y`,
-     * the pie/donut headline figure). The summarise stage runs the grand-total summariser only for geoms
-     * that declare this, so eligibility lives on the definition rather than a geom-name gate.
-     */
-    readonly emitsGrandTotal: boolean;
-    /**
-     * Whether a stacked layer of this geom carries per-x stack totals (the share-of-stack denominator).
-     * The summarise stage runs the stack-totals summariser only for geoms that declare this, so a stacked
-     * area (which writes the same interval columns) is excluded by declaration, not by a geom-name gate.
-     */
-    readonly emitsStackTotals: boolean;
-    /**
-     * Whether a layer of this geom contributes a per-group headline figure. The headline guide builds a
-     * per-group strip only when an eligible geom is present, reading this from the definition rather than
-     * a membership list of geom names (so a reference-line geom, which is an annotation, opts out).
-     */
-    readonly supportsPerGroupHeadline: boolean;
-    abstract readonly type: GeomIdentity;
-    /**
-     * Where an annotation anchored to the given observation sits, in normalised panel space, or `null`
-     * when this geom does not support anchoring (the default). The annotations compiler resolves anchors
-     * through this method rather than branching on geom name; the returned `geom` discriminant tells the
-     * renderer how to place the annotation.
-     */
-    resolveAnchorPosition(_observation: Observation, _coordSystem: CoordSystem): AnchorPosition | null;
-    abstract compile(input: GeomCompilerInput): CompiledGeom;
-    /**
-     * Validates the layer's mapping against invariants specific to this geom (e.g. a rule needs exactly
-     * one numeric axis). Returns the issues found; omit the method when the geom imposes no mapping
-     * invariant. The layer validator dispatches here instead of branching on geom name.
-     */
-    validateMapping?(input: GeomMappingValidationInput): ValidationIssue[];
-}
-
-/**
- * The built-in geometric marks. The single source for both the {@link GeomName} type and the runtime
- * {@link BUILTIN_GEOM_NAMES} set used to tell a built-in name from a custom registration.
- *
- * - `'point'` — Scatter-style dot marks
- * - `'line'` — Connected line marks
- * - `'area'` — Filled area marks
- * - `'bar'` — Rectangular bar marks
- * - `'rule'` — Horizontal or vertical reference line at a constant value
- */
-declare const GEOM_NAMES: readonly ["point", "line", "area", "bar", "rule"];
-
-export declare interface GeomCompilerInput {
-    /** The dataset after stat transformation */
-    data: Dataset;
-    /** The effective mapping for the layer */
-    mapping: AesMapping;
-    /** Geom-specific params */
-    params: LayerSpec['params'];
-}
-
-/**
- * Open geom identity: the built-in vocabulary plus any custom registration's `type`. The layer types,
- * the compiled layer, and the geom registry key on this so a registered custom geom is a first-class
- * mark; the built-in literals stay for autocomplete. Core never *decides* on the name (the decisions
- * live on the geom definition) — this is purely the identity a layer carries.
- */
-declare type GeomIdentity = GeomName | (string & {});
-
-/**
- * Input to a geom's mapping validation. The validator resolves the stat-computed aesthetics and the
- * effective mapping, so the geom only expresses its own invariant (e.g. a rule needs exactly one
- * numeric axis) without reaching for a registry.
- */
-declare interface GeomMappingValidationInput {
-    /** Layer id, for issue attribution. */
-    layerId: string;
-    /** The effective mapping: spec mapping merged with the layer's. */
-    mapping: AesMapping;
-    /** Aesthetics a stat computes at compile time, so a missing literal there is not an error. */
-    computedVariables: ReadonlySet<AestheticKey>;
-}
-
-/** A built-in geom's name — the default vocabulary the spec builder offers out of the box. */
-export declare type GeomName = (typeof GEOM_NAMES)[number];
-
-/**
- * Maps each geom type name to its resolved parameter type.
- */
-declare interface GeomParamsMap {
-    point: PointGeomParams;
-    line: LineGeomParams;
-    area: AreaGeomParams;
-    bar: BarGeomParams;
-    rule: RuleGeomParams;
-}
-
-/**
- * One extra tooltip row a geom contributes for the hovered observation — a named reading of a data
- * column the standard one-row-per-series tooltip would not surface on its own. An OHLC candle, for
- * instance, declares four (open/high/low/close); the compiler derives each row's display format from
- * the column and the renderer materialises the values for the observation under the cursor. Pure
- * data: the `label` is static text and the `variable` names a column, so the rows ride in the
- * serialisable compiled spec.
- */
-export declare interface GeomTooltipRow {
-    /** The row's label (e.g. "Open"). Static text the geom supplies. */
-    label: string;
-    /** The data column whose per-observation value the row displays. */
-    variable: VariableName;
-}
-
-declare interface GetValuesOptions {
-    /** The expected type of the values. */
-    type?: DataType;
-    /** Whether to skip null values. Defaults to `false`. */
-    skipNulls?: boolean;
-    /** Whether to return distinct values. Defaults to `false`. */
-    distinct?: boolean;
-}
-
-/**
- * Grid/border visibility a geom requests per coord type — a bar hides the categorical-axis grid,
- * for instance. A geom declares these so the axis guide resolves grid policy from the definition
- * instead of a geom-keyed lookup. Every field absent means the geom imposes no policy.
- */
-export declare interface GridPolicy {
-    hideGridX?: boolean;
-    hideGridY?: boolean;
-    hideBorder?: boolean;
-}
-
-/**
- * A group by operation on a dataset. This is returned when calling `new Dataset(...).groupBy(...)`.
- */
-declare class GroupBy {
-    private groupedBy;
-    private grouped;
-    private variableMetadata;
-    constructor(groupedBy: VariableName[], grouped: Table, variableMetadata: VariableMetadata);
-    /**
-     * Iterates over each group.
-     */
-    forEach(callback: (group: Dataset, groupKey: string, groupIndex: number) => void): void;
-    /**
-     * Aggregates the variables in each group.
-     */
-    rollup(aggregations: AggregationInput): Dataset;
-    /**
-     * Computes the group key based on the first value of the grouped variable. If multiple variables are grouped, returns a composite key.
-     */
-    private getStableKey;
-}
-
-/** A map of variable names grouped by their type. */
-declare type GroupedVariableNames = {
-    [key in DataType]: VariableName[];
-};
-
-declare type GuideGeometry = 'linear' | 'circular' | 'radial';
-
-/**
- * How a geom composes highlight matches above its base render. Declared per geom on the geom
- * definition and stamped onto `CompiledLayer.highlight.strategy` by the layer compiler.
- *
- * - `'observation-rerender'`: matched observations re-render through the same plugin against a
- *   filtered sub-dataset. Used by per-observation surface geoms (bar, rule).
- * - `'overlay-anchor'`: series-scope matches go through the matched re-render pass;
- *   data-point / x-value-scope matches surface as a dot + value label at the plugin's
- *   reported anchor. Used by line, area, point.
- */
-export declare type HighlightStrategy = 'observation-rerender' | 'overlay-anchor';
-
-/**
- * Resolved identity stat spec.
- */
-declare interface IdentityStatSpec {
-    type: 'identity';
-}
-
-/**
- * Recovers where a raw sub-value sits inside an already-scaled interval. Given a raw `[rawLo, rawHi]`
- * pair that the compiler mapped to the scaled `[scaledLo, scaledHi]` endpoints, returns the scaled
- * position of `raw` by affine interpolation. The Tier-B trick a candlestick uses to place its open/close
- * inside the scaled `[low, high]` wick without re-running the y-scale.
- *
- * Exact only when the scale between raw and scaled space is **linear** — both endpoints pin a straight
- * line every interior value reads off. A degenerate interval (`rawLo === rawHi`) returns `scaledLo`.
- */
-export declare function interpolateInScaledInterval(raw: number, rawLo: number, rawHi: number, scaledLo: number, scaledHi: number): number;
-
-/**
- * Curve interpolation method for lines and areas.
- *
- * - `'linear'` — Straight segments between points
- * - `'catmull-rom'` — Smooth spline through points
- */
-declare type InterpolateType = 'linear' | 'catmull-rom';
-
-/**
- * Any resolved layer spec: a built-in or a custom registration. All properties are fully resolved.
- */
-declare type LayerSpec = BuiltinLayerSpec | CustomLayerSpec;
-
-declare interface LayerSpecBase {
-    type: 'layer';
-    id: string;
-    mapping: AesMapping;
-    stat: StatSpec;
-    position: PositionType;
-    yScaleType: YScaleType;
-    transforms: TransformInput[];
-    interactive: boolean;
-    dataLabels: DataLabelsConfig;
-}
-
-declare type LayerSpecOf<G extends GeomName> = LayerSpecBase & {
-    geom: G;
-    params: GeomParamsMap[G];
-};
-
-/**
- * Line-specific parameters
- */
-declare interface LineGeomParams {
-    lineWidth: number | 'auto';
-    /**
-     * Interpolation method to use for the line.
-     * @default 'linear'
-     */
-    interpolate: InterpolateType;
-    /**
-     * How to handle missing (NULL/undefined) values.
-     * @default 'gap'
-     */
-    missingValues: MissingValuesType;
-}
-
-/**
- * Stroke style for line rendering.
- *
- * - `'solid'` — Continuous unbroken stroke
- * - `'dashed'` — Repeating dash pattern
- * - `'dotted'` — Repeating dot pattern
- */
-declare type LineStyleType = 'solid' | 'dashed' | 'dotted';
-
-/**
- * A value format that switches on a peer variable's value. Produced by transforms whose output is
- * structurally observation-dependent (see `reshapeFromWideToLong`).
- */
-declare interface LookupValueFormat {
-    type: 'lookup';
-    /** Peer variable whose stringified value selects the case. */
-    byVariable: VariableName;
-    /** Case format keyed by `getStableKey(observation[byVariable])`. */
-    cases: Record<string, ExplicitValueFormat>;
-    /** Format used when an observation isn't available, or its case-key is absent from `cases`. */
-    fallback: ExplicitValueFormat;
-}
-
-/** The data-space axis a `CartesianCoordSystem` uses as the main (independent) axis. */
-declare type MainAxis = 'x' | 'y';
-
-/** Declares one mark kind's own columns and the data type of each. */
-export declare type MarkColumnSchema = Record<string, DataType>;
-
-/**
- * Builds one columnar {@link Dataset} from heterogeneous marks discriminated by a `kind` column — *the*
- * Tier-C dataset shape (node+link, group+leaf, node+edge). Each kind declares its own columns; the union
- * across kinds forms the dataset's columns, and a row's off-kind columns are filled with `null` **by
- * construction**, so the null-padding invariant a hand-built builder maintains by hand (and breaks when a
- * column is omitted from one kind's push) can no longer drift.
- */
-declare class MarkTable {
-    /** Column name → declared type, accumulated as the union across every declared kind. */
-    private readonly columnTypes;
-    /** Kind name → the column names that kind owns. */
-    private readonly kindColumns;
-    private readonly rows;
-    /** Declares a mark kind and the columns it carries. Throws if the kind repeats or a column's type conflicts. */
-    kind(name: string, columns: MarkColumnSchema): this;
-    /** Appends one row for a declared kind. Throws if the kind is unknown, or a value misses/overshoots the kind's columns. */
-    push(kind: string, values: Record<string, DataValue>): this;
-    /** Materialises the rows into a {@link Dataset}, null-padding every off-kind column. */
-    toDataset(options: ToDatasetOptions): Dataset;
-}
-
-/**
- * Resolved mean stat spec.
- */
-declare interface MeanStatSpec {
-    type: 'mean';
-}
-
-/**
- * Strategy for handling null/undefined values in lines and areas.
- *
- * - `'zero'` — Replace missing values with zero
- * - `'gap'` — Leave a visible gap where values are missing
- * - `'connect'` — Skip missing values and connect adjacent valid points
- */
-declare type MissingValuesType = 'zero' | 'gap' | 'connect';
-
-declare interface NumericValueFormat {
-    type: 'decimal' | 'integer' | 'percentage' | 'duration';
-}
-
-/** A single row of data, mapping every variable name to the value in that row. */
-declare type Observation = Record<VariableName, DataValue>;
-
-/** Points at a single observation by its anchor value and series. */
-declare interface ObservationAnchorInput {
-    /** Pick a specific layer when multiple share the same `(anchorValue, groupValue)` pair. */
-    layerIndex?: number;
-    /** Value on the main axis (x in cartesian, y in flipped). */
-    anchorValue: DataValue;
-    /** Series identity (the `group` aesthetic value). */
-    groupValue: DataValue;
-}
-
-/**
- * Point-specific parameters
- */
-declare interface PointGeomParams {
-    size: number;
-}
-
-/**
- * Polar coordinate system - for pie charts, radar charts, etc.
- * Angular params (theta, startAngle) are consumed by the compiler during coordTransform.
- * `innerRadius` is also exposed here so the renderer can recover the donut hole geometry
- * (e.g. to place a centred headline) without reaching into per-observation radii.
- */
-declare interface PolarCoordSystem {
-    type: 'polar';
-    /** Axis orientation metadata for the guide compiler */
-    axisMapping: AxisMapping;
-    /** Donut hole radius as a fraction of the outer radius (0-1). 0 for a full pie. */
-    innerRadius: number;
-}
-
-/**
- * One position channel a geom declares: where it sits ({@link ChannelAxis}, {@link PositionChannelRole}),
- * how its raw column maps to a position ({@link PositionValueKind}), and an open identity its column
- * derives from. A geom's channels are the manifest the position mapper and coord projection iterate
- * instead of hardcoding the column set.
- */
-export declare type PositionChannel = RolePositionChannel | ScalarPositionChannel;
-
-declare interface PositionChannelBase {
-    axis: ChannelAxis;
-    valueKind: PositionValueKind;
-}
-
-/**
- * Position adjustment for overlapping geometries.
- *
- * - `'stack'` — Stack geometries on top of each other (e.g. stacked bar chart)
- * - `'dodge'` — Place geometries side by side (e.g. grouped bar chart)
- * - `'identity'` — No adjustment, use raw positions (e.g. scatter plot, allows overlapping)
- * - `'fill'` — Normalize stacks to fill 100% of the axis (e.g. 100% stacked bar chart)
- */
-export declare type PositionType = 'stack' | 'dodge' | 'identity' | 'fill';
-
-/**
- * How a channel's raw column becomes a scaled position.
- * - `value` — the column holds data-domain values mapped directly through the scale.
- * - `bandOffset` — the column holds fractional offsets around the scaled axis point, sized by the
- *   scale's bandwidth (a bar's left/right edges relative to its band centre).
- */
-declare type PositionValueKind = 'value' | 'bandOffset';
-
-/**
- * Reads an aesthetic value by an open channel name — built-in (`x`, `color`, …) or custom. A custom
- * geom maps extra channels (a box plot's `q1`/`median`/`q3`, an error bar's bounds) under names outside
- * the closed {@link AestheticKey} set; those keys ride in the mapping at runtime and are read here
- * through the one sanctioned widening, so a channel's value is sourced from `aes` rather than `params`.
- */
-export declare function readAesthetic(aesMapping: AesMapping, name: string): AestheticValue | undefined;
-
-/**
- * Reads an author-named numeric column from an observation with the same null-discipline as the
- * built-in position/visual readers (`getX`, `getColor`, …): a missing or wrong-typed value is
- * `null`, never silently coerced to `0`. A custom geom writes its own columns and has no typed
- * accessor for them; these readers fill that gap without re-deriving the coercion per geom.
- *
- * Pass `fallback` to opt into a default for genuinely-missing values; the overload then narrows the
- * return to `number`, so a geom that wants `0`-on-missing says so explicitly.
- */
-export declare function readNumber(observation: Observation, key: string): number | null;
-
-export declare function readNumber(observation: Observation, key: string, fallback: number): number;
-
-/** Reads an author-named string column from an observation; missing or wrong-typed is `null` unless a `fallback` is given. */
-export declare function readString(observation: Observation, key: string): string | null;
-
-export declare function readString(observation: Observation, key: string, fallback: string): string;
-
-/***************************************************************
- * Reshape Transform
- ***************************************************************/
-declare interface ReshapeOptions {
-    /**
-     * Numeric variables to collapse into rows.
-     * Defaults to all numeric variables
-     * */
-    reshape?: VariableName[];
-    /**
-     * Variables to carry through unchanged.
-     * Defaults to all categorical/temporal variables
-     * */
-    keep?: VariableName[];
-    /**
-     * Name of the output column containing the original variable names.
-     * @default 'key'
-     * */
-    keyName?: VariableName;
-    /**
-     * Name of the output column containing the original values.
-     * @default 'value'
-     * */
-    valueName?: VariableName;
-}
-
-declare interface ReshapeTransformInput {
-    type: 'transform';
-    transformType: 'reshape';
-    options: ReshapeOptions;
-}
-
-/**
- * A custom annotation's coordinate resolved to normalized panel space, in **top-left [0,1]** — the
- * space the draw function paints in. `observation` is attached only for a snap-to-observation
- * coordinate (so the draw can read the bound row's columns); unit/data targets are synthetic points.
- */
-export declare interface ResolvedTarget {
-    x: number;
-    y: number;
-    mode: 'data' | 'unit' | 'observation';
-    observation?: Observation;
-}
-
-/**
- * A structural channel — the per-axis anchor (`point`) or one end of an interval (`lower`/`upper`).
- * Its {@link PositionChannel.name | name} defaults to the role, so the canonical position columns
- * (`x`, `xMin`, `yMax`, …) are preserved and a geom declares `{ axis, role, valueKind }` with no name.
- */
-declare interface RolePositionChannel extends PositionChannelBase {
-    role: 'point' | 'lower' | 'upper';
-    /** Open identity override; defaults to {@link role}. Built-ins omit it to keep canonical columns. */
-    name?: string;
-}
-
-/**
- * Rule-specific parameters.
- */
-declare interface RuleGeomParams {
-    /** Stroke color; falls back to a theme token. */
-    color?: string;
-    strokeWidth: number;
-    lineType: LineStyleType;
-    /** Optional inline text label rendered alongside the line. */
-    label?: string;
-    labelPosition: RuleLabelPosition;
-}
-
-/**
- * Where the optional inline label is anchored along a reference line.
- */
-declare type RuleLabelPosition = 'start' | 'end';
-
-/**
- * A standalone scaled value on an axis, identified by an open {@link ScalarPositionChannel.name | name}.
- * Always `value`-kind — a lone value has no band to offset against. Its column is namespaced from the
- * name, so two geoms' scalars never collide and neither freezes an internal column (the decision-9
- * litmus): a box plot declares `q1`/`median`/`q3`, an error bar its CI bounds, and the position mapper
- * scales each through the axis scale exactly as it scales an interval bound.
- */
-declare interface ScalarPositionChannel extends PositionChannelBase {
-    role: 'scalar';
-    valueKind: 'value';
-    name: string;
-    /**
-     * The mapping key this channel sources its raw values from. When set, the position mapper reads
-     * `mapping[aes]`'s column and scales it in place — so the value is authored as `aes` (a box plot's
-     * `q1`), not hand-copied from `params`. When omitted, the channel reads the column the geom wrote
-     * under {@link variableFor}`(axis, name)` (a geom that computes the value itself).
-     */
-    aes?: string;
-}
-
-export declare type ScaledVisualAestheticKey = 'color' | 'size' | 'alpha' | 'strokeWidth' | 'lineType';
-
-/**
- * Regression methods supported by the `smooth` stat.
- */
-declare type SmoothMethod = 'linear' | 'loess' | 'exponential' | 'logarithmic' | 'quadratic' | 'power' | 'polynomial';
-
-/**
- * Resolved smooth (regression) stat spec.
- */
-declare interface SmoothStatSpec {
-    type: 'smooth';
-    method: SmoothMethod;
-    /** Polynomial order — only meaningful when `method: 'polynomial'`. */
-    order: number;
-    /** LOESS bandwidth — only meaningful when `method: 'loess'`. */
-    bandwidth: number;
-}
-
-/**
- * Sorts the data by the x variable if it is numeric or temporal.
- */
-export declare const sortByXIfContinuous: (data: Dataset, mapping: AesMapping) => Dataset;
-
-/***************************************************************
- * Sort Transform
- ***************************************************************/
-declare interface SortOptions {
-    /** The variable to sort by. */
-    variableName: VariableName;
-    /** Sort direction. @default 'asc' */
-    direction?: 'asc' | 'desc';
-}
-
-declare interface SortTransformInput {
-    type: 'transform';
-    transformType: 'sort';
-    options: SortOptions;
-}
-
-/**
- * The kind of spatial structure a geom presents for hit-testing. Each value selects one of the
- * runtime's index builders, so the descriptor lets the engine dispatch on declared data instead
- * of branching on the geom name.
- *
- * `render-hit-test` is the Tier-C escape hatch: the geom's geometry comes from a layout algorithm,
- * not from scales, so the compiler cannot build a spatial index from position columns. The geom
- * instead provides a render-side hit-test function (injected per-instance through the renderer),
- * and the engine resolves the observation it returns against the declared identity key. Only the
- * kind rides in the compiled spec — the closure never crosses the serialisable boundary.
- */
-export declare type SpatialIndexKind = 'buckets' | 'rects' | 'points' | 'arcs' | 'noop' | 'render-hit-test';
-
-/**
- * Discriminated union of all resolved stat specs (post-resolution).
- */
-declare type StatSpec = IdentityStatSpec | CountStatSpec | SmoothStatSpec | MeanStatSpec;
-
-/**
- * Visual signature of a geom's mark, decoupled from `GeomName` because legends and tooltips care
- * only about the shape that best evokes the on-canvas mark, not the geom's spec-level identity.
- *
- * - `square` → a filled rect (bar)
- * - `line` → a horizontal stroke
- * - `area` → a filled region with a stroke accent
- * - `circle` → a point
- * - `slice` → a pie / donut wedge (a `square` mark refined under polar coords)
- */
-export declare type SwatchShape = 'square' | 'line' | 'circle' | 'area' | 'slice';
-
-declare type Table = internal.ColumnTable;
-
-declare interface TemporalValueFormat {
-    type: 'datetime' | 'time' | 'date' | 'year' | 'quarter' | 'month_year' | 'month' | 'weekly_date_range_with_year' | 'weekly_date_range' | 'day_month';
-    /** Template string representing how values of this type have been formatted. ie. dd-mm-yyyy  */
-    dateFormat?: string;
-}
-
-declare interface ToDatasetOptions {
-    /** Name of the categorical column that discriminates each row's kind. Must not collide with a declared column. */
-    kindColumn: string;
-}
-
-/***************************************************************
- * Transform Input
- ***************************************************************/
-declare type TransformInput = ReshapeTransformInput | FilterTransformInput | SortTransformInput | AggregateTransformInput | ConstantTransformInput;
-
-/**
- * Shared validation types used across compiler stages.
- *
- * Each validation stage (e.g. {@link LayerValidator}, the pre-pass in {@link ScaleCompiler}) collects
- * {@link ValidationIssue}s and throws a single {@link SpecValidationError} at the end of its stage.
- */
-declare type ValidationCode = 'UNKNOWN_VARIABLE' | 'INCOMPATIBLE_TYPE' | 'MISSING_AESTHETIC' | 'INVALID_RULE_MAPPING' | 'UNSUPPORTED_COORD';
-
-declare interface ValidationIssue {
-    code: ValidationCode;
-    message: string;
-    layerId?: string;
-    aesthetic?: string;
-}
-
-declare type ValueFormat = ExplicitValueFormat | LookupValueFormat;
-
-/**
- * Constant mapping - a literal value applied to every observation.
- * Analogous to Vega-Lite's `{datum: X}` / ggplot2's `aes(color = "literal")`.
- */
-declare interface ValueMapping {
-    value: DataValue;
-}
-
-/** A column of a variable in the dataset. When `valueFormat` is omitted, the Dataset assigns a type-based default (`numeric → decimal`, `categorical → text`, `temporal → date`). */
-declare type Variable = {
-    type: DataType;
-    values: DataValue[];
-    valueFormat?: ValueFormat;
-};
-
-/**
- * The internal dataset variable a channel reads and writes, derived from its axis and open name. The
- * built-in names (`point`/`lower`/`upper`) resolve to the canonical position columns (`x`, `xMin`, …),
- * so value readers and renderer recipes stay untouched; any other name resolves to a namespaced column,
- * so a custom scaled channel never collides with a built-in or another geom's channel.
- */
-export declare function variableFor(axis: ChannelAxis, name: string): string;
-
-/** A map of variable names to their type and values. */
-declare type VariableMap = Record<VariableName, Variable>;
-
-/**
- * Variable mapping - references a column in the data
- */
-declare interface VariableMapping {
-    variable: string;
-}
-
-declare type VariableMetadata = Record<VariableName, {
-    type: DataType;
-    valueFormat: ValueFormat;
-}>;
-
-/** A type alias for variable names. */
-declare type VariableName = string;
-
-/**
- * Which Y axis a layer binds to.
- */
-declare type YScaleType = 'primary' | 'secondary';
-
-export { }