@uwdata/mosaic-spec 0.7.0 → 0.8.0

package/src/spec/marks/Raster.ts

@@ -0,0 +1,145 @@
+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/src/spec/marks/Rect.ts

@@ -0,0 +1,183 @@
+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; // disallow x interval
+}
+
+/** 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; // disallow y interval
+}
+
+/** 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/src/spec/marks/Regression.ts

@@ -0,0 +1,63 @@
+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';
+}

package/src/spec/marks/Rule.ts

@@ -0,0 +1,113 @@
+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';
+}

package/src/spec/marks/Text.ts

@@ -0,0 +1,122 @@
+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/src/spec/marks/Tick.ts

@@ -0,0 +1,69 @@
+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';
+}