teechart.js 4.0.4 → 5.0.0-beta.1

package/dist/types/chart-options.d.ts

@@ -0,0 +1,826 @@
+import type { Chart } from "./chart.js";
+import type { AccessibilityOptions } from "./accessibility.js";
+import type { ChartEventMap, EventListener } from "./events.js";
+import type { ChartPlugin, ChartPluginOptions } from "./plugin.js";
+import type { HistogramNormalize, HistogramRule } from "./series/histogram.js";
+import type { SankeyGraph, SankeyLinkColor } from "./series/sankey.js";
+import type { BoxPlotGroup, BoxPlotLimit, BoxPlotQuantiles, BoxPlotWhisker, BoxPlotWhiskerMode } from "./series/box-plot.js";
+import type { ViolinGroup, ViolinInner, ViolinScale } from "./series/violin.js";
+import type { TreemapColorBy, TreemapNode, TreemapTiling } from "./series/treemap.js";
+import type { Series } from "./series.js";
+import type { MapDefinition } from "./series/map-series.js";
+import type { MarkConnector, MarkPlacement } from "./tools/annotation.js";
+export type { MarkConnector, MarkPlacement } from "./tools/annotation.js";
+import type { ThemeName } from "./theme.js";
+import type { Tool } from "./tools/tool.js";
+type ExtensibleName<T extends string> = T | (string & {});
+export type LegendPosition = "bottom" | "left" | "right" | "top";
+/** Whether the legend lists the series, the points of the first visible series, or chooses by series count. */
+export type LegendStyle = "auto" | "series" | "values";
+/** What each legend item shows for the points of a series. */
+export type LegendValueFormat = "auto" | "index" | "label" | "labelpercent" | "labelvalue" | "percent" | "percentlabel" | "value" | "valuelabel" | "valuepercent";
+/** How a legend item shows and toggles a series: clicking an item hides or shows its series unless "none". */
+export type LegendInteraction = "checkbox" | "linethrough" | "none" | "opacity";
+export type LegendSymbolShape = "diamond" | "ellipse" | "line" | "pill" | "rectangle" | "triangle";
+export type ChartTheme = ExtensibleName<ThemeName>;
+export interface PaletteRegistry {
+    castaway: true;
+    classic: true;
+    cool: true;
+    excel: true;
+    grayscale: true;
+    macOS: true;
+    modern: true;
+    onBlack: true;
+    opera: true;
+    pastels: true;
+    rainbow: true;
+    rainbowWide: true;
+    redRiver: true;
+    rust: true;
+    seaWash: true;
+    solid: true;
+    teechart: true;
+    victorian: true;
+    warm: true;
+    web: true;
+    windowsVista: true;
+    windowsxp: true;
+}
+export type PaletteName = ExtensibleName<keyof PaletteRegistry>;
+export type HorizontalAxisName = "bottom" | "top" | "both";
+export type VerticalAxisName = "left" | "right" | "both";
+/** How multiple series of the same type are combined. */
+export type StackMode = "no" | "yes" | "100" | "side" | "sideAll" | "self";
+export type PointerStyle = "cone" | "cross" | "cube" | "cylinder" | "diamond" | "downtriangle" | "ellipse" | "rectangle" | "sphere" | "triangle" | "x";
+export interface MarksOptions {
+    visible?: boolean;
+    style?: string;
+    drawEvery?: number;
+    showZero?: boolean;
+    /** Fill color for the label background. */
+    backgroundColor?: string;
+    /** Outline color for the mark label box. Use an empty string to hide the outline. */
+    borderColor?: string;
+    /** Text color inside the mark label. */
+    fontColor?: string;
+    /** Text size in pixels. */
+    fontSize?: number;
+    /** Corner radius, in pixels, for the label background. */
+    borderRadius?: number;
+    /** Space between the label text and its background edges, in pixels. */
+    margins?: {
+        left?: number;
+        top?: number;
+        right?: number;
+        bottom?: number;
+    };
+    /** Position for pie and donut labels. */
+    placement?: MarkPlacement;
+    /** Connector for outside pie and donut labels. */
+    connector?: MarkConnector;
+}
+export interface PointerOptions {
+    visible?: boolean;
+    style?: PointerStyle;
+    width?: number;
+    height?: number;
+    colorEach?: boolean;
+    strokeWidth?: number;
+    strokeColor?: string;
+    shadow?: boolean;
+}
+/** Visual and visibility options shared by every declarative series type. */
+export interface SeriesStyleOptions {
+    /** Stable identity used to match this series across declarative updates and reordering. */
+    id?: string;
+    label?: string;
+    /** Keeps at most this many points when values are appended, dropping the oldest. */
+    maxPoints?: number;
+    visible?: boolean;
+    borderColor?: string;
+    backgroundColor?: string;
+    borderWidth?: number;
+    shadow?: boolean;
+    hoverColor?: string;
+    hoverEnabled?: boolean;
+    gradientVisible?: boolean;
+    /** Colors of the series fill gradient. */
+    gradientColors?: string[];
+    /** Image used to texture the series fill. */
+    image?: {
+        url: string;
+    };
+    transparency?: number;
+    marks?: MarksOptions;
+    /** CSS cursor shown over the series points. */
+    cursor?: string;
+    /** Paints each point with its own palette color. `"auto"` lets the series decide. */
+    colorEach?: boolean | "auto";
+    /** How the series appears in the legend. */
+    legend?: SeriesLegendOptions;
+}
+/** How one series appears in the legend. */
+export interface SeriesLegendOptions {
+    /** Lists the series in the legend; `false` hides it. */
+    visible?: boolean;
+    /** Overrides the legend symbol of this series. */
+    symbol?: {
+        style?: LegendSymbolShape;
+        color?: string;
+    };
+}
+/** Options of series drawn against chart axes. */
+export interface AxisSeriesOptions extends SeriesStyleOptions {
+    horizAxis?: HorizontalAxisName;
+    vertAxis?: VerticalAxisName;
+}
+export type CartesianChartType = "area" | "bar" | "bubble" | "horizArea" | "horizBar" | "line" | "point" | "volume";
+export type CircularChartType = "activityGauge" | "donut" | "pie" | "sliced";
+export type ValueChartType = CartesianChartType | CircularChartType;
+/** One Cartesian point with its own horizontal position and vertical value. */
+export interface CartesianDataPoint {
+    x: number | Date;
+    y: number;
+}
+/**
+ * Series plotted against axes whose data is a list of numbers or objects. Omitting `type` uses the chart level
+ * `type`. `stacked`, `smooth` and `stairs` throw when the selected type does not support them.
+ */
+export interface CartesianSeriesOptions extends AxisSeriesOptions {
+    type?: CartesianChartType;
+    data: number[] | CartesianDataPoint[] | object[];
+    /**
+     * Horizontal position of each numeric point, when it is not the index. Dates make the bottom axis a date axis,
+     * and ascending values let line and area series process only the visible points when zoomed in. It
+     * needs one value per point. Use `{ x, y }` data points to keep each position alongside its value.
+     */
+    x?: Array<number | Date>;
+    /** Object property used for horizontal positions. Defaults to `x` for object data. */
+    xKey?: string;
+    /** Object property used for vertical values. Defaults to `y` for object data. */
+    yKey?: string;
+    pointer?: PointerOptions;
+    stacked?: StackMode;
+    smooth?: number;
+    stairs?: boolean;
+    /** How line series render null values. */
+    treatNulls?: "skip" | "dontPaint";
+    barSize?: number;
+}
+/** Pie like series whose data is a list of numbers and that do not use axes. */
+export interface CircularSeriesOptions extends SeriesStyleOptions {
+    type?: CircularChartType;
+    data: number[];
+    /** Maximum pie or donut radius as a percentage of the available radius. */
+    maxRadius?: number;
+}
+export type ValueSeriesOptions = CartesianSeriesOptions | CircularSeriesOptions;
+export interface PolarSeriesOptions extends SeriesStyleOptions {
+    type: "polar";
+    data: number[];
+    pointer?: PointerOptions;
+    smooth?: number;
+}
+export interface CandleRow {
+    open: number;
+    high: number;
+    low: number;
+    close: number;
+    /** Optional numeric position; the point index is used when omitted. */
+    x?: number;
+}
+/** Financial OHLC series. `type` is required because its data is not a list of numbers. */
+export interface CandleSeriesOptions extends AxisSeriesOptions {
+    type: "candle";
+    data: CandleRow[];
+    style?: "candle" | "bar" | "openclose";
+}
+export interface HighLowRow {
+    high: number;
+    low: number;
+}
+export interface HighLowBarSeriesOptions extends AxisSeriesOptions {
+    type: "highLowBar";
+    data: HighLowRow[];
+}
+export interface GanttTask {
+    start: number | Date;
+    end: number | Date;
+    /** Task name; falls back to the chart level label with the same index. */
+    label?: string;
+    /** Vertical position; the task index is used when omitted. */
+    x?: number;
+}
+export interface GanttSeriesOptions extends AxisSeriesOptions {
+    type: "gantt";
+    data: GanttTask[];
+    /** Height of each task bar, as a percentage of its row. */
+    height?: number;
+    /** Corner radius of each task bar, in pixels. */
+    borderRadius?: number;
+    /** Task index pairs connected by dependency arrows. */
+    nextTasks?: Array<[number, number]>;
+    /** Stroke color used for dependency arrows. */
+    nextTasksStrokeStyle?: string;
+    /** Draw dependency arrows behind or in front of the task bars. */
+    nextTasksPosition?: "back" | "front";
+}
+/** Groups raw numbers into bins and draws how many fall in each. */
+export interface HistogramSeriesOptions extends AxisSeriesOptions {
+    type: "histogram";
+    /** Raw values; they are grouped, not plotted one by one. */
+    data: number[];
+    /** Number of bins. When omitted, `rule` chooses it. */
+    bins?: number;
+    /** Width of each bin, in data units. It takes precedence over `bins`. */
+    binWidth?: number;
+    /** How the number of bins is chosen when neither `bins` nor `binWidth` is set; defaults to "sturges". */
+    rule?: HistogramRule;
+    /** Bar height: the "count" of values, their "percent" or the "density"; defaults to "count". */
+    normalize?: HistogramNormalize;
+}
+/** Draws a box and whiskers for each group, from raw values or from precomputed summaries. */
+export interface BoxPlotSeriesOptions extends AxisSeriesOptions {
+    type: "boxPlot";
+    /** One item per box: a `{ name, values, color? }` group, a precomputed `{ name, min, q1, median, q3, max, outliers? }` or a plain array of values. */
+    data: Array<BoxPlotGroup | number[]>;
+    /** Where the whiskers end: "tukey" within `whiskerRange` times the IQR, or "minmax"; defaults to "tukey". */
+    whisker?: BoxPlotWhisker;
+    /** Multiple of the interquartile range used by the "tukey" whiskers; defaults to 1.5. */
+    whiskerRange?: number;
+    /** Where "tukey" whiskers end: at the farthest value inside the fences ("nearest") or at the fences ("exact"). */
+    whiskerMode?: BoxPlotWhiskerMode;
+    /** How quartiles are computed from raw values; defaults to 7 (linear interpolation). */
+    quantiles?: BoxPlotQuantiles;
+    /** What sets the lowest value of the axis: the "extreme" value, the "box" or the "whisker"; defaults to "extreme". */
+    minStats?: BoxPlotLimit;
+    /** What sets the highest value of the axis; defaults to "extreme". */
+    maxStats?: BoxPlotLimit;
+    /** Draws every raw value as a dot; defaults to false. */
+    showPoints?: boolean;
+    /** Radius of the dots in pixels; defaults to 2.5. */
+    pointRadius?: number;
+    /** Sideways spread of the dots, from 0 to 1 of the box width; defaults to 0.5. */
+    jitter?: number;
+    /** Width of a box in percent of its category; defaults to 60. */
+    width?: number;
+    /** Draws the values beyond the whiskers; defaults to true. */
+    showOutliers?: boolean;
+    /** Marks the mean of each group of raw values with a diamond; defaults to false. */
+    showMean?: boolean;
+    /** Opacity of the fill of the box, from 0 to 1. */
+    fillOpacity?: number;
+    /** Width of the outline in pixels. */
+    lineWidth?: number;
+    /** Formats the values shown in tooltips. */
+    formatValue?: (value: number) => string;
+}
+/** Draws the distribution of each group of raw values as a violin. */
+export interface ViolinSeriesOptions extends AxisSeriesOptions {
+    type: "violin";
+    /** One item per violin: a `{ name, values, color? }` group or a plain array of values. */
+    data: Array<ViolinGroup | number[]>;
+    /** Smoothing of the density in data units; 0 or omitted chooses it for each group. */
+    bandwidth?: number;
+    /** Multiplies the automatic bandwidth: below 1 follows the values more closely, above 1 smooths more; defaults to 1. */
+    smoothing?: number;
+    /** How far the shapes extend beyond the lowest and highest value, in bandwidths; defaults to 0. */
+    cut?: number;
+    /** Number of positions where the density is estimated for each violin; defaults to 100. */
+    resolution?: number;
+    /** Violin widths: all the same ("width"), the same area ("area") or by number of values ("count"). */
+    scale?: ViolinScale;
+    /** Maximum width of a violin in percent of its category; defaults to 80. */
+    width?: number;
+    /** What is drawn inside: the "median", a "box" with the quartiles or "none"; defaults to "median". */
+    inner?: ViolinInner;
+    /** Opacity of the fill, from 0 to 1. */
+    fillOpacity?: number;
+    /** Width of the outline in pixels; 0 draws none. */
+    lineWidth?: number;
+    /** Formats the values shown in tooltips. */
+    formatValue?: (value: number) => string;
+}
+export interface TreemapSeriesOptions extends SeriesStyleOptions {
+    type: "treemap";
+    data: TreemapNode;
+    /** How the children of a node are arranged; defaults to "squarify". */
+    tiling?: TreemapTiling;
+    /** What decides the color of a tile; defaults to "branch". */
+    colorBy?: TreemapColorBy;
+    /** Space between sibling tiles in pixels. */
+    padding?: number;
+    /** Height of the title band of branches in pixels; 0 hides the bands. */
+    headerHeight?: number;
+    /** Corner radius of the tiles in pixels. */
+    cornerRadius?: number;
+    /** Width of the tile outline in pixels; 0 draws none. */
+    lineWidth?: number;
+    /** Color of the tile outline; the chart background when omitted. */
+    borderColor?: string;
+    /** Levels drawn below the focused node, 0 for all of them. */
+    maxDepth?: number;
+    /** Draws the node names; defaults to true. */
+    labels?: boolean;
+    /** Draws the values under the names of the tiles that have room for them; defaults to true. */
+    showValues?: boolean;
+    /** Orders siblings from the largest to the smallest; defaults to true. */
+    sortByValue?: boolean;
+    /** Clicking a branch zooms into it; defaults to true. */
+    zoomOnClick?: boolean;
+    /** Formats the values shown in labels and tooltips. */
+    formatValue?: (value: number) => string;
+}
+export interface SankeySeriesOptions extends SeriesStyleOptions {
+    type: "sankey";
+    data: SankeyGraph;
+    /** Width of the node bars in pixels. */
+    nodeWidth?: number;
+    /** Minimum vertical space between the nodes of a column in pixels. */
+    nodePadding?: number;
+    /** Opacity of the links, from 0 to 1. */
+    linkOpacity?: number;
+    /** Link painting: the color of the source node, of the target node, or a gradient between both. */
+    linkColor?: SankeyLinkColor;
+    /** Draws the node names and values; defaults to true. */
+    labels?: boolean;
+    /** Formats the values shown in labels and tooltips. */
+    formatValue?: (value: number) => string;
+}
+/** A colored band of a gauge: it ends at `to` and starts where the previous band ends, the first one at `min`. */
+export interface GaugeBand {
+    to: number;
+    color: string;
+}
+/** A gauge shows a single value between `min` and `max`. */
+interface GaugeBaseOptions extends SeriesStyleOptions {
+    data: number;
+    min?: number;
+    max?: number;
+    /** Milliseconds the pointer or arc takes to reach a new value set with `setValue`; 0 disables the animation. */
+    animationDuration?: number;
+}
+/** A classic dial: ticks, labels and a hand over a round, rectangular or segment shaped face. */
+export interface CircularGaugeSeriesOptions extends GaugeBaseOptions {
+    type: "circularGauge";
+    /** Distance between labelled ticks; the range is divided in 20 when omitted. */
+    step?: number;
+    /** Minor ticks between two labelled ticks; 0 hides them. */
+    minorTicks?: number;
+    /** Degrees covered by the scale; defaults to 280. */
+    angle?: number;
+    /** Degrees the scale is turned clockwise. */
+    rotation?: number;
+    /** The scale runs from `max` to `min`. */
+    inverted?: boolean;
+    /** Turns the tick labels with the scale. */
+    rotateText?: boolean;
+    /** Face of the dial; defaults to "circle". */
+    shape?: "circle" | "rectangle" | "segment";
+    /** Shape of the hand; defaults to "needle". */
+    handShape?: "needle" | "rectangle";
+    /** Colored bands behind the ticks. */
+    ranges?: GaugeBand[];
+    /** Text under the value, such as "km/h". */
+    units?: string;
+    /** Draws the value; defaults to true. */
+    showValue?: boolean;
+    /** Lets the user drag the hand; defaults to true. */
+    draggable?: boolean;
+    /** Formats the labels of the scale. */
+    formatLabel?: (value: number) => string;
+    /** Formats the value shown under the hand. */
+    formatValue?: (value: number) => string;
+}
+export interface NumericGaugeSeriesOptions extends GaugeBaseOptions {
+    type: "numericGauge";
+}
+/** A flat radial gauge: a track and a rounded arc that grows with the value. */
+export interface ArcGaugeSeriesOptions extends GaugeBaseOptions {
+    type: "arcGauge";
+    /** Degrees covered by the track, from 180 for a semicircle to 360 for a ring; defaults to 240. */
+    angle?: number;
+    /** Degrees the track is turned clockwise; 0 leaves the gap at the bottom. */
+    rotation?: number;
+    /** Width of the track as a percentage of the radius; defaults to 14. */
+    thickness?: number;
+    /** Rounds the ends of the track and the arc; defaults to true. */
+    roundCaps?: boolean;
+    /** Fills from the end of the track instead of from the start. */
+    inverted?: boolean;
+    /** The arc takes the color of the band that contains the value. */
+    ranges?: GaugeBand[];
+    /** Marks a value with a short line across the track. */
+    target?: number;
+    /** Text under the value. */
+    caption?: string;
+    /** Text next to the value, such as "%". */
+    units?: string;
+    /** Draws the minimum and the maximum under the ends of the track; defaults to true. */
+    limits?: boolean;
+    /** Draws the value in the middle; defaults to true. */
+    showValue?: boolean;
+    /** Lets the user drag the arc; defaults to false. */
+    draggable?: boolean;
+    /** Draws a knob at the end of the arc. */
+    knob?: boolean;
+    /** Value that dragging snaps to. */
+    step?: number;
+    /** Formats the value and the limits. */
+    formatValue?: (value: number) => string;
+    trackColor?: string;
+    textColor?: string;
+}
+export type GaugeSeriesOptions = CircularGaugeSeriesOptions | NumericGaugeSeriesOptions | ArcGaugeSeriesOptions;
+export interface BulletSeriesOptions extends AxisSeriesOptions {
+    type: "bullet";
+    /** Measure of each bullet. */
+    data: number[];
+    /** Draws bullets vertically instead of horizontally. */
+    vertical?: boolean;
+    /** Target marker position, relative to the origin; use an array for one target per point. */
+    target?: number | number[];
+    /** Consecutive qualitative range widths; use an array of arrays for different ranges per point. */
+    ranges?: number[] | number[][];
+}
+/**
+ * Maps every declarative series type to its options. Extend it with declaration merging to type
+ * series registered with `registerSeriesType`:
+ *
+ * ```ts
+ * declare module "teechart.js" {
+ *   interface SeriesOptionsRegistry { waterfall: WaterfallSeriesOptions }
+ * }
+ * ```
+ */
+export interface SeriesOptionsRegistry {
+    map: MapSeriesOptions;
+    colorGrid: ColorGridSeriesOptions;
+    surface: SurfaceSeriesOptions;
+    linearGauge: LinearGaugeSeriesOptions;
+    activityGauge: CircularSeriesOptions;
+    arcGauge: ArcGaugeSeriesOptions;
+    area: CartesianSeriesOptions;
+    bar: CartesianSeriesOptions;
+    bubble: CartesianSeriesOptions;
+    boxPlot: BoxPlotSeriesOptions;
+    bullet: BulletSeriesOptions;
+    candle: CandleSeriesOptions;
+    circularGauge: CircularGaugeSeriesOptions;
+    donut: CircularSeriesOptions;
+    gantt: GanttSeriesOptions;
+    highLowBar: HighLowBarSeriesOptions;
+    histogram: HistogramSeriesOptions;
+    horizArea: CartesianSeriesOptions;
+    horizBar: CartesianSeriesOptions;
+    line: CartesianSeriesOptions;
+    numericGauge: NumericGaugeSeriesOptions;
+    pie: CircularSeriesOptions;
+    point: CartesianSeriesOptions;
+    polar: PolarSeriesOptions;
+    sankey: SankeySeriesOptions;
+    sliced: CircularSeriesOptions;
+    treemap: TreemapSeriesOptions;
+    violin: ViolinSeriesOptions;
+    volume: CartesianSeriesOptions;
+}
+/** Creates the SVG map when the chart mounts, so options can be declared outside the browser. */
+export interface MapSeriesOptions extends AxisSeriesOptions {
+    type: "map";
+    data: () => MapDefinition;
+}
+/** One array of cell values per row. */
+export interface ColorGridSeriesOptions extends AxisSeriesOptions {
+    type: "colorGrid";
+    data: number[][];
+}
+export interface SurfaceSeriesOptions extends AxisSeriesOptions {
+    type: "surface";
+    data: number[][];
+    wireFrame?: boolean;
+}
+export interface LinearGaugeSeriesOptions extends SeriesStyleOptions {
+    type: "linearGauge";
+    data: number;
+    min?: number;
+    max?: number;
+}
+export type ChartType = keyof SeriesOptionsRegistry;
+export type SeriesOptions = SeriesOptionsRegistry[ChartType];
+export interface ChartDataOptions {
+    labels?: string[];
+    series: SeriesOptions[];
+}
+export interface AxisOptions {
+    visible?: boolean;
+    title?: string;
+    minimum?: number;
+    maximum?: number;
+    increment?: number;
+    roundFirst?: boolean;
+    titleVisible?: boolean;
+    titleColor?: string;
+    titleFontSize?: number;
+    ticksVisible?: boolean;
+    /** Position of the axis as a percentage across the chart. */
+    position?: number;
+    innerTicksVisible?: boolean;
+    minorTicksVisible?: boolean;
+    lineColor?: string;
+    lineWidth?: number;
+    inverted?: boolean;
+    log?: boolean;
+    headroom?: number;
+    grid?: {
+        visible?: boolean;
+        centered?: boolean;
+        lineDash?: boolean;
+        lineColor?: string;
+        lineWidth?: number;
+        /** Fill color of alternating grid bands; an empty string disables the fill. */
+        bandColor?: string;
+    };
+    labels?: {
+        visible?: boolean;
+        decimals?: number;
+        fixedDecimals?: boolean;
+        rotation?: number;
+        labelStyle?: string;
+        dateFormat?: string;
+        valueFormat?: string;
+    };
+}
+export interface ZoomOptions {
+    enabled?: boolean;
+    direction?: "both" | "horizontal" | "vertical";
+    keepAspect?: boolean;
+    mouseButton?: number;
+    wheel?: {
+        enabled?: boolean;
+        factor?: number;
+    };
+}
+export interface ScrollOptions {
+    enabled?: boolean;
+    direction?: "both" | "horizontal" | "vertical";
+    mouseButton?: number;
+}
+export interface PanelOptions {
+    backgroundColor?: string;
+    borderColor?: string;
+    borderWidth?: number;
+    transparent?: boolean;
+    shadow?: boolean;
+    /** Corner radius of the chart panel, in pixels. */
+    borderRadius?: number;
+    /** Enables a panel fill gradient. */
+    gradientVisible?: boolean;
+    /** Colors used by the panel fill gradient. */
+    gradientColors?: string[];
+    margins?: {
+        left?: number;
+        top?: number;
+        right?: number;
+        bottom?: number;
+    };
+}
+export interface DOMTipOptions {
+    enabled?: boolean;
+}
+export interface TooltipOptions {
+    enabled?: boolean;
+    /** Shows visible cartesian series at the hovered category or x value in the default tooltip. */
+    shared?: boolean;
+    render?: "dom" | "canvas";
+    autoHide?: boolean;
+    delay?: number;
+    animated?: number;
+    autoRedraw?: boolean;
+    findPoint?: boolean;
+    /** When true, the DOM tooltip follows the pointer instead of staying anchored to the hovered point. Defaults to false. */
+    followCursor?: boolean;
+    realTime?: boolean;
+    /** Adds x value, share of total, difference from the average, extremes and position to the DOM tooltip. */
+    extended?: boolean;
+    domStyle?: string;
+    format?: (series: Series, index: number) => string | Promise<string>;
+    pointer?: {
+        visible?: boolean;
+        fill?: string;
+        firstCircleRadius?: number;
+        secondCircleRadius?: number;
+        firstCircleOpacity?: number;
+        secondCircleOpacity?: number;
+        animationVisible?: boolean;
+        animationDuration?: number;
+    };
+}
+export interface AnimationOptions {
+    /** Duration in milliseconds. */
+    duration?: number;
+    /** Animation style. Defaults to `"axis"`. */
+    kind?: "axis" | "left" | "top" | "right" | "bottom" | "x" | "y" | "each" | "all" | "zoomin" | "zoomout";
+    mode?: "linear" | "exponential";
+    /** Fades the listed elements in while the series animate. */
+    fade?: {
+        duration?: number;
+        series?: boolean;
+        marks?: boolean;
+        legend?: boolean;
+        title?: boolean;
+        axes?: boolean;
+        panel?: boolean;
+    };
+}
+export interface CursorToolOptions {
+    enabled?: boolean;
+    direction?: "both" | "horizontal" | "vertical";
+    render?: "full" | "copy" | "layer";
+    followMouse?: boolean;
+    color?: string;
+    width?: number;
+    symbol?: "circle" | "square" | "diamond" | "none";
+    symbolSize?: number;
+}
+export interface DragToolOptions {
+    enabled?: boolean;
+}
+export interface AnnotationOptions {
+    text: string;
+    /** Left position in pixels. */
+    x?: number;
+    /** Top position in pixels. */
+    y?: number;
+    visible?: boolean;
+    transparent?: boolean;
+    backgroundColor?: string;
+    borderColor?: string;
+    borderWidth?: number;
+    fontColor?: string;
+    fontSize?: number;
+    fontFamily?: string;
+}
+export interface ToolsOptions {
+    cursor?: CursorToolOptions;
+    drag?: DragToolOptions;
+    annotations?: AnnotationOptions[];
+}
+/** Listeners for the events of a chart, by event name. See `ChartEventMap` for their arguments. */
+export type ChartListeners = {
+    [K in keyof ChartEventMap]?: EventListener<ChartEventMap[K]>;
+};
+/** Declarative chart title settings. */
+export interface ChartTitleOptions {
+    text?: string;
+    visible?: boolean;
+    fontSize?: number;
+    fontFamily?: string;
+    color?: string;
+    expand?: boolean;
+}
+export interface ChartOptions {
+    /** Plugins used only by this chart, in addition to globally registered plugins. */
+    plugins?: ChartPlugin[];
+    /** Per-chart plugin options keyed by id. Use `false` to disable a registered plugin on this chart. */
+    pluginOptions?: ChartPluginOptions;
+    /** Series type used by series that do not declare their own. Defaults to `"line"`. */
+    type?: ChartType;
+    data?: ChartDataOptions;
+    title?: string | ChartTitleOptions;
+    subtitle?: string;
+    footer?: string;
+    /**
+     * Theme applied when the chart is created. Defaults to `"minimal"`; use `null` to keep the engine
+     * defaults untouched. Theme and palette are applied before the rest of the options.
+     */
+    theme?: ChartTheme | null;
+    palette?: PaletteName | string[];
+    legend?: {
+        visible?: boolean;
+        position?: LegendPosition;
+        /** Text drawn above a vertical legend. */
+        title?: string;
+        style?: LegendStyle;
+        valueFormat?: LegendValueFormat;
+        interaction?: LegendInteraction;
+        /** Lists the items in reverse order. */
+        inverted?: boolean;
+        /** Draws each item text with the color of its series or point. */
+        fontColor?: boolean;
+        fontSize?: number;
+        /** Item text color. */
+        color?: string;
+        /** Item text color under the mouse; an empty string keeps `color`. */
+        hoverColor?: string;
+        /** Fill of the rounded highlight behind the item under the mouse; an empty string draws none. */
+        hoverBackground?: string;
+        /** Legend background; `null` makes it transparent. */
+        background?: string | null;
+        /** Horizontal space between the items of a horizontal legend, in pixels; use `rowGap` for vertical legends. */
+        itemGap?: number;
+        /** Vertical space between rows of items, in pixels. */
+        rowGap?: number;
+        symbol?: {
+            style?: LegendSymbolShape;
+            /** Sets both the width and the height of the symbol, in pixels. */
+            size?: number;
+            width?: number;
+            height?: number;
+            /** Space between the symbol and the item text, in pixels. */
+            padding?: number;
+            /** Corner radius of rectangle symbols, in pixels. */
+            radius?: number;
+            /** Shows the line and pointer style from each series in the legend. */
+            useSeriesPointer?: boolean;
+        };
+    };
+    axes?: {
+        bottom?: AxisOptions;
+        left?: AxisOptions;
+        top?: AxisOptions;
+        right?: AxisOptions;
+    };
+    panel?: PanelOptions;
+    aspect?: {
+        clip?: boolean;
+        view3d?: boolean;
+    };
+    walls?: {
+        visible?: boolean;
+    };
+    domTip?: DOMTipOptions;
+    tooltip?: TooltipOptions;
+    zoom?: ZoomOptions;
+    scroll?: ScrollOptions;
+    /**
+     * Device pixels per drawing unit, or `"auto"` for `window.devicePixelRatio`. Renders sharper on high
+     * density screens at the cost of more pixels to paint. Defaults to 1.
+     */
+    pixelRatio?: number | "auto";
+    /** Labels the canvas for screen readers, which cannot read what is painted on it. */
+    accessibility?: AccessibilityOptions;
+    /**
+     * Resizes the chart whenever its canvas changes display size, using `ResizeObserver`. The observer is
+     * removed when the chart is destroyed.
+     */
+    responsive?: boolean;
+    /** Plays an entrance animation once the series are added. */
+    animation?: AnimationOptions;
+    tools?: ToolsOptions;
+    /**
+     * Event listeners. They are attached to the chart, replaced as a group when `on` is set again, and
+     * removed by `Chart.destroy`. Use `chart.on` for listeners that are not part of the options.
+     */
+    on?: ChartListeners;
+}
+/** Chart option sections that can be restored to TeeChart.js defaults. */
+export type ResettableChartOption = "data" | "domTip" | "footer" | "legend" | "on" | "palette" | "panel" | "pluginOptions" | "scroll" | "subtitle" | "theme" | "title" | "tooltip" | "type" | "zoom";
+export declare function isChartOptions(value: unknown): value is ChartOptions;
+interface OptionSections {
+    tools: (chart: Chart, options: ToolsOptions) => void;
+    animation: (chart: Chart, options: AnimationOptions) => void;
+    /** Returns a function that stops keeping the accessible texts up to date. */
+    accessibility: (chart: Chart, options: AccessibilityOptions) => () => void;
+    /** Returns a function that stops observing the canvas size. */
+    responsive: (chart: Chart) => () => void;
+}
+/**
+ * Enables a chart option section whose implementation is kept out of the core bundle. See
+ * `registerAllOptions`.
+ * @internal
+ */
+export declare function registerOptionSection<K extends keyof OptionSections>(name: K, apply: OptionSections[K]): void;
+/**
+ * Returns the chart tool of the given class, adding one when the chart has none.
+ * @internal
+ */
+export declare function findOrAddTool<T extends Tool>(chart: Chart, ToolClass: new (chart: Chart) => T): T;
+/** Applies the options a chart is created with: the default theme first, then everything else. */
+export declare function applyChartOptions(chart: Chart, options: ChartOptions): void;
+/**
+ * Applies a patch over the options already applied to the chart. Only the given keys change, series
+ * are matched by position, and a theme or palette reapplies the options that refine them.
+ */
+export declare function updateChartOptions(chart: Chart, patch: ChartOptions): void;
+/** Restores the selected declarative option sections to their TeeChart.js defaults. */
+export declare function resetChartOptions(chart: Chart, sections?: readonly ResettableChartOption[]): void;
+/** Returns a copy of the declarative options applied to the chart so far. */
+export declare function getChartOptions(chart: Chart): ChartOptions;
+/**
+ * How to bring a chart that was built from `previous` in line with `next`: `"none"` when they are
+ * equivalent, `"patch"` when `Chart.setOptions` can do it, and `"recreate"` when a value was removed or
+ * the plugin definitions changed.
+ */
+export type ChartOptionsChange = "none" | "patch" | "recreate";
+export interface ChartOptionsComparison {
+    change: ChartOptionsChange;
+    /**
+     * What to pass to `Chart.setOptions`: only the top level sections whose value changed, so that an
+     * unchanged `theme` is not reapplied and an unchanged `animation` does not play again. For
+     * `"recreate"` it holds all of `next`, ready for the new chart.
+     */
+    patch: ChartOptions;
+}
+export declare function compareChartOptions(previous: ChartOptions | undefined, next: ChartOptions | undefined): ChartOptionsComparison;
+//# sourceMappingURL=chart-options.d.ts.map