import * as i0 from '@angular/core';
import { AfterViewInit, ElementRef, EventEmitter, ApplicationRef, AfterContentInit, Type, ModuleWithProviders } from '@angular/core';
import * as ChartJS from 'chart.js';
import { InteractionMode as InteractionMode$1, Chart, LinearScale, LogarithmicScale, TimeScale } from 'chart.js';
import { Locale } from 'date-fns';
import { Context } from 'chartjs-plugin-datalabels';
import * as i3 from '@angular/common';
import * as i4 from '@angular/forms';

declare class DecimalFormatService {
    /**
     * @fieldOf decimalFormat
     * @type String
     */
    prefix: string;
    /**
     * @fieldOf decimalFormat
     * @type String
     */
    suffix: string;
    /**
     * @description Grouping size
     * @fieldOf decimalFormat
     * @type String
     */
    comma: number;
    /**
     * @description Minimum integer digits to be displayed
     * @fieldOf decimalFormat
     * @type Number
     */
    minInt: number;
    /**
     * @description Minimum fractional digits to be displayed
     * @fieldOf decimalFormat
     * @type String
     */
    minFrac: number;
    /**
     * @description Maximum fractional digits to be displayed
     * @fieldOf decimalFormat
     * @type String
     */
    maxFrac: number;
    /**
     * @description Formats given value
     * @methodOf decimalFormat
     * @param numStr
     * @param formatStr
     * @return Formatted number
     * @author Oskan Savli
     */
    execute(numStr: any, formatStr: string): any;
    private configureService;
    /**
     * @description Converts formatted value back to non-formatted value
     * @methodOf decimalFormat
     * @param fNumStr Formatted number
     * @return Original number
     * @author Oskan Savli
     */
    private formatBack;
    /**
     * @description We shouldn't return strings like 1.000 in formatBack method.
     * However, using only Number(str) is not enough, because it omits . in big numbers
     * like 23423423423342234.34 => 23423423423342236 . There's a conflict in cases
     * 6143 and 6541.
     * @methodOf decimalFormat
     * @param str Numberic string
     * @return Corrected numeric string
     * @author Serdar Bicer
     */
    private getNumericString;
    static ɵfac: i0.ɵɵFactoryDeclaration<DecimalFormatService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<DecimalFormatService>;
}

declare class ChartTooltipItem {
    title?: string;
    label?: string;
    afterLabel?: string;
    valueInAfterLabel?: boolean;
    numberFormat?: string;
    constructor(title?: string, label?: string, afterLabel?: string, valueInAfterLabel?: boolean, numberFormat?: string);
}
declare class ChartTooltipSettings {
    backgroundColor?: string;
    borderColor?: string;
    borderWidth?: number;
    bodyFontColor?: string;
    bodyFontSize?: number;
    titleFontSize?: number;
    titleFontColor?: string;
    constructor(backgroundColor?: string, borderColor?: string, borderWidth?: number, bodyFontColor?: string, bodyFontSize?: number, titleFontSize?: number, titleFontColor?: string);
}
declare class TooltipLegacyService {
    private readonly decimalFormatService;
    constructor(decimalFormatService: DecimalFormatService);
    title(tooltipItems: any): any;
    tooltipLabel(tooltipItem: any, tooltipTimeFormatConstant: any): any;
    tooltipAfterLabel(tooltipItem: any): string;
    static ɵfac: i0.ɵɵFactoryDeclaration<TooltipLegacyService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<TooltipLegacyService>;
}

