@uwdata/mosaic-spec 0.7.0 → 0.8.0

package/dist/types/spec/marks/Raster.d.ts

@@ -0,0 +1,124 @@
+import { ParamRef } from '../Param.js';
+import { ChannelValueSpec, MarkData, MarkOptions } from './Marks.js';
+/**
+ * A spatial interpolation method; one of:
+ *
+ * - *none* - do not perform interpolation (the default), maps samples to single bins
+ * - *linear* - apply proportional linear interpolation across adjacent bins
+ * - *nearest* - assign each pixel to the closest sample’s value (Voronoi diagram)
+ * - *barycentric* - apply barycentric interpolation over the Delaunay triangulation
+ * - *random-walk* - apply a random walk from each pixel, stopping when near a sample
+ */
+export type GridInterpolate = 'none' | 'linear' | 'nearest' | 'barycentric' | 'random-walk';
+/** Options for grid2d marks. */
+export interface Grid2DOptions {
+    /**
+     * The horizontal position channel, typically bound to the *x* scale.
+     * Domain values are binned into a grid with *width* horizontal bins.
+     */
+    x?: ChannelValueSpec;
+    /**
+     * The vertical position channel, typically bound to the *y* scale.
+     * Domain values are binned into a grid with *height* vertical bins.
+     */
+    y?: ChannelValueSpec;
+    /** The width (number of columns) of the grid, in actual pixels. */
+    width?: number | ParamRef;
+    /** The height (number of rows) of the grid, in actual pixels. */
+    height?: number | ParamRef;
+    /**
+     * The effective screen size of a raster pixel, used to determine the height
+     * and width of the raster from the frame’s dimensions; defaults to 1.
+     */
+    pixelSize?: number | ParamRef;
+    /**
+     * The bin padding, one of 1 (default) to include extra padding for the final
+     * bin, or 0 to make the bins flush with the maximum domain value.
+     */
+    pad?: number | ParamRef;
+    /**
+     * The kernel density bandwidth for smoothing, in pixels.
+     */
+    bandwidth?: number | ParamRef;
+    /**
+     * The spatial interpolation method; one of:
+     *
+     * - *none* - do not perform interpolation (the default), maps samples to single bins
+     * - *linear* - apply proportional linear interpolation across adjacent bins
+     * - *nearest* - assign each pixel to the closest sample’s value (Voronoi diagram)
+     * - *barycentric* - apply barycentric interpolation over the Delaunay triangulation
+     * - *random-walk* - apply a random walk from each pixel, stopping when near a sample
+     */
+    interpolate?: GridInterpolate | null | ParamRef;
+}
+/** Options for the raster mark. */
+export interface RasterOptions extends Grid2DOptions, Omit<MarkOptions, 'fill' | 'fillOpacity'> {
+    /**
+     * The [image-rendering attribute][1]; defaults to *auto* (bilinear). The
+     * option may be set to *pixelated* to disable bilinear interpolation for a
+     * sharper image; however, note that this is not supported in WebKit.
+     *
+     * [1]: https://developer.mozilla.org/en-US/docs/Web/SVG/Attribute/image-rendering
+     */
+    imageRendering?: string | ParamRef;
+    /**
+     * The fill, typically bound to the *color* scale. Can be specified as a
+     * constant or a channel based on the input data.  Use the special value
+     * `"density"` to map computed density values to pixel colors. Use an
+     * aggregate expression to instead visualize an aggregate value per raster
+     * bin. If fill is set to a constant color or to a non-aggregate field,
+     * opacity will be used to convey densities. If a non-aggregate (group by)
+     * field is provided, multiple rasters are created with a unique categorical
+     * color per layer.
+     */
+    fill?: ChannelValueSpec | ParamRef;
+    /**
+     * The opacity, typically bound to the *opacity* scale. Can be specified as a
+     * constant or a channel based on the input data. Use the special value
+     * `"density"` to map computed density values to opacity. Use an aggregate
+     * expression to instead visualize an aggregate value per raster bin.
+     */
+    fillOpacity?: ChannelValueSpec | ParamRef;
+}
+/** The raster mark. */
+export interface Raster extends MarkData, RasterOptions {
+    /**
+     * A raster mark which renders a raster image from spatial samples. It
+     * represents discrete samples in abstract coordinates **x** and **y**;
+     * the **fill** and **fillOpacity** channels specify further abstract
+     * values (_e.g._, height in a topographic map) to be spatially
+     * interpolated to produce an image.
+     *
+     * The **x** and **y** data domains are binned into the cells ("pixels")
+     * of a raster grid, typically with an aggregate function evaluated over
+     * the binned data. The result can be optionally smoothed (blurred).
+     *
+     * To create a smoothed density heatmap, use the heatmap mark, which is
+     * a raster mark with different default options.
+     */
+    mark: 'raster';
+}
+/** The heatmap mark. */
+export interface Heatmap extends MarkData, RasterOptions {
+    /**
+     * Like raster, but with default options for accurate density estimation
+     * via smoothing. The *bandwidth* (20), *interpolate* ("linear"), and
+     * *pixelSize* (2) options are set to produce smoothed density heatmaps.
+     */
+    mark: 'heatmap';
+}
+/** The rasterTile mark. */
+export interface RasterTile extends MarkData, RasterOptions {
+    /**
+     * An experimental raster mark which performs tiling and prefetching to
+     * support more scalable rasters upon panning the domain. Uses a tile
+     * size that matches with current width and height, and prefetches data
+     * from neighboring tile segments.
+     */
+    mark: 'rasterTile';
+    /**
+     * The coordinates of the tile origin in the **x** and **y** data domains.
+     * Defaults to [0, 0].
+     */
+    origin?: [number, number] | ParamRef;
+}

