minerva-design 1.3.0 → 1.4.0

package/dist/angular/types/minerva-angular.d.ts

@@ -3,6 +3,7 @@ import { AfterViewChecked, ElementRef, EnvironmentProviders, InjectionToken, OnI
 import { ColorScheme, ComponentTheme, CustomBilingualTheme, DefaultTheme, Density, DesignPreset, FontScale, Palette, RadiusScale, RatingMachineEvent, RatingStarFill, ResolvedDesign, ResolvedThemeMode, ShadowScale, SupportTheme, SupportedLanguage, ThemeMap, ThemeMode, ThemeName, TranslateOptions, dayKey, resolveSpace } from "../../core/index.js";
 import { ControlValueAccessor } from "@angular/forms";
 import { Placement, ReadingDirection } from "../../dom/index.js";
+import { Bar3DSeries, BoxplotGroup, BulletDatum, CalendarDate, CalendarDatum, Chart3DAxisOptions, Chart3DCameraOptions, Chart3DCameraState, Chart3DColorBarOptions, Chart3DColorScale, Chart3DHoverEvent, Chart3DInstance, Chart3DLegendOptions, Chart3DOptions, Chart3DSeries, Chart3DTooltipOptions, ChartAnnotation, ChartAxisOptions, ChartCurve, ChartDragEvent, ChartHoverEvent, ChartInstance, ChartInteractionOptions, ChartLegendOptions, ChartOptions, ChartOrientation, ChartPadding, ChartPlotClickEvent, ChartRendererKind, ChartRendererPreference, ChartSeries, ChartSeriesType, ChartTooltipOptions, ChartView, DepthChartHoverEvent, DepthChartInstance, DepthChartOptions, GanttTask, GaugeBand, HeatmapCell, HistogramBinning, Line3DSeries, OrderBookDelta, OrderBookHeatmapHoverEvent, OrderBookHeatmapInstance, OrderBookHeatmapOptions, OrderBookInstance, OrderBookLevelEvent, OrderBookOptions, OrderBookSnapshot, QuadrantAxisLabels, QuadrantCorner, QuadrantPoint, QuadrantRegions, RadarIndicator, RadarSeries, RadialBarDatum, SankeyLink, SankeyNode, Scatter3DSeries, ShapeChartCommonOptions, ShapeChartInstance, ShapeChartOptions, ShapeDatum, ShapeDrillEvent, ShapeHoverEvent, ShapeLegendOptions, ShapeToggleEvent, ShapeTooltipOptions, Surface3DContourOptions, Surface3DSeries, Surface3DWireframeOptions, TimeAndSalesInstance, TimeAndSalesOptions, TimeAndSalesRowEvent, TradingBar, TradingBarsInput, TradingChartInstance, TradingChartOptions, TradingChartStyle, TradingClickEvent, TradingCrosshairEvent, TradingDrawing, TradingDrawingTool, TradingHistoryRequestEvent, TradingIndicator, TradingIndicatorToggleEvent, TradingOrderMoveEvent, TradingTimeframe, TradingVisibleRange, TreemapNode, WaterfallStep } from "../../charts/core.js";
 /**
  * Accepted `theme` values: "auto" / "system" (follow
  * `prefers-color-scheme`), a built-in theme name, a theme object, or a
@@ -7393,6 +7394,2245 @@ export declare class MnTableCell {
   static ɵfac: i0.ɵɵFactoryDeclaration<MnTableCell, never>;
   static ɵdir: i0.ɵɵDirectiveDeclaration<MnTableCell, "td[mnTableCell]", never, {}, {}, never, never, true, never>;
 }
+/**
+ * What a chart engine factory of `minerva-design/charts/core` returns
+ * (`createChart`, `createShapeChart`, ...): options can be replaced, the
+ * instance destroyed.
+ */
+export interface EngineInstance<O> {
+  setOptions(options: O): void;
+  destroy(): void;
+}
+/** `booleanAttribute` keeping `undefined` (the engine default applies) */
+export declare const optionalBoolean: (value: unknown) => boolean | undefined;
+/** Template of the chart components: the surface the engine renders into */
+export declare const CHART_SURFACE = "<div #surface style=\"position:absolute;inset:0\"></div>";
+/**
+ * Base of the chart components: mounts an engine of
+ * `minerva-design/charts/core` into the `#surface` of the template after
+ * the first render (browser only: nothing runs during SSR), passes new
+ * options whenever an input read by `engineOptions()` changes (signals, no
+ * zone needed), and destroys it with the component.
+ *
+ * A subclass names the factory (`createEngine`), turns its inputs into
+ * engine options (`engineOptions`, `null` while there is nothing to draw)
+ * and forwards the engine events (`bindEngine`).
+ */
+export declare abstract class MnChartEngine<O, I extends EngineInstance<O>> {
+  /** Height of the chart (the legend included); numbers are pixels, strings any CSS length (default 320) */
+  readonly height: import("@angular/core").InputSignal<string | number | undefined>;
+  /** Width of the chart; numbers are pixels (default `100%`) */
+  readonly width: import("@angular/core").InputSignal<string | number | undefined>;
+  private readonly engine;
+  /** The engine instance (minerva-design/charts/core), `null` before the first render */
+  readonly instance: import("@angular/core").Signal<I | null>;
+  private readonly surface;
+  protected readonly cssWidth: import("@angular/core").Signal<string>;
+  protected readonly cssHeight: import("@angular/core").Signal<string>;
+  /** Height used when the `height` input is not set */
+  protected defaultHeight(): number;
+  /** Creates the engine (e.g. `createChart(container, options)`) */
+  protected abstract createEngine(container: HTMLElement, options: O): I;
+  /** Engine options of the current inputs; `null` while there is nothing to draw */
+  protected abstract engineOptions(): O | null;
+  /** Subscribes to the engine events; returns the unsubscribe functions */
+  protected bindEngine?(engine: I): Array<() => void>;
+  constructor();
+  static ɵfac: i0.ɵɵFactoryDeclaration<MnChartEngine<any, any>, never>;
+  static ɵdir: i0.ɵɵDirectiveDeclaration<MnChartEngine<any, any>, never, never, {
+    "height": {
+      "alias": "height";
+      "required": false;
+      "isSignal": true;
+    };
+    "width": {
+      "alias": "width";
+      "required": false;
+      "isSignal": true;
+    };
+  }, {}, never, never, true, never>;
+}
+/**
+ * Gives the series without a `type` the type of the component: `stack` /
+ * `curve` apply to the series of that type that do not set their own.
+ */
+export declare const withSeriesType: (series: readonly ChartSeries[], type: ChartSeriesType, stack?: string, curve?: ChartCurve) => ChartSeries[];
+/** Where a dragged MnQuadrantChart point was dropped */
+export interface QuadrantPointDrop {
+  /** The dragged point and its index */
+  point: QuadrantPoint;
+  index: number;
+  /** Data coordinates of the drop */
+  x: number;
+  y: number;
+  /** Quadrant of the drop, as seen on screen */
+  quadrant: QuadrantCorner;
+}
+/**
+ * Base of the cartesian chart components (engine `createChart`): common
+ * inputs, hover / zoom / renderer outputs and the zoom methods.
+ */
+export declare abstract class MnCartesianChartBase extends MnChartEngine<ChartOptions, ChartInstance> {
+  /** Backend of the data layer: `auto` tries WebGPU, then WebGL2, then WebGL, then Canvas2D */
+  readonly renderer: import("@angular/core").InputSignal<ChartRendererPreference | undefined>;
+  /** Legend; shown by default when several series have a name */
+  readonly legend: import("@angular/core").InputSignal<boolean | ChartLegendOptions | undefined>;
+  /** Tooltip; `false` disables it */
+  readonly tooltip: import("@angular/core").InputSignal<boolean | ChartTooltipOptions | undefined>;
+  /** Vertical guide line following the pointer */
+  readonly crosshair: import("@angular/core").InputSignalWithTransform<boolean | undefined, unknown>;
+  /** Background areas and reference lines */
+  readonly annotations: import("@angular/core").InputSignal<readonly ChartAnnotation[] | undefined>;
+  /** Zoom (Ctrl / ⌘ + wheel, pinch), pan, double-click reset and keyboard navigation; `false` makes the chart static */
+  readonly interaction: import("@angular/core").InputSignal<boolean | ChartInteractionOptions | undefined>;
+  /** Space around the plot area, in pixels */
+  readonly padding: import("@angular/core").InputSignal<ChartPadding | undefined>;
+  /** Series colors (defaults to the `--chart-series-1..8` CSS variables, then the theme colors) */
+  readonly palette: import("@angular/core").InputSignal<readonly string[] | undefined>;
+  /** Accessible name of the chart */
+  readonly ariaLabel: import("@angular/core").InputSignal<string | undefined>;
+  /** BCP 47 locale of the texts and numbers the engine writes (tooltip, axes, accessible names); the runtime's default locale by default */
+  readonly locale: import("@angular/core").InputSignal<string | undefined>;
+  /** The hovered (or keyboard-focused) points changed (`null`: none) */
+  readonly hover: import("@angular/core").OutputEmitterRef<ChartHoverEvent | null>;
+  /** The user zoomed or panned */
+  readonly zoom: import("@angular/core").OutputEmitterRef<ChartView>;
+  /** The backend is ready (or fell back after a GPU loss) */
+  readonly rendererChange: import("@angular/core").OutputEmitterRef<ChartRendererKind>;
+  protected createEngine(container: HTMLElement, options: ChartOptions): ChartInstance;
+  protected bindEngine(chart: ChartInstance): Array<() => void>;
+  protected clicked?(event: ChartHoverEvent): void;
+  protected plotClicked?(event: ChartPlotClickEvent): void;
+  protected dropped?(event: ChartDragEvent): void;
+  /** Engine options of the common inputs */
+  protected commonOptions(): Omit<ChartOptions, "series">;
+  /** Shows the whole data range */
+  resetZoom(): void;
+  /** Visible range, `null` before the first render */
+  getView(): ChartView | null;
+  /** Sets the visible range */
+  setView(view: Partial<ChartView>): void;
+  /** Backend in use, `null` until ready */
+  getRenderer(): ChartRendererKind | null;
+  static ɵfac: i0.ɵɵFactoryDeclaration<MnCartesianChartBase, never>;
+  static ɵdir: i0.ɵɵDirectiveDeclaration<MnCartesianChartBase, never, never, {
+    "renderer": {
+      "alias": "renderer";
+      "required": false;
+      "isSignal": true;
+    };
+    "legend": {
+      "alias": "legend";
+      "required": false;
+      "isSignal": true;
+    };
+    "tooltip": {
+      "alias": "tooltip";
+      "required": false;
+      "isSignal": true;
+    };
+    "crosshair": {
+      "alias": "crosshair";
+      "required": false;
+      "isSignal": true;
+    };
+    "annotations": {
+      "alias": "annotations";
+      "required": false;
+      "isSignal": true;
+    };
+    "interaction": {
+      "alias": "interaction";
+      "required": false;
+      "isSignal": true;
+    };
+    "padding": {
+      "alias": "padding";
+      "required": false;
+      "isSignal": true;
+    };
+    "palette": {
+      "alias": "palette";
+      "required": false;
+      "isSignal": true;
+    };
+    "ariaLabel": {
+      "alias": "ariaLabel";
+      "required": false;
+      "isSignal": true;
+    };
+    "locale": {
+      "alias": "locale";
+      "required": false;
+      "isSignal": true;
+    };
+  }, {
+    "hover": "hover";
+    "zoom": "zoom";
+    "rendererChange": "rendererChange";
+  }, never, never, true, never>;
+}
+/** Base of the components drawing series on X / Y axes */
+export declare abstract class MnSeriesChartBase extends MnCartesianChartBase {
+  /** X axis */
+  readonly xAxis: import("@angular/core").InputSignal<ChartAxisOptions | undefined>;
+  /** Y axis */
+  readonly yAxis: import("@angular/core").InputSignal<ChartAxisOptions | undefined>;
+  /** A point (or a bar) was clicked */
+  readonly pointClick: import("@angular/core").OutputEmitterRef<ChartHoverEvent>;
+  /** The plot area was clicked where there is no point */
+  readonly plotClick: import("@angular/core").OutputEmitterRef<ChartPlotClickEvent>;
+  protected clicked(event: ChartHoverEvent): void;
+  protected plotClicked(event: ChartPlotClickEvent): void;
+  protected axesOptions(): Omit<ChartOptions, "series">;
+  static ɵfac: i0.ɵɵFactoryDeclaration<MnSeriesChartBase, never>;
+  static ɵdir: i0.ɵɵDirectiveDeclaration<MnSeriesChartBase, never, never, {
+    "xAxis": {
+      "alias": "xAxis";
+      "required": false;
+      "isSignal": true;
+    };
+    "yAxis": {
+      "alias": "yAxis";
+      "required": false;
+      "isSignal": true;
+    };
+  }, {
+    "pointClick": "pointClick";
+    "plotClick": "plotClick";
+  }, never, never, true, never>;
+}
+/**
+ * GPU chart (WebGPU, then WebGL2, WebGL, Canvas2D) mixing line, area, bar,
+ * scatter, candlestick and heatmap series; zoomable, keyboard accessible
+ * and themed by the Minerva CSS variables (engine of
+ * `minerva-design/charts/core`).
+ */
+export declare class MnChart extends MnSeriesChartBase {
+  /** Data series; each sets its own `type` (line by default) */
+  readonly series: import("@angular/core").InputSignal<readonly ChartSeries[]>;
+  /** `percent` scales every stack to 100% at each x */
+  readonly stackMode: import("@angular/core").InputSignal<"normal" | "percent" | undefined>;
+  /** Right value axis of the series with `yAxis: "right"`; its range is aligned on the left ticks (vertical charts) */
+  readonly yAxis2: import("@angular/core").InputSignal<ChartAxisOptions | undefined>;
+  /** `horizontal` puts the x axis (categories) down the left side and the values along the bottom */
+  readonly orientation: import("@angular/core").InputSignal<ChartOrientation | undefined>;
+  protected engineOptions(): ChartOptions;
+  static ɵfac: i0.ɵɵFactoryDeclaration<MnChart, never>;
+  static ɵcmp: i0.ɵɵComponentDeclaration<MnChart, "mn-chart", never, {
+    "series": {
+      "alias": "series";
+      "required": true;
+      "isSignal": true;
+    };
+    "stackMode": {
+      "alias": "stackMode";
+      "required": false;
+      "isSignal": true;
+    };
+    "yAxis2": {
+      "alias": "yAxis2";
+      "required": false;
+      "isSignal": true;
+    };
+    "orientation": {
+      "alias": "orientation";
+      "required": false;
+      "isSignal": true;
+    };
+  }, {}, never, never, true, never>;
+}
+/** Line (or area) chart; handles millions of points on the GPU */
+export declare class MnLineChart extends MnSeriesChartBase {
+  /** Series drawn as lines (or areas with `area`) unless they set a `type` */
+  readonly series: import("@angular/core").InputSignal<readonly ChartSeries[]>;
+  /** Fills the area under the lines */
+  readonly area: import("@angular/core").InputSignalWithTransform<boolean, unknown>;
+  /** Shape of the lines: straight, smooth (monotone) or steps */
+  readonly curve: import("@angular/core").InputSignal<ChartCurve | undefined>;
+  /** Stacks the series on top of each other */
+  readonly stacked: import("@angular/core").InputSignalWithTransform<boolean, unknown>;
+  /** Scales the stacks to 100% (implies `stacked`) */
+  readonly percent: import("@angular/core").InputSignalWithTransform<boolean, unknown>;
+  protected engineOptions(): ChartOptions;
+  static ɵfac: i0.ɵɵFactoryDeclaration<MnLineChart, never>;
+  static ɵcmp: i0.ɵɵComponentDeclaration<MnLineChart, "mn-line-chart", never, {
+    "series": {
+      "alias": "series";
+      "required": true;
+      "isSignal": true;
+    };
+    "area": {
+      "alias": "area";
+      "required": false;
+      "isSignal": true;
+    };
+    "curve": {
+      "alias": "curve";
+      "required": false;
+      "isSignal": true;
+    };
+    "stacked": {
+      "alias": "stacked";
+      "required": false;
+      "isSignal": true;
+    };
+    "percent": {
+      "alias": "percent";
+      "required": false;
+      "isSignal": true;
+    };
+  }, {}, never, never, true, never>;
+}
+/** Area chart: smooth by default, stacked or 100% stacked */
+export declare class MnAreaChart extends MnSeriesChartBase {
+  /** Series drawn as areas unless they set a `type` */
+  readonly series: import("@angular/core").InputSignal<readonly ChartSeries[]>;
+  /** Shape of the edges: straight, smooth (monotone) or steps */
+  readonly curve: import("@angular/core").InputSignal<ChartCurve>;
+  /** Stacks the areas on top of each other */
+  readonly stacked: import("@angular/core").InputSignalWithTransform<boolean, unknown>;
+  /** Scales the stacks to 100% (implies `stacked`) */
+  readonly percent: import("@angular/core").InputSignalWithTransform<boolean, unknown>;
+  protected engineOptions(): ChartOptions;
+  static ɵfac: i0.ɵɵFactoryDeclaration<MnAreaChart, never>;
+  static ɵcmp: i0.ɵɵComponentDeclaration<MnAreaChart, "mn-area-chart", never, {
+    "series": {
+      "alias": "series";
+      "required": true;
+      "isSignal": true;
+    };
+    "curve": {
+      "alias": "curve";
+      "required": false;
+      "isSignal": true;
+    };
+    "stacked": {
+      "alias": "stacked";
+      "required": false;
+      "isSignal": true;
+    };
+    "percent": {
+      "alias": "percent";
+      "required": false;
+      "isSignal": true;
+    };
+  }, {}, never, never, true, never>;
+}
+/** Bar chart: grouped side by side, stacked or 100% stacked, with optional value labels */
+export declare class MnBarChart extends MnSeriesChartBase {
+  /** Series drawn as bars unless they set a `type` (e.g. a `line` overlay) */
+  readonly series: import("@angular/core").InputSignal<readonly ChartSeries[]>;
+  /** Stacks the bars of every series (otherwise they are grouped side by side) */
+  readonly stacked: import("@angular/core").InputSignalWithTransform<boolean, unknown>;
+  /** Scales the stacks to 100% (implies `stacked`) */
+  readonly percent: import("@angular/core").InputSignalWithTransform<boolean, unknown>;
+  /** Writes the value above every bar */
+  readonly labels: import("@angular/core").InputSignalWithTransform<boolean, unknown>;
+  /** `horizontal` draws the bars from the left, the categories down the left side */
+  readonly orientation: import("@angular/core").InputSignal<ChartOrientation | undefined>;
+  protected engineOptions(): ChartOptions;
+  static ɵfac: i0.ɵɵFactoryDeclaration<MnBarChart, never>;
+  static ɵcmp: i0.ɵɵComponentDeclaration<MnBarChart, "mn-bar-chart", never, {
+    "series": {
+      "alias": "series";
+      "required": true;
+      "isSignal": true;
+    };
+    "stacked": {
+      "alias": "stacked";
+      "required": false;
+      "isSignal": true;
+    };
+    "percent": {
+      "alias": "percent";
+      "required": false;
+      "isSignal": true;
+    };
+    "labels": {
+      "alias": "labels";
+      "required": false;
+      "isSignal": true;
+    };
+    "orientation": {
+      "alias": "orientation";
+      "required": false;
+      "isSignal": true;
+    };
+  }, {}, never, never, true, never>;
+}
+/** Scatter chart: zooms on both axes, hit testing through a spatial index */
+export declare class MnScatterChart extends MnSeriesChartBase {
+  /** Series drawn as dots unless they set a `type` */
+  readonly series: import("@angular/core").InputSignal<readonly ChartSeries[]>;
+  protected engineOptions(): ChartOptions;
+  static ɵfac: i0.ɵɵFactoryDeclaration<MnScatterChart, never>;
+  static ɵcmp: i0.ɵɵComponentDeclaration<MnScatterChart, "mn-scatter-chart", never, {
+    "series": {
+      "alias": "series";
+      "required": true;
+      "isSignal": true;
+    };
+  }, {}, never, never, true, never>;
+}
+/**
+ * Candlestick (OHLC) chart: rising and falling candles, zoomable on the
+ * GPU; data points carry `open`, `high`, `low` and `y` (the close)
+ */
+export declare class MnCandlestickChart extends MnSeriesChartBase {
+  /** Series drawn as candles unless they set a `type` (e.g. a moving average `line`) */
+  readonly series: import("@angular/core").InputSignal<readonly ChartSeries[]>;
+  protected engineOptions(): ChartOptions;
+  static ɵfac: i0.ɵɵFactoryDeclaration<MnCandlestickChart, never>;
+  static ɵcmp: i0.ɵɵComponentDeclaration<MnCandlestickChart, "mn-candlestick-chart", never, {
+    "series": {
+      "alias": "series";
+      "required": true;
+      "isSignal": true;
+    };
+  }, {}, never, never, true, never>;
+}
+/** Heatmap: a grid of cells colored by value (categories or numbers on both axes) */
+export declare class MnHeatmapChart extends MnSeriesChartBase {
+  /** Cells `{ x, y, value }` */
+  readonly data: import("@angular/core").InputSignal<readonly HeatmapCell[]>;
+  /** Column names in order (collected from the data when omitted) */
+  readonly xCategories: import("@angular/core").InputSignal<readonly string[] | undefined>;
+  /** Row names from bottom to top (collected from the data when omitted) */
+  readonly yCategories: import("@angular/core").InputSignal<readonly string[] | undefined>;
+  /** Colors from the lowest to the highest value; a ramp of the first palette color by default */
+  readonly colorScale: import("@angular/core").InputSignal<readonly string[] | undefined>;
+  /** Values at the ends of the color scale; the data range by default */
+  readonly valueRange: import("@angular/core").InputSignal<readonly [number, number] | undefined>;
+  /** Name of the value in the tooltip */
+  readonly name: import("@angular/core").InputSignal<string | undefined>;
+  /** Corner radius of the cells, in pixels */
+  readonly radius: import("@angular/core").InputSignal<number | undefined>;
+  /** Formats the values in the tooltip */
+  readonly format: import("@angular/core").InputSignal<((value: number) => string) | undefined>;
+  protected engineOptions(): ChartOptions;
+  static ɵfac: i0.ɵɵFactoryDeclaration<MnHeatmapChart, never>;
+  static ɵcmp: i0.ɵɵComponentDeclaration<MnHeatmapChart, "mn-heatmap-chart", never, {
+    "data": {
+      "alias": "data";
+      "required": true;
+      "isSignal": true;
+    };
+    "xCategories": {
+      "alias": "xCategories";
+      "required": false;
+      "isSignal": true;
+    };
+    "yCategories": {
+      "alias": "yCategories";
+      "required": false;
+      "isSignal": true;
+    };
+    "colorScale": {
+      "alias": "colorScale";
+      "required": false;
+      "isSignal": true;
+    };
+    "valueRange": {
+      "alias": "valueRange";
+      "required": false;
+      "isSignal": true;
+    };
+    "name": {
+      "alias": "name";
+      "required": false;
+      "isSignal": true;
+    };
+    "radius": {
+      "alias": "radius";
+      "required": false;
+      "isSignal": true;
+    };
+    "format": {
+      "alias": "format";
+      "required": false;
+      "isSignal": true;
+    };
+  }, {}, never, never, true, never>;
+}
+/** Word-sized chart without axes: a trend in a table cell, a KPI card, ... (default height 48) */
+export declare class MnSparkline extends MnCartesianChartBase {
+  /** Values (or `[x, y]` pairs, typed arrays, ...) */
+  readonly data: import("@angular/core").InputSignal<import("../../charts/core.js").ChartSeriesData>;
+  /** How the values are drawn */
+  readonly type: import("@angular/core").InputSignal<"area" | "bar" | "line">;
+  /** Color (any CSS color); the first palette color by default */
+  readonly color: import("@angular/core").InputSignal<string | undefined>;
+  /** Shape of the line (default `smooth`) */
+  readonly curve: import("@angular/core").InputSignal<ChartCurve | undefined>;
+  /** Name shown in the tooltip */
+  readonly name: import("@angular/core").InputSignal<string | undefined>;
+  /** Draws a reference line at this value (e.g. a target or the average) */
+  readonly reference: import("@angular/core").InputSignal<number | undefined>;
+  /** Formats the value in the tooltip */
+  readonly format: import("@angular/core").InputSignal<((value: number) => string) | undefined>;
+  protected defaultHeight(): number;
+  protected engineOptions(): ChartOptions;
+  static ɵfac: i0.ɵɵFactoryDeclaration<MnSparkline, never>;
+  static ɵcmp: i0.ɵɵComponentDeclaration<MnSparkline, "mn-sparkline", never, {
+    "data": {
+      "alias": "data";
+      "required": true;
+      "isSignal": true;
+    };
+    "type": {
+      "alias": "type";
+      "required": false;
+      "isSignal": true;
+    };
+    "color": {
+      "alias": "color";
+      "required": false;
+      "isSignal": true;
+    };
+    "curve": {
+      "alias": "curve";
+      "required": false;
+      "isSignal": true;
+    };
+    "name": {
+      "alias": "name";
+      "required": false;
+      "isSignal": true;
+    };
+    "reference": {
+      "alias": "reference";
+      "required": false;
+      "isSignal": true;
+    };
+    "format": {
+      "alias": "format";
+      "required": false;
+      "isSignal": true;
+    };
+  }, {}, never, never, true, never>;
+}
+/**
+ * Four-quadrant matrix (priority matrix, Eisenhower, BCG, ...): tinted
+ * quadrants with titles, dividers, and labelled dots placed without
+ * overlapping labels. With `draggable`, dots can be dragged to another
+ * quadrant (`pointDrop`; update `points` to move them).
+ */
+export declare class MnQuadrantChart extends MnCartesianChartBase {
+  /** Points to place */
+  readonly points: import("@angular/core").InputSignal<readonly QuadrantPoint[]>;
+  /** Range of the horizontal axis (default `[0, 10]`) */
+  readonly xDomain: import("@angular/core").InputSignal<[number, number] | undefined>;
+  /** Range of the vertical axis (default `[0, 10]`) */
+  readonly yDomain: import("@angular/core").InputSignal<[number, number] | undefined>;
+  /** X value of the vertical divider (the middle of `xDomain` by default) */
+  readonly xSplit: import("@angular/core").InputSignal<number | undefined>;
+  /** Y value of the horizontal divider (the middle of `yDomain` by default) */
+  readonly ySplit: import("@angular/core").InputSignal<number | undefined>;
+  /** Titles and colors of the quadrants */
+  readonly quadrants: import("@angular/core").InputSignal<QuadrantRegions | undefined>;
+  /** Title of the horizontal axis */
+  readonly xLabel: import("@angular/core").InputSignal<string | undefined>;
+  /** Title of the vertical axis */
+  readonly yLabel: import("@angular/core").InputSignal<string | undefined>;
+  /** Texts at the ends of the dividers, drawn inside the plot */
+  readonly axisLabels: import("@angular/core").InputSignal<QuadrantAxisLabels | undefined>;
+  /** Shows the numeric ticks of the axes (default `true`) */
+  readonly showTicks: import("@angular/core").InputSignalWithTransform<boolean | undefined, unknown>;
+  /** Reverses the horizontal axis (e.g. "urgent" on the left) */
+  readonly reverseX: import("@angular/core").InputSignalWithTransform<boolean | undefined, unknown>;
+  /** Draws the labels next to the dots (default `true`) */
+  readonly showLabels: import("@angular/core").InputSignalWithTransform<boolean | undefined, unknown>;
+  /** Dot diameter in pixels (default 12) */
+  readonly pointSize: import("@angular/core").InputSignal<number | undefined>;
+  /** Name of the points in the tooltip */
+  readonly name: import("@angular/core").InputSignal<string | undefined>;
+  /** Lets the user drag the dots (`pointDrop`) */
+  readonly draggable: import("@angular/core").InputSignalWithTransform<boolean, unknown>;
+  /** A point was clicked */
+  readonly pointClick: import("@angular/core").OutputEmitterRef<{
+    point: QuadrantPoint;
+    index: number;
+  }>;
+  /** The empty area of a quadrant was clicked */
+  readonly quadrantClick: import("@angular/core").OutputEmitterRef<{
+    quadrant: QuadrantCorner;
+    x: number;
+    y: number;
+  }>;
+  /** A dragged point was released (the chart does not move it: update `points`) */
+  readonly pointDrop: import("@angular/core").OutputEmitterRef<QuadrantPointDrop>;
+  private geometry;
+  protected engineOptions(): ChartOptions;
+  protected clicked(event: ChartHoverEvent): void;
+  protected plotClicked(event: ChartPlotClickEvent): void;
+  protected dropped(event: ChartDragEvent): void;
+  static ɵfac: i0.ɵɵFactoryDeclaration<MnQuadrantChart, never>;
+  static ɵcmp: i0.ɵɵComponentDeclaration<MnQuadrantChart, "mn-quadrant-chart", never, {
+    "points": {
+      "alias": "points";
+      "required": true;
+      "isSignal": true;
+    };
+    "xDomain": {
+      "alias": "xDomain";
+      "required": false;
+      "isSignal": true;
+    };
+    "yDomain": {
+      "alias": "yDomain";
+      "required": false;
+      "isSignal": true;
+    };
+    "xSplit": {
+      "alias": "xSplit";
+      "required": false;
+      "isSignal": true;
+    };
+    "ySplit": {
+      "alias": "ySplit";
+      "required": false;
+      "isSignal": true;
+    };
+    "quadrants": {
+      "alias": "quadrants";
+      "required": false;
+      "isSignal": true;
+    };
+    "xLabel": {
+      "alias": "xLabel";
+      "required": false;
+      "isSignal": true;
+    };
+    "yLabel": {
+      "alias": "yLabel";
+      "required": false;
+      "isSignal": true;
+    };
+    "axisLabels": {
+      "alias": "axisLabels";
+      "required": false;
+      "isSignal": true;
+    };
+    "showTicks": {
+      "alias": "showTicks";
+      "required": false;
+      "isSignal": true;
+    };
+    "reverseX": {
+      "alias": "reverseX";
+      "required": false;
+      "isSignal": true;
+    };
+    "showLabels": {
+      "alias": "showLabels";
+      "required": false;
+      "isSignal": true;
+    };
+    "pointSize": {
+      "alias": "pointSize";
+      "required": false;
+      "isSignal": true;
+    };
+    "name": {
+      "alias": "name";
+      "required": false;
+      "isSignal": true;
+    };
+    "draggable": {
+      "alias": "draggable";
+      "required": false;
+      "isSignal": true;
+    };
+  }, {
+    "pointClick": "pointClick";
+    "quadrantClick": "quadrantClick";
+    "pointDrop": "pointDrop";
+  }, never, never, true, never>;
+}
+/**
+ * Base of the shape chart components (engine `createShapeChart`): hover,
+ * click and toggle outputs and the `toggle()` method.
+ */
+export declare abstract class MnShapeChartBase extends MnChartEngine<ShapeChartOptions, ShapeChartInstance> {
+  /** The hovered (or keyboard-focused) mark changed (`null`: none) */
+  readonly hover: import("@angular/core").OutputEmitterRef<ShapeHoverEvent | null>;
+  /** A mark (slice, stage, series, cell) was clicked, tapped or activated with Enter */
+  readonly itemClick: import("@angular/core").OutputEmitterRef<ShapeHoverEvent>;
+  /** An entry was hidden or shown (legend click or `toggle()`) */
+  readonly visibilityChange: import("@angular/core").OutputEmitterRef<ShapeToggleEvent>;
+  protected createEngine(container: HTMLElement, options: ShapeChartOptions): ShapeChartInstance;
+  protected bindEngine(chart: ShapeChartInstance): Array<() => void>;
+  /** Hides / shows a slice, stage, radar series or top-level treemap node by index */
+  toggle(index: number): void;
+  static ɵfac: i0.ɵɵFactoryDeclaration<MnShapeChartBase, never>;
+  static ɵdir: i0.ɵɵDirectiveDeclaration<MnShapeChartBase, never, never, {}, {
+    "hover": "hover";
+    "itemClick": "itemClick";
+    "visibilityChange": "visibilityChange";
+  }, never, never, true, never>;
+}
+/** Base of the named shape charts: the inputs shared by every type */
+export declare abstract class MnShapeChartCommon extends MnShapeChartBase {
+  /** Colors of the marks without `color` (defaults to the `--chart-series-1..8` CSS variables, then the theme colors) */
+  readonly palette: import("@angular/core").InputSignal<readonly string[] | undefined>;
+  /** Legend; clicking an item hides / shows its entry (shown by default for pie, donut, funnel and multi-series radar charts) */
+  readonly legend: import("@angular/core").InputSignal<boolean | ShapeLegendOptions | undefined>;
+  /** Tooltip; `false` disables it */
+  readonly tooltip: import("@angular/core").InputSignal<boolean | ShapeTooltipOptions | undefined>;
+  /** Formats the values of the labels and the tooltip (default: compact numbers) */
+  readonly format: import("@angular/core").InputSignal<((value: number) => string) | undefined>;
+  /** Formats the shares (labels, conversion rates, tooltip); `share` is 0-1 */
+  readonly percentFormat: import("@angular/core").InputSignal<((share: number) => string) | undefined>;
+  /** Hidden entries by index; makes the visibility controlled (store the `hiddenIndexes` of `visibilityChange` and pass them back) */
+  readonly hidden: import("@angular/core").InputSignal<readonly number[] | undefined>;
+  /** Entry and update animations (skipped when the user prefers reduced motion) */
+  readonly animation: import("@angular/core").InputSignalWithTransform<boolean | undefined, unknown>;
+  /** Space around the drawing, in pixels (default 8 on every side) */
+  readonly padding: import("@angular/core").InputSignal<ChartPadding | undefined>;
+  /** Accessible name of the chart (default: the chart type) */
+  readonly ariaLabel: import("@angular/core").InputSignal<string | undefined>;
+  /** BCP 47 locale of the texts and numbers the engine writes (tooltip rows, accessible names, compact numbers); the runtime's default locale by default */
+  readonly locale: import("@angular/core").InputSignal<string | undefined>;
+  /** Replaces built-in texts of the `locale` (tooltip rows, accessible names, "No data") */
+  readonly texts: import("@angular/core").InputSignal<Partial<import("../../charts/core.js").ShapeChartLabels> | undefined>;
+  protected commonOptions(): ShapeChartCommonOptions;
+  static ɵfac: i0.ɵɵFactoryDeclaration<MnShapeChartCommon, never>;
+  static ɵdir: i0.ɵɵDirectiveDeclaration<MnShapeChartCommon, never, never, {
+    "palette": {
+      "alias": "palette";
+      "required": false;
+      "isSignal": true;
+    };
+    "legend": {
+      "alias": "legend";
+      "required": false;
+      "isSignal": true;
+    };
+    "tooltip": {
+      "alias": "tooltip";
+      "required": false;
+      "isSignal": true;
+    };
+    "format": {
+      "alias": "format";
+      "required": false;
+      "isSignal": true;
+    };
+    "percentFormat": {
+      "alias": "percentFormat";
+      "required": false;
+      "isSignal": true;
+    };
+    "hidden": {
+      "alias": "hidden";
+      "required": false;
+      "isSignal": true;
+    };
+    "animation": {
+      "alias": "animation";
+      "required": false;
+      "isSignal": true;
+    };
+    "padding": {
+      "alias": "padding";
+      "required": false;
+      "isSignal": true;
+    };
+    "ariaLabel": {
+      "alias": "ariaLabel";
+      "required": false;
+      "isSignal": true;
+    };
+    "locale": {
+      "alias": "locale";
+      "required": false;
+      "isSignal": true;
+    };
+    "texts": {
+      "alias": "texts";
+      "required": false;
+      "isSignal": true;
+    };
+  }, {}, never, never, true, never>;
+}
+/**
+ * Any shape chart of the engine (pie, donut, radar, gauge, funnel, treemap,
+ * sankey, sunburst...), chosen by the `type` of its engine options
+ * (`ShapeChartOptions` of `minerva-design/charts/core`)
+ */
+export declare class MnShapeChart extends MnShapeChartBase {
+  /** Engine options, `type` included (replace the object to update the chart: it animates from the previous values) */
+  readonly options: import("@angular/core").InputSignal<ShapeChartOptions>;
+  protected defaultHeight(): number;
+  protected engineOptions(): ShapeChartOptions;
+  static ɵfac: i0.ɵɵFactoryDeclaration<MnShapeChart, never>;
+  static ɵcmp: i0.ɵɵComponentDeclaration<MnShapeChart, "mn-shape-chart", never, {
+    "options": {
+      "alias": "options";
+      "required": true;
+      "isSignal": true;
+    };
+  }, {}, never, never, true, never>;
+}
+export declare abstract class MnPieBase extends MnShapeChartCommon {
+  /** Slices: a name, a value (negative values count as 0) and an optional color */
+  readonly data: import("@angular/core").InputSignal<readonly ShapeDatum[]>;
+  /** Inner radius as a fraction of the outer radius: 0 = pie, 0.6 = donut */
+  readonly innerRadius: import("@angular/core").InputSignal<number | undefined>;
+  /** Angle of the first slice, degrees clockwise from 12 o'clock */
+  readonly startAngle: import("@angular/core").InputSignal<number | undefined>;
+  /** Gap between the slices, in pixels */
+  readonly padAngle: import("@angular/core").InputSignal<number | undefined>;
+  /** Corner radius of the slices, in pixels */
+  readonly cornerRadius: import("@angular/core").InputSignal<number | undefined>;
+  /** Nightingale rose: the radius (instead of the angle) shows the value */
+  readonly rose: import("@angular/core").InputSignalWithTransform<boolean | undefined, unknown>;
+  /** Slice labels: `outside` with leader lines, `inside` the slices, or none */
+  readonly labels: import("@angular/core").InputSignal<"none" | "outside" | "inside" | undefined>;
+  /** What a label shows: name, value, percent (default name and percent) */
+  readonly labelContent: import("@angular/core").InputSignal<readonly ("value" | "name" | "percent")[] | undefined>;
+  /** Big text in the hole of a donut (e.g. the total) */
+  readonly centerValue: import("@angular/core").InputSignal<string | undefined>;
+  /** Small text under `centerValue` */
+  readonly centerLabel: import("@angular/core").InputSignal<string | undefined>;
+  protected abstract defaultInnerRadius(): number;
+  protected engineOptions(): ShapeChartOptions;
+  static ɵfac: i0.ɵɵFactoryDeclaration<MnPieBase, never>;
+  static ɵdir: i0.ɵɵDirectiveDeclaration<MnPieBase, never, never, {
+    "data": {
+      "alias": "data";
+      "required": true;
+      "isSignal": true;
+    };
+    "innerRadius": {
+      "alias": "innerRadius";
+      "required": false;
+      "isSignal": true;
+    };
+    "startAngle": {
+      "alias": "startAngle";
+      "required": false;
+      "isSignal": true;
+    };
+    "padAngle": {
+      "alias": "padAngle";
+      "required": false;
+      "isSignal": true;
+    };
+    "cornerRadius": {
+      "alias": "cornerRadius";
+      "required": false;
+      "isSignal": true;
+    };
+    "rose": {
+      "alias": "rose";
+      "required": false;
+      "isSignal": true;
+    };
+    "labels": {
+      "alias": "labels";
+      "required": false;
+      "isSignal": true;
+    };
+    "labelContent": {
+      "alias": "labelContent";
+      "required": false;
+      "isSignal": true;
+    };
+    "centerValue": {
+      "alias": "centerValue";
+      "required": false;
+      "isSignal": true;
+    };
+    "centerLabel": {
+      "alias": "centerLabel";
+      "required": false;
+      "isSignal": true;
+    };
+  }, {}, never, never, true, never>;
+}
+/**
+ * Pie chart (or a donut with `innerRadius`, or a Nightingale rose with
+ * `rose`): slices with gaps, outside labels with leader lines, legend toggles.
+ */
+export declare class MnPieChart extends MnPieBase {
+  protected defaultInnerRadius(): number;
+  static ɵfac: i0.ɵɵFactoryDeclaration<MnPieChart, never>;
+  static ɵcmp: i0.ɵɵComponentDeclaration<MnPieChart, "mn-pie-chart", never, {}, {}, never, never, true, never>;
+}
+/** Donut chart: a pie chart with a hole (`innerRadius` 0.62) and optional center texts */
+export declare class MnDonutChart extends MnPieBase {
+  protected defaultInnerRadius(): number;
+  static ɵfac: i0.ɵɵFactoryDeclaration<MnDonutChart, never>;
+  static ɵcmp: i0.ɵɵComponentDeclaration<MnDonutChart, "mn-donut-chart", never, {}, {}, never, never, true, never>;
+}
+/** Radar (spider) chart comparing series over several indicators */
+export declare class MnRadarChart extends MnShapeChartCommon {
+  /** Axes of the chart `{ name, max }`, clockwise from 12 o'clock */
+  readonly indicators: import("@angular/core").InputSignal<readonly RadarIndicator[]>;
+  /** Polygons `{ name, values }`: one value per indicator */
+  readonly series: import("@angular/core").InputSignal<readonly RadarSeries[]>;
+  /** Grid shape */
+  readonly shape: import("@angular/core").InputSignal<"circle" | "polygon" | undefined>;
+  /** Number of grid rings (default 4) */
+  readonly levels: import("@angular/core").InputSignal<number | undefined>;
+  /** Dots on the vertices (default `true`) */
+  readonly dots: import("@angular/core").InputSignalWithTransform<boolean | undefined, unknown>;
+  protected engineOptions(): ShapeChartOptions;
+  static ɵfac: i0.ɵɵFactoryDeclaration<MnRadarChart, never>;
+  static ɵcmp: i0.ɵɵComponentDeclaration<MnRadarChart, "mn-radar-chart", never, {
+    "indicators": {
+      "alias": "indicators";
+      "required": true;
+      "isSignal": true;
+    };
+    "series": {
+      "alias": "series";
+      "required": true;
+      "isSignal": true;
+    };
+    "shape": {
+      "alias": "shape";
+      "required": false;
+      "isSignal": true;
+    };
+    "levels": {
+      "alias": "levels";
+      "required": false;
+      "isSignal": true;
+    };
+    "dots": {
+      "alias": "dots";
+      "required": false;
+      "isSignal": true;
+    };
+  }, {}, never, never, true, never>;
+}
+/** Gauge (speedometer) showing one value on an arc, with colored bands (default height 240) */
+export declare class MnGaugeChart extends MnShapeChartCommon {
+  /** Value shown by the arc (clamped to `min` - `max` for the drawing) */
+  readonly value: import("@angular/core").InputSignal<number>;
+  /** Value at the start of the arc (default 0) */
+  readonly min: import("@angular/core").InputSignal<number | undefined>;
+  /** Value at the end of the arc (default 100) */
+  readonly max: import("@angular/core").InputSignal<number | undefined>;
+  /** Caption under the value */
+  readonly label: import("@angular/core").InputSignal<string | undefined>;
+  /** Total angle of the arc, degrees (default 240) */
+  readonly sweep: import("@angular/core").InputSignal<number | undefined>;
+  /** Thickness of the arc as a fraction of the radius (default 0.16) */
+  readonly thickness: import("@angular/core").InputSignal<number | undefined>;
+  /** Colored ranges of the track; the value arc takes the color of its band */
+  readonly bands: import("@angular/core").InputSignal<readonly GaugeBand[] | undefined>;
+  /** Color of the value arc when there are no bands */
+  readonly color: import("@angular/core").InputSignal<string | undefined>;
+  /** Draws a needle in addition to the value arc */
+  readonly needle: import("@angular/core").InputSignalWithTransform<boolean | undefined, unknown>;
+  /** Tick labels at the ends and at the band bounds (default `true`) */
+  readonly ticks: import("@angular/core").InputSignalWithTransform<boolean | undefined, unknown>;
+  protected defaultHeight(): number;
+  protected engineOptions(): ShapeChartOptions;
+  static ɵfac: i0.ɵɵFactoryDeclaration<MnGaugeChart, never>;
+  static ɵcmp: i0.ɵɵComponentDeclaration<MnGaugeChart, "mn-gauge-chart", never, {
+    "value": {
+      "alias": "value";
+      "required": true;
+      "isSignal": true;
+    };
+    "min": {
+      "alias": "min";
+      "required": false;
+      "isSignal": true;
+    };
+    "max": {
+      "alias": "max";
+      "required": false;
+      "isSignal": true;
+    };
+    "label": {
+      "alias": "label";
+      "required": false;
+      "isSignal": true;
+    };
+    "sweep": {
+      "alias": "sweep";
+      "required": false;
+      "isSignal": true;
+    };
+    "thickness": {
+      "alias": "thickness";
+      "required": false;
+      "isSignal": true;
+    };
+    "bands": {
+      "alias": "bands";
+      "required": false;
+      "isSignal": true;
+    };
+    "color": {
+      "alias": "color";
+      "required": false;
+      "isSignal": true;
+    };
+    "needle": {
+      "alias": "needle";
+      "required": false;
+      "isSignal": true;
+    };
+    "ticks": {
+      "alias": "ticks";
+      "required": false;
+      "isSignal": true;
+    };
+  }, {}, never, never, true, never>;
+}
+/** Funnel chart of the stages of a process, with conversion rates */
+export declare class MnFunnelChart extends MnShapeChartCommon {
+  /** Stages: a name, a value and an optional color */
+  readonly data: import("@angular/core").InputSignal<readonly ShapeDatum[]>;
+  /** Order of the stages (default: the data order) */
+  readonly sort: import("@angular/core").InputSignal<"none" | "ascending" | "descending" | undefined>;
+  /** Vertical gap between the stages, in pixels (default 4) */
+  readonly gap: import("@angular/core").InputSignal<number | undefined>;
+  /** Shows the conversion rate from the previous stage (default `true`) */
+  readonly conversion: import("@angular/core").InputSignalWithTransform<boolean | undefined, unknown>;
+  /** Shape of the stages: trapezoids narrowing to the next stage, or centered bars */
+  readonly shape: import("@angular/core").InputSignal<"bar" | "trapezoid" | undefined>;
+  protected engineOptions(): ShapeChartOptions;
+  static ɵfac: i0.ɵɵFactoryDeclaration<MnFunnelChart, never>;
+  static ɵcmp: i0.ɵɵComponentDeclaration<MnFunnelChart, "mn-funnel-chart", never, {
+    "data": {
+      "alias": "data";
+      "required": true;
+      "isSignal": true;
+    };
+    "sort": {
+      "alias": "sort";
+      "required": false;
+      "isSignal": true;
+    };
+    "gap": {
+      "alias": "gap";
+      "required": false;
+      "isSignal": true;
+    };
+    "conversion": {
+      "alias": "conversion";
+      "required": false;
+      "isSignal": true;
+    };
+    "shape": {
+      "alias": "shape";
+      "required": false;
+      "isSignal": true;
+    };
+  }, {}, never, never, true, never>;
+}
+/** Treemap: nested rectangles of areas proportional to the values */
+export declare class MnTreemapChart extends MnShapeChartCommon {
+  /** Nodes `{ name, value, children }`: leaves carry a value, parents sum their children */
+  readonly data: import("@angular/core").InputSignal<readonly TreemapNode[]>;
+  /** Gap between the cells, in pixels (default 2) */
+  readonly gap: import("@angular/core").InputSignal<number | undefined>;
+  /** Draws the names of the parents above their children (default `true`) */
+  readonly headers: import("@angular/core").InputSignalWithTransform<boolean | undefined, unknown>;
+  protected engineOptions(): ShapeChartOptions;
+  static ɵfac: i0.ɵɵFactoryDeclaration<MnTreemapChart, never>;
+  static ɵcmp: i0.ɵɵComponentDeclaration<MnTreemapChart, "mn-treemap-chart", never, {
+    "data": {
+      "alias": "data";
+      "required": true;
+      "isSignal": true;
+    };
+    "gap": {
+      "alias": "gap";
+      "required": false;
+      "isSignal": true;
+    };
+    "headers": {
+      "alias": "headers";
+      "required": false;
+      "isSignal": true;
+    };
+  }, {}, never, never, true, never>;
+}
+/**
+ * Horizontal bar chart: categories down the left side, values from the
+ * left (rankings, long names, diverging surveys, stacked progress)
+ */
+export declare class MnHorizontalBarChart extends MnSeriesChartBase {
+  /** Series drawn as bars from the left unless they set a `type`; the x values (categories) run from top to bottom */
+  readonly series: import("@angular/core").InputSignal<readonly ChartSeries[]>;
+  /** Stacks the bars of every series (otherwise they are grouped side by side) */
+  readonly stacked: import("@angular/core").InputSignalWithTransform<boolean, unknown>;
+  /** Scales the stacks to 100% (implies `stacked`) */
+  readonly percent: import("@angular/core").InputSignalWithTransform<boolean, unknown>;
+  /** Writes the value at the end of every bar */
+  readonly labels: import("@angular/core").InputSignalWithTransform<boolean, unknown>;
+  protected engineOptions(): ChartOptions;
+  static ɵfac: i0.ɵɵFactoryDeclaration<MnHorizontalBarChart, never>;
+  static ɵcmp: i0.ɵɵComponentDeclaration<MnHorizontalBarChart, "mn-horizontal-bar-chart", never, {
+    "series": {
+      "alias": "series";
+      "required": true;
+      "isSignal": true;
+    };
+    "stacked": {
+      "alias": "stacked";
+      "required": false;
+      "isSignal": true;
+    };
+    "percent": {
+      "alias": "percent";
+      "required": false;
+      "isSignal": true;
+    };
+    "labels": {
+      "alias": "labels";
+      "required": false;
+      "isSignal": true;
+    };
+  }, {}, never, never, true, never>;
+}
+/**
+ * Range area chart: bands between a lower (`y0`) and an upper edge
+ * (confidence intervals, min-max ranges), mixable with lines
+ */
+export declare class MnRangeAreaChart extends MnSeriesChartBase {
+  /** Bands between `y0` (lower edge) and `y` (upper edge) of every point, unless a series sets a `type` */
+  readonly series: import("@angular/core").InputSignal<readonly ChartSeries[]>;
+  /** Shape of the edges: straight, smooth (monotone) or steps */
+  readonly curve: import("@angular/core").InputSignal<ChartCurve>;
+  protected engineOptions(): ChartOptions;
+  static ɵfac: i0.ɵɵFactoryDeclaration<MnRangeAreaChart, never>;
+  static ɵcmp: i0.ɵɵComponentDeclaration<MnRangeAreaChart, "mn-range-area-chart", never, {
+    "series": {
+      "alias": "series";
+      "required": true;
+      "isSignal": true;
+    };
+    "curve": {
+      "alias": "curve";
+      "required": false;
+      "isSignal": true;
+    };
+  }, {}, never, never, true, never>;
+}
+/**
+ * Combination chart: bars, lines and areas on one or two value axes
+ * (`yAxis: "right"` series use `yAxis2`, aligned on the left grid)
+ */
+export declare class MnMixedChart extends MnSeriesChartBase {
+  /** Bars, lines, areas and dots, each with its `type` (line by default) */
+  readonly series: import("@angular/core").InputSignal<readonly ChartSeries[]>;
+  /** Right value axis of the series with `yAxis: "right"` */
+  readonly yAxis2: import("@angular/core").InputSignal<ChartAxisOptions | undefined>;
+  /** `percent` scales every stack to 100% at each x */
+  readonly stackMode: import("@angular/core").InputSignal<"normal" | "percent" | undefined>;
+  /** `horizontal` puts the x axis (categories) down the left side */
+  readonly orientation: import("@angular/core").InputSignal<ChartOrientation | undefined>;
+  protected engineOptions(): ChartOptions;
+  static ɵfac: i0.ɵɵFactoryDeclaration<MnMixedChart, never>;
+  static ɵcmp: i0.ɵɵComponentDeclaration<MnMixedChart, "mn-mixed-chart", never, {
+    "series": {
+      "alias": "series";
+      "required": true;
+      "isSignal": true;
+    };
+    "yAxis2": {
+      "alias": "yAxis2";
+      "required": false;
+      "isSignal": true;
+    };
+    "stackMode": {
+      "alias": "stackMode";
+      "required": false;
+      "isSignal": true;
+    };
+    "orientation": {
+      "alias": "orientation";
+      "required": false;
+      "isSignal": true;
+    };
+  }, {}, never, never, true, never>;
+}
+/** Bubble chart: x, y and a value sized by area (√value diameters) */
+export declare class MnBubbleChart extends MnSeriesChartBase {
+  /** Series of points with a `value` sizing their bubble (area ∝ value) */
+  readonly series: import("@angular/core").InputSignal<readonly ChartSeries[]>;
+  /** Diameter in pixels of the smallest bubbles (default 6) */
+  readonly minSize: import("@angular/core").InputSignal<number | undefined>;
+  /** Diameter in pixels of the largest value (default 48) */
+  readonly maxSize: import("@angular/core").InputSignal<number | undefined>;
+  /** Value drawn with `maxSize` (share a scale between charts); the largest value by default */
+  readonly maxValue: import("@angular/core").InputSignal<number | undefined>;
+  protected engineOptions(): ChartOptions;
+  static ɵfac: i0.ɵɵFactoryDeclaration<MnBubbleChart, never>;
+  static ɵcmp: i0.ɵɵComponentDeclaration<MnBubbleChart, "mn-bubble-chart", never, {
+    "series": {
+      "alias": "series";
+      "required": true;
+      "isSignal": true;
+    };
+    "minSize": {
+      "alias": "minSize";
+      "required": false;
+      "isSignal": true;
+    };
+    "maxSize": {
+      "alias": "maxSize";
+      "required": false;
+      "isSignal": true;
+    };
+    "maxValue": {
+      "alias": "maxValue";
+      "required": false;
+      "isSignal": true;
+    };
+  }, {}, never, never, true, never>;
+}
+/**
+ * Histogram: the distribution of raw samples in bins of equal width
+ * (Freedman-Diaconis, Sturges or a count); millions of samples are binned
+ * in milliseconds
+ */
+export declare class MnHistogramChart extends MnSeriesChartBase {
+  /** Raw samples (typed arrays are counted without copies) */
+  readonly values: import("@angular/core").InputSignal<ArrayLike<number>>;
+  /** Number of bins, or the rule choosing it (default `auto`) */
+  readonly bins: import("@angular/core").InputSignal<HistogramBinning | undefined>;
+  /** Range covered by the bins; the data range by default */
+  readonly domain: import("@angular/core").InputSignal<readonly [number, number] | undefined>;
+  /** Rounds the bin width to 1, 2 or 5 × 10^k and aligns the edges on it */
+  readonly nice: import("@angular/core").InputSignalWithTransform<boolean, unknown>;
+  /** Name of the counts (legend, tooltip; default "Count") */
+  readonly name: import("@angular/core").InputSignal<string | undefined>;
+  /** Bar color (any CSS color) */
+  readonly color: import("@angular/core").InputSignal<string | undefined>;
+  /** Formats the edges of the bins in the tooltip */
+  readonly formatBin: import("@angular/core").InputSignal<((value: number) => string) | undefined>;
+  /** More series drawn over the bins (e.g. a density `line`) */
+  readonly series: import("@angular/core").InputSignal<readonly ChartSeries[] | undefined>;
+  protected engineOptions(): ChartOptions;
+  static ɵfac: i0.ɵɵFactoryDeclaration<MnHistogramChart, never>;
+  static ɵcmp: i0.ɵɵComponentDeclaration<MnHistogramChart, "mn-histogram-chart", never, {
+    "values": {
+      "alias": "values";
+      "required": true;
+      "isSignal": true;
+    };
+    "bins": {
+      "alias": "bins";
+      "required": false;
+      "isSignal": true;
+    };
+    "domain": {
+      "alias": "domain";
+      "required": false;
+      "isSignal": true;
+    };
+    "nice": {
+      "alias": "nice";
+      "required": false;
+      "isSignal": true;
+    };
+    "name": {
+      "alias": "name";
+      "required": false;
+      "isSignal": true;
+    };
+    "color": {
+      "alias": "color";
+      "required": false;
+      "isSignal": true;
+    };
+    "formatBin": {
+      "alias": "formatBin";
+      "required": false;
+      "isSignal": true;
+    };
+    "series": {
+      "alias": "series";
+      "required": false;
+      "isSignal": true;
+    };
+  }, {}, never, never, true, never>;
+}
+/**
+ * Box plot: medians, quartiles, whiskers and outliers of samples, from raw
+ * values (`groups`) or computed statistics (`series`)
+ */
+export declare class MnBoxPlotChart extends MnSeriesChartBase {
+  /** Series of box plots: points with `low`, `q1`, `y` (the median), `q3`, `high` and `outliers` */
+  readonly series: import("@angular/core").InputSignal<readonly ChartSeries[] | undefined>;
+  /** Raw samples, one box each (an alternative to `series`) */
+  readonly groups: import("@angular/core").InputSignal<readonly BoxplotGroup[] | undefined>;
+  /** Name of the series built from `groups` */
+  readonly name: import("@angular/core").InputSignal<string>;
+  /** Reach of the whiskers in interquartile ranges (Tukey: 1.5), or `minmax` */
+  readonly whisker: import("@angular/core").InputSignal<number | "minmax" | undefined>;
+  /** `horizontal` lays the boxes out in rows */
+  readonly orientation: import("@angular/core").InputSignal<ChartOrientation | undefined>;
+  protected engineOptions(): ChartOptions | null;
+  static ɵfac: i0.ɵɵFactoryDeclaration<MnBoxPlotChart, never>;
+  static ɵcmp: i0.ɵɵComponentDeclaration<MnBoxPlotChart, "mn-box-plot-chart", never, {
+    "series": {
+      "alias": "series";
+      "required": false;
+      "isSignal": true;
+    };
+    "groups": {
+      "alias": "groups";
+      "required": false;
+      "isSignal": true;
+    };
+    "name": {
+      "alias": "name";
+      "required": false;
+      "isSignal": true;
+    };
+    "whisker": {
+      "alias": "whisker";
+      "required": false;
+      "isSignal": true;
+    };
+    "orientation": {
+      "alias": "orientation";
+      "required": false;
+      "isSignal": true;
+    };
+  }, {}, never, never, true, never>;
+}
+/**
+ * Waterfall (bridge) chart: how changes take a value from a start to an
+ * end, with subtotals and totals (P&L bridges, budget variances)
+ */
+export declare class MnWaterfallChart extends MnSeriesChartBase {
+  /** Changes, subtotals and totals `{ label, value, kind, color }`, in order */
+  readonly steps: import("@angular/core").InputSignal<readonly WaterfallStep[]>;
+  /** Name of the series (tooltip; default "Change") */
+  readonly name: import("@angular/core").InputSignal<string | undefined>;
+  /** Color of the increases (the success color by default) */
+  readonly upColor: import("@angular/core").InputSignal<string | undefined>;
+  /** Color of the decreases (the danger color by default) */
+  readonly downColor: import("@angular/core").InputSignal<string | undefined>;
+  /** Color of the totals and subtotals (the primary color by default) */
+  readonly totalColor: import("@angular/core").InputSignal<string | undefined>;
+  /** Value the first change starts from (default 0) */
+  readonly start: import("@angular/core").InputSignal<number | undefined>;
+  /** Writes the change (or the total) at the end of every bar */
+  readonly labels: import("@angular/core").InputSignalWithTransform<boolean, unknown>;
+  /** Formats the values (labels, tooltip) */
+  readonly format: import("@angular/core").InputSignal<((value: number) => string) | undefined>;
+  /** `horizontal` lays the steps out in rows */
+  readonly orientation: import("@angular/core").InputSignal<ChartOrientation | undefined>;
+  protected engineOptions(): ChartOptions;
+  static ɵfac: i0.ɵɵFactoryDeclaration<MnWaterfallChart, never>;
+  static ɵcmp: i0.ɵɵComponentDeclaration<MnWaterfallChart, "mn-waterfall-chart", never, {
+    "steps": {
+      "alias": "steps";
+      "required": true;
+      "isSignal": true;
+    };
+    "name": {
+      "alias": "name";
+      "required": false;
+      "isSignal": true;
+    };
+    "upColor": {
+      "alias": "upColor";
+      "required": false;
+      "isSignal": true;
+    };
+    "downColor": {
+      "alias": "downColor";
+      "required": false;
+      "isSignal": true;
+    };
+    "totalColor": {
+      "alias": "totalColor";
+      "required": false;
+      "isSignal": true;
+    };
+    "start": {
+      "alias": "start";
+      "required": false;
+      "isSignal": true;
+    };
+    "labels": {
+      "alias": "labels";
+      "required": false;
+      "isSignal": true;
+    };
+    "format": {
+      "alias": "format";
+      "required": false;
+      "isSignal": true;
+    };
+    "orientation": {
+      "alias": "orientation";
+      "required": false;
+      "isSignal": true;
+    };
+  }, {}, never, never, true, never>;
+}
+/**
+ * Gantt chart: tasks as bars on a time axis with their progress, groups,
+ * milestones and a today line; zooms and pans along the time
+ */
+export declare class MnGanttChart extends MnSeriesChartBase {
+  /** Tasks and milestones `{ name, start, end, progress, group, color, milestone }`, from top to bottom */
+  readonly tasks: import("@angular/core").InputSignal<readonly GanttTask[]>;
+  /** Colors of the groups in order of appearance; the chart palette by default */
+  readonly colors: import("@angular/core").InputSignal<readonly string[] | undefined>;
+  /** Name of the tasks without a group (default "Tasks") */
+  readonly taskName: import("@angular/core").InputSignal<string | undefined>;
+  /** Name of the progress bars (legend, tooltip; default "Progress") */
+  readonly progressName: import("@angular/core").InputSignal<string | undefined>;
+  /** Name of the milestones (legend, tooltip; default "Milestones") */
+  readonly milestoneName: import("@angular/core").InputSignal<string | undefined>;
+  /** Formats the progress shares (tooltip; default "60%") */
+  readonly formatProgress: import("@angular/core").InputSignal<((share: number) => string) | undefined>;
+  /** Draws a line at this date (`true`: now) */
+  readonly today: import("@angular/core").InputSignal<number | boolean | Date>;
+  /** Label of the today line */
+  readonly todayLabel: import("@angular/core").InputSignal<string | undefined>;
+  private readonly mountedAt;
+  protected engineOptions(): ChartOptions;
+  static ɵfac: i0.ɵɵFactoryDeclaration<MnGanttChart, never>;
+  static ɵcmp: i0.ɵɵComponentDeclaration<MnGanttChart, "mn-gantt-chart", never, {
+    "tasks": {
+      "alias": "tasks";
+      "required": true;
+      "isSignal": true;
+    };
+    "colors": {
+      "alias": "colors";
+      "required": false;
+      "isSignal": true;
+    };
+    "taskName": {
+      "alias": "taskName";
+      "required": false;
+      "isSignal": true;
+    };
+    "progressName": {
+      "alias": "progressName";
+      "required": false;
+      "isSignal": true;
+    };
+    "milestoneName": {
+      "alias": "milestoneName";
+      "required": false;
+      "isSignal": true;
+    };
+    "formatProgress": {
+      "alias": "formatProgress";
+      "required": false;
+      "isSignal": true;
+    };
+    "today": {
+      "alias": "today";
+      "required": false;
+      "isSignal": true;
+    };
+    "todayLabel": {
+      "alias": "todayLabel";
+      "required": false;
+      "isSignal": true;
+    };
+  }, {}, never, never, true, never>;
+}
+/**
+ * Sankey diagram: flows between nodes in columns, link thickness
+ * proportional to the flow; hovering a node or a link highlights its flows
+ */
+export declare class MnSankeyChart extends MnShapeChartCommon {
+  /** Nodes, in their initial order; nodes only named by a link are appended */
+  readonly nodes: import("@angular/core").InputSignal<readonly SankeyNode[] | undefined>;
+  /** Flows between the nodes (by name or index); links closing a cycle are ignored */
+  readonly links: import("@angular/core").InputSignal<readonly SankeyLink[]>;
+  /** Width of the node bars, in pixels (default 12) */
+  readonly nodeWidth: import("@angular/core").InputSignal<number | undefined>;
+  /** Vertical gap between the nodes of a column, in pixels (default 12) */
+  readonly nodePadding: import("@angular/core").InputSignal<number | undefined>;
+  /** Column of the nodes without a `column` (default `justify`) */
+  readonly align: import("@angular/core").InputSignal<"left" | "right" | "center" | "justify" | undefined>;
+  /** Color of the links without `color` (default `gradient`) */
+  readonly linkColor: import("@angular/core").InputSignal<"source" | "neutral" | "gradient" | "target" | undefined>;
+  /** Opacity of the links, 0-1 (default 0.4) */
+  readonly linkOpacity: import("@angular/core").InputSignal<number | undefined>;
+  /** Node labels (default `true`) */
+  readonly labels: import("@angular/core").InputSignalWithTransform<boolean | undefined, unknown>;
+  protected defaultHeight(): number;
+  protected engineOptions(): ShapeChartOptions;
+  static ɵfac: i0.ɵɵFactoryDeclaration<MnSankeyChart, never>;
+  static ɵcmp: i0.ɵɵComponentDeclaration<MnSankeyChart, "mn-sankey-chart", never, {
+    "nodes": {
+      "alias": "nodes";
+      "required": false;
+      "isSignal": true;
+    };
+    "links": {
+      "alias": "links";
+      "required": true;
+      "isSignal": true;
+    };
+    "nodeWidth": {
+      "alias": "nodeWidth";
+      "required": false;
+      "isSignal": true;
+    };
+    "nodePadding": {
+      "alias": "nodePadding";
+      "required": false;
+      "isSignal": true;
+    };
+    "align": {
+      "alias": "align";
+      "required": false;
+      "isSignal": true;
+    };
+    "linkColor": {
+      "alias": "linkColor";
+      "required": false;
+      "isSignal": true;
+    };
+    "linkOpacity": {
+      "alias": "linkOpacity";
+      "required": false;
+      "isSignal": true;
+    };
+    "labels": {
+      "alias": "labels";
+      "required": false;
+      "isSignal": true;
+    };
+  }, {}, never, never, true, never>;
+}
+/**
+ * Sunburst chart: a hierarchy as concentric rings; clicking a parent zooms
+ * into it, clicking the center goes back up
+ */
+export declare class MnSunburstChart extends MnShapeChartCommon {
+  /** Nodes `{ name, value, children }`: leaves carry a value, parents sum their children */
+  readonly data: import("@angular/core").InputSignal<readonly TreemapNode[]>;
+  /** Radius of the center circle as a fraction of the outer radius (default 0.26) */
+  readonly innerRadius: import("@angular/core").InputSignal<number | undefined>;
+  /** Rings shown at once below the focused node (default: every level) */
+  readonly levels: import("@angular/core").InputSignal<number | undefined>;
+  /** Sector labels along the arc or the radius (default `auto`) */
+  readonly labels: import("@angular/core").InputSignal<"auto" | "none" | "tangential" | "radial" | undefined>;
+  /** Clicking a parent zooms into it, the center goes back up (default `true`) */
+  readonly drillDown: import("@angular/core").InputSignalWithTransform<boolean | undefined, unknown>;
+  /** Names from the root to the focused node (`[]`: the root); makes the drill-down controlled */
+  readonly drillPath: import("@angular/core").InputSignal<readonly string[] | undefined>;
+  /** A parent or the center was clicked (or `drill()` was called) */
+  readonly drillChange: import("@angular/core").OutputEmitterRef<ShapeDrillEvent>;
+  protected defaultHeight(): number;
+  protected bindEngine(chart: ShapeChartInstance): Array<() => void>;
+  /** Zooms into the node at `path` (names from the root, `[]`: the root) */
+  drill(path: readonly string[]): void;
+  protected engineOptions(): ShapeChartOptions;
+  static ɵfac: i0.ɵɵFactoryDeclaration<MnSunburstChart, never>;
+  static ɵcmp: i0.ɵɵComponentDeclaration<MnSunburstChart, "mn-sunburst-chart", never, {
+    "data": {
+      "alias": "data";
+      "required": true;
+      "isSignal": true;
+    };
+    "innerRadius": {
+      "alias": "innerRadius";
+      "required": false;
+      "isSignal": true;
+    };
+    "levels": {
+      "alias": "levels";
+      "required": false;
+      "isSignal": true;
+    };
+    "labels": {
+      "alias": "labels";
+      "required": false;
+      "isSignal": true;
+    };
+    "drillDown": {
+      "alias": "drillDown";
+      "required": false;
+      "isSignal": true;
+    };
+    "drillPath": {
+      "alias": "drillPath";
+      "required": false;
+      "isSignal": true;
+    };
+  }, {
+    "drillChange": "drillChange";
+  }, never, never, true, never>;
+}
+/** Radial bar chart: concentric progress rings (activity rings, KPI completion) */
+export declare class MnRadialBarChart extends MnShapeChartCommon {
+  /** Bars `{ name, value, max, color }`, from the outermost ring inward */
+  readonly data: import("@angular/core").InputSignal<readonly RadialBarDatum[]>;
+  /** Value of a full bar for the data without `max` (default: the largest value) */
+  readonly max: import("@angular/core").InputSignal<number | undefined>;
+  /** Radius of the innermost ring's inner edge, as a fraction of the outer radius (default 0.3) */
+  readonly innerRadius: import("@angular/core").InputSignal<number | undefined>;
+  /** Angle of a full bar, degrees; 360 = full rings (default 270) */
+  readonly sweep: import("@angular/core").InputSignal<number | undefined>;
+  /** Labels before the start of the bars (default: when `sweep` leaves room) */
+  readonly labels: import("@angular/core").InputSignalWithTransform<boolean | undefined, unknown>;
+  /** Big text in the center (e.g. the overall completion) */
+  readonly centerValue: import("@angular/core").InputSignal<string | undefined>;
+  /** Small text under `centerValue` */
+  readonly centerLabel: import("@angular/core").InputSignal<string | undefined>;
+  protected defaultHeight(): number;
+  protected engineOptions(): ShapeChartOptions;
+  static ɵfac: i0.ɵɵFactoryDeclaration<MnRadialBarChart, never>;
+  static ɵcmp: i0.ɵɵComponentDeclaration<MnRadialBarChart, "mn-radial-bar-chart", never, {
+    "data": {
+      "alias": "data";
+      "required": true;
+      "isSignal": true;
+    };
+    "max": {
+      "alias": "max";
+      "required": false;
+      "isSignal": true;
+    };
+    "innerRadius": {
+      "alias": "innerRadius";
+      "required": false;
+      "isSignal": true;
+    };
+    "sweep": {
+      "alias": "sweep";
+      "required": false;
+      "isSignal": true;
+    };
+    "labels": {
+      "alias": "labels";
+      "required": false;
+      "isSignal": true;
+    };
+    "centerValue": {
+      "alias": "centerValue";
+      "required": false;
+      "isSignal": true;
+    };
+    "centerLabel": {
+      "alias": "centerLabel";
+      "required": false;
+      "isSignal": true;
+    };
+  }, {}, never, never, true, never>;
+}
+/** Calendar heatmap: daily values on a calendar, contributions-style */
+export declare class MnCalendarHeatmap extends MnShapeChartCommon {
+  /** Daily values `{ date, value }` (several entries of the same day add up) */
+  readonly data: import("@angular/core").InputSignal<readonly CalendarDatum[]>;
+  /** Days shown: a year (`2026`) or an inclusive `[start, end]` range (default: the 53 weeks ending on the last day of the data) */
+  readonly range: import("@angular/core").InputSignal<number | readonly [CalendarDate, CalendarDate] | undefined>;
+  /** `weeks`: a column per week; `months`: a small calendar per month (default `weeks`) */
+  readonly layout: import("@angular/core").InputSignal<"weeks" | "months" | undefined>;
+  /** First day of the week, 0 = Sunday … 6 = Saturday (default: from `locale`) */
+  readonly weekStart: import("@angular/core").InputSignal<number | undefined>;
+  /** Color of the highest level (default: the first palette color) */
+  readonly color: import("@angular/core").InputSignal<string | undefined>;
+  /** Colors of the levels, lowest first (replaces `color`) */
+  readonly colors: import("@angular/core").InputSignal<readonly string[] | undefined>;
+  /** Number of color levels above the empty days (default 4) */
+  readonly levels: import("@angular/core").InputSignal<number | undefined>;
+  /** Upper bounds of the levels but the last, ascending */
+  readonly thresholds: import("@angular/core").InputSignal<readonly number[] | undefined>;
+  protected defaultHeight(): number;
+  protected engineOptions(): ShapeChartOptions;
+  static ɵfac: i0.ɵɵFactoryDeclaration<MnCalendarHeatmap, never>;
+  static ɵcmp: i0.ɵɵComponentDeclaration<MnCalendarHeatmap, "mn-calendar-heatmap", never, {
+    "data": {
+      "alias": "data";
+      "required": true;
+      "isSignal": true;
+    };
+    "range": {
+      "alias": "range";
+      "required": false;
+      "isSignal": true;
+    };
+    "layout": {
+      "alias": "layout";
+      "required": false;
+      "isSignal": true;
+    };
+    "weekStart": {
+      "alias": "weekStart";
+      "required": false;
+      "isSignal": true;
+    };
+    "color": {
+      "alias": "color";
+      "required": false;
+      "isSignal": true;
+    };
+    "colors": {
+      "alias": "colors";
+      "required": false;
+      "isSignal": true;
+    };
+    "levels": {
+      "alias": "levels";
+      "required": false;
+      "isSignal": true;
+    };
+    "thresholds": {
+      "alias": "thresholds";
+      "required": false;
+      "isSignal": true;
+    };
+  }, {}, never, never, true, never>;
+}
+/** Bullet chart: KPI bars against qualitative ranges and a target marker */
+export declare class MnBulletChart extends MnShapeChartCommon {
+  /** Rows `{ name, value, target, ranges, max }` (columns when vertical) */
+  readonly data: import("@angular/core").InputSignal<readonly BulletDatum[]>;
+  /** Horizontal rows or vertical columns (default `horizontal`) */
+  readonly orientation: import("@angular/core").InputSignal<"horizontal" | "vertical" | undefined>;
+  /** Qualitative ranges of the rows without `ranges`: upper bounds, ascending */
+  readonly ranges: import("@angular/core").InputSignal<readonly number[] | undefined>;
+  /** Names of the qualitative ranges, lowest first (tooltip) */
+  readonly rangeLabels: import("@angular/core").InputSignal<readonly string[] | undefined>;
+  /** Colors of the qualitative ranges, lowest first */
+  readonly rangeColors: import("@angular/core").InputSignal<readonly string[] | undefined>;
+  /** Color of the target markers (default: the text color) */
+  readonly targetColor: import("@angular/core").InputSignal<string | undefined>;
+  protected defaultHeight(): number;
+  protected engineOptions(): ShapeChartOptions;
+  static ɵfac: i0.ɵɵFactoryDeclaration<MnBulletChart, never>;
+  static ɵcmp: i0.ɵɵComponentDeclaration<MnBulletChart, "mn-bullet-chart", never, {
+    "data": {
+      "alias": "data";
+      "required": true;
+      "isSignal": true;
+    };
+    "orientation": {
+      "alias": "orientation";
+      "required": false;
+      "isSignal": true;
+    };
+    "ranges": {
+      "alias": "ranges";
+      "required": false;
+      "isSignal": true;
+    };
+    "rangeLabels": {
+      "alias": "rangeLabels";
+      "required": false;
+      "isSignal": true;
+    };
+    "rangeColors": {
+      "alias": "rangeColors";
+      "required": false;
+      "isSignal": true;
+    };
+    "targetColor": {
+      "alias": "targetColor";
+      "required": false;
+      "isSignal": true;
+    };
+  }, {}, never, never, true, never>;
+}
+/** Trades of `MnTimeAndSales` and `MnOrderBookHeatmap`, oldest first */
+export type ChartTrades = Parameters<TimeAndSalesInstance["setTrades"]>[0];
+/**
+ * Professional trading chart: candles (hollow, Heikin-Ashi, bars, line,
+ * area, baseline) over a gap-free time axis, indicator panes, drawing
+ * tools, order lines and real-time streaming, drawn on the GPU (engine
+ * `createTradingChart`). Stream ticks with `update(bar)`.
+ */
+export declare class MnTradingChart extends MnChartEngine<TradingChartOptions, TradingChartInstance> {
+  /** Bars, oldest first; replaced when a new array / object is passed */
+  readonly bars: import("@angular/core").InputSignal<TradingBarsInput | undefined>;
+  /** Name shown in the legend and the accessible label (`"BTC/USDT"`) */
+  readonly symbol: import("@angular/core").InputSignal<string | undefined>;
+  /** Duration of a bar; inferred from the bar times by default */
+  readonly timeframe: import("@angular/core").InputSignal<TradingTimeframe | undefined>;
+  /** How the bars are drawn (default `candles`) */
+  readonly chartStyle: import("@angular/core").InputSignal<TradingChartStyle | undefined>;
+  /** Indicators, over the price or in panes below it, in this order */
+  readonly indicators: import("@angular/core").InputSignal<readonly TradingIndicator[] | undefined>;
+  /** Locale of the texts, numbers and dates (`"zh-CN"`); the page language by default */
+  readonly locale: import("@angular/core").InputSignal<string | undefined>;
+  /** Other engine options (`TradingChartOptions`: markers, priceLines, drawings, colorConvention, labels...) */
+  readonly options: import("@angular/core").InputSignal<Partial<TradingChartOptions> | undefined>;
+  /** The crosshair moved (`null` when it left the chart) */
+  readonly crosshairMove: import("@angular/core").OutputEmitterRef<TradingCrosshairEvent | null>;
+  /** A pane was clicked */
+  readonly paneClick: import("@angular/core").OutputEmitterRef<TradingClickEvent>;
+  /** The visible bars changed */
+  readonly visibleRangeChange: import("@angular/core").OutputEmitterRef<TradingVisibleRange>;
+  /** A draggable price line was dropped at a new price */
+  readonly orderMove: import("@angular/core").OutputEmitterRef<TradingOrderMoveEvent>;
+  /** The user added, moved or deleted drawings (pass them back in `options.drawings`) */
+  readonly drawingsChange: import("@angular/core").OutputEmitterRef<readonly TradingDrawing[]>;
+  /** The selected drawing changed */
+  readonly drawingSelect: import("@angular/core").OutputEmitterRef<string | null>;
+  /** The drawing tool changed (back to `cursor` after a drawing) */
+  readonly drawingToolChange: import("@angular/core").OutputEmitterRef<TradingDrawingTool>;
+  /** An indicator was shown or hidden from its legend */
+  readonly indicatorToggle: import("@angular/core").OutputEmitterRef<TradingIndicatorToggleEvent>;
+  /** The oldest bar came into view: load older bars (`prependBars`) */
+  readonly historyRequest: import("@angular/core").OutputEmitterRef<TradingHistoryRequestEvent>;
+  /** The backend in use (again after a fallback) */
+  readonly rendererChange: import("@angular/core").OutputEmitterRef<ChartRendererKind>;
+  protected defaultHeight(): number;
+  protected createEngine(container: HTMLElement, options: TradingChartOptions): TradingChartInstance;
+  protected engineOptions(): TradingChartOptions;
+  protected bindEngine(chart: TradingChartInstance): (() => void)[];
+  /** Streams a bar: the time of the last bar replaces it, a later time appends it (cheap: call it on every tick) */
+  update(bar: TradingBar): void;
+  /** Appends bars newer than the last one */
+  appendBars(bars: TradingBarsInput): void;
+  /** Inserts older bars before the first one, keeping the view */
+  prependBars(bars: TradingBarsInput): void;
+  /** Replaces the bars */
+  setBars(bars: TradingBarsInput): void;
+  /** Number of bars */
+  getBarCount(): number;
+  /** Bar at an index, `null` outside the data */
+  getBar(index: number): TradingBar | null;
+  /** Scrolls to the latest bar */
+  scrollToRealtime(animate?: boolean): void;
+  /** Shows every bar */
+  fitContent(): void;
+  /** Visible bars, `null` before the first render */
+  getVisibleRange(): TradingVisibleRange | null;
+  /** Shows the bars between two logical indices */
+  setVisibleRange(range: {
+    from: number;
+    to: number;
+  }): void;
+  /** Fits every price scale to the visible bars again */
+  resetPriceScales(): void;
+  /** Activates a drawing tool */
+  setDrawingTool(tool: TradingDrawingTool): void;
+  /** Current drawings */
+  getDrawings(): readonly TradingDrawing[];
+  /** Deletes a drawing */
+  removeDrawing(id: string): void;
+  /** Selects a drawing (`null` clears the selection) */
+  selectDrawing(id: string | null): void;
+  /** Shows or hides an indicator */
+  setIndicatorVisible(id: string, visible: boolean): void;
+  /** Backend in use, `null` until ready */
+  getRenderer(): ChartRendererKind | null;
+  static ɵfac: i0.ɵɵFactoryDeclaration<MnTradingChart, never>;
+  static ɵcmp: i0.ɵɵComponentDeclaration<MnTradingChart, "mn-trading-chart", never, {
+    "bars": {
+      "alias": "bars";
+      "required": false;
+      "isSignal": true;
+    };
+    "symbol": {
+      "alias": "symbol";
+      "required": false;
+      "isSignal": true;
+    };
+    "timeframe": {
+      "alias": "timeframe";
+      "required": false;
+      "isSignal": true;
+    };
+    "chartStyle": {
+      "alias": "chartStyle";
+      "required": false;
+      "isSignal": true;
+    };
+    "indicators": {
+      "alias": "indicators";
+      "required": false;
+      "isSignal": true;
+    };
+    "locale": {
+      "alias": "locale";
+      "required": false;
+      "isSignal": true;
+    };
+    "options": {
+      "alias": "options";
+      "required": false;
+      "isSignal": true;
+    };
+  }, {
+    "crosshairMove": "crosshairMove";
+    "paneClick": "paneClick";
+    "visibleRangeChange": "visibleRangeChange";
+    "orderMove": "orderMove";
+    "drawingsChange": "drawingsChange";
+    "drawingSelect": "drawingSelect";
+    "drawingToolChange": "drawingToolChange";
+    "indicatorToggle": "indicatorToggle";
+    "historyRequest": "historyRequest";
+    "rendererChange": "rendererChange";
+  }, never, never, true, never>;
+}
+/** Engine of an order book widget: options plus a book streamed apart */
+interface BookEngine<O> extends EngineInstance<O> {
+  setBook(snapshot: OrderBookSnapshot): void;
+  applyDeltas(deltas: OrderBookDelta | readonly OrderBookDelta[]): void;
+}
+/**
+ * Base of the order book widgets: `options` go through `setOptions`, the
+ * `book` input through `setBook` when the object changes (stream updates
+ * with `applyDeltas`)
+ */
+export declare abstract class MnBookWidgetBase<O extends object, I extends BookEngine<O>> extends MnChartEngine<O, I> {
+  /** Book to draw `{ bids, asks, time }`, applied when the object changes (stream updates through `applyDeltas`) */
+  readonly book: import("@angular/core").InputSignal<OrderBookSnapshot | undefined>;
+  /** Locale of the numbers and texts (`"zh-CN"`); the page language by default */
+  readonly locale: import("@angular/core").InputSignal<string | undefined>;
+  /** Engine options (colors, precision, labels, ...) */
+  readonly options: import("@angular/core").InputSignal<O | undefined>;
+  constructor();
+  protected engineOptions(): O;
+  /** Replaces the book */
+  setBook(snapshot: OrderBookSnapshot): void;
+  /** Applies updates (size 0 removes a level); drawn once at the next frame */
+  applyDeltas(deltas: OrderBookDelta | readonly OrderBookDelta[]): void;
+  static ɵfac: i0.ɵɵFactoryDeclaration<MnBookWidgetBase<any, any>, never>;
+  static ɵdir: i0.ɵɵDirectiveDeclaration<MnBookWidgetBase<any, any>, never, never, {
+    "book": {
+      "alias": "book";
+      "required": false;
+      "isSignal": true;
+    };
+    "locale": {
+      "alias": "locale";
+      "required": false;
+      "isSignal": true;
+    };
+    "options": {
+      "alias": "options";
+      "required": false;
+      "isSignal": true;
+    };
+  }, {}, never, never, true, never>;
+}
+/**
+ * Cumulative depth of an order book: stepped bid / ask areas around the mid
+ * price, mirrored hover readout, zoom around the mid, eased updates (engine
+ * `createDepthChart`)
+ */
+export declare class MnDepthChart extends MnBookWidgetBase<DepthChartOptions, DepthChartInstance> {
+  /** Pointer over the curves (`null` when it leaves) */
+  readonly hover: import("@angular/core").OutputEmitterRef<DepthChartHoverEvent | null>;
+  /** Click / tap on the curves */
+  readonly depthClick: import("@angular/core").OutputEmitterRef<DepthChartHoverEvent>;
+  /** The visible range changed by zooming (fraction of the mid) */
+  readonly rangeChange: import("@angular/core").OutputEmitterRef<number>;
+  protected createEngine(container: HTMLElement, options: DepthChartOptions): DepthChartInstance;
+  protected bindEngine(chart: DepthChartInstance): (() => void)[];
+  /** Sets the visible range (fraction of the mid); `null` fits the book */
+  setRange(range: number | null): void;
+  static ɵfac: i0.ɵɵFactoryDeclaration<MnDepthChart, never>;
+  static ɵcmp: i0.ɵɵComponentDeclaration<MnDepthChart, "mn-depth-chart", never, {}, {
+    "hover": "hover";
+    "depthClick": "depthClick";
+    "rangeChange": "rangeChange";
+  }, never, never, true, never>;
+}
+/**
+ * Order book ladder: asks above the spread row, bids below, with depth
+ * bars, price grouping, change flashes and large order highlight (engine
+ * `createOrderBook`)
+ */
+export declare class MnOrderBook extends MnBookWidgetBase<OrderBookOptions, OrderBookInstance> {
+  /** Price of the spread row, colored by its last move; the mid price when omitted */
+  readonly lastPrice: import("@angular/core").InputSignal<number | null | undefined>;
+  /** Hovered row (`null` when the pointer leaves) */
+  readonly hover: import("@angular/core").OutputEmitterRef<OrderBookLevelEvent | null>;
+  /** Click / tap / Enter on a row (e.g. to fill a price in an order form) */
+  readonly levelClick: import("@angular/core").OutputEmitterRef<OrderBookLevelEvent>;
+  constructor();
+  protected defaultHeight(): number;
+  protected createEngine(container: HTMLElement, options: OrderBookOptions): OrderBookInstance;
+  protected bindEngine(book: OrderBookInstance): (() => void)[];
+  /** Price of the spread row (the mid price when `null`) */
+  setLastPrice(price: number | null): void;
+  static ɵfac: i0.ɵɵFactoryDeclaration<MnOrderBook, never>;
+  static ɵcmp: i0.ɵɵComponentDeclaration<MnOrderBook, "mn-order-book", never, {
+    "lastPrice": {
+      "alias": "lastPrice";
+      "required": false;
+      "isSignal": true;
+    };
+  }, {
+    "hover": "hover";
+    "levelClick": "levelClick";
+  }, never, never, true, never>;
+}
+/**
+ * Liquidity heatmap: resting size over time and price drawn by the GPU,
+ * best bid / ask lines and trades as bubbles sized by volume (engine
+ * `createOrderBookHeatmap`)
+ */
+export declare class MnOrderBookHeatmap extends MnBookWidgetBase<OrderBookHeatmapOptions, OrderBookHeatmapInstance> {
+  /** Trades; when the array grows, only the appended ones are added */
+  readonly trades: import("@angular/core").InputSignal<readonly import("../../charts/core.js").MarketTrade[] | undefined>;
+  /** Hovered cell (`null` when the pointer leaves) */
+  readonly hover: import("@angular/core").OutputEmitterRef<OrderBookHeatmapHoverEvent | null>;
+  /** Backend in use (also after a GPU loss) */
+  readonly rendererChange: import("@angular/core").OutputEmitterRef<ChartRendererKind>;
+  /** `true` while the view follows the market, `false` after a zoom / pan */
+  readonly followChange: import("@angular/core").OutputEmitterRef<boolean>;
+  constructor();
+  protected defaultHeight(): number;
+  protected createEngine(container: HTMLElement, options: OrderBookHeatmapOptions): OrderBookHeatmapInstance;
+  protected bindEngine(heatmap: OrderBookHeatmapInstance): (() => void)[];
+  /** Adds trades (bubbles) */
+  addTrades(trades: ChartTrades[number] | ChartTrades): void;
+  /** Follows the market again */
+  resetView(): void;
+  static ɵfac: i0.ɵɵFactoryDeclaration<MnOrderBookHeatmap, never>;
+  static ɵcmp: i0.ɵɵComponentDeclaration<MnOrderBookHeatmap, "mn-order-book-heatmap", never, {
+    "trades": {
+      "alias": "trades";
+      "required": false;
+      "isSignal": true;
+    };
+  }, {
+    "hover": "hover";
+    "rendererChange": "rendererChange";
+    "followChange": "followChange";
+  }, never, never, true, never>;
+}
+/**
+ * Time and sales tape: newest trades on top, virtualized (hundreds of
+ * thousands of rows), large trades highlighted, paused while hovered
+ * (engine `createTimeAndSales`)
+ */
+export declare class MnTimeAndSales extends MnChartEngine<TimeAndSalesOptions, TimeAndSalesInstance> {
+  /** Trades, oldest first; when the array grows, only the appended ones are added (other changes replace the tape) */
+  readonly trades: import("@angular/core").InputSignal<readonly import("../../charts/core.js").MarketTrade[] | undefined>;
+  /** Locale of the numbers, times and texts (`"zh-CN"`); the page language by default */
+  readonly locale: import("@angular/core").InputSignal<string | undefined>;
+  /** Engine options (columns, minSize, largeTradeThreshold, aggregate, labels...) */
+  readonly options: import("@angular/core").InputSignal<TimeAndSalesOptions | undefined>;
+  /** Hovered row (`null` when the pointer leaves) */
+  readonly hover: import("@angular/core").OutputEmitterRef<TimeAndSalesRowEvent | null>;
+  /** Click / tap / Enter on a row */
+  readonly tradeClick: import("@angular/core").OutputEmitterRef<TimeAndSalesRowEvent>;
+  /** The tape paused (pointer over it, scrolled down) or resumed */
+  readonly pause: import("@angular/core").OutputEmitterRef<boolean>;
+  constructor();
+  protected defaultHeight(): number;
+  protected createEngine(container: HTMLElement, options: TimeAndSalesOptions): TimeAndSalesInstance;
+  protected engineOptions(): TimeAndSalesOptions;
+  protected bindEngine(tape: TimeAndSalesInstance): (() => void)[];
+  /** Appends trades (oldest first) */
+  addTrades(trades: ChartTrades[number] | ChartTrades): void;
+  /** Replaces every trade */
+  setTrades(trades: ChartTrades): void;
+  /** Removes every trade */
+  clear(): void;
+  /** Scrolls back to the newest trade and resumes */
+  scrollToLatest(): void;
+  static ɵfac: i0.ɵɵFactoryDeclaration<MnTimeAndSales, never>;
+  static ɵcmp: i0.ɵɵComponentDeclaration<MnTimeAndSales, "mn-time-and-sales", never, {
+    "trades": {
+      "alias": "trades";
+      "required": false;
+      "isSignal": true;
+    };
+    "locale": {
+      "alias": "locale";
+      "required": false;
+      "isSignal": true;
+    };
+    "options": {
+      "alias": "options";
+      "required": false;
+      "isSignal": true;
+    };
+  }, {
+    "hover": "hover";
+    "tradeClick": "tradeClick";
+    "pause": "pause";
+  }, never, never, true, never>;
+}
+/**
+ * Base of the 3D chart components (engine `createChart3D`): common inputs,
+ * hover / click / camera / renderer outputs and the camera methods
+ */
+export declare abstract class MnChart3DBase<S extends Chart3DSeries> extends MnChartEngine<Chart3DOptions, Chart3DInstance> {
+  /** Data series; replace the array (or a data array) to update the chart */
+  readonly series: import("@angular/core").InputSignal<readonly S[]>;
+  /** X axis (width of the box) */
+  readonly xAxis: import("@angular/core").InputSignal<Chart3DAxisOptions | undefined>;
+  /** Y axis (depth of the box) */
+  readonly yAxis: import("@angular/core").InputSignal<Chart3DAxisOptions | undefined>;
+  /** Z axis (height of the box) */
+  readonly zAxis: import("@angular/core").InputSignal<Chart3DAxisOptions | undefined>;
+  /** Initial camera, also restored by a double click */
+  readonly camera: import("@angular/core").InputSignal<Chart3DCameraOptions | undefined>;
+  /** Turns the camera around the box: `true` at 12°/s or a speed in degrees per second */
+  readonly autoRotate: import("@angular/core").InputSignal<number | boolean | undefined>;
+  /** Colors of `colorBy: "z"` / `"value"`: a built-in ramp or CSS colors (default `viridis`) */
+  readonly colorScale: import("@angular/core").InputSignal<Chart3DColorScale | undefined>;
+  /** Color bar; shown by default when a visible series uses the color scale */
+  readonly colorBar: import("@angular/core").InputSignal<boolean | Chart3DColorBarOptions | undefined>;
+  /** Legend; shown by default when several series have a name */
+  readonly legend: import("@angular/core").InputSignal<boolean | Chart3DLegendOptions | undefined>;
+  /** Tooltip; `false` disables it */
+  readonly tooltip: import("@angular/core").InputSignal<boolean | Chart3DTooltipOptions | undefined>;
+  /** BCP 47 locale of the texts and numbers the engine writes; the runtime's default locale by default */
+  readonly locale: import("@angular/core").InputSignal<string | undefined>;
+  /** Other engine options (`Chart3DOptions`: aspect, box, valueRange, interaction, lighting, renderer, palette...) */
+  readonly options: import("@angular/core").InputSignal<Partial<Omit<Chart3DOptions, "series">> | undefined>;
+  /** The hovered point, cell or bar changed (`null`: none) */
+  readonly hover: import("@angular/core").OutputEmitterRef<Chart3DHoverEvent | null>;
+  /** A point, cell or bar was clicked */
+  readonly pointClick: import("@angular/core").OutputEmitterRef<Chart3DHoverEvent>;
+  /** The user rotated, zoomed, panned or reset the camera */
+  readonly cameraChange: import("@angular/core").OutputEmitterRef<Chart3DCameraState>;
+  /** The backend is ready (or fell back after a GPU loss) */
+  readonly rendererChange: import("@angular/core").OutputEmitterRef<ChartRendererKind>;
+  protected abstract typed(series: readonly S[]): Chart3DSeries[];
+  protected defaultHeight(): number;
+  protected createEngine(container: HTMLElement, options: Chart3DOptions): Chart3DInstance;
+  protected engineOptions(): Chart3DOptions;
+  protected bindEngine(chart: Chart3DInstance): (() => void)[];
+  /** Restores the camera of the `camera` input */
+  resetCamera(): void;
+  /** Current camera, `null` before the first render */
+  getCamera(): Chart3DCameraState | null;
+  /** Moves the camera */
+  setCamera(camera: Partial<Chart3DCameraState>): void;
+  /** Backend in use, `null` until ready */
+  getRenderer(): ChartRendererKind | null;
+  static ɵfac: i0.ɵɵFactoryDeclaration<MnChart3DBase<any>, never>;
+  static ɵdir: i0.ɵɵDirectiveDeclaration<MnChart3DBase<any>, never, never, {
+    "series": {
+      "alias": "series";
+      "required": true;
+      "isSignal": true;
+    };
+    "xAxis": {
+      "alias": "xAxis";
+      "required": false;
+      "isSignal": true;
+    };
+    "yAxis": {
+      "alias": "yAxis";
+      "required": false;
+      "isSignal": true;
+    };
+    "zAxis": {
+      "alias": "zAxis";
+      "required": false;
+      "isSignal": true;
+    };
+    "camera": {
+      "alias": "camera";
+      "required": false;
+      "isSignal": true;
+    };
+    "autoRotate": {
+      "alias": "autoRotate";
+      "required": false;
+      "isSignal": true;
+    };
+    "colorScale": {
+      "alias": "colorScale";
+      "required": false;
+      "isSignal": true;
+    };
+    "colorBar": {
+      "alias": "colorBar";
+      "required": false;
+      "isSignal": true;
+    };
+    "legend": {
+      "alias": "legend";
+      "required": false;
+      "isSignal": true;
+    };
+    "tooltip": {
+      "alias": "tooltip";
+      "required": false;
+      "isSignal": true;
+    };
+    "locale": {
+      "alias": "locale";
+      "required": false;
+      "isSignal": true;
+    };
+    "options": {
+      "alias": "options";
+      "required": false;
+      "isSignal": true;
+    };
+  }, {
+    "hover": "hover";
+    "pointClick": "pointClick";
+    "cameraChange": "cameraChange";
+    "rendererChange": "rendererChange";
+  }, never, never, true, never>;
+}
+/**
+ * 3D scatter plot: point clouds of up to millions of points on the GPU,
+ * colored per series, per point or through a color scale; orbit camera,
+ * hover picking and color bar
+ */
+export declare class MnScatter3DChart extends MnChart3DBase<Scatter3DSeries> {
+  protected typed(series: readonly Scatter3DSeries[]): Chart3DSeries[];
+  static ɵfac: i0.ɵɵFactoryDeclaration<MnScatter3DChart, never>;
+  static ɵcmp: i0.ɵɵComponentDeclaration<MnScatter3DChart, "mn-scatter-3d-chart", never, {}, {}, never, never, true, never>;
+}
+/** 3D polylines (trajectories, paths), optionally colored along the line */
+export declare class MnLine3DChart extends MnChart3DBase<Line3DSeries> {
+  protected typed(series: readonly Line3DSeries[]): Chart3DSeries[];
+  static ɵfac: i0.ɵɵFactoryDeclaration<MnLine3DChart, never>;
+  static ɵcmp: i0.ɵɵComponentDeclaration<MnLine3DChart, "mn-line-3d-chart", never, {}, {}, never, never, true, never>;
+}
+/**
+ * 3D surface `z = f(x, y)` over a regular grid: lit, colored by a color
+ * map, with an optional wireframe, contour lines and transparency
+ */
+export declare class MnSurface3DChart extends MnChart3DBase<Surface3DSeries> {
+  /** Wireframe of the series that do not set one */
+  readonly wireframe: import("@angular/core").InputSignal<boolean | Surface3DWireframeOptions | undefined>;
+  /** Contour lines of the series that do not set them */
+  readonly contours: import("@angular/core").InputSignal<boolean | Surface3DContourOptions | undefined>;
+  protected typed(series: readonly Surface3DSeries[]): Chart3DSeries[];
+  static ɵfac: i0.ɵɵFactoryDeclaration<MnSurface3DChart, never>;
+  static ɵcmp: i0.ɵɵComponentDeclaration<MnSurface3DChart, "mn-surface-3d-chart", never, {
+    "wireframe": {
+      "alias": "wireframe";
+      "required": false;
+      "isSignal": true;
+    };
+    "contours": {
+      "alias": "contours";
+      "required": false;
+      "isSignal": true;
+    };
+  }, {}, never, never, true, never>;
+}
+/** 3D bars over an x × y category grid, lit, stacked across series */
+export declare class MnBar3DChart extends MnChart3DBase<Bar3DSeries> {
+  /** Width of the bars of the series that do not set one, as a fraction of a cell */
+  readonly barWidth: import("@angular/core").InputSignal<number>;
+  protected typed(series: readonly Bar3DSeries[]): Chart3DSeries[];
+  static ɵfac: i0.ɵɵFactoryDeclaration<MnBar3DChart, never>;
+  static ɵcmp: i0.ɵɵComponentDeclaration<MnBar3DChart, "mn-bar-3d-chart", never, {
+    "barWidth": {
+      "alias": "barWidth";
+      "required": false;
+      "isSignal": true;
+    };
+  }, {}, never, never, true, never>;
+}
 /** Shares tooltip timing within a subtree. Recently opened tooltips skip the
  * initial delay when the pointer moves between controls. Nested providers isolate timing. */
 export declare class MnTooltipProvider {