interface MultipleAxis {
    id: string;
    type: string;
    position: string;
    stacked: boolean;
    max: number;
    min: number;
    ticks: {
        min: number;
        max: number;
        stepSize?: number;
        display?: boolean;
        callbackFunction?(any: any): any;
    };
    border: {
        drawBorder: boolean;
    };
    grid: {
        display: boolean;
    };
    title: {
        text: string;
    };
}
declare class ChartItem {
    label: string;
    data: Array<any>;
    borderColor?: string;
    backgroundColor?: string;
    fill?: boolean;
    showLine?: boolean;
    isGradient?: boolean;
    borderWidth?: number;
    chartType?: string;
    chartTooltipItem?: ChartTooltipItem | Array<ChartTooltipItem>;
    pointRadius?: number;
    yAxisID?: string;
    legendType?: string;
    labelBorderColors?: Array<number[]>;
    labelBackgroundColors?: Array<number[]>;
    constructor(label: string, data: Array<any>, borderColor?: string, backgroundColor?: string, fill?: boolean, showLine?: boolean, isGradient?: boolean, borderWidth?: number, chartType?: string, chartTooltipItem?: ChartTooltipItem | Array<ChartTooltipItem>, pointRadius?: number, yAxisID?: string, legendType?: string, labelBorderColors?: Array<number[]>, labelBackgroundColors?: Array<number[]>);
}
declare class Annotation$1 {
    drawTime: string;
    type: string;
    borderColor?: string;
    borderWidth?: number;
    scaleId: string;
    constructor(drawTime: string, type: string, borderColor?: string, borderWidth?: number, scaleId?: string);
}
declare class ChartLineAnnotation extends Annotation$1 {
    label: ChartLabelAnnotation;
    value: number;
    orientation: string;
    borderDash?: Array<number>;
    endValue?: number;
    constructor(label: ChartLabelAnnotation, value: number, orientation: string, drawTime: string, type: string, borderDash?: Array<number>, borderColor?: string, borderWidth?: number, endValue?: number);
}
declare class ChartLine {
    xMinValue: number;
    yMinValue: number;
    xMaxValue: number;
    yMaxValue: number;
    borderColor?: string;
    borderWidth?: number;
    constructor(xMinValue: number, yMinValue: number, xMaxValue: number, yMaxValue: number, borderColor?: string, borderWidth?: number);
}
declare class ChartBoxAnnotation extends Annotation$1 {
    xMin: number;
    xMax: number;
    yMin: number;
    yMax: number;
    backgroundColor?: string;
    constructor(drawTime: string, xMin: number, xMax: number, yMin: number, yMax: number, type: string, backgroundColor?: string, borderColor?: string, borderWidth?: number);
}
declare class ChartLabelAnnotation {
    text?: string;
    position?: string;
    backgroundColor?: string;
    fontStyle?: string;
    fontColor?: string;
    constructor(text?: string, position?: string, backgroundColor?: string, fontStyle?: string, fontColor?: string);
}
declare class ChartLabelSettings {
    position?: ChartLabelPosition;
    labelColors?: ChartLabelColor;
    chartLabelFont?: ChartLabelFont;
    chartLabelPadding?: ChartLabelPadding;
    chartLabelText?: ChartLabelText;
    formatter?: (value: any, context: any) => string;
    constructor(position?: ChartLabelPosition, labelColors?: ChartLabelColor, chartLabelFont?: ChartLabelFont, chartLabelPadding?: ChartLabelPadding, chartLabelText?: ChartLabelText, formatter?: (value: any, context: any) => string);
}
declare class ChartLabelPosition {
    align?: string | number;
    anchor?: string;
    clamp?: boolean;
    clip?: boolean;
    display?: ((context: any) => (boolean | string)) | boolean | string;
    offset?: number;
    rotation?: number;
    constructor(align?: string | number, anchor?: string, clamp?: boolean, clip?: boolean, display?: ((context: any) => (boolean | string)) | boolean | string, offset?: number, rotation?: number);
}
declare class ChartLabelColor {
    backgroundColor?: string;
    color?: string;
    borderColor?: string;
    borderRadius?: number;
    borderWidth?: number;
    opacity?: number;
    constructor(backgroundColor?: string, color?: string, borderColor?: string, borderRadius?: number, borderWidth?: number, opacity?: number);
}
declare class ChartLabelFont {
    font?: object;
    family?: string;
    size?: number;
    style?: string;
    weight?: string | number;
    lineHeight?: string | number;
    constructor(font?: object, family?: string, size?: number, style?: string, weight?: string | number, lineHeight?: string | number);
}
declare class ChartLabelPadding {
    padding?: number | object;
    top?: number;
    right?: number;
    bottom?: number;
    left?: number;
    constructor(padding?: number | object, top?: number, right?: number, bottom?: number, left?: number);
}
declare class ChartLabelText {
    textAlign?: string;
    textStrokeColor?: string;
    textShadowBlur?: number;
    textStrokeWidth?: number;
    textShadowColor?: string;
    constructor(textAlign?: string, textStrokeColor?: string, textShadowBlur?: number, textStrokeWidth?: number, textShadowColor?: string);
}
declare class ChartMultipleYAxisScales {
    id?: string;
    type?: string;
    position?: string;
    stacked: boolean;
    ticks?: {
        min: number;
        max: number;
        stepSize?: number;
        display?: boolean;
    };
    gridLines?: {
        display: boolean;
        drawBorder: boolean;
    };
    scaleLabel?: {
        display: boolean;
        labelString: string;
    };
    constructor(id?: string, type?: string, position?: string, stacked?: boolean, ticks?: {
        min: number;
        max: number;
        stepSize?: number;
        display?: boolean;
    }, gridLines?: {
        display: boolean;
        drawBorder: boolean;
    }, scaleLabel?: {
        display: boolean;
        labelString: string;
    });
    getScaleDefinition(callbackFunction?: (value: any, index: any, values: any) => string): MultipleAxis;
}
declare class ChartIntersectionSettings {
    intersect: boolean;
    mode: string;
    constructor(intersect?: boolean, mode?: InteractionMode$1);
}
declare class ChartLegacyComponent implements AfterViewInit {
    private readonly appRef;
    private readonly tooltipsService;
    canvas: ElementRef;
    topLegend: ElementRef;
    bottomLegend: ElementRef;
    labels: Array<any>;
    data: Array<ChartItem>;
    annotations: Array<Annotation$1 | ChartLineAnnotation | ChartBoxAnnotation>;
    showLegend: boolean;
    legendPosition: string;
    intersectionSettings: ChartIntersectionSettings;
    isHorizontal: boolean;
    yMinValue: any;
    yMaxValue: any;
    xMinValue: any;
    xMaxValue: any;
    xAutoSkip: boolean;
    yLabelAxis: string;
    xLabelAxis: string;
    lineTension: number;
    isBackgroundGrid: boolean;
    type: string;
    responsive: boolean;
    maintainAspectRatio: boolean;
    tooltipSettings: ChartTooltipSettings;
    chartLabelSettings: ChartLabelSettings;
    isStacked: boolean;
    animationDuration: number;
    minValueForRadar: number;
    maxValueForRadar: number;
    multipleYAxisScales: ChartMultipleYAxisScales[];
    timeScale: boolean;
    timeUnit: string;
    tooltipTimeFormat: string;
    customLegend: boolean;
    legendWithoutBox: boolean;
    hideInitialAndFinalTick: boolean;
    hideFinalTick: boolean;
    chartLine: ChartLine;
    pointStyle: string | 'circle' | 'cross' | 'crossRot' | 'dash' | 'line' | 'rect' | 'rectRounded' | 'rectRot' | 'star' | 'triangle';
    canvasBackground: string;
    itemSelectedChange: EventEmitter<any>;
    action: EventEmitter<any>;
    chart: Chart;
    chartResized: boolean;
    private defaultColors;
    private _itemSelected;
    private dataset;
    private _annotations;
    private axesVisible;
    private yAxisLabelVisible;
    private xAxisLabelVisible;
    constructor(appRef: ApplicationRef, tooltipsService: TooltipLegacyService);
    get itemSelected(): any;
    set itemSelected(value: any);
    ngAfterViewInit(): void;
    rgba(colour: Array<number>, alpha: number): string;
    getResizedBase64Image(height?: number, width?: number): string;
    doResizeChart(height: number, width: number): boolean;
    doUpdate(): void;
    drawLine(chartData: any, chartLine: ChartLine): void;
    private initCustomLegend;
    private buildCustomLegend;
    private generateLegend;
    private drawChart;
    private legendCallback;
    private scales;
    private initDatalabelsFontProperties;
    private initDatalabelsPaddingProperties;
    private setData;
    private addAnnotations;
    private addLineAnnotation;
    private getColorNumber;
    private addBoxAnnotation;
    private setAxisVisibility;
    private legendClickCallback;
    static ɵfac: i0.ɵɵFactoryDeclaration<ChartLegacyComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<ChartLegacyComponent, "systelab-chart-legacy", never, { "labels": { "alias": "labels"; "required": false; }; "data": { "alias": "data"; "required": false; }; "annotations": { "alias": "annotations"; "required": false; }; "showLegend": { "alias": "showLegend"; "required": false; }; "legendPosition": { "alias": "legendPosition"; "required": false; }; "intersectionSettings": { "alias": "intersectionSettings"; "required": false; }; "isHorizontal": { "alias": "isHorizontal"; "required": false; }; "yMinValue": { "alias": "yMinValue"; "required": false; }; "yMaxValue": { "alias": "yMaxValue"; "required": false; }; "xMinValue": { "alias": "xMinValue"; "required": false; }; "xMaxValue": { "alias": "xMaxValue"; "required": false; }; "xAutoSkip": { "alias": "xAutoSkip"; "required": false; }; "yLabelAxis": { "alias": "yLabelAxis"; "required": false; }; "xLabelAxis": { "alias": "xLabelAxis"; "required": false; }; "lineTension": { "alias": "lineTension"; "required": false; }; "isBackgroundGrid": { "alias": "isBackgroundGrid"; "required": false; }; "type": { "alias": "type"; "required": false; }; "responsive": { "alias": "responsive"; "required": false; }; "maintainAspectRatio": { "alias": "maintainAspectRatio"; "required": false; }; "tooltipSettings": { "alias": "tooltipSettings"; "required": false; }; "chartLabelSettings": { "alias": "chartLabelSettings"; "required": false; }; "isStacked": { "alias": "isStacked"; "required": false; }; "animationDuration": { "alias": "animationDuration"; "required": false; }; "minValueForRadar": { "alias": "minValueForRadar"; "required": false; }; "maxValueForRadar": { "alias": "maxValueForRadar"; "required": false; }; "multipleYAxisScales": { "alias": "multipleYAxisScales"; "required": false; }; "timeScale": { "alias": "timeScale"; "required": false; }; "timeUnit": { "alias": "timeUnit"; "required": false; }; "tooltipTimeFormat": { "alias": "tooltipTimeFormat"; "required": false; }; "customLegend": { "alias": "customLegend"; "required": false; }; "legendWithoutBox": { "alias": "legendWithoutBox"; "required": false; }; "hideInitialAndFinalTick": { "alias": "hideInitialAndFinalTick"; "required": false; }; "hideFinalTick": { "alias": "hideFinalTick"; "required": false; }; "chartLine": { "alias": "chartLine"; "required": false; }; "pointStyle": { "alias": "pointStyle"; "required": false; }; "canvasBackground": { "alias": "canvasBackground"; "required": false; }; "itemSelected": { "alias": "itemSelected"; "required": false; }; }, { "itemSelectedChange": "itemSelectedChange"; "action": "action"; }, never, never, false, never>;
}

