@oliasoft-open-source/charts-library 7.0.0 → 7.0.1

package/dist/index.d.ts

@@ -8,6 +8,7 @@ import { Plugin as Plugin_2 } from 'chart.js';
 import { ReactNode } from 'react';
 import { ScaleOptions } from 'chart.js';
 
+/** Alignment identifiers used by chart layout and legend options. */
 export declare enum AlignOptions {
     End = "end",
     Start = "start",
@@ -16,6 +17,7 @@ export declare enum AlignOptions {
     Left = "left"
 }
 
+/** Annotation shape identifiers. */
 export declare enum AnnotationType {
     Box = "box",
     Ellipse = "ellipse",
@@ -24,22 +26,65 @@ export declare enum AnnotationType {
     Label = "label"
 }
 
+/** Cartesian axis identifiers. */
 export declare enum AxisType {
     X = "x",
     Y = "y"
 }
 
+/**
+ * Renders vertical or horizontal bars with optional stacking, annotations and a legend.
+ *
+ * Pass partial configuration through `chart`; omitted settings receive component defaults.
+ * The example uses sample data, labels and a height of 320 pixels; these are not default values.
+ *
+ * @remarks
+ * Defaults: vertical bars, a top-left legend, zero included in automatic scale bounds, and annotations enabled.
+ * Zoom, pan, stacking and data labels are disabled. No fixed width or height is assigned.
+ * Performance mode is enabled by default, disabling animations.
+ * The linked reference lists the complete normalized default configuration.
+ *
+ * @see https://gitlab.com/oliasoft-open-source/charts-library/-/blob/master/README.md#barchart
+ *
+ * @param props - Chart data and options.
+ * @returns The chart canvas and its associated UI.
+ * @example
+ * ```tsx
+ * <BarChart chart={{
+ *   data: {
+ *     labels: ['A', 'B', 'C'],
+ *     datasets: [{
+ *       label: 'DS A',
+ *       data: [{ x: 'A', y: 10 }, { x: 'B', y: 20 }, { x: 'C', y: 15 }],
+ *     }],
+ *   },
+ *   options: {
+ *     direction: 'vertical',
+ *     axes: {
+ *       x: [{ label: 'Category', position: 'bottom' }],
+ *       y: [{ label: 'Value', position: 'left' }],
+ *     },
+ *     chartStyling: { height: 320 },
+ *     legend: { display: true, position: 'top-left' },
+ *     graph: { showDataLabels: false },
+ *   },
+ * }} />
+ * ```
+ */
 export declare const BarChart: (props: IBarChartProps) => JSX.Element;
 
+/** Cartesian rendering orientation; this does not select LineChart tooltip content. */
 export declare enum ChartDirection {
     VERTICAL = "vertical",
     HORIZONTAL = "horizontal"
 }
 
+/** Hover interaction modes used by the library. */
 export declare enum ChartHoverMode {
     Nearest = "nearest"
 }
 
+/** Chart.js chart-kind identifiers used by the library. */
 export declare enum ChartType {
     LINE = "line",
     BAR = "bar",
@@ -48,8 +93,10 @@ export declare enum ChartType {
     SCATTER = "scatter"
 }
 
+/** Default categorical DS colour palette. Treat the exported array as read-only. */
 export declare const COLORS: string[];
 
+/** CSS cursors used during chart interactions. */
 export declare enum CursorStyle {
     Pointer = "pointer",
     Initial = "initial",
@@ -59,16 +106,19 @@ export declare enum CursorStyle {
     Move = "move"
 }
 
+/** Recursively makes object properties optional while preserving callable types and array element shapes. */
 export declare type DeepPartial<T> = T extends (...args: any[]) => any ? T : T extends Array<infer U> ? Array<DeepPartial<U>> : T extends object ? {
     [K in keyof T]?: DeepPartial<T[K]>;
 } : T;
 
+/** Allowed axes for annotation dragging. */
 export declare enum DragAxis {
     X = "x",
     Y = "y",
     Both = "both"
 }
 
+/** Annotation shape identifiers. */
 export declare enum DraggableAnnotationType {
     POINT = "point",
     BOX = "box",
@@ -77,6 +127,7 @@ export declare enum DraggableAnnotationType {
     LABEL = "label"
 }
 
+/** DOM event names used by chart interaction handlers. */
 export declare enum Events {
     Mousemove = "mousemove",
     Mouseout = "mouseout",
@@ -86,8 +137,20 @@ export declare enum Events {
     Dblclick = "dblclick"
 }
 
+/**
+ * Builds a darkest-first palette by varying LCH lightness while retaining the starting hue and chroma.
+ *
+ * @param length - Requested number of colours. Use a non-negative integer; zero returns an empty array.
+ * @param startingColor - Colour understood by colord. A length of one returns this string unchanged.
+ * @returns CSS LCH colour strings, except for the unchanged single-colour case.
+ * @example
+ * ```ts
+ * const colors = getGroupedColorScheme(3, '#3366cc');
+ * ```
+ */
 export declare const getGroupedColorScheme: (length: number, startingColor: string) => string[];
 
+/** Direction of the background gradient between chart-area edges or corners. */
 export declare enum GradientDirection {
     TopToBottom = 0,
     BottomToTop = 1,
@@ -99,140 +162,237 @@ export declare enum GradientDirection {
     TopRightToBottomLeft = 7
 }
 
+/** Annotation label options, including additional plugin-specific fields. */
 export declare interface IAnnotationLabelConfig {
+    /** Canvas fill colour; arrays provide per-element colours where supported. */
     backgroundColor?: string;
+    /** Whether this element is visible. */
     display?: boolean;
+    /** Visual placement of this element. */
     position?: string;
+    /** Canvas/CSS colour used by this element. */
     color?: string;
+    /** Canvas font specification used for the text. */
     font?: string;
+    /** Canvas colour used for the element outline. */
     borderColor?: string;
+    /** Additional connector settings for an annotation label. */
     callout?: Record<string, unknown>;
     [key: string]: unknown;
 }
 
+/** BarChart scale options with independent X/Y stacking controls. */
 export declare interface IBarAdditionalAxesOptions extends ICommonAdditionalAxesOptions {
+    /** Enables stacking on the X scale. */
     stackedX?: boolean;
+    /** Enables stacking on the Y scale. */
     stackedY?: boolean;
 }
 
+/** Ordered horizontal and vertical BarChart axis collections. */
 export declare interface IBarAxes {
+    /** Horizontal axis definitions in order. */
     x: ICommonAxis<'top' | 'bottom'>[];
+    /** Vertical axis definitions in order. */
     y: ICommonAxis<'left' | 'right'>[];
     [key: string]: ICommonAxis[];
 }
 
+/** Bar labels and DS definitions. */
 export declare interface IBarChartBaseData {
+    /** Labels associated with the input data. */
     labels: string[];
+    /** DS definitions in rendering order. */
     datasets: IBarChartDataset[];
 }
 
+/** Normalized BarChart data, options and controls container. */
 export declare interface IBarChartData extends ICommonData {
+    /** Test identifier applied to the rendered chart container. */
     testId?: string;
+    /** ID of an existing DOM element in which chart controls should be rendered. */
     controlsPortalId?: string;
+    /** Values rendered by the chart or DS. */
     data: IBarChartBaseData;
+    /** Configuration for this chart or generated element. */
     options: IBarOptions;
 }
 
+/** Consumer-facing BarChart configuration with optional datasets and options. */
 export declare interface IBarChartDataInput extends Omit<IBarChartData, 'options' | 'data'> {
+    /** Values rendered by the chart or DS. */
     data?: Omit<DeepPartial<IBarChartData['data']>, 'datasets'> & {
+        /** DS definitions in rendering order. */
         datasets?: Array<DeepPartial<IBarChartDataset> | object | null>;
     };
+    /** Configuration for this chart or generated element. */
     options?: IBarOptionsInput;
 }
 
+/** Input bar DS, including axis bindings and legend grouping. */
 export declare interface IBarChartDataset extends ICommonDataset {
+    /** Marks a generated DS as annotation data rather than plotted input data. */
     isAnnotation?: boolean;
+    /** Index of the source annotation in the annotation collection. */
     annotationIndex?: number;
+    /** Controls whether a bar border edge is omitted. */
     borderSkipped?: boolean;
+    /** Bar corner radius in pixels. */
     borderRadius?: number;
+    /** Horizontal scale ID for this DS, such as `x` or `x2`. */
     xAxisID?: string;
+    /** Vertical scale ID for this DS, such as `y` or `y2`. */
     yAxisID?: string;
+    /** Initial visibility flag for the DS. */
     hidden?: boolean;
+    /** Groups DS entries for legend display. */
     displayGroup?: string | number;
+    /** Chart or annotation kind. */
     type?: ChartType.BAR;
 }
 
+/** Props accepted by the BarChart React component. */
 export declare interface IBarChartProps {
+    /** Chart data and options. Omitted optional settings are resolved by the component defaults. */
     chart: IBarChartDataInput;
 }
 
+/** BarChart configuration after default values have been applied. */
 export declare interface IBarDefaultProps {
+    /** Test identifier applied to the rendered chart container. */
     testId: string;
+    /** ID of an existing DOM element in which chart controls should be rendered. */
     controlsPortalId: string;
+    /** Values rendered by the chart or DS. */
     data: IBarChartBaseData;
+    /** Configuration for this chart or generated element. */
     options: {
+        /** Chart title; an array represents multiple lines. */
         title?: string | string[];
+        /** Chart orientation. Support and interpretation depend on the chart component. */
         direction: 'vertical' | 'horizontal';
+        /** Axis descriptions. Configure horizontal axes in `x` and vertical axes in `y`. */
         axes: IBarAxes;
+        /** Scale behaviour, bounds and tick settings shared across the chart axes. */
         additionalAxesOptions: IBarAdditionalAxesOptions;
+        /** Chart sizing and visual layout settings. */
         chartStyling: IBarStyling;
+        /** Tooltip visibility, formatting and supported callbacks. */
         tooltip: ICommonTooltip;
+        /** Geometry, grid and data-label rendering options. */
         graph: IChartGraph;
+        /** Chart.js scale configuration keyed by scale ID. */
         scales?: ICommonScales;
+        /** Annotation visibility, interaction and geometry configuration. */
         annotations: {
+            /** Whether configured annotations are rendered. */
             showAnnotations: boolean;
+            /** Enables annotation controls where supported by the chart. */
             controlAnnotation: boolean;
+            /** Annotation definitions in drawing order. */
             annotationsData: ICommonAnnotationsData[];
         };
+        /** Legend visibility, placement and custom rendering options. */
         legend: IBarLegend;
+        /** Initial interaction and rendering controls. */
         chartOptions: ICommonChartOptions;
+        /** Callbacks for legend and pointer interactions. */
         interactions: ICommonInteractions;
+        /** Point-dragging options and lifecycle callbacks. */
         dragData: ICommonDragData;
     };
 }
 
+/** BarChart legend options, including custom HTML legend integration. */
 export declare interface IBarLegend extends ICommonLegend {
+    /** Custom legend plugin and its target DOM container. */
     customLegend?: ICommonCustomLegend<any>;
 }
 
+/** Resolved BarChart options. Use {@link IBarOptionsInput} for partial consumer configuration. */
 export declare interface IBarOptions extends ICommonOptions {
+    /** Chart orientation. Support and interpretation depend on the chart component. */
     direction?: 'vertical' | 'horizontal';
+    /** Axis descriptions. Configure horizontal axes in `x` and vertical axes in `y`. */
     axes: IBarAxes;
+    /** Chart.js scale configuration keyed by scale ID. */
     scales?: ICommonScales;
+    /** Scale behaviour, bounds and tick settings shared across the chart axes. */
     additionalAxesOptions?: IBarAdditionalAxesOptions;
+    /** Chart sizing and visual layout settings. */
     chartStyling: IBarStyling;
+    /** Geometry, grid and data-label rendering options. */
     graph?: ICommonGraph;
+    /** Annotation visibility, interaction and geometry configuration. */
     annotations?: ICommonAnnotations;
+    /** Legend visibility, placement and custom rendering options. */
     legend?: IBarLegend;
+    /** Point-dragging options and lifecycle callbacks. */
     dragData?: ICommonDragData;
 }
 
+/**
+ * Partial BarChart options accepted at the component boundary.
+ * Unknown fields are accepted for compatibility, not guaranteed to be forwarded.
+ */
 export declare type IBarOptionsInput = Omit<DeepPartial<IBarOptions>, 'title' | 'direction' | 'axes' | 'legend' | 'chartStyling' | 'interactions' | 'annotations' | 'additionalAxesOptions' | 'scales'> & {
     [key: string]: unknown;
+    /** Chart title; an array represents multiple lines. */
     title?: unknown;
+    /** Chart orientation. Support and interpretation depend on the chart component. */
     direction?: string;
+    /** Axis descriptions. Configure horizontal axes in `x` and vertical axes in `y`. */
     axes?: {
+        /** Horizontal axis definitions in order. */
         x?: ILooseBarAxis[];
+        /** Vertical axis definitions in order. */
         y?: ILooseBarAxis[];
         [key: string]: ILooseBarAxis[] | undefined;
     };
+    /** Legend visibility, placement and custom rendering options. */
     legend?: Omit<DeepPartial<IBarLegend>, 'position' | 'align'> & {
+        /** Visual placement of this element; does not select LineChart tooltip axes. */
         position?: string;
+        /** Alignment within the available layout space. */
         align?: string;
         [key: string]: unknown;
     };
+    /** Chart sizing and visual layout settings. */
     chartStyling?: DeepPartial<IBarStyling> & {
+        /** Compatibility input; not currently consumed by the chart option normalizers. */
         hideControls?: boolean;
+        /** Compatibility input; not currently consumed by the chart option normalizers. */
         minHeight?: number | string;
         [key: string]: unknown;
     };
+    /** Scale behaviour, bounds and tick settings shared across the chart axes. */
     additionalAxesOptions?: Omit<DeepPartial<IBarAdditionalAxesOptions>, 'chartScaleType'> & {
+        /** Scale family used when constructing axes. */
         chartScaleType?: string;
         [key: string]: unknown;
     };
+    /** Chart.js scale configuration keyed by scale ID. */
     scales?: Record<string, unknown>;
+    /** Callbacks for legend and pointer interactions. */
     interactions?: DeepPartial<ICommonInteractions> & {
+        /** Compatibility interaction input; configure zoom through `chartOptions.enableZoom`. */
         enableZoom?: boolean;
+        /** Compatibility interaction input; configure pan through `chartOptions.enablePan`. */
         enablePan?: boolean;
         [key: string]: unknown;
     };
+    /** Annotation visibility, interaction and geometry configuration. */
     annotations?: (Omit<DeepPartial<ICommonAnnotations>, 'annotationsData'> & {
+        /** Annotation definitions in drawing order. */
         annotationsData?: ILooseBarAnnotation[];
     }) | null;
 };
 
+/** BarChart canvas sizing and padding. */
 export declare interface IBarStyling extends ICommonStyling {
+    /** Requests a square chart layout; LineChart also accepts a numeric layout value. */
     squareAspectRatio?: boolean;
+    /** Padding around the chart area, globally or per side. */
     layoutPadding?: string | number | {
         top: number;
         bottom: number;
@@ -241,36 +401,63 @@ export declare interface IBarStyling extends ICommonStyling {
     };
 }
 
+/** Appearance, geometry and drag callbacks for a callout label. */
 export declare interface ICalloutLabelConfig {
+    /** Whether this feature is active. */
     enabled?: boolean;
+    /** Canvas/CSS colour used by this element. */
     color?: string;
+    /** Canvas font specification used for the text. */
     font?: string;
+    /** Canvas colour used for the element outline. */
     borderColor?: string;
+    /** Canvas stroke colour used by the connector. */
     strokeStyle?: string;
+    /** Stroke width in canvas pixels. */
     lineWidth?: number;
+    /** Connector clearance from the source element, in canvas pixels. */
     startOffset?: number;
+    /** Connector clearance from the label end, in canvas pixels. */
     endOffset?: number;
+    /** Callout label margin in pixels. */
     margin?: number;
+    /** X coordinate in scale units. */
     xValue?: number;
+    /** Y coordinate in scale units. */
     yValue?: number;
+    /** Horizontal adjustment of the annotation label in pixels. */
     xAdjust?: number;
+    /** Vertical adjustment of the annotation label in pixels. */
     yAdjust?: number;
+    /** Called when a drag starts. */
     onDragStart?: (coordinates: ICoordinates, annotation: ICommonAnnotationsData) => void;
+    /** Called as the dragged value or annotation position changes. */
     onDrag?: (coordinates: ICoordinates, annotation: ICommonAnnotationsData) => void;
+    /** Called when dragging ends. */
     onDragEnd?: (coordinates: ICoordinates, annotation: ICommonAnnotationsData) => void;
 }
 
+/** Data-label plugin display and formatting options. */
 export declare interface IChartDataLabelsOptions {
+    /** Whether this element is visible. */
     display?: 'auto' | boolean;
+    /** Alignment within the available layout space. */
     align?: 'center';
+    /** Anchor used to place the data label relative to its element. */
     anchor?: 'center';
+    /** Formats the displayed data label from the value and plugin context. */
     formatter?: (_value: unknown, context: unknown) => unknown;
 }
 
+/** Legend label produced by chart dataset generation. */
 export declare interface IChartGeneratedLabel {
+    /** Text to display; arrays represent multiple lines where supported. */
     text: string;
+    /** Canvas fill style used by the generated legend label. */
     fillStyle: string;
+    /** Canvas stroke colour used by the connector. */
     strokeStyle: string;
+    /** Zero-based index of the data item. */
     index: number;
 }
 
@@ -278,486 +465,872 @@ declare interface IChartGraph {
     showMinorGridlines?: boolean;
 }
 
+/** DS visibility metadata passed to legend filtering helpers. */
 export declare interface IChartLegendItemFilter {
+    /** Zero-based index of the data item. */
     index: number;
+    /** Zero-based index of the DS in the chart data. */
     datasetIndex: number;
+    /** Initial visibility flag for the DS. */
     hidden: boolean;
 }
 
+/** Shared Cartesian scale behaviour and range settings. */
 export declare interface ICommonAdditionalAxesOptions {
+    /** Scale family used when constructing axes. */
     chartScaleType?: 'linear' | 'logarithmic' | 'time' | 'timeseries';
+    /** Reverses the relevant scale or marker direction. */
     reverse?: boolean;
+    /** Includes zero when determining automatic scale bounds. */
     beginAtZero?: boolean;
+    /** Requested spacing between axis ticks, in scale units. */
     stepSize?: number;
+    /** Enables stacked rendering where supported. */
     stacked?: boolean;
+    /** Suggested lower scale bound; data may extend beyond it. */
     suggestedMin?: number;
+    /** Suggested upper scale bound; data may extend beyond it. */
     suggestedMax?: number;
+    /** Explicit lower bound in scale units. */
     min?: number | string;
+    /** Explicit upper bound in scale units. */
     max?: number | string;
 }
 
+/** A text overlay placed inside the chart area. */
 export declare interface ICommonAnnotation {
+    /** Shows the chart-area text overlay. */
     showLabel?: boolean;
+    /** Text to display; arrays represent multiple lines where supported. */
     text?: string | string[];
+    /** Visual placement of this element. */
     position?: string;
+    /** Text size in pixels. */
     fontSize?: number;
+    /** Horizontal offset of the text overlay in pixels. */
     xOffset?: number;
+    /** Vertical offset of the text overlay in pixels. */
     yOffset?: number;
+    /** Maximum width available for the text overlay, in pixels. */
     maxWidth?: number;
+    /** Text line spacing in pixels. */
     lineHeight?: number;
 }
 
+/** Rendered annotation metadata used by annotation interaction helpers. */
 export declare interface ICommonAnnotationElement {
+    /** Identifier used to associate this configuration with its rendered element. */
     id?: string;
+    /** Whether this element is visible. */
     display: boolean;
+    /** Index of the source annotation in the annotation collection. */
     annotationIndex: number;
+    /** Rendered annotation label content and plugin options. */
     label: {
+        /** Configuration for this chart or generated element. */
         options: LabelOptions;
+        /** Text content of the generated label. */
         content: string;
     };
+    /** Configuration for this chart or generated element. */
     options: {
+        /** Identifier used to associate this configuration with its rendered element. */
         id?: string;
+        /** Chart.js scale ID associated with this element. */
         scaleID?: string;
+        /** Canvas colour used for the element outline. */
         borderColor?: string;
+        /** Outline width in canvas pixels. */
         borderWidth?: number;
+        /** Rendered annotation radius in pixels. */
         radius?: number;
+        /** Rendered annotation label content and plugin options. */
         label?: {
+            /** Text content of the generated label. */
             content?: string;
+            /** Visual placement of this element. */
             position?: string;
+            /** Whether this feature is active. */
             enabled?: boolean;
+            /** Horizontal adjustment of the annotation label in pixels. */
             xAdjust?: number;
         };
     };
 }
 
+/** Annotation collection and associated controls. */
 export declare interface ICommonAnnotations {
+    /** Whether configured annotations are rendered. */
     showAnnotations?: boolean;
+    /** Enables annotation controls where supported by the chart. */
     controlAnnotation?: boolean;
+    /** Enables annotation dragging in the corresponding controls. */
     enableDragAnnotation?: boolean;
+    /** Enables callout annotation controls in LineChart. */
     enableCalloutAnnotation?: boolean;
+    /** Line-marker plugin configuration. */
     lineMarkersAnnotation?: ILineMarkersAnnotation;
+    /** Annotation definitions in drawing order. */
     annotationsData?: ICommonAnnotationsData[];
+    /** Text overlay drawn inside the chart area. */
     labelAnnotation?: ICommonAnnotation;
 }
 
+/**
+ * Geometry and interaction settings for one annotation.
+ * Coordinate values use the referenced scales; pixel offsets are named separately.
+ */
 export declare interface ICommonAnnotationsData {
+    /** Whether this element is visible. */
     display?: boolean;
+    /** Excludes this entry from the legend where supported. */
     hideLegend?: boolean;
+    /** Pixel offset between the label and its associated geometry. */
     labelOffsetPx?: number;
+    /** Identifier used to associate this configuration with its rendered element. */
     id?: string;
+    /** Whether this annotation may expand the scale bounds to remain visible. */
     adjustScaleRange?: boolean;
+    /** Axis on which `value` and `endValue` locate the annotation. */
     annotationAxis?: 'x' | 'y';
+    /** Annotation rotation in degrees. */
     rotation?: number;
+    /** Canvas/CSS colour used by this element. */
     color?: string;
+    /** End coordinate of a ranged annotation on `annotationAxis`. */
     endValue?: number;
+    /** Outline width in canvas pixels. */
     borderWidth?: number;
+    /** Canvas fill colour; arrays provide per-element colours where supported. */
     backgroundColor?: string;
+    /** Display text associated with this element. */
     label?: string;
+    /** Appearance and placement of the annotation label. */
     labelConfig?: IAnnotationLabelConfig;
+    /** Chart or annotation kind. */
     type?: DraggableAnnotationType;
+    /** Numeric value or axis coordinate represented by this item. */
     value?: number;
+    /** Lower X bound in scale units. */
     xMin?: number;
+    /** Upper X bound in scale units. */
     xMax?: number;
+    /** Lower Y bound in scale units. */
     yMin?: number;
+    /** Upper Y bound in scale units. */
     yMax?: number;
+    /** X coordinate in scale units. */
     xValue?: number;
+    /** Y coordinate in scale units. */
     yValue?: number;
+    /** Annotation point or circle radius in pixels. */
     radius?: number;
+    /** Allows this annotation to be dragged when annotation dragging is enabled. */
     enableDrag?: boolean;
+    /** Called when a drag starts. */
     onDragStart?: (coordinates: ICoordinates, annotation: ICommonAnnotationsData) => void;
+    /** Called as the dragged value or annotation position changes. */
     onDrag?: (coordinates: ICoordinates, annotation: ICommonAnnotationsData) => void;
+    /** Called when dragging ends. */
     onDragEnd?: (coordinates: ICoordinates, annotation: ICommonAnnotationsData) => void;
+    /** Restricts annotation movement to X, Y, or both axes. */
     dragAxis?: DragAxis;
+    /** Point marker shape. */
     pointStyle?: string;
+    /** Allows interactive resizing of supported annotations. */
     resizable?: boolean;
+    /** Inclusive dragging limits in axis units, expressed as [minimum, maximum]. */
     dragRange?: {
+        /** Inclusive X dragging bounds [minimum, maximum], in scale units. */
         x?: [number, number];
+        /** Inclusive Y dragging bounds [minimum, maximum], in scale units. */
         y?: [number, number];
     };
+    /** Displays coordinates while dragging an annotation. */
     displayDragCoordinates?: boolean;
+    /** Horizontal Chart.js scale ID used to resolve annotation coordinates. */
     xScaleID?: string;
+    /** Vertical Chart.js scale ID used to resolve annotation coordinates. */
     yScaleID?: string;
+    /** Opacity multiplier between 0 (transparent) and 1 (opaque). */
     opacity?: number;
 }
 
+/** Shared Cartesian axis label, placement and tick settings. */
 export declare interface ICommonAxis<PositionType = string> {
+    /** Display text associated with this element. */
     label?: string;
+    /** Visual placement of this element. */
     position?: PositionType;
+    /** Canvas/CSS colour used by this element. */
     color?: string | string[];
+    /** Unit identifier used by the axis. */
     unit?: string;
+    /** Grid-line configuration for this axis. */
     gridLines?: boolean;
+    /** Requested spacing between axis ticks, in scale units. */
     stepSize?: number;
 }
 
+/** Shared zoom and pan controls; defaults differ between chart components. */
 export declare interface ICommonChartOptions {
+    /** Enables zooming when supported by the chart. */
     enableZoom?: boolean;
+    /** Enables panning when supported by the chart. */
     enablePan?: boolean;
 }
 
+/** Shared legend and title plugin option shapes. */
 export declare interface ICommonChartPlugins {
+    /** Legend visibility, placement and custom rendering options. */
     legend: {
+        /** Visual placement of this element. */
         position: TAxisPosition;
     };
+    /** Chart title; an array represents multiple lines. */
     title: {
+        /** Whether this element is visible. */
         display: boolean;
+        /** Text to display; arrays represent multiple lines where supported. */
         text: string;
     };
 }
 
+/** A Chart.js legend plugin paired with an external DOM container. */
 export declare interface ICommonCustomLegend<T extends keyof ChartTypeRegistry> {
+    /** Chart.js plugin implementing the custom legend; null selects no custom plugin. */
     customLegendPlugin: Plugin_2<T> | null;
+    /** ID of the DOM element used by the custom legend plugin. */
     customLegendContainerID: string;
 }
 
+/** Base chart input extended by component-specific data models. */
 export declare interface ICommonData {
+    /** Test identifier applied to the rendered chart container. */
     testId?: string;
+    /** Values rendered by the chart or DS. */
     data?: {
+        /** Labels associated with the input data. */
         labels?: string[];
+        /** DS definitions in rendering order. */
         datasets?: ICommonDataset[];
     };
+    /** Configuration for this chart or generated element. */
     options: ICommonOptions;
 }
 
+/** Shared input DS fields for Cartesian chart components. */
 export declare interface ICommonDataset {
+    /** DS name used in the legend and tooltip. */
     label?: string;
+    /** Canvas colour used for the element outline. */
     borderColor?: string;
+    /** Canvas fill colour; arrays provide per-element colours where supported. */
     backgroundColor?: string | string[];
+    /** Outline width in canvas pixels. */
     borderWidth?: number;
+    /** Values rendered by the chart or DS. */
     data: ICommonDataValue[];
+    /** Initial visibility flag for the DS. */
     hidden?: boolean;
 }
 
+/** A Cartesian data point with an optional display label. */
 export declare interface ICommonDataValue {
+    /** X coordinate in scale units. */
     x: number | string;
+    /** Y coordinate in scale units. */
     y: number | string;
+    /** Display text associated with this element. */
     label?: string;
 }
 
+/** Data-point dragging configuration passed to the drag-data plugin. */
 export declare interface ICommonDragData {
+    /** Enables dragging data points. Defaults to false. */
     enableDragData?: boolean;
+    /** Displays the drag tooltip while moving a data point. */
     showTooltip?: boolean;
+    /** Rounds values during point dragging. */
     roundPoints?: boolean;
+    /** Allows point dragging along the X axis. */
     dragX?: boolean;
+    /** Allows point dragging along the Y axis. */
     dragY?: boolean;
+    /** Called when a drag starts. */
     onDragStart?: (event: unknown, element: unknown) => unknown;
+    /** Called as the dragged value or annotation position changes. */
     onDrag?: (event: unknown, datasetIndex: number, index: number, value: unknown) => unknown;
+    /** Called when dragging ends. */
     onDragEnd?: (event: unknown, datasetIndex: number, index: number, value: unknown) => unknown;
 }
 
+/** Background gradient settings used by ScatterChart. */
 export declare interface ICommonGradient {
+    /** Whether this element is visible. */
     display: boolean;
+    /** Ordered colour stops for the background gradient. */
     gradientColors?: ICommonGradientColor[];
+    /** Chart orientation. Support and interpretation depend on the chart component. */
     direction?: GradientDirection;
 }
 
+/** One colour stop in a canvas gradient. */
 export declare interface ICommonGradientColor {
+    /** Gradient stop position between 0 and 1. */
     offset: number;
+    /** Canvas/CSS colour used by this element. */
     color: string;
 }
 
+/** Shared line geometry, grid and data-label settings. */
 export declare interface ICommonGraph {
+    /** Line interpolation tension; zero produces straight segments. */
     lineTension?: number;
+    /** Connects line segments across missing values. */
     spanGaps?: boolean;
+    /** Draws labels on data elements. */
     showDataLabels?: boolean;
+    /** Draws intermediate grid lines between the main ticks. */
     showMinorGridlines?: boolean;
 }
 
+/** Indices identifying the currently hovered DS and point. */
 export declare interface ICommonHoveredItems {
+    /** Zero-based index of the data item. */
     index: number;
+    /** Zero-based index of the DS in the chart data. */
     datasetIndex: number;
 }
 
+/** Chart interaction callbacks. Generated DS indices may include annotation entries. */
 export declare interface ICommonInteractions {
+    /** Receives the clicked legend text and its hidden state. */
     onLegendClick?: (text: string, hidden: boolean) => void;
+    /** Receives the chart event, DS index, point index and generated DS collection on hover. */
     onHover?: (event: ChartEvent, datasetIndex: number, index: number, generatedDataset: any[]) => void;
+    /** Called when the pointer leaves the hovered chart element. */
     onUnhover?: (event?: ChartEvent, datasetIndex?: number, index?: number, generatedDataset?: any[]) => void;
 }
 
+/** Common legend visibility and placement settings. */
 export declare interface ICommonLegend {
+    /** Whether this element is visible. */
     display: boolean;
+    /** Visual placement of this element. */
     position?: Position;
+    /** Alignment within the available layout space. */
     align?: AlignOptions;
 }
 
+/**
+ * Common chart options extended by each chart component.
+ * A field's presence in this shared type does not imply support in every chart.
+ */
 export declare interface ICommonOptions {
+    /** Chart title; an array represents multiple lines. */
     title?: string | string[];
+    /** Chart sizing and visual layout settings. */
     chartStyling?: ICommonStyling;
+    /** Tooltip visibility, formatting and supported callbacks. */
     tooltip?: ICommonTooltip;
+    /** Legend visibility, placement and custom rendering options. */
     legend?: ICommonLegend;
+    /** Initial interaction and rendering controls. */
     chartOptions?: ICommonChartOptions;
+    /** Callbacks for legend and pointer interactions. */
     interactions?: ICommonInteractions;
+    /** Point-dragging options and lifecycle callbacks. */
     dragData?: ICommonDragData;
+    /** Annotation visibility, interaction and geometry configuration. */
     annotations?: ICommonAnnotations;
+    /** Plugin configuration accepted by this options shape; forwarding is chart-specific. */
     plugins?: {
+        /** Line-marker plugin enablement settings. */
         lineMarkersPlugin?: {
+            /** Whether this feature is active. */
             enabled?: boolean;
         };
     };
 }
 
+/** Supported Chart.js scale option variants. */
 export declare type ICommonScaleOptions = ScaleOptions<'category'> | ScaleOptions<'linear'> | ScaleOptions<'logarithmic'> | ScaleOptions<'time'> | ScaleOptions<'timeseries'>;
 
+/** Scale configuration indexed by Chart.js scale ID. */
 export declare type ICommonScales = Partial<Record<string, ICommonScaleOptions>>;
 
+/** Shared chart container and canvas layout settings. */
 export declare interface ICommonStyling {
+    /** Chart width as a number or CSS size string. */
     width?: number | string;
+    /** Chart height as a number or CSS size string. */
     height?: number | string;
+    /** Preserves the canvas aspect ratio while resizing. */
     maintainAspectRatio?: boolean;
+    /** Uses the fixed-height layout instead of stretching to the container. */
     staticChartHeight?: boolean;
+    /** Disables chart animation when true. Defaults to true. */
     performanceMode?: boolean;
+    /** Background gradient configuration; consumed by ScatterChart. */
     gradient?: ICommonGradient;
 }
 
+/** Shared tooltip settings; individual chart components determine supported callbacks. */
 export declare interface ICommonTooltip {
+    /** Enables hover tooltips. Defaults to true. */
     tooltips?: boolean;
+    /** Includes the optional point label in supported tooltips. Defaults to false. */
     showLabelsInTooltips?: boolean;
+    /** Allows scientific notation when formatting tooltip numbers. Defaults to true. */
     scientificNotation?: boolean;
+    /** Custom tooltip callbacks. LineChart preserves title, label and afterLabel overrides independently. */
     callbacks?: ICommonTooltipCallbacks;
 }
 
+/**
+ * Tooltip callback overrides consumed by LineChart.
+ * BarChart, PieChart and ScatterChart currently use their own tooltip formatters.
+ */
 export declare interface ICommonTooltipCallbacks {
+    /** Replaces the tooltip title callback. LineChart passes the hovered tooltip items. */
     title?: (...args: unknown[]) => unknown;
+    /** Replaces the DS-row callback. LineChart passes one tooltip item. */
     label?: (...args: unknown[]) => unknown;
+    /** Appends content below the DS value. LineChart uses this instead of its built-in after-label callback. */
     afterLabel?: (...args: unknown[]) => unknown;
 }
 
+/** A pair of X/Y coordinates passed to annotation drag callbacks. */
 export declare interface ICoordinates {
+    /** X coordinate in scale units. */
     x: number;
+    /** Y coordinate in scale units. */
     y: number;
 }
 
+/** Legacy selector type retained for source compatibility. */
 export declare interface IDepthType {
+    /** Available selector values. */
     options: string[];
+    /** Currently selected unit identifier. */
     selectedUnit: string;
+    /** Notifies the consumer when another unit is selected; the consumer owns the selection. */
     setSelectedUnit: (value: string) => void;
 }
 
+/** Generated bar DS with annotation and legend metadata. */
 export declare interface IGenerateBarChartDataset extends ChartDataset<'bar', ICommonDataValue[]> {
+    /** Canvas colour used for the element outline. */
     borderColor: string;
+    /** Canvas fill colour; arrays provide per-element colours where supported. */
     backgroundColor: string | string[];
+    /** Alternating dash and gap lengths in canvas pixels. */
     borderDash?: number[];
+    /** Outline width in canvas pixels. */
     borderWidth?: number;
+    /** Shape identifier retained for the generated annotation DS. */
     annotationType?: string;
+    /** Excludes this entry from the legend where supported. */
     hideLegend?: boolean;
+    /** Groups DS entries for legend display. */
     displayGroup?: string | number;
+    /** Marks a generated DS as annotation data rather than plotted input data. */
     isAnnotation?: boolean;
+    /** Index of the source annotation in the annotation collection. */
     annotationIndex?: number;
 }
 
+/** DS produced by LineChart normalization, including generated annotation metadata. */
 export declare interface IGeneratedLineChartDataset {
+    /** Display text associated with this element. */
     label?: string;
+    /** Values rendered by the chart or DS. */
     data: ICommonDataValue[];
+    /** Whether to draw connecting lines. */
     showLine?: boolean;
+    /** Resolved interpolation tension for the generated DS. */
     lineTension: number;
+    /** Connects line segments across missing values. */
     spanGaps: boolean;
+    /** Outline width in canvas pixels. */
     borderWidth: number;
+    /** Alternating dash and gap lengths in canvas pixels. */
     borderDash: number[];
+    /** Canvas join style at line segment corners. */
     borderJoinStyle: 'round' | 'bevel' | 'miter';
+    /** Canvas colour used for the element outline. */
     borderColor: string;
+    /** Canvas fill colour; arrays provide per-element colours where supported. */
     backgroundColor: string | string[];
+    /** Fill colour of the point marker. */
     pointBackgroundColor: string;
+    /** Point marker radius in pixels. */
     pointRadius: number;
+    /** Point radius while hovered, in pixels. */
     pointHoverRadius: number;
+    /** Additional hit-test radius around a point, in pixels. */
     pointHitRadius: number;
+    /** Marks a generated DS as annotation data rather than plotted input data. */
     isAnnotation?: boolean;
+    /** Shape identifier retained for the generated annotation DS. */
     annotationType?: string;
+    /** Index of the source annotation in the annotation collection. */
     annotationIndex?: number;
+    /** Text retained for the generated annotation DS. */
     annotationLabel?: string;
+    /** Fill colour retained for the generated annotation DS. */
     annotationBackgroundColor?: string;
+    /** Point fill retained for the generated annotation DS. */
     annotationPointBackgroundColor?: string;
+    /** Outline colour retained for the generated annotation DS. */
     annotationBorderColor?: string;
+    /** Outline dash pattern retained for the generated annotation DS. */
     annotationBorderDash?: number[];
+    /** Outline width retained for the generated annotation DS. */
     annotationBorderWidth?: number;
+    /** Groups DS entries for legend display. */
     displayGroup?: string | number;
+    /** Excludes this entry from the legend where supported. */
     hideLegend?: boolean;
+    /** Point marker shape. */
     pointStyle?: string;
+    /** Horizontal scale ID for this DS, such as `x` or `x2`. */
     xAxisID?: string;
+    /** Vertical scale ID for this DS, such as `y` or `y2`. */
     yAxisID?: string;
 }
 
+/** Generated pie DS with annotation and legend metadata. */
 export declare interface IGeneratedPieChartDataset {
+    /** Display text associated with this element. */
     label: string;
+    /** Canvas fill colour; arrays provide per-element colours where supported. */
     backgroundColor: string[];
+    /** Canvas colour used for the element outline. */
     borderColor: string;
+    /** Outline width in canvas pixels. */
     borderWidth: number;
+    /** Alternating dash and gap lengths in canvas pixels. */
     borderDash: number[];
+    /** Shape identifier retained for the generated annotation DS. */
     annotationType?: string;
+    /** Values rendered by the chart or DS. */
     data: IPieDataValue[];
+    /** Excludes this entry from the legend where supported. */
     hideLegend?: boolean;
+    /** Groups DS entries for legend display. */
     displayGroup?: string | number;
+    /** Marks a generated DS as annotation data rather than plotted input data. */
     isAnnotation?: boolean;
+    /** Index of the source annotation in the annotation collection. */
     annotationIndex?: number;
 }
 
+/** Generated scatter DS with annotation and legend metadata. */
 export declare interface IGeneratedScatterChartDataset {
+    /** Display text associated with this element. */
     label: string;
+    /** Canvas fill colour; arrays provide per-element colours where supported. */
     backgroundColor: string[];
+    /** Canvas colour used for the element outline. */
     borderColor: string;
+    /** Outline width in canvas pixels. */
     borderWidth: number;
+    /** Alternating dash and gap lengths in canvas pixels. */
     borderDash: number[];
+    /** Shape identifier retained for the generated annotation DS. */
     annotationType?: string;
+    /** Values rendered by the chart or DS. */
     data: IScatterDataValue[];
+    /** Excludes this entry from the legend where supported. */
     hideLegend?: boolean;
+    /** Groups DS entries for legend display. */
     displayGroup?: string | number;
+    /** Marks a generated DS as annotation data rather than plotted input data. */
     isAnnotation?: boolean;
+    /** Index of the source annotation in the annotation collection. */
     annotationIndex?: number;
 }
 
+/** Initial LineChart rendering and interaction controls. */
 export declare interface ILChartOptions extends ICommonChartOptions {
+    /** Whether to draw point markers. */
     showPoints?: boolean;
+    /** Closes the LineChart controls panel when clicking outside it. Defaults to false. */
     closeOnOutsideClick?: boolean;
+    /** Whether to draw connecting lines. */
     showLine?: boolean;
+    /** Enables zooming when supported by the chart. */
     enableZoom?: boolean;
+    /** Enables panning when supported by the chart. */
     enablePan?: boolean;
+    /** Enables annotation dragging in the corresponding controls. */
     enableDragAnnotation?: boolean;
+    /** Legacy control flag; use `dragData.enableDragData` to configure LineChart point dragging. */
     enableDragPoints?: boolean;
 }
 
+/** LineChart scale defaults and per-axis range overrides. */
 export declare interface ILineChartAdditionalAxesOptions {
+    /** Scale family used when constructing axes. */
     chartScaleType?: 'linear' | 'logarithmic' | 'time' | 'timeseries';
+    /** Reverses the Y scale direction. Does not change tooltip axis selection. */
     reverse?: boolean;
+    /** Includes zero when determining automatic scale bounds. */
     beginAtZero?: boolean;
+    /** Requested spacing between axis ticks, in scale units. */
     stepSize?: number;
+    /** Suggested lower scale bound; data may extend beyond it. */
     suggestedMin?: number;
+    /** Suggested upper scale bound; data may extend beyond it. */
     suggestedMax?: number;
+    /** Per-axis bounds keyed by scale ID, such as `x`, `y`, or `y2`. */
     range?: ILineRange;
+    /** Adds padding to automatically computed axis bounds. Defaults to false in LineChart. */
     autoAxisPadding?: boolean;
 }
 
+/** Ordered horizontal and vertical axis collections for LineChart. */
 export declare interface ILineChartAxes {
+    /** Horizontal axis definitions in order. */
     x: ILineChartAxis<'top' | 'bottom'>[];
+    /** Vertical axis definitions in order. */
     y: ILineChartAxis<'left' | 'right'>[];
     [key: string]: ILineChartAxis[];
 }
 
+/** One LineChart axis. Array order determines generated IDs (`x`, `x2`, ... or `y`, `y2`, ...). */
 export declare interface ILineChartAxis<PositionType = TAxisPosition> {
+    /** Optional axis metadata; generated scale IDs currently follow the axis array order. */
     id?: string;
+    /** Axis title, also appended to the default tooltip title when this is the selected title axis. */
     label?: string;
+    /** Axis placement. Placing the first X axis at the top also swaps the default tooltip coordinate roles. */
     position?: PositionType;
+    /** Canvas/CSS colour used by this element. */
     color?: string | string[];
+    /**
+     * Unit metadata or a consumer-owned unit selector. Does not convert DS coordinates.
+     * Default tooltip units are extracted from square brackets in the axis label, not from this field.
+     */
     unit?: IUnitOptions | string;
+    /** Requested spacing between axis ticks, in scale units. */
     stepSize?: number;
+    /** Grid-line configuration for this axis. */
     gridLines?: ILineChartGraph;
+    /** Explicit lower bound in scale units. */
     min?: number | string;
+    /** Explicit upper bound in scale units. */
     max?: number | string;
 }
 
+/** Normalized LineChart configuration and control integration identifiers. */
 export declare interface ILineChartData extends ICommonData {
+    /** Values rendered by the chart or DS. */
     data?: {
+        /** DS definitions in rendering order. */
         datasets: ILineChartDataset[];
     };
+    /** Configuration for this chart or generated element. */
     options: ILineChartOptions;
+    /** Key used by LineChart to persist chart settings; use distinct IDs for independent charts. */
     persistenceId?: string;
+    /** ID of an existing DOM element in which chart controls should be rendered. */
     controlsPortalId?: string;
 }
 
+/**
+ * Consumer-facing LineChart configuration. Missing datasets and options receive component defaults.
+ * Use this type for standalone chart configuration objects.
+ */
 export declare interface ILineChartDataInput extends Omit<ILineChartData, 'data' | 'options'> {
+    /** Values rendered by the chart or DS. */
     data?: Omit<DeepPartial<ILineChartData['data']>, 'datasets'> & {
+        /** DS definitions in rendering order. */
         datasets?: Array<(DeepPartial<ILineChartDataset> & {
+            /** Line interpolation tension; zero produces straight segments. */
             lineTension?: number | string;
+            /** Controls filling beneath or between lines. */
             fill?: boolean | string | Record<string, unknown>;
+            /** Point marker shape. */
             pointStyle?: unknown;
+            /** Legacy input accepted for compatibility; prefer `showPoints`. */
             showPoint?: boolean;
+            /** Whether to draw point markers. */
             showPoints?: boolean;
+            /** Legacy DS input accepted for compatibility; not a tooltip formatting option. */
             lineHeight?: number;
+            /** Values rendered by the chart or DS. */
             data?: Array<DeepPartial<ICommonDataValue> | null>;
             [key: string]: unknown;
         }) | object | null> | object;
     };
+    /** Configuration for this chart or generated element. */
     options?: ILineChartOptionsInput;
 }
 
+/** Input DS for LineChart. Axis IDs bind values and tooltip units to the corresponding axes. */
 export declare interface ILineChartDataset extends ICommonDataset {
+    /** DS interpolation tension; overrides `options.graph.lineTension` when provided. */
     lineTension?: number;
+    /** Fill colour of the point marker. */
     pointBackgroundColor?: string;
+    /** Point marker radius in pixels. */
     pointRadius?: number;
+    /** Point radius while hovered, in pixels. */
     pointHoverRadius?: number;
+    /** Additional hit-test radius around a point, in pixels. */
     pointHitRadius?: number;
+    /** Controls filling beneath or between lines. */
     fill?: boolean;
+    /** Horizontal scale ID for this DS, such as `x` or `x2`. */
     xAxisID?: string;
+    /** Vertical scale ID for this DS, such as `y` or `y2`. */
     yAxisID?: string;
+    /** Legacy flag that clips the DS endpoints against the first axis bounds. */
     formation?: boolean;
+    /** Groups DS entries for legend display. */
     displayGroup?: string | number;
+    /** Point marker shape. */
     pointStyle?: string;
 }
 
+/** LineChart interpolation, missing-value and grid rendering settings. */
 export declare interface ILineChartGraph {
+    /** Line interpolation tension; zero produces straight segments. */
     lineTension?: number;
+    /** Connects line segments across missing values. */
     spanGaps?: boolean;
+    /** Draws labels on data elements. */
     showDataLabels?: boolean;
+    /** Draws intermediate grid lines between the main ticks. */
     showMinorGridlines?: boolean;
 }
 
+/** Resolved LineChart options. Consumers normally provide the partial {@link ILineChartOptionsInput}. */
 export declare interface ILineChartOptions extends ICommonOptions {
+    /** Chart title; an array represents multiple lines. */
     title?: string | string[];
+    /** Axis descriptions. Configure horizontal axes in `x` and vertical axes in `y`. */
     axes: ILineChartAxes;
+    /** Chart.js scale configuration keyed by scale ID. */
     scales: ICommonScales;
+    /** Scale behaviour, bounds and tick settings shared across the chart axes. */
     additionalAxesOptions: ILineChartAdditionalAxesOptions;
+    /** Chart sizing and visual layout settings. */
     chartStyling: ILineChartStyling;
+    /** Tooltip visibility, formatting and supported callbacks. */
     tooltip: ILineChartTooltip;
+    /** Geometry, grid and data-label rendering options. */
     graph: ILineChartGraph;
+    /** Annotation visibility, interaction and geometry configuration. */
     annotations: ICommonAnnotations;
+    /** Legend visibility, placement and custom rendering options. */
     legend: ILineLegend;
+    /** Initial interaction and rendering controls. */
     chartOptions: ILChartOptions;
+    /** Callbacks for legend and pointer interactions. */
     interactions: ILineInteractions;
+    /** Point-dragging options and lifecycle callbacks. */
     dragData?: ICommonDragData;
+    /** Legacy selector configuration passed to the LineChart axes controls. */
     depthType?: IDepthType | object;
 }
 
+/**
+ * Consumer-facing LineChart options with optional defaults and compatibility fields.
+ * Unknown fields are accepted for compatibility, not guaranteed to be forwarded to Chart.js.
+ */
 export declare type ILineChartOptionsInput = Omit<DeepPartial<ILineChartOptions>, 'title' | 'axes' | 'legend' | 'chartStyling' | 'interactions' | 'graph' | 'annotations' | 'additionalAxesOptions' | 'scales' | 'plugins'> & {
     [key: string]: unknown;
+    /** Chart title; an array represents multiple lines. */
     title?: unknown;
+    /** Legacy input accepted for compatibility; LineChart does not use it to swap axes or tooltip values. */
     direction?: string;
+    /** Axis descriptions. Configure horizontal axes in `x` and vertical axes in `y`. */
     axes?: {
+        /** Horizontal axis definitions in order. */
         x?: ILooseLineAxis[];
+        /** Vertical axis definitions in order. */
         y?: ILooseLineAxis[];
         [key: string]: ILooseLineAxis[] | undefined;
     };
+    /** Chart.js scale overrides keyed by generated scale ID (`x`, `x2`, `y`, `y2`, ...). */
     scales?: Record<string, unknown>;
+    /** Compatibility input; not forwarded by the LineChart option normalizer. */
     plugins?: Record<string, unknown>;
+    /** Legend visibility, placement and custom rendering options. */
     legend?: Omit<DeepPartial<ILineLegend>, 'position' | 'align'> & {
+        /** Visual placement of this element. */
         position?: string;
+        /** Alignment within the available layout space. */
         align?: string;
         [key: string]: unknown;
     };
+    /** Chart sizing and visual layout settings. */
     chartStyling?: DeepPartial<ILineChartStyling> & {
+        /** Compatibility input; not currently consumed by the chart option normalizers. */
         hideControls?: boolean;
+        /** Compatibility input; not currently consumed by the chart option normalizers. */
         minHeight?: number | string;
         [key: string]: unknown;
     };
+    /** Callbacks for legend and pointer interactions. */
     interactions?: DeepPartial<ILineInteractions> & {
+        /** Compatibility interaction input; configure zoom through `chartOptions.enableZoom`. */
         enableZoom?: boolean;
+        /** Compatibility interaction input; configure pan through `chartOptions.enablePan`. */
         enablePan?: boolean;
         [key: string]: unknown;
     };
+    /** Geometry, grid and data-label rendering options. */
     graph?: DeepPartial<ILineChartGraph> & {
+        /** Legacy graph-level input; configure tooltips through `options.tooltip` instead. */
         tooltip?: unknown;
         [key: string]: unknown;
     };
+    /** Annotation visibility, interaction and geometry configuration. */
     annotations?: (Omit<DeepPartial<ICommonAnnotations>, 'annotationsData'> & {
+        /** Annotation definitions in drawing order. */
         annotationsData?: ILooseLineAnnotation[];
     }) | ILooseLineAnnotation[] | null;
+    /** Scale behaviour, bounds and tick settings shared across the chart axes. */
     additionalAxesOptions?: Omit<DeepPartial<ILineChartAdditionalAxesOptions>, 'chartScaleType'> & {
+        /** Scale family used when constructing axes. */
         chartScaleType?: string;
+        /** Requested spacing between axis ticks, in scale units. */
         stepSize?: unknown;
+        /** Per-axis bounds keyed by scale ID, such as `x`, `y`, or `y2`. */
         range?: ILineRange | ILineChartRange | Record<string, ILineChartRange | undefined>;
     } & Record<string, unknown>;
 };
 
+/** Props accepted by the LineChart React component. */
 export declare interface ILineChartProps {
+    /** Chart data and options. Omitted optional settings are resolved by the component defaults. */
     chart: ILineChartDataInput;
+    /** React table content exposed through the LineChart controls. */
     table?: ReactNode;
+    /** React content rendered in the LineChart header. */
     headerComponent?: ReactNode;
+    /** React content rendered below the LineChart header. */
     subheaderComponent?: ReactNode;
 }
 
+/** Optional lower and upper bounds for one scale. */
 export declare interface ILineChartRange {
+    /** Explicit lower bound in scale units. */
     min?: number | string;
+    /** Explicit upper bound in scale units. */
     max?: number | string;
 }
 
+/** LineChart canvas size and chart-area padding. */
 export declare interface ILineChartStyling extends ICommonStyling {
+    /** Requests a square chart layout; LineChart also accepts a numeric layout value. */
     squareAspectRatio?: number | boolean;
+    /** Padding around the chart area, globally or per side. */
     layoutPadding?: number | {
         top: number;
         bottom: number;
@@ -766,295 +1339,513 @@ export declare interface ILineChartStyling extends ICommonStyling {
     };
 }
 
+/**
+ * LineChart tooltip formatting and callback overrides.
+ * When the first X axis is placed at the top, the default title uses Y and the DS row uses X.
+ * Otherwise, the title uses X and the DS row uses Y. Callbacks can override this formatting.
+ */
 export declare interface ILineChartTooltip extends ICommonTooltip {
+    /** Compatibility flag retained by LineChart; currently does not alter tooltip text. */
     hideSimulationName?: boolean;
+    /** Allows scientific notation when formatting tooltip numbers. Defaults to true. */
     scientificNotation?: boolean;
 }
 
+/** LineChart pointer, legend and animation lifecycle callbacks. */
 export declare interface ILineInteractions extends ICommonInteractions {
+    /** Called after a LineChart animation completes. */
     onAnimationComplete?: () => void;
 }
 
+/** LineChart legend options, including external legend integration. */
 export declare interface ILineLegend extends ICommonLegend {
+    /** Custom legend plugin and its target DOM container. */
     customLegend?: ICommonCustomLegend<any>;
+    /** Uses point symbols in legend entries. */
     usePointStyle?: boolean;
 }
 
+/** Annotation configuration alias for the line-marker plugin. */
 export declare type ILineMarkersAnnotation = TLineMarkersOptions;
 
+/** LineChart bounds indexed by scale ID. */
 export declare interface ILineRange {
     [key: string]: ILineChartRange;
 }
 
+/** Compatibility annotation input normalized by BarChart. */
 declare type ILooseBarAnnotation = Omit<DeepPartial<ICommonAnnotationsData>, 'annotationAxis'> & {
     [key: string]: unknown;
+    /** Axis on which `value` and `endValue` locate the annotation. */
     annotationAxis?: string;
+    /** Chart or annotation kind. */
     type?: string;
+    /** Numeric value or axis coordinate represented by this item. */
     value?: number | string | null;
 };
 
+/** Compatibility input for a BarChart axis. */
 declare type ILooseBarAxis = Omit<DeepPartial<ICommonAxis<string>>, 'gridLines'> & {
     [key: string]: unknown;
+    /** Grid-line configuration for this axis. */
     gridLines?: unknown;
 };
 
+/** Permissive annotation input normalized by LineChart. */
 declare type ILooseLineAnnotation = {
     [key: string]: unknown;
+    /** Identifier used to associate this configuration with its rendered element. */
     id?: string;
+    /** Display text associated with this element. */
     label?: string;
+    /** Canvas/CSS colour used by this element. */
     color?: string;
+    /** Canvas colour used for the element outline. */
     borderColor?: string;
+    /** Canvas fill colour; arrays provide per-element colours where supported. */
     backgroundColor?: string;
+    /** Outline width in canvas pixels. */
     borderWidth?: number;
+    /** Whether this element is visible. */
     display?: boolean;
+    /** Whether this annotation may expand the scale bounds to remain visible. */
     adjustScaleRange?: boolean;
+    /** Opacity multiplier between 0 (transparent) and 1 (opaque). */
     opacity?: number;
+    /** Excludes this entry from the legend where supported. */
     hideLegend?: boolean;
+    /** Pixel offset between the label and its associated geometry. */
     labelOffsetPx?: number;
+    /** Axis on which `value` and `endValue` locate the annotation. */
     annotationAxis?: string;
+    /** Chart or annotation kind. */
     type?: string;
+    /** Numeric value or axis coordinate represented by this item. */
     value?: number | string | null;
+    /** Lower X bound in scale units. */
     xMin?: number | string | null;
+    /** Upper X bound in scale units. */
     xMax?: number | string | null;
+    /** Lower Y bound in scale units. */
     yMin?: number | string | null;
+    /** Upper Y bound in scale units. */
     yMax?: number | string | null;
+    /** X coordinate in scale units. */
     xValue?: number | string | null;
+    /** Y coordinate in scale units. */
     yValue?: number | string | null;
+    /** Called when a drag starts. */
     onDragStart?: (...args: unknown[]) => void;
+    /** Called as the dragged value or annotation position changes. */
     onDrag?: (...args: unknown[]) => void;
+    /** Called when dragging ends. */
     onDragEnd?: (...args: unknown[]) => void;
 };
 
+/** Compatibility input for a LineChart axis; known fields are normalized before rendering. */
 declare type ILooseLineAxis = Omit<DeepPartial<ILineChartAxis<string>>, 'gridLines'> & {
     [key: string]: unknown;
+    /** Requested spacing between axis ticks, in scale units. */
     stepSize?: unknown;
+    /** Grid-line configuration for this axis. */
     gridLines?: unknown;
 };
 
+/** Compatibility annotation input normalized by ScatterChart. */
 declare type ILooseScatterAnnotation = Omit<DeepPartial<ICommonAnnotationsData>, 'annotationAxis'> & {
     [key: string]: unknown;
+    /** Axis on which `value` and `endValue` locate the annotation. */
     annotationAxis?: string;
+    /** Chart or annotation kind. */
     type?: string;
+    /** Numeric value or axis coordinate represented by this item. */
     value?: number | string | null;
 };
 
+/** Compatibility input for a ScatterChart axis. */
 declare type ILooseScatterAxis = DeepPartial<ICommonAxis<string>> & {
     [key: string]: unknown;
 };
 
 /**
- * Initialize the charts library with the provided configurations.
- * This function will store the configuration options in a config object.
- * @param {object} options - An object containing the configuration options for the library.
- * @param {object} options.translations - The translations to be used in the library.
- * @param {string} options.languageKey - The language key to be stored in the config object, used for translations.
- * @param {...object} options - Any additional options to be stored in the config object.
+ * Updates the shared chart configuration, including the language and translated control labels.
+ *
+ * Call during application setup before rendering charts. Configuration is shared across chart instances;
+ * this is not a per-chart configuration API. Each call sets the language key (default `en`) and updates
+ * the supplied configuration entries. Non-primitive entries other than translations are shallow-copied.
+ *
+ * @param options - Language key, translations and other shared configuration entries.
+ * @example
+ * ```ts
+ * initializeLineChart({ languageKey: 'en' });
+ * ```
  */
 export declare const initializeLineChart: ({ languageKey, ...options }: {
     [x: string]: any;
     languageKey?: string | undefined;
 }) => void;
 
+/** Normalized PieChart input structure. */
 export declare interface IPieChartData extends ICommonData {
+    /** Values rendered by the chart or DS. */
     data: IPieData;
+    /** Configuration for this chart or generated element. */
     options: IPieOptions;
 }
 
+/** Consumer-facing PieChart configuration; point input accepts numbers or partial value objects. */
 export declare interface IPieChartDataInput extends Omit<IPieChartData, 'data' | 'options'> {
+    /** Values rendered by the chart or DS. */
     data?: Omit<DeepPartial<IPieChartData['data']>, 'datasets'> & {
+        /** DS definitions in rendering order. */
         datasets?: Array<(Omit<DeepPartial<IPieChartDataset>, 'data'> & {
+            /** Values rendered by the chart or DS. */
             data?: Array<DeepPartial<IPieDataValue> | number>;
             [key: string]: unknown;
         }) | object | null>;
     };
+    /** Configuration for this chart or generated element. */
     options?: IPieOptionsInput;
 }
 
+/** Input pie DS containing object-form values. */
 export declare interface IPieChartDataset extends ICommonDataset {
+    /** Values rendered by the chart or DS. */
     data: IPieDataValue[];
+    /** Excludes this entry from the legend where supported. */
     hideLegend?: boolean;
 }
 
+/** Props accepted by the PieChart React component. */
 export declare interface IPieChartProps {
+    /** Chart data and options. Omitted optional settings are resolved by the component defaults. */
     chart: IPieChartDataInput;
+    /** Legacy top-level field; use `chart.testId`, which is read by the component normalizer. */
     testId?: string | null;
 }
 
+/** Pie labels, DS definitions and legacy unit metadata. */
 export declare interface IPieData {
+    /** Labels associated with the input data. */
     labels?: string[];
+    /** DS definitions in rendering order. */
     datasets?: IPieChartDataset[];
+    /** Legacy X-unit metadata on the input data object. */
     xUnit?: string;
+    /** Legacy Y-unit metadata on the input data object. */
     yUnit?: string;
 }
 
+/** Object-form pie value with optional display styling and related labels. */
 export declare interface IPieDataValue extends ICommonDataValue {
+    /** Display text associated with this element. */
     label: string;
+    /** Outline width in canvas pixels. */
     borderWidth: string | number;
+    /** Numeric value or axis coordinate represented by this item. */
     value: number;
+    /** Canvas fill colour; arrays provide per-element colours where supported. */
     backgroundColor?: string | string[];
+    /** Canvas colour used for the element outline. */
     borderColor?: string;
+    /** Labels associated with the input data. */
     labels: string[];
 }
 
+/** PieChart alias for generated legend label metadata. */
 export declare type IPieGeneratedLabel = IChartGeneratedLabel;
 
+/** Pie geometry and data-label rendering options. */
 export declare interface IPieGraph {
+    /** Draws labels on data elements. */
     showDataLabels?: boolean;
+    /** Enables stacked rendering where supported. */
     stacked?: boolean;
+    /** Inner radius of the pie: a pixel value or percentage string. Defaults to 0. */
     cutout?: number | string;
 }
 
+/** PieChart legend configuration and DS-based visibility filtering. */
 export declare interface IPieLegend extends ICommonLegend {
+    /** Filters legend items using `hideLegend` on the DS at the corresponding item index. */
     useDataset?: boolean;
 }
 
+/** PieChart alias for legend visibility metadata. */
 export declare type IPieLegendItemFilter = IChartLegendItemFilter;
 
+/** PieChart-specific options layered over the common chart options. */
 export declare interface IPieOptions extends ICommonOptions {
+    /** Geometry, grid and data-label rendering options. */
     graph?: IPieGraph;
+    /** Legend visibility, placement and custom rendering options. */
     legend?: IPieLegend;
+    /** Compatibility field; pie charts do not render Cartesian axes. */
     axes?: unknown;
     [key: string]: unknown;
 }
 
+/**
+ * Partial PieChart options accepted at the component boundary.
+ * Only settings supported by the pie normalizer affect rendering.
+ */
 export declare type IPieOptionsInput = Omit<DeepPartial<IPieOptions>, 'title' | 'graph' | 'legend' | 'chartStyling' | 'tooltip' | 'chartOptions' | 'interactions'> & {
     [key: string]: unknown;
+    /** Chart title; an array represents multiple lines. */
     title?: unknown;
+    /** Geometry, grid and data-label rendering options. */
     graph?: DeepPartial<IPieGraph>;
+    /** Legend visibility, placement and custom rendering options. */
     legend?: Omit<DeepPartial<IPieLegend>, 'position' | 'align'> & {
+        /** Visual placement of this element; does not select LineChart tooltip axes. */
         position?: string;
+        /** Alignment within the available layout space. */
         align?: string;
         [key: string]: unknown;
     };
+    /** Chart sizing and visual layout settings. */
     chartStyling?: DeepPartial<ICommonStyling> & {
         [key: string]: unknown;
     };
+    /** Tooltip visibility, formatting and supported callbacks. */
     tooltip?: DeepPartial<ICommonTooltip>;
+    /** Initial interaction and rendering controls. */
     chartOptions?: DeepPartial<ICommonChartOptions>;
+    /** Callbacks for legend and pointer interactions. */
     interactions?: DeepPartial<ICommonOptions['interactions']> & {
         [key: string]: unknown;
     };
 };
 
+/** PieChart alias for data-label plugin settings. */
 export declare type IPiesDataLabelsOptions = IChartDataLabelsOptions;
 
+/** Ordered horizontal and vertical ScatterChart axis collections. */
 export declare interface IScatterAxes {
+    /** Horizontal axis definitions in order. */
     x: ICommonAxis<'top' | 'bottom'>[];
+    /** Vertical axis definitions in order. */
     y: ICommonAxis<'left' | 'right'>[];
     [key: string]: ICommonAxis[];
 }
 
+/** Normalized ScatterChart input structure. */
 export declare interface IScatterChartData extends ICommonData {
+    /** Values rendered by the chart or DS. */
     data: IScatterData;
+    /** Configuration for this chart or generated element. */
     options: IScatterOptions;
 }
 
+/** Consumer-facing ScatterChart configuration with optional datasets and options. */
 export declare interface IScatterChartDataInput extends Omit<IScatterChartData, 'data' | 'options'> {
+    /** Values rendered by the chart or DS. */
     data?: Omit<DeepPartial<IScatterChartData['data']>, 'datasets'> & {
+        /** DS definitions in rendering order. */
         datasets?: Array<DeepPartial<IScatterChartDataset> | object | null>;
     };
+    /** Configuration for this chart or generated element. */
     options?: IScatterOptionsInput;
 }
 
+/** Input scatter DS and its legend visibility. */
 export declare interface IScatterChartDataset extends ICommonDataset {
+    /** Values rendered by the chart or DS. */
     data: IScatterDataValue[];
+    /** Excludes this entry from the legend where supported. */
     hideLegend?: boolean;
 }
 
+/** Props accepted by the ScatterChart React component. */
 export declare interface IScatterChartProps {
+    /** Chart data and options. Omitted optional settings are resolved by the component defaults. */
     chart: IScatterChartDataInput;
+    /** Legacy top-level field; use `chart.testId`, which is read by the component normalizer. */
     testId?: string | null;
 }
 
+/** Scatter labels, DS definitions and legacy unit metadata. */
 export declare interface IScatterData {
+    /** Labels associated with the input data. */
     labels?: string[];
+    /** DS definitions in rendering order. */
     datasets?: IScatterChartDataset[];
+    /** Legacy X-unit metadata on the input data object. */
     xUnit?: string;
+    /** Legacy Y-unit metadata on the input data object. */
     yUnit?: string;
 }
 
+/** ScatterChart alias for data-label plugin settings. */
 export declare type IScatterDataLabelsOptions = IChartDataLabelsOptions;
 
+/** A scatter point with an optional display label. */
 export declare interface IScatterDataValue extends ICommonDataValue {
+    /** Display text associated with this element. */
     label?: string;
 }
 
+/** ScatterChart alias for generated legend label metadata. */
 export declare type IScatterGeneratedLabel = IChartGeneratedLabel;
 
+/** ScatterChart grid and data-label rendering options. */
 export declare interface IScatterGraph {
+    /** Draws intermediate grid lines between the main ticks. */
     showMinorGridlines?: boolean;
+    /** Draws labels on data elements. */
     showDataLabels?: boolean;
 }
 
+/** ScatterChart legend configuration and compatibility flags. */
 export declare interface IScatterLegend extends ICommonLegend {
+    /** Compatibility flag retained by the normalizer; currently does not change ScatterChart legend rendering. */
     useDataset?: boolean;
 }
 
+/** ScatterChart alias for legend visibility metadata. */
 export declare type IScatterLegendItemFilter = IChartLegendItemFilter;
 
+/** ScatterChart options layered over common Cartesian settings. */
 export declare interface IScatterOptions extends ICommonOptions {
+    /** Geometry, grid and data-label rendering options. */
     graph?: IScatterGraph;
+    /** Legend visibility, placement and custom rendering options. */
     legend?: IScatterLegend;
+    /** Axis descriptions. Configure horizontal axes in `x` and vertical axes in `y`. */
     axes?: IScatterAxes;
+    /** Chart.js scale configuration keyed by scale ID. */
     scales?: ICommonScales;
+    /** Scale behaviour, bounds and tick settings shared across the chart axes. */
     additionalAxesOptions?: ICommonAdditionalAxesOptions;
+    /** Chart orientation. Support and interpretation depend on the chart component. */
     direction?: ChartDirection;
 }
 
+/**
+ * Partial ScatterChart options accepted at the component boundary.
+ * Unknown fields are accepted for compatibility, not guaranteed to be forwarded.
+ */
 export declare type IScatterOptionsInput = Omit<DeepPartial<IScatterOptions>, 'title' | 'direction' | 'axes' | 'legend' | 'chartStyling' | 'interactions' | 'annotations' | 'scales'> & {
     [key: string]: unknown;
+    /** Chart title; an array represents multiple lines. */
     title?: unknown;
+    /** Chart orientation. Support and interpretation depend on the chart component. */
     direction?: string;
+    /** Axis descriptions. Configure horizontal axes in `x` and vertical axes in `y`. */
     axes?: {
+        /** Horizontal axis definitions in order. */
         x?: ILooseScatterAxis[];
+        /** Vertical axis definitions in order. */
         y?: ILooseScatterAxis[];
         [key: string]: ILooseScatterAxis[] | undefined;
     };
+    /** Chart.js scale configuration keyed by scale ID. */
     scales?: Record<string, unknown>;
+    /** Legend visibility, placement and custom rendering options. */
     legend?: Omit<DeepPartial<IScatterLegend>, 'position' | 'align'> & {
+        /** Visual placement of this element; does not select LineChart tooltip axes. */
         position?: string;
+        /** Alignment within the available layout space. */
         align?: string;
         [key: string]: unknown;
     };
+    /** Chart sizing and visual layout settings. */
     chartStyling?: {
         [key: string]: unknown;
     };
+    /** Callbacks for legend and pointer interactions. */
     interactions?: DeepPartial<ICommonOptions['interactions']> & {
+        /** Compatibility interaction input; configure zoom through `chartOptions.enableZoom`. */
         enableZoom?: boolean;
+        /** Compatibility interaction input; configure pan through `chartOptions.enablePan`. */
         enablePan?: boolean;
         [key: string]: unknown;
     };
+    /** Annotation visibility, interaction and geometry configuration. */
     annotations?: (Omit<DeepPartial<ICommonAnnotations>, 'annotationsData'> & {
+        /** Annotation definitions in drawing order. */
         annotationsData?: ILooseScatterAnnotation[];
     }) | null;
 };
 
+/** ScatterChart tooltip settings resolved by its default-props helper. */
 export declare interface IScatterTooltip {
+    /** Whether this feature is active. */
     enabled?: boolean;
+    /** Enables hover tooltips. Defaults to true. */
     tooltips?: boolean;
+    /** Includes the optional point label in supported tooltips. Defaults to false. */
     showLabelsInTooltips: boolean;
+    /** Canvas fill colour; arrays provide per-element colours where supported. */
     backgroundColor?: string;
+    /** Whether the tooltip includes colour swatches. */
     displayColors?: boolean;
+    /** Allows scientific notation when formatting tooltip numbers. Defaults to true. */
     scientificNotation?: boolean;
 }
 
+/** Consumer-owned unit selector configuration. Selecting a unit does not itself convert input data. */
 export declare interface IUnitOptions {
+    /** Available unit identifiers shown in the selector. */
     options: string[];
+    /** Currently selected unit identifier. */
     selectedUnit: string;
+    /** Notifies the consumer when another unit is selected; the consumer owns the selection. */
     setSelectedUnit: (value: string) => void;
 }
 
+/** Keyboard modifier identifiers used by chart interactions. */
 export declare enum Key {
     Shift = "Shift"
 }
 
+/**
+ * Renders an interactive line chart with multiple axes, annotations, a legend and chart controls.
+ *
+ * Pass partial configuration through `chart`; omitted settings receive component defaults.
+ * The example uses sample data, labels and a height of 320 pixels; these are not default values.
+ *
+ * @remarks
+ * Defaults: bottom X axis, left Y axis, visible lines and points, bottom-left legend, and zoom enabled.
+ * Pan, data labels, minor grid lines and annotations are disabled. No fixed width or height is assigned.
+ * Performance mode is enabled by default, disabling animations.
+ * The linked reference lists the complete normalized default configuration.
+ *
+ * @see https://gitlab.com/oliasoft-open-source/charts-library/-/blob/master/README.md#linechart
+ *
+ * @param props - Chart data and options, plus optional header, subheader and table content.
+ * @returns The chart canvas and its associated UI.
+ * @example
+ * ```tsx
+ * <LineChart chart={{
+ *   data: {
+ *     datasets: [{
+ *       label: 'DS A',
+ *       data: [{ x: 0, y: 10 }, { x: 1, y: 20 }, { x: 2, y: 15 }],
+ *     }],
+ *   },
+ *   options: {
+ *     axes: {
+ *       x: [{ label: 'X', position: 'bottom' }],
+ *       y: [{ label: 'Y', position: 'left' }],
+ *     },
+ *     chartStyling: { height: 320 },
+ *     legend: { display: true, position: 'bottom-left' },
+ *     graph: { lineTension: 0.01, showDataLabels: false },
+ *     chartOptions: { showLine: true, showPoints: true },
+ *   },
+ * }} />
+ * ```
+ */
 export declare const LineChart: (props: ILineChartProps) => JSX.Element;
 
+/** Orientation of a line marker. */
 export declare enum LineMarkerDirection {
     Vertical = "vertical",
     Horizontal = "horizontal"
 }
 
+/** Label placement relative to a line marker. */
 export declare enum LineMarkerLabelPosition {
     Left = "left",
     Right = "right",
@@ -1063,17 +1854,20 @@ export declare enum LineMarkerLabelPosition {
     OnLine = "onLine"
 }
 
+/** Left/right attachment side for line markers. */
 export declare enum LineMarkerSide {
     Left = "left",
     Right = "right"
 }
 
+/** Horizontal alignment of marker label text. */
 export declare enum LineMarkerTextAlign {
     Left = "left",
     Right = "right",
     Center = "center"
 }
 
+/** Interaction mode identifiers; availability depends on the chart controls. */
 export declare enum PanZoomMode {
     X = "x",
     Y = "y",
@@ -1081,8 +1875,44 @@ export declare enum PanZoomMode {
     Z = "z"
 }
 
+/**
+ * Renders pie segments with optional data labels, a legend and an inner cutout.
+ *
+ * Pass partial configuration through `chart`; omitted settings receive component defaults.
+ * The example uses sample data, labels and a height of 320 pixels; these are not default values.
+ *
+ * @remarks
+ * Defaults: a full pie (cutout 0), a bottom legend, and no fixed width or height.
+ * Data labels, stacking, zoom and pan are disabled. Pie charts do not have Cartesian axes.
+ * Performance mode is enabled by default, disabling animations.
+ * The linked reference lists the complete normalized default configuration.
+ *
+ * @see https://gitlab.com/oliasoft-open-source/charts-library/-/blob/master/README.md#piechart
+ *
+ * @param props - Chart data and options.
+ * @returns The chart canvas and its associated UI.
+ * @example
+ * ```tsx
+ * <PieChart chart={{
+ *   data: {
+ *     labels: ['A', 'B', 'C'],
+ *     datasets: [{
+ *       label: 'DS A',
+ *       data: [10, 20, 15],
+ *       backgroundColor: ['#3366cc', '#dc3912', '#ff9900'],
+ *     }],
+ *   },
+ *   options: {
+ *     chartStyling: { height: 320 },
+ *     legend: { display: true, position: 'bottom' },
+ *     graph: { cutout: 0, showDataLabels: false },
+ *   },
+ * }} />
+ * ```
+ */
 export declare const PieChart: (props: IPieChartProps) => JSX.Element;
 
+/** Point marker shapes compatible with Chart.js. */
 export declare enum PointStyle {
     Circle = "circle",
     Square = "rect",
@@ -1090,10 +1920,12 @@ export declare enum PointStyle {
     Triangle = "triangle"
 }
 
+/** Legacy point classification identifiers. */
 export declare enum PointType {
     Casing = "casing"
 }
 
+/** Legend/layout positions. Individual options accept only the positions relevant to their layout. */
 export declare enum Position {
     Bottom = "bottom",
     Top = "top",
@@ -1105,6 +1937,7 @@ export declare enum Position {
     BottomRight = "bottom-right"
 }
 
+/** Chart.js scale-family identifiers. */
 export declare enum ScaleType {
     Category = "category",
     Linear = "linear",
@@ -1113,123 +1946,259 @@ export declare enum ScaleType {
     TimeSeries = "timeseries"
 }
 
+/**
+ * Renders Cartesian points with a legend, optional annotations and a background gradient.
+ *
+ * Pass partial configuration through `chart`; omitted settings receive component defaults.
+ * The example uses sample data, labels and a height of 320 pixels; these are not default values.
+ *
+ * @remarks
+ * Defaults: automatic width and height, a bottom-left legend, zero included in automatic scale bounds,
+ * and annotations enabled. Zoom, pan, data labels, minor grid lines and the background gradient are disabled.
+ * Performance mode is enabled by default, disabling animations.
+ * The linked reference lists the complete normalized default configuration.
+ *
+ * @see https://gitlab.com/oliasoft-open-source/charts-library/-/blob/master/README.md#scatterchart
+ *
+ * @param props - Chart data and options.
+ * @returns The chart canvas and its associated UI.
+ * @example
+ * ```tsx
+ * <ScatterChart chart={{
+ *   data: {
+ *     datasets: [{
+ *       label: 'DS A',
+ *       data: [{ x: 1, y: 10 }, { x: 2, y: 20 }, { x: 3, y: 15 }],
+ *     }],
+ *   },
+ *   options: {
+ *     axes: {
+ *       x: [{ label: 'X', position: 'bottom' }],
+ *       y: [{ label: 'Y', position: 'left' }],
+ *     },
+ *     chartStyling: { height: 320 },
+ *     legend: { display: true, position: 'bottom-left' },
+ *     graph: { showDataLabels: false, showMinorGridlines: false },
+ *   },
+ * }} />
+ * ```
+ */
 export declare const ScatterChart: (props: IScatterChartProps) => JSX.Element;
 
+/** Allowed positions for a Cartesian axis. */
 export declare type TAxisPosition = 'top' | 'bottom' | 'left' | 'right';
 
+/** Chart.js instance types used by the library's Cartesian chart helpers. */
 export declare type TChart = Chart<'bar', ICommonDataValue[]> | Chart<'line', ICommonDataValue[]> | Chart<'scatter', ICommonDataValue[]>;
 
+/** Generated BarChart DS collection. */
 export declare type TGenerateBarChartDatasets = IGenerateBarChartDataset[];
 
+/** Generated LineChart DS collection. */
 export declare type TGeneratedLineChartDatasets = IGeneratedLineChartDataset[];
 
+/** Generated PieChart DS collection. */
 export declare type TGeneratedPieChartDatasets = IGeneratedPieChartDataset[];
 
+/** Generated ScatterChart DS collection. */
 export declare type TGeneratedScatterChartDatasets = IGeneratedScatterChartDataset[];
 
+/** Orientation accepted by marker items. */
 export declare type TLineMarkerDirection = LineMarkerDirection;
 
+/**
+ * One marker with optional endpoints, ticks and labels.
+ * Item settings override the shared {@link TLineMarkersOptions} values.
+ */
 export declare type TLineMarkerItem = {
+    /** Identifier used to associate this configuration with its rendered element. */
     id?: string;
+    /** Chart orientation. Support and interpretation depend on the chart component. */
     direction?: TLineMarkerDirection;
+    /** Horizontal Chart.js scale ID used to resolve annotation coordinates. */
     xScaleID?: string;
+    /** Vertical Chart.js scale ID used to resolve annotation coordinates. */
     yScaleID?: string;
+    /** X coordinate in scale units. */
     xValue?: number;
+    /** Y coordinate in scale units. */
     yValue?: number;
+    /** Vertical start coordinate in scale units. */
     yStartValue?: number;
+    /** Vertical end coordinate in scale units. */
     yEndValue?: number;
+    /** Horizontal start coordinate in scale units. */
     xStartValue?: number;
+    /** Horizontal end coordinate in scale units. */
     xEndValue?: number;
+    /** Explicit marker length in pixels instead of a span derived from axis values. */
     lengthPx?: number;
+    /** Numeric value or axis coordinate represented by this item. */
     value?: number;
+    /** Display text associated with this element. */
     label?: string | string[];
+    /** Canvas font specification used for the text. */
     font?: string;
+    /** Pixel offset between the label and its associated geometry. */
     labelOffsetPx?: number;
+    /** Attaches marker geometry to a chart edge. */
     stickToEdge?: boolean;
+    /** Aligns marker geometry to the shared group anchor. */
     stickToGroup?: boolean;
+    /** Chart edge used for attached markers. */
     stickSide?: TStickSide;
+    /** Additional pixel offset from the shared marker group anchor. */
     groupOffsetPx?: number;
+    /** Reverses the relevant scale or marker direction. */
     reverse?: boolean;
+    /** Canvas/CSS colour used by this element. */
     color?: string;
+    /** Opacity multiplier between 0 (transparent) and 1 (opaque). */
     opacity?: number;
+    /** Stroke width in canvas pixels. */
     lineWidth?: number;
+    /** Alternating marker dash and gap lengths in pixels. */
     lineDash?: number[];
+    /** Tick and label configuration for the marker start. */
     startTick?: TLineMarkerTick;
+    /** Tick and label configuration for the marker end. */
     endTick?: TLineMarkerTick;
+    /** Additional ticks or branches attached to this marker. */
     extras?: TMarkerExtraItem[];
+    /** Whether this element is visible. */
     display?: boolean;
 };
 
+/** Placement accepted by marker tick labels. */
 export declare type TLineMarkerLabelPosition = LineMarkerLabelPosition;
 
+/**
+ * Shared marker defaults and marker items.
+ * Configure through `options.annotations.lineMarkersAnnotation`.
+ */
 export declare type TLineMarkersOptions = {
+    /** Whether this feature is active. */
     enabled?: boolean;
+    /** Spacing between grouped marker items in pixels. */
     itemGapPx?: number;
+    /** Gap between edge-attached markers and the chart boundary, in pixels. */
     edgePaddingPx?: number;
+    /** Default length of horizontal marker lines in pixels. */
     horizontalLineLengthPx?: number;
+    /** Default orientation for marker items. */
     lineDirection?: TLineMarkerDirection;
+    /** Vertical clearance used when resolving marker label overlaps, in pixels. */
     labelCollisionPx?: number;
+    /** Horizontal distance used to cluster potentially overlapping marker labels, in pixels. */
     labelCollisionClusterXPx?: number;
+    /** Adjusts marker label placement to reduce overlaps. */
     enableLabelCollisionResolver?: boolean;
+    /** Attaches marker geometry to a chart edge. */
     stickToEdge?: boolean;
+    /** Aligns marker geometry to the shared group anchor. */
     stickToGroup?: boolean;
+    /** Chart edge used for attached markers. */
     stickSide?: TStickSide;
+    /** Reverses the relevant scale or marker direction. */
     reverse?: boolean;
+    /** X coordinate in scale units. */
     xValue?: number;
+    /** Y coordinate in scale units. */
     yValue?: number;
+    /** Vertical end coordinate in scale units. */
     yEndValue?: number;
+    /** Horizontal start coordinate in scale units. */
     xStartValue?: number;
+    /** Horizontal end coordinate in scale units. */
     xEndValue?: number;
+    /** Explicit marker length in pixels instead of a span derived from axis values. */
     lengthPx?: number;
+    /** Vertical start coordinate in scale units. */
     yStartValue?: number;
+    /** Canvas/CSS colour used by this element. */
     color?: string;
+    /** Opacity multiplier between 0 (transparent) and 1 (opaque). */
     opacity?: number;
+    /** Stroke width in canvas pixels. */
     lineWidth?: number;
+    /** Alternating marker dash and gap lengths in pixels. */
     lineDash?: number[];
+    /** Tick and label configuration for the marker start. */
     startTick?: TLineMarkerTick;
+    /** Tick and label configuration for the marker end. */
     endTick?: TLineMarkerTick;
+    /** Marker definitions; item settings override the shared marker settings. */
     items?: TLineMarkerItem[];
 };
 
+/** Text alignment accepted by marker label helpers. */
 export declare type TLineMarkerTextAlign = LineMarkerTextAlign;
 
+/** Tick styling and optional text at a marker endpoint. */
 export declare type TLineMarkerTick = {
+    /** Whether this feature is active. */
     enabled?: boolean;
+    /** Display text associated with this element. */
     label?: string | string[];
+    /** Canvas/CSS colour used by this element. */
     color?: string;
+    /** Canvas font specification used for the text. */
     font?: string;
+    /** Pixel offset between the label and its associated geometry. */
     labelOffsetPx?: number;
+    /** Label placement relative to the marker or tick. */
     labelPosition?: TLineMarkerLabelPosition;
+    /** Side on which the marker tick or branch is drawn. */
     side?: TStickSide;
+    /** Reverses the relevant scale or marker direction. */
     reverse?: boolean;
+    /** Tick size in pixels. */
     sizePx?: number;
 };
 
+/** Additional tick or branch attached to a line marker. */
 export declare type TMarkerExtraItem = {
+    /** Identifier used to associate this configuration with its rendered element. */
     id?: string;
+    /** Whether this element is visible. */
     display?: boolean;
+    /** Vertical Chart.js scale ID used to resolve annotation coordinates. */
     yScaleID?: string;
+    /** Y coordinate in scale units. */
     yValue?: number;
+    /** Numeric value or axis coordinate represented by this item. */
     value?: number;
+    /** Explicit marker length in pixels instead of a span derived from axis values. */
     lengthPx?: number;
+    /** Side on which the marker tick or branch is drawn. */
     side?: TStickSide;
+    /** Reverses the relevant scale or marker direction. */
     reverse?: boolean;
+    /** Canvas/CSS colour used by this element. */
     color?: string;
+    /** Opacity multiplier between 0 (transparent) and 1 (opaque). */
     opacity?: number;
+    /** Stroke width in canvas pixels. */
     lineWidth?: number;
+    /** Alternating marker dash and gap lengths in pixels. */
     lineDash?: number[];
+    /** Tick and label settings for this extra marker branch. */
     tick?: TLineMarkerTick;
 };
 
+/** Legacy tooltip label keys. */
 export declare enum TooltipLabel {
     Y = "yLabel",
     X = "xLabel"
 }
 
+/** Primitive configuration values excluding undefined. */
 export declare type TPrimitive = string | number | boolean | null;
 
+/** Attachment side accepted by marker options. */
 export declare type TStickSide = LineMarkerSide;
 
+/** Placeholder for a callback parameter whose runtime value is intentionally unspecified. */
 export declare type UnusedParameter = unknown;
 
 export { }
@@ -1237,25 +2206,25 @@ export { }
 
 declare module 'chart.js' {
     interface PluginOptionsByType<TType extends ChartType> {
-        annotationDraggerPlugin?: AnnotationDraggerPluginOptions;
+        lineMarkersPlugin?: {
+            enabled?: boolean;
+        } | TLineMarkersOptions;
     }
 }
 
 
 declare module 'chart.js' {
     interface PluginOptionsByType<TType extends ChartType> {
-        calloutConnectorPlugin?: {
-            enableCalloutAnnotation?: boolean;
-        };
+        annotationDraggerPlugin?: AnnotationDraggerPluginOptions;
     }
 }
 
 
 declare module 'chart.js' {
     interface PluginOptionsByType<TType extends ChartType> {
-        lineMarkersPlugin?: {
-            enabled?: boolean;
-        } | TLineMarkersOptions;
+        calloutConnectorPlugin?: {
+            enableCalloutAnnotation?: boolean;
+        };
     }
 }