plot-io 0.12.0__py3-none-win_amd64.whl

plot_io/_methods.py

@@ -0,0 +1,1691 @@
+# Generated by tools/gen_api.py from the SETTINGS declarations: do not edit.
+"""Mixins of the settings classes: ``set`` typed for type checkers, and the
+methods of the built-in plot types on ``Plot``, ``Figure`` and ``PanelSet``.
+Nothing here is imported at run time but ``typing``."""
+
+from __future__ import annotations
+
+from typing import TYPE_CHECKING, Any, Unpack
+
+if TYPE_CHECKING:
+    from typing import Self
+
+    from . import types as t
+    from .colorbar import Colorbar
+    from .decorations import Decoration, Text, _Rule, _Span
+    from .facets import LayerSet
+    from .figure import FigureTitle
+    from .genome.contacts import HiC
+    from .genome.intervals import Bed, Genes, Gtf
+    from .genome.links import Links
+    from .genome.series import GenomeSeries
+    from .genome.signal import BigWig
+    from .genome.sites import SiteHeatmap, SiteProfile
+    from .helpers.dendrogram import Dendrogram
+    from .helpers.qq import QQ
+    from .helpers.raincloud import Raincloud
+    from .helpers.volcano import Ma, Manhattan, Volcano, _Thresholds
+    from .layers.base import Series
+    from .mapped import _MappedAxis
+    from .plot import Legend, Plot
+    from .presets.area import Area
+    from .presets.bar import Bar
+    from .presets.box import Box
+    from .presets.catpoints import Strip, Swarm, _CatPoints
+    from .presets.contour import Contour
+    from .presets.dots import Dots
+    from .presets.ecdf import Ecdf
+    from .presets.errorbar import Errorbar
+    from .presets.errors import Summarized
+    from .presets.fill import Fill
+    from .presets.heatmap import Heatmap
+    from .presets.hexbin import Hexbin
+    from .presets.hist import Hist
+    from .presets.hist2d import Hist2d
+    from .presets.kde import Kde
+    from .presets.line import Line
+    from .presets.pie import Pie
+    from .presets.regression import Regression
+    from .presets.scatter import Scatter
+    from .presets.stem import Stem
+    from .presets.violin import Violin
+    from .settings import Settings
+    from .titles import TitleBase
+else:
+    Bed = object
+    Colorbar = object
+    Contour = object
+    Decoration = object
+    FigureTitle = object
+    Genes = object
+    GenomeSeries = object
+    Heatmap = object
+    Legend = object
+    Plot = object
+    Scatter = object
+    Series = object
+    Settings = object
+    Summarized = object
+    Text = object
+    TitleBase = object
+    _CatPoints = object
+    _MappedAxis = object
+    _Rule = object
+    _Span = object
+    _Thresholds = object
+
+#: The plot types with a method here.
+LAYERS = frozenset(['area', 'bar', 'bed', 'bigwig', 'box', 'contour', 'dendrogram', 'dots',
+                   'ecdf', 'errorbar', 'fill', 'genes', 'gtf', 'heatmap', 'hexbin', 'hic',
+                   'hist', 'hist2d', 'kde', 'line', 'links', 'ma', 'manhattan', 'pie', 'qq',
+                   'raincloud', 'regression', 'scatter', 'site_heatmap', 'site_profile',
+                   'stem', 'strip', 'swarm', 'violin', 'volcano'])
+
+
+def _values(values: tuple[Any, ...], required: int) -> tuple[Any, ...]:
+    """The data arguments given: trailing ``None`` past the required ones left out."""
+    n = len(values)
+    while n > required and values[n - 1] is None:
+        n -= 1
+    return values[:n]
+
+
+def _named(named: dict[str, Any]) -> dict[str, Any]:
+    return {k: v for k, v in named.items() if v is not None}
+
+
+def _plot_layer(plot: Any, name: str, values: tuple[Any, ...], required: int,
+                named: dict[str, Any], settings: Any) -> Any:
+    from .layers import layer_type
+    return layer_type(name)(*_values(values, required), plot=plot, **_named(named),
+                            **settings)
+
+
+def _figure_layer(figure: Any, name: str, values: tuple[Any, ...], required: int,
+                  named: dict[str, Any], settings: Any) -> Any:
+    from .layers import figure_call, layer_type
+    return figure_call(figure, layer_type(name), _values(values, required),
+                       {**_named(named), **settings})
+
+
+def _panelset_layer(facets: Any, name: str, values: tuple[Any, ...], required: int,
+                    named: dict[str, Any], settings: Any) -> Any:
+    return facets.call(name, _values(values, required), {**_named(named), **settings})
+
+
+class AxisMixin(Settings):
+    """The typed API of ``Axis``."""
+
+    if TYPE_CHECKING:
+        def set(self, **settings: Unpack[t.AxisSettings]) -> Self:  # type: ignore[override]
+            """Set settings; ``None`` goes back to the inherited or default value."""
+
+
+class FigureColorbarMixin(Colorbar):
+    """The typed API of ``FigureColorbar``."""
+
+    if TYPE_CHECKING:
+        def set(self, **settings: Unpack[t.FigureColorbarSettings]) -> Self:  # type: ignore[override]
+            """Set settings; ``None`` goes back to the inherited or default value."""
+
+
+class AnnotateMixin(Text):
+    """The typed API of ``Annotate``."""
+
+    if TYPE_CHECKING:
+        def set(self, **settings: Unpack[t.AnnotateSettings]) -> Self:  # type: ignore[override]
+            """Set settings; ``None`` goes back to the inherited or default value."""
+
+
+class AxLineMixin(Decoration):
+    """The typed API of ``AxLine``."""
+
+    if TYPE_CHECKING:
+        def set(self, **settings: Unpack[t.AxLineSettings]) -> Self:  # type: ignore[override]
+            """Set settings; ``None`` goes back to the inherited or default value."""
+
+
+class BracketMixin(Decoration):
+    """The typed API of ``Bracket``."""
+
+    if TYPE_CHECKING:
+        def set(self, **settings: Unpack[t.BracketSettings]) -> Self:  # type: ignore[override]
+            """Set settings; ``None`` goes back to the inherited or default value."""
+
+
+class HLineMixin(_Rule):
+    """The typed API of ``HLine``."""
+
+    if TYPE_CHECKING:
+        def set(self, **settings: Unpack[t.HLineSettings]) -> Self:  # type: ignore[override]
+            """Set settings; ``None`` goes back to the inherited or default value."""
+
+
+class HSpanMixin(_Span):
+    """The typed API of ``HSpan``."""
+
+    if TYPE_CHECKING:
+        def set(self, **settings: Unpack[t.HSpanSettings]) -> Self:  # type: ignore[override]
+            """Set settings; ``None`` goes back to the inherited or default value."""
+
+
+class TextMixin(Decoration):
+    """The typed API of ``Text``."""
+
+    if TYPE_CHECKING:
+        def set(self, **settings: Unpack[t.TextSettings]) -> Self:  # type: ignore[override]
+            """Set settings; ``None`` goes back to the inherited or default value."""
+
+
+class VLineMixin(_Rule):
+    """The typed API of ``VLine``."""
+
+    if TYPE_CHECKING:
+        def set(self, **settings: Unpack[t.VLineSettings]) -> Self:  # type: ignore[override]
+            """Set settings; ``None`` goes back to the inherited or default value."""
+
+
+class VSpanMixin(_Span):
+    """The typed API of ``VSpan``."""
+
+    if TYPE_CHECKING:
+        def set(self, **settings: Unpack[t.VSpanSettings]) -> Self:  # type: ignore[override]
+            """Set settings; ``None`` goes back to the inherited or default value."""
+
+
+class FigureMixin(Settings):
+    """The typed API of ``Figure``."""
+
+    def scatter(self, x: Any, y: Any, *, data: Any = None, group: Any = None,
+                group_order: Any = None, group_missing: Any = None, group_colors: Any = None,
+                **settings: Unpack[t.ScatterFigureSettings]) -> Scatter:
+        """A new plot holding: Markers at points ``(x, y)``."""
+        return _figure_layer(self, "scatter", (x, y), 2, {"data": data, "group": group,
+                                                          "group_order": group_order,
+                                                          "group_missing": group_missing,
+                                                          "group_colors": group_colors}, settings)
+
+    def line(self, x: Any, y: Any = None, *, data: Any = None, group: Any = None,
+             group_order: Any = None, group_missing: Any = None, group_colors: Any = None,
+             **settings: Unpack[t.LineFigureSettings]) -> Line:
+        """A new plot holding: A line through ``(x, y)``; ``y`` may hold several columns (one
+        line each, sharing ``x``: a 2-D buffer's columns, a data frame, a list of arrays),
+        and ``x`` may be omitted (``0, 1, 2, …``). ``orientation="horizontal"`` draws ``x``
+        on the y axis (a profile along y). Numbers per point (or ``"density"``) in
+        ``marker_color``/``marker_edge_color`` map through the series' color axis.
+        """
+        return _figure_layer(self, "line", (x, y), 1, {"data": data, "group": group,
+                                                       "group_order": group_order,
+                                                       "group_missing": group_missing,
+                                                       "group_colors": group_colors}, settings)
+
+    def fill(self, x: Any, y1: Any, y2: Any = 0.0, *, data: Any = None, group: Any = None,
+             group_order: Any = None, group_missing: Any = None, group_colors: Any = None,
+             **settings: Unpack[t.FillFigureSettings]) -> Fill:
+        """A new plot holding: The area between ``y1`` and ``y2`` (a sequence or a constant)
+        along ``x``; ``orientation="horizontal"`` fills between x curves along y (``fill(y,
+        x1, x2)``).
+        """
+        return _figure_layer(self, "fill", (x, y1, y2), 2, {"data": data, "group": group,
+                                                            "group_order": group_order,
+                                                            "group_missing": group_missing,
+                                                            "group_colors": group_colors}, settings)
+
+    def box(self, values: Any, positions: Any = None, *, data: Any = None, group: Any = None,
+            group_order: Any = None, group_missing: Any = None, group_colors: Any = None,
+            **settings: Unpack[t.BoxFigureSettings]) -> Box:
+        """A new plot holding: Box plots of ``values``: a dict ``{category: values}``, a list
+        of arrays (categories ``0, 1, …`` or ``categories=``), or one array.
+        """
+        return _figure_layer(self, "box", (values, positions), 1, {"data": data, "group": group,
+                                                                   "group_order": group_order,
+                                                                   "group_missing": group_missing,
+                                                                   "group_colors": group_colors}, settings)
+
+    def heatmap(self, values: Any, x: Any = None, y: Any = None, *, data: Any = None,
+                group: Any = None, group_order: Any = None, group_missing: Any = None,
+                group_colors: Any = None,
+                **settings: Unpack[t.HeatmapFigureSettings]) -> Heatmap:
+        """A new plot holding: A grid of values (rows first) as colored cells; ``x``/``y`` give
+        cell labels, centres or edges.
+        """
+        return _figure_layer(self, "heatmap", (values, x, y), 1, {"data": data, "group": group,
+                                                                  "group_order": group_order,
+                                                                  "group_missing": group_missing,
+                                                                  "group_colors": group_colors}, settings)
+
+    def bar(self, x: Any, y: Any = None, *, data: Any = None, group: Any = None,
+            group_order: Any = None, group_missing: Any = None, group_colors: Any = None,
+            **settings: Unpack[t.BarFigureSettings]) -> Bar:
+        """A new plot holding: Bars of height ``y`` at ``x`` (categories or numbers), or of a
+        dict ``{category: height}``, or of heights alone (at 0, 1, …).
+        """
+        return _figure_layer(self, "bar", (x, y), 1, {"data": data, "group": group,
+                                                      "group_order": group_order,
+                                                      "group_missing": group_missing,
+                                                      "group_colors": group_colors}, settings)
+
+    def hist(self, values: Any, *, data: Any = None, group: Any = None, group_order: Any = None,
+             group_missing: Any = None, group_colors: Any = None,
+             **settings: Unpack[t.HistFigureSettings]) -> Hist:
+        """A new plot holding: A histogram of ``values``: one array, or several (a dict or a
+        list of arrays) that share the same bins.
+        """
+        return _figure_layer(self, "hist", (values,), 1, {"data": data, "group": group,
+                                                          "group_order": group_order,
+                                                          "group_missing": group_missing,
+                                                          "group_colors": group_colors}, settings)
+
+    def kde(self, values: Any, y: Any = None, *, data: Any = None, group: Any = None,
+            group_order: Any = None, group_missing: Any = None, group_colors: Any = None,
+            **settings: Unpack[t.KdeFigureSettings]) -> Kde:
+        """A new plot holding: A Gaussian kernel density estimate of ``values`` (one array, or
+        several as a dict or a list of arrays, on a common grid).
+        """
+        return _figure_layer(self, "kde", (values, y), 1, {"data": data, "group": group,
+                                                           "group_order": group_order,
+                                                           "group_missing": group_missing,
+                                                           "group_colors": group_colors}, settings)
+
+    def ecdf(self, values: Any, *, data: Any = None, group: Any = None, group_order: Any = None,
+             group_missing: Any = None, group_colors: Any = None,
+             **settings: Unpack[t.EcdfFigureSettings]) -> Ecdf:
+        """A new plot holding: The empirical cumulative distribution of ``values`` (one array,
+        or several as a dict or a list of arrays).
+        """
+        return _figure_layer(self, "ecdf", (values,), 1, {"data": data, "group": group,
+                                                          "group_order": group_order,
+                                                          "group_missing": group_missing,
+                                                          "group_colors": group_colors}, settings)
+
+    def violin(self, values: Any, positions: Any = None, *, data: Any = None, group: Any = None,
+               group_order: Any = None, group_missing: Any = None, group_colors: Any = None,
+               **settings: Unpack[t.ViolinFigureSettings]) -> Violin:
+        """A new plot holding: Violins of ``values``: a dict ``{category: values}``, a list of
+        arrays (categories ``0, 1, …`` or ``categories=``), or one array.
+        """
+        return _figure_layer(self, "violin", (values, positions), 1, {"data": data,
+                                                                      "group": group,
+                                                                      "group_order": group_order,
+                                                                      "group_missing": group_missing,
+                                                                      "group_colors": group_colors}, settings)
+
+    def strip(self, values: Any, positions: Any = None, *, data: Any = None, group: Any = None,
+              group_order: Any = None, group_missing: Any = None, group_colors: Any = None,
+              **settings: Unpack[t.StripFigureSettings]) -> Strip:
+        """A new plot holding: Points of each category's values, spread across the slot by
+        random jitter (from a fixed seed, so output is reproducible).
+        """
+        return _figure_layer(self, "strip", (values, positions), 1, {"data": data,
+                                                                     "group": group,
+                                                                     "group_order": group_order,
+                                                                     "group_missing": group_missing,
+                                                                     "group_colors": group_colors}, settings)
+
+    def swarm(self, values: Any, positions: Any = None, *, data: Any = None, group: Any = None,
+              group_order: Any = None, group_missing: Any = None, group_colors: Any = None,
+              **settings: Unpack[t.SwarmFigureSettings]) -> Swarm:
+        """A new plot holding: Points of each category's values, side by side so that they do
+        not overlap (points that do not fit go to the slot's edge, with a warning; above
+        100,000 points, jittered across the width as a strip, with a warning).
+        """
+        return _figure_layer(self, "swarm", (values, positions), 1, {"data": data,
+                                                                     "group": group,
+                                                                     "group_order": group_order,
+                                                                     "group_missing": group_missing,
+                                                                     "group_colors": group_colors}, settings)
+
+    def area(self, x: Any, y: Any, *, data: Any = None, group: Any = None,
+             group_order: Any = None, group_missing: Any = None, group_colors: Any = None,
+             **settings: Unpack[t.AreaFigureSettings]) -> Area:
+        """A new plot holding: Areas of the layers ``y`` (one column, or several: a dict
+        ``{name: values}``, a data frame, a 2-D buffer's columns, a list of arrays) along
+        ``x``, stacked on ``baseline``; ``orientation="horizontal"`` runs them along y.
+        """
+        return _figure_layer(self, "area", (x, y), 2, {"data": data, "group": group,
+                                                       "group_order": group_order,
+                                                       "group_missing": group_missing,
+                                                       "group_colors": group_colors}, settings)
+
+    def errorbar(self, x: Any, y: Any, *, data: Any = None, group: Any = None,
+                 group_order: Any = None, group_missing: Any = None, group_colors: Any = None,
+                 **settings: Unpack[t.ErrorbarFigureSettings]) -> Errorbar:
+        """A new plot holding: Error bars at ``(x, y)``: ``y_error``/``x_error`` as a value, a
+        sequence, ``(low, high)`` or ``Errors``; ``marker`` adds markers at the points
+        (numbers per point in ``marker_color`` map through the series' color axis).
+        """
+        return _figure_layer(self, "errorbar", (x, y), 2, {"data": data, "group": group,
+                                                           "group_order": group_order,
+                                                           "group_missing": group_missing,
+                                                           "group_colors": group_colors}, settings)
+
+    def stem(self, x: Any, y: Any = None, *, data: Any = None, group: Any = None,
+             group_order: Any = None, group_missing: Any = None, group_colors: Any = None,
+             **settings: Unpack[t.StemFigureSettings]) -> Stem:
+        """A new plot holding: Stems from ``baseline`` to ``y`` at ``x`` (or at 0, 1, … when
+        ``y`` is omitted); numbers per point in ``marker_color`` map through the series'
+        color axis.
+        """
+        return _figure_layer(self, "stem", (x, y), 1, {"data": data, "group": group,
+                                                       "group_order": group_order,
+                                                       "group_missing": group_missing,
+                                                       "group_colors": group_colors}, settings)
+
+    def regression(self, x: Any, y: Any, *, data: Any = None, group: Any = None,
+                   group_order: Any = None, group_missing: Any = None, group_colors: Any = None,
+                   **settings: Unpack[t.RegressionFigureSettings]) -> Regression:
+        """A new plot holding: A regression of ``y`` on ``x``: a polynomial of ``order`` (least
+        squares) with a confidence band of the mean, or a LOWESS curve; ``scatter`` also
+        draws the points (numbers per point in ``marker_color`` map through the series'
+        color axis).
+        """
+        return _figure_layer(self, "regression", (x, y), 2, {"data": data, "group": group,
+                                                             "group_order": group_order,
+                                                             "group_missing": group_missing,
+                                                             "group_colors": group_colors}, settings)
+
+    def hist2d(self, x: Any, y: Any, *, data: Any = None, group: Any = None,
+               group_order: Any = None, group_missing: Any = None, group_colors: Any = None,
+               **settings: Unpack[t.Hist2dFigureSettings]) -> Hist2d:
+        """A new plot holding: A 2-D histogram of points ``(x, y)``: counts in bins (even on
+        the axis scales), drawn as a heatmap; bins with fewer than ``min_count`` points are
+        left empty.
+        """
+        return _figure_layer(self, "hist2d", (x, y), 2, {"data": data, "group": group,
+                                                         "group_order": group_order,
+                                                         "group_missing": group_missing,
+                                                         "group_colors": group_colors}, settings)
+
+    def hexbin(self, x: Any, y: Any, *, data: Any = None, group: Any = None,
+               group_order: Any = None, group_missing: Any = None, group_colors: Any = None,
+               **settings: Unpack[t.HexbinFigureSettings]) -> Hexbin:
+        """A new plot holding: A hexagonal 2-D histogram of points ``(x, y)``: ``bins`` regular
+        hexagons across the axes width. The lattice is laid out in page units for the axes
+        the layout placed (its domain is the data's, its bins the axes'), so the hexagons
+        are regular and tile exactly whatever the axes' aspect.
+        """
+        return _figure_layer(self, "hexbin", (x, y), 2, {"data": data, "group": group,
+                                                         "group_order": group_order,
+                                                         "group_missing": group_missing,
+                                                         "group_colors": group_colors}, settings)
+
+    def contour(self, values: Any, x: Any = None, y: Any = None, *, data: Any = None,
+                group: Any = None, group_order: Any = None, group_missing: Any = None,
+                group_colors: Any = None,
+                **settings: Unpack[t.ContourFigureSettings]) -> Contour:
+        """A new plot holding: Contour lines and/or filled bands of ``values`` (rows first) at
+        nodes ``x``/``y`` (centres; edges are reduced to their midpoints).
+        """
+        return _figure_layer(self, "contour", (values, x, y), 1, {"data": data, "group": group,
+                                                                  "group_order": group_order,
+                                                                  "group_missing": group_missing,
+                                                                  "group_colors": group_colors}, settings)
+
+    def pie(self, values: Any, *, data: Any = None, group: Any = None, group_order: Any = None,
+            group_missing: Any = None, group_colors: Any = None,
+            **settings: Unpack[t.PieFigureSettings]) -> Pie:
+        """A new plot holding: A pie (or donut, with ``hole``) of ``values``: a sequence, or a
+        dict ``{label: value}``; the plot is drawn without axes.
+        """
+        return _figure_layer(self, "pie", (values,), 1, {"data": data, "group": group,
+                                                         "group_order": group_order,
+                                                         "group_missing": group_missing,
+                                                         "group_colors": group_colors}, settings)
+
+    def dots(self, color: Any = None, size: Any = None, x: Any = None, y: Any = None, *,
+             data: Any = None, group: Any = None, group_order: Any = None,
+             group_missing: Any = None, group_colors: Any = None,
+             **settings: Unpack[t.DotsFigureSettings]) -> Dots:
+        """A new plot holding: One marker per cell of a grid: ``color`` and ``size`` are grids
+        of values (row 0 first) of one shape, or one value; ``x``/``y`` label the columns
+        and rows, as ``heatmap``'s. With long data (``x``, ``y`` and values per cell), the
+        cells come from the rows; cells without a row get no dot.
+        """
+        return _figure_layer(self, "dots", (color, size, x, y), 0, {"data": data,
+                                                                    "group": group,
+                                                                    "group_order": group_order,
+                                                                    "group_missing": group_missing,
+                                                                    "group_colors": group_colors}, settings)
+
+    def bigwig(self, reader: Any = None, *, x: Any = None, y: Any = None,
+               **settings: Unpack[t.BigWigFigureSettings]) -> BigWig:
+        """A new plot holding: A binned signal over the region: a step line along the bins,
+        filled to a baseline. ``reader`` is a signal reader (bigWig; bigBed, BED and peaks
+        give their coverage; :func:`~plot_io.genome.combine.combine` of two), a path (opened
+        with gwseq_io), ``chr``, ``start``, ``end``, ``value`` records (columns, a DataFrame
+        or rows; binned by plot_io), a function ``f(chr, start, end, bins)`` giving values,
+        or ``None`` with ``y`` (values over the region) and optionally ``x`` (bin centres,
+        or n + 1 edges, in bp).
+        """
+        return _figure_layer(self, "bigwig", (reader,), 0, {"x": x, "y": y}, settings)
+
+    def bed(self, reader: Any, **settings: Unpack[t.BedFigureSettings]) -> Bed:
+        """A new plot holding: Intervals over the region: boxes or gene models, on one row or
+        packed onto rows. ``reader`` is an interval reader (bigBed, BED, peaks), a path
+        (opened with gwseq_io) or plain data: a dict of columns, a DataFrame, or rows
+        (``start``, ``end`` and optionally ``name``, ``score``, ``strand``, ``thickStart``,
+        ``thickEnd``, ``itemRgb``, ``blockCount``, ``blockSizes``, ``blockStarts``).
+        """
+        return _figure_layer(self, "bed", (reader,), 1, {}, settings)
+
+    def genes(self, reader: Any, **settings: Unpack[t.GenesFigureSettings]) -> Genes:
+        """A new plot holding: Gene models (BED12): ``Bed`` with ``kind="genes"``, rows
+        expanded and names on.
+        """
+        return _figure_layer(self, "genes", (reader,), 1, {}, settings)
+
+    def gtf(self, reader: Any, **settings: Unpack[t.GtfFigureSettings]) -> Gtf:
+        """A new plot holding: Gene models of a GTF or GFF3 reader (``read_entries(model=)``)
+        or path: ``Genes``, one model per gene (its transcripts' exons merged) or per
+        transcript, or plain BED12 data as ``Genes`` takes it.
+        """
+        return _figure_layer(self, "gtf", (reader,), 1, {}, settings)
+
+    def hic(self, reader: Any, **settings: Unpack[t.HiCFigureSettings]) -> HiC:
+        """A new plot holding: The upper triangle of a contact matrix, the diagonal along the x
+        axis (each cell a diamond), or with ``shape="square"`` the whole matrix of
+        ``region`` (x) against ``region2`` (y, its start at the top). ``reader`` is a Hi-C
+        reader, a path (opened with gwseq_io), or a square matrix over the region (bins of
+        ``span / n``).
+        """
+        return _figure_layer(self, "hic", (reader,), 1, {}, settings)
+
+    def links(self, pairs: Any, **settings: Unpack[t.LinksFigureSettings]) -> Links:
+        """A new plot holding: Links between pairs of places (BEDPE): an arc from anchor centre
+        to anchor centre in a lane of its own, or, ``lane="over"`` a Hi-C triangle or
+        square, a mark at each pair's contact cell (on a square, and at its mirror).
+        ``pairs`` is a reader whose ``read_entries`` gives the BEDPE columns, a path
+        gwseq_io reads them from, or plain data (the pairs with an anchor in view are read):
+        a dict of columns, a DataFrame, or rows in BEDPE order (``chr1``, ``start1``,
+        ``end1``, ``chr2``, ``start2``, ``end2``, then optionally ``name``, ``score``).
+        """
+        return _figure_layer(self, "links", (pairs,), 1, {}, settings)
+
+    def site_heatmap(self, signal: Any, sites: Any, *, group: Any = None,
+                     **settings: Unpack[t.SiteHeatmapFigureSettings]) -> SiteHeatmap:
+        """A new plot holding: A signal around sites, one row per site (a table with ``chr``,
+        ``start``, ``end`` and optional ``strand``, ``summit`` columns, or an interval
+        reader), x the distance from the anchor in bp; ``group`` (a column of the sites, or
+        a label per site) makes a block of rows per group.
+        """
+        return _figure_layer(self, "site_heatmap", (signal, sites), 2, {"group": group}, settings)
+
+    def site_profile(self, signal: Any, sites: Any, *, group: Any = None,
+                     **settings: Unpack[t.SiteProfileFigureSettings]) -> SiteProfile:
+        """A new plot holding: The column mean (or median) of a signal around sites (see
+        :class:`SiteHeatmap`): one line per group, x the distance from the anchor in bp, an
+        optional band.
+        """
+        return _figure_layer(self, "site_profile", (signal, sites), 2, {"group": group}, settings)
+
+    def dendrogram(self, tree: Any, labels: Any = None,
+                   **settings: Unpack[t.DendrogramFigureSettings]) -> Dendrogram:
+        """A new plot holding: The merges of ``tree`` (a :class:`Tree`, or a scipy ``Z``) as
+        U-shaped links: the leaves at slots 0, 1, … in ``tree.leaves`` order on the leaf
+        axis, the heights on the value axis, the root at the top
+        (``orientation="horizontal"``: at the left, heights along x, the x axis inverted
+        unless set). ``labels`` (default: the tree's) make the leaf axis categorical, in
+        leaf order, so a heatmap with the same categories shares it; without labels each
+        leaf is ticked with its observation's index. Every leaf is labelled: turned 90° when
+        the labels do not fit flat, then smaller, down to the axis' ``label_min_size`` (6
+        pt), and every k-th only below it.
+        """
+        return _figure_layer(self, "dendrogram", (tree, labels), 1, {}, settings)
+
+    def qq(self, values: Any, y: Any = None, **settings: Unpack[t.QQFigureSettings]) -> QQ:
+        """A new plot holding: The sorted ``values`` against the quantiles of ``dist`` at R's
+        ``ppoints`` (``(i − a) / (n + 1 − 2a)``, a = 3/8 for n ≤ 10, else 1/2), or against
+        the sorted ``y`` (two samples: the longer interpolated to the shorter's size, as R's
+        ``qqplot``; ``values`` on x). ``pvalues=True``: ``values`` are p-values, drawn as
+        −log10 of the sorted p-values (y) against −log10 of the expected uniform quantiles
+        (x). Points as `Scatter`'s; the reference ``line`` and the pointwise ``band`` of
+        order statistics in the series color. The points and the default line are R's
+        (``qqnorm``, ``qqline``), not scipy's ``probplot`` (Filliben's medians, a least-
+        squares line).
+        """
+        return _figure_layer(self, "qq", (values, y), 1, {}, settings)
+
+    def raincloud(self, values: Any, positions: Any = None,
+                  **settings: Unpack[t.RaincloudFigureSettings]) -> Raincloud:
+        """A new plot holding: Rainclouds of ``values`` (a dict ``{category: values}``, a list
+        of arrays, or one array; long data with ``x=`` categories): per category a half
+        violin on the high side (stat ``violin``), a narrow box at the centre (stat ``box``)
+        and the values as jittered points on the low side. ``parts`` keeps some of the
+        three. Widths and offsets are `%` of the slot.
+        """
+        return _figure_layer(self, "raincloud", (values, positions), 1, {}, settings)
+
+    def volcano(self, fold_change: Any, p: Any,
+                **settings: Unpack[t.VolcanoFigureSettings]) -> Volcano:
+        """A new plot holding: Differential results: log2 ``fold_change`` (x) against −log10
+        ``p`` (y; p = 0 at the smallest positive p, NaN left out). Points are ``up``,
+        ``down`` or ``n.s.``: up or down when ``p < p_threshold`` and |fold change| ≥
+        ``fold_change_threshold``, coloured by ``colors`` as a level axis on ``color`` (the
+        legend counts them), dashed rules at the thresholds. ``labels`` gives a text per
+        point, ``label`` which are drawn (placed as Scatter's). The classification settings
+        are read at the call.
+        """
+        return _figure_layer(self, "volcano", (fold_change, p), 2, {}, settings)
+
+    def ma(self, mean: Any, fold_change: Any, p: Any = None,
+           **settings: Unpack[t.MaFigureSettings]) -> Ma:
+        """A new plot holding: An MA plot: mean expression ``mean`` (x, on a log10 axis unless
+        the axis has a scale) against log2 ``fold_change`` (y), a rule at 0 and dashed ones
+        at ± ``fold_change_threshold``. Classes, colors and labels as `Volcano`'s (by fold
+        change alone without ``p``; ``label="top"``: the largest |fold change| among the
+        significant).
+        """
+        return _figure_layer(self, "ma", (mean, fold_change, p), 2, {}, settings)
+
+    def manhattan(self, chromosomes: Any, positions: Any, p: Any,
+                  **settings: Unpack[t.ManhattanFigureSettings]) -> Manhattan:
+        """A new plot holding: Genome-wide association results: −log10 ``p`` (y) at
+        ``positions`` (bp) of ``chromosomes`` laid end to end (x) in natural order (chr1 …
+        chr22, X, Y, M), each ``chr_sizes`` long (unset: to its last position), its points
+        in the next of the two ``colors``, its name as the tick at its middle (left to
+        right, a name that would overlap the last one shown is left out), the x axis from
+        the first chromosome's start to the last one's end; a dashed rule at ``threshold``
+        (genome-wide significance). ``labels``/``label``/``label_count`` as `Volcano`'s
+        (``top``: the most significant beyond ``threshold``).
+        """
+        return _figure_layer(self, "manhattan", (chromosomes, positions, p), 3, {}, settings)
+
+
+class FigureTitleMixin(TitleBase):
+    """The typed API of ``FigureTitle``."""
+
+    if TYPE_CHECKING:
+        def set(self, **settings: Unpack[t.FigureTitleSettings]) -> Self:  # type: ignore[override]
+            """Set settings; ``None`` goes back to the inherited or default value."""
+
+
+class MainTitleMixin(FigureTitle):
+    """The typed API of ``MainTitle``."""
+
+    if TYPE_CHECKING:
+        def set(self, **settings: Unpack[t.MainTitleSettings]) -> Self:  # type: ignore[override]
+            """Set settings; ``None`` goes back to the inherited or default value."""
+
+
+class BedMixin(GenomeSeries):
+    """The typed API of ``Bed``."""
+
+    if TYPE_CHECKING:
+        def set(self, **settings: Unpack[t.BedSettings]) -> Self:  # type: ignore[override]
+            """Set settings; ``None`` goes back to the inherited or default value."""
+
+
+class GenesMixin(Bed):
+    """The typed API of ``Genes``."""
+
+    if TYPE_CHECKING:
+        def set(self, **settings: Unpack[t.GenesSettings]) -> Self:  # type: ignore[override]
+            """Set settings; ``None`` goes back to the inherited or default value."""
+
+
+class GtfMixin(Genes):
+    """The typed API of ``Gtf``."""
+
+    if TYPE_CHECKING:
+        def set(self, **settings: Unpack[t.GtfSettings]) -> Self:  # type: ignore[override]
+            """Set settings; ``None`` goes back to the inherited or default value."""
+
+
+class TrackMixin(Plot):
+    """The typed API of ``Track``."""
+
+    if TYPE_CHECKING:
+        def set(self, **settings: Unpack[t.TrackSettings]) -> Self:  # type: ignore[override]
+            """Set settings; ``None`` goes back to the inherited or default value."""
+
+
+class LinksMixin(GenomeSeries):
+    """The typed API of ``Links``."""
+
+    if TYPE_CHECKING:
+        def set(self, **settings: Unpack[t.LinksSettings]) -> Self:  # type: ignore[override]
+            """Set settings; ``None`` goes back to the inherited or default value."""
+
+
+class DendrogramMixin(Series):
+    """The typed API of ``Dendrogram``."""
+
+    if TYPE_CHECKING:
+        def set(self, **settings: Unpack[t.DendrogramSettings]) -> Self:  # type: ignore[override]
+            """Set settings; ``None`` goes back to the inherited or default value."""
+
+
+class QQMixin(Scatter):
+    """The typed API of ``QQ``."""
+
+    if TYPE_CHECKING:
+        def set(self, **settings: Unpack[t.QQSettings]) -> Self:  # type: ignore[override]
+            """Set settings; ``None`` goes back to the inherited or default value."""
+
+
+class RaincloudMixin(Series):
+    """The typed API of ``Raincloud``."""
+
+    if TYPE_CHECKING:
+        def set(self, **settings: Unpack[t.RaincloudSettings]) -> Self:  # type: ignore[override]
+            """Set settings; ``None`` goes back to the inherited or default value."""
+
+
+class MaMixin(_Thresholds):
+    """The typed API of ``Ma``."""
+
+    if TYPE_CHECKING:
+        def set(self, **settings: Unpack[t.MaSettings]) -> Self:  # type: ignore[override]
+            """Set settings; ``None`` goes back to the inherited or default value."""
+
+
+class ManhattanMixin(Scatter):
+    """The typed API of ``Manhattan``."""
+
+    if TYPE_CHECKING:
+        def set(self, **settings: Unpack[t.ManhattanSettings]) -> Self:  # type: ignore[override]
+            """Set settings; ``None`` goes back to the inherited or default value."""
+
+
+class VolcanoMixin(_Thresholds):
+    """The typed API of ``Volcano``."""
+
+    if TYPE_CHECKING:
+        def set(self, **settings: Unpack[t.VolcanoSettings]) -> Self:  # type: ignore[override]
+            """Set settings; ``None`` goes back to the inherited or default value."""
+
+
+class SizeLegendMixin(Settings):
+    """The typed API of ``SizeLegend``."""
+
+    if TYPE_CHECKING:
+        def set(self, **settings: Unpack[t.SizeLegendSettings]) -> Self:  # type: ignore[override]
+            """Set settings; ``None`` goes back to the inherited or default value."""
+
+
+class ColorAxisMixin(_MappedAxis):
+    """The typed API of ``ColorAxis``."""
+
+    if TYPE_CHECKING:
+        def set(self, **settings: Unpack[t.ColorAxisSettings]) -> Self:  # type: ignore[override]
+            """Set settings; ``None`` goes back to the inherited or default value."""
+
+
+class SizeAxisMixin(_MappedAxis):
+    """The typed API of ``SizeAxis``."""
+
+    if TYPE_CHECKING:
+        def set(self, **settings: Unpack[t.SizeAxisSettings]) -> Self:  # type: ignore[override]
+            """Set settings; ``None`` goes back to the inherited or default value."""
+
+
+class FigureLegendMixin(Legend):
+    """The typed API of ``FigureLegend``."""
+
+    if TYPE_CHECKING:
+        def set(self, **settings: Unpack[t.FigureLegendSettings]) -> Self:  # type: ignore[override]
+            """Set settings; ``None`` goes back to the inherited or default value."""
+
+
+class PlotMixin(Settings):
+    """The typed API of ``Plot``."""
+
+    def scatter(self, x: Any, y: Any, *, data: Any = None, group: Any = None,
+                group_order: Any = None, group_missing: Any = None, group_colors: Any = None,
+                **settings: Unpack[t.ScatterCallSettings]) -> Scatter:
+        """Markers at points ``(x, y)``."""
+        return _plot_layer(self, "scatter", (x, y), 2, {"data": data, "group": group,
+                                                        "group_order": group_order,
+                                                        "group_missing": group_missing,
+                                                        "group_colors": group_colors}, settings)
+
+    def line(self, x: Any, y: Any = None, *, data: Any = None, group: Any = None,
+             group_order: Any = None, group_missing: Any = None, group_colors: Any = None,
+             **settings: Unpack[t.LineCallSettings]) -> Line:
+        """A line through ``(x, y)``; ``y`` may hold several columns (one line each, sharing
+        ``x``: a 2-D buffer's columns, a data frame, a list of arrays), and ``x`` may be
+        omitted (``0, 1, 2, …``). ``orientation="horizontal"`` draws ``x`` on the y axis (a
+        profile along y). Numbers per point (or ``"density"``) in
+        ``marker_color``/``marker_edge_color`` map through the series' color axis.
+        """
+        return _plot_layer(self, "line", (x, y), 1, {"data": data, "group": group,
+                                                     "group_order": group_order,
+                                                     "group_missing": group_missing,
+                                                     "group_colors": group_colors}, settings)
+
+    def fill(self, x: Any, y1: Any, y2: Any = 0.0, *, data: Any = None, group: Any = None,
+             group_order: Any = None, group_missing: Any = None, group_colors: Any = None,
+             **settings: Unpack[t.FillCallSettings]) -> Fill:
+        """The area between ``y1`` and ``y2`` (a sequence or a constant) along ``x``;
+        ``orientation="horizontal"`` fills between x curves along y (``fill(y, x1, x2)``).
+        """
+        return _plot_layer(self, "fill", (x, y1, y2), 2, {"data": data, "group": group,
+                                                          "group_order": group_order,
+                                                          "group_missing": group_missing,
+                                                          "group_colors": group_colors}, settings)
+
+    def box(self, values: Any, positions: Any = None, *, data: Any = None, group: Any = None,
+            group_order: Any = None, group_missing: Any = None, group_colors: Any = None,
+            **settings: Unpack[t.BoxCallSettings]) -> Box:
+        """Box plots of ``values``: a dict ``{category: values}``, a list of arrays (categories
+        ``0, 1, …`` or ``categories=``), or one array.
+        """
+        return _plot_layer(self, "box", (values, positions), 1, {"data": data, "group": group,
+                                                                 "group_order": group_order,
+                                                                 "group_missing": group_missing,
+                                                                 "group_colors": group_colors}, settings)
+
+    def heatmap(self, values: Any, x: Any = None, y: Any = None, *, data: Any = None,
+                group: Any = None, group_order: Any = None, group_missing: Any = None,
+                group_colors: Any = None, **settings: Unpack[t.HeatmapCallSettings]) -> Heatmap:
+        """A grid of values (rows first) as colored cells; ``x``/``y`` give cell labels,
+        centres or edges.
+        """
+        return _plot_layer(self, "heatmap", (values, x, y), 1, {"data": data, "group": group,
+                                                                "group_order": group_order,
+                                                                "group_missing": group_missing,
+                                                                "group_colors": group_colors}, settings)
+
+    def bar(self, x: Any, y: Any = None, *, data: Any = None, group: Any = None,
+            group_order: Any = None, group_missing: Any = None, group_colors: Any = None,
+            **settings: Unpack[t.BarCallSettings]) -> Bar:
+        """Bars of height ``y`` at ``x`` (categories or numbers), or of a dict ``{category:
+        height}``, or of heights alone (at 0, 1, …).
+        """
+        return _plot_layer(self, "bar", (x, y), 1, {"data": data, "group": group,
+                                                    "group_order": group_order,
+                                                    "group_missing": group_missing,
+                                                    "group_colors": group_colors}, settings)
+
+    def hist(self, values: Any, *, data: Any = None, group: Any = None, group_order: Any = None,
+             group_missing: Any = None, group_colors: Any = None,
+             **settings: Unpack[t.HistCallSettings]) -> Hist:
+        """A histogram of ``values``: one array, or several (a dict or a list of arrays) that
+        share the same bins.
+        """
+        return _plot_layer(self, "hist", (values,), 1, {"data": data, "group": group,
+                                                        "group_order": group_order,
+                                                        "group_missing": group_missing,
+                                                        "group_colors": group_colors}, settings)
+
+    def kde(self, values: Any, y: Any = None, *, data: Any = None, group: Any = None,
+            group_order: Any = None, group_missing: Any = None, group_colors: Any = None,
+            **settings: Unpack[t.KdeCallSettings]) -> Kde:
+        """A Gaussian kernel density estimate of ``values`` (one array, or several as a dict or
+        a list of arrays, on a common grid).
+        """
+        return _plot_layer(self, "kde", (values, y), 1, {"data": data, "group": group,
+                                                         "group_order": group_order,
+                                                         "group_missing": group_missing,
+                                                         "group_colors": group_colors}, settings)
+
+    def ecdf(self, values: Any, *, data: Any = None, group: Any = None, group_order: Any = None,
+             group_missing: Any = None, group_colors: Any = None,
+             **settings: Unpack[t.EcdfCallSettings]) -> Ecdf:
+        """The empirical cumulative distribution of ``values`` (one array, or several as a dict
+        or a list of arrays).
+        """
+        return _plot_layer(self, "ecdf", (values,), 1, {"data": data, "group": group,
+                                                        "group_order": group_order,
+                                                        "group_missing": group_missing,
+                                                        "group_colors": group_colors}, settings)
+
+    def violin(self, values: Any, positions: Any = None, *, data: Any = None, group: Any = None,
+               group_order: Any = None, group_missing: Any = None, group_colors: Any = None,
+               **settings: Unpack[t.ViolinCallSettings]) -> Violin:
+        """Violins of ``values``: a dict ``{category: values}``, a list of arrays (categories
+        ``0, 1, …`` or ``categories=``), or one array.
+        """
+        return _plot_layer(self, "violin", (values, positions), 1, {"data": data,
+                                                                    "group": group,
+                                                                    "group_order": group_order,
+                                                                    "group_missing": group_missing,
+                                                                    "group_colors": group_colors}, settings)
+
+    def strip(self, values: Any, positions: Any = None, *, data: Any = None, group: Any = None,
+              group_order: Any = None, group_missing: Any = None, group_colors: Any = None,
+              **settings: Unpack[t.StripCallSettings]) -> Strip:
+        """Points of each category's values, spread across the slot by random jitter (from a
+        fixed seed, so output is reproducible).
+        """
+        return _plot_layer(self, "strip", (values, positions), 1, {"data": data, "group": group,
+                                                                   "group_order": group_order,
+                                                                   "group_missing": group_missing,
+                                                                   "group_colors": group_colors}, settings)
+
+    def swarm(self, values: Any, positions: Any = None, *, data: Any = None, group: Any = None,
+              group_order: Any = None, group_missing: Any = None, group_colors: Any = None,
+              **settings: Unpack[t.SwarmCallSettings]) -> Swarm:
+        """Points of each category's values, side by side so that they do not overlap (points
+        that do not fit go to the slot's edge, with a warning; above 100,000 points,
+        jittered across the width as a strip, with a warning).
+        """
+        return _plot_layer(self, "swarm", (values, positions), 1, {"data": data, "group": group,
+                                                                   "group_order": group_order,
+                                                                   "group_missing": group_missing,
+                                                                   "group_colors": group_colors}, settings)
+
+    def area(self, x: Any, y: Any, *, data: Any = None, group: Any = None,
+             group_order: Any = None, group_missing: Any = None, group_colors: Any = None,
+             **settings: Unpack[t.AreaCallSettings]) -> Area:
+        """Areas of the layers ``y`` (one column, or several: a dict ``{name: values}``, a data
+        frame, a 2-D buffer's columns, a list of arrays) along ``x``, stacked on
+        ``baseline``; ``orientation="horizontal"`` runs them along y.
+        """
+        return _plot_layer(self, "area", (x, y), 2, {"data": data, "group": group,
+                                                     "group_order": group_order,
+                                                     "group_missing": group_missing,
+                                                     "group_colors": group_colors}, settings)
+
+    def errorbar(self, x: Any, y: Any, *, data: Any = None, group: Any = None,
+                 group_order: Any = None, group_missing: Any = None, group_colors: Any = None,
+                 **settings: Unpack[t.ErrorbarCallSettings]) -> Errorbar:
+        """Error bars at ``(x, y)``: ``y_error``/``x_error`` as a value, a sequence, ``(low,
+        high)`` or ``Errors``; ``marker`` adds markers at the points (numbers per point in
+        ``marker_color`` map through the series' color axis).
+        """
+        return _plot_layer(self, "errorbar", (x, y), 2, {"data": data, "group": group,
+                                                         "group_order": group_order,
+                                                         "group_missing": group_missing,
+                                                         "group_colors": group_colors}, settings)
+
+    def stem(self, x: Any, y: Any = None, *, data: Any = None, group: Any = None,
+             group_order: Any = None, group_missing: Any = None, group_colors: Any = None,
+             **settings: Unpack[t.StemCallSettings]) -> Stem:
+        """Stems from ``baseline`` to ``y`` at ``x`` (or at 0, 1, … when ``y`` is omitted);
+        numbers per point in ``marker_color`` map through the series' color axis.
+        """
+        return _plot_layer(self, "stem", (x, y), 1, {"data": data, "group": group,
+                                                     "group_order": group_order,
+                                                     "group_missing": group_missing,
+                                                     "group_colors": group_colors}, settings)
+
+    def regression(self, x: Any, y: Any, *, data: Any = None, group: Any = None,
+                   group_order: Any = None, group_missing: Any = None, group_colors: Any = None,
+                   **settings: Unpack[t.RegressionCallSettings]) -> Regression:
+        """A regression of ``y`` on ``x``: a polynomial of ``order`` (least squares) with a
+        confidence band of the mean, or a LOWESS curve; ``scatter`` also draws the points
+        (numbers per point in ``marker_color`` map through the series' color axis).
+        """
+        return _plot_layer(self, "regression", (x, y), 2, {"data": data, "group": group,
+                                                           "group_order": group_order,
+                                                           "group_missing": group_missing,
+                                                           "group_colors": group_colors}, settings)
+
+    def hist2d(self, x: Any, y: Any, *, data: Any = None, group: Any = None,
+               group_order: Any = None, group_missing: Any = None, group_colors: Any = None,
+               **settings: Unpack[t.Hist2dCallSettings]) -> Hist2d:
+        """A 2-D histogram of points ``(x, y)``: counts in bins (even on the axis scales),
+        drawn as a heatmap; bins with fewer than ``min_count`` points are left empty.
+        """
+        return _plot_layer(self, "hist2d", (x, y), 2, {"data": data, "group": group,
+                                                       "group_order": group_order,
+                                                       "group_missing": group_missing,
+                                                       "group_colors": group_colors}, settings)
+
+    def hexbin(self, x: Any, y: Any, *, data: Any = None, group: Any = None,
+               group_order: Any = None, group_missing: Any = None, group_colors: Any = None,
+               **settings: Unpack[t.HexbinCallSettings]) -> Hexbin:
+        """A hexagonal 2-D histogram of points ``(x, y)``: ``bins`` regular hexagons across the
+        axes width. The lattice is laid out in page units for the axes the layout placed
+        (its domain is the data's, its bins the axes'), so the hexagons are regular and tile
+        exactly whatever the axes' aspect.
+        """
+        return _plot_layer(self, "hexbin", (x, y), 2, {"data": data, "group": group,
+                                                       "group_order": group_order,
+                                                       "group_missing": group_missing,
+                                                       "group_colors": group_colors}, settings)
+
+    def contour(self, values: Any, x: Any = None, y: Any = None, *, data: Any = None,
+                group: Any = None, group_order: Any = None, group_missing: Any = None,
+                group_colors: Any = None, **settings: Unpack[t.ContourCallSettings]) -> Contour:
+        """Contour lines and/or filled bands of ``values`` (rows first) at nodes ``x``/``y``
+        (centres; edges are reduced to their midpoints).
+        """
+        return _plot_layer(self, "contour", (values, x, y), 1, {"data": data, "group": group,
+                                                                "group_order": group_order,
+                                                                "group_missing": group_missing,
+                                                                "group_colors": group_colors}, settings)
+
+    def pie(self, values: Any, *, data: Any = None, group: Any = None, group_order: Any = None,
+            group_missing: Any = None, group_colors: Any = None,
+            **settings: Unpack[t.PieCallSettings]) -> Pie:
+        """A pie (or donut, with ``hole``) of ``values``: a sequence, or a dict ``{label:
+        value}``; the plot is drawn without axes.
+        """
+        return _plot_layer(self, "pie", (values,), 1, {"data": data, "group": group,
+                                                       "group_order": group_order,
+                                                       "group_missing": group_missing,
+                                                       "group_colors": group_colors}, settings)
+
+    def dots(self, color: Any = None, size: Any = None, x: Any = None, y: Any = None, *,
+             data: Any = None, group: Any = None, group_order: Any = None,
+             group_missing: Any = None, group_colors: Any = None,
+             **settings: Unpack[t.DotsCallSettings]) -> Dots:
+        """One marker per cell of a grid: ``color`` and ``size`` are grids of values (row 0
+        first) of one shape, or one value; ``x``/``y`` label the columns and rows, as
+        ``heatmap``'s. With long data (``x``, ``y`` and values per cell), the cells come
+        from the rows; cells without a row get no dot.
+        """
+        return _plot_layer(self, "dots", (color, size, x, y), 0, {"data": data, "group": group,
+                                                                  "group_order": group_order,
+                                                                  "group_missing": group_missing,
+                                                                  "group_colors": group_colors}, settings)
+
+    def bigwig(self, reader: Any = None, *, x: Any = None, y: Any = None,
+               **settings: Unpack[t.BigWigSettings]) -> BigWig:
+        """A binned signal over the region: a step line along the bins, filled to a baseline.
+        ``reader`` is a signal reader (bigWig; bigBed, BED and peaks give their coverage;
+        :func:`~plot_io.genome.combine.combine` of two), a path (opened with gwseq_io),
+        ``chr``, ``start``, ``end``, ``value`` records (columns, a DataFrame or rows; binned
+        by plot_io), a function ``f(chr, start, end, bins)`` giving values, or ``None`` with
+        ``y`` (values over the region) and optionally ``x`` (bin centres, or n + 1 edges, in
+        bp).
+        """
+        return _plot_layer(self, "bigwig", (reader,), 0, {"x": x, "y": y}, settings)
+
+    def bed(self, reader: Any, **settings: Unpack[t.BedSettings]) -> Bed:
+        """Intervals over the region: boxes or gene models, on one row or packed onto rows.
+        ``reader`` is an interval reader (bigBed, BED, peaks), a path (opened with gwseq_io)
+        or plain data: a dict of columns, a DataFrame, or rows (``start``, ``end`` and
+        optionally ``name``, ``score``, ``strand``, ``thickStart``, ``thickEnd``,
+        ``itemRgb``, ``blockCount``, ``blockSizes``, ``blockStarts``).
+        """
+        return _plot_layer(self, "bed", (reader,), 1, {}, settings)
+
+    def genes(self, reader: Any, **settings: Unpack[t.GenesSettings]) -> Genes:
+        """Gene models (BED12): ``Bed`` with ``kind="genes"``, rows expanded and names on."""
+        return _plot_layer(self, "genes", (reader,), 1, {}, settings)
+
+    def gtf(self, reader: Any, **settings: Unpack[t.GtfSettings]) -> Gtf:
+        """Gene models of a GTF or GFF3 reader (``read_entries(model=)``) or path: ``Genes``,
+        one model per gene (its transcripts' exons merged) or per transcript, or plain BED12
+        data as ``Genes`` takes it.
+        """
+        return _plot_layer(self, "gtf", (reader,), 1, {}, settings)
+
+    def hic(self, reader: Any, **settings: Unpack[t.HiCSettings]) -> HiC:
+        """The upper triangle of a contact matrix, the diagonal along the x axis (each cell a
+        diamond), or with ``shape="square"`` the whole matrix of ``region`` (x) against
+        ``region2`` (y, its start at the top). ``reader`` is a Hi-C reader, a path (opened
+        with gwseq_io), or a square matrix over the region (bins of ``span / n``).
+        """
+        return _plot_layer(self, "hic", (reader,), 1, {}, settings)
+
+    def links(self, pairs: Any, **settings: Unpack[t.LinksSettings]) -> Links:
+        """Links between pairs of places (BEDPE): an arc from anchor centre to anchor centre in
+        a lane of its own, or, ``lane="over"`` a Hi-C triangle or square, a mark at each
+        pair's contact cell (on a square, and at its mirror). ``pairs`` is a reader whose
+        ``read_entries`` gives the BEDPE columns, a path gwseq_io reads them from, or plain
+        data (the pairs with an anchor in view are read): a dict of columns, a DataFrame, or
+        rows in BEDPE order (``chr1``, ``start1``, ``end1``, ``chr2``, ``start2``, ``end2``,
+        then optionally ``name``, ``score``).
+        """
+        return _plot_layer(self, "links", (pairs,), 1, {}, settings)
+
+    def site_heatmap(self, signal: Any, sites: Any, *, group: Any = None,
+                     **settings: Unpack[t.SiteHeatmapSettings]) -> SiteHeatmap:
+        """A signal around sites, one row per site (a table with ``chr``, ``start``, ``end``
+        and optional ``strand``, ``summit`` columns, or an interval reader), x the distance
+        from the anchor in bp; ``group`` (a column of the sites, or a label per site) makes
+        a block of rows per group.
+        """
+        return _plot_layer(self, "site_heatmap", (signal, sites), 2, {"group": group}, settings)
+
+    def site_profile(self, signal: Any, sites: Any, *, group: Any = None,
+                     **settings: Unpack[t.SiteProfileSettings]) -> SiteProfile:
+        """The column mean (or median) of a signal around sites (see :class:`SiteHeatmap`): one
+        line per group, x the distance from the anchor in bp, an optional band.
+        """
+        return _plot_layer(self, "site_profile", (signal, sites), 2, {"group": group}, settings)
+
+    def dendrogram(self, tree: Any, labels: Any = None,
+                   **settings: Unpack[t.DendrogramSettings]) -> Dendrogram:
+        """The merges of ``tree`` (a :class:`Tree`, or a scipy ``Z``) as U-shaped links: the
+        leaves at slots 0, 1, … in ``tree.leaves`` order on the leaf axis, the heights on
+        the value axis, the root at the top (``orientation="horizontal"``: at the left,
+        heights along x, the x axis inverted unless set). ``labels`` (default: the tree's)
+        make the leaf axis categorical, in leaf order, so a heatmap with the same categories
+        shares it; without labels each leaf is ticked with its observation's index. Every
+        leaf is labelled: turned 90° when the labels do not fit flat, then smaller, down to
+        the axis' ``label_min_size`` (6 pt), and every k-th only below it.
+        """
+        return _plot_layer(self, "dendrogram", (tree, labels), 1, {}, settings)
+
+    def qq(self, values: Any, y: Any = None, **settings: Unpack[t.QQSettings]) -> QQ:
+        """The sorted ``values`` against the quantiles of ``dist`` at R's ``ppoints`` (``(i −
+        a) / (n + 1 − 2a)``, a = 3/8 for n ≤ 10, else 1/2), or against the sorted ``y`` (two
+        samples: the longer interpolated to the shorter's size, as R's ``qqplot``;
+        ``values`` on x). ``pvalues=True``: ``values`` are p-values, drawn as −log10 of the
+        sorted p-values (y) against −log10 of the expected uniform quantiles (x). Points as
+        `Scatter`'s; the reference ``line`` and the pointwise ``band`` of order statistics
+        in the series color. The points and the default line are R's (``qqnorm``,
+        ``qqline``), not scipy's ``probplot`` (Filliben's medians, a least-squares line).
+        """
+        return _plot_layer(self, "qq", (values, y), 1, {}, settings)
+
+    def raincloud(self, values: Any, positions: Any = None,
+                  **settings: Unpack[t.RaincloudSettings]) -> Raincloud:
+        """Rainclouds of ``values`` (a dict ``{category: values}``, a list of arrays, or one
+        array; long data with ``x=`` categories): per category a half violin on the high
+        side (stat ``violin``), a narrow box at the centre (stat ``box``) and the values as
+        jittered points on the low side. ``parts`` keeps some of the three. Widths and
+        offsets are `%` of the slot.
+        """
+        return _plot_layer(self, "raincloud", (values, positions), 1, {}, settings)
+
+    def volcano(self, fold_change: Any, p: Any,
+                **settings: Unpack[t.VolcanoSettings]) -> Volcano:
+        """Differential results: log2 ``fold_change`` (x) against −log10 ``p`` (y; p = 0 at the
+        smallest positive p, NaN left out). Points are ``up``, ``down`` or ``n.s.``: up or
+        down when ``p < p_threshold`` and |fold change| ≥ ``fold_change_threshold``,
+        coloured by ``colors`` as a level axis on ``color`` (the legend counts them), dashed
+        rules at the thresholds. ``labels`` gives a text per point, ``label`` which are
+        drawn (placed as Scatter's). The classification settings are read at the call.
+        """
+        return _plot_layer(self, "volcano", (fold_change, p), 2, {}, settings)
+
+    def ma(self, mean: Any, fold_change: Any, p: Any = None,
+           **settings: Unpack[t.MaSettings]) -> Ma:
+        """An MA plot: mean expression ``mean`` (x, on a log10 axis unless the axis has a
+        scale) against log2 ``fold_change`` (y), a rule at 0 and dashed ones at ±
+        ``fold_change_threshold``. Classes, colors and labels as `Volcano`'s (by fold change
+        alone without ``p``; ``label="top"``: the largest |fold change| among the
+        significant).
+        """
+        return _plot_layer(self, "ma", (mean, fold_change, p), 2, {}, settings)
+
+    def manhattan(self, chromosomes: Any, positions: Any, p: Any,
+                  **settings: Unpack[t.ManhattanSettings]) -> Manhattan:
+        """Genome-wide association results: −log10 ``p`` (y) at ``positions`` (bp) of
+        ``chromosomes`` laid end to end (x) in natural order (chr1 … chr22, X, Y, M), each
+        ``chr_sizes`` long (unset: to its last position), its points in the next of the two
+        ``colors``, its name as the tick at its middle (left to right, a name that would
+        overlap the last one shown is left out), the x axis from the first chromosome's
+        start to the last one's end; a dashed rule at ``threshold`` (genome-wide
+        significance). ``labels``/``label``/``label_count`` as `Volcano`'s (``top``: the
+        most significant beyond ``threshold``).
+        """
+        return _plot_layer(self, "manhattan", (chromosomes, positions, p), 3, {}, settings)
+
+
+class TitleMixin(TitleBase):
+    """The typed API of ``Title``."""
+
+    if TYPE_CHECKING:
+        def set(self, **settings: Unpack[t.TitleSettings]) -> Self:  # type: ignore[override]
+            """Set settings; ``None`` goes back to the inherited or default value."""
+
+
+class AreaMixin(Series):
+    """The typed API of ``Area``."""
+
+    if TYPE_CHECKING:
+        def set(self, **settings: Unpack[t.AreaSettings]) -> Self:  # type: ignore[override]
+            """Set settings; ``None`` goes back to the inherited or default value."""
+
+
+class BarMixin(Summarized):
+    """The typed API of ``Bar``."""
+
+    if TYPE_CHECKING:
+        def set(self, **settings: Unpack[t.BarSettings]) -> Self:  # type: ignore[override]
+            """Set settings; ``None`` goes back to the inherited or default value."""
+
+
+class BoxMixin(Series):
+    """The typed API of ``Box``."""
+
+    if TYPE_CHECKING:
+        def set(self, **settings: Unpack[t.BoxSettings]) -> Self:  # type: ignore[override]
+            """Set settings; ``None`` goes back to the inherited or default value."""
+
+
+class StripMixin(_CatPoints):
+    """The typed API of ``Strip``."""
+
+    if TYPE_CHECKING:
+        def set(self, **settings: Unpack[t.StripSettings]) -> Self:  # type: ignore[override]
+            """Set settings; ``None`` goes back to the inherited or default value."""
+
+
+class SwarmMixin(_CatPoints):
+    """The typed API of ``Swarm``."""
+
+    if TYPE_CHECKING:
+        def set(self, **settings: Unpack[t.SwarmSettings]) -> Self:  # type: ignore[override]
+            """Set settings; ``None`` goes back to the inherited or default value."""
+
+
+class ContourMixin(Series):
+    """The typed API of ``Contour``."""
+
+    if TYPE_CHECKING:
+        def set(self, **settings: Unpack[t.ContourSettings]) -> Self:  # type: ignore[override]
+            """Set settings; ``None`` goes back to the inherited or default value."""
+
+
+class EcdfMixin(Series):
+    """The typed API of ``Ecdf``."""
+
+    if TYPE_CHECKING:
+        def set(self, **settings: Unpack[t.EcdfSettings]) -> Self:  # type: ignore[override]
+            """Set settings; ``None`` goes back to the inherited or default value."""
+
+
+class ErrorbarMixin(Summarized):
+    """The typed API of ``Errorbar``."""
+
+    if TYPE_CHECKING:
+        def set(self, **settings: Unpack[t.ErrorbarSettings]) -> Self:  # type: ignore[override]
+            """Set settings; ``None`` goes back to the inherited or default value."""
+
+
+class FillMixin(Series):
+    """The typed API of ``Fill``."""
+
+    if TYPE_CHECKING:
+        def set(self, **settings: Unpack[t.FillSettings]) -> Self:  # type: ignore[override]
+            """Set settings; ``None`` goes back to the inherited or default value."""
+
+
+class HeatmapMixin(Series):
+    """The typed API of ``Heatmap``."""
+
+    if TYPE_CHECKING:
+        def set(self, **settings: Unpack[t.HeatmapSettings]) -> Self:  # type: ignore[override]
+            """Set settings; ``None`` goes back to the inherited or default value."""
+
+
+class HexbinMixin(Series):
+    """The typed API of ``Hexbin``."""
+
+    if TYPE_CHECKING:
+        def set(self, **settings: Unpack[t.HexbinSettings]) -> Self:  # type: ignore[override]
+            """Set settings; ``None`` goes back to the inherited or default value."""
+
+
+class HistMixin(Series):
+    """The typed API of ``Hist``."""
+
+    if TYPE_CHECKING:
+        def set(self, **settings: Unpack[t.HistSettings]) -> Self:  # type: ignore[override]
+            """Set settings; ``None`` goes back to the inherited or default value."""
+
+
+class Hist2dMixin(Heatmap):
+    """The typed API of ``Hist2d``."""
+
+    if TYPE_CHECKING:
+        def set(self, **settings: Unpack[t.Hist2dSettings]) -> Self:  # type: ignore[override]
+            """Set settings; ``None`` goes back to the inherited or default value."""
+
+
+class KdeMixin(Series):
+    """The typed API of ``Kde``."""
+
+    if TYPE_CHECKING:
+        def set(self, **settings: Unpack[t.KdeSettings]) -> Self:  # type: ignore[override]
+            """Set settings; ``None`` goes back to the inherited or default value."""
+
+
+class Kde2dMixin(Contour):
+    """The typed API of ``Kde2d``."""
+
+    if TYPE_CHECKING:
+        def set(self, **settings: Unpack[t.Kde2dSettings]) -> Self:  # type: ignore[override]
+            """Set settings; ``None`` goes back to the inherited or default value."""
+
+
+class PieMixin(Series):
+    """The typed API of ``Pie``."""
+
+    if TYPE_CHECKING:
+        def set(self, **settings: Unpack[t.PieSettings]) -> Self:  # type: ignore[override]
+            """Set settings; ``None`` goes back to the inherited or default value."""
+
+
+class RegressionMixin(Series):
+    """The typed API of ``Regression``."""
+
+    if TYPE_CHECKING:
+        def set(self, **settings: Unpack[t.RegressionSettings]) -> Self:  # type: ignore[override]
+            """Set settings; ``None`` goes back to the inherited or default value."""
+
+
+class ScatterMixin(Summarized):
+    """The typed API of ``Scatter``."""
+
+    if TYPE_CHECKING:
+        def set(self, **settings: Unpack[t.ScatterSettings]) -> Self:  # type: ignore[override]
+            """Set settings; ``None`` goes back to the inherited or default value."""
+
+
+class StemMixin(Summarized):
+    """The typed API of ``Stem``."""
+
+    if TYPE_CHECKING:
+        def set(self, **settings: Unpack[t.StemSettings]) -> Self:  # type: ignore[override]
+            """Set settings; ``None`` goes back to the inherited or default value."""
+
+
+class ViolinMixin(Series):
+    """The typed API of ``Violin``."""
+
+    if TYPE_CHECKING:
+        def set(self, **settings: Unpack[t.ViolinSettings]) -> Self:  # type: ignore[override]
+            """Set settings; ``None`` goes back to the inherited or default value."""
+
+
+class FigureGroupMixin(Settings):
+    """The typed API of ``FigureGroup``."""
+
+    if TYPE_CHECKING:
+        def set(self, **settings: Unpack[t.FigureGroupSettings]) -> Self:  # type: ignore[override]
+            """Set settings; ``None`` goes back to the inherited or default value."""
+
+
+class FigureVLineMixin(Settings):
+    """The typed API of ``FigureVLine``."""
+
+    if TYPE_CHECKING:
+        def set(self, **settings: Unpack[t.FigureVLineSettings]) -> Self:  # type: ignore[override]
+            """Set settings; ``None`` goes back to the inherited or default value."""
+
+
+class FigureVSpanMixin(Settings):
+    """The typed API of ``FigureVSpan``."""
+
+    if TYPE_CHECKING:
+        def set(self, **settings: Unpack[t.FigureVSpanSettings]) -> Self:  # type: ignore[override]
+            """Set settings; ``None`` goes back to the inherited or default value."""
+
+
+class PanelSetMixin(object):
+    """The typed API of ``PanelSet``."""
+
+    def scatter(self, x: Any, y: Any, *, group: Any = None, group_order: Any = None,
+                group_missing: Any = None, group_colors: Any = None,
+                **settings: Unpack[t.ScatterCallSettings]) -> LayerSet:
+        """One per panel: Markers at points ``(x, y)``."""
+        return _panelset_layer(self, "scatter", (x, y), 2, {"group": group,
+                                                            "group_order": group_order,
+                                                            "group_missing": group_missing,
+                                                            "group_colors": group_colors}, settings)
+
+    def line(self, x: Any, y: Any = None, *, group: Any = None, group_order: Any = None,
+             group_missing: Any = None, group_colors: Any = None,
+             **settings: Unpack[t.LineCallSettings]) -> LayerSet:
+        """One per panel: A line through ``(x, y)``; ``y`` may hold several columns (one line
+        each, sharing ``x``: a 2-D buffer's columns, a data frame, a list of arrays), and
+        ``x`` may be omitted (``0, 1, 2, …``). ``orientation="horizontal"`` draws ``x`` on
+        the y axis (a profile along y). Numbers per point (or ``"density"``) in
+        ``marker_color``/``marker_edge_color`` map through the series' color axis.
+        """
+        return _panelset_layer(self, "line", (x, y), 1, {"group": group,
+                                                         "group_order": group_order,
+                                                         "group_missing": group_missing,
+                                                         "group_colors": group_colors}, settings)
+
+    def fill(self, x: Any, y1: Any, y2: Any = 0.0, *, group: Any = None,
+             group_order: Any = None, group_missing: Any = None, group_colors: Any = None,
+             **settings: Unpack[t.FillCallSettings]) -> LayerSet:
+        """One per panel: The area between ``y1`` and ``y2`` (a sequence or a constant) along
+        ``x``; ``orientation="horizontal"`` fills between x curves along y (``fill(y, x1,
+        x2)``).
+        """
+        return _panelset_layer(self, "fill", (x, y1, y2), 2, {"group": group,
+                                                              "group_order": group_order,
+                                                              "group_missing": group_missing,
+                                                              "group_colors": group_colors}, settings)
+
+    def box(self, values: Any, positions: Any = None, *, group: Any = None,
+            group_order: Any = None, group_missing: Any = None, group_colors: Any = None,
+            **settings: Unpack[t.BoxCallSettings]) -> LayerSet:
+        """One per panel: Box plots of ``values``: a dict ``{category: values}``, a list of
+        arrays (categories ``0, 1, …`` or ``categories=``), or one array.
+        """
+        return _panelset_layer(self, "box", (values, positions), 1, {"group": group,
+                                                                     "group_order": group_order,
+                                                                     "group_missing": group_missing,
+                                                                     "group_colors": group_colors}, settings)
+
+    def heatmap(self, values: Any, x: Any = None, y: Any = None, *, group: Any = None,
+                group_order: Any = None, group_missing: Any = None, group_colors: Any = None,
+                **settings: Unpack[t.HeatmapCallSettings]) -> LayerSet:
+        """One per panel: A grid of values (rows first) as colored cells; ``x``/``y`` give cell
+        labels, centres or edges.
+        """
+        return _panelset_layer(self, "heatmap", (values, x, y), 1, {"group": group,
+                                                                    "group_order": group_order,
+                                                                    "group_missing": group_missing,
+                                                                    "group_colors": group_colors}, settings)
+
+    def bar(self, x: Any, y: Any = None, *, group: Any = None, group_order: Any = None,
+            group_missing: Any = None, group_colors: Any = None,
+            **settings: Unpack[t.BarCallSettings]) -> LayerSet:
+        """One per panel: Bars of height ``y`` at ``x`` (categories or numbers), or of a dict
+        ``{category: height}``, or of heights alone (at 0, 1, …).
+        """
+        return _panelset_layer(self, "bar", (x, y), 1, {"group": group,
+                                                        "group_order": group_order,
+                                                        "group_missing": group_missing,
+                                                        "group_colors": group_colors}, settings)
+
+    def hist(self, values: Any, *, group: Any = None, group_order: Any = None,
+             group_missing: Any = None, group_colors: Any = None,
+             **settings: Unpack[t.HistCallSettings]) -> LayerSet:
+        """One per panel: A histogram of ``values``: one array, or several (a dict or a list of
+        arrays) that share the same bins.
+        """
+        return _panelset_layer(self, "hist", (values,), 1, {"group": group,
+                                                            "group_order": group_order,
+                                                            "group_missing": group_missing,
+                                                            "group_colors": group_colors}, settings)
+
+    def kde(self, values: Any, y: Any = None, *, group: Any = None, group_order: Any = None,
+            group_missing: Any = None, group_colors: Any = None,
+            **settings: Unpack[t.KdeCallSettings]) -> LayerSet:
+        """One per panel: A Gaussian kernel density estimate of ``values`` (one array, or
+        several as a dict or a list of arrays, on a common grid).
+        """
+        return _panelset_layer(self, "kde", (values, y), 1, {"group": group,
+                                                             "group_order": group_order,
+                                                             "group_missing": group_missing,
+                                                             "group_colors": group_colors}, settings)
+
+    def ecdf(self, values: Any, *, group: Any = None, group_order: Any = None,
+             group_missing: Any = None, group_colors: Any = None,
+             **settings: Unpack[t.EcdfCallSettings]) -> LayerSet:
+        """One per panel: The empirical cumulative distribution of ``values`` (one array, or
+        several as a dict or a list of arrays).
+        """
+        return _panelset_layer(self, "ecdf", (values,), 1, {"group": group,
+                                                            "group_order": group_order,
+                                                            "group_missing": group_missing,
+                                                            "group_colors": group_colors}, settings)
+
+    def violin(self, values: Any, positions: Any = None, *, group: Any = None,
+               group_order: Any = None, group_missing: Any = None, group_colors: Any = None,
+               **settings: Unpack[t.ViolinCallSettings]) -> LayerSet:
+        """One per panel: Violins of ``values``: a dict ``{category: values}``, a list of
+        arrays (categories ``0, 1, …`` or ``categories=``), or one array.
+        """
+        return _panelset_layer(self, "violin", (values, positions), 1, {"group": group,
+                                                                        "group_order": group_order,
+                                                                        "group_missing": group_missing,
+                                                                        "group_colors": group_colors}, settings)
+
+    def strip(self, values: Any, positions: Any = None, *, group: Any = None,
+              group_order: Any = None, group_missing: Any = None, group_colors: Any = None,
+              **settings: Unpack[t.StripCallSettings]) -> LayerSet:
+        """One per panel: Points of each category's values, spread across the slot by random
+        jitter (from a fixed seed, so output is reproducible).
+        """
+        return _panelset_layer(self, "strip", (values, positions), 1, {"group": group,
+                                                                       "group_order": group_order,
+                                                                       "group_missing": group_missing,
+                                                                       "group_colors": group_colors}, settings)
+
+    def swarm(self, values: Any, positions: Any = None, *, group: Any = None,
+              group_order: Any = None, group_missing: Any = None, group_colors: Any = None,
+              **settings: Unpack[t.SwarmCallSettings]) -> LayerSet:
+        """One per panel: Points of each category's values, side by side so that they do not
+        overlap (points that do not fit go to the slot's edge, with a warning; above 100,000
+        points, jittered across the width as a strip, with a warning).
+        """
+        return _panelset_layer(self, "swarm", (values, positions), 1, {"group": group,
+                                                                       "group_order": group_order,
+                                                                       "group_missing": group_missing,
+                                                                       "group_colors": group_colors}, settings)
+
+    def area(self, x: Any, y: Any, *, group: Any = None, group_order: Any = None,
+             group_missing: Any = None, group_colors: Any = None,
+             **settings: Unpack[t.AreaCallSettings]) -> LayerSet:
+        """One per panel: Areas of the layers ``y`` (one column, or several: a dict ``{name:
+        values}``, a data frame, a 2-D buffer's columns, a list of arrays) along ``x``,
+        stacked on ``baseline``; ``orientation="horizontal"`` runs them along y.
+        """
+        return _panelset_layer(self, "area", (x, y), 2, {"group": group,
+                                                         "group_order": group_order,
+                                                         "group_missing": group_missing,
+                                                         "group_colors": group_colors}, settings)
+
+    def errorbar(self, x: Any, y: Any, *, group: Any = None, group_order: Any = None,
+                 group_missing: Any = None, group_colors: Any = None,
+                 **settings: Unpack[t.ErrorbarCallSettings]) -> LayerSet:
+        """One per panel: Error bars at ``(x, y)``: ``y_error``/``x_error`` as a value, a
+        sequence, ``(low, high)`` or ``Errors``; ``marker`` adds markers at the points
+        (numbers per point in ``marker_color`` map through the series' color axis).
+        """
+        return _panelset_layer(self, "errorbar", (x, y), 2, {"group": group,
+                                                             "group_order": group_order,
+                                                             "group_missing": group_missing,
+                                                             "group_colors": group_colors}, settings)
+
+    def stem(self, x: Any, y: Any = None, *, group: Any = None, group_order: Any = None,
+             group_missing: Any = None, group_colors: Any = None,
+             **settings: Unpack[t.StemCallSettings]) -> LayerSet:
+        """One per panel: Stems from ``baseline`` to ``y`` at ``x`` (or at 0, 1, … when ``y``
+        is omitted); numbers per point in ``marker_color`` map through the series' color
+        axis.
+        """
+        return _panelset_layer(self, "stem", (x, y), 1, {"group": group,
+                                                         "group_order": group_order,
+                                                         "group_missing": group_missing,
+                                                         "group_colors": group_colors}, settings)
+
+    def regression(self, x: Any, y: Any, *, group: Any = None, group_order: Any = None,
+                   group_missing: Any = None, group_colors: Any = None,
+                   **settings: Unpack[t.RegressionCallSettings]) -> LayerSet:
+        """One per panel: A regression of ``y`` on ``x``: a polynomial of ``order`` (least
+        squares) with a confidence band of the mean, or a LOWESS curve; ``scatter`` also
+        draws the points (numbers per point in ``marker_color`` map through the series'
+        color axis).
+        """
+        return _panelset_layer(self, "regression", (x, y), 2, {"group": group,
+                                                               "group_order": group_order,
+                                                               "group_missing": group_missing,
+                                                               "group_colors": group_colors}, settings)
+
+    def hist2d(self, x: Any, y: Any, *, group: Any = None, group_order: Any = None,
+               group_missing: Any = None, group_colors: Any = None,
+               **settings: Unpack[t.Hist2dCallSettings]) -> LayerSet:
+        """One per panel: A 2-D histogram of points ``(x, y)``: counts in bins (even on the
+        axis scales), drawn as a heatmap; bins with fewer than ``min_count`` points are left
+        empty.
+        """
+        return _panelset_layer(self, "hist2d", (x, y), 2, {"group": group,
+                                                           "group_order": group_order,
+                                                           "group_missing": group_missing,
+                                                           "group_colors": group_colors}, settings)
+
+    def hexbin(self, x: Any, y: Any, *, group: Any = None, group_order: Any = None,
+               group_missing: Any = None, group_colors: Any = None,
+               **settings: Unpack[t.HexbinCallSettings]) -> LayerSet:
+        """One per panel: A hexagonal 2-D histogram of points ``(x, y)``: ``bins`` regular
+        hexagons across the axes width. The lattice is laid out in page units for the axes
+        the layout placed (its domain is the data's, its bins the axes'), so the hexagons
+        are regular and tile exactly whatever the axes' aspect.
+        """
+        return _panelset_layer(self, "hexbin", (x, y), 2, {"group": group,
+                                                           "group_order": group_order,
+                                                           "group_missing": group_missing,
+                                                           "group_colors": group_colors}, settings)
+
+    def contour(self, values: Any, x: Any = None, y: Any = None, *, group: Any = None,
+                group_order: Any = None, group_missing: Any = None, group_colors: Any = None,
+                **settings: Unpack[t.ContourCallSettings]) -> LayerSet:
+        """One per panel: Contour lines and/or filled bands of ``values`` (rows first) at nodes
+        ``x``/``y`` (centres; edges are reduced to their midpoints).
+        """
+        return _panelset_layer(self, "contour", (values, x, y), 1, {"group": group,
+                                                                    "group_order": group_order,
+                                                                    "group_missing": group_missing,
+                                                                    "group_colors": group_colors}, settings)
+
+    def pie(self, values: Any, *, group: Any = None, group_order: Any = None,
+            group_missing: Any = None, group_colors: Any = None,
+            **settings: Unpack[t.PieCallSettings]) -> LayerSet:
+        """One per panel: A pie (or donut, with ``hole``) of ``values``: a sequence, or a dict
+        ``{label: value}``; the plot is drawn without axes.
+        """
+        return _panelset_layer(self, "pie", (values,), 1, {"group": group,
+                                                           "group_order": group_order,
+                                                           "group_missing": group_missing,
+                                                           "group_colors": group_colors}, settings)
+
+    def dots(self, color: Any = None, size: Any = None, x: Any = None, y: Any = None, *,
+             group: Any = None, group_order: Any = None, group_missing: Any = None,
+             group_colors: Any = None, **settings: Unpack[t.DotsCallSettings]) -> LayerSet:
+        """One per panel: One marker per cell of a grid: ``color`` and ``size`` are grids of
+        values (row 0 first) of one shape, or one value; ``x``/``y`` label the columns and
+        rows, as ``heatmap``'s. With long data (``x``, ``y`` and values per cell), the cells
+        come from the rows; cells without a row get no dot.
+        """
+        return _panelset_layer(self, "dots", (color, size, x, y), 0, {"group": group,
+                                                                      "group_order": group_order,
+                                                                      "group_missing": group_missing,
+                                                                      "group_colors": group_colors}, settings)
+
+    def bigwig(self, reader: Any = None, *, x: Any = None, y: Any = None,
+               **settings: Unpack[t.BigWigSettings]) -> LayerSet:
+        """One per panel: A binned signal over the region: a step line along the bins, filled
+        to a baseline. ``reader`` is a signal reader (bigWig; bigBed, BED and peaks give
+        their coverage; :func:`~plot_io.genome.combine.combine` of two), a path (opened with
+        gwseq_io), ``chr``, ``start``, ``end``, ``value`` records (columns, a DataFrame or
+        rows; binned by plot_io), a function ``f(chr, start, end, bins)`` giving values, or
+        ``None`` with ``y`` (values over the region) and optionally ``x`` (bin centres, or n
+        + 1 edges, in bp).
+        """
+        return _panelset_layer(self, "bigwig", (reader,), 0, {"x": x, "y": y}, settings)
+
+    def bed(self, reader: Any, **settings: Unpack[t.BedSettings]) -> LayerSet:
+        """One per panel: Intervals over the region: boxes or gene models, on one row or packed
+        onto rows. ``reader`` is an interval reader (bigBed, BED, peaks), a path (opened
+        with gwseq_io) or plain data: a dict of columns, a DataFrame, or rows (``start``,
+        ``end`` and optionally ``name``, ``score``, ``strand``, ``thickStart``,
+        ``thickEnd``, ``itemRgb``, ``blockCount``, ``blockSizes``, ``blockStarts``).
+        """
+        return _panelset_layer(self, "bed", (reader,), 1, {}, settings)
+
+    def genes(self, reader: Any, **settings: Unpack[t.GenesSettings]) -> LayerSet:
+        """One per panel: Gene models (BED12): ``Bed`` with ``kind="genes"``, rows expanded and
+        names on.
+        """
+        return _panelset_layer(self, "genes", (reader,), 1, {}, settings)
+
+    def gtf(self, reader: Any, **settings: Unpack[t.GtfSettings]) -> LayerSet:
+        """One per panel: Gene models of a GTF or GFF3 reader (``read_entries(model=)``) or
+        path: ``Genes``, one model per gene (its transcripts' exons merged) or per
+        transcript, or plain BED12 data as ``Genes`` takes it.
+        """
+        return _panelset_layer(self, "gtf", (reader,), 1, {}, settings)
+
+    def hic(self, reader: Any, **settings: Unpack[t.HiCSettings]) -> LayerSet:
+        """One per panel: The upper triangle of a contact matrix, the diagonal along the x axis
+        (each cell a diamond), or with ``shape="square"`` the whole matrix of ``region`` (x)
+        against ``region2`` (y, its start at the top). ``reader`` is a Hi-C reader, a path
+        (opened with gwseq_io), or a square matrix over the region (bins of ``span / n``).
+        """
+        return _panelset_layer(self, "hic", (reader,), 1, {}, settings)
+
+    def links(self, pairs: Any, **settings: Unpack[t.LinksSettings]) -> LayerSet:
+        """One per panel: Links between pairs of places (BEDPE): an arc from anchor centre to
+        anchor centre in a lane of its own, or, ``lane="over"`` a Hi-C triangle or square, a
+        mark at each pair's contact cell (on a square, and at its mirror). ``pairs`` is a
+        reader whose ``read_entries`` gives the BEDPE columns, a path gwseq_io reads them
+        from, or plain data (the pairs with an anchor in view are read): a dict of columns,
+        a DataFrame, or rows in BEDPE order (``chr1``, ``start1``, ``end1``, ``chr2``,
+        ``start2``, ``end2``, then optionally ``name``, ``score``).
+        """
+        return _panelset_layer(self, "links", (pairs,), 1, {}, settings)
+
+    def site_heatmap(self, signal: Any, sites: Any, *, group: Any = None,
+                     **settings: Unpack[t.SiteHeatmapSettings]) -> LayerSet:
+        """One per panel: A signal around sites, one row per site (a table with ``chr``,
+        ``start``, ``end`` and optional ``strand``, ``summit`` columns, or an interval
+        reader), x the distance from the anchor in bp; ``group`` (a column of the sites, or
+        a label per site) makes a block of rows per group.
+        """
+        return _panelset_layer(self, "site_heatmap", (signal, sites), 2, {"group": group}, settings)
+
+    def site_profile(self, signal: Any, sites: Any, *, group: Any = None,
+                     **settings: Unpack[t.SiteProfileSettings]) -> LayerSet:
+        """One per panel: The column mean (or median) of a signal around sites (see
+        :class:`SiteHeatmap`): one line per group, x the distance from the anchor in bp, an
+        optional band.
+        """
+        return _panelset_layer(self, "site_profile", (signal, sites), 2, {"group": group}, settings)
+
+    def dendrogram(self, tree: Any, labels: Any = None,
+                   **settings: Unpack[t.DendrogramSettings]) -> LayerSet:
+        """One per panel: The merges of ``tree`` (a :class:`Tree`, or a scipy ``Z``) as
+        U-shaped links: the leaves at slots 0, 1, … in ``tree.leaves`` order on the leaf
+        axis, the heights on the value axis, the root at the top
+        (``orientation="horizontal"``: at the left, heights along x, the x axis inverted
+        unless set). ``labels`` (default: the tree's) make the leaf axis categorical, in
+        leaf order, so a heatmap with the same categories shares it; without labels each
+        leaf is ticked with its observation's index. Every leaf is labelled: turned 90° when
+        the labels do not fit flat, then smaller, down to the axis' ``label_min_size`` (6
+        pt), and every k-th only below it.
+        """
+        return _panelset_layer(self, "dendrogram", (tree, labels), 1, {}, settings)
+
+    def qq(self, values: Any, y: Any = None, **settings: Unpack[t.QQSettings]) -> LayerSet:
+        """One per panel: The sorted ``values`` against the quantiles of ``dist`` at R's
+        ``ppoints`` (``(i − a) / (n + 1 − 2a)``, a = 3/8 for n ≤ 10, else 1/2), or against
+        the sorted ``y`` (two samples: the longer interpolated to the shorter's size, as R's
+        ``qqplot``; ``values`` on x). ``pvalues=True``: ``values`` are p-values, drawn as
+        −log10 of the sorted p-values (y) against −log10 of the expected uniform quantiles
+        (x). Points as `Scatter`'s; the reference ``line`` and the pointwise ``band`` of
+        order statistics in the series color. The points and the default line are R's
+        (``qqnorm``, ``qqline``), not scipy's ``probplot`` (Filliben's medians, a least-
+        squares line).
+        """
+        return _panelset_layer(self, "qq", (values, y), 1, {}, settings)
+
+    def raincloud(self, values: Any, positions: Any = None,
+                  **settings: Unpack[t.RaincloudSettings]) -> LayerSet:
+        """One per panel: Rainclouds of ``values`` (a dict ``{category: values}``, a list of
+        arrays, or one array; long data with ``x=`` categories): per category a half violin
+        on the high side (stat ``violin``), a narrow box at the centre (stat ``box``) and
+        the values as jittered points on the low side. ``parts`` keeps some of the three.
+        Widths and offsets are `%` of the slot.
+        """
+        return _panelset_layer(self, "raincloud", (values, positions), 1, {}, settings)
+
+    def volcano(self, fold_change: Any, p: Any,
+                **settings: Unpack[t.VolcanoSettings]) -> LayerSet:
+        """One per panel: Differential results: log2 ``fold_change`` (x) against −log10 ``p``
+        (y; p = 0 at the smallest positive p, NaN left out). Points are ``up``, ``down`` or
+        ``n.s.``: up or down when ``p < p_threshold`` and |fold change| ≥
+        ``fold_change_threshold``, coloured by ``colors`` as a level axis on ``color`` (the
+        legend counts them), dashed rules at the thresholds. ``labels`` gives a text per
+        point, ``label`` which are drawn (placed as Scatter's). The classification settings
+        are read at the call.
+        """
+        return _panelset_layer(self, "volcano", (fold_change, p), 2, {}, settings)
+
+    def ma(self, mean: Any, fold_change: Any, p: Any = None,
+           **settings: Unpack[t.MaSettings]) -> LayerSet:
+        """One per panel: An MA plot: mean expression ``mean`` (x, on a log10 axis unless the
+        axis has a scale) against log2 ``fold_change`` (y), a rule at 0 and dashed ones at ±
+        ``fold_change_threshold``. Classes, colors and labels as `Volcano`'s (by fold change
+        alone without ``p``; ``label="top"``: the largest |fold change| among the
+        significant).
+        """
+        return _panelset_layer(self, "ma", (mean, fold_change, p), 2, {}, settings)
+
+    def manhattan(self, chromosomes: Any, positions: Any, p: Any,
+                  **settings: Unpack[t.ManhattanSettings]) -> LayerSet:
+        """One per panel: Genome-wide association results: −log10 ``p`` (y) at ``positions``
+        (bp) of ``chromosomes`` laid end to end (x) in natural order (chr1 … chr22, X, Y,
+        M), each ``chr_sizes`` long (unset: to its last position), its points in the next of
+        the two ``colors``, its name as the tick at its middle (left to right, a name that
+        would overlap the last one shown is left out), the x axis from the first
+        chromosome's start to the last one's end; a dashed rule at ``threshold`` (genome-
+        wide significance). ``labels``/``label``/``label_count`` as `Volcano`'s (``top``:
+        the most significant beyond ``threshold``).
+        """
+        return _panelset_layer(self, "manhattan", (chromosomes, positions, p), 3, {}, settings)