import{type TemplateResult,type PropertyValues}from'lit';import{LyraElement}from'../../../internal/lyra-element.js';import'../../overlays/skeleton/skeleton.class.js';import type{LyraVariant}from'../../../internal/variants.js';import{type LyraChartLegendVisibilityChangeDetail,type LyraChartDatumVisibilityChangeDetail}from'./chart-legend-visibility.js';export type{LyraChartLegendVisibilityChangeDetail,LyraChartDatumVisibilityChangeDetail}from'./chart-legend-visibility.js';export{seriesPalette}from'./chart-colors.js';export interface LyraChartPoint{readonly x:number;readonly y:number;
/** Bubble radius. Ignored by chart types that do not consume a radius. */
readonly r?:number;
/**
* Caller-owned per-point label retained verbatim by events/export and interpolated into the
* localized whole-point message used by descriptions, tables, and keyboard announcements.
*/
readonly label?:string;}export interface LyraChartSeries{readonly label:string;readonly data?:readonly(number|null)[];readonly points?:readonly LyraChartPoint[];readonly color?:string|readonly string[];readonly fill?:boolean;readonly width?:number;readonly dash?:boolean;readonly noTooltip?:boolean;readonly axis?:'y'|'y2';
/**
* Chart.js dataset `stack` group id. Series sharing the same `stack` value on the same axis
* accumulate into one stack; a different id starts an independent stack that Chart.js draws
* side by side with the first on that same (stacked) axis. Omitted series default to Chart.js's
* own ungrouped stack, matching every series's behavior before this existed. Only meaningful on
* an axis that is actually stacked -- see `LyraChart.stacked`/`LyraChart.stackedAxes`.
*/
readonly stack?:string;readonly pointColors?:readonly string[];
/**
* Per-point radius. A single number applies to every point; an array (matching `data`'s
* length) sets each point independently — passed straight through to Chart.js, which
* supports both natively.
*/
readonly pointRadius?:number|readonly number[];
/**
* Per-segment (the line between two consecutive points) border color, indexed by the
* *starting* point of each segment — e.g. `['red', 'green']` on 3 points colors the first
* segment red and the second green. Wired to Chart.js's `segment.borderColor`, and cycled
* when shorter than the segment count. Sampled segments retain the original source starting
* point's palette index. Only meaningful for line-type series.
*/
readonly segmentColors?:readonly string[];readonly type?:'line'|'bar';}export type LyraChartType='line'|'bar'|'scatter'|'pie'|'doughnut'|'radar'|'polarArea'|'bubble';export type LyraChartGrid='x'|'y'|'both'|'none';
/** Complete cartesian axes, including their ticks, labels, borders and grid lines. */
export type LyraChartAxes=LyraChartGrid;export type LyraChartIndexAxis='x'|'y';
/** Scale type for a chart's value axis. The categorical axis is never affected. */
export type LyraChartScaleType='linear'|'logarithmic';
/**
* One declarative chart annotation: a reference line (`value`) or a shaded band (`from`/`to`) on
* the named axis.
*
* `value` and `from`/`to` are mutually exclusive; an entry supplying neither, or non-finite
* numbers, is dropped rather than handed to Chart.js, where it would silently render nothing or
* throw. `axis` defaults to `'y'`, the value axis for the common threshold case.
*/
export interface LyraChartAnnotation{readonly axis?:LyraChartIndexAxis;readonly value?:number;readonly from?:number;readonly to?:number;readonly label?:string;readonly tone?:LyraVariant;}export type LyraChartLayoutPosition='left'|'top'|'right'|'bottom'|'center'|'chartArea'|{[scaleId:string]:number;};export type LyraChartLegendPosition=LyraChartLayoutPosition|'start'|'end'|'auto';
/** Dataset toggles, or shared category toggles for pie/doughnut/polar-area charts. */
export type LyraChartLegendMode='auto'|'dataset'|'datum';
/** Text shown in the DOM legend, independently of tooltip and axis formatting. */
export type LyraChartLegendDisplay='auto'|'label'|'value'|'percentage'|'value-percentage';export type LyraChartValueFormatterContext='tick'|'tooltip'|'legend'|'table';export type LyraChartValueFormatter=(value:number,context:LyraChartValueFormatterContext)=>string;export type LyraChartFormatSurface=LyraChartValueFormatterContext|'visual'|'spoken'|'export';
/** Identifies which numeric component of a structured datum the formatter receives. */
export type LyraChartStatistic='x'|'y'|'r'|'min'|'q1'|'median'|'q3'|'max'|'total';
/**
* The scale a formatted number belongs to: the two cartesian value axes (`y`, and `y2` for a
* `LyraChartSeries.axis: 'y2'` series), the `x` scale wherever it carries numbers rather than
* categories (scatter/bubble, and a horizontal bar/line), and the single radial `r` scale of a
* radar/polar-area chart. `undefined` where there is no axis at all -- a pie/doughnut slice, or a
* surface whose value is not bound to one scale.
*/
export type LyraChartFormatterAxis='x'|'y'|'y2'|'r';export interface LyraChartFormatterContext{readonly value:number;readonly surface:LyraChartFormatSurface;readonly datasetIndex?:number;readonly index?:number;readonly label?:string;readonly seriesLabel?:string;readonly statistic?:LyraChartStatistic;
/**
* Which scale this number is plotted against. Two axes usually exist precisely because they
* carry different units, so without it one formatter cannot render a secondary axis correctly --
* the gap that forced dual-axis and scatter charts onto the raw `config` tick callback, which
* bypasses this formatter and so drops the same unit text from the data table, the CSV export and
* the spoken announcement.
*/
readonly axis?:LyraChartFormatterAxis;
/**
* This entry's share of the represented `surface: 'legend'` total, as a fraction in `[0, 1]`
* (`0.5` is 50%) -- present only on that surface, so a `legendDisplay: 'value'` or
* `'value-percentage'` formatter can render a share without recomputing it from raw data. There
* is no accompanying `total`: internally the sum is computed in a per-entry rescaled coordinate
* system for numeric stability with datasets whose finite values sum beyond
* `Number.MAX_VALUE`, so it has no fixed public unit -- `percentage` alone is stable regardless.
*/
readonly percentage?:number;}export type LyraChartFormatter=(context:LyraChartFormatterContext)=>string;
/**
* Tooltip title/footer formatter. Chart.js calls its own `title`/`footer` tooltip callbacks once
* per tooltip render against every hovered item, not once per item like the label path -- so
* unlike `LyraChartFormatter`, this receives every hovered item's context at once, each in the
* same `LyraChartFormatterContext` shape `formatter`'s `'tooltip'` surface already produces (one
* entry per dataset the tooltip covers, e.g. every stacked series sharing the hovered category).
* The property itself being unset -- not the formatter's return value -- is what leaves Chart.js's
* own default title (the shared category label) or default footer (none) in place.
*/
export type LyraChartTooltipGroupFormatter=(items:readonly LyraChartFormatterContext[])=>string;export type LyraChartExportFormat='csv'|'png';export interface LyraChartArea{readonly top:number;readonly left:number;readonly right:number;readonly bottom:number;readonly width:number;readonly height:number;}
/** A Chart.js-compatible plugin shape without making `chart.js` a type dependency for consumers. */
export interface LyraChartPlugin{readonly id:string;}
/** Dataset configuration accepted by the raw `config` passthrough. */
export interface LyraChartDatasetConfiguration{type?:string;label?:unknown;data?:unknown[];hidden?:boolean;axis?:string;yAxisID?:string;stack?:string;noTooltip?:boolean;fill?:unknown;backgroundColor?:unknown;borderColor?:unknown;borderRadius?:unknown;borderWidth?:unknown;borderDash?:unknown;color?:unknown;pointStyle?:unknown;pointBackgroundColor?:unknown;pointRadius?:unknown;segment?:unknown;}
/** Data block accepted by the raw `config` passthrough. */
export interface LyraChartDataConfiguration{labels?:unknown[];datasets?:LyraChartDatasetConfiguration[];}
/**
* Peer-neutral structural configuration accepted by `LyraChart.config`.
* Install `chart.js` and use its own `ChartConfiguration` type when stricter
* controller-specific checking is useful; that type remains structurally
* assignable to this passthrough surface.
*/
export interface LyraChartConfiguration{type?:string;data?:LyraChartDataConfiguration;options?:object;plugins?:LyraChartPlugin[];}
/** A single Chart.js hit-test result, as returned by `LyraChartInstance.getElementsAtEventForMode()`.
*  Exported so the documented `LyraChartInstance` reference (`llms/charts.md`) names a real,
*  importable symbol instead of an inaccessible internal interface. */
interface ChartHit{datasetIndex:number;index:number;}
/** Structural shape of a live Chart.js instance, without imposing `chart.js` as a type dependency
*  on consumers. Exported so `LyraChartInstance`'s documented `extends RuntimeChart` reference
*  names a real, importable symbol. */
interface RuntimeChart{data:{labels?:unknown[];datasets:LyraChartDatasetConfiguration[];};options:Record<string,unknown>;config:{type?:unknown;};legend?:unknown;chartArea?:LyraChartArea;destroy():void;update(mode?:string):void;toBase64Image?():string;getElementsAtEventForMode(event:Event,mode:string,options:Record<string,unknown>,useFinalPosition:boolean):ChartHit[];getDatasetMeta?(index:number):{hidden:boolean|null;};isDatasetVisible(index:number):boolean;setDatasetVisibility(index:number,visible:boolean):void;getDataVisibility?(index:number):boolean;toggleDataVisibility?(index:number):void;}
/** Public structural view of the current Chart.js instance, without imposing `chart.js` as a
* type dependency on consumers. The value is `undefined` before the peer loads and after the
* component disconnects. */
export interface LyraChartInstance extends RuntimeChart{}export type LyraChartDatumKind='bar'|'point'|'segment'|'slice'|'box';type LyraCoreChartDatumKind=Exclude<LyraChartDatumKind,'box'>;
/** Input-neutral detail shared by every chart-family `lr-datum-activate` event. */
export interface LyraChartDatumActivateDetail<TKind extends LyraChartDatumKind=LyraChartDatumKind,TValue=unknown>{readonly kind:TKind;readonly datasetIndex:number;readonly index:number;readonly label:string|undefined;readonly value:TValue;}export interface LyraChartEventMap{'lr-point-click':CustomEvent<{datasetIndex:number;index:number;label:string|undefined;value:unknown;}>;'lr-zoom':CustomEvent<{zoomed:boolean;}>;'lr-before-legend-visibility-change':CustomEvent<LyraChartLegendVisibilityChangeDetail>;'lr-legend-visibility-change':CustomEvent<LyraChartLegendVisibilityChangeDetail>;'lr-before-datum-visibility-change':CustomEvent<LyraChartDatumVisibilityChangeDetail>;'lr-datum-visibility-change':CustomEvent<LyraChartDatumVisibilityChangeDetail>;'lr-datum-activate':CustomEvent<LyraChartDatumActivateDetail<LyraCoreChartDatumKind>>;}
/**
* `<lr-chart>` — the core Chart.js wrapper used directly and by the typed
* Chart.js tags plus `<lr-histogram>`. `<lr-lite-chart>` and `<lr-box-plot>`
* are independent implementations. Requires the optional peer dep `chart.js`; `chartjs-plugin-zoom`
* (for `zoom`) and `chartjs-plugin-datalabels` (for `data-labels`/`stack-totals`)
* are further optional peers loaded only on demand.
* With IntersectionObserver available, canvas construction waits for the first delivered
* visibility decision; without it, drawing starts as soon as the peer and canvas are ready.
* Simplified pie/doughnut datasets with magnitudes above Number.MAX_SAFE_INTEGER are uniformly
* scaled for finite peer arc geometry. Legends, tooltips, data labels and semantic exports retain
* original values; direct peer callbacks see scaled values. Explicit config.data is passed through.
*
* **API mirror note:** the real `wa-chart` docs page
* (https://webawesome.com/docs/components/chart/) documents a `config:
* ChartJS['config']` property alongside its simplified attributes — "a
* flexible wrapper around Chart.js" supporting *both* simplified attributes
* and full Chart.js configuration passthrough, not a `data`/`options` prop
* pair. `lr-chart` mirrors that dual surface: the `LyraChartSeries`-based
* `datasets`/`labels`/`type`/`withoutLegend`/`xLabel`/`yLabel`/`zoom` attributes
* below are the simplified surface (compatible with WA's `type`, `xLabel`,
* `yLabel`, `withoutLegend`, etc.), and the additional
* `config` property is the raw-passthrough escape hatch — a
* `LyraChartConfiguration` deep-merged over the generated config in
* `buildConfig()`, mirroring WA's `config` property without discarding the
* `LyraChartSeries` shape the rest of this component family (subclasses, box-plot,
* histogram) is built on.
*
* `datasets`, `annotations`, and `hiddenDatasets` take bounded, clone-owned readonly snapshots.
* Create a new collection and reassign it after changes; mutating the assigned array does not
* update the view. `labels` does not yet share this contract.
*
* @customElement lr-chart
* @event lr-zoom - `detail: { zoomed }`.
* @event lr-point-click - Fired when pointer input lands on a data point/segment, when a generated
*   data-table value is activated, or when Enter/Space activates the keyboard-current canvas datum.
*   `detail: { datasetIndex: number, index: number, label: string |
*   undefined, value: unknown }`. For scatter/bubble data, `label` prefers the per-point label and
*   `value` is the complete typed `LyraChartPoint` (`x`, `y`, optional `r`, optional `label`).
* @event lr-datum-activate - Family-normalized activation event. Its detail adds `kind`
*   (`bar`, `point`, `segment`, or `slice`) to the `lr-point-click` detail.
* @event lr-before-legend-visibility-change - Cancelable proposal emitted before a DOM legend
*   toggle changes state. `detail` contains the target `datasetIndex`, its proposed `visible`
*   value, and the complete canonical proposed `hiddenDatasets` snapshot.
* @event lr-legend-visibility-change - Emitted after an accepted DOM legend toggle commits the
*   same detail. Programmatic `hiddenDatasets` changes reconcile without either event.
* @event lr-before-datum-visibility-change - Cancelable category visibility proposal in datum
*   legend mode. `detail: { index: number, visible: boolean, hiddenDatums: readonly number[] }`.
*   Source category indexes apply to every dataset/ring. The complete detail is frozen.
* @event lr-datum-visibility-change - Emitted after an accepted category toggle commits the same
*   frozen detail. Programmatic `hiddenDatums` assignments are silent.
* @csspart base - The chart wrapper.
* @csspart plot - The fixed-height canvas/overlay region.
* @csspart canvas - The Chart.js canvas.
* @csspart legend - The wrapping DOM legend, rendered unless `withoutLegend` is set.
* @csspart legend-item - A keyboard-operable dataset or category visibility toggle.
* @csspart legend-item-hidden - Added while the legend item's dataset or category is hidden.
* @csspart legend-swatch - The resolved dataset/category color swatch in a legend item.
* @csspart reset-zoom-button - The reset-zoom control when zoom is active.
* @csspart description - The accessible chart summary.
* @csspart data-table - The optional generated or slotted data table.
* @csspart data-table-toggle - The disclosure button rendered by `dataTableToggle`.
* @csspart center - The chart-area-centered overlay wrapper for the `center` slot.
* @csspart error - Static visible error shown instead of `canvas` when the optional `chart.js`
*   peer dependency is not installed; its transition is announced through a shared light-DOM alert.
* @csspart notices - Wrapper for nonfatal feature warnings and generated-data truncation notices.
* @csspart data-truncation - Explanation shown when the generated accessible alternative samples
*   a data set larger than its 1,000-record ceiling.
* @csspart feature-warning - Static nonfatal warning when a requested optional feature peer is
*   unavailable while the core chart remains usable.
* @cssprop [--lr-chart-height=var(--lr-size-280px)] - The plot region's `block-size` and the
*   host's minimum block size. A visible data table or wrapping DOM legend grows the host in
*   normal flow instead of overlapping following content. `height` supplies a private fallback;
*   this public token always wins when a consumer sets it.
* @cssprop [--lr-chart-grid-color=var(--lr-color-border)] - Grid-line color. Resolved via
*   `getComputedStyle` on every draw (Chart.js paints to canvas and cannot consume `var()`).
* @cssprop [--lr-chart-tick-color=var(--lr-color-text-quiet)] - Axis tick-label color; also used
*   for the `xLabel`/`yLabel`/`y2Label` axis-title text (there is no separate title-color token).
*   Resolved via `getComputedStyle` on every draw.
* @cssprop [--lr-chart-tick-font-size=var(--lr-font-size-xs)] - Axis tick-label font size, in any
*   CSS length unit. Defaults to `--lr-font-size-xs` (12px at the standard root) because that
*   matches Chart.js's OWN built-in tick font size, which is what every canvas chart rendered
*   before this token existed -- leaving it unset must stay byte-identical to that, not shrink to
*   `<lr-lite-chart>`'s SVG default. Also sizes the radar/polarArea `r`-scale `pointLabels` (the
*   spoke labels), but ONLY once set: those default separately to Chart.js's OWN distinct
*   `RadialLinearScale` `pointLabels` default (10px, not this token's 12px), and only adopt this
*   token's size once the consumer explicitly sets it, at which point ticks and point labels match.
*   Resolved via `getComputedStyle` on every draw, same constraint as every other `--lr-chart-*`
*   token here (Chart.js paints to canvas and cannot consume `var()`).
* @cssprop [--lr-chart-legend-color=var(--lr-color-text)] - Legend label color. Resolved via
*   `getComputedStyle` on every draw.
* @cssprop [--lr-chart-legend-side-max=var(--lr-size-15rem)] - Maximum inline size reserved for a
*   side-positioned DOM legend; the track is also capped at one third of the chart allocation.
* @cssprop [--lr-chart-legend-item-hover-bg=var(--lr-color-brand-quiet)] - Hover background of a
*   legend visibility button.
* @cssprop --lr-chart-legend-item-active-bg - Pressed background of a legend visibility button;
*   defaults to the standard active mix of `--lr-color-brand-quiet`.
* @cssprop [--lr-chart-data-table-button-hover-bg=var(--lr-color-brand-quiet)] - Hover background
*   of an actionable generated-table value.
* @cssprop --lr-chart-data-table-button-active-bg - Pressed background of an actionable generated-
*   table value; defaults to the standard active mix of `--lr-color-brand-quiet`.
* @cssprop [--lr-chart-data-table-toggle-hover-bg=var(--lr-color-brand-quiet)] - Hover background
*   of the `dataTableToggle` disclosure button.
* @cssprop --lr-chart-data-table-toggle-active-bg - Pressed background of the `dataTableToggle`
*   disclosure button; defaults to a mix of the hover background with the shared active mix
*   partner.
* @cssprop [--lr-chart-reset-zoom-button-hover-bg=var(--lr-color-brand-quiet)] - Hover background
*   of the reset-zoom button.
* @cssprop --lr-chart-reset-zoom-button-active-bg - Pressed background of the reset-zoom button;
*   defaults to the standard active mix of `--lr-color-brand-quiet`.
* @cssprop [--lr-chart-tooltip-bg=var(--lr-color-surface)] - Tooltip background color. Resolved
*   via `getComputedStyle` on every draw.
* @cssprop [--lr-chart-tooltip-text=var(--lr-color-text)] - Tooltip text color. Resolved via
*   `getComputedStyle` on every draw.
* @cssprop [--lr-chart-canvas-hover-outline-width=var(--lr-border-width-thin)] - Width of the
*   `[part='canvas']` hover-state outline.
* @cssprop [--lr-chart-canvas-hover-outline-color=var(--lr-chart-grid-color)] - Color of the
*   `[part='canvas']` hover-state outline.
* @cssprop [--lr-chart-pattern-step=var(--lr-space-2xs)] - Tile size of the texture painted on
*   `[part='legend-swatch']` while `forced-colors: active` matches, where every series collapses to
*   one system color and the stripe/crosshatch pattern becomes the only channel keeping series
*   apart. Declared on the swatch part rather than the host; the stripe width within a tile stays
*   `--lr-border-width-thin`, so a larger step spaces the stripes further apart.
* @cssprop [--border-color-1=var(--lr-color-chart-1)] - First dataset border color.
* @cssprop [--border-color-2=var(--lr-color-chart-2)] - Second dataset border color.
* @cssprop [--border-color-3=var(--lr-color-chart-3)] - Third dataset border color.
* @cssprop [--border-color-4=var(--lr-color-chart-4)] - Fourth dataset border color.
* @cssprop [--border-color-5=var(--lr-color-chart-5)] - Fifth dataset border color.
* @cssprop [--border-color-6=var(--lr-color-chart-6)] - Sixth dataset border color.
* @cssprop [--fill-color-1=var(--lr-color-chart-1)] - First dataset fill color.
* @cssprop [--fill-color-2=var(--lr-color-chart-2)] - Second dataset fill color.
* @cssprop [--fill-color-3=var(--lr-color-chart-3)] - Third dataset fill color.
* @cssprop [--fill-color-4=var(--lr-color-chart-4)] - Fourth dataset fill color.
* @cssprop [--fill-color-5=var(--lr-color-chart-5)] - Fifth dataset fill color.
* @cssprop [--fill-color-6=var(--lr-color-chart-6)] - Sixth dataset fill color.
* @cssprop [--border-radius=var(--lr-radius)] - Dataset element corner radius.
* @cssprop [--border-width=var(--lr-border-width-thin)] - Dataset element border width.
* @cssprop [--grid-border-width=var(--lr-border-width-thin)] - Axis and grid line width.
* @cssprop [--grid-color=var(--lr-chart-grid-color)] - Grid line color.
* @cssprop [--line-border-width=var(--lr-border-width-medium)] - Line dataset stroke width.
* @cssprop [--point-radius=var(--lr-space-2xs)] - Line/scatter point radius.
* @slot - An optional `<script type="application/json">` containing a Chart.js configuration.
* @slot data-table - An optional consumer-provided accessible table alternative. Use this escape
*   hatch for a complete paginated or virtualized alternative when the generated 1,000-record
*   sample is insufficient.
* @slot center - Optional overlay content positioned at the chart area's center. Useful for
*   doughnut and pie totals.
* @status stable
* @since 4.0.0
*/
export declare class LyraChart extends LyraElement<LyraChartEventMap>{protected static readonly immutableEventDetails:readonly string[];protected static readonly ownedCollectionProperties:readonly string[];static styles:import("lit").CSSResultGroup[];constructor();type:LyraChartType;labels:string[];private labelsSnapshot?;private annotationsSnapshot?;private hiddenDatasetsSnapshot?;
/** Public collection identities remain observable; internal computation uses these one-read copies. */
private canonicalLabels;private canonicalAnnotations;private canonicalHiddenDatasets;private _datasets;private datasetsSource;
/** Simplified chart series. Non-record entries are dropped while valid sibling series remain. */
get datasets():readonly LyraChartSeries[];set datasets(value:readonly LyraChartSeries[]);
/**
* Complete controlled visibility state for DOM legend toggles. `undefined` (the default) honors
* each effective dataset's `hidden` configuration; a defined array wins over those defaults, and
* an empty array deliberately makes every dataset visible. Invalid, duplicate, and out-of-range
* indexes are ignored when state is applied or emitted.
*/
hiddenDatasets?:readonly number[];private _hiddenDatums;
/**
* Controlled hidden source category indexes for pie/doughnut/polar-area charts, shared by all
* datasets/rings. Clone-owned; invalid, duplicate and out-of-range indexes are ignored when
* applied or emitted. Empty restores all categories. Does not alter dataset visibility or exports.
* @default []
*/
get hiddenDatums():readonly number[];set hiddenDatums(value:readonly number[]);
/**
* `datum` renders category toggles for pie/doughnut/polar-area charts. Categories use the first
* dataset's colors and values; a toggle affects that category in every ring. Other chart types
* retain dataset legends. `auto` (the default) resolves to `datum` on pie/doughnut/polar-area
* charts -- where a single-dataset legend would otherwise enumerate one entry for the whole
* dataset instead of one per visible slice -- and to `dataset` everywhere else. `dataset` always
* forces the dataset legend, even on a slice chart. Both non-`auto` modes use the generated
* accessible-data sampling budget.
* @default 'auto'
*/
legendMode:LyraChartLegendMode;
/**
* `auto` retains optional legend formatting; `label` omits values even with a formatter; `value`
* appends a formatted value. `percentage` uses locale percentages of the absolute represented
* legend values, including hidden items (zero totals yield 0%). `value-percentage` appends both,
* as `label: value (percentage)`. Dataset values are sampled sums; category values come from the
* first dataset. The `formatter`/`valueFormatter` callback backing `value` and `value-percentage`
* additionally receives that same `percentage` in its `surface: 'legend'` context, so a custom
* formatter can build its own combined text without recomputing the share. Tooltip and axis
* formatting are unchanged.
*/
legendDisplay:LyraChartLegendDisplay;
/**
* Accessible chart description, which REPLACES the generated summary rather than adding to it.
*
* Left unset, the component builds an sr-only per-series summary from the actual data. Setting
* this discards that summary entirely and substitutes your text -- a full override, which is the
* right tool when you can describe the chart better than a generic walk of the series can.
*
* It is the wrong tool for adding a caveat ("excludes returns", "sampled hourly") on top of the
* data summary: you would trade the whole summary for the caveat, and a consumer reasonably read
* the old one-line doc as additive and did exactly that. For a caveat, prefer visible text beside
* the chart -- a note only screen-reader users hear is worse for everyone than one everybody
* sees -- or fold the data into your own `description` text if you are overriding anyway.
*/
description:string|null;
/** Controls which cartesian grid axes are drawn. */
grid:LyraChartGrid;
/** Complete cartesian axis visibility, independent of grid. `y` also controls the y2 axis.
* Radial charts ignore this setting. Explicit config scale options retain precedence. */
axes:LyraChartAxes;
/** Compact cartesian plot: hide axes and remove automatic layout padding. Set height and
* withoutLegend for a small histogram/sparkline. Preserves data tables, tooltips and keyboard
* actions; radial charts ignore this setting. Explicit config options retain precedence. */
compact:boolean;
/** Chart.js index axis. `'y'` is Chart.js's own mechanism for horizontal bars (it also flips
*  line/area types onto a horizontal category axis). */
indexAxis:LyraChartIndexAxis;
/** Accessible chart label. A host `aria-label` still has highest precedence. */
label:string|null;
/** Legend placement. `auto` uses a right legend above 480px and a bottom legend below it. */
legendPosition:LyraChartLegendPosition;
/**
* Scale type for the **value** axis (the categorical axis is unaffected). `'logarithmic'` plots
* a dataset spanning several orders of magnitude honestly, where a linear axis collapses
* everything below the maximum into the baseline. Inherited by `lr-line-chart`,
* `lr-scatter-chart` and `lr-bar-chart`.
*
* A logarithmic axis cannot represent zero or negative values (`log(0)` is `-Infinity`), so
* `beginAtZero` is not forwarded in that mode -- Chart.js would otherwise be handed a bound it
* cannot place. Non-positive data points are dropped by Chart.js's own log scale.
*/
scaleType:LyraChartScaleType;
/**
* Declarative reference lines and shaded bands — a threshold, an event year, a regime change, a
* highlighted period. Each entry marks either a single `value` or a `from`/`to` range on `axis`
* (default `'y'`), with an optional `label` and semantic `tone`.
*
* Needs the optional `chartjs-plugin-annotation` peer, loaded on first actual demand so a page
* with no annotated charts never downloads it. The plugin is registered globally, like
* `chartjs-plugin-zoom` and unlike `chartjs-plugin-datalabels`: it draws nothing unless a chart
* supplies annotation options, so the registration is unobservable to charts that set none, and
* registration is also what installs the plugin's own element defaults. Without the peer
* installed the chart still renders; a console warning plus a localized visible warning and
* light-DOM announcement explain the no-op — the same fail-closed contract `data-labels` uses.
*
* Entries are included in the generated accessible description, mirroring `lr-heatmap`.
*/
annotations:readonly LyraChartAnnotation[];
/** Maximum value-axis bound. Non-finite values are ignored. */
max:number|null;
/** Minimum value-axis bound. Non-finite values are ignored. */
min:number|null;private _plugins;private pluginsSource;
/** Chart.js plugins attached to this chart instance. Valid plugins retain their opaque identity.
* @default [] */
get plugins():readonly LyraChartPlugin[];set plugins(value:readonly LyraChartPlugin[]);
/**
* Formats numeric (value-axis) ticks, tooltip values, legend values, and generated accessible
* table cells from one callback.
* Horizontal scalar tooltips use parsed x, including a raw config indexAxis override;
* structured points retain their y-value contract. The context-object formatter shares this rule.
* Never runs against the categorical x-axis's own labels (line/bar's `labels` strings) —
* Chart.js's category scale passes the tick index to `ticks.callback`, not the label text,
* so formatting it would corrupt the axis.
*/
valueFormatter?:LyraChartValueFormatter;
/** Unified context-object formatter for visual, tooltip, table/export, and spoken values. */
formatter?:LyraChartFormatter;
/**
* Tooltip title formatter -- e.g. a scatter point's own name. Receives every item the hovered
* tooltip covers, each in `formatter`'s `'tooltip'`-surface context shape. Unset (the default)
* leaves Chart.js's own default title (the shared category label) in place.
*/
tooltipTitleFormatter?:LyraChartTooltipGroupFormatter;
/**
* Tooltip footer formatter -- e.g. a category's stack total under the items. Receives every
* item the hovered tooltip covers, in the same shape as `tooltipTitleFormatter`. Unset (the
* default) leaves Chart.js's own default (no footer).
*/
tooltipFooterFormatter?:LyraChartTooltipGroupFormatter;
/** Chart-wide default fill-under-line setting for line-type series; a series's own `LyraChartSeries.fill` overrides it. */
area:boolean;zoom:boolean;height:string;xLabel:string|null;yLabel:string|null;y2Label:string;beginAtZero:boolean;
/** Makes the generated data table visible; it remains screen-reader available when false. */
showDataTable:boolean;
/**
* Render a disclosure button above the accessible data table so a sighted reader can reveal the
* numbers behind the chart on demand. `showDataTable` alone is all-or-nothing -- the table is
* either permanently screen-reader-only or permanently visible -- which left a consumer wrapping
* a duplicated table in their own `<details>`.
*
* With this set, `showDataTable` becomes the disclosure's *initial* state rather than its whole
* behavior. The table stays in the DOM in both states, so assistive technology never loses it.
* @default false
*/
dataTableToggle:boolean;
/**
* Live disclosure state. Null until the reader actually toggles, so an untouched control keeps
* following `showDataTable` (including a later change to it) instead of freezing a seeded copy.
*/
private dataTableExpandedOverride;private readonly dataTableId;
/** Whether the data table is currently visible. Identical to `showDataTable` whenever
*  `dataTableToggle` is off, which is what keeps the unset path byte-identical to before. */
private get dataTableVisible();private toggleDataTable;
/** Stacks the `x`/`y`(/`y2`) scale entries `buildScales()` returns; only meaningful for `bar` and `line` types. */
stacked:boolean;
/**
* Per-value-axis override of `stacked`, keyed by `'y'`/`'y2'`. An axis absent from this record
* -- including every axis when the whole property is unset -- falls back to the chart-wide
* `stacked` value, which is what keeps a chart that never sets this byte-identical to before.
* Lets a `stacked` bar series on the primary axis sit next to an unstacked overlay series on
* `y2` (via `LyraChartSeries.axis: 'y2'`): set `stackedAxes` to `{ y2: false }` alongside
* `stacked`, or spell out both axes explicitly. The shared categorical axis (`x` for a vertical
* bar/line, or `y` when `indexAxis` is `'y'`) has no independent entry of its own -- it always
* mirrors the resolved `'y'` value, matching Chart.js's own paired index/value-scale stacking
* contract. Only meaningful for `bar`/`line` types, matching `stacked` itself.
*/
stackedAxes?:Partial<Record<'y'|'y2',boolean>>;
/** Disables Chart.js animation. */
withoutAnimation:boolean;
/** Hides the legend. */
withoutLegend:boolean;
/** Hides Chart.js tooltips. */
withoutTooltip:boolean;
/**
* Draws each data point's value on the chart via the optional
* `chartjs-plugin-datalabels` peer. Unset (the default) leaves labels off for
* this chart; the peer is attached only to instances that opt in, and
* `buildConfig()` keeps its per-chart options disabled until this is set. The
* screen-reader equivalent is the always-present data table (see
* `show-data-table`); labels are a purely visual, canvas-only addition.
*/
dataLabels:boolean;
/**
* When the chart is `stacked` (bar/line only), draws the per-category stack
* total above each stack, via the same optional `chartjs-plugin-datalabels`
* peer as `data-labels`. Null/undefined points are skipped; a category whose
* every value is null shows no total. The generated accessible data table
* receives the same formatted total column (one per value axis). Unset (the
* default) draws and adds nothing.
*/
stackTotals:boolean;
/**
* Raw Chart.js configuration passthrough — mirrors `wa-chart`'s `config`
* property. Recursively deep-merged over the `LyraChartSeries`-derived
* config in `buildConfig()` (any key at any nesting depth — e.g.
* `config.options.scales.y.min` — wins over the generated equivalent
* without discarding sibling keys the generated config set), for consumers
* who need full Chart.js control beyond the simplified `LyraChartSeries` shape. Generated bar
* borderWidth/borderRadius defer to authored bar option scopes; explicit series.width still wins.
*
* Caveat: the merge only recurses into plain objects — an *array* value
* (e.g. `config.plugins` as an inline-plugin array, or `config.data.datasets`)
* REPLACES the generated array wholesale rather than concatenating with it.
* The public `plugins` array and Lyra's on-demand data-label plugin are then
* appended without duplicate object identities, so required per-instance
* plugins remain attached without global registration.
*
* When `config.data` supplies `labels` and/or `datasets`, those arrays are the effective data
* model for canvas rendering, append mutation, CSV export, the accessible name/summary, keyboard
* navigation/events, the DOM legend, and the fallback data table.
*/
private _config?;private configSource;get config():LyraChartConfiguration|undefined;set config(value:LyraChartConfiguration|undefined);private slottedConfig?;
/** Subclass hook for removing raw peer keys that contradict a derived public contract. */
protected normalizeEffectiveConfig(config:LyraChartConfiguration|undefined):LyraChartConfiguration|undefined;private effectiveConfig;private onConfigSlotChange;
/**
* Reads the `config-slot`'s currently assigned `<script type="application/json">` and applies
* it -- wired as the `slotchange` handler (via `onConfigSlotChange`) for every later mutation,
* and called once more from `firstUpdated()` (see `collectInitialSlotAssignment`) to cover an
* environment, or a real-browser timing race, where the slot's initial assignment never fires
* `slotchange`.
*/
private collectConfigFromSlot;
/**
* The single data model used by every chart surface. `config.data` follows the same merge rule
* as the Chart.js render config: an explicit labels/datasets array replaces the generated array,
* while an omitted member falls back to the simplified property surface.
*/
private effectiveData;
/** Validates peer callback indexes against the visual data sent to Chart.js. */
private callbackDatasetIndex;
/** Validates a peer callback's visual row as well as its visual dataset. */
private callbackIndexes;
/** The public controlled snapshot when supplied, otherwise the effective configuration default. */
private effectiveHiddenDatasetIndexes;
/** Applies the public controlled state to the live Chart.js metadata after any data replacement. */
private applyDatasetVisibility;private isSliceChart;
/** Reconcile through Chart.js's public category visibility API after data/index remapping. */
private applyDatumVisibility;private hasExplicitConfigData;private datasetLabel;private datasetValues;private isPointDataset;
/**
* Appends one streamed category to numeric `data` series and optionally keeps only the newest
* `maxPoints` categories. An explicitly supplied `config.data` member is updated at that same
* source; generated members continue to update `labels`/`datasets`, preserving generated styling.
* Point-based scatter/bubble series are left unchanged because their x/y/r coordinates need a
* richer host-defined append contract.
*/
appendData(label:string,values:(number|null)[],maxPoints?:number):void;
/**
* Returns a spreadsheet-safe CSV snapshot of the effective chart data. Point datasets expand to
* x/y and, when present, radius/per-point-label columns so export never flattens point meaning.
*/
exportData(format:LyraChartExportFormat):string;
/** True until the lazy-loaded `chart.js` peer dependency has settled (success or failure). */
private loading;
/**
* True once the optional `chart.js` peer failed to load (not installed) -- `render()` fails
* closed into a visible `part="error"` and announces through the document-level sink.
*/
private loadFailed;private loadLibrary;private loadZoomFeature;private loadDataLabelsFeature;private loadAnnotationFeature;private loadGeneration;private zoomLoadGeneration;private dataLabelsLoadGeneration;private annotationLoadGeneration;private zoomFeatureState;private dataLabelsFeatureState;private annotationFeatureState;private dataLabelsPlugin?;private annotationPlugin?;private stopAnnotationRegistrationWatch?;private zoomed;private visible;private intersectionObserver?;private intersectionGeneration;private reducedMotionQuery?;private reducedMotionWindow?;private canvasEl?;private configSlotEl?;
/** The current Chart.js instance. Read it only while the element is connected and loaded. */
chart?:LyraChartInstance;private scaledSliceDatasets;private chartJsModule?;private resizeObserver?;private resizeDrawFrame?;private resizeDrawFrameOwner?;private lastObservedInlineSize?;private autoLegendPosition;private resolvedChartArea?;private chartAreaUpdateQueued;private builtType?;private builtPlugins;private visualDatasetSourceIndexes?;private visualRowSourceIndexes?;private suppressZoomComplete;private descriptionId;private keyboardDatumIndex;private keyboardDatumAnnouncement;
/** Shared document-level regions that carry announcements. The visually hidden datum copy is an
*  inspection mirror only because shadow-root live regions are not consistently spoken. */
private politeAnnouncementSink?;private assertiveAnnouncementSink?;private lastDataTruncationAnnouncement;
/** Gates the sampling notice so an initially supplied large dataset is described, not announced. */
private isMounting;private announcedFeatureWarnings;private lastDrawnDirection?;private lastDrawnLocale?;connectedCallback():void;disconnectedCallback():void;adoptedCallback():void;private readonly onReducedMotionChange;private armReducedMotionWatcher;private disarmReducedMotionWatcher;
/** Re-target the ref-counted regions after reconnect/adoption without replaying existing text. */
private syncAnnouncementSinks;private releaseAnnouncementSinks;private get ownerWindow();private computedStyle;
/**
* Called once the `chartjs-plugin-datalabels` peer resolves. Chart.js reads a
* config's inline `plugins: [...]` array ONLY at construction — the in-place
* `chart.data`/`chart.options` update path in `draw()` never picks up a plugin
* added later. So on a cold load (plugin resolves after the chart was already
* built) or a `data-labels`/`stack-totals` turn-on, the live chart must be
* torn down and rebuilt for the per-instance plugin to actually attach. Guards
* on the plugin being newly present so a redraw that already includes it (or a
* feature that's since been turned back off) doesn't needlessly rebuild.
*/
private applyDataLabelsPlugin;private get zoomFeatureAvailable();private featureWarningMessages;private requestZoomFeature;private requestAnnotationFeature;
/**
* Same constraint as `applyDataLabelsPlugin()`: Chart.js reads a config's inline `plugins: [...]`
* array ONLY at construction, so a live chart built before the peer resolved cannot gain it
* through `chart.update()`. Force reconstruction so the next `draw()` takes the `new Chart()`
* branch that reads `config.plugins`.
*/
private applyAnnotationPlugin;
/**
* `chartjs-plugin-annotation` creates its per-chart state only in `beforeInit`, so once it is
* registered globally every chart constructed earlier throws inside the plugin on its next
* update. A chart that requested the feature rebuilds through `applyAnnotationPlugin()`; every
* other live chart rebuilds here so a sibling's annotations cannot break it.
*/
private rebuildAfterAnnotationRegistration;private requestDataLabelsFeature;
/**
* Resets a stale `zoomed` flag before the render pass that's about to call
* `draw()`: a `type` (or `config.type` override) change that lands on a
* *different* effective Chart.js type makes `draw()` destroy the old
* `Chart` instance and construct a brand-new one, which was never zoomed —
* without this, `render()`'s reset-zoom-button stays visible for an
* instance that has no zoom/pan state left to reset. Computed here (before
* render), not in `updated()`/`draw()`, because setting `zoomed` — a
* reactive `@state` property — from `updated()` would schedule a second,
* redundant update pass; `willUpdate()` runs before this cycle's render is
* considered complete, so the same set just folds into the render already
* in progress. Same rationale as `toast-item.ts`'s `willUpdate()`-vs-
* `updated()` split.
*/
protected willUpdate(changed:PropertyValues):void;
/**
* happy-dom (through at least 20.14.5) never fires the default slot's INITIAL `slotchange` --
* see `collectInitialSlotAssignment`'s own doc -- so an `<lr-chart>` whose
* `<script type="application/json">` raw config already exists at connect (the ordinary
* "render once data is ready" Lit pattern) would otherwise never pick it up. Collect once here
* too, from the slot's current assignment; `collectConfigFromSlot()` simply recomputes and
* overwrites `slottedConfig` from scratch each call, so a real browser firing the initial event
* as well is naturally idempotent -- the second call reads back the same assigned elements and
* writes the same value.
* Deferred a microtask: `slottedConfig` is a reactive `@state`, so writing it synchronously
* inside `firstUpdated()` -- after this same update has already been marked complete -- trips
* Lit's "scheduled an update after an update completed" dev warning. A real `slotchange` event
* runs this same collection from a task/microtask entirely outside the update cycle, which never
* trips it; queuing a microtask here reproduces that same "outside the cycle" timing instead of
* writing `slottedConfig` from inside it. Still guaranteed to land before any caller's own
* `await el.updateComplete` continuation: that continuation is queued only once this update's
* promise resolves, later in this same synchronous turn, so it always joins the microtask queue
* behind the one queued here.
*/
protected firstUpdated(changed:PropertyValues):void;protected updated(changed:PropertyValues):void;
/**
* Subclass extension point for derived reactive inputs. Keeping this gate in the normal
* visibility-checked update path prevents subclasses such as histogram from issuing a second,
* unconditional post-update redraw.
*/
protected chartContentChanged(changed:PropertyValues):boolean;private seriesToDataset;
/** Let Chart.js resolve an authored default -- including scriptable/indexable values -- at its
* native `datasets.<datasetTypeKey>` / `elements.<elementKey>` / top-level `options` scope,
* instead of shadowing every one of those scopes with a generated per-dataset fallback.
* Generalizes the bar-only precedence check to every element type Chart.js resolves the same
* way (arc for pie/doughnut/polar-area, point for radius on any point-bearing dataset type). */
private hasConfiguredElementOption;private hasConfiguredBarOption;
/**
* Resolves the `--lr-chart-*` theme tokens (declared in
* `chart.styles.ts`, each layered over an existing semantic token) via
* `getComputedStyle`. Chart.js renders to canvas, not the DOM, so it can't
* consume CSS `var()` directly — same constraint documented on
* `heatmap.ts`'s `labelColor()`/`noDataFill()`/`scaleEndpoints()` — so this
* is called fresh from `buildConfig()` on every draw rather than cached.
*/
private themeColors;private styleColor;private styleNumber;
/**
* The radar/polarArea `r`-scale `pointLabels` font size ONLY when the consumer has explicitly
* set the PUBLIC `--lr-chart-tick-font-size` token -- `undefined` otherwise. Deliberately
* ignores the PRIVATE `--_lr-chart-tick-font-size` fallback that `chart.styles.ts` always sets
* (to size the adjacent tick labels at 12px): `RadialLinearScale`'s own built-in `pointLabels`
* default is 10px, not the global 12px tick default, so an unset public token must leave
* `pointLabels.font` unset entirely and let Chart.js apply that scale-specific default, exactly
* as it did before `--lr-chart-tick-font-size` existed. When the consumer DOES set the public
* token, this returns the same resolved size `theme.tickFontSize` uses for the ticks, so the
* two stay in sync as documented.
*/
private explicitTickFontSize;
/**
* Builds a small deterministic CanvasPattern for the category index, using the family-wide
* encoding table in `chart-forced-colors.ts` so `<lr-box-plot>` and `<lr-lite-chart>` texture
* their own series identically.
*/
private forcedColorPattern;private chartStyleOptions;
/** Whether this chart wants the optional `chartjs-plugin-datalabels` peer loaded — either to draw
*  per-point data labels or per-stack totals. */
private get needsDataLabels();private get needsAnnotations();
/**
* The usable annotations: a finite single `value`, or a finite `from`/`to` pair. An entry
* supplying neither (or non-finite numbers) is dropped rather than handed to Chart.js, where it
* renders nothing at best. A reversed range is normalized rather than rejected — the author's
* intent is unambiguous.
*/
private normalizedAnnotations;
/** Resolves an annotation tone to a canvas-ready color, through the same
*  `getComputedStyle`-then-`resolveCanvasColor` path every other chart color takes — canvas
*  silently ignores an unparseable `strokeStyle`/`fillStyle`. */
private annotationColor;
/**
* The `chartjs-plugin-annotation` options for this chart, keyed by a stable synthetic id.
* A single `value` becomes a `line` on that axis's scale; a `from`/`to` pair becomes a `box`
* bounded on that axis and unbounded on the other.
*/
private annotationOptions;
/**
* `options.plugins.datalabels`. Always emitted so the chart also stays inert if
* a consumer independently registers the peer globally — returns `{ display: false }`
* unless `data-labels`/`stack-totals` is set. The label
* color is resolved via `getComputedStyle` (the same `themeColors()` tick
* color) because Chart.js paints to canvas and cannot read `var()`.
*
* `stackTotals` draws once per category per (axis, `LyraChartSeries.stack` group): the plugin
* fires per (dataset, point), so a total is shown only on the topmost dataset of each group
* whose OWN axis is actually stacked (`axisStacked()`) and its formatter returns the null-aware
* `computeStackTotals()` value for that group (blank when the whole category is null). Two
* stack groups sharing one axis each get their own total, drawn above their own topmost
* dataset. When only `dataLabels` is set, or a dataset's axis isn't stacked, each point shows
* its own value; a null/non-finite point renders blank.
*/
private datalabelsOptions;
/** Locale/format a data-label number through the same `valueFormatter` the axis/tooltip use, so a
*  drawn label matches the rest of the chart; falls back to a plain locale string. The formatter
*  runs in the `'tooltip'` context — the closest semantic match to an on-point value label, so a
*  consumer formatter that branches on context behaves predictably rather than seeing `undefined`. */
private formatDataLabel;
/**
* Per-category stack totals for the datasets on axis `axisId` (`'y'`/`'y2'`) belonging to
* `stackGroup` (a `LyraChartSeries.stack` id), or `null` for a category whose every value is
* null/undefined (so no total is drawn there rather than a misleading `0`). `stackGroup`
* defaults to `undefined` -- the implicit group every series without its own `stack` id
* shares -- so an existing call site untouched by the per-series `stack` feature keeps summing
* exactly the datasets it always did. Reads the same per-point values as the sr-only data
* table, null-aware — canvas draws these via the datalabels plugin, but the numbers themselves
* stay screen-reader available through `renderDataTable()`.
*/
private computeStackTotals;
/**
* Resolves the categorical series palette (`--lr-color-chart-1..8`, declared in
* `internal/specialist-tokens.styles.ts` as indirections through
* `--lr-theme-color-chart-1..8`, with their own dark-theme ramp) via `getComputedStyle` —
* same canvas-can't-read-`var()` constraint as `themeColors()`, and the same source
* `<lr-lite-chart>` draws its default palette from. Feeds `seriesToDataset()` a concrete,
* theme-aware default color for any series that sets no `color` of its own. Falls back to
* the light-mode literals only if the custom properties can't be resolved (host detached).
*
* Public so app code can color its own chart-adjacent UI (legends, KPI tiles, annotations
* fed through the raw `config` passthrough) from the same resolved ramp the chart itself
* uses, instead of hand-resolving `--lr-color-chart-N` and drifting out of sync with the
* active theme. Returns a fresh array on every call — mutating it does not affect the chart.
*/
seriesPalette():string[];private tickOptions;private effectiveIndexAxis;
/** The resolved Chart.js scale type for a value axis, honoring `scaleType`. */
private valueScaleType;
/** `beginAtZero` for a value axis, suppressed on a logarithmic scale which cannot place zero. */
private valueBeginAtZero;private scaleBounds;private gridAxisVisible;private axisVisible;
/**
* Resolves whether `axisId`'s scale should stack, folding `stackedAxes`'s per-axis override
* over the chart-wide `stacked` default. `'x'` has no override of its own -- it mirrors the
* resolved `'y'` value, since Chart.js's stacking contract needs the paired index and value
* scales to agree (an unstacked value scale ignores an index scale marked `stacked`, and vice
* versa). Every axis falls back to `stacked` when `stackedAxes` (or its own entry) is unset,
* which is what keeps a chart that never sets `stackedAxes` byte-identical to before.
*/
private axisStacked;
/**
* Builds `options.scales` for the effective chart type: no scale at all for
* pie/doughnut (a proportional-area chart has no axis), the single radial
* `r` scale Chart.js v4 uses for radar/polarArea, and the cartesian
* `x`/`y`(/`y2`) block for every other (line/bar/scatter/bubble) type — with
* `x` itself further split within that block: scatter and bubble datasets
* carry raw numeric `{x, y(, r)}` points (via `LyraChartSeries.points`) and need a
* linear `x` scale, while line/bar plot against `labels` and need the
* default categorical one. `theme` (from `themeColors()`) drives every
* scale's `ticks.color`/`grid.color`/axis `title.color` so grid lines and
* labels retheme instead of sitting at Chart.js's own hardcoded defaults.
*/
private buildScales;
/**
* `options.onClick` handler wired in `buildConfig()`. The chart-wide
* `interaction` mode above (`'index'`/`'nearest'`, `intersect: false`) is
* tuned for hover tooltips — resolving which single point/segment was
* actually clicked needs its own `getElementsAtEventForMode('nearest', {
* intersect: true }, true)` lookup instead, so a click landing off any
* point/segment reports nothing (`elements` empty) rather than firing for
* whatever's nearest. Covers the per-bar/per-segment click ask for any
* chart type (bar/line/pie/doughnut/etc.), not just bars.
*/
private handlePointClick;private chartDatums;private datumDisplayValue;private datumAnnouncement;private activateDatum;private onCanvasFocus;private onCanvasKeyDown;
/**
* `config.type` (if set) overrides the attribute `type` post-merge — this
* is the one place that resolution logic lives, shared by `buildConfig()`
* (which needs it to build scales/interaction for the right type) and
* `willUpdate()` (which needs it to detect a type change against the last
* *actually built* type, `this.builtType`, before the render pass that
* would rebuild the `Chart` instance).
*/
private effectiveType;
/** Localized chart-type name for `chartDescription()`'s sr-only summary. `effectiveType()` can
*  return a raw Chart.js type string a consumer set through the `config` passthrough (including a
*  custom registered controller name beyond this library's own `LyraChartType` union) -- that's
*  caller-supplied data, not library copy, so it passes through untranslated rather than through
*  `localize()`, matching every other known type's localized label. */
private localizedChartType;
/**
* The tick/tooltip/legend/table value path. `metadata` is spread onto the unified formatter's
* context exactly as the table/export/spoken helpers already do theirs; the legacy positional
* `valueFormatter` has no place to carry it and is called unchanged.
*/
private formatValue;
/**
* The scale `dataset`'s values are plotted against, for the formatter context's `axis` field.
* A point dataset's `x`/`r` components are told apart by `statistic`, not by this -- `axis`
* names the scale the dataset's primary value sits on.
*/
private datasetValueAxis;
/**
* Formatter metadata for one datum, in SOURCE index space -- the same space the data table,
* CSV export and `lr-point-click` already report, so a formatter's `datasetIndex`/`index` mean
* one thing across every surface even while sampling has renumbered what Chart.js sees.
*/
private datumFormatterMetadata;
/**
* The same metadata for a call site that ALREADY holds source indexes -- the rendered DOM legend,
* whose entries come from `dataTableSample()`'s source-space `seriesIndexes`/`rowIndexes`.
* Mapping those through the visual tables a second time renumbers them onto a different series
* whenever sampling is active, so the legend entry would report the label and index of a series
* other than the one its own swatch paints.
*/
private sourceDatumFormatterMetadata;
/**
* A stack total is the sum ACROSS the stack's datasets, so it names none of them. Carrying the
* topmost dataset's `datasetIndex`/`seriesLabel` would make a formatter that branches on the
* series render one series' unit for a cross-series number; `lr-lite-chart`'s total cells drop
* both for exactly that reason. The axis survives, because every dataset in one stack shares it
* and it is what a dual-axis formatter needs to pick the total's unit.
*/
private stackTotalMetadata;
/** `effective` is threaded in: `effectiveData()` rebuilds every label and dataset array, and this
*  runs once per legend entry, so resolving it here would rebuild it N times per legend pass. */
private legendValue;private legendLabels;private tooltipLabel;
/**
* Resolves one hovered tooltip item into the unified formatter context, for
* `tooltipTitleFormatter`/`tooltipFooterFormatter`. Mirrors `tooltipLabel()`'s raw-value and
* rescaled-slice resolution so a hovered item's `value` means the same number on every tooltip
* surface, but returns the context object itself rather than one rendered string -- title/footer
* need every hovered item's context at once, not one item's formatted text. `undefined` for an
* item with no numeric value, so it's dropped from the group rather than passed through as
* `NaN`.
*/
private tooltipItemContext;
/**
* Runs `formatter` (`tooltipTitleFormatter`/`tooltipFooterFormatter`) against every hovered
* item's context at once. `undefined` when the formatter itself is unset -- the caller uses that
* to omit the Chart.js `title`/`footer` callback entirely, which leaves Chart.js's own default
* in place -- or when no hovered item resolved a numeric value.
*/
private tooltipGroupText;private updateAutoLegendPosition;private legendPositionForConfig;private legendPositionForLayout;
/**
* The `data-legend-position` token that selects `[part='base']`'s grid template. Deliberately
* *not* the physical side `legendPositionForLayout()` reports: CSS Grid numbers a two-column
* template along the inline axis, so the template already mirrors itself under `dir="rtl"`.
* Feeding the direction-compensated physical value in here mirrored a side legend a second time
* and landed it on the opposite edge from the one `start`/`end` names. The logical aliases
* therefore pick a column outright and let the grid perform the single mirror, while a literal
* `left`/`right` (the Chart.js-vocabulary passthrough) is pre-compensated so it stays on the
* physical edge its name promises. `auto` keeps its existing reading-end placement.
*/
private legendGridPlacement;private updateChartArea;
/** The current Chart.js chart-area geometry in canvas-local coordinates. Read-only -- derived
*  from the live Chart.js instance's own layout pass, never assignable. The setter is a
*  documented no-op (matching `lr-histogram`'s `labels`/`datasets` pattern) so an accidental
*  `.chartArea=${x}` Lit template binding degrades silently instead of throwing from inside
*  lit-html's property-commit. */
get chartArea():LyraChartArea|undefined;set chartArea(_value:LyraChartArea|undefined);private buildConfig;
/** Keep proportional slice geometry finite while every Lyra readout retains source values. */
private scaleExtremeSlices;private draw;private drawIfVisible;
/** Destroys the peer instance and reconciles the Lyra-owned zoom state in one place. */
private discardChart;
/**
* Renders or incrementally updates the current Chart.js instance from the effective public
* properties/config. Offscreen/disconnected charts remain gated until visible/reconnected.
*/
renderChart():void;
/** Reset any active zoom/pan back to the original view. */
resetZoom():void;
/**
* Forces a redraw so `themeColors()` re-reads the `--lr-chart-*` custom
* properties from the current computed style. A {@link ThemeWatcher} now
* calls this automatically when `prefers-color-scheme` flips or an ancestor's
* `class`/`style`/`data-theme`/`data-color-scheme` attribute mutates, so a
* consumer flipping an upstream theme attribute no longer has to. It remains
* public as the manual escape hatch for theme changes those signals can't
* observe (e.g. a same-attribute value swap the observer already covers is
* handled, but a fully out-of-band restyle is not).
*/
refreshTheme():void;
/** Aggregates a numeric series without materializing a second unbounded values array. */
private summarizeSeries;private formatSummaryValue;private formatTableValue;
/**
* The `'export'` surface, for CSV cells. `LyraChartFormatSurface` has always declared it and
* `<lr-lite-chart>` has always emitted it, but this component never did -- so one formatter
* written against the documented contract behaved differently depending on which chart rendered
* it, silently, in exactly the place unit formatting matters most.
*
* Deliberately NOT falling back to `formatSummaryValue()`: with no formatter installed a CSV cell
* must stay the raw machine-readable number, not a locale-grouped string a spreadsheet would
* misparse. `undefined` means "leave the cell as it was".
*/
private formatExportValue;
/** The `'spoken'` surface, for the live announcement a keyboard user hears. Falls back to the
*  legacy `valueFormatter` (mapped to its `'table'` context, matching `formatTableValue()`/
*  `formatExportValue()`), then the locale number format. */
private formatSpokenValue;private tableStackAxes;private tableStackTotalLabel;private accessibleName;private chartDescription;private dataTableSample;private generatedDataIsSampled;private dataTruncationMessage;private renderDataTable;private hasCustomDataTable;private legendTextFor;private legendColor;private toggleDataset;private toggleDatum;private renderLegend;render():TemplateResult;private get showsLegend();}declare global{interface HTMLElementTagNameMap{'lr-chart':LyraChart;}}