type AnnotationTypes = LineAnnotation | BoxAnnotation | PointAnnotation | EllipseAnnotation;
interface Annotation {
    type: AnnotationType;
    axisID?: string;
    drawTime?: AnnotationDrawTime;
    backgroundColor?: string;
}
declare enum AnnotationType {
    line = "line",
    box = "box",
    point = "point",
    ellipse = "ellipse"
}
declare enum AnnotationDrawTime {
    afterDraw = "afterDraw",
    afterDatasetsDraw = "afterDatasetsDraw",
    beforeDraw = "beforeDraw",
    beforeDatasetsDraw = "beforeDatasetsDraw"
}
interface LineAnnotation extends Annotation {
    label?: AnnotationLabel;
    value: number | string;
    endValue?: number;
    orientation?: LineAnnotationOrientation;
    border?: {
        width?: number;
        color?: string;
        dash?: boolean;
    };
}
declare enum LineAnnotationOrientation {
    vertical = "vertical",
    horizontal = "horizontal"
}
interface LineAnnotationDefaultConfiguration extends Omit<LineAnnotation, 'value' | 'type' | 'label'> {
    label?: Omit<AnnotationLabel, 'display' | 'text'>;
}
interface AnnotationLabel {
    display: boolean;
    text: string;
    position?: AnnotationLabelLabelPosition;
    backgroundColor?: string;
    font?: {
        style: string;
        color: string;
    };
    border?: {
        width?: number;
        color?: string;
        radius?: number;
    };
}
declare enum AnnotationLabelLabelPosition {
    start = "start",
    center = "center",
    end = "end"
}
interface BoxAnnotation extends Annotation {
    limits: {
        x: {
            min: number;
            max: number;
        };
        y: {
            min: number;
            max: number;
        };
    };
    xAxisID?: string;
    yAxisID?: string;
    border?: {
        width?: number;
        radius?: number;
        color?: string;
    };
}
interface PointAnnotation extends Annotation {
    x: number;
    y: number;
    xAxisID?: string;
    yAxisID?: string;
    radius?: number;
    border?: {
        width?: number;
        color?: string;
    };
}
interface EllipseAnnotation extends Annotation {
    xMax: number;
    xMin: number;
    yMax: number;
    yMin: number;
    xAxisID?: string;
    yAxisID?: string;
    rotation: number;
    backgroundColor?: string;
    border?: {
        width?: number;
        color?: string;
    };
}

interface Axes {
    isHorizontal?: boolean;
    mainAxis?: 'x' | 'y';
    dataAxes?: Axis;
}
interface Axis {
    [id: string]: AxisContent;
}
interface AxisContent {
    title?: {
        display: boolean;
        text: string;
    };
    type?: string;
    position?: string;
    distribution?: string;
    time?: {
        unit: string;
        minUnit: string;
    };
    stacked?: boolean;
    min?: number;
    max?: number;
    ticks?: Ticks;
    border?: {
        drawBorder?: boolean;
    };
    grid?: {
        display: boolean;
    };
    adapters?: {
        date: {
            locale: Locale;
        };
    };
}
interface Ticks {
    display?: boolean;
    min?: number;
    max?: number;
    stepSize?: number;
    autoSkip?: boolean;
    initialTick?: boolean;
    finalTick?: boolean;
    callback?: (val: any, index: any) => string | string[];
}

interface Legend {
    enabled?: boolean;
    title?: {
        enabled: boolean;
        text: string;
        color?: string;
        font?: {
            size?: number;
            style?: string;
            weight?: string;
        };
    };
    labels?: {
        enabled: boolean;
        pointStyle: LegendPointStyle | HTMLImageElement;
    };
    position?: LegendPosition;
    align?: LegendAlign;
    disabledClickEvent?: boolean;
}
declare enum LegendPointStyle {
    circle = "circle",
    cross = "cross",
    crossRot = "crossRot",
    dash = "dash",
    line = "line",
    rect = "rect",
    rectRounded = "rectRounded",
    rectRot = "rectRot",
    star = "star",
    triangle = "triangle"
}
declare enum LegendPosition {
    top = "top",
    right = "right",
    bottom = "bottom",
    left = "left",
    chartArea = "chartArea"
}
declare enum LegendAlign {
    start = "start",
    center = "center",
    end = "end"
}
declare enum LegendType {
    line = "line"
}

type Dataset = LineDataset | BarDataset | BubbleDataset | TimeDataset | ScatterDataset;
type ChartPointStyleAllowedType = ChartPointStyle | LegendPointStyle | HTMLImageElement | undefined;
interface BaseDataset {
    label?: string;
    type?: ChartType;
    backgroundColor?: string | number[][];
    pointStyle?: ChartPointStyleAllowedType;
    isGradient?: boolean;
    fill?: boolean;
    yAxisID?: string;
    datalabels?: {
        align: string;
        anchor: string;
    };
    pointRadius?: number;
}
interface LineDataset extends BaseDataset {
    data: number[];
    border?: LineDatasetBorderStyle | LineDatasetBorderStyle[];
}
interface LineDatasetBorderStyle {
    color?: string | number[];
    width?: number;
    dash?: number[];
}
interface BarDataset extends BaseDataset {
    data: number[];
    border?: BarDatasetBorderStyle | BarDatasetBorderStyle[];
}
interface BarDatasetBorderStyle {
    width?: number;
    color?: string | number[];
    radius?: number;
}
interface BubbleDataset extends BaseDataset {
    data: BubblePoint[];
    border?: BubbleDatasetBorderStyle | BubbleDatasetBorderStyle[];
}
interface BubblePoint {
    x: number;
    y: number;
    r: number;
}
interface BubbleDatasetBorderStyle {
    width?: number;
    color?: string | number[];
}
interface TimeDataset extends BaseDataset {
    data: TimePoint[];
    border?: TimeDatasetBorderStyle | TimeDatasetBorderStyle[];
}
interface TimePoint {
    x: string | Date;
    y: number;
}
interface TimeDatasetBorderStyle {
    width?: number;
    color?: string | number[];
}
interface ScatterDataset extends BaseDataset {
    data: ScatterPoint[];
    showLine: boolean;
    border?: ScatterDatasetBorderStyle | ScatterDatasetBorderStyle[];
}
interface ScatterPoint {
    x: number;
    y: number;
}
interface ScatterDatasetBorderStyle {
    color?: string | number[];
    width?: number;
    dash?: number[];
}

interface Tooltip {
    enabled: boolean;
    position?: string;
    backgroundColor?: string;
    title?: {
        enabled?: boolean;
        text?: string;
        prefix?: string;
        fontSize?: string;
        fontColor?: string;
    };
}

interface ClickPoint {
    x: number;
    y: number;
}

interface Zoom {
    zoom?: {
        wheel: {
            enabled: boolean;
        };
        pinch: {
            enabled: boolean;
        };
        mode: 'x' | 'y' | 'xy';
        scaleMode?: 'x' | 'y' | 'xy';
        overScaleMode?: 'x' | 'y' | 'xy';
    };
    pan?: {
        enabled: boolean;
        mode: 'x' | 'y' | 'xy';
        scaleMode?: 'x' | 'y' | 'xy';
        overScaleMode?: 'x' | 'y' | 'xy';
    };
    limits?: {
        x: {
            min: number;
            max: number;
        };
        y: {
            min: number;
            max: number;
        };
    };
}

interface ChartConfiguration {
    type: ChartType;
    labels?: {
        data: (string | Date)[];
        skipItems?: number;
        showOnlyIntegers?: boolean;
    };
    datasets: Dataset[];
    annotations?: AnnotationTypes[];
    tooltip?: Tooltip;
    customTooltip?: CustomTooltipFn;
    legend?: Legend;
    grid?: {
        enabled: boolean;
        limits: {
            x: {
                max: number;
                min: number;
            };
            y: {
                max: number;
                min: number;
            };
        };
    };
    axes?: Axes;
    options?: {
        responsive?: boolean;
        line?: {
            tension: number;
        };
        maintainAspectRatio?: boolean;
        animations?: {
            duration: number;
        };
        interaction?: {
            intersect: boolean;
            mode: InteractionMode;
        };
        datalabels?: {
            display: boolean | DatalabelsDisplayFunction;
            formatter: DatalabelsFormatterFunction;
            font?: {
                color: string;
                weight: string;
            };
        };
        onClick?: OnClickCallbackFunction;
        zoom?: Zoom;
    };
}
type ChartJSContext = Context;
type DatalabelsFormatterFunction = (value: any, context: ChartJSContext) => number | string;
type DatalabelsDisplayFunction = (context: ChartJSContext) => boolean;
type OnClickCallbackFunction = (data: ClickPoint) => void;
type CustomTooltipFn = (context: ChartJSContext) => void;
declare enum ChartType {
    line = "line",
    bar = "bar",
    pie = "pie",
    radar = "radar",
    doughnut = "doughnut",
    polarArea = "polarArea",
    scatter = "scatter",
    bubble = "bubble"
}
declare enum ChartPointStyle {
    Circle = "circle",
    Cross = "cross",
    CrossRotated = "crossRot",
    Line = "line",
    Rectangle = "rect",
    RectangleRounded = "rectRounded",
    RectangleRotated = "rectRot",
    Star = "star",
    Triangle = "triangle"
}
declare enum InteractionMode {
    point = "point",
    nearest = "nearest",
    index = "index",
    dataset = "dataset",
    x = "x",
    y = "y"
}

declare class AxesService {
    mapConfiguration(configuration: ChartConfiguration): (LinearScale | LogarithmicScale | TimeScale | undefined);
    static ɵfac: i0.ɵɵFactoryDeclaration<AxesService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<AxesService>;
}

declare class DatasetService {
    private readonly defaultColors;
    mapDatasets(chartConfiguration: ChartConfiguration, cx: CanvasRenderingContext2D): any[];
    private mapDataset;
    private buildOutputDataset;
    private setPointStyle;
    private getPieDoughnutPolarAreaColors;
    private toRGBA;
    private fillForScatterChart;
    static ɵfac: i0.ɵɵFactoryDeclaration<DatasetService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<DatasetService>;
}

declare class AnnotationService {
    mapAnnotations(annotations: AnnotationTypes[]): any[];
    private mapBoxAnnotation;
    private mapPointAnnotation;
    private mapLineAnnotation;
    private mapEllipseAnnotation;
    private isBoxAnnotation;
    private isPointAnnotation;
    private isLineAnnotation;
    private isEllipseAnnotation;
    static ɵfac: i0.ɵɵFactoryDeclaration<AnnotationService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<AnnotationService>;
}

declare class LegendService {
    mapLegend(legend: Legend): {
        onClick: () => void;
        position: LegendPosition;
        align: LegendAlign;
        labels: {
            usePointStyle: boolean;
            pointStyle: HTMLImageElement | LegendPointStyle;
        };
        title: {
            enabled: boolean;
            text: string;
        };
        display: boolean;
    };
    static ɵfac: i0.ɵɵFactoryDeclaration<LegendService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<LegendService>;
}

declare class TooltipService {
    mapTooltip(chartConfiguration: ChartConfiguration): {
        enabled: boolean;
        usePointStyle: boolean;
        callbacks: {
            title: (tooltipItems: any) => string;
        };
        external: CustomTooltipFn;
    };
    static ɵfac: i0.ɵɵFactoryDeclaration<TooltipService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<TooltipService>;
}

type ChartJSOnClick = (event: ChartJS.ChartEvent, elements: ChartJS.ActiveElement[], chart: ChartJS.Chart) => void;
declare class ClickService {
    map(userOnClick: OnClickCallbackFunction): ChartJSOnClick;
    private toClickPoint;
    static ɵfac: i0.ɵɵFactoryDeclaration<ClickService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<ClickService>;
}

declare class ZoomService {
    mapZoom(chartConfiguration: ChartConfiguration): Zoom;
    static ɵfac: i0.ɵɵFactoryDeclaration<ZoomService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<ZoomService>;
}

declare class ChartService {
    private readonly axesService;
    private readonly datasetService;
    private readonly annotationService;
    private readonly legendService;
    private readonly tooltipService;
    private readonly clickService;
    private readonly zoomService;
    private _cx;
    constructor(axesService: AxesService, datasetService: DatasetService, annotationService: AnnotationService, legendService: LegendService, tooltipService: TooltipService, clickService: ClickService, zoomService: ZoomService);
    mapConfiguration(configuration: ChartConfiguration, cx: CanvasRenderingContext2D): ChartJS.ChartConfiguration;
    private mapBasicInformation;
    static ɵfac: i0.ɵɵFactoryDeclaration<ChartService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<ChartService>;
}

declare class ChartComponent implements AfterContentInit {
    private readonly chartService;
    config: ChartConfiguration;
    chartCanvas: ElementRef;
    chart: ChartJS.Chart;
    drawing: boolean;
    constructor(chartService: ChartService);
    ngAfterContentInit(): void;
    refresh(): void;
    private drawChart;
    static ɵfac: i0.ɵɵFactoryDeclaration<ChartComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<ChartComponent, "systelab-chart", never, { "config": { "alias": "config"; "required": false; }; }, {}, never, never, false, never>;
}

declare class SystelabChartsModule {
    static forRoot(entryComponents?: Array<Type<any> | any[]>): ModuleWithProviders<SystelabChartsModule>;
    static ɵfac: i0.ɵɵFactoryDeclaration<SystelabChartsModule, never>;
    static ɵmod: i0.ɵɵNgModuleDeclaration<SystelabChartsModule, [typeof ChartLegacyComponent, typeof ChartComponent], [typeof i3.CommonModule, typeof i4.FormsModule], [typeof ChartLegacyComponent, typeof ChartComponent]>;
    static ɵinj: i0.ɵɵInjectorDeclaration<SystelabChartsModule>;
}

export { Annotation$1 as Annotation, AnnotationDrawTime, AnnotationLabelLabelPosition, AnnotationType, ChartBoxAnnotation, ChartComponent, ChartIntersectionSettings, ChartItem, ChartLabelAnnotation, ChartLabelColor, ChartLabelFont, ChartLabelPadding, ChartLabelPosition, ChartLabelSettings, ChartLabelText, ChartLegacyComponent, ChartLine, ChartLineAnnotation, ChartMultipleYAxisScales, ChartPointStyle, ChartTooltipItem, ChartTooltipSettings, ChartType, InteractionMode, LegendAlign, LegendPointStyle, LegendPosition, LegendType, LineAnnotationOrientation, SystelabChartsModule, TooltipLegacyService };
export type { AnnotationLabel, AnnotationTypes, Axes, Axis, AxisContent, BarDataset, BarDatasetBorderStyle, BaseDataset, BoxAnnotation, BubbleDataset, BubbleDatasetBorderStyle, BubblePoint, ChartConfiguration, ChartJSContext, ChartPointStyleAllowedType, ClickPoint, CustomTooltipFn, DatalabelsDisplayFunction, DatalabelsFormatterFunction, Dataset, EllipseAnnotation, Legend, LineAnnotation, LineAnnotationDefaultConfiguration, LineDataset, LineDatasetBorderStyle, OnClickCallbackFunction, PointAnnotation, ScatterDataset, ScatterDatasetBorderStyle, ScatterPoint, Ticks, TimeDataset, TimeDatasetBorderStyle, TimePoint, Tooltip };