@umriss-ui/charts 0.3.0-rc.0

package/dist/index.d.ts

@@ -0,0 +1,1033 @@
+import { CSSProperties } from 'react';
+import { ReactNode } from 'react';
+
+export declare type Accessor<T> = (d: T, index: number) => number | null | undefined;
+
+export declare function Area<T>(props: AreaProps<T>): null;
+
+export declare interface AreaProps<T> {
+    /** Upper edge; null/undefined/NaN means a gap (R-2.5). */
+    accessor: Accessor<T>;
+    /** Lower edge; without a value the fixed baseline 0. */
+    baseline?: Accessor<T>;
+    /** Binding to an x axis (R-4.12). */
+    xAxisId?: string;
+    /** Binding to a y axis (R-4.12). */
+    yAxisId?: string;
+    /** Series-own data; overrides the container data (R-2.4). */
+    data?: readonly T[];
+    /** The name in legend and tooltip. Without one the series is called
+     "Series n" and a warning stands in DEV - an unnamed series is a colour
+     nobody can look up. */
+    name?: string;
+    /** Any CSS colour value; without one the palette --uc-series-N. */
+    color?: string;
+    /** Opacity of the fill; the outline stays fully opaque. */
+    fillOpacity?: number;
+    /** Width of the outline along the upper edge; 0 leaves it out. */
+    strokeWidth?: number;
+}
+
+export declare interface AreaSeriesConfig<T = unknown> extends SeriesBase<T> {
+    kind: "area";
+    /** Lower edge; without a value the fixed baseline 0. */
+    baseline?: Accessor<T>;
+    /** Opacity of the fill; the outline stays fully opaque. */
+    fillOpacity: number;
+    strokeWidth: number;
+}
+
+/** What the value is, given the limit set. A pure function of the two.
+
+ A missing or non-finite value yields `unknown` - and nothing else: the
+ deviation of a value nobody has is unknown to everybody too.
+
+ A bound is violated when the value lies beyond it, not when it lies on it. A
+ value exactly on the upper bound is in order. That is decided once here
+ (ADR-0006), so that two building blocks on the same screen do not disagree
+ about the edge.
+
+ Where several bounds are violated the most severe wins; among equally severe
+ ones the one the value lies furthest beyond. Under a tie in both, the one
+ named first.
+
+ No hysteresis: that would need the previous state, and a function of one
+ value has none. Exactly that is the property which makes this module safe to
+ duplicate. */
+export declare function assess(value: number | null | undefined, set?: LimitSet): Assessment;
+
+/** The verdict and what led to it. */
+export declare interface Assessment {
+    verdict: Verdict;
+    /** The violated limit - the same object the caller passed in, so that it can
+     be recognised against the caller's own data. Absent where none is
+     violated. */
+    limit?: Limit;
+    /** The amount beyond the bound, always positive. Absent where none is
+     violated. */
+    excess?: number;
+    /** The signed distance from the target. Absent where none is set - a missing
+     target yields no deviation of zero.
+
+     Two fields and not one: excess and deviation are two numbers, and a single
+     field meaning the one thing when a bound is violated and the other
+     otherwise reads well and is wrong at three in the morning. */
+    deviation?: number;
+}
+
+export declare interface AxisConfig<T = unknown> {
+    id: string;
+    orientation: AxisOrientation;
+    position: AxisPosition;
+    accessor: (d: T, index: number) => number;
+    label?: string;
+    tickCount?: number;
+    tickFormat?: (v: number) => string;
+    domain: "nice" | "data" | readonly [number, number];
+    /** undefined = the default per R-4.15 (only the first registered axis per
+     orientation). */
+    grid?: boolean;
+    /** Fixed tick values instead of the 1-2-5 algorithm. For axes whose values are
+     not numbers but places: the lanes of a state stack, the categories of a
+     Pareto. */
+    ticks?: readonly number[];
+    /** Operating calendar: the intervals in which time counts. With it,
+     materialisation maps wall clock time onto operating time before the scale
+     calculates - the scale stays affine (ADR-0001). */
+    calendar?: readonly OperatingInterval[];
+}
+
+export declare type AxisOrientation = "x" | "y";
+
+export declare type AxisPosition = "bottom" | "top" | "left" | "right";
+
+export declare function Bar<T>(props: BarProps<T>): null;
+
+export declare interface BarProps<T> {
+    /** Height; null/undefined/NaN means a gap (R-2.5). */
+    accessor: Accessor<T>;
+    /** Binding to an x axis (R-4.12). */
+    xAxisId?: string;
+    /** Binding to a y axis (R-4.12). */
+    yAxisId?: string;
+    /** Series-own data; overrides the container data (R-2.4). */
+    data?: readonly T[];
+    /** The name in legend and tooltip. Without one the series is called
+     "Series n" and a warning stands in DEV - an unnamed series is a colour
+     nobody can look up. */
+    name?: string;
+    /** Any CSS colour value; without one the palette --uc-series-N. */
+    color?: string;
+    /** Width as a fraction of the step; just under 1, so that neighbours do not
+     touch. Several bar series share this fraction. */
+    barWidth?: number;
+}
+
+export declare interface BarSeriesConfig<T = unknown> extends SeriesBase<T> {
+    kind: "bar";
+    /** Width as a fraction of the step; the group shares this fraction. */
+    barWidth: number;
+}
+
+/** The breaks in operating time that lie within the extent [from, to] - what the
+ axis must mark, in domain units. */
+export declare function breaks(input: CalendarInput, from: number, to: number): number[];
+
+/** Calendar from an input - a built calendar is passed straight through, a raw
+ list is built once and remembered. */
+export declare function calendarFrom(input: CalendarInput): OperatingCalendar;
+
+/** Every function of this module takes either: the raw list as it stands on the
+ axis, or the calendar built from it. */
+export declare type CalendarInput = OperatingCalendar | readonly OperatingInterval[];
+
+export declare function Chart<T>(props: ChartProps<T>): ReactNode;
+
+/** Measurements of the instrumentation for the benchmark page (R-5.1). */
+export declare interface ChartPerf {
+    materializeMs: number;
+    seriesDrawMs: number;
+    points: number;
+}
+
+export declare interface ChartProps<T> {
+    /** Shared data basis (required); access only through accessors (R-2.4). */
+    data: readonly T[];
+    /** Width in CSS pixels, or `"100%"` for the host's. Without a value the chart
+     measures its host and follows it through a ResizeObserver. */
+    width?: number | "100%";
+    /** Height in CSS pixels. Without a value the chart takes its host's, which
+     then has to have one - a chart in a box of height 0 draws nothing. */
+    height?: number;
+    /** Outer spacing of the plot area in CSS pixels. */
+    padding?: number | Partial<Padding>;
+    /** Required in DEV through a warning (R-7.6). */
+    ariaLabel?: string;
+    /** Goes to the root element, as it does everywhere in this workspace. */
+    className?: string;
+    /** Goes to the root element. The plot area is measured, never styled from
+     here: a height set past the component is a height the scene does not know
+     about. */
+    style?: CSSProperties;
+    /** Instrumentation for the benchmark page (R-5.1); not needed otherwise. */
+    onPerf?: (perf: ChartPerf) => void;
+    /** The axes, series and companions of this chart. They draw nothing
+     themselves: each registers its configuration and the scene draws it
+     (R-2.1), and the order in the JSX is the drawing order. */
+    children?: ReactNode;
+}
+
+declare interface CommonProps {
+    /** Axis on which the value lies. */
+    axisId?: string;
+    /** Whether the value lies on the x or on the y axis. Without one, y: a limit
+     is nearly always a value and not a moment. */
+    orientation?: "x" | "y";
+    /** Two severities, not five: five urgencies are five colours, and five colours
+     on a plant screen are noise. */
+    severity?: Severity;
+    /** What the value means. A line at 90 does not say what 90 is. */
+    label?: string;
+    /** Any CSS colour value, in place of the one the severity yields. A colour
+     handed in instead of a severity puts the rule in the application and the
+     presentation in the library, and the two drift apart as soon as a bound
+     moves - so this is for the case that has no severity, not for taste. */
+    color?: string;
+    /** Whether the value widens the axis extent, so that the limit is certainly
+     visible. Default true; the head of this file says why. */
+    inExtent?: boolean;
+    /** A chosen specification limit (the default) or a calculated control limit.
+     They look different because they mean different things (ADR-0008). */
+    role?: LimitRole;
+}
+
+declare interface CommonProps_2<T> {
+    /** Axis id, through which series bind themselves (R-4.12). */
+    id?: string;
+    /** Value access of this axis. */
+    accessor: (d: T, index: number) => number;
+    /** Axis title. */
+    label?: string;
+    /** Target value; the 1-2-5 algorithm may deviate. */
+    tickCount?: number;
+    tickFormat?: (v: number) => string;
+    domain?: "nice" | "data" | readonly [number, number];
+    /** Grid lines; the default follows R-4.15. */
+    grid?: boolean;
+    /** Fixed tick values instead of the 1-2-5 algorithm. For axes whose values are
+     places and not numbers: the lanes of a state stack, the categories of a
+     Pareto. */
+    ticks?: readonly number[];
+}
+
+export declare function ControlChart<T>(props: ControlChartProps<T>): ReactNode;
+
+export declare interface ControlChartProps<T> {
+    /** The values of the chart. */
+    accessor: Accessor<T>;
+    /** Required: the limits arise out of these values, not out of what happens to
+     be visible. */
+    data: readonly T[];
+    /** Given, or from a named reference window - never tacitly from everything on
+     the screen (ADR-0008). */
+    origin: ControlLimitOrigin;
+    /** Binding to an x axis (R-4.12). */
+    xAxisId?: string;
+    /** Binding to a y axis (R-4.12). */
+    yAxisId?: string;
+    /** The name in legend and tooltip. Without one the series is called
+     "Series n" and a warning stands in DEV - an unnamed series is a colour
+     nobody can look up. */
+    name?: string;
+    /** Any CSS colour value; without one the palette --uc-series-N. */
+    color?: string;
+    /** Switchable one by one; run lengths are parameters. */
+    rules?: Partial<RuleOptions>;
+    /** The faint zone lines at one and two sigma. Rule 4 is about the two-sigma
+     zone; without them a reader cannot check it. */
+    zoneLines?: boolean;
+    /** Labels of the control limits in the axis band. Without a value, none: the
+     package brings no text along, not even "UCL" and "LCL". */
+    labelUpper?: string;
+    /** The same for the lower control limit. Named separately because a chart may
+     well want one of the two labelled and not the other. */
+    labelLower?: string;
+    /** Name of the scatter of violations in the legend and the tooltip. Without a
+     value, none: a legend then carries it as "Series n" and warns once in DEV.
+     Before this, a German suffix stood on the name of the chart. */
+    violationName?: string;
+    /** The violations as data - they can be listed beside the chart as well as
+     marked on it. */
+    onViolations?: (found: readonly Violation[]) => void;
+}
+
+/** Where the limits come from. There are exactly these two possibilities. */
+export declare type ControlLimitOrigin = 
+/** From a baseline the caller has fixed. Taken as it is - even where the
+series would yield something else out of itself. */
+    {
+    readonly kind: "given";
+    readonly center: number;
+    readonly sigma: number;
+}
+/** From exactly this index range of the series, half-open [from, to). */
+| {
+    readonly kind: "referenceWindow";
+    readonly from: number;
+    readonly to: number;
+};
+
+/** Centre line, estimated spread and the control limits at three sigma. */
+export declare interface ControlLimits {
+    readonly center: number;
+    /** Estimated spread of a single value, not the distance to the limit. */
+    readonly sigma: number;
+    readonly upper: number;
+    readonly lower: number;
+}
+
+/** Centre line and control limits. Either given or calculated from exactly the
+ named reference window - never from the whole series and never from the
+ visible excerpt. Gaps (NaN) count neither in the centre line nor in the
+ moving range. A window without values yields NaN limits, not an error: the
+ chart then draws no line instead of bursting. */
+export declare function controlLimits(values: readonly number[], origin: ControlLimitOrigin): ControlLimits;
+
+export declare const DAY: number;
+
+/** Default gradient: a sequential set, light to dark, so that it stays readable
+ as an order of lightness even without colour. It is a default, not a
+ restriction - whoever has a scale of their own names it. */
+export declare const DEFAULT_GRADIENT: readonly string[];
+
+/** All four rules, with Nelson's run lengths: nine points on one side, six
+ points in succession rising or falling. Western Electric counts eight; both
+ lengths are therefore parameters. */
+export declare const defaultRules: RuleOptions;
+
+export declare const HOUR: number;
+
+/** Explicit invalidation: devalue the cache, every living chart reads anew and
+ redraws. */
+export declare function invalidateTheme(): void;
+
+export declare function Legend({ placement }: LegendProps): ReactNode;
+
+export declare interface LegendConfig {
+    placement: "top" | "bottom";
+}
+
+export declare interface LegendProps {
+    /** Which side of the plot area the legend stands on. Without a value, below
+     it. */
+    placement?: "top" | "bottom";
+}
+
+/** A bound: a value, a side and a severity. No more - a tolerance band is
+ derived and never an input (two limits of equal severity on opposite sides
+ enclose one). That keeps the one-sided case, which is the more common one,
+ free of a `null` on the other edge. */
+export declare interface Limit {
+    value: number;
+    side: Side;
+    severity: Severity;
+}
+
+export declare function LimitBand(props: LimitBandProps): null;
+
+export declare interface LimitBandConfig extends LimitBase {
+    kind: "band";
+    from: number;
+    to: number;
+}
+
+export declare interface LimitBandProps extends CommonProps {
+    /** Lower edge of the band, in domain units of its axis. */
+    from: number;
+    /** Upper edge. A band drawn backwards (`from` above `to`) is drawn between
+     the two all the same - the pair is a range, not a direction. */
+    to: number;
+}
+
+declare interface LimitBase {
+    /** Axis on which the value lies. */
+    axisId: string;
+    orientation: AxisOrientation;
+    severity: Severity;
+    role: LimitRole;
+    label?: string;
+    /** A colour of its own; without one, that of the role or of the severity out of
+     the theme. */
+    color?: string;
+    /** Pulls the extent of the axis along. Default true: an excluded limit yields a
+     chart that looks right and does not show its most important line - and that
+     nobody notices. A squashed plot is noticed at once. */
+    inExtent: boolean;
+}
+
+export declare type LimitConfig = LimitLineConfig | LimitBandConfig;
+
+export declare function LimitLine(props: LimitLineProps): null;
+
+export declare interface LimitLineConfig extends LimitBase {
+    kind: "line";
+    value: number;
+}
+
+export declare interface LimitLineProps extends CommonProps {
+    /** Where the line lies, in domain units of its axis. */
+    value: number;
+}
+
+/** What a limit stands for. The difference is not cosmetic: a specification
+ limit is chosen (what the customer assumes), a control limit is calculated
+ (what the process normally does). A process can be in control and outside the
+ specification and the other way round, and each of the four cases calls for
+ something different - which is why the two lines have to look
+ distinguishable (ADR-0008). */
+export declare type LimitRole = "specification" | "control" | "zone";
+
+/** The set a value is read against: its bounds and, where there is one, its
+ target.
+
+ The target is not a limit. It is missed, never violated, and it is never the
+ edge of a region. Conflating the two is how a tile turns red for being above
+ target. */
+export declare interface LimitSet {
+    /** In any order; none, one or several. */
+    limits?: readonly Limit[];
+    target?: number;
+}
+
+export declare function Line<T>(props: LineProps<T>): null;
+
+export declare class LinearScale implements Scale {
+    readonly domain: readonly [number, number];
+    readonly range: readonly [number, number];
+    /** Pre-computed line equation px = v·m + b - the draw loop uses it directly. */
+    readonly m: number;
+    readonly b: number;
+    constructor(domain: readonly [number, number], range: readonly [number, number]);
+    toPx(v: number): number;
+    fromPx(px: number): number;
+    ticks(n: number): number[];
+}
+
+export declare interface LineProps<T> {
+    /** Y value; null/undefined/NaN means a gap (R-2.5). */
+    accessor: Accessor<T>;
+    /** Binding to an x axis (R-4.12). */
+    xAxisId?: string;
+    /** Binding to a y axis (R-4.12). */
+    yAxisId?: string;
+    /** Series-own data; overrides the container data (R-2.4). */
+    data?: readonly T[];
+    /** The name in legend and tooltip. Without one the series is called
+     "Series n" and a warning stands in DEV - an unnamed series is a colour
+     nobody can look up. */
+    name?: string;
+    /** Any CSS colour value; without one the palette --uc-series-N. */
+    color?: string;
+    /** A role instead of a colour value; the theme resolves it. */
+    tone?: "ok" | "warning" | "alarm";
+    /** Line width in CSS pixels. */
+    strokeWidth?: number;
+    /** Dash pattern as a run of lengths in CSS pixels; without one a solid line. */
+    dash?: readonly number[];
+    /** When the individual points are drawn as marks: `auto` from a density at
+     which they no longer run into each other, `always`, `never`. */
+    markers?: "auto" | "always" | "never";
+}
+
+export declare interface LineSeriesConfig<T = unknown> extends SeriesBase<T> {
+    kind: "line";
+    strokeWidth: number;
+    dash?: readonly number[];
+    markers: "auto" | "always" | "never";
+}
+
+/** Map a whole series inwards - the route materialisation takes when it wants to
+ go it in one piece. Only the first n values are touched. */
+export declare function mapSeries(input: CalendarInput, source: Float64Array, n: number, target: Float64Array): void;
+
+/** Materialised series: the draw loop works only on this (R-2.7).
+ Gaps (null/undefined/NaN out of the accessor) are encoded as NaN (R-2.5). */
+export declare interface MaterializedSeries {
+    x: Float64Array;
+    y: Float64Array;
+    /** Lower edge, where the baseline is an accessor of its own; otherwise null.
+     A fixed baseline needs no channel - it is a number (R-2.7). */
+    y0: Float64Array | null;
+    /** Value channel: the third value per point, which today only the matrix
+     needs. Named rather than overloading y0 - a property that only some kinds
+     carry does not belong in the shared type with a comment (ADR-0011). null
+     for every kind that does not use it. */
+    w: Float64Array | null;
+    /** Second x channel: the end of a span. Named for the same reason.
+     NaN here does not mean a gap but open (ADR-0011). */
+    x1: Float64Array | null;
+    length: number;
+}
+
+export declare function Matrix<T>(props: MatrixProps<T>): null;
+
+/** How a matrix colours its cells. Discretely by assessment - the same limits
+ that colour a tile - or across a gradient. */
+export declare type MatrixColoring = {
+    kind: "assessment";
+    limits: LimitSet;
+} | {
+    kind: "gradient";
+    /** Colour stops from small to large; at least two. The stops ARE the
+     steps - the library does not interpolate between them, because that
+     would mean a colour parser for arbitrary CSS colour values, which this
+     package does not have and is not to get (ADR-0011). Whoever wants a
+     finer gradation names more colours. */
+    stops: readonly string[];
+    /** Value range of the gradient; without a value taken from the data. */
+    range?: readonly [number, number];
+};
+
+export declare interface MatrixProps<T> {
+    /** Row position on the y axis. */
+    accessor: Accessor<T>;
+    /** The value that decides the colour. */
+    value: Accessor<T>;
+    /** Without a value the default gradient across the data range. */
+    coloring?: MatrixColoring;
+    /** Binding to an x axis (R-4.12). */
+    xAxisId?: string;
+    /** Binding to a y axis (R-4.12). */
+    yAxisId?: string;
+    /** Series-own data; overrides the container data (R-2.4). */
+    data?: readonly T[];
+    /** The name in legend and tooltip. Without one the series is called
+     "Series n" and a warning stands in DEV - an unnamed series is a colour
+     nobody can look up. */
+    name?: string;
+}
+
+export declare interface MatrixSeriesConfig<T = unknown> extends SeriesBase<T> {
+    kind: "matrix";
+    /** The value that decides the colour - the third channel (ADR-0011).
+     The base accessor yields the row position, not this value. */
+    value: Accessor<T>;
+    coloring: MatrixColoring;
+}
+
+export declare const MINUTE: number;
+
+/** An operating calendar: sorted, merged intervals with the operating time
+ accumulated before each one begins. An empty calendar is no calendar: it maps
+ unchanged.
+
+ Build once, then pass around: the mapping runs once per point, and were it to
+ sort and accumulate every time, the calendar would be the most expensive
+ thing about the frame. */
+export declare interface OperatingCalendar {
+    readonly intervals: readonly OperatingInterval[];
+    /** Operating time accumulated before the respective interval begins. */
+    readonly offsets: readonly number[];
+    /** The whole operating time - the axis' extent is [0, total]. */
+    readonly total: number;
+}
+
+/** Builds a calendar: sorts, merges overlapping and abutting intervals and
+ throws away empty, reversed and non-finite ones. Merging is not a courtesy
+ but a precondition: only over separated intervals is the reverse mapping
+ unambiguous. */
+export declare function operatingCalendar(intervals: readonly OperatingInterval[]): OperatingCalendar;
+
+/** An interval in which time counts; thought of as half-open, but mappable from
+ both sides at its edges: both `from` and `to` have an operating time. */
+export declare interface OperatingInterval {
+    readonly from: number;
+    readonly to: number;
+}
+
+/** Tick values for an axis extent that already stands in OPERATING TIME - the
+ route the axis layout takes.
+
+ The extent is trimmed to the operating time that exists (an extent widened to
+ nice boundaries reaches beyond it), calculated back into wall clock time, and
+ the candidates arise there. The step comes from the span in operating time and
+ not from the one in wall clock time: roughly one candidate per step of
+ operating time survives, and calculated from the wall clock span, four out of
+ ten wanted ticks would be left. */
+export declare function operatingTicks(input: CalendarInput, from: number, to: number, count: number, offset?: number): number[];
+
+/** A tick: where it stands on the clock and where it lies on the axis. */
+export declare interface OperatingTimeTick {
+    readonly wallClock: number;
+    readonly operatingTime: number;
+}
+
+/** Ticks for an operating time axis, from an extent in WALL CLOCK TIME.
+
+ The candidates arise in wall clock time on multiples of the step - hours,
+ shift changes, days - whatever lies in removed time falls away, the rest is
+ mapped. Never the other way round: ticks generated in operating time land in
+ the middle of a shift and yield an axis labelled 14.5 and 29.0 which nobody
+ can read.
+
+ The offset shifts the grid; with it a local time hits its own midnight without
+ this module having to know about time zones.
+
+ If two candidates fall on the same operating time - the end of one shift and
+ the beginning of the next - the earlier one stays: two labels on the same
+ pixel would be one too many.
+
+ Both times come back, because the axis needs both: the operating time to
+ place the tick, the wall clock time to label it. */
+export declare function operatingTimeTicks(input: CalendarInput, from: number, to: number, step: number, offset?: number): OperatingTimeTick[];
+
+export declare interface Padding {
+    top: number;
+    right: number;
+    bottom: number;
+    left: number;
+}
+
+/** Sorts descending, accumulates, collects the tail and finds the cutoff
+ crossing.
+
+ Ties keep the input order - explicitly through the input index, not in
+ reliance on a stable sort - so that two reasons with the same count do not
+ swap places between two frames.
+
+ The remainder stands last, independently of its value. Two hundred small
+ reasons regularly yield a remainder larger than the third real bar; sorted
+ into place, the chart would claim there is a fault reason called "other"
+ which is the third biggest problem. */
+export declare function pareto(items: readonly ParetoItem[], options?: ParetoSettings): ParetoResult;
+
+export declare const paretoDefaults: Omit<ParetoOptions, "remainderName">;
+
+/** An item, the way it is drawn. */
+export declare interface ParetoEntry {
+    readonly name: string;
+    readonly value: number;
+    /** Category and at the same time x value: category n lies at x = n
+     (ADR-0002). */
+    readonly index: number;
+    /** Share of the total, 0…1. */
+    readonly share: number;
+    /** Cumulative share up to and including this entry, 0…1. Exactly 1 at the
+     last entry. */
+    readonly cumulative: number;
+    /** The collected tail. Exactly one entry can be this, and it always stands
+     last. */
+    readonly remainder: boolean;
+}
+
+/** An item, the way the caller counts it. */
+export declare interface ParetoItem {
+    readonly name: string;
+    readonly value: number;
+}
+
+export declare interface ParetoOptions {
+    /** The share whose crossing is sought. Whoever lands exactly on it counts as
+     the crossing: the question is "which reasons make up eighty per cent", and
+     whoever reaches eighty exactly belongs to them. */
+    readonly cutoff: number;
+    /** How many items stay on their own. Everything behind that becomes a single
+     entry. Beyond the number of items no remainder arises at all - not an empty
+     one. Default: infinity, so no collecting. */
+    readonly collectRank: number;
+    /** Name of the collected remainder. `@umriss-ui/charts` has no wording module
+     - every string it draws comes from the caller - and no module is introduced
+     for a single label. Hence no default either: until library-audit 03 the
+     default here was "Sonstige", the one German word the package brought along
+     itself. */
+    readonly remainderName?: string;
+}
+
+export declare interface ParetoResult {
+    readonly entries: readonly ParetoEntry[];
+    /** Total of the drawn entries - after collecting, the same as before. */
+    readonly total: number;
+    /** Index of the first entry whose cumulative share reaches the cutoff; -1
+     when it is never reached. */
+    readonly cutoffIndex: number;
+}
+
+/** What a call may specify: a collect rank only together with the name of the
+ remainder it creates. */
+export declare type ParetoSettings = {
+    readonly cutoff?: number;
+} & ({
+    readonly collectRank?: undefined;
+    readonly remainderName?: undefined;
+} | {
+    readonly collectRank: number;
+    readonly remainderName: string;
+});
+
+export declare interface Rect {
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+}
+
+/** The removed spans between the operating intervals, for the mark in the axis
+ band. A chart that takes a weekend out and does not say so claims a
+ continuity it does not have. Before the first and after the last interval
+ there is nothing to mark: that lies outside the axis' extent. */
+export declare function removedIntervals(input: CalendarInput): RemovedSpan[];
+
+/** A removed span and the place it collapses onto. */
+export declare interface RemovedSpan {
+    readonly from: number;
+    readonly to: number;
+    /** Operating time on which the whole span lies - a point, not a stretch. */
+    readonly operatingTime: number;
+}
+
+export declare interface ResolvedTheme {
+    colorAxis: string;
+    colorGrid: string;
+    colorText: string;
+    colorBg: string;
+    /** Colours of the two limit severities. A limit carries the colour of its
+     severity, not that of its series - it belongs to none. */
+    colorWarning: string;
+    colorAlarm: string;
+    /** The third outcome of an assessment. "unknown" deliberately has no
+     colour: a missing value becomes a hole like every gap in this library, and
+     a hole carries no colour, because a colour would be a claim. */
+    colorOk: string;
+    font: string;
+    fontMono: string;
+    series: readonly string[];
+}
+
+/** Name of a rule, the way it is switched on and off in `violations`. */
+export declare type RuleName = "outlier" | "run" | "trend" | "twoOfThree";
+
+/** Which rules run, and with which run lengths. */
+export declare interface RuleOptions {
+    readonly outlier: boolean;
+    readonly run: boolean;
+    readonly trend: boolean;
+    readonly twoOfThree: boolean;
+    /** Points on one side of the centre line from which rule 2 fires. */
+    readonly runLength: number;
+    /** Points in succession from which rule 3 fires. */
+    readonly trendLength: number;
+}
+
+/** Rule 1 (Nelson 1, Western Electric 1): one point beyond three sigma.
+ Beyond, not on it - a point exactly on the limit violates nothing. */
+export declare function ruleOutlier(values: readonly number[], limits: ControlLimits): number[];
+
+/** Rule 2 (Nelson 2): a run of points on one side of the centre line. The
+ default length is nine - Nelson. Western Electric counts eight; that is why
+ the length is a parameter and not a literal, so that a works with a rule of
+ its own need not argue with the library. */
+export declare function ruleRun(values: readonly number[], limits: ControlLimits, length?: number): number[];
+
+/** Rule 3 (Nelson 3): a run of nothing but rises or nothing but falls. The
+ default length is six points, so five steps - Nelson. Two equal values are
+ neither a rise nor a fall and break the run. */
+export declare function ruleTrend(values: readonly number[], length?: number): number[];
+
+/** Rule 4 (Nelson 5): two of three consecutive points beyond two sigma on the
+ same side. Reported are the points beyond the zone, not the one in between -
+ that one is unremarkable and, marked, would look like a measurement error. */
+export declare function ruleTwoOfThree(values: readonly number[], limits: ControlLimits): number[];
+
+export declare interface Scale {
+    domain: readonly [number, number];
+    range: readonly [number, number];
+    /** Affine coefficients of the mapping px = v·m + b.
+
+     They stand in the interface because the drawing code reads them and
+     computes inline in the point loop instead of calling toPx() per point -
+     that is what carries 60 fps at millions of points. Every scale of this
+     library is affine; see docs/adr/0001-affine-scale-contract.md, which also
+     says what a later log scale would cost. */
+    readonly m: number;
+    readonly b: number;
+    toPx(v: number): number;
+    fromPx(px: number): number;
+    ticks(n: number): number[];
+}
+
+export declare function Scatter<T>(props: ScatterProps<T>): null;
+
+export declare interface ScatterProps<T> {
+    /** Y value; null/undefined/NaN means a gap (R-2.5). */
+    accessor: Accessor<T>;
+    /** Binding to an x axis (R-4.12). */
+    xAxisId?: string;
+    /** Binding to a y axis (R-4.12). */
+    yAxisId?: string;
+    /** Series-own data; overrides the container data (R-2.4). */
+    data?: readonly T[];
+    /** The name in legend and tooltip. Without one the series is called
+     "Series n" and a warning stands in DEV - an unnamed series is a colour
+     nobody can look up. */
+    name?: string;
+    /** Any CSS colour value; without one the palette --uc-series-N. */
+    color?: string;
+    /** A role instead of a colour value; the theme resolves it. */
+    tone?: "ok" | "warning" | "alarm";
+    /** Point radius in CSS pixels. */
+    radius?: number;
+}
+
+export declare interface ScatterSeriesConfig<T = unknown> extends SeriesBase<T> {
+    kind: "scatter";
+    /** Point radius in CSS pixels. */
+    radius: number;
+}
+
+export declare const SECOND = 1000;
+
+export declare interface SeriesBase<T = unknown> {
+    /** Y value; null/undefined/NaN means a gap (R-2.5). */
+    accessor: Accessor<T>;
+    /** Series-own data; overrides the container data (R-2.4). */
+    data?: readonly T[];
+    xAxisId: string;
+    yAxisId: string;
+    name?: string;
+    color?: string;
+    /** A role instead of a colour value: the theme resolves it, in both themes.
+     For series that mean something rather than just being the next one - the
+     violating points of a control chart, say. `color` beats it. */
+    tone?: "ok" | "warning" | "alarm";
+}
+
+export declare type SeriesConfig<T = unknown> = LineSeriesConfig<T> | AreaSeriesConfig<T> | BarSeriesConfig<T> | ScatterSeriesConfig<T> | StateSeriesConfig<T> | MatrixSeriesConfig<T> | SpanSeriesConfig<T>;
+
+export declare type SeriesKind = SeriesConfig["kind"];
+
+/** How seriously a violation weighs. Exactly two: one severity that advises and
+ one that calls for action. Five severities would be five colours, and five
+ colours on a control room screen are noise. Whoever needs a third
+ distinction sets a second limit. */
+export declare type Severity = "warning" | "alarm";
+
+/** Whether a limit is an upper or a lower bound. */
+export declare type Side = "upper" | "lower";
+
+/** Sigma calculated back from a limit that stands on paper. For callers whose
+ baseline has been handed down as a centre line and a control limit. */
+export declare function sigmaFromLimit(center: number, upper: number): number;
+
+export declare function Span<T>(props: SpanProps<T>): null;
+
+export declare interface SpanProps<T> {
+    /** Lane position on the y axis. */
+    accessor: Accessor<T>;
+    /** End on the x axis. Missing means open: the span runs to the edge and is
+     drawn as open - a running job is a fact one wants to see. */
+    to: Accessor<T>;
+    /** Binding to an x axis (R-4.12). */
+    xAxisId?: string;
+    /** Binding to a y axis (R-4.12). */
+    yAxisId?: string;
+    /** Series-own data; overrides the container data (R-2.4). */
+    data?: readonly T[];
+    /** The name in legend and tooltip. Without one the series is called
+     "Series n" and a warning stands in DEV - an unnamed series is a colour
+     nobody can look up. */
+    name?: string;
+    /** Any CSS colour value; without one the palette --uc-series-N. */
+    color?: string;
+    /** Height of a span as a fraction of one domain unit of the y axis. */
+    height?: number;
+}
+
+export declare interface SpanSeriesConfig<T = unknown> extends SeriesBase<T> {
+    kind: "span";
+    /** End of the span on the x axis. Missing means open: the span runs to the end
+     of the domain and is drawn as open. */
+    to: Accessor<T>;
+    /** Height of a span as a fraction of one domain unit of the y axis. */
+    height?: number;
+}
+
+export declare function StateBand<T>(props: StateBandProps<T>): null;
+
+export declare interface StateBandProps<T> {
+    /** Index of the state in `states`; null/undefined/NaN is a gap - and a gap
+     stays a hole, it gets no colour for "unknown". A colour would be a claim
+     about the interval. */
+    accessor: Accessor<T>;
+    /** The closed set of states, in the order of their codes. */
+    states: readonly StateEntry[];
+    /** Binding to an x axis (R-4.12). */
+    xAxisId?: string;
+    /** Binding to a y axis (R-4.12). */
+    yAxisId?: string;
+    /** Series-own data; overrides the container data (R-2.4). */
+    data?: readonly T[];
+    /** The name in legend and tooltip. Without one the series is called
+     "Series n" and a warning stands in DEV - an unnamed series is a colour
+     nobody can look up. */
+    name?: string;
+    /** Lower edge of the lane in domain units of the y axis. */
+    laneFrom?: number;
+    /** Upper edge of the lane in domain units of the y axis. */
+    laneTo?: number;
+}
+
+/** One state of the closed set a state series knows. */
+export declare interface StateEntry {
+    label: string;
+    color: string;
+}
+
+export declare interface StateSeriesConfig<T = unknown> extends SeriesBase<T> {
+    kind: "state";
+    /** The closed set of states. The accessor yields the index into it - a number,
+     not a key (ADR-0007). */
+    states: readonly StateEntry[];
+    /** Lower edge of the lane in domain units of the y axis; without a value the
+     beginning of the axis domain. */
+    laneFrom?: number;
+    /** Upper edge of the lane; without a value the end of the axis domain. */
+    laneTo?: number;
+}
+
+/** Step for tick candidates in wall clock time, at an intended count. Rounded up
+ to the next readable step, so that no more ticks arise than wanted. Above the
+ day steps it continues in whole days. */
+export declare function timeStep(span: number, count: number): number;
+
+export declare function Tooltip<T>(props: TooltipProps<T>): null;
+
+export declare interface TooltipConfig<T = unknown> {
+    mode: "x" | "nearest";
+    render?: (hit: TooltipHit<T>) => ReactNode;
+}
+
+export declare interface TooltipHit<T = unknown> {
+    xValue: number;
+    points: readonly TooltipPoint<T>[];
+    /** Pixel position of the crosshair (snapped to the data point). */
+    xPx: number;
+    /** Pixel position of the primary hit. */
+    yPx: number;
+}
+
+/** One hit per series in the tooltip (R-4.4). */
+export declare interface TooltipPoint<T = unknown> {
+    seriesName: string;
+    color: string;
+    yValue: number;
+    datum: T;
+    index: number;
+    /** Only for the matrix: the value out of the value channel. It stands here and
+     not in yValue, because yValue is the position on the y axis - for a matrix
+     therefore the row. Putting both into one field would be exactly the
+     overloading ADR-0011 is written against. */
+    value?: number;
+    /** Only for state series and spans: the section being pointed at.
+     A duration does not stand here - it is the difference of two numbers the
+     entry already carries, and formatting it would presuppose knowing what the
+     x axis means. The caller knows that, not this library. */
+    segment?: {
+        from: number;
+        to: number;
+        label: string;
+        open: boolean;
+    };
+}
+
+export declare interface TooltipProps<T> {
+    /** "x": every series at the x position; "nearest": only the nearest point. */
+    mode?: "x" | "nearest";
+    /** Render prop for content of one's own; without it the built-in tooltip
+     applies. */
+    render?: (hit: TooltipHit<T>) => ReactNode;
+}
+
+/** Wall clock time → operating time.
+
+ A point in a removed interval is a gap and becomes `NaN` - the encoding every
+ gap of this library already uses, and the drawing loop breaks the mark at it
+ of its own accord. Not the edge of the interval: a measurement from a time
+ which, according to the calendar, did not exist could not be laid there
+ honestly; it would pile up on what really does lie there. The same holds
+ before the first and after the last interval.
+
+ The end of one interval and the beginning of the next fall on the same value:
+ in operating time they are neighbours, and the line between two points on
+ either side is drawn. That is not a lie but the whole purpose of the axis; the
+ mark in the axis band tells the reader that time was taken out there. */
+export declare function toOperatingTime(wallClock: number, input: CalendarInput): number;
+
+/** Operating time → wall clock time; outside [0, total] there is none.
+
+ At a seam - the end of an interval which is at the same time the beginning of
+ the next - the beginning of the next comes out: from there time counts again,
+ and a pointer aiming there aims at the coming shift. Only the end of the last
+ interval has no next and comes back as itself. */
+export declare function toWallClock(operatingTime: number, input: CalendarInput): number;
+
+/** What a value is. Four outcomes, not three.
+
+ `unknown` is an outcome of its own and not a `null` return: a `null`
+ invites `?? "ok"` at the call site, and that very expression is the defect
+ this module exists to prevent. A value nobody has is a reason to look and
+ not a reason to relax. */
+export declare type Verdict = "ok" | "unknown" | "warning" | "alarm";
+
+/** How heavily a verdict weighs, as a number - for sorting and comparing, as
+ when a matrix is to bring its worst cell to the top. It stands here so that
+ the order is not reinvented at every call site. */
+export declare function verdictWeight(verdict: Verdict): number;
+
+/** All violated indices, ascending and free of duplicates - the scatter drawn
+ beside the line. */
+export declare function violatedIndices(found: readonly Violation[]): number[];
+
+/** A rule and the indices it violates. */
+export declare interface Violation {
+    readonly rule: RuleName;
+    readonly indices: readonly number[];
+}
+
+/** The rules switched on, each with its indices. Rules without hits do not
+ appear in the list. The indices are data, not merely marks: they can be
+ listed beside the chart as well as marked on it. */
+export declare function violations(values: readonly number[], limits: ControlLimits, options?: Partial<RuleOptions>): Violation[];
+
+export declare function XAxis<T>(props: XAxisProps<T>): null;
+
+export declare interface XAxisProps<T> extends CommonProps_2<T> {
+    /** Which edge the axis stands at. A second x axis on the opposite edge is how
+     a series counts in a unit of its own. */
+    position?: "bottom" | "top";
+    /** Operating calendar: the intervals in which time counts. With it the axis
+     stands in operating time - weekends and night shifts are out, and every
+     removed span gets a break mark. The scale stays affine; the mapping happens
+     in materialisation (ADR-0001). */
+    calendar?: readonly OperatingInterval[];
+}
+
+export declare function YAxis<T>(props: YAxisProps<T>): null;
+
+export declare interface YAxisProps<T> extends CommonProps_2<T> {
+    /** Which edge the axis stands at. Several y axes per side are stacked
+     outwards, so that extents of clearly different magnitude stay readable. */
+    position?: "left" | "right";
+}
+
+/** A zone line: k times sigma above and below the centre line. */
+export declare interface Zone {
+    readonly k: number;
+    readonly upper: number;
+    readonly lower: number;
+}
+
+/** The faintly drawn zone lines. Rule 4 is about the two-sigma zone, and a
+ reader cannot check it against a chart that does not show it. */
+export declare function zones(limits: ControlLimits, multiples?: readonly number[]): Zone[];
+
+export { }