package/dist/types/spec/marks/Rect.d.ts

@@ -0,0 +1,166 @@
+import { ParamRef } from '../Param.js';
+import { Interval } from '../PlotTypes.js';
+import { ChannelValueIntervalSpec, ChannelValueSpec, InsetOptions, MarkData, MarkOptions, StackOptions } from './Marks.js';
+/** Options for marks that render rectangles, including bar, cell, and rect. */
+export interface RectCornerOptions {
+    /**
+     * The rounded corner [*x*-radius][1], either in pixels or as a percentage of
+     * the rect width. If **rx** is not specified, it defaults to **ry** if
+     * present, and otherwise draws square corners.
+     *
+     * [1]: https://developer.mozilla.org/en-US/docs/Web/SVG/Attribute/rx
+     */
+    rx?: number | string | ParamRef;
+    /**
+     * The rounded corner [*y*-radius][1], either in pixels or as a percentage of
+     * the rect height. If **ry** is not specified, it defaults to **rx** if
+     * present, and otherwise draws square corners.
+     *
+     * [1]: https://developer.mozilla.org/en-US/docs/Web/SVG/Attribute/ry
+     */
+    ry?: number | string | ParamRef;
+}
+/** Options for the rect mark. */
+export interface RectOptions extends MarkOptions, InsetOptions, RectCornerOptions, StackOptions {
+    /**
+     * The horizontal position (or length/width) channel, typically bound to the
+     * *x* scale.
+     *
+     * If an **interval** is specified, then **x1** and **x2** are derived from
+     * **x**, representing the lower and upper bound of the containing interval,
+     * respectively. For example, for a vertical bar chart of items sold by day:
+     *
+     * ```js
+     * Plot.rectY(sales, {x: "date", interval: "day", y2: "items"})
+     * ```
+     *
+     * If *x* represents ordinal values, use a bar or cell mark instead.
+     */
+    x?: ChannelValueIntervalSpec;
+    /**
+     * The required primary (starting, often left) horizontal position channel,
+     * typically bound to the *x* scale. Setting this option disables the rectX
+     * mark’s implicit stackX transform.
+     *
+     * If *x* represents ordinal values, use a bar or cell mark instead.
+     */
+    x1?: ChannelValueSpec;
+    /**
+     * The required secondary (ending, often right) horizontal position channel,
+     * typically bound to the *x* scale. Setting this option disables the rectX
+     * mark’s implicit stackX transform.
+     *
+     * If *x* represents ordinal values, use a bar or cell mark instead.
+     */
+    x2?: ChannelValueSpec;
+    /**
+     * The vertical position (or length/height) channel, typically bound to the
+     * *y* scale.
+     *
+     * If an **interval** is specified, then **y1** and **y2** are derived from
+     * **y**, representing the lower and upper bound of the containing interval,
+     * respectively. For example, for a horizontal bar chart of items sold by day:
+     *
+     * ```js
+     * Plot.rectX(sales, {y: "date", interval: "day", x2: "items"})
+     * ```
+     *
+     * If *y* represents ordinal values, use a bar or cell mark instead.
+     */
+    y?: ChannelValueIntervalSpec;
+    /**
+     * The required primary (starting, often bottom) vertical position channel,
+     * typically bound to the *y* scale. Setting this option disables the rectY
+     * mark’s implicit stackY transform.
+     *
+     * If *y* represents ordinal values, use a bar or cell mark instead.
+     */
+    y1?: ChannelValueSpec;
+    /**
+     * The required secondary (ending, often top) vertical position channel,
+     * typically bound to the *y* scale. Setting this option disables the rectY
+     * mark’s implicit stackY transform.
+     *
+     * If *y* represents ordinal values, use a bar or cell mark instead.
+     */
+    y2?: ChannelValueSpec;
+    /**
+     * How to convert a continuous value (**x** for rectY, **y** for rectX, or
+     * both for rect) into an interval (**x1** and **x2** for rectY, or **y1** and
+     * **y2** for rectX, or both for rect); one of:
+     *
+     * - a named time interval such as *day* (for date intervals)
+     * - a number (for number intervals), defining intervals at integer multiples of *n*
+     *
+     * Setting this option disables the implicit stack transform (stackX for rectX,
+     * or stackY for rectY).
+     */
+    interval?: Interval | ParamRef;
+}
+/** Options for the rectX mark. */
+export interface RectXOptions extends RectOptions {
+    /**
+     * The horizontal position (or length/width) channel, typically bound to the
+     * *x* scale.
+     *
+     * If neither **x1** nor **x2** is specified, an implicit stackX transform is
+     * applied and **x** defaults to the identity function, assuming that *data* =
+     * [*x₀*, *x₁*, *x₂*, …]. Otherwise, if only one of **x1** or **x2** is
+     * specified, the other defaults to **x**, which defaults to zero.
+     */
+    x?: ChannelValueSpec;
+}
+/** Options for the rectY mark. */
+export interface RectYOptions extends RectOptions {
+    /**
+     * The vertical position (or length/height) channel, typically bound to the
+     * *y* scale.
+     *
+     * If neither **y1** nor **y2** is specified, an implicit stackY transform is
+     * applied and **y** defaults to the identity function, assuming that *data* =
+     * [*y₀*, *y₁*, *y₂*, …]. Otherwise, if only one of **y1** or **y2** is
+     * specified, the other defaults to **y**, which defaults to zero.
+     */
+    y?: ChannelValueSpec;
+}
+/** The rect mark. */
+export interface Rect extends MarkData, RectOptions {
+    /**
+     * A rect mark. The rectangle extends horizontally from **x1** to **x2**,
+     * and vertically from **y1** to **y2**. The position channels are often
+     * derived with a transform.
+     *
+     * When **y** extends from zero, for example for a histogram where the
+     * height of each rect reflects a count of values, use the rectY mark for an
+     * implicit stackY transform; similarly, if **x** extends from zero, use the
+     * rectX mark for an implicit stackX transform.
+     *
+     * If an **interval** is specified, then **x1** and **x2** are derived from
+     * **x**, and **y1** and **y2** are derived from **y**, each representing the
+     * lower and upper bound of the containing interval, respectively.
+     *
+     * Both *x* and *y* should be quantitative or temporal; otherwise, use a bar
+     * or cell mark.
+     */
+    mark: 'rect';
+}
+/** The rectX mark. */
+export interface RectX extends MarkData, RectXOptions {
+    /**
+     * Like rect, but if neither **x1** nor **x2** is specified, an implicit
+     * stackX transform is applied to **x**, and if **x** is not specified, it
+     * defaults to the identity function, assuming that *data* is an array of
+     * numbers [*x₀*, *x₁*, *x₂*, …].
+     */
+    mark: 'rectX';
+}
+/** The rectY mark. */
+export interface RectY extends MarkData, RectYOptions {
+    /**
+     * Like rect, but if neither **y1** nor **y2** is specified, apply an
+     * implicit stackY transform is applied to **y**, and if **y** is not
+     * specified, it defaults to the identity function, assuming that *data*
+     * is an array of numbers [*y₀*, *y₁*, *y₂*, …].
+     */
+    mark: 'rectY';
+}

package/dist/types/spec/marks/Regression.d.ts

@@ -0,0 +1,58 @@
+import { ParamRef } from '../Param.js';
+import { ChannelValue, ChannelValueSpec, MarkData, MarkOptions } from './Marks.js';
+/** Options for regression marks. */
+interface RegressionOptions extends MarkOptions {
+    /**
+     * The confidence interval in (0, 1), or 0 to hide bands; defaults to 0.95.
+     */
+    ci?: number | ParamRef;
+    /**
+     * The distance in pixels between samples of the confidence band;
+     * defaults to 4.
+     */
+    precision?: number | ParamRef;
+    /**
+     * An optional ordinal channel for grouping data into (possibly stacked)
+     * series, producing an independent regression for each group. If not
+     * specified, it defaults to **fill** if a channel, or **stroke** if a
+     * channel.
+     */
+    z?: ChannelValue;
+}
+/** Options for the regressionY mark. */
+export interface RegressionYOptions extends RegressionOptions {
+    /**
+     * The independent variable horizontal position channel, typically bound to
+     * the *x* scale; defaults to the zero-based index of the data [0, 1, 2, …].
+     */
+    x?: ChannelValueSpec;
+    /**
+     * The dependent variable vertical position channel, typically bound to the
+     * *y* scale; defaults to identity, assuming that *data* = [*y₀*, *y₁*, *y₂*,
+     * …].
+     */
+    y?: ChannelValueSpec;
+}
+/** The regressionY mark. */
+export interface RegressionY extends MarkData, RegressionYOptions {
+    /**
+     * A mark that draws [linear regression][1] lines with confidence bands,
+     * representing the estimated relation of a dependent variable (*y*) on an
+     * independent variable (*x*).
+     *
+     * The linear regression line is fit using the [least squares][2] approach.
+     * See Torben Jansen’s [“Linear regression with confidence bands”][3] and
+     * [this StatExchange question][4] for details on the confidence interval
+     * calculation.
+     *
+     * Multiple regressions can be produced by specifying a **z**, **fill**, or
+     * **stroke** channel.
+     *
+     * [1]: https://en.wikipedia.org/wiki/Linear_regression
+     * [2]: https://en.wikipedia.org/wiki/Least_squares
+     * [3]: https://observablehq.com/@toja/linear-regression-with-confidence-bands
+     * [4]: https://stats.stackexchange.com/questions/101318/understanding-shape-and-calculation-of-confidence-bands-in-linear-regression
+     */
+    mark: 'regressionY';
+}
+export {};

package/dist/types/spec/marks/Rule.d.ts

@@ -0,0 +1,100 @@
+import { ParamRef } from '../Param.js';
+import { Interval } from '../PlotTypes.js';
+import { ChannelValueIntervalSpec, ChannelValueSpec, InsetOptions, MarkDataOptional, MarkOptions, MarkerOptions } from './Marks.js';
+/** Options for the ruleX and ruleY marks. */
+interface RuleOptions extends MarkOptions, MarkerOptions {
+    /**
+     * How to convert a continuous value (**y** for ruleX, or **x** for ruleY)
+     * into an interval (**y1** and **y2** for ruleX, or **x1** and **x2** for
+     * ruleY); one of:
+     *
+     * - a named time interval such as *day* (for date intervals)
+     * - a number (for number intervals), defining intervals at integer multiples of *n*
+     */
+    interval?: Interval | ParamRef;
+}
+/** Options for the ruleX mark. */
+export interface RuleXOptions extends RuleOptions, Omit<InsetOptions, 'insetLeft' | 'insetRight'> {
+    /**
+     * The horizontal position of the tick; an optional channel bound to the *x*
+     * scale. If not specified, the rule will be horizontally centered in the
+     * plot’s frame.
+     */
+    x?: ChannelValueSpec;
+    /**
+     * Shorthand for specifying both the primary and secondary vertical position
+     * of the tick as the bounds of the containing interval; can only be used in
+     * conjunction with the **interval** option.
+     */
+    y?: ChannelValueIntervalSpec;
+    /**
+     * The primary (starting, often bottom) vertical position of the tick; a
+     * channel bound to the *y* scale.
+     *
+     * If *y* represents ordinal values, use a tickX mark instead.
+     */
+    y1?: ChannelValueSpec;
+    /**
+     * The secondary (ending, often top) vertical position of the tick; a channel
+     * bound to the *y* scale.
+     *
+     * If *y* represents ordinal values, use a tickX mark instead.
+     */
+    y2?: ChannelValueSpec;
+}
+/** Options for the ruleY mark. */
+export interface RuleYOptions extends RuleOptions, Omit<InsetOptions, "insetTop" | "insetBottom"> {
+    /**
+     * Shorthand for specifying both the primary and secondary horizontal position
+     * of the tick as the bounds of the containing interval; can only be used in
+     * conjunction with the **interval** option.
+     */
+    x?: ChannelValueIntervalSpec;
+    /**
+     * The primary (starting, often left) horizontal position of the tick; a
+     * channel bound to the *x* scale.
+     *
+     * If *x* represents ordinal values, use a tickY mark instead.
+     */
+    x1?: ChannelValueSpec;
+    /**
+     * The secondary (ending, often right) horizontal position of the tick; a
+     * channel bound to the *x* scale.
+     *
+     * If *x* represents ordinal values, use a tickY mark instead.
+     */
+    x2?: ChannelValueSpec;
+    /**
+     * The vertical position of the tick; an optional channel bound to the *y*
+     * scale. If not specified, the rule will be vertically centered in the plot’s
+     * frame.
+     */
+    y?: ChannelValueSpec;
+}
+/** The ruleX mark. */
+export interface RuleX extends MarkDataOptional, RuleXOptions {
+    /**
+     * A horizontally-positioned ruleX mark (a vertical line, |). The **x**
+     * channel specifies the rule’s horizontal position and defaults to identity,
+     * assuming that *data* = [*x₀*, *x₁*, *x₂*, …]; the optional **y1** and
+     * **y2** channels specify its vertical extent.
+     *
+     * The ruleX mark is often used to highlight specific *x* values.
+     * If *y* represents ordinal values, use a tickX mark instead.
+     */
+    mark: 'ruleX';
+}
+/** The ruleY mark. */
+export interface RuleY extends MarkDataOptional, RuleXOptions {
+    /**
+     * A vertically-positioned ruleY mark (a horizontal line, —). The **y**
+     * channel specifies the rule's vertical position and defaults to identity,
+     * assuming that *data* = [*y₀*, *y₁*, *y₂*, …]; the optional **x1** and
+     * **x2** channels specify its horizontal extent.
+     *
+     * The ruleY mark is often used to highlight specific *y* values.
+     * If *x* represents ordinal values, use a tickY mark instead.
+     */
+    mark: 'ruleY';
+}
+export {};

package/dist/types/spec/marks/Text.d.ts

@@ -0,0 +1,106 @@
+import { ParamRef } from '../Param.js';
+import { FrameAnchor, Interval } from '../PlotTypes.js';
+import { ChannelValue, ChannelValueIntervalSpec, ChannelValueSpec, MarkDataOptional, MarkOptions, TextStyles } from './Marks.js';
+/** Options for the text mark. */
+export interface TextOptions extends MarkOptions, TextStyles {
+    /**
+     * The horizontal position channel specifying the text’s anchor point,
+     * typically bound to the *x* scale.
+     */
+    x?: ChannelValueSpec;
+    /**
+     * The vertical position channel specifying the text’s anchor point, typically
+     * bound to the *y* scale.
+     */
+    y?: ChannelValueSpec;
+    /**
+     * The text contents channel, possibly with line breaks (\n, \r\n, or \r). If
+     * not specified, defaults to the zero-based index [0, 1, 2, …].
+     */
+    text?: ChannelValue;
+    /**
+     * The frame anchor specifies defaults for **x** and **y**, along with
+     * **textAnchor** and **lineAnchor**, based on the plot’s frame; it may be one
+     * of the four sides (*top*, *right*, *bottom*, *left*), one of the four
+     * corners (*top-left*, *top-right*, *bottom-right*, *bottom-left*), or the
+     * *middle* of the frame.
+     */
+    frameAnchor?: FrameAnchor | ParamRef;
+    /**
+     * The line anchor controls how text is aligned (typically vertically)
+     * relative to its anchor point; it is one of *top*, *bottom*, or *middle*. If
+     * the frame anchor is *top*, *top-left*, or *top-right*, the default line
+     * anchor is *top*; if the frame anchor is *bottom*, *bottom-right*, or
+     * *bottom-left*, the default is *bottom*; otherwise it is *middle*.
+     */
+    lineAnchor?: 'top' | 'middle' | 'bottom' | ParamRef;
+    /**
+     * The rotation angle in degrees clockwise; a constant or a channel; defaults
+     * to 0°. When a number, it is interpreted as a constant; otherwise it is
+     * interpreted as a channel.
+     */
+    rotate?: ChannelValue | ParamRef;
+}
+/** Options for the textX mark. */
+export interface TextXOptions extends Omit<TextOptions, 'y'> {
+    /**
+     * The vertical position of the text’s anchor point, typically bound to the
+     * *y* scale.
+     */
+    y?: ChannelValueIntervalSpec;
+    /**
+     * An interval (such as *day* or a number), to transform **y** values to the
+     * middle of the interval.
+     */
+    interval?: Interval | ParamRef;
+}
+/** Options for the textY mark. */
+export interface TextYOptions extends Omit<TextOptions, 'x'> {
+    /**
+     * The horizontal position of the text’s anchor point, typically bound to the
+     * *x* scale.
+     */
+    x?: ChannelValueIntervalSpec;
+    /**
+     * An interval (such as *day* or a number), to transform **x** values to the
+     * middle of the interval.
+     */
+    interval?: Interval;
+}
+/** The text mark. */
+export interface Text extends MarkDataOptional, TextOptions {
+    /**
+     * A text mark. The **text** channel specifies the textual contents of the
+     * mark, which may be preformatted with line breaks (\n, \r\n, or \r), or
+     * wrapped or clipped using the **lineWidth** and **textOverflow** options.
+     *
+     * If **text** contains numbers or dates, a default formatter will be
+     * applied, and the **fontVariant** will default to *tabular-nums* instead
+     * of *normal*. If **text** is not specified, it defaults to the identity
+     * function for primitive data (such as numbers, dates, and strings), and to
+     * the zero-based index [0, 1, 2, …] for objects (so that something
+     * identifying is visible by default).
+     *
+     * If either **x** or **y** is not specified, the default is determined by
+     * the **frameAnchor** option.
+     */
+    mark: 'text';
+}
+/** The textX mark. */
+export interface TextX extends MarkDataOptional, TextXOptions {
+    /**
+     * Like text, but **x** defaults to the identity function, assuming that
+     * *data* = [*x₀*, *x₁*, *x₂*, …]. If an **interval** is specified, such as
+     * *day*, **y** is transformed to the middle of the interval.
+     */
+    mark: 'textX';
+}
+/** The textY mark. */
+export interface TextY extends MarkDataOptional, TextYOptions {
+    /**
+     * Like text, but **y** defaults to the identity function, assuming that
+     * *data* = [*y₀*, *y₁*, *y₂*, …]. If an **interval** is specified, such as
+     * *day*, **x** is transformed to the middle of the interval.
+     */
+    mark: 'textY';
+}

package/dist/types/spec/marks/Tick.d.ts

@@ -0,0 +1,61 @@
+import { ChannelValueSpec, InsetOptions, MarkData, MarkOptions, MarkerOptions } from './Marks.js';
+/** Options for the tickX mark. */
+export interface TickXOptions extends MarkOptions, MarkerOptions, Omit<InsetOptions, 'insetLeft' | 'insetRight'> {
+    /**
+     * The required horizontal position of the tick; a channel typically bound to
+     * the *x* scale.
+     */
+    x?: ChannelValueSpec;
+    /**
+     * The optional vertical position of the tick; an ordinal channel typically
+     * bound to the *y* scale. If not specified, the tick spans the vertical
+     * extent of the frame; otherwise the *y* scale must be a *band* scale.
+     *
+     * If *y* represents quantitative or temporal values, use a ruleX mark
+     * instead.
+     */
+    y?: ChannelValueSpec;
+}
+/** Options for the tickY mark. */
+export interface TickYOptions extends MarkOptions, MarkerOptions, Omit<InsetOptions, 'insetTop' | 'insetBottom'> {
+    /**
+     * The required vertical position of the tick; a channel typically bound to
+     * the *y* scale.
+     */
+    y?: ChannelValueSpec;
+    /**
+     * The optional horizontal position of the tick; an ordinal channel typically
+     * bound to the *x* scale. If not specified, the tick spans the horizontal
+     * extent of the frame; otherwise the *x* scale must be a *band* scale.
+     *
+     * If *x* represents quantitative or temporal values, use a ruleY mark
+     * instead.
+     */
+    x?: ChannelValueSpec;
+}
+/** The tickX mark. */
+export interface TickX extends MarkData, TickXOptions {
+    /**
+     * A horizontally-positioned tickX mark (a vertical line, |). The **x**
+     * channel specifies the tick’s horizontal position and defaults to identity,
+     * assuming that *data* = [*x₀*, *x₁*, *x₂*, …]; the optional **y** ordinal
+     * channel specifies its vertical position.
+     *
+     * If *y* represents quantitative or temporal values, use a ruleX mark
+     * instead.
+     */
+    mark: 'tickX';
+}
+/** The tickY mark. */
+export interface TickY extends MarkData, TickYOptions {
+    /**
+     * A vertically-positioned tickY mark (a horizontal line, —). The **y**
+     * channel specifies the tick's vertical position and defaults to identity,
+     * assuming that *data* = [*y₀*, *y₁*, *y₂*, …]; the optional **x** ordinal
+     * channel specifies its horizontal position.
+     *
+     * If *x* represents quantitative or temporal values, use a ruleY mark
+     * instead.
+     */
+    mark: 'tickY';
+}