@hestia-earth/ui-components-charts 0.43.23 → 0.43.24

package/dist/index.d.mts

@@ -1,6 +1,10 @@
 import * as chart_js from 'chart.js';
-import { ChartDataset, Chart, BarOptions, Plugin, ChartEvent, Color, Scale } from 'chart.js';
-import { IImpactAssessmentJSONLD } from '@hestia-earth/schema';
+import { ChartDataset, Chart, BarOptions, Plugin, ChartEvent, Color, Scale, ActiveElement, ChartData, ChartConfiguration, ChartComponentLike } from 'chart.js';
+import { Selection } from 'd3-selection';
+import { AnnotationOptions } from 'chartjs-plugin-annotation';
+import * as _hestia_earth_schema from '@hestia-earth/schema';
+import { IImpactAssessmentJSONLD, ITermJSONLD, Term, TermTermType } from '@hestia-earth/schema';
+import { HierarchyPointNode } from 'd3-hierarchy';
 
 interface BarChartDataItem {
     label?: string;
@@ -108,6 +112,18 @@ declare const defaultTicksFont: {
  * Maximum length of an axis label, past which the charts truncate it.
  */
 declare const chartLabelMaxLength = 50;
+/** What every chart starts from: it fills its container, without Chart.js' own legend. */
+declare const defaultChartSettings: Readonly<{
+    options: {
+        responsive: boolean;
+        maintainAspectRatio: boolean;
+        plugins: {
+            legend: {
+                display: boolean;
+            };
+        };
+    };
+}>;
 
 interface ContributionChartDataItem {
     id?: string;
@@ -155,68 +171,7 @@ declare const sumValues: (values: number[]) => number;
  */
 declare const groupDataByCategory: (data: ContributionChartDataItem[], labels: string[], category: string, { emissionCategoryValue, categoryLabel }: IContributionCategory) => ContributionChartDataItem[];
 
-declare const escape: (value: string) => string;
-declare const toLine: (values: any[]) => string;
-
-interface IEmissionCategory {
-    key: string;
-    label: string;
-}
-declare const categoryLabel: (key: string) => string;
-/**
- * The list of all available categories.
- */
-declare const emissionCategories: IEmissionCategory[];
-/**
- * Return all possible values for a specific Category.
- *
- * @param category {string} The specific category
- * @returns List of all values possible for this Category.
- */
-declare const categoryValues: (category: string) => string[];
-/**
- * Return the different categories available for a single Emission.
- *
- * @param emissionId The `@id` of the Emission
- * @returns List of categories.
- */
-declare const emissionCategoriesOf: (emissionId: string) => string[];
-/**
- * Return the Category value for a specific Emission and Category.
- *
- * @param emissionId  The `@id` of the Emission
- * @param category The Category
- * @returns The value
- */
-declare const emissionCategoryValue: (emissionId: string, category: string) => string;
-
-declare const defaultHorizontalBarConfig: Readonly<{
-    options: {
-        indexAxis: "y";
-        scales: {
-            x: {
-                grid: {
-                    drawOnChartArea: false;
-                };
-                ticks: {
-                    callback: (this: chart_js.Scale, value: string | number) => number;
-                };
-            };
-            y: {
-                grid: {
-                    drawOnChartArea: false;
-                };
-                ticks: {
-                    crossAlign: "near";
-                };
-            };
-        };
-    };
-}>;
-/** The text of the tooltip on one bar: its label and value, or every item it groups. */
-declare const defaultHorizontalTooltip: ({ label, count, includedItems }: BarChartDataItem) => string;
-/** The chart's height for this many bars, kept between the two bounds. */
-declare const horizontalBarHeight: (minHeight: number, maxHeight: number, nbRows: number) => number;
+type AnyObject = Record<string, any>;
 
 type placement = 'left' | 'right';
 type positionFn = (n: number, index: number, width: number, chart: Chart, data?: number | number[], placement?: placement) => number;
@@ -292,6 +247,401 @@ declare const lollipopChartPlugin: (settings?: LollipopPluginSettings) => Plugin
 
 declare const increaseScaleLimits: (scale: Scale, handleMinScaleZero?: boolean) => void;
 
+declare const contributionBarHeight = 8;
+declare const contributionHoverHeight = 10;
+declare const defaultContributionSettings: Readonly<{
+    type: "bar";
+    options: {
+        indexAxis: "y";
+        responsive: true;
+        plugins: {
+            tooltip: {
+                enabled: false;
+            };
+            legend: {
+                display: false;
+            };
+        };
+        scales: {
+            x: {
+                stacked: true;
+                display: true;
+                grid: {
+                    display: true;
+                    drawOnChartArea: true;
+                };
+                ticks: {
+                    font: {
+                        family: string;
+                        size: number;
+                    };
+                    callback: (this: chart_js.Scale, label: string | number) => string;
+                };
+            };
+            y: {
+                stacked: true;
+                display: true;
+                position: "left";
+                grid: {
+                    display: true;
+                    drawOnChartArea: false;
+                    drawTicks: true;
+                    tickLength: number;
+                    offset: false;
+                };
+                ticks: {
+                    color: string;
+                    padding: number;
+                    crossAlign: "center";
+                    font: {
+                        weight: number;
+                        family: string;
+                        size: number;
+                    };
+                    callback: (this: chart_js.Scale, value: string | number) => string;
+                };
+            };
+        };
+    };
+}>;
+/** The chart's height for this many stacks, kept between the two bounds. */
+declare const contributionChartHeight: (minHeight: number, maxHeight: number, nbRows: number) => number;
+/** The middle of a stack across the datasets drawn, where its tooltip opens. */
+declare const datasetCenter: (chart: Chart, index: number) => number;
+declare const contributionItemColor: (item: ContributionChartDataItem) => string;
+/** Each item's value in one stack, with its own items, largest first, without the items it lacks. */
+declare const dataAtIndex: (data: ContributionChartDataItem[], index: number, includeItems?: boolean) => {
+    value: number;
+    includedItems: {
+        value: number;
+        id?: string;
+        label: string;
+        values: number[];
+        color?: string;
+        backgroundColor?: string;
+        borderColor?: string;
+        includedItems?: ContributionChartDataItem[];
+    }[];
+    id?: string;
+    label: string;
+    values: number[];
+    color?: string;
+    backgroundColor?: string;
+    borderColor?: string;
+}[];
+declare const contributionCsv: (labels: string[], data: ContributionChartDataItem[]) => string;
+declare const hasNegativeValues: (data?: ContributionChartDataItem[]) => boolean;
+/** One stacked dataset per item, each keeping the items it groups for the tooltip. */
+declare const contributionData: (data: ContributionChartDataItem[], labels: string[]) => {
+    datasets: {
+        label: string;
+        data: number[];
+        backgroundColor: string;
+        borderColor: string;
+        barThickness: number;
+        maxBarThickness: number;
+        includedItems: ContributionChartDataItem[];
+    }[];
+    labels: string[];
+};
+interface ContributionChartSettings {
+    onClick: (event: ChartEvent, activeElements: ActiveElement[], chart: Chart) => void;
+    /** Axis labels interactive, through the axis hover plugin. */
+    axis?: AxisHoverSettings;
+    /** The x axis title. */
+    label?: string;
+    hasNegativeValues: boolean;
+    /** Axes are hidden on a small screen. */
+    mobile: boolean;
+}
+/** The contribution chart's own configuration, to merge over `defaultContributionSettings`. */
+declare const contributionChartConfig: ({ onClick, axis, label, hasNegativeValues: negative, mobile }: ContributionChartSettings) => {
+    options: {
+        onClick: (event: ChartEvent, activeElements: ActiveElement[], chart: Chart) => void;
+        plugins: any;
+        scales: {
+            x: {
+                display: boolean;
+                afterDataLimits: (scale: chart_js.Scale<chart_js.CoreScaleOptions>) => void;
+                title: {
+                    display: boolean;
+                    text: string;
+                };
+                grid: {
+                    lineWidth: (context: chart_js.ScriptableScaleContext) => 0 | 1;
+                };
+            };
+            y: {
+                display: boolean;
+            };
+        };
+    };
+    plugins: (Plugin<keyof chart_js.ChartTypeRegistry, AnyObject> | {
+        id: string;
+        afterEvent: (chart: Chart, args: {
+            event: ChartEvent;
+            changed?: boolean;
+        }) => void;
+        beforeDraw: (chart: Chart) => void;
+    })[];
+};
+
+declare const escape: (value: string) => string;
+declare const toLine: (values: any[]) => string;
+
+declare const d3ellipse: <Datum>(selection: Selection<SVGTextElement, Datum, any, any>, maxWidth: number, ellipsisStr?: string) => void;
+declare const d3wrap: <Datum>(t: Selection<SVGTextElement, Datum, any, any>, { maxWidth, maxLines, words, nHeight, lHeight, vcentre, ownLineWord }: {
+    maxWidth: number;
+    maxLines: number;
+    words: string[];
+    nHeight: number;
+    lHeight: number;
+    vcentre?: boolean;
+    ownLineWord?: string;
+}) => void;
+
+interface HistogramChartDataItem {
+    label: string;
+    values: number[];
+    color?: string;
+    backgroundColor?: string;
+    borderColor?: string;
+}
+declare const defaultDistributionSettings: Readonly<{
+    type: "line";
+    options: {
+        events: any[];
+        responsive: true;
+        plugins: {
+            tooltip: {
+                enabled: false;
+            };
+            legend: {
+                display: false;
+                align: "center";
+            };
+        };
+        scales: {
+            y: {
+                display: true;
+                position: "left";
+                grid: {
+                    display: true;
+                };
+                beginAtZero: true;
+                ticks: {
+                    crossAlign: "center";
+                };
+            };
+        };
+    };
+}>;
+/** What the distribution chart is given: samples to bin, or the parameters of a normal curve. */
+interface DistributionChartInputs {
+    distribution?: number[];
+    value?: number;
+    label?: string;
+    nbBins?: number;
+    maxPercentile?: number;
+    mu?: number;
+    sd?: number;
+    intervalMin?: number;
+    intervalMax?: number;
+    minX?: number;
+}
+/** `sd` must be strictly positive: a zero or negative deviation makes the PDF a division by zero. */
+declare const isParametric: ({ mu, sd }: DistributionChartInputs) => boolean;
+/**
+ * The distribution chart's data and configuration: a histogram of the samples with the value marked, or
+ * the normal curve with its interval, mean and value, when only the parameters are known.
+ */
+declare const distributionChart: (inputs: DistributionChartInputs) => {
+    data: ChartData<"bar" | "line">;
+    config: Readonly<{
+        type: "line";
+        options: {
+            events: any[];
+            responsive: true;
+            plugins: {
+                tooltip: {
+                    enabled: false;
+                };
+                legend: {
+                    display: false;
+                    align: "center";
+                };
+            };
+            scales: {
+                y: {
+                    display: true;
+                    position: "left";
+                    grid: {
+                        display: true;
+                    };
+                    beginAtZero: true;
+                    ticks: {
+                        crossAlign: "center";
+                    };
+                };
+            };
+        };
+    }> & {
+        options: {
+            plugins: {
+                annotation: {
+                    annotations: Record<string, AnnotationOptions>;
+                };
+            };
+            scales: {
+                x: {
+                    type: "linear";
+                    display: true;
+                    ticks: {
+                        font: {
+                            family: string;
+                            size: number;
+                            weight: number;
+                        };
+                        color: string;
+                        callback: (this: chart_js.Scale, tick: string | number) => string;
+                    };
+                    title: {
+                        display: true;
+                        text: string;
+                    };
+                };
+                y: {
+                    ticks: {
+                        display: false;
+                    };
+                    grid: {
+                        display: false;
+                    };
+                    title: {
+                        display: false;
+                    };
+                };
+            };
+        };
+    };
+} | {
+    data: ChartData<"bar" | "line">;
+    config: Readonly<{
+        type: "line";
+        options: {
+            events: any[];
+            responsive: true;
+            plugins: {
+                tooltip: {
+                    enabled: false;
+                };
+                legend: {
+                    display: false;
+                    align: "center";
+                };
+            };
+            scales: {
+                y: {
+                    display: true;
+                    position: "left";
+                    grid: {
+                        display: true;
+                    };
+                    beginAtZero: true;
+                    ticks: {
+                        crossAlign: "center";
+                    };
+                };
+            };
+        };
+    }> & {
+        options: {
+            scales: {
+                x: {
+                    display: true;
+                    grid: {
+                        offset: true;
+                    };
+                    min: number;
+                    ticks: {
+                        callback: (this: chart_js.Scale, value: string | number) => string;
+                    };
+                    title: {
+                        display: true;
+                        text: string;
+                    };
+                };
+                y: {
+                    ticks: {
+                        font: {
+                            family: string;
+                            size: number;
+                            weight: number;
+                        };
+                        color: string;
+                    };
+                    title: {
+                        display: true;
+                        text: string;
+                    };
+                };
+            };
+        };
+    };
+};
+
+/** Saves `url` as `fileName` through a temporary link, then frees an object URL it was given. */
+declare const downloadFile: (url: string, fileName: string) => void;
+
+interface IEmissionCategory {
+    key: string;
+    label: string;
+}
+declare const categoryLabel: (key: string) => string;
+/**
+ * The list of all available categories.
+ */
+declare const emissionCategories: IEmissionCategory[];
+/**
+ * Return all possible values for a specific Category.
+ *
+ * @param category {string} The specific category
+ * @returns List of all values possible for this Category.
+ */
+declare const categoryValues: (category: string) => string[];
+/**
+ * Return the different categories available for a single Emission.
+ *
+ * @param emissionId The `@id` of the Emission
+ * @returns List of categories.
+ */
+declare const emissionCategoriesOf: (emissionId: string) => string[];
+/**
+ * Return the Category value for a specific Emission and Category.
+ *
+ * @param emissionId  The `@id` of the Emission
+ * @param category The Category
+ * @returns The value
+ */
+declare const emissionCategoryValue: (emissionId: string, category: string) => string;
+
+interface ChartExportMetadata {
+    title?: string;
+    fileName?: string;
+    width?: number;
+    height?: number;
+    units?: string;
+    lollipopConfig?: Omit<LollipopPluginSettings, 'isMouseInsideLollipopFn'>;
+    afterBarDrawConfig?: AfterBarDrawSettings | AfterBarDrawSettings[];
+}
+declare const convertToSvg: (config: Partial<ChartConfiguration>, metadata?: ChartExportMetadata) => Promise<string>;
+declare const exportAsSVG: (config: Partial<ChartConfiguration>, metadata: ChartExportMetadata) => Promise<void>;
+declare const downloadSvg: (svgElement: HTMLElement) => void;
+declare const downloadPng: (svgElement: HTMLElement, { width, height }?: {
+    width?: number;
+    height?: number;
+}) => Promise<void>;
+
 /** How much each indicator, by its position on the node, contributes to each other indicator, per method. */
 type contributions = Record<string, Record<string, number>>;
 /** The contributions file the engine writes beside an ImpactAssessment. */
@@ -365,4 +715,255 @@ declare const breakdownScale: (values: IContributionLog[]) => {
     };
 };
 
-export { type AfterBarDrawSettings, type AxisHoverSettings, type AxisLabelEvent, type BarChartDataItem, ColorPalette, type ContributionChartDataItem, type ContributionTooltipData, type IContributionCategory, type IContributionLog, type IEmissionCategory, type INodeContributions, type LollipopPluginSettings, type RgbColor, afterBarDrawPlugin, axisHoverPlugin, axisLabelCursor, backgroundHoverPlugin, barDataset, breakdownBarText, breakdownBars, breakdownScale, breakdownTooltip, categoryLabel, categoryValues, chartBreakdownLabel, chartLabel, chartLabelMaxLength, colorToRgba, type contributions, defaultBarDatasets, defaultBarSettings, defaultHorizontalBarConfig, defaultHorizontalTooltip, defaultTicksFont, emissionCategories, emissionCategoriesOf, emissionCategoryValue, escape, getColor, groupDataByCategory, groupLogsById, hasNegativeContributions, hexToRgba, horizontalBarHeight, increaseScaleLimits, indicatorLogs, listColor, listColorContinuous, listColorWithAlpha, logToCsv, logsTotalValue, lollipopChartPlugin, namedContributors, nonZeroContributors, parseColor, parseContributions, sumValues, toLine, valueRatio, withOthers };
+type termType = Partial<ITermJSONLD | Term>;
+declare enum ChartNodeType {
+    midpoint = "midpoint",
+    category = "category",
+    emission = "emission",
+    endpoint = "endpoint",
+    input = "input",
+    operation = "operation",
+    root = "root"
+}
+declare const nodeBorderColours: {
+    endpoint: string;
+    midpoint: string;
+    category: string;
+    emission: string;
+    input: string;
+    operation: string;
+};
+declare const nodeColours: {
+    endpoint: string;
+    midpoint: string;
+    category: string;
+    emission: string;
+    input: string;
+    operation: string;
+};
+declare const legend: {
+    type: ChartNodeType;
+    text: string;
+}[];
+interface NodeDatum {
+    id?: string;
+    terms?: termType[];
+    modelId?: string;
+    modelName?: string;
+    modelDocs?: string;
+    label: string;
+    type: ChartNodeType;
+    value: number | null;
+    weightedValue?: number | null;
+    fraction?: number;
+    children?: NodeDatum[];
+    group?: boolean;
+    showBar?: boolean;
+    units: string;
+}
+interface IChartInputLog {
+    id: string;
+    label: string;
+    units: string;
+    weightedValue: number;
+    value: number;
+    operations: IChartInputLog[];
+}
+interface IChartData {
+    indicator: string;
+    category?: string;
+    categoryLabel?: string;
+    contributor: string;
+    coefficient: number;
+    value: number;
+    weightedValue: number;
+    modelId: string;
+    inputs?: IChartInputLog[];
+}
+/** A Term as the chart names it; a search result's score and fields may come along. */
+type term = ITermJSONLD & {
+    _score?: number;
+    docs?: string;
+};
+interface ITermMapping {
+    [id: string]: term;
+}
+declare const getUnitsAndLabel: (terms: termType | termType[], fallbackLabel?: string) => {
+    label: string;
+    terms: termType[];
+    units: string;
+};
+interface IIndicatorsSum {
+    [indicator: string]: number;
+}
+declare const sumIndicators: (data: IChartData[]) => IIndicatorsSum;
+declare const groupIndicators: (data: IChartData[], terms?: ITermMapping, totals?: IIndicatorsSum) => {
+    [id: string]: NodeDatum;
+};
+
+/** The terms the driver chart names: what contributes, what is contributed to, and the models. */
+declare const hierarchyTermTypes: TermTermType[];
+declare const defaultIndicatorsModelId = "defaultIndicatorsModelId";
+declare const defaultIndicatorsModelName = "Default Indicators (multi-model)";
+/** HESTIA's default model for an indicator, from the glossary. */
+declare const defaultModelId: (indicatorId: string) => string;
+/** What the chart cannot show as it should: a contribution naming a term it has not been given. */
+declare const hierarchyWarnings: (logs: IChartData[], terms: {
+    [id: string]: term;
+}) => string[];
+/**
+ * The driver chart's data from the contributions file: one contribution per indicator, contributor and
+ * model, with the inputs and operations the contributor came from.
+ */
+declare const hierarchyContributions: (impactAssessment: IImpactAssessmentJSONLD, stored: INodeContributions) => IChartData[];
+/** The terms the contributions name that `terms` does not have yet, to look up. */
+declare const missingTermIds: (logs: IChartData[], terms?: ITermMapping) => string[];
+/** The models to choose from: HESTIA's default indicators first when any contribution uses one. */
+declare const hierarchyModels: (logs: IChartData[], terms: ITermMapping) => Partial<ITermJSONLD>[];
+/** The contributions of one model, each emission or resource use in its category when one is chosen. */
+declare const hierarchyData: (logs: IChartData[], terms: ITermMapping, modelId: string, category?: string) => IChartData[];
+
+declare const nonLCAIndicatorsId = "nonLCAIndicators";
+type Indicators = ReturnType<typeof groupIndicators>;
+/** Endpoints linked to their midpoints, and midpoints to any midpoint below them, each listed once. */
+declare const linkIndicators: (indicators: Indicators) => {
+    children: NodeDatum[];
+    id?: string;
+    terms?: (Partial<_hestia_earth_schema.Term> | Partial<_hestia_earth_schema.ITermJSONLD>)[];
+    modelId?: string;
+    modelName?: string;
+    modelDocs?: string;
+    label: string;
+    type: ChartNodeType;
+    value: number | null;
+    weightedValue?: number | null;
+    fraction?: number;
+    group?: boolean;
+    showBar?: boolean;
+    units: string;
+}[];
+/**
+ * The tree's first layer: the endpoints, with the midpoints no endpoint covers under "Other
+ * indicators"; or, without endpoints, every indicator.
+ */
+declare const hierarchyChildren: (data: IChartData[], terms: ITermMapping) => NodeDatum[];
+/** The legend for the layers drawn, naming the category layer after the category chosen. */
+declare const hierarchyLegend: (data: IChartData[], includedTypes: ChartNodeType[]) => {
+    type: ChartNodeType;
+    text: string;
+}[];
+/** The chart's data as CSV: a line per contribution, then its inputs and their operations. */
+declare const hierarchyCsv: (data: IChartData[], terms: ITermMapping) => string;
+
+/** Where a node's tooltip links to: the platform the chart is shown on. */
+interface HierarchyUrls {
+    baseUrl: () => string;
+    schemaBaseUrl: () => string;
+}
+/** The tooltip each application draws itself, opened on a node with what it should say. */
+interface HierarchyTooltip {
+    open: (tipData: HierarchyTipData, target: Element) => void;
+    close: () => void;
+    /** The tooltip's element while open, so that moving onto it keeps it open. */
+    element: () => Element | null;
+}
+interface HierarchyChartOptions {
+    data: IChartData[];
+    terms: ITermMapping;
+    tooltip: HierarchyTooltip;
+    urls: HierarchyUrls;
+}
+interface ChartNode extends HierarchyPointNode<NodeDatum> {
+    _children?: ChartNode[];
+    _groupChildren?: ChartNode[];
+    _open?: boolean;
+    _greyed?: boolean;
+    _groupOpen?: boolean;
+    _timeout?: ReturnType<typeof setTimeout>;
+}
+declare const generateTipData: (nodeDatum: ChartNode, { baseUrl, schemaBaseUrl }: HierarchyUrls) => {
+    hasWeightedValue: number;
+    weightedValueText: string;
+    valueKeyHref: string;
+    modelDocsHref: string;
+    valueValueText: string;
+    hasValue: number;
+    modelKeyHref: string;
+    modelValue: string;
+    modelValueHref: string;
+    termKeyHref: string;
+    terms: {
+        text: any;
+        href: string;
+    }[];
+};
+type HierarchyTipData = ReturnType<typeof generateTipData>;
+/**
+ * Draws the platform's driver chart into `svgElement`: the endpoints, opening onto what drives them,
+ * down to the inputs and operations behind each emission. The tree is the chart's own state, kept here
+ * between clicks; the application gives the data, the terms, its tooltip and the platform's links.
+ *
+ * Give the svg, or an element around it, the class `hestia-hierarchy-chart`, and import
+ * `@hestia-earth/ui-components-charts/hierarchy-chart.css` once: only the nodes take the pointer.
+ *
+ * @returns The layers drawn, for a legend.
+ */
+declare const drawHierarchyChart: (svgElement: SVGSVGElement, { data, terms, tooltip, urls }: HierarchyChartOptions) => {
+    includedTypes: ChartNodeType[];
+};
+
+declare const defaultHorizontalBarConfig: Readonly<{
+    options: {
+        indexAxis: "y";
+        scales: {
+            x: {
+                grid: {
+                    drawOnChartArea: false;
+                };
+                ticks: {
+                    callback: (this: chart_js.Scale, value: string | number) => number;
+                };
+            };
+            y: {
+                grid: {
+                    drawOnChartArea: false;
+                };
+                ticks: {
+                    crossAlign: "near";
+                };
+            };
+        };
+    };
+}>;
+/** The text of the tooltip on one bar: its label and value, or every item it groups. */
+declare const defaultHorizontalTooltip: ({ label, count, includedItems }: BarChartDataItem) => string;
+/** The chart's height for this many bars, kept between the two bounds. */
+declare const horizontalBarHeight: (minHeight: number, maxHeight: number, nbRows: number) => number;
+
+/** A line chart over time, a point a day. */
+declare const defaultLineSettings: Readonly<{
+    type: "line";
+    options: {
+        scales: {
+            x: {
+                type: "time";
+                time: {
+                    unit: "day";
+                };
+                ticks: {
+                    font: {
+                        family: string;
+                        size: number;
+                    };
+                };
+            };
+        };
+    };
+}>;
+
+/** A number at `precision` significant digits, with thousands separators; anything else as it is. */
+declare const formatPrecision: (value: string | number | boolean, precision?: string | number, enableComma?: boolean) => string | number | boolean;
+
+declare const registerChart: (items?: ChartComponentLike[]) => () => void;
+
+export { type AfterBarDrawSettings, type AxisHoverSettings, type AxisLabelEvent, type BarChartDataItem, type ChartExportMetadata, ChartNodeType, ColorPalette, type ContributionChartDataItem, type ContributionChartSettings, type ContributionTooltipData, type DistributionChartInputs, type HierarchyChartOptions, type HierarchyTipData, type HierarchyTooltip, type HierarchyUrls, type HistogramChartDataItem, type IChartData, type IChartInputLog, type IContributionCategory, type IContributionLog, type IEmissionCategory, type INodeContributions, type ITermMapping, type LollipopPluginSettings, type NodeDatum, type RgbColor, afterBarDrawPlugin, axisHoverPlugin, axisLabelCursor, backgroundHoverPlugin, barDataset, breakdownBarText, breakdownBars, breakdownScale, breakdownTooltip, categoryLabel, categoryValues, chartBreakdownLabel, chartLabel, chartLabelMaxLength, colorToRgba, contributionBarHeight, contributionChartConfig, contributionChartHeight, contributionCsv, contributionData, contributionHoverHeight, contributionItemColor, type contributions, convertToSvg, d3ellipse, d3wrap, dataAtIndex, datasetCenter, defaultBarDatasets, defaultBarSettings, defaultChartSettings, defaultContributionSettings, defaultDistributionSettings, defaultHorizontalBarConfig, defaultHorizontalTooltip, defaultIndicatorsModelId, defaultIndicatorsModelName, defaultLineSettings, defaultModelId, defaultTicksFont, distributionChart, downloadFile, downloadPng, downloadSvg, drawHierarchyChart, emissionCategories, emissionCategoriesOf, emissionCategoryValue, escape, exportAsSVG, formatPrecision, getColor, getUnitsAndLabel, groupDataByCategory, groupIndicators, groupLogsById, hasNegativeContributions, hasNegativeValues, hexToRgba, hierarchyChildren, hierarchyContributions, hierarchyCsv, hierarchyData, hierarchyLegend, hierarchyModels, hierarchyTermTypes, hierarchyWarnings, horizontalBarHeight, increaseScaleLimits, indicatorLogs, isParametric, legend, linkIndicators, listColor, listColorContinuous, listColorWithAlpha, logToCsv, logsTotalValue, lollipopChartPlugin, missingTermIds, namedContributors, nodeBorderColours, nodeColours, nonLCAIndicatorsId, nonZeroContributors, parseColor, parseContributions, registerChart, sumIndicators, sumValues, type term, toLine, valueRatio, withOthers };