import * as i0 from '@angular/core';
import { OnChanges, EventEmitter, ElementRef, NgZone, AfterViewInit, OnDestroy, OnInit, ChangeDetectorRef, SimpleChanges, TemplateRef, Renderer2, ViewContainerRef, ApplicationRef, Injector, ComponentRef, Type, TrackByFunction } from '@angular/core';
import * as i18 from '@angular/common';
import { CurveFactory, DefaultArcObject } from 'd3-shape';
import { ScaleBand, ScaleLinear, ScaleTime, ScalePoint } from 'd3-scale';
import { BaseType } from 'd3-selection';

interface IPoint {
    x: number;
    y: number;
}
interface IVector2D {
    v1: IPoint;
    v2: IPoint;
}

type StringOrNumberOrDate = string | number | Date;
interface DataItem {
    name: StringOrNumberOrDate;
    value: number;
    extra?: any;
    min?: number;
    max?: number;
    label?: string;
}
interface SingleSeries extends Array<DataItem> {
}
interface Series {
    name: StringOrNumberOrDate;
    series: DataItem[];
}
interface MultiSeries extends Array<Series> {
}
interface AreaChartDataItem extends DataItem {
    d0: number;
    d1: number;
}
interface AreaChartSeries {
    name: StringOrNumberOrDate;
    series: AreaChartDataItem[];
}
interface PieGridData {
    data: PieGridDataItem;
    height: number;
    width: number;
    x: number;
    y: number;
}
interface PieGridDataItem extends DataItem {
    percent: number;
    total: number;
    value: number;
}
interface BubbleChartDataItem {
    name: StringOrNumberOrDate;
    x: StringOrNumberOrDate;
    y: StringOrNumberOrDate;
    r: number;
    extra?: any;
}
interface BubbleChartSeries {
    name: StringOrNumberOrDate;
    series: BubbleChartDataItem[];
}
interface BubbleChartMultiSeries extends Array<BubbleChartSeries> {
}
interface TreeMapDataItem {
    name: StringOrNumberOrDate;
    size?: number;
    children?: TreeMapDataItem[];
    extra?: any;
}
interface TreeMapData extends Array<TreeMapDataItem> {
}
interface SankeyObject {
    source: string;
    target: string;
    value: number;
}
interface SankeyData extends Array<SankeyObject> {
}
interface BoxChartSeries {
    name: StringOrNumberOrDate;
    series: DataItem[];
}
interface BoxChartMultiSeries extends Array<BoxChartSeries> {
}
interface IBoxModel {
    value: number | Date;
    label: StringOrNumberOrDate;
    data: DataItem[];
    formattedLabel: string;
    height: number;
    width: number;
    x: number;
    y: number;
    roundEdges: boolean;
    lineCoordinates: IVector2D[];
    quartiles: number[];
    tooltipText?: string;
    ariaLabel?: string;
    color?: string;
    gradientStops?: Array<{
        offset: number;
        color: string;
        opacity: number;
    }>;
}

declare enum BarOrientation {
    Vertical = "vertical",
    Horizontal = "horizontal"
}

interface Gradient {
    offset: number;
    originalOffset?: number;
    color: string;
    opacity: number;
}

declare class AreaComponent implements OnChanges {
    data: AreaChartSeries;
    path: string;
    startingPath: string;
    fill: string;
    opacity: number;
    startOpacity: number;
    endOpacity: number;
    gradient: boolean;
    stops: Gradient[];
    animations: boolean;
    select: EventEmitter<any>;
    element: HTMLElement;
    gradientId: string;
    gradientFill: string;
    areaPath: string;
    animationsLoaded: boolean;
    gradientStops: Gradient[];
    hasGradient: boolean;
    barOrientation: typeof BarOrientation;
    constructor(element: ElementRef);
    ngOnChanges(): void;
    update(): void;
    loadAnimation(): void;
    updatePathEl(): void;
    getGradient(): Gradient[];
    static ɵfac: i0.ɵɵFactoryDeclaration<AreaComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<AreaComponent, "g[ngx-charts-area]", never, { "data": { "alias": "data"; "required": false; }; "path": { "alias": "path"; "required": false; }; "startingPath": { "alias": "startingPath"; "required": false; }; "fill": { "alias": "fill"; "required": false; }; "opacity": { "alias": "opacity"; "required": false; }; "startOpacity": { "alias": "startOpacity"; "required": false; }; "endOpacity": { "alias": "endOpacity"; "required": false; }; "gradient": { "alias": "gradient"; "required": false; }; "stops": { "alias": "stops"; "required": false; }; "animations": { "alias": "animations"; "required": false; }; }, { "select": "select"; }, never, never, false, never>;
}

/**
 * Visibility Observer
 */
declare class VisibilityObserver {
    private element;
    private zone;
    visible: EventEmitter<any>;
    timeout: any;
    isVisible: boolean;
    constructor(element: ElementRef, zone: NgZone);
    destroy(): void;
    onVisibilityChange(): void;
    runCheck(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<VisibilityObserver, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<VisibilityObserver, "visibility-observer", never, {}, { "visible": "visible"; }, never, never, false, never>;
}

declare enum ScaleType {
    Time = "time",
    Linear = "linear",
    Ordinal = "ordinal",
    Quantile = "quantile"
}

interface Color {
    name: string;
    selectable: boolean;
    group: ScaleType;
    domain: string[];
}
declare const colorSets: Color[];

interface ViewDimensions {
    width: number;
    height: number;
    xOffset?: number;
    yOffset?: number;
}

declare class BaseChartComponent implements OnChanges, AfterViewInit, OnDestroy, OnInit {
    protected chartElement: ElementRef;
    protected zone: NgZone;
    protected cd: ChangeDetectorRef;
    platformId: any;
    results: any;
    view: [number, number];
    scheme: string | Color;
    schemeType: ScaleType;
    customColors: any;
    animations: boolean;
    select: EventEmitter<any>;
    width: number;
    height: number;
    resizeSubscription: any;
    visibilityObserver: VisibilityObserver;
    constructor(chartElement: ElementRef, zone: NgZone, cd: ChangeDetectorRef, platformId: any);
    ngOnInit(): void;
    ngAfterViewInit(): void;
    ngOnDestroy(): void;
    ngOnChanges(changes: SimpleChanges): void;
    update(): void;
    getContainerDims(): ViewDimensions;
    /**
     * Converts all date objects that appear as name
     * into formatted date strings
     */
    formatDates(): void;
    protected unbindEvents(): void;
    private bindWindowResizeEvent;
    /**
     * Clones the data into a new object
     *
     * @memberOf BaseChart
     */
    private cloneData;
    static ɵfac: i0.ɵɵFactoryDeclaration<BaseChartComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<BaseChartComponent, "base-chart", never, { "results": { "alias": "results"; "required": false; }; "view": { "alias": "view"; "required": false; }; "scheme": { "alias": "scheme"; "required": false; }; "schemeType": { "alias": "schemeType"; "required": false; }; "customColors": { "alias": "customColors"; "required": false; }; "animations": { "alias": "animations"; "required": false; }; }, { "select": "select"; }, never, never, false, never>;
}

/**
 * Count up component
 *
 * Loosely inspired by:
 *  - https://github.com/izupet/angular2-counto
 *  - https://inorganik.github.io/countUp.js/
 *
 * @export
 */
declare class CountUpDirective implements OnDestroy {
    private cd;
    countDuration: number;
    countPrefix: string;
    countSuffix: string;
    valueFormatting: any;
    set countDecimals(val: number);
    get countDecimals(): number;
    set countTo(val: any);
    get countTo(): any;
    set countFrom(val: any);
    get countFrom(): any;
    countChange: EventEmitter<any>;
    countFinish: EventEmitter<any>;
    nativeElement: any;
    value: any;
    formattedValue: string;
    private animationReq;
    private _countDecimals;
    private _countTo;
    private _countFrom;
    constructor(cd: ChangeDetectorRef, element: ElementRef);
    ngOnDestroy(): void;
    start(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<CountUpDirective, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<CountUpDirective, "[ngx-charts-count-up]", never, { "countDuration": { "alias": "countDuration"; "required": false; }; "countPrefix": { "alias": "countPrefix"; "required": false; }; "countSuffix": { "alias": "countSuffix"; "required": false; }; "valueFormatting": { "alias": "valueFormatting"; "required": false; }; "countDecimals": { "alias": "countDecimals"; "required": false; }; "countTo": { "alias": "countTo"; "required": false; }; "countFrom": { "alias": "countFrom"; "required": false; }; }, { "countChange": "countChange"; "countFinish": "countFinish"; }, never, never, false, never>;
}

declare class ColorHelper {
    scale: any;
    scaleType: ScaleType;
    colorDomain: string[];
    domain: number[] | string[];
    customColors: any;
    constructor(scheme: string | Color, type: ScaleType, domain: number[] | string[], customColors?: any);
    generateColorScheme(scheme: string | Color, type: ScaleType, domain: number[] | string[]): any;
    getColor(value: StringOrNumberOrDate): string;
    getLinearGradientStops(value: number | string, start?: number | string): Gradient[];
}

declare enum PlacementTypes {
    Top = "top",
    Bottom = "bottom",
    Left = "left",
    Right = "right",
    Center = "center"
}

declare enum StyleTypes {
    popover = "popover",
    tooltip = "tooltip"
}

interface Tooltip {
    color: string;
    d0: number;
    d1: number;
    max: number;
    min: number;
    name: any;
    series: any;
    value: any;
}
declare class TooltipArea {
    private platformId;
    anchorOpacity: number;
    anchorPos: number;
    anchorValues: Tooltip[];
    lastAnchorPos: number;
    placementTypes: typeof PlacementTypes;
    styleTypes: typeof StyleTypes;
    dims: ViewDimensions;
    xSet: any[];
    xScale: any;
    yScale: any;
    results: any[];
    colors: ColorHelper;
    showPercentage: boolean;
    tooltipDisabled: boolean;
    tooltipTemplate: TemplateRef<any>;
    hover: EventEmitter<{
        value: any;
    }>;
    tooltipAnchor: any;
    constructor(platformId: any);
    getValues(xVal: any): Tooltip[];
    mouseMove(event: any): void;
    findClosestPointIndex(xPos: number): number;
    showTooltip(): void;
    hideTooltip(): void;
    getToolTipText(tooltipItem: Tooltip): string;
    static ɵfac: i0.ɵɵFactoryDeclaration<TooltipArea, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<TooltipArea, "g[ngx-charts-tooltip-area]", never, { "dims": { "alias": "dims"; "required": false; }; "xSet": { "alias": "xSet"; "required": false; }; "xScale": { "alias": "xScale"; "required": false; }; "yScale": { "alias": "yScale"; "required": false; }; "results": { "alias": "results"; "required": false; }; "colors": { "alias": "colors"; "required": false; }; "showPercentage": { "alias": "showPercentage"; "required": false; }; "tooltipDisabled": { "alias": "tooltipDisabled"; "required": false; }; "tooltipTemplate": { "alias": "tooltipTemplate"; "required": false; }; }, { "hover": "hover"; }, never, never, false, never>;
}

interface LegendOptions {
    colors: any;
    domain: any[];
    position: LegendPosition;
    title: string;
    scaleType: ScaleType;
}
declare enum LegendPosition {
    Right = "right",
    Below = "below"
}
declare enum LegendType {
    ScaleLegend = "scaleLegend",
    Legend = "legend"
}

declare class ChartComponent implements OnChanges {
    view: [number, number];
    showLegend: boolean;
    legendOptions: LegendOptions;
    legendType: LegendType;
    activeEntries: any[];
    animations: boolean;
    legendLabelClick: EventEmitter<string>;
    legendLabelActivate: EventEmitter<{
        name: string;
    }>;
    legendLabelDeactivate: EventEmitter<{
        name: string;
    }>;
    chartWidth: number;
    title: string;
    legendWidth: number;
    readonly LegendPosition: typeof LegendPosition;
    readonly LegendType: typeof LegendType;
    ngOnChanges(changes: SimpleChanges): void;
    update(): void;
    getLegendType(): LegendType;
    static ɵfac: i0.ɵɵFactoryDeclaration<ChartComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<ChartComponent, "ngx-charts-chart", never, { "view": { "alias": "view"; "required": false; }; "showLegend": { "alias": "showLegend"; "required": false; }; "legendOptions": { "alias": "legendOptions"; "required": false; }; "legendType": { "alias": "legendType"; "required": false; }; "activeEntries": { "alias": "activeEntries"; "required": false; }; "animations": { "alias": "animations"; "required": false; }; }, { "legendLabelClick": "legendLabelClick"; "legendLabelActivate": "legendLabelActivate"; "legendLabelDeactivate": "legendLabelDeactivate"; }, never, ["*"], false, never>;
}

interface LegendEntry {
    color: string;
    formattedLabel: string;
    label: string;
}
declare class LegendComponent implements OnChanges {
    private cd;
    data: string[];
    title: string;
    colors: ColorHelper;
    height: number;
    width: number;
    activeEntries: any;
    horizontal: boolean;
    labelClick: EventEmitter<string>;
    labelActivate: EventEmitter<{
        name: string;
    }>;
    labelDeactivate: EventEmitter<{
        name: string;
    }>;
    legendEntries: LegendEntry[];
    constructor(cd: ChangeDetectorRef);
    ngOnChanges(changes: SimpleChanges): void;
    update(): void;
    getLegendEntries(): LegendEntry[];
    isActive(entry: LegendEntry): boolean;
    activate(item: {
        name: string;
    }): void;
    deactivate(item: {
        name: string;
    }): void;
    trackBy(index: number, item: LegendEntry): string;
    static ɵfac: i0.ɵɵFactoryDeclaration<LegendComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<LegendComponent, "ngx-charts-legend", never, { "data": { "alias": "data"; "required": false; }; "title": { "alias": "title"; "required": false; }; "colors": { "alias": "colors"; "required": false; }; "height": { "alias": "height"; "required": false; }; "width": { "alias": "width"; "required": false; }; "activeEntries": { "alias": "activeEntries"; "required": false; }; "horizontal": { "alias": "horizontal"; "required": false; }; }, { "labelClick": "labelClick"; "labelActivate": "labelActivate"; "labelDeactivate": "labelDeactivate"; }, never, never, false, never>;
}

declare class LegendEntryComponent {
    color: string;
    label: string;
    formattedLabel: string;
    isActive: boolean;
    select: EventEmitter<string>;
    activate: EventEmitter<{
        name: string;
    }>;
    deactivate: EventEmitter<{
        name: string;
    }>;
    toggle: EventEmitter<string>;
    get trimmedLabel(): string;
    onMouseEnter(): void;
    onMouseLeave(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<LegendEntryComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<LegendEntryComponent, "ngx-charts-legend-entry", never, { "color": { "alias": "color"; "required": false; }; "label": { "alias": "label"; "required": false; }; "formattedLabel": { "alias": "formattedLabel"; "required": false; }; "isActive": { "alias": "isActive"; "required": false; }; }, { "select": "select"; "activate": "activate"; "deactivate": "deactivate"; "toggle": "toggle"; }, never, never, false, never>;
}

declare class ScaleLegendComponent implements OnChanges {
    valueRange: number[];
    colors: any;
    height: number;
    width: number;
    horizontal: boolean;
    gradient: string;
    ngOnChanges(changes: SimpleChanges): void;
    /**
     * Generates the string used in the gradient stylesheet properties
     * @param colors array of colors
     * @param splits array of splits on a scale of (0, 1)
     */
    gradientString(colors: string[], splits: number[]): string;
    static ɵfac: i0.ɵɵFactoryDeclaration<ScaleLegendComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<ScaleLegendComponent, "ngx-charts-scale-legend", never, { "valueRange": { "alias": "valueRange"; "required": false; }; "colors": { "alias": "colors"; "required": false; }; "height": { "alias": "height"; "required": false; }; "width": { "alias": "width"; "required": false; }; "horizontal": { "alias": "horizontal"; "required": false; }; }, {}, never, never, false, never>;
}

declare class CircleComponent implements OnChanges {
    cx: number;
    cy: number;
    r: number;
    fill: string;
    stroke: string;
    data: number | string;
    classNames: string[] | string;
    circleOpacity: number;
    pointerEvents: string;
    select: EventEmitter<number | string>;
    activate: EventEmitter<number | string>;
    deactivate: EventEmitter<number | string>;
    onClick(): void;
    onMouseEnter(): void;
    onMouseLeave(): void;
    ngOnChanges(changes: SimpleChanges): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<CircleComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<CircleComponent, "g[ngx-charts-circle]", never, { "cx": { "alias": "cx"; "required": false; }; "cy": { "alias": "cy"; "required": false; }; "r": { "alias": "r"; "required": false; }; "fill": { "alias": "fill"; "required": false; }; "stroke": { "alias": "stroke"; "required": false; }; "data": { "alias": "data"; "required": false; }; "classNames": { "alias": "classNames"; "required": false; }; "circleOpacity": { "alias": "circleOpacity"; "required": false; }; "pointerEvents": { "alias": "pointerEvents"; "required": false; }; }, { "select": "select"; "activate": "activate"; "deactivate": "deactivate"; }, never, never, false, never>;
}

declare enum SeriesType {
    Standard = "standard",
    Stacked = "stacked"
}
interface Circle {
    classNames: string[];
    value: string | number;
    label: string;
    data: DataItem;
    cx: number;
    cy: number;
    radius: number;
    height: number;
    tooltipLabel: string;
    color: string;
    opacity: number;
    seriesName: string;
    gradientStops: Gradient[];
    min: number;
    max: number;
}
declare class CircleSeriesComponent implements OnChanges, OnInit {
    private platformId;
    data: Series;
    type: SeriesType;
    xScale: any;
    yScale: any;
    colors: ColorHelper;
    scaleType: ScaleType;
    visibleValue: boolean;
    activeEntries: any[];
    tooltipDisabled: boolean;
    tooltipTemplate: TemplateRef<any>;
    select: EventEmitter<DataItem>;
    activate: EventEmitter<{
        name: StringOrNumberOrDate;
    }>;
    deactivate: EventEmitter<{
        name: StringOrNumberOrDate;
    }>;
    areaPath: any;
    circle: Circle;
    barVisible: boolean;
    gradientId: string;
    gradientFill: string;
    barOrientation: typeof BarOrientation;
    placementTypes: typeof PlacementTypes;
    styleTypes: typeof StyleTypes;
    isSSR: boolean;
    constructor(platformId: any);
    ngOnInit(): void;
    ngOnChanges(): void;
    update(): void;
    getActiveCircle(): Circle;
    mapDataPointToCircle(d: any, i: number): Circle;
    getTooltipText({ tooltipLabel, value, seriesName, min, max }: {
        tooltipLabel: string;
        value: any;
        seriesName: string;
        min: number;
        max: number;
    }): string;
    getTooltipMinMaxText(min: number, max: number): string;
    getGradientStops(color: string): Gradient[];
    onClick(data: DataItem): void;
    isActive(entry: any): boolean;
    activateCircle(): void;
    deactivateCircle(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<CircleSeriesComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<CircleSeriesComponent, "g[ngx-charts-circle-series]", never, { "data": { "alias": "data"; "required": false; }; "type": { "alias": "type"; "required": false; }; "xScale": { "alias": "xScale"; "required": false; }; "yScale": { "alias": "yScale"; "required": false; }; "colors": { "alias": "colors"; "required": false; }; "scaleType": { "alias": "scaleType"; "required": false; }; "visibleValue": { "alias": "visibleValue"; "required": false; }; "activeEntries": { "alias": "activeEntries"; "required": false; }; "tooltipDisabled": { "alias": "tooltipDisabled"; "required": false; }; "tooltipTemplate": { "alias": "tooltipTemplate"; "required": false; }; }, { "select": "select"; "activate": "activate"; "deactivate": "deactivate"; }, never, never, false, never>;
}

declare class GridPanelComponent {
    width: number;
    height: number;
    x: number;
    y: number;
    static ɵfac: i0.ɵɵFactoryDeclaration<GridPanelComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<GridPanelComponent, "g[ngx-charts-grid-panel]", never, { "width": { "alias": "width"; "required": false; }; "height": { "alias": "height"; "required": false; }; "x": { "alias": "x"; "required": false; }; "y": { "alias": "y"; "required": false; }; }, {}, never, never, false, never>;
}

interface GridPanel {
    class: ClassEnum;
    height: number;
    name: string;
    width: number;
    x: number;
    y: number;
}
declare enum ClassEnum {
    Odd = "odd",
    Even = "even"
}
declare class GridPanelSeriesComponent implements OnChanges {
    gridPanels: GridPanel[];
    data: any[];
    dims: ViewDimensions;
    xScale: any;
    yScale: any;
    orient: BarOrientation;
    ngOnChanges(changes: SimpleChanges): void;
    update(): void;
    getGridPanels(): GridPanel[];
    static ɵfac: i0.ɵɵFactoryDeclaration<GridPanelSeriesComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<GridPanelSeriesComponent, "g[ngx-charts-grid-panel-series]", never, { "data": { "alias": "data"; "required": false; }; "dims": { "alias": "dims"; "required": false; }; "xScale": { "alias": "xScale"; "required": false; }; "yScale": { "alias": "yScale"; "required": false; }; "orient": { "alias": "orient"; "required": false; }; }, {}, never, never, false, never>;
}

declare class SvgLinearGradientComponent implements OnChanges {
    orientation: BarOrientation;
    name: string;
    stops: Gradient[];
    x1: string;
    x2: string;
    y1: string;
    y2: string;
    ngOnChanges(changes: SimpleChanges): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<SvgLinearGradientComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<SvgLinearGradientComponent, "g[ngx-charts-svg-linear-gradient]", never, { "orientation": { "alias": "orientation"; "required": false; }; "name": { "alias": "name"; "required": false; }; "stops": { "alias": "stops"; "required": false; }; }, {}, never, never, false, never>;
}

declare class SvgRadialGradientComponent implements OnChanges {
    color: string;
    name: string;
    startOpacity: number;
    endOpacity: number;
    cx: number;
    cy: number;
    get stops(): Gradient[];
    set stops(value: Gradient[]);
    r: string;
    private stopsInput;
    private stopsDefault;
    ngOnChanges(changes: SimpleChanges): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<SvgRadialGradientComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<SvgRadialGradientComponent, "g[ngx-charts-svg-radial-gradient]", never, { "color": { "alias": "color"; "required": false; }; "name": { "alias": "name"; "required": false; }; "startOpacity": { "alias": "startOpacity"; "required": false; }; "endOpacity": { "alias": "endOpacity"; "required": false; }; "cx": { "alias": "cx"; "required": false; }; "cy": { "alias": "cy"; "required": false; }; "stops": { "alias": "stops"; "required": false; }; }, {}, never, never, false, never>;
}

declare class Timeline implements OnChanges {
    private cd;
    view: [number, number];
    results: any;
    scheme: any;
    customColors: any;
    legend: boolean;
    autoScale: boolean;
    scaleType: ScaleType;
    height: number;
    select: EventEmitter<any>;
    onDomainChange: EventEmitter<any>;
    element: HTMLElement;
    dims: ViewDimensions;
    xDomain: any[];
    xScale: any;
    brush: any;
    transform: string;
    initialized: boolean;
    filterId: string;
    filter: string;
    constructor(element: ElementRef, cd: ChangeDetectorRef);
    ngOnChanges(changes: SimpleChanges): void;
    update(): void;
    getXDomain(): any[];
    getXScale(): any;
    addBrush(): void;
    updateBrush(): void;
    getDims(): ViewDimensions;
    static ɵfac: i0.ɵɵFactoryDeclaration<Timeline, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<Timeline, "g[ngx-charts-timeline]", never, { "view": { "alias": "view"; "required": false; }; "results": { "alias": "results"; "required": false; }; "scheme": { "alias": "scheme"; "required": false; }; "customColors": { "alias": "customColors"; "required": false; }; "legend": { "alias": "legend"; "required": false; }; "autoScale": { "alias": "autoScale"; "required": false; }; "scaleType": { "alias": "scaleType"; "required": false; }; "height": { "alias": "height"; "required": false; }; }, { "select": "select"; "onDomainChange": "onDomainChange"; }, never, ["*"], false, never>;
}

interface AdvancedLegendItem {
    value: StringOrNumberOrDate;
    _value: StringOrNumberOrDate;
    color: string;
    data: DataItem;
    label: string;
    displayLabel: string;
    originalLabel: string;
    percentage: string;
}
declare class AdvancedLegendComponent implements OnChanges {
    width: number;
    data: DataItem[];
    colors: ColorHelper;
    label: string;
    animations: boolean;
    select: EventEmitter<DataItem>;
    activate: EventEmitter<DataItem>;
    deactivate: EventEmitter<DataItem>;
    legendItems: AdvancedLegendItem[];
    total: number;
    roundedTotal: number;
    valueFormatting: (value: StringOrNumberOrDate) => any;
    labelFormatting: (value: string) => string;
    percentageFormatting: (value: number) => number;
    defaultValueFormatting: (value: StringOrNumberOrDate) => string;
    ngOnChanges(changes: SimpleChanges): void;
    getTotal(): number;
    update(): void;
    getLegendItems(): AdvancedLegendItem[];
    trackBy(index: number, item: AdvancedLegendItem): string;
    static ɵfac: i0.ɵɵFactoryDeclaration<AdvancedLegendComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<AdvancedLegendComponent, "ngx-charts-advanced-legend", never, { "width": { "alias": "width"; "required": false; }; "data": { "alias": "data"; "required": false; }; "colors": { "alias": "colors"; "required": false; }; "label": { "alias": "label"; "required": false; }; "animations": { "alias": "animations"; "required": false; }; "valueFormatting": { "alias": "valueFormatting"; "required": false; }; "labelFormatting": { "alias": "labelFormatting"; "required": false; }; "percentageFormatting": { "alias": "percentageFormatting"; "required": false; }; }, { "select": "select"; "activate": "activate"; "deactivate": "deactivate"; }, never, never, false, never>;
}

declare enum Orientation {
    Top = "top",
    Bottom = "bottom",
    Left = "left",
    Right = "right"
}

declare class AxisLabelComponent implements OnChanges {
    orient: Orientation;
    label: string;
    offset: number;
    width: number;
    height: number;
    x: number;
    y: number;
    transform: string;
    strokeWidth: string;
    textAnchor: string;
    element: ElementRef;
    textHeight: number;
    margin: number;
    constructor(element: ElementRef);
    ngOnChanges(changes: SimpleChanges): void;
    update(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<AxisLabelComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<AxisLabelComponent, "g[ngx-charts-axis-label]", never, { "orient": { "alias": "orient"; "required": false; }; "label": { "alias": "label"; "required": false; }; "offset": { "alias": "offset"; "required": false; }; "width": { "alias": "width"; "required": false; }; "height": { "alias": "height"; "required": false; }; }, {}, never, never, false, never>;
}

declare enum TextAnchor {
    Start = "start",
    Middle = "middle",
    End = "end"
}

declare class XAxisTicksComponent implements OnChanges, AfterViewInit {
    private platformId;
    scale: any;
    orient: Orientation;
    tickArguments: number[];
    tickValues: string[] | number[];
    tickStroke: string;
    trimTicks: boolean;
    maxTickLength: number;
    tickFormatting: any;
    showGridLines: boolean;
    gridLineHeight: number;
    width: number;
    rotateTicks: boolean;
    wrapTicks: boolean;
    dimensionsChanged: EventEmitter<any>;
    verticalSpacing: number;
    rotateLabels: boolean;
    innerTickSize: number;
    outerTickSize: number;
    tickPadding: number;
    textAnchor: TextAnchor;
    maxTicksLength: number;
    maxAllowedLength: number;
    adjustedScale: any;
    textTransform: string;
    ticks: any[];
    tickFormat: (o: any) => any;
    height: number;
    approxHeight: number;
    maxPossibleLengthForTickIfWrapped: number;
    ticksElement: ElementRef;
    get isWrapTicksSupported(): any;
    constructor(platformId: any);
    ngOnChanges(changes: SimpleChanges): void;
    ngAfterViewInit(): void;
    updateDims(): void;
    update(): void;
    getRotationAngle(ticks: any[]): number;
    getTicks(): any[];
    getMaxTicks(tickWidth: number): number;
    tickTransform(tick: number): string;
    gridLineTransform(): string;
    tickTrim(label: string): string;
    getMaxPossibleLengthForTick(longestLabel: string): number;
    tickChunks(label: string): string[];
    static ɵfac: i0.ɵɵFactoryDeclaration<XAxisTicksComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<XAxisTicksComponent, "g[ngx-charts-x-axis-ticks]", never, { "scale": { "alias": "scale"; "required": false; }; "orient": { "alias": "orient"; "required": false; }; "tickArguments": { "alias": "tickArguments"; "required": false; }; "tickValues": { "alias": "tickValues"; "required": false; }; "tickStroke": { "alias": "tickStroke"; "required": false; }; "trimTicks": { "alias": "trimTicks"; "required": false; }; "maxTickLength": { "alias": "maxTickLength"; "required": false; }; "tickFormatting": { "alias": "tickFormatting"; "required": false; }; "showGridLines": { "alias": "showGridLines"; "required": false; }; "gridLineHeight": { "alias": "gridLineHeight"; "required": false; }; "width": { "alias": "width"; "required": false; }; "rotateTicks": { "alias": "rotateTicks"; "required": false; }; "wrapTicks": { "alias": "wrapTicks"; "required": false; }; }, { "dimensionsChanged": "dimensionsChanged"; }, never, never, false, never>;
}

declare class XAxisComponent implements OnChanges {
    xScale: any;
    dims: ViewDimensions;
    trimTicks: boolean;
    rotateTicks: boolean;
    maxTickLength: number;
    tickFormatting: any;
    showGridLines: boolean;
    showLabel: boolean;
    labelText: string;
    ticks: any[];
    xAxisTickCount: number;
    xOrient: Orientation;
    xAxisOffset: number;
    wrapTicks: boolean;
    dimensionsChanged: EventEmitter<any>;
    xAxisClassName: string;
    tickArguments: number[];
    transform: string;
    labelOffset: number;
    fill: string;
    stroke: string;
    tickStroke: string;
    strokeWidth: string;
    padding: number;
    readonly orientation: typeof Orientation;
    ticksComponent: XAxisTicksComponent;
    ngOnChanges(changes: SimpleChanges): void;
    update(): void;
    emitTicksHeight({ height }: {
        height: any;
    }): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<XAxisComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<XAxisComponent, "g[ngx-charts-x-axis]", never, { "xScale": { "alias": "xScale"; "required": false; }; "dims": { "alias": "dims"; "required": false; }; "trimTicks": { "alias": "trimTicks"; "required": false; }; "rotateTicks": { "alias": "rotateTicks"; "required": false; }; "maxTickLength": { "alias": "maxTickLength"; "required": false; }; "tickFormatting": { "alias": "tickFormatting"; "required": false; }; "showGridLines": { "alias": "showGridLines"; "required": false; }; "showLabel": { "alias": "showLabel"; "required": false; }; "labelText": { "alias": "labelText"; "required": false; }; "ticks": { "alias": "ticks"; "required": false; }; "xAxisTickCount": { "alias": "xAxisTickCount"; "required": false; }; "xOrient": { "alias": "xOrient"; "required": false; }; "xAxisOffset": { "alias": "xAxisOffset"; "required": false; }; "wrapTicks": { "alias": "wrapTicks"; "required": false; }; }, { "dimensionsChanged": "dimensionsChanged"; }, never, never, false, never>;
}

declare class YAxisTicksComponent implements OnChanges, AfterViewInit {
    private platformId;
    scale: any;
    orient: Orientation;
    tickArguments: number[];
    tickValues: string[] | number[];
    tickStroke: string;
    trimTicks: boolean;
    maxTickLength: number;
    tickFormatting: any;
    showGridLines: boolean;
    gridLineWidth: number;
    height: number;
    referenceLines: any;
    showRefLabels: boolean;
    showRefLines: boolean;
    wrapTicks: boolean;
    dimensionsChanged: EventEmitter<any>;
    innerTickSize: number;
    tickPadding: number;
    tickSpacing: number;
    verticalSpacing: number;
    textAnchor: TextAnchor;
    dy: string;
    x1: number;
    x2: number;
    y1: number;
    y2: number;
    adjustedScale: any;
    transform: (o: any) => string;
    tickFormat: (o: any) => string;
    ticks: any[];
    width: number;
    outerTickSize: number;
    rotateLabels: boolean;
    refMax: number;
    refMin: number;
    referenceLineLength: number;
    referenceAreaPath: string;
    readonly Orientation: typeof Orientation;
    ticksElement: ElementRef;
    constructor(platformId: any);
    ngOnChanges(changes: SimpleChanges): void;
    ngAfterViewInit(): void;
    updateDims(): void;
    update(): void;
    setReferencelines(): void;
    getTicks(): any[];
    getMaxTicks(tickHeight: number): number;
    tickTransform(tick: number): string;
    gridLineTransform(): string;
    tickTrim(label: string): string;
    getApproximateAxisWidth(): number;
    tickChunks(label: string): string[];
    static ɵfac: i0.ɵɵFactoryDeclaration<YAxisTicksComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<YAxisTicksComponent, "g[ngx-charts-y-axis-ticks]", never, { "scale": { "alias": "scale"; "required": false; }; "orient": { "alias": "orient"; "required": false; }; "tickArguments": { "alias": "tickArguments"; "required": false; }; "tickValues": { "alias": "tickValues"; "required": false; }; "tickStroke": { "alias": "tickStroke"; "required": false; }; "trimTicks": { "alias": "trimTicks"; "required": false; }; "maxTickLength": { "alias": "maxTickLength"; "required": false; }; "tickFormatting": { "alias": "tickFormatting"; "required": false; }; "showGridLines": { "alias": "showGridLines"; "required": false; }; "gridLineWidth": { "alias": "gridLineWidth"; "required": false; }; "height": { "alias": "height"; "required": false; }; "referenceLines": { "alias": "referenceLines"; "required": false; }; "showRefLabels": { "alias": "showRefLabels"; "required": false; }; "showRefLines": { "alias": "showRefLines"; "required": false; }; "wrapTicks": { "alias": "wrapTicks"; "required": false; }; }, { "dimensionsChanged": "dimensionsChanged"; }, never, never, false, never>;
}

declare class YAxisComponent implements OnChanges {
    yScale: any;
    dims: ViewDimensions;
    trimTicks: boolean;
    maxTickLength: number;
    tickFormatting: any;
    ticks: any[];
    showGridLines: boolean;
    showLabel: boolean;
    labelText: string;
    yAxisTickCount: any;
    yOrient: Orientation;
    referenceLines: any;
    showRefLines: boolean;
    showRefLabels: boolean;
    yAxisOffset: number;
    wrapTicks: boolean;
    dimensionsChanged: EventEmitter<any>;
    yAxisClassName: string;
    tickArguments: number[];
    offset: number;
    transform: string;
    labelOffset: number;
    fill: string;
    stroke: string;
    tickStroke: string;
    strokeWidth: number;
    padding: number;
    ticksComponent: YAxisTicksComponent;
    ngOnChanges(changes: SimpleChanges): void;
    update(): void;
    emitTicksWidth({ width }: {
        width: any;
    }): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<YAxisComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<YAxisComponent, "g[ngx-charts-y-axis]", never, { "yScale": { "alias": "yScale"; "required": false; }; "dims": { "alias": "dims"; "required": false; }; "trimTicks": { "alias": "trimTicks"; "required": false; }; "maxTickLength": { "alias": "maxTickLength"; "required": false; }; "tickFormatting": { "alias": "tickFormatting"; "required": false; }; "ticks": { "alias": "ticks"; "required": false; }; "showGridLines": { "alias": "showGridLines"; "required": false; }; "showLabel": { "alias": "showLabel"; "required": false; }; "labelText": { "alias": "labelText"; "required": false; }; "yAxisTickCount": { "alias": "yAxisTickCount"; "required": false; }; "yOrient": { "alias": "yOrient"; "required": false; }; "referenceLines": { "alias": "referenceLines"; "required": false; }; "showRefLines": { "alias": "showRefLines"; "required": false; }; "showRefLabels": { "alias": "showRefLabels"; "required": false; }; "yAxisOffset": { "alias": "yAxisOffset"; "required": false; }; "wrapTicks": { "alias": "wrapTicks"; "required": false; }; }, { "dimensionsChanged": "dimensionsChanged"; }, never, never, false, never>;
}

declare class AxesModule {
    static ɵfac: i0.ɵɵFactoryDeclaration<AxesModule, never>;
    static ɵmod: i0.ɵɵNgModuleDeclaration<AxesModule, [typeof AxisLabelComponent, typeof XAxisComponent, typeof XAxisTicksComponent, typeof YAxisComponent, typeof YAxisTicksComponent], [typeof i18.CommonModule], [typeof AxisLabelComponent, typeof XAxisComponent, typeof XAxisTicksComponent, typeof YAxisComponent, typeof YAxisTicksComponent]>;
    static ɵinj: i0.ɵɵInjectorDeclaration<AxesModule>;
}

declare class TooltipContentComponent implements AfterViewInit {
    element: ElementRef;
    private renderer;
    private platformId;
    host: ElementRef;
    showCaret: boolean;
    type: StyleTypes;
    placement: PlacementTypes;
    alignment: PlacementTypes;
    spacing: number;
    cssClass: string;
    title: string;
    template: TemplateRef<any>;
    context: any;
    caretElm: ElementRef;
    get cssClasses(): string;
    constructor(element: ElementRef, renderer: Renderer2, platformId: any);
    ngAfterViewInit(): void;
    position(): void;
    positionContent(nativeElm: HTMLElement, hostDim: DOMRect, elmDim: DOMRect): void;
    positionCaret(hostDim: DOMRect, elmDim: DOMRect): void;
    checkFlip(hostDim: DOMRect, elmDim: DOMRect): void;
    onWindowResize(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<TooltipContentComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<TooltipContentComponent, "ngx-tooltip-content", never, { "host": { "alias": "host"; "required": false; }; "showCaret": { "alias": "showCaret"; "required": false; }; "type": { "alias": "type"; "required": false; }; "placement": { "alias": "placement"; "required": false; }; "alignment": { "alias": "alignment"; "required": false; }; "spacing": { "alias": "spacing"; "required": false; }; "cssClass": { "alias": "cssClass"; "required": false; }; "title": { "alias": "title"; "required": false; }; "template": { "alias": "template"; "required": false; }; "context": { "alias": "context"; "required": false; }; }, {}, never, never, false, never>;
}

declare enum ShowTypes {
    all,
    focus,
    mouseover
}

/**
 * Injection service is a helper to append components
 * dynamically to a known location in the DOM, most
 * noteably for dialogs/tooltips appending to body.
 *
 * @export
 */
declare class InjectionService {
    private applicationRef;
    private injector;
    static globalRootViewContainer: ViewContainerRef;
    /**
     * Sets a default global root view container. This is useful for
     * things like ngUpgrade that doesn't have a ApplicationRef root.
     *
     * @param container
     */
    static setGlobalRootViewContainer(container: ViewContainerRef): void;
    private _container;
    constructor(applicationRef: ApplicationRef, injector: Injector);
    /**
     * Gets the root view container to inject the component to.
     *
     * @memberOf InjectionService
     */
    getRootViewContainer(): ViewContainerRef | ComponentRef<any>;
    /**
     * Overrides the default root view container. This is useful for
     * things like ngUpgrade that doesn't have a ApplicationRef root.
     *
     * @param container
     *
     * @memberOf InjectionService
     */
    setRootViewContainer(container: ViewContainerRef): void;
    /**
     * Gets the html element for a component ref.
     *
     * @param componentRef
     *
     * @memberOf InjectionService
     */
    getComponentRootNode(component: ViewContainerRef | ComponentRef<any>): HTMLElement;
    /**
     * Gets the root component container html element.
     *
     * @memberOf InjectionService
     */
    getRootViewContainerNode(component: ViewContainerRef | ComponentRef<any>): HTMLElement;
    /**
     * Projects the bindings onto the component
     *
     * @param component
     * @param options
     *
     * @memberOf InjectionService
     */
    projectComponentBindings(component: ComponentRef<any>, bindings: any): ComponentRef<any>;
    /**
     * Appends a component to a adjacent location
     *
     * @param componentClass
     * @param [options={}]
     * @param [location]
     *
     * @memberOf InjectionService
     */
    appendComponent<T>(componentClass: Type<T>, bindings?: any, location?: any): ComponentRef<any>;
    static ɵfac: i0.ɵɵFactoryDeclaration<InjectionService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<InjectionService>;
}

interface PartialBindings {
    inputs?: object;
    outputs?: object;
}
declare abstract class InjectionRegisteryService<T = any> {
    injectionService: InjectionService;
    protected abstract type: Type<T>;
    protected defaults: PartialBindings;
    protected components: Map<any, Array<ComponentRef<T>>>;
    constructor(injectionService: InjectionService);
    getByType(type?: Type<T>): ComponentRef<T>[];
    create(bindings: object): ComponentRef<T>;
    createByType(type: Type<T>, bindings: PartialBindings): ComponentRef<T>;
    destroy(instance: ComponentRef<T>): void;
    destroyAll(): void;
    destroyByType(type: Type<T>): void;
    protected injectComponent(type: Type<T>, bindings: PartialBindings): ComponentRef<T>;
    protected assignDefaults(bindings: PartialBindings): PartialBindings;
    protected register(type: Type<T>, component: ComponentRef<T>): void;
}

declare class TooltipService extends InjectionRegisteryService<TooltipContentComponent> {
    type: any;
    constructor(injectionService: InjectionService);
    static ɵfac: i0.ɵɵFactoryDeclaration<TooltipService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<TooltipService>;
}

declare class TooltipDirective implements OnDestroy {
    private tooltipService;
    private viewContainerRef;
    private renderer;
    tooltipCssClass: string;
    tooltipTitle?: string;
    tooltipAppendToBody: boolean;
    tooltipSpacing: number;
    tooltipDisabled: boolean;
    tooltipShowCaret: boolean;
    tooltipPlacement: PlacementTypes;
    tooltipAlignment: PlacementTypes;
    tooltipType: StyleTypes;
    tooltipCloseOnClickOutside: boolean;
    tooltipCloseOnMouseLeave: boolean;
    tooltipHideTimeout: number;
    tooltipShowTimeout: number;
    tooltipTemplate: TemplateRef<any>;
    tooltipShowEvent: ShowTypes;
    tooltipContext: any;
    tooltipImmediateExit: boolean;
    show: EventEmitter<boolean>;
    hide: EventEmitter<boolean>;
    private get listensForFocus();
    private get listensForHover();
    private component;
    private timeout;
    private mouseLeaveContentEvent;
    private mouseEnterContentEvent;
    private documentClickEvent;
    constructor(tooltipService: TooltipService, viewContainerRef: ViewContainerRef, renderer: Renderer2);
    ngOnDestroy(): void;
    onFocus(): void;
    onBlur(): void;
    onMouseEnter(): void;
    onMouseLeave(target: any): void;
    onMouseClick(): void;
    showTooltip(immediate?: boolean): void;
    addHideListeners(tooltip: HTMLElement): void;
    hideTooltip(immediate?: boolean): void;
    private createBoundOptions;
    static ɵfac: i0.ɵɵFactoryDeclaration<TooltipDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<TooltipDirective, "[ngx-tooltip]", never, { "tooltipCssClass": { "alias": "tooltipCssClass"; "required": false; }; "tooltipTitle": { "alias": "tooltipTitle"; "required": false; }; "tooltipAppendToBody": { "alias": "tooltipAppendToBody"; "required": false; }; "tooltipSpacing": { "alias": "tooltipSpacing"; "required": false; }; "tooltipDisabled": { "alias": "tooltipDisabled"; "required": false; }; "tooltipShowCaret": { "alias": "tooltipShowCaret"; "required": false; }; "tooltipPlacement": { "alias": "tooltipPlacement"; "required": false; }; "tooltipAlignment": { "alias": "tooltipAlignment"; "required": false; }; "tooltipType": { "alias": "tooltipType"; "required": false; }; "tooltipCloseOnClickOutside": { "alias": "tooltipCloseOnClickOutside"; "required": false; }; "tooltipCloseOnMouseLeave": { "alias": "tooltipCloseOnMouseLeave"; "required": false; }; "tooltipHideTimeout": { "alias": "tooltipHideTimeout"; "required": false; }; "tooltipShowTimeout": { "alias": "tooltipShowTimeout"; "required": false; }; "tooltipTemplate": { "alias": "tooltipTemplate"; "required": false; }; "tooltipShowEvent": { "alias": "tooltipShowEvent"; "required": false; }; "tooltipContext": { "alias": "tooltipContext"; "required": false; }; "tooltipImmediateExit": { "alias": "tooltipImmediateExit"; "required": false; }; }, { "show": "show"; "hide": "hide"; }, never, never, false, never>;
}

declare class TooltipModule {
    static ɵfac: i0.ɵɵFactoryDeclaration<TooltipModule, never>;
    static ɵmod: i0.ɵɵNgModuleDeclaration<TooltipModule, [typeof TooltipContentComponent, typeof TooltipDirective], [typeof i18.CommonModule], [typeof TooltipContentComponent, typeof TooltipDirective]>;
    static ɵinj: i0.ɵɵInjectorDeclaration<TooltipModule>;
}

declare class ChartCommonModule {
    static ɵfac: i0.ɵɵFactoryDeclaration<ChartCommonModule, never>;
    static ɵmod: i0.ɵɵNgModuleDeclaration<ChartCommonModule, [typeof AreaComponent, typeof BaseChartComponent, typeof CountUpDirective, typeof TooltipArea, typeof ChartComponent, typeof LegendComponent, typeof LegendEntryComponent, typeof ScaleLegendComponent, typeof CircleComponent, typeof CircleSeriesComponent, typeof GridPanelComponent, typeof GridPanelSeriesComponent, typeof SvgLinearGradientComponent, typeof SvgRadialGradientComponent, typeof Timeline, typeof AdvancedLegendComponent, typeof VisibilityObserver], [typeof i18.CommonModule, typeof AxesModule, typeof TooltipModule], [typeof i18.CommonModule, typeof AxesModule, typeof TooltipModule, typeof AreaComponent, typeof BaseChartComponent, typeof CountUpDirective, typeof TooltipArea, typeof ChartComponent, typeof LegendComponent, typeof LegendEntryComponent, typeof ScaleLegendComponent, typeof CircleComponent, typeof CircleSeriesComponent, typeof GridPanelComponent, typeof GridPanelSeriesComponent, typeof SvgLinearGradientComponent, typeof SvgRadialGradientComponent, typeof Timeline, typeof AdvancedLegendComponent, typeof VisibilityObserver]>;
    static ɵinj: i0.ɵɵInjectorDeclaration<ChartCommonModule>;
}

declare class AreaChartComponent extends BaseChartComponent {
    legend: boolean;
    legendTitle: string;
    legendPosition: LegendPosition;
    xAxis: boolean;
    yAxis: boolean;
    baseValue: any;
    autoScale: boolean;
    showXAxisLabel: boolean;
    showYAxisLabel: boolean;
    xAxisLabel: string;
    yAxisLabel: string;
    timeline: boolean;
    gradient: boolean;
    showGridLines: boolean;
    curve: CurveFactory;
    activeEntries: any[];
    schemeType: ScaleType;
    trimXAxisTicks: boolean;
    trimYAxisTicks: boolean;
    rotateXAxisTicks: boolean;
    maxXAxisTickLength: number;
    maxYAxisTickLength: number;
    xAxisTickFormatting: any;
    yAxisTickFormatting: any;
    xAxisTicks: any[];
    yAxisTicks: any[];
    roundDomains: boolean;
    tooltipDisabled: boolean;
    xScaleMin: any;
    xScaleMax: any;
    yScaleMin: number;
    yScaleMax: number;
    wrapTicks: boolean;
    activate: EventEmitter<any>;
    deactivate: EventEmitter<any>;
    tooltipTemplate: TemplateRef<any>;
    seriesTooltipTemplate: TemplateRef<any>;
    dims: ViewDimensions;
    xSet: any;
    xDomain: any[];
    yDomain: [number, number];
    seriesDomain: string[];
    xScale: any;
    yScale: any;
    transform: string;
    colors: ColorHelper;
    clipPathId: string;
    clipPath: string;
    scaleType: ScaleType;
    series: Series;
    margin: number[];
    hoveredVertical: any;
    xAxisHeight: number;
    yAxisWidth: number;
    filteredDomain: any;
    legendOptions: LegendOptions;
    timelineWidth: number;
    timelineHeight: number;
    timelineXScale: any;
    timelineYScale: any;
    timelineXDomain: any[];
    timelineTransform: any;
    timelinePadding: number;
    update(): void;
    updateTimeline(): void;
    getXDomain(): any[];
    getYDomain(): [number, number];
    getSeriesDomain(): string[];
    getXScale(domain: any, width: number): number;
    getYScale(domain: [number, number], height: number): any;
    getScaleType(values: any): ScaleType;
    updateDomain(domain: any): void;
    updateHoveredVertical(item: any): void;
    hideCircles(): void;
    onClick(data: any, series?: Series): void;
    trackBy: TrackByFunction<Series>;
    setColors(): void;
    getLegendOptions(): LegendOptions;
    updateYAxisWidth({ width }: {
        width: number;
    }): void;
    updateXAxisHeight({ height }: {
        height: number;
    }): void;
    onActivate(item: any): void;
    onDeactivate(item: any): void;
    deactivateAll(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<AreaChartComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<AreaChartComponent, "ngx-charts-area-chart", never, { "legend": { "alias": "legend"; "required": false; }; "legendTitle": { "alias": "legendTitle"; "required": false; }; "legendPosition": { "alias": "legendPosition"; "required": false; }; "xAxis": { "alias": "xAxis"; "required": false; }; "yAxis": { "alias": "yAxis"; "required": false; }; "baseValue": { "alias": "baseValue"; "required": false; }; "autoScale": { "alias": "autoScale"; "required": false; }; "showXAxisLabel": { "alias": "showXAxisLabel"; "required": false; }; "showYAxisLabel": { "alias": "showYAxisLabel"; "required": false; }; "xAxisLabel": { "alias": "xAxisLabel"; "required": false; }; "yAxisLabel": { "alias": "yAxisLabel"; "required": false; }; "timeline": { "alias": "timeline"; "required": false; }; "gradient": { "alias": "gradient"; "required": false; }; "showGridLines": { "alias": "showGridLines"; "required": false; }; "curve": { "alias": "curve"; "required": false; }; "activeEntries": { "alias": "activeEntries"; "required": false; }; "schemeType": { "alias": "schemeType"; "required": false; }; "trimXAxisTicks": { "alias": "trimXAxisTicks"; "required": false; }; "trimYAxisTicks": { "alias": "trimYAxisTicks"; "required": false; }; "rotateXAxisTicks": { "alias": "rotateXAxisTicks"; "required": false; }; "maxXAxisTickLength": { "alias": "maxXAxisTickLength"; "required": false; }; "maxYAxisTickLength": { "alias": "maxYAxisTickLength"; "required": false; }; "xAxisTickFormatting": { "alias": "xAxisTickFormatting"; "required": false; }; "yAxisTickFormatting": { "alias": "yAxisTickFormatting"; "required": false; }; "xAxisTicks": { "alias": "xAxisTicks"; "required": false; }; "yAxisTicks": { "alias": "yAxisTicks"; "required": false; }; "roundDomains": { "alias": "roundDomains"; "required": false; }; "tooltipDisabled": { "alias": "tooltipDisabled"; "required": false; }; "xScaleMin": { "alias": "xScaleMin"; "required": false; }; "xScaleMax": { "alias": "xScaleMax"; "required": false; }; "yScaleMin": { "alias": "yScaleMin"; "required": false; }; "yScaleMax": { "alias": "yScaleMax"; "required": false; }; "wrapTicks": { "alias": "wrapTicks"; "required": false; }; }, { "activate": "activate"; "deactivate": "deactivate"; }, ["tooltipTemplate", "seriesTooltipTemplate"], never, false, never>;
}

declare class AreaChartNormalizedComponent extends BaseChartComponent {
    legend: boolean;
    legendTitle: string;
    legendPosition: LegendPosition;
    xAxis: boolean;
    yAxis: boolean;
    showXAxisLabel: boolean;
    showYAxisLabel: boolean;
    xAxisLabel: string;
    yAxisLabel: string;
    timeline: any;
    gradient: any;
    showGridLines: boolean;
    curve: any;
    activeEntries: any[];
    schemeType: ScaleType;
    trimXAxisTicks: boolean;
    trimYAxisTicks: boolean;
    rotateXAxisTicks: boolean;
    maxXAxisTickLength: number;
    maxYAxisTickLength: number;
    xAxisTickFormatting: any;
    yAxisTickFormatting: any;
    xAxisTicks: any[];
    yAxisTicks: any[];
    roundDomains: boolean;
    tooltipDisabled: boolean;
    wrapTicks: boolean;
    activate: EventEmitter<any>;
    deactivate: EventEmitter<any>;
    tooltipTemplate: TemplateRef<any>;
    seriesTooltipTemplate: TemplateRef<any>;
    dims: ViewDimensions;
    scaleType: ScaleType;
    xDomain: any[];
    xSet: any[];
    yDomain: [number, number];
    seriesDomain: any;
    xScale: any;
    yScale: any;
    transform: string;
    clipPathId: string;
    clipPath: string;
    colors: ColorHelper;
    margin: number[];
    tooltipAreas: any[];
    hoveredVertical: any;
    xAxisHeight: number;
    yAxisWidth: number;
    filteredDomain: any;
    legendOptions: LegendOptions;
    seriesType: typeof SeriesType;
    timelineWidth: any;
    timelineHeight: number;
    timelineXScale: any;
    timelineYScale: any;
    timelineXDomain: any;
    timelineTransform: any;
    timelinePadding: number;
    update(): void;
    updateTimeline(): void;
    getXDomain(): any[];
    getSeriesDomain(): string[];
    getXScale(domain: any, width: number): any;
    getYScale(domain: any, height: number): any;
    updateDomain(domain: any): void;
    updateHoveredVertical(item: any): void;
    hideCircles(): void;
    onClick(data: any, series?: any): void;
    trackBy: TrackByFunction<Series>;
    setColors(): void;
    getLegendOptions(): LegendOptions;
    updateYAxisWidth({ width }: {
        width: number;
    }): void;
    updateXAxisHeight({ height }: {
        height: number;
    }): void;
    onActivate(item: any): void;
    onDeactivate(item: any): void;
    deactivateAll(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<AreaChartNormalizedComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<AreaChartNormalizedComponent, "ngx-charts-area-chart-normalized", never, { "legend": { "alias": "legend"; "required": false; }; "legendTitle": { "alias": "legendTitle"; "required": false; }; "legendPosition": { "alias": "legendPosition"; "required": false; }; "xAxis": { "alias": "xAxis"; "required": false; }; "yAxis": { "alias": "yAxis"; "required": false; }; "showXAxisLabel": { "alias": "showXAxisLabel"; "required": false; }; "showYAxisLabel": { "alias": "showYAxisLabel"; "required": false; }; "xAxisLabel": { "alias": "xAxisLabel"; "required": false; }; "yAxisLabel": { "alias": "yAxisLabel"; "required": false; }; "timeline": { "alias": "timeline"; "required": false; }; "gradient": { "alias": "gradient"; "required": false; }; "showGridLines": { "alias": "showGridLines"; "required": false; }; "curve": { "alias": "curve"; "required": false; }; "activeEntries": { "alias": "activeEntries"; "required": false; }; "schemeType": { "alias": "schemeType"; "required": false; }; "trimXAxisTicks": { "alias": "trimXAxisTicks"; "required": false; }; "trimYAxisTicks": { "alias": "trimYAxisTicks"; "required": false; }; "rotateXAxisTicks": { "alias": "rotateXAxisTicks"; "required": false; }; "maxXAxisTickLength": { "alias": "maxXAxisTickLength"; "required": false; }; "maxYAxisTickLength": { "alias": "maxYAxisTickLength"; "required": false; }; "xAxisTickFormatting": { "alias": "xAxisTickFormatting"; "required": false; }; "yAxisTickFormatting": { "alias": "yAxisTickFormatting"; "required": false; }; "xAxisTicks": { "alias": "xAxisTicks"; "required": false; }; "yAxisTicks": { "alias": "yAxisTicks"; "required": false; }; "roundDomains": { "alias": "roundDomains"; "required": false; }; "tooltipDisabled": { "alias": "tooltipDisabled"; "required": false; }; "wrapTicks": { "alias": "wrapTicks"; "required": false; }; }, { "activate": "activate"; "deactivate": "deactivate"; }, ["tooltipTemplate", "seriesTooltipTemplate"], never, false, never>;
}

declare class AreaChartStackedComponent extends BaseChartComponent {
    legend: boolean;
    legendTitle: string;
    legendPosition: LegendPosition;
    xAxis: boolean;
    yAxis: boolean;
    showXAxisLabel: boolean;
    showYAxisLabel: boolean;
    xAxisLabel: string;
    yAxisLabel: string;
    timeline: boolean;
    gradient: boolean;
    showGridLines: boolean;
    curve: any;
    activeEntries: any[];
    schemeType: ScaleType;
    trimXAxisTicks: boolean;
    trimYAxisTicks: boolean;
    rotateXAxisTicks: boolean;
    maxXAxisTickLength: number;
    maxYAxisTickLength: number;
    xAxisTickFormatting: any;
    yAxisTickFormatting: any;
    xAxisTicks: any[];
    yAxisTicks: any[];
    roundDomains: boolean;
    tooltipDisabled: boolean;
    xScaleMin: any;
    xScaleMax: any;
    yScaleMin: number;
    yScaleMax: number;
    wrapTicks: boolean;
    activate: EventEmitter<any>;
    deactivate: EventEmitter<any>;
    tooltipTemplate: TemplateRef<any>;
    seriesTooltipTemplate: TemplateRef<any>;
    dims: ViewDimensions;
    scaleType: ScaleType;
    xDomain: any[];
    xSet: any[];
    yDomain: [number, number];
    seriesDomain: any;
    xScale: any;
    yScale: any;
    transform: string;
    clipPathId: string;
    clipPath: string;
    colors: ColorHelper;
    margin: number[];
    hoveredVertical: any;
    xAxisHeight: number;
    yAxisWidth: number;
    filteredDomain: any;
    legendOptions: any;
    timelineWidth: number;
    timelineHeight: number;
    timelineXScale: any;
    timelineYScale: any;
    timelineXDomain: any;
    timelineTransform: any;
    timelinePadding: number;
    seriesType: typeof SeriesType;
    update(): void;
    updateTimeline(): void;
    getXDomain(): any[];
    getYDomain(): [number, number];
    getSeriesDomain(): string[];
    getXScale(domain: any, width: number): any;
    getYScale(domain: any, height: number): any;
    updateDomain(domain: any): void;
    updateHoveredVertical(item: any): void;
    hideCircles(): void;
    onClick(data: any, series?: any): void;
    trackBy(index: any, item: any): string;
    setColors(): void;
    getLegendOptions(): LegendOptions;
    updateYAxisWidth({ width }: {
        width: number;
    }): void;
    updateXAxisHeight({ height }: {
        height: number;
    }): void;
    onActivate(item: any): void;
    onDeactivate(item: any): void;
    deactivateAll(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<AreaChartStackedComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<AreaChartStackedComponent, "ngx-charts-area-chart-stacked", never, { "legend": { "alias": "legend"; "required": false; }; "legendTitle": { "alias": "legendTitle"; "required": false; }; "legendPosition": { "alias": "legendPosition"; "required": false; }; "xAxis": { "alias": "xAxis"; "required": false; }; "yAxis": { "alias": "yAxis"; "required": false; }; "showXAxisLabel": { "alias": "showXAxisLabel"; "required": false; }; "showYAxisLabel": { "alias": "showYAxisLabel"; "required": false; }; "xAxisLabel": { "alias": "xAxisLabel"; "required": false; }; "yAxisLabel": { "alias": "yAxisLabel"; "required": false; }; "timeline": { "alias": "timeline"; "required": false; }; "gradient": { "alias": "gradient"; "required": false; }; "showGridLines": { "alias": "showGridLines"; "required": false; }; "curve": { "alias": "curve"; "required": false; }; "activeEntries": { "alias": "activeEntries"; "required": false; }; "schemeType": { "alias": "schemeType"; "required": false; }; "trimXAxisTicks": { "alias": "trimXAxisTicks"; "required": false; }; "trimYAxisTicks": { "alias": "trimYAxisTicks"; "required": false; }; "rotateXAxisTicks": { "alias": "rotateXAxisTicks"; "required": false; }; "maxXAxisTickLength": { "alias": "maxXAxisTickLength"; "required": false; }; "maxYAxisTickLength": { "alias": "maxYAxisTickLength"; "required": false; }; "xAxisTickFormatting": { "alias": "xAxisTickFormatting"; "required": false; }; "yAxisTickFormatting": { "alias": "yAxisTickFormatting"; "required": false; }; "xAxisTicks": { "alias": "xAxisTicks"; "required": false; }; "yAxisTicks": { "alias": "yAxisTicks"; "required": false; }; "roundDomains": { "alias": "roundDomains"; "required": false; }; "tooltipDisabled": { "alias": "tooltipDisabled"; "required": false; }; "xScaleMin": { "alias": "xScaleMin"; "required": false; }; "xScaleMax": { "alias": "xScaleMax"; "required": false; }; "yScaleMin": { "alias": "yScaleMin"; "required": false; }; "yScaleMax": { "alias": "yScaleMax"; "required": false; }; "wrapTicks": { "alias": "wrapTicks"; "required": false; }; }, { "activate": "activate"; "deactivate": "deactivate"; }, ["tooltipTemplate", "seriesTooltipTemplate"], never, false, never>;
}

declare class AreaSeriesComponent implements OnChanges {
    data: AreaChartSeries;
    xScale: any;
    yScale: any;
    baseValue: any;
    colors: ColorHelper;
    scaleType: ScaleType;
    stacked: boolean;
    normalized: boolean;
    gradient: boolean;
    curve: any;
    activeEntries: any[];
    animations: boolean;
    select: EventEmitter<any>;
    opacity: number;
    path: string;
    startingPath: string;
    hasGradient: boolean;
    gradientStops: Gradient[];
    ngOnChanges(changes: SimpleChanges): void;
    update(): void;
    updateGradient(): void;
    isActive(entry: any): boolean;
    isInactive(entry: any): boolean;
    static ɵfac: i0.ɵɵFactoryDeclaration<AreaSeriesComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<AreaSeriesComponent, "g[ngx-charts-area-series]", never, { "data": { "alias": "data"; "required": false; }; "xScale": { "alias": "xScale"; "required": false; }; "yScale": { "alias": "yScale"; "required": false; }; "baseValue": { "alias": "baseValue"; "required": false; }; "colors": { "alias": "colors"; "required": false; }; "scaleType": { "alias": "scaleType"; "required": false; }; "stacked": { "alias": "stacked"; "required": false; }; "normalized": { "alias": "normalized"; "required": false; }; "gradient": { "alias": "gradient"; "required": false; }; "curve": { "alias": "curve"; "required": false; }; "activeEntries": { "alias": "activeEntries"; "required": false; }; "animations": { "alias": "animations"; "required": false; }; }, { "select": "select"; }, never, never, false, never>;
}

declare class AreaChartModule {
    static ɵfac: i0.ɵɵFactoryDeclaration<AreaChartModule, never>;
    static ɵmod: i0.ɵɵNgModuleDeclaration<AreaChartModule, [typeof AreaChartComponent, typeof AreaChartNormalizedComponent, typeof AreaChartStackedComponent, typeof AreaSeriesComponent], [typeof ChartCommonModule], [typeof AreaChartComponent, typeof AreaChartNormalizedComponent, typeof AreaChartStackedComponent, typeof AreaSeriesComponent]>;
    static ɵinj: i0.ɵɵInjectorDeclaration<AreaChartModule>;
}

declare class BarComponent implements OnChanges {
    fill: string;
    data: DataItem;
    width: number;
    height: number;
    x: number;
    y: number;
    orientation: BarOrientation;
    roundEdges: boolean;
    gradient: boolean;
    offset: number;
    isActive: boolean;
    stops: Gradient[];
    animations: boolean;
    ariaLabel: string;
    noBarWhenZero: boolean;
    select: EventEmitter<DataItem>;
    activate: EventEmitter<DataItem>;
    deactivate: EventEmitter<DataItem>;
    element: HTMLElement;
    path: string;
    gradientId: string;
    gradientFill: string;
    gradientStops: Gradient[];
    hasGradient: boolean;
    hideBar: boolean;
    constructor(element: ElementRef);
    ngOnChanges(changes: SimpleChanges): void;
    update(): void;
    loadAnimation(): void;
    updatePathEl(): void;
    getGradient(): Gradient[];
    getStartingPath(): string;
    getPath(): string;
    getRadius(): number;
    getStartOpacity(): number;
    get edges(): boolean[];
    onMouseEnter(): void;
    onMouseLeave(): void;
    private checkToHideBar;
    static ɵfac: i0.ɵɵFactoryDeclaration<BarComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<BarComponent, "g[ngx-charts-bar]", never, { "fill": { "alias": "fill"; "required": false; }; "data": { "alias": "data"; "required": false; }; "width": { "alias": "width"; "required": false; }; "height": { "alias": "height"; "required": false; }; "x": { "alias": "x"; "required": false; }; "y": { "alias": "y"; "required": false; }; "orientation": { "alias": "orientation"; "required": false; }; "roundEdges": { "alias": "roundEdges"; "required": false; }; "gradient": { "alias": "gradient"; "required": false; }; "offset": { "alias": "offset"; "required": false; }; "isActive": { "alias": "isActive"; "required": false; }; "stops": { "alias": "stops"; "required": false; }; "animations": { "alias": "animations"; "required": false; }; "ariaLabel": { "alias": "ariaLabel"; "required": false; }; "noBarWhenZero": { "alias": "noBarWhenZero"; "required": false; }; }, { "select": "select"; "activate": "activate"; "deactivate": "deactivate"; }, never, never, false, never>;
}

declare class BarHorizontalComponent extends BaseChartComponent {
    legend: boolean;
    legendTitle: string;
    legendPosition: LegendPosition;
    xAxis: any;
    yAxis: any;
    showXAxisLabel: boolean;
    showYAxisLabel: boolean;
    xAxisLabel: string;
    yAxisLabel: string;
    tooltipDisabled: boolean;
    gradient: boolean;
    showGridLines: boolean;
    activeEntries: any[];
    schemeType: ScaleType;
    trimXAxisTicks: boolean;
    trimYAxisTicks: boolean;
    rotateXAxisTicks: boolean;
    maxXAxisTickLength: number;
    maxYAxisTickLength: number;
    xAxisTickFormatting: any;
    yAxisTickFormatting: any;
    xAxisTicks: any[];
    yAxisTicks: any[];
    barPadding: number;
    roundDomains: boolean;
    roundEdges: boolean;
    xScaleMax: number;
    xScaleMin: number;
    showDataLabel: boolean;
    dataLabelFormatting: any;
    noBarWhenZero: boolean;
    wrapTicks: boolean;
    activate: EventEmitter<any>;
    deactivate: EventEmitter<any>;
    tooltipTemplate: TemplateRef<any>;
    dims: ViewDimensions;
    yScale: any;
    xScale: any;
    xDomain: [number, number];
    yDomain: string[];
    transform: string;
    colors: ColorHelper;
    margin: number[];
    xAxisHeight: number;
    yAxisWidth: number;
    legendOptions: LegendOptions;
    dataLabelMaxWidth: any;
    ngOnChanges(): void;
    update(): void;
    getXScale(): any;
    getYScale(): any;
    getXDomain(): [number, number];
    getYDomain(): string[];
    onClick(data: any): void;
    setColors(): void;
    getLegendOptions(): LegendOptions;
    updateYAxisWidth({ width }: {
        width: number;
    }): void;
    updateXAxisHeight({ height }: {
        height: number;
    }): void;
    onDataLabelMaxWidthChanged(event: any): void;
    onActivate(item: any, fromLegend?: boolean): void;
    onDeactivate(item: any, fromLegend?: boolean): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<BarHorizontalComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<BarHorizontalComponent, "ngx-charts-bar-horizontal", never, { "legend": { "alias": "legend"; "required": false; }; "legendTitle": { "alias": "legendTitle"; "required": false; }; "legendPosition": { "alias": "legendPosition"; "required": false; }; "xAxis": { "alias": "xAxis"; "required": false; }; "yAxis": { "alias": "yAxis"; "required": false; }; "showXAxisLabel": { "alias": "showXAxisLabel"; "required": false; }; "showYAxisLabel": { "alias": "showYAxisLabel"; "required": false; }; "xAxisLabel": { "alias": "xAxisLabel"; "required": false; }; "yAxisLabel": { "alias": "yAxisLabel"; "required": false; }; "tooltipDisabled": { "alias": "tooltipDisabled"; "required": false; }; "gradient": { "alias": "gradient"; "required": false; }; "showGridLines": { "alias": "showGridLines"; "required": false; }; "activeEntries": { "alias": "activeEntries"; "required": false; }; "schemeType": { "alias": "schemeType"; "required": false; }; "trimXAxisTicks": { "alias": "trimXAxisTicks"; "required": false; }; "trimYAxisTicks": { "alias": "trimYAxisTicks"; "required": false; }; "rotateXAxisTicks": { "alias": "rotateXAxisTicks"; "required": false; }; "maxXAxisTickLength": { "alias": "maxXAxisTickLength"; "required": false; }; "maxYAxisTickLength": { "alias": "maxYAxisTickLength"; "required": false; }; "xAxisTickFormatting": { "alias": "xAxisTickFormatting"; "required": false; }; "yAxisTickFormatting": { "alias": "yAxisTickFormatting"; "required": false; }; "xAxisTicks": { "alias": "xAxisTicks"; "required": false; }; "yAxisTicks": { "alias": "yAxisTicks"; "required": false; }; "barPadding": { "alias": "barPadding"; "required": false; }; "roundDomains": { "alias": "roundDomains"; "required": false; }; "roundEdges": { "alias": "roundEdges"; "required": false; }; "xScaleMax": { "alias": "xScaleMax"; "required": false; }; "xScaleMin": { "alias": "xScaleMin"; "required": false; }; "showDataLabel": { "alias": "showDataLabel"; "required": false; }; "dataLabelFormatting": { "alias": "dataLabelFormatting"; "required": false; }; "noBarWhenZero": { "alias": "noBarWhenZero"; "required": false; }; "wrapTicks": { "alias": "wrapTicks"; "required": false; }; }, { "activate": "activate"; "deactivate": "deactivate"; }, ["tooltipTemplate"], never, false, never>;
}

declare class BarHorizontal2DComponent extends BaseChartComponent {
    legend: boolean;
    legendTitle: string;
    legendPosition: LegendPosition;
    xAxis: any;
    yAxis: any;
    showXAxisLabel: boolean;
    showYAxisLabel: boolean;
    xAxisLabel: string;
    yAxisLabel: string;
    tooltipDisabled: boolean;
    gradient: boolean;
    showGridLines: boolean;
    activeEntries: any[];
    schemeType: ScaleType;
    trimXAxisTicks: boolean;
    trimYAxisTicks: boolean;
    rotateXAxisTicks: boolean;
    maxXAxisTickLength: number;
    maxYAxisTickLength: number;
    xAxisTickFormatting: any;
    yAxisTickFormatting: any;
    xAxisTicks: any[];
    yAxisTicks: any[];
    groupPadding: number;
    barPadding: number;
    roundDomains: boolean;
    roundEdges: boolean;
    xScaleMax: number;
    showDataLabel: boolean;
    dataLabelFormatting: any;
    noBarWhenZero: boolean;
    wrapTicks: boolean;
    activate: EventEmitter<any>;
    deactivate: EventEmitter<any>;
    tooltipTemplate: TemplateRef<any>;
    dims: ViewDimensions;
    groupDomain: string[];
    innerDomain: string[];
    valueDomain: [number, number];
    groupScale: any;
    innerScale: any;
    valueScale: any;
    transform: string;
    colors: ColorHelper;
    margin: number[];
    xAxisHeight: number;
    yAxisWidth: number;
    legendOptions: LegendOptions;
    dataLabelMaxWidth: any;
    isSSR: boolean;
    barOrientation: typeof BarOrientation;
    ngOnInit(): void;
    ngOnChanges(): void;
    update(): void;
    getGroupScale(): any;
    getInnerScale(): any;
    getValueScale(): any;
    getGroupDomain(): string[];
    getInnerDomain(): string[];
    getValueDomain(): [number, number];
    groupTransform(group: DataItem): string;
    onClick(data: any, group?: DataItem): void;
    trackBy: TrackByFunction<DataItem>;
    setColors(): void;
    getLegendOptions(): LegendOptions;
    updateYAxisWidth({ width }: {
        width: number;
    }): void;
    updateXAxisHeight({ height }: {
        height: number;
    }): void;
    onDataLabelMaxWidthChanged(event: any, groupIndex: number): void;
    onActivate(event: any, group: DataItem, fromLegend?: boolean): void;
    onDeactivate(event: any, group: DataItem, fromLegend?: boolean): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<BarHorizontal2DComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<BarHorizontal2DComponent, "ngx-charts-bar-horizontal-2d", never, { "legend": { "alias": "legend"; "required": false; }; "legendTitle": { "alias": "legendTitle"; "required": false; }; "legendPosition": { "alias": "legendPosition"; "required": false; }; "xAxis": { "alias": "xAxis"; "required": false; }; "yAxis": { "alias": "yAxis"; "required": false; }; "showXAxisLabel": { "alias": "showXAxisLabel"; "required": false; }; "showYAxisLabel": { "alias": "showYAxisLabel"; "required": false; }; "xAxisLabel": { "alias": "xAxisLabel"; "required": false; }; "yAxisLabel": { "alias": "yAxisLabel"; "required": false; }; "tooltipDisabled": { "alias": "tooltipDisabled"; "required": false; }; "gradient": { "alias": "gradient"; "required": false; }; "showGridLines": { "alias": "showGridLines"; "required": false; }; "activeEntries": { "alias": "activeEntries"; "required": false; }; "schemeType": { "alias": "schemeType"; "required": false; }; "trimXAxisTicks": { "alias": "trimXAxisTicks"; "required": false; }; "trimYAxisTicks": { "alias": "trimYAxisTicks"; "required": false; }; "rotateXAxisTicks": { "alias": "rotateXAxisTicks"; "required": false; }; "maxXAxisTickLength": { "alias": "maxXAxisTickLength"; "required": false; }; "maxYAxisTickLength": { "alias": "maxYAxisTickLength"; "required": false; }; "xAxisTickFormatting": { "alias": "xAxisTickFormatting"; "required": false; }; "yAxisTickFormatting": { "alias": "yAxisTickFormatting"; "required": false; }; "xAxisTicks": { "alias": "xAxisTicks"; "required": false; }; "yAxisTicks": { "alias": "yAxisTicks"; "required": false; }; "groupPadding": { "alias": "groupPadding"; "required": false; }; "barPadding": { "alias": "barPadding"; "required": false; }; "roundDomains": { "alias": "roundDomains"; "required": false; }; "roundEdges": { "alias": "roundEdges"; "required": false; }; "xScaleMax": { "alias": "xScaleMax"; "required": false; }; "showDataLabel": { "alias": "showDataLabel"; "required": false; }; "dataLabelFormatting": { "alias": "dataLabelFormatting"; "required": false; }; "noBarWhenZero": { "alias": "noBarWhenZero"; "required": false; }; "wrapTicks": { "alias": "wrapTicks"; "required": false; }; }, { "activate": "activate"; "deactivate": "deactivate"; }, ["tooltipTemplate"], never, false, never>;
}

declare enum BarChartType {
    Standard = "standard",
    Normalized = "normalized",
    Stacked = "stacked"
}

declare class BarHorizontalNormalizedComponent extends BaseChartComponent {
    legend: boolean;
    legendTitle: string;
    legendPosition: LegendPosition;
    xAxis: any;
    yAxis: any;
    showXAxisLabel: boolean;
    showYAxisLabel: boolean;
    xAxisLabel: string;
    yAxisLabel: string;
    tooltipDisabled: boolean;
    gradient: boolean;
    showGridLines: boolean;
    activeEntries: any[];
    schemeType: ScaleType;
    trimXAxisTicks: boolean;
    trimYAxisTicks: boolean;
    rotateXAxisTicks: boolean;
    maxXAxisTickLength: number;
    maxYAxisTickLength: number;
    xAxisTickFormatting: any;
    yAxisTickFormatting: any;
    xAxisTicks: any[];
    yAxisTicks: any[];
    barPadding: number;
    roundDomains: boolean;
    noBarWhenZero: boolean;
    wrapTicks: boolean;
    activate: EventEmitter<any>;
    deactivate: EventEmitter<any>;
    tooltipTemplate: TemplateRef<any>;
    dims: ViewDimensions;
    groupDomain: string[];
    innerDomain: string[];
    valueDomain: [number, number];
    xScale: any;
    yScale: any;
    transform: string;
    colors: ColorHelper;
    margin: number[];
    xAxisHeight: number;
    yAxisWidth: number;
    legendOptions: LegendOptions;
    barChartType: typeof BarChartType;
    isSSR: boolean;
    ngOnInit(): void;
    update(): void;
    getGroupDomain(): string[];
    getInnerDomain(): string[];
    getYScale(): any;
    getXScale(): any;
    groupTransform(group: Series): string;
    onClick(data: any, group?: Series): void;
    trackBy: TrackByFunction<Series>;
    setColors(): void;
    getLegendOptions(): LegendOptions;
    updateYAxisWidth({ width }: {
        width: number;
    }): void;
    updateXAxisHeight({ height }: {
        height: number;
    }): void;
    onActivate(event: any, group: Series, fromLegend?: boolean): void;
    onDeactivate(event: any, group: Series, fromLegend?: boolean): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<BarHorizontalNormalizedComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<BarHorizontalNormalizedComponent, "ngx-charts-bar-horizontal-normalized", never, { "legend": { "alias": "legend"; "required": false; }; "legendTitle": { "alias": "legendTitle"; "required": false; }; "legendPosition": { "alias": "legendPosition"; "required": false; }; "xAxis": { "alias": "xAxis"; "required": false; }; "yAxis": { "alias": "yAxis"; "required": false; }; "showXAxisLabel": { "alias": "showXAxisLabel"; "required": false; }; "showYAxisLabel": { "alias": "showYAxisLabel"; "required": false; }; "xAxisLabel": { "alias": "xAxisLabel"; "required": false; }; "yAxisLabel": { "alias": "yAxisLabel"; "required": false; }; "tooltipDisabled": { "alias": "tooltipDisabled"; "required": false; }; "gradient": { "alias": "gradient"; "required": false; }; "showGridLines": { "alias": "showGridLines"; "required": false; }; "activeEntries": { "alias": "activeEntries"; "required": false; }; "schemeType": { "alias": "schemeType"; "required": false; }; "trimXAxisTicks": { "alias": "trimXAxisTicks"; "required": false; }; "trimYAxisTicks": { "alias": "trimYAxisTicks"; "required": false; }; "rotateXAxisTicks": { "alias": "rotateXAxisTicks"; "required": false; }; "maxXAxisTickLength": { "alias": "maxXAxisTickLength"; "required": false; }; "maxYAxisTickLength": { "alias": "maxYAxisTickLength"; "required": false; }; "xAxisTickFormatting": { "alias": "xAxisTickFormatting"; "required": false; }; "yAxisTickFormatting": { "alias": "yAxisTickFormatting"; "required": false; }; "xAxisTicks": { "alias": "xAxisTicks"; "required": false; }; "yAxisTicks": { "alias": "yAxisTicks"; "required": false; }; "barPadding": { "alias": "barPadding"; "required": false; }; "roundDomains": { "alias": "roundDomains"; "required": false; }; "noBarWhenZero": { "alias": "noBarWhenZero"; "required": false; }; "wrapTicks": { "alias": "wrapTicks"; "required": false; }; }, { "activate": "activate"; "deactivate": "deactivate"; }, ["tooltipTemplate"], never, false, never>;
}

declare class BarHorizontalStackedComponent extends BaseChartComponent {
    legend: boolean;
    legendTitle: string;
    legendPosition: LegendPosition;
    xAxis: any;
    yAxis: any;
    showXAxisLabel: boolean;
    showYAxisLabel: boolean;
    xAxisLabel: string;
    yAxisLabel: string;
    tooltipDisabled: boolean;
    gradient: boolean;
    showGridLines: boolean;
    activeEntries: any[];
    schemeType: ScaleType;
    trimXAxisTicks: boolean;
    trimYAxisTicks: boolean;
    rotateXAxisTicks: boolean;
    maxXAxisTickLength: number;
    maxYAxisTickLength: number;
    xAxisTickFormatting: any;
    yAxisTickFormatting: any;
    xAxisTicks: any[];
    yAxisTicks: any[];
    barPadding: number;
    roundDomains: boolean;
    xScaleMax: number;
    showDataLabel: boolean;
    dataLabelFormatting: any;
    noBarWhenZero: boolean;
    wrapTicks: boolean;
    activate: EventEmitter<any>;
    deactivate: EventEmitter<any>;
    tooltipTemplate: TemplateRef<any>;
    dims: ViewDimensions;
    groupDomain: string[];
    innerDomain: string[];
    valueDomain: [number, number];
    xScale: any;
    yScale: any;
    transform: string;
    colors: ColorHelper;
    margin: number[];
    xAxisHeight: number;
    yAxisWidth: number;
    legendOptions: LegendOptions;
    dataLabelMaxWidth: any;
    barChartType: typeof BarChartType;
    isSSR: boolean;
    ngOnInit(): void;
    update(): void;
    getGroupDomain(): string[];
    getInnerDomain(): string[];
    getValueDomain(): [number, number];
    getYScale(): any;
    getXScale(): any;
    groupTransform(group: Series): string;
    onClick(data: any, group?: Series): void;
    trackBy: TrackByFunction<Series>;
    setColors(): void;
    getLegendOptions(): LegendOptions;
    updateYAxisWidth({ width }: {
        width: number;
    }): void;
    updateXAxisHeight({ height }: {
        height: number;
    }): void;
    onDataLabelMaxWidthChanged(event: any, groupIndex: number): void;
    onActivate(event: any, group: Series, fromLegend?: boolean): void;
    onDeactivate(event: any, group: Series, fromLegend?: boolean): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<BarHorizontalStackedComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<BarHorizontalStackedComponent, "ngx-charts-bar-horizontal-stacked", never, { "legend": { "alias": "legend"; "required": false; }; "legendTitle": { "alias": "legendTitle"; "required": false; }; "legendPosition": { "alias": "legendPosition"; "required": false; }; "xAxis": { "alias": "xAxis"; "required": false; }; "yAxis": { "alias": "yAxis"; "required": false; }; "showXAxisLabel": { "alias": "showXAxisLabel"; "required": false; }; "showYAxisLabel": { "alias": "showYAxisLabel"; "required": false; }; "xAxisLabel": { "alias": "xAxisLabel"; "required": false; }; "yAxisLabel": { "alias": "yAxisLabel"; "required": false; }; "tooltipDisabled": { "alias": "tooltipDisabled"; "required": false; }; "gradient": { "alias": "gradient"; "required": false; }; "showGridLines": { "alias": "showGridLines"; "required": false; }; "activeEntries": { "alias": "activeEntries"; "required": false; }; "schemeType": { "alias": "schemeType"; "required": false; }; "trimXAxisTicks": { "alias": "trimXAxisTicks"; "required": false; }; "trimYAxisTicks": { "alias": "trimYAxisTicks"; "required": false; }; "rotateXAxisTicks": { "alias": "rotateXAxisTicks"; "required": false; }; "maxXAxisTickLength": { "alias": "maxXAxisTickLength"; "required": false; }; "maxYAxisTickLength": { "alias": "maxYAxisTickLength"; "required": false; }; "xAxisTickFormatting": { "alias": "xAxisTickFormatting"; "required": false; }; "yAxisTickFormatting": { "alias": "yAxisTickFormatting"; "required": false; }; "xAxisTicks": { "alias": "xAxisTicks"; "required": false; }; "yAxisTicks": { "alias": "yAxisTicks"; "required": false; }; "barPadding": { "alias": "barPadding"; "required": false; }; "roundDomains": { "alias": "roundDomains"; "required": false; }; "xScaleMax": { "alias": "xScaleMax"; "required": false; }; "showDataLabel": { "alias": "showDataLabel"; "required": false; }; "dataLabelFormatting": { "alias": "dataLabelFormatting"; "required": false; }; "noBarWhenZero": { "alias": "noBarWhenZero"; "required": false; }; "wrapTicks": { "alias": "wrapTicks"; "required": false; }; }, { "activate": "activate"; "deactivate": "deactivate"; }, ["tooltipTemplate"], never, false, never>;
}

declare class BarVerticalComponent extends BaseChartComponent {
    legend: boolean;
    legendTitle: string;
    legendPosition: LegendPosition;
    xAxis: any;
    yAxis: any;
    showXAxisLabel: boolean;
    showYAxisLabel: boolean;
    xAxisLabel: string;
    yAxisLabel: string;
    tooltipDisabled: boolean;
    gradient: boolean;
    showGridLines: boolean;
    activeEntries: any[];
    schemeType: ScaleType;
    trimXAxisTicks: boolean;
    trimYAxisTicks: boolean;
    rotateXAxisTicks: boolean;
    maxXAxisTickLength: number;
    maxYAxisTickLength: number;
    xAxisTickFormatting: any;
    yAxisTickFormatting: any;
    xAxisTicks: any[];
    yAxisTicks: any[];
    barPadding: number;
    roundDomains: boolean;
    roundEdges: boolean;
    yScaleMax: number;
    yScaleMin: number;
    showDataLabel: boolean;
    dataLabelFormatting: any;
    noBarWhenZero: boolean;
    wrapTicks: boolean;
    activate: EventEmitter<any>;
    deactivate: EventEmitter<any>;
    tooltipTemplate: TemplateRef<any>;
    dims: ViewDimensions;
    xScale: any;
    yScale: any;
    xDomain: any;
    yDomain: any;
    transform: string;
    colors: ColorHelper;
    margin: number[];
    xAxisHeight: number;
    yAxisWidth: number;
    legendOptions: LegendOptions;
    dataLabelMaxHeight: any;
    ngOnChanges(): void;
    update(): void;
    getXScale(): any;
    getYScale(): any;
    getXDomain(): any[];
    getYDomain(): [number, number];
    onClick(data: DataItem | string): void;
    setColors(): void;
    getLegendOptions(): {
        scaleType: any;
        colors: any;
        domain: any[];
        title: any;
        position: LegendPosition;
    };
    updateYAxisWidth({ width }: {
        width: any;
    }): void;
    updateXAxisHeight({ height }: {
        height: any;
    }): void;
    onDataLabelMaxHeightChanged(event: any): void;
    onActivate(item: any, fromLegend?: boolean): void;
    onDeactivate(item: any, fromLegend?: boolean): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<BarVerticalComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<BarVerticalComponent, "ngx-charts-bar-vertical", never, { "legend": { "alias": "legend"; "required": false; }; "legendTitle": { "alias": "legendTitle"; "required": false; }; "legendPosition": { "alias": "legendPosition"; "required": false; }; "xAxis": { "alias": "xAxis"; "required": false; }; "yAxis": { "alias": "yAxis"; "required": false; }; "showXAxisLabel": { "alias": "showXAxisLabel"; "required": false; }; "showYAxisLabel": { "alias": "showYAxisLabel"; "required": false; }; "xAxisLabel": { "alias": "xAxisLabel"; "required": false; }; "yAxisLabel": { "alias": "yAxisLabel"; "required": false; }; "tooltipDisabled": { "alias": "tooltipDisabled"; "required": false; }; "gradient": { "alias": "gradient"; "required": false; }; "showGridLines": { "alias": "showGridLines"; "required": false; }; "activeEntries": { "alias": "activeEntries"; "required": false; }; "schemeType": { "alias": "schemeType"; "required": false; }; "trimXAxisTicks": { "alias": "trimXAxisTicks"; "required": false; }; "trimYAxisTicks": { "alias": "trimYAxisTicks"; "required": false; }; "rotateXAxisTicks": { "alias": "rotateXAxisTicks"; "required": false; }; "maxXAxisTickLength": { "alias": "maxXAxisTickLength"; "required": false; }; "maxYAxisTickLength": { "alias": "maxYAxisTickLength"; "required": false; }; "xAxisTickFormatting": { "alias": "xAxisTickFormatting"; "required": false; }; "yAxisTickFormatting": { "alias": "yAxisTickFormatting"; "required": false; }; "xAxisTicks": { "alias": "xAxisTicks"; "required": false; }; "yAxisTicks": { "alias": "yAxisTicks"; "required": false; }; "barPadding": { "alias": "barPadding"; "required": false; }; "roundDomains": { "alias": "roundDomains"; "required": false; }; "roundEdges": { "alias": "roundEdges"; "required": false; }; "yScaleMax": { "alias": "yScaleMax"; "required": false; }; "yScaleMin": { "alias": "yScaleMin"; "required": false; }; "showDataLabel": { "alias": "showDataLabel"; "required": false; }; "dataLabelFormatting": { "alias": "dataLabelFormatting"; "required": false; }; "noBarWhenZero": { "alias": "noBarWhenZero"; "required": false; }; "wrapTicks": { "alias": "wrapTicks"; "required": false; }; }, { "activate": "activate"; "deactivate": "deactivate"; }, ["tooltipTemplate"], never, false, never>;
}

declare class BarVertical2DComponent extends BaseChartComponent {
    legend: boolean;
    legendTitle: string;
    legendPosition: LegendPosition;
    xAxis: any;
    yAxis: any;
    showXAxisLabel: boolean;
    showYAxisLabel: boolean;
    xAxisLabel: string;
    yAxisLabel: string;
    tooltipDisabled: boolean;
    scaleType: ScaleType;
    gradient: boolean;
    showGridLines: boolean;
    activeEntries: any[];
    schemeType: ScaleType;
    trimXAxisTicks: boolean;
    trimYAxisTicks: boolean;
    rotateXAxisTicks: boolean;
    maxXAxisTickLength: number;
    maxYAxisTickLength: number;
    xAxisTickFormatting: any;
    yAxisTickFormatting: any;
    xAxisTicks: any[];
    yAxisTicks: any[];
    groupPadding: number;
    barPadding: number;
    roundDomains: boolean;
    roundEdges: boolean;
    yScaleMax: number;
    showDataLabel: boolean;
    dataLabelFormatting: any;
    noBarWhenZero: boolean;
    wrapTicks: boolean;
    activate: EventEmitter<any>;
    deactivate: EventEmitter<any>;
    tooltipTemplate: TemplateRef<any>;
    dims: ViewDimensions;
    groupDomain: string[];
    innerDomain: string[];
    valueDomain: [number, number];
    groupScale: any;
    innerScale: any;
    valueScale: any;
    transform: string;
    colors: ColorHelper;
    margin: number[];
    xAxisHeight: number;
    yAxisWidth: number;
    legendOptions: LegendOptions;
    dataLabelMaxHeight: any;
    isSSR: boolean;
    barOrientation: typeof BarOrientation;
    ngOnInit(): void;
    update(): void;
    onDataLabelMaxHeightChanged(event: any, groupIndex: number): void;
    getGroupScale(): any;
    getInnerScale(): any;
    getValueScale(): any;
    getGroupDomain(): string[];
    getInnerDomain(): string[];
    getValueDomain(): [number, number];
    groupTransform(group: DataItem): string;
    onClick(data: any, group?: DataItem): void;
    trackBy: TrackByFunction<DataItem>;
    setColors(): void;
    getLegendOptions(): LegendOptions;
    updateYAxisWidth({ width }: {
        width: number;
    }): void;
    updateXAxisHeight({ height }: {
        height: number;
    }): void;
    onActivate(event: any, group: DataItem, fromLegend?: boolean): void;
    onDeactivate(event: any, group: DataItem, fromLegend?: boolean): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<BarVertical2DComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<BarVertical2DComponent, "ngx-charts-bar-vertical-2d", never, { "legend": { "alias": "legend"; "required": false; }; "legendTitle": { "alias": "legendTitle"; "required": false; }; "legendPosition": { "alias": "legendPosition"; "required": false; }; "xAxis": { "alias": "xAxis"; "required": false; }; "yAxis": { "alias": "yAxis"; "required": false; }; "showXAxisLabel": { "alias": "showXAxisLabel"; "required": false; }; "showYAxisLabel": { "alias": "showYAxisLabel"; "required": false; }; "xAxisLabel": { "alias": "xAxisLabel"; "required": false; }; "yAxisLabel": { "alias": "yAxisLabel"; "required": false; }; "tooltipDisabled": { "alias": "tooltipDisabled"; "required": false; }; "scaleType": { "alias": "scaleType"; "required": false; }; "gradient": { "alias": "gradient"; "required": false; }; "showGridLines": { "alias": "showGridLines"; "required": false; }; "activeEntries": { "alias": "activeEntries"; "required": false; }; "schemeType": { "alias": "schemeType"; "required": false; }; "trimXAxisTicks": { "alias": "trimXAxisTicks"; "required": false; }; "trimYAxisTicks": { "alias": "trimYAxisTicks"; "required": false; }; "rotateXAxisTicks": { "alias": "rotateXAxisTicks"; "required": false; }; "maxXAxisTickLength": { "alias": "maxXAxisTickLength"; "required": false; }; "maxYAxisTickLength": { "alias": "maxYAxisTickLength"; "required": false; }; "xAxisTickFormatting": { "alias": "xAxisTickFormatting"; "required": false; }; "yAxisTickFormatting": { "alias": "yAxisTickFormatting"; "required": false; }; "xAxisTicks": { "alias": "xAxisTicks"; "required": false; }; "yAxisTicks": { "alias": "yAxisTicks"; "required": false; }; "groupPadding": { "alias": "groupPadding"; "required": false; }; "barPadding": { "alias": "barPadding"; "required": false; }; "roundDomains": { "alias": "roundDomains"; "required": false; }; "roundEdges": { "alias": "roundEdges"; "required": false; }; "yScaleMax": { "alias": "yScaleMax"; "required": false; }; "showDataLabel": { "alias": "showDataLabel"; "required": false; }; "dataLabelFormatting": { "alias": "dataLabelFormatting"; "required": false; }; "noBarWhenZero": { "alias": "noBarWhenZero"; "required": false; }; "wrapTicks": { "alias": "wrapTicks"; "required": false; }; }, { "activate": "activate"; "deactivate": "deactivate"; }, ["tooltipTemplate"], never, false, never>;
}

declare class BarVerticalNormalizedComponent extends BaseChartComponent {
    legend: boolean;
    legendTitle: string;
    legendPosition: LegendPosition;
    xAxis: any;
    yAxis: any;
    showXAxisLabel: boolean;
    showYAxisLabel: boolean;
    xAxisLabel: string;
    yAxisLabel: string;
    tooltipDisabled: boolean;
    gradient: boolean;
    showGridLines: boolean;
    activeEntries: any[];
    schemeType: ScaleType;
    trimXAxisTicks: boolean;
    trimYAxisTicks: boolean;
    rotateXAxisTicks: boolean;
    maxXAxisTickLength: number;
    maxYAxisTickLength: number;
    xAxisTickFormatting: any;
    yAxisTickFormatting: any;
    xAxisTicks: any[];
    yAxisTicks: any[];
    barPadding: number;
    roundDomains: boolean;
    noBarWhenZero: boolean;
    wrapTicks: boolean;
    activate: EventEmitter<any>;
    deactivate: EventEmitter<any>;
    tooltipTemplate: TemplateRef<any>;
    dims: ViewDimensions;
    groupDomain: string[];
    innerDomain: string[];
    valueDomain: [number, number];
    xScale: any;
    yScale: any;
    transform: string;
    colors: ColorHelper;
    margin: number[];
    xAxisHeight: number;
    yAxisWidth: number;
    legendOptions: LegendOptions;
    isSSR: boolean;
    barChartType: typeof BarChartType;
    ngOnInit(): void;
    update(): void;
    getGroupDomain(): string[];
    getInnerDomain(): string[];
    getXScale(): any;
    getYScale(): any;
    groupTransform(group: Series): string;
    onClick(data: any, group?: Series): void;
    trackBy: TrackByFunction<Series>;
    setColors(): void;
    getLegendOptions(): LegendOptions;
    updateYAxisWidth({ width }: {
        width: number;
    }): void;
    updateXAxisHeight({ height }: {
        height: number;
    }): void;
    onActivate(event: any, group: Series, fromLegend?: boolean): void;
    onDeactivate(event: any, group: Series, fromLegend?: boolean): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<BarVerticalNormalizedComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<BarVerticalNormalizedComponent, "ngx-charts-bar-vertical-normalized", never, { "legend": { "alias": "legend"; "required": false; }; "legendTitle": { "alias": "legendTitle"; "required": false; }; "legendPosition": { "alias": "legendPosition"; "required": false; }; "xAxis": { "alias": "xAxis"; "required": false; }; "yAxis": { "alias": "yAxis"; "required": false; }; "showXAxisLabel": { "alias": "showXAxisLabel"; "required": false; }; "showYAxisLabel": { "alias": "showYAxisLabel"; "required": false; }; "xAxisLabel": { "alias": "xAxisLabel"; "required": false; }; "yAxisLabel": { "alias": "yAxisLabel"; "required": false; }; "tooltipDisabled": { "alias": "tooltipDisabled"; "required": false; }; "gradient": { "alias": "gradient"; "required": false; }; "showGridLines": { "alias": "showGridLines"; "required": false; }; "activeEntries": { "alias": "activeEntries"; "required": false; }; "schemeType": { "alias": "schemeType"; "required": false; }; "trimXAxisTicks": { "alias": "trimXAxisTicks"; "required": false; }; "trimYAxisTicks": { "alias": "trimYAxisTicks"; "required": false; }; "rotateXAxisTicks": { "alias": "rotateXAxisTicks"; "required": false; }; "maxXAxisTickLength": { "alias": "maxXAxisTickLength"; "required": false; }; "maxYAxisTickLength": { "alias": "maxYAxisTickLength"; "required": false; }; "xAxisTickFormatting": { "alias": "xAxisTickFormatting"; "required": false; }; "yAxisTickFormatting": { "alias": "yAxisTickFormatting"; "required": false; }; "xAxisTicks": { "alias": "xAxisTicks"; "required": false; }; "yAxisTicks": { "alias": "yAxisTicks"; "required": false; }; "barPadding": { "alias": "barPadding"; "required": false; }; "roundDomains": { "alias": "roundDomains"; "required": false; }; "noBarWhenZero": { "alias": "noBarWhenZero"; "required": false; }; "wrapTicks": { "alias": "wrapTicks"; "required": false; }; }, { "activate": "activate"; "deactivate": "deactivate"; }, ["tooltipTemplate"], never, false, never>;
}

declare class BarVerticalStackedComponent extends BaseChartComponent {
    legend: boolean;
    legendTitle: string;
    legendPosition: LegendPosition;
    xAxis: any;
    yAxis: any;
    showXAxisLabel: boolean;
    showYAxisLabel: boolean;
    xAxisLabel: string;
    yAxisLabel: string;
    tooltipDisabled: boolean;
    gradient: boolean;
    showGridLines: boolean;
    activeEntries: any[];
    schemeType: ScaleType;
    trimXAxisTicks: boolean;
    trimYAxisTicks: boolean;
    rotateXAxisTicks: boolean;
    maxXAxisTickLength: number;
    maxYAxisTickLength: number;
    xAxisTickFormatting: any;
    yAxisTickFormatting: any;
    xAxisTicks: any[];
    yAxisTicks: any[];
    barPadding: number;
    roundDomains: boolean;
    yScaleMax: number;
    showDataLabel: boolean;
    dataLabelFormatting: any;
    noBarWhenZero: boolean;
    wrapTicks: boolean;
    activate: EventEmitter<any>;
    deactivate: EventEmitter<any>;
    tooltipTemplate: TemplateRef<any>;
    dims: ViewDimensions;
    groupDomain: string[];
    innerDomain: string[];
    valueDomain: [number, number];
    xScale: any;
    yScale: any;
    transform: string;
    tickFormatting: (label: string) => string;
    colors: ColorHelper;
    margin: number[];
    xAxisHeight: number;
    yAxisWidth: number;
    legendOptions: LegendOptions;
    dataLabelMaxHeight: any;
    isSSR: boolean;
    barChartType: typeof BarChartType;
    ngOnInit(): void;
    ngOnChanges(): void;
    update(): void;
    getGroupDomain(): string[];
    getInnerDomain(): string[];
    getValueDomain(): [number, number];
    getXScale(): any;
    getYScale(): any;
    onDataLabelMaxHeightChanged(event: any, groupIndex: number): void;
    groupTransform(group: Series): string;
    onClick(data: any, group?: Series): void;
    trackBy: TrackByFunction<Series>;
    setColors(): void;
    getLegendOptions(): LegendOptions;
    updateYAxisWidth({ width }: {
        width: number;
    }): void;
    updateXAxisHeight({ height }: {
        height: number;
    }): void;
    onActivate(event: any, group: any, fromLegend?: boolean): void;
    onDeactivate(event: any, group: Series, fromLegend?: boolean): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<BarVerticalStackedComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<BarVerticalStackedComponent, "ngx-charts-bar-vertical-stacked", never, { "legend": { "alias": "legend"; "required": false; }; "legendTitle": { "alias": "legendTitle"; "required": false; }; "legendPosition": { "alias": "legendPosition"; "required": false; }; "xAxis": { "alias": "xAxis"; "required": false; }; "yAxis": { "alias": "yAxis"; "required": false; }; "showXAxisLabel": { "alias": "showXAxisLabel"; "required": false; }; "showYAxisLabel": { "alias": "showYAxisLabel"; "required": false; }; "xAxisLabel": { "alias": "xAxisLabel"; "required": false; }; "yAxisLabel": { "alias": "yAxisLabel"; "required": false; }; "tooltipDisabled": { "alias": "tooltipDisabled"; "required": false; }; "gradient": { "alias": "gradient"; "required": false; }; "showGridLines": { "alias": "showGridLines"; "required": false; }; "activeEntries": { "alias": "activeEntries"; "required": false; }; "schemeType": { "alias": "schemeType"; "required": false; }; "trimXAxisTicks": { "alias": "trimXAxisTicks"; "required": false; }; "trimYAxisTicks": { "alias": "trimYAxisTicks"; "required": false; }; "rotateXAxisTicks": { "alias": "rotateXAxisTicks"; "required": false; }; "maxXAxisTickLength": { "alias": "maxXAxisTickLength"; "required": false; }; "maxYAxisTickLength": { "alias": "maxYAxisTickLength"; "required": false; }; "xAxisTickFormatting": { "alias": "xAxisTickFormatting"; "required": false; }; "yAxisTickFormatting": { "alias": "yAxisTickFormatting"; "required": false; }; "xAxisTicks": { "alias": "xAxisTicks"; "required": false; }; "yAxisTicks": { "alias": "yAxisTicks"; "required": false; }; "barPadding": { "alias": "barPadding"; "required": false; }; "roundDomains": { "alias": "roundDomains"; "required": false; }; "yScaleMax": { "alias": "yScaleMax"; "required": false; }; "showDataLabel": { "alias": "showDataLabel"; "required": false; }; "dataLabelFormatting": { "alias": "dataLabelFormatting"; "required": false; }; "noBarWhenZero": { "alias": "noBarWhenZero"; "required": false; }; "wrapTicks": { "alias": "wrapTicks"; "required": false; }; }, { "activate": "activate"; "deactivate": "deactivate"; }, ["tooltipTemplate"], never, false, never>;
}

declare class BarLabelComponent implements OnChanges {
    value: any;
    valueFormatting: any;
    barX: any;
    barY: any;
    barWidth: any;
    barHeight: any;
    orientation: BarOrientation;
    dimensionsChanged: EventEmitter<any>;
    element: any;
    x: number;
    y: number;
    horizontalPadding: number;
    verticalPadding: number;
    formatedValue: string;
    transform: string;
    textAnchor: string;
    constructor(element: ElementRef);
    ngOnChanges(changes: SimpleChanges): void;
    getSize(): any;
    ngAfterViewInit(): void;
    update(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<BarLabelComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<BarLabelComponent, "g[ngx-charts-bar-label]", never, { "value": { "alias": "value"; "required": false; }; "valueFormatting": { "alias": "valueFormatting"; "required": false; }; "barX": { "alias": "barX"; "required": false; }; "barY": { "alias": "barY"; "required": false; }; "barWidth": { "alias": "barWidth"; "required": false; }; "barHeight": { "alias": "barHeight"; "required": false; }; "orientation": { "alias": "orientation"; "required": false; }; }, { "dimensionsChanged": "dimensionsChanged"; }, never, never, false, never>;
}

interface Bar {
    ariaLabel: string;
    color: string;
    data: DataItem;
    formattedLabel: string;
    gradientStops: Gradient[];
    height: number;
    label: string;
    roundEdges: boolean;
    tooltipText: string;
    value: number;
    width: number;
    x: number;
    y: number;
}

declare class SeriesHorizontal implements OnChanges {
    dims: ViewDimensions;
    type: BarChartType;
    series: DataItem[];
    xScale: any;
    yScale: any;
    colors: ColorHelper;
    tooltipDisabled: boolean;
    gradient: boolean;
    activeEntries: DataItem[];
    seriesName: StringOrNumberOrDate;
    tooltipTemplate: TemplateRef<any>;
    roundEdges: boolean;
    animations: boolean;
    showDataLabel: boolean;
    dataLabelFormatting: any;
    noBarWhenZero: boolean;
    select: EventEmitter<DataItem>;
    activate: EventEmitter<any>;
    deactivate: EventEmitter<any>;
    dataLabelWidthChanged: EventEmitter<{
        size: Event;
        index: number;
    }>;
    tooltipPlacement: PlacementTypes;
    tooltipType: StyleTypes;
    bars: Bar[];
    barsForDataLabels: Array<{
        x: number;
        y: number;
        width: number;
        height: number;
        total: number;
        series: string;
    }>;
    barOrientation: typeof BarOrientation;
    ngOnChanges(): void;
    update(): void;
    updateDataLabels(): void;
    updateTooltipSettings(): void;
    isActive(entry: DataItem): boolean;
    getLabel(dataItem: DataItem): StringOrNumberOrDate;
    trackBy(index: number, bar: Bar): string;
    trackDataLabelBy(index: number, barLabel: any): string;
    click(data: DataItem): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<SeriesHorizontal, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<SeriesHorizontal, "g[ngx-charts-series-horizontal]", never, { "dims": { "alias": "dims"; "required": false; }; "type": { "alias": "type"; "required": false; }; "series": { "alias": "series"; "required": false; }; "xScale": { "alias": "xScale"; "required": false; }; "yScale": { "alias": "yScale"; "required": false; }; "colors": { "alias": "colors"; "required": false; }; "tooltipDisabled": { "alias": "tooltipDisabled"; "required": false; }; "gradient": { "alias": "gradient"; "required": false; }; "activeEntries": { "alias": "activeEntries"; "required": false; }; "seriesName": { "alias": "seriesName"; "required": false; }; "tooltipTemplate": { "alias": "tooltipTemplate"; "required": false; }; "roundEdges": { "alias": "roundEdges"; "required": false; }; "animations": { "alias": "animations"; "required": false; }; "showDataLabel": { "alias": "showDataLabel"; "required": false; }; "dataLabelFormatting": { "alias": "dataLabelFormatting"; "required": false; }; "noBarWhenZero": { "alias": "noBarWhenZero"; "required": false; }; }, { "select": "select"; "activate": "activate"; "deactivate": "deactivate"; "dataLabelWidthChanged": "dataLabelWidthChanged"; }, never, never, false, never>;
}

declare class SeriesVerticalComponent implements OnChanges {
    private platformId;
    dims: ViewDimensions;
    type: BarChartType;
    series: DataItem[];
    xScale: any;
    yScale: any;
    colors: ColorHelper;
    gradient: boolean;
    activeEntries: DataItem[];
    seriesName: StringOrNumberOrDate;
    tooltipDisabled: boolean;
    tooltipTemplate: TemplateRef<any>;
    roundEdges: boolean;
    animations: boolean;
    showDataLabel: boolean;
    dataLabelFormatting: any;
    noBarWhenZero: boolean;
    select: EventEmitter<DataItem>;
    activate: EventEmitter<any>;
    deactivate: EventEmitter<any>;
    dataLabelHeightChanged: EventEmitter<any>;
    tooltipPlacement: PlacementTypes;
    tooltipType: StyleTypes;
    bars: Bar[];
    barsForDataLabels: Array<{
        x: number;
        y: number;
        width: number;
        height: number;
        total: number;
        series: string;
    }>;
    barOrientation: typeof BarOrientation;
    isSSR: boolean;
    constructor(platformId: any);
    ngOnInit(): void;
    ngOnChanges(): void;
    update(): void;
    updateDataLabels(): void;
    updateTooltipSettings(): void;
    isActive(entry: DataItem): boolean;
    onClick(data: DataItem): void;
    getLabel(dataItem: DataItem): StringOrNumberOrDate;
    trackBy(index: number, bar: Bar): string;
    trackDataLabelBy(index: number, barLabel: any): string;
    static ɵfac: i0.ɵɵFactoryDeclaration<SeriesVerticalComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<SeriesVerticalComponent, "g[ngx-charts-series-vertical]", never, { "dims": { "alias": "dims"; "required": false; }; "type": { "alias": "type"; "required": false; }; "series": { "alias": "series"; "required": false; }; "xScale": { "alias": "xScale"; "required": false; }; "yScale": { "alias": "yScale"; "required": false; }; "colors": { "alias": "colors"; "required": false; }; "gradient": { "alias": "gradient"; "required": false; }; "activeEntries": { "alias": "activeEntries"; "required": false; }; "seriesName": { "alias": "seriesName"; "required": false; }; "tooltipDisabled": { "alias": "tooltipDisabled"; "required": false; }; "tooltipTemplate": { "alias": "tooltipTemplate"; "required": false; }; "roundEdges": { "alias": "roundEdges"; "required": false; }; "animations": { "alias": "animations"; "required": false; }; "showDataLabel": { "alias": "showDataLabel"; "required": false; }; "dataLabelFormatting": { "alias": "dataLabelFormatting"; "required": false; }; "noBarWhenZero": { "alias": "noBarWhenZero"; "required": false; }; }, { "select": "select"; "activate": "activate"; "deactivate": "deactivate"; "dataLabelHeightChanged": "dataLabelHeightChanged"; }, never, never, false, never>;
}

declare class BarChartModule {
    static ɵfac: i0.ɵɵFactoryDeclaration<BarChartModule, never>;
    static ɵmod: i0.ɵɵNgModuleDeclaration<BarChartModule, [typeof BarComponent, typeof BarHorizontalComponent, typeof BarHorizontal2DComponent, typeof BarHorizontalNormalizedComponent, typeof BarHorizontalStackedComponent, typeof BarVerticalComponent, typeof BarVertical2DComponent, typeof BarVerticalNormalizedComponent, typeof BarVerticalStackedComponent, typeof BarLabelComponent, typeof SeriesHorizontal, typeof SeriesVerticalComponent], [typeof ChartCommonModule], [typeof BarComponent, typeof BarHorizontalComponent, typeof BarHorizontal2DComponent, typeof BarHorizontalNormalizedComponent, typeof BarHorizontalStackedComponent, typeof BarVerticalComponent, typeof BarVertical2DComponent, typeof BarVerticalNormalizedComponent, typeof BarVerticalStackedComponent, typeof BarLabelComponent, typeof SeriesHorizontal, typeof SeriesVerticalComponent]>;
    static ɵinj: i0.ɵɵInjectorDeclaration<BarChartModule>;
}

declare class BoxChartComponent extends BaseChartComponent {
    /** Show or hide the legend. */
    legend: boolean;
    legendPosition: LegendPosition;
    legendTitle: string;
    /** I think it is better to handle legend options as single Input object of type ILegendOptions */
    legendOptionsConfig: LegendOptions;
    showGridLines: boolean;
    xAxis: boolean;
    yAxis: boolean;
    showXAxisLabel: boolean;
    showYAxisLabel: boolean;
    roundDomains: boolean;
    xAxisLabel: string;
    yAxisLabel: string;
    roundEdges: boolean;
    strokeColor: string;
    strokeWidth: number;
    tooltipDisabled: boolean;
    gradient: boolean;
    wrapTicks: boolean;
    select: EventEmitter<IBoxModel>;
    activate: EventEmitter<IBoxModel>;
    deactivate: EventEmitter<IBoxModel>;
    tooltipTemplate: TemplateRef<any>;
    /** Input Data, this came from Base Chart Component. */
    results: BoxChartMultiSeries;
    /** Chart Dimensions, this came from Base Chart Component. */
    dims: ViewDimensions;
    /** Color data. */
    colors: ColorHelper;
    /** Transform string css attribute for the chart container */
    transform: string;
    /** Chart Margins (For each side, counterclock wise). */
    margin: [number, number, number, number];
    /** Legend Options object to handle positioning, title, colors and domain. */
    legendOptions: LegendOptions;
    xScale: ScaleBand<string>;
    yScale: ScaleLinear<number, number>;
    xDomain: StringOrNumberOrDate[];
    yDomain: number[];
    seriesDomain: string[];
    /** Chart X axis dimension. */
    xAxisHeight: number;
    /** Chart Y axis dimension. */
    yAxisWidth: number;
    ngOnChanges(): void;
    trackBy(index: number, item: BoxChartSeries): StringOrNumberOrDate;
    update(): void;
    setColors(): void;
    setScales(): void;
    getXScale(domain: Array<string | number | Date>, width: number): ScaleBand<string>;
    getYScale(domain: number[], height: number): ScaleLinear<number, number>;
    getUniqueBoxChartXDomainValues(results: BoxChartMultiSeries): (string | number | Date)[];
    getXDomain(): Array<string | number | Date>;
    getYDomain(): number[];
    getSeriesDomain(): string[];
    updateYAxisWidth({ width }: {
        width: any;
    }): void;
    updateXAxisHeight({ height }: {
        height: any;
    }): void;
    onClick(data: IBoxModel): void;
    onActivate(data: IBoxModel): void;
    onDeactivate(data: IBoxModel): void;
    private getLegendOptions;
    static ɵfac: i0.ɵɵFactoryDeclaration<BoxChartComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<BoxChartComponent, "ngx-charts-box-chart", never, { "legend": { "alias": "legend"; "required": false; }; "legendPosition": { "alias": "legendPosition"; "required": false; }; "legendTitle": { "alias": "legendTitle"; "required": false; }; "legendOptionsConfig": { "alias": "legendOptionsConfig"; "required": false; }; "showGridLines": { "alias": "showGridLines"; "required": false; }; "xAxis": { "alias": "xAxis"; "required": false; }; "yAxis": { "alias": "yAxis"; "required": false; }; "showXAxisLabel": { "alias": "showXAxisLabel"; "required": false; }; "showYAxisLabel": { "alias": "showYAxisLabel"; "required": false; }; "roundDomains": { "alias": "roundDomains"; "required": false; }; "xAxisLabel": { "alias": "xAxisLabel"; "required": false; }; "yAxisLabel": { "alias": "yAxisLabel"; "required": false; }; "roundEdges": { "alias": "roundEdges"; "required": false; }; "strokeColor": { "alias": "strokeColor"; "required": false; }; "strokeWidth": { "alias": "strokeWidth"; "required": false; }; "tooltipDisabled": { "alias": "tooltipDisabled"; "required": false; }; "gradient": { "alias": "gradient"; "required": false; }; "wrapTicks": { "alias": "wrapTicks"; "required": false; }; }, { "select": "select"; "activate": "activate"; "deactivate": "deactivate"; }, ["tooltipTemplate"], never, false, never>;
}

declare class BoxSeriesComponent implements OnChanges {
    dims: ViewDimensions;
    series: BoxChartSeries;
    xScale: ScaleBand<string>;
    yScale: ScaleLinear<number, number>;
    colors: ColorHelper;
    animations: boolean;
    strokeColor: string;
    strokeWidth: number;
    tooltipDisabled: boolean;
    tooltipTemplate: TemplateRef<any>;
    tooltipPlacement: PlacementTypes;
    tooltipType: StyleTypes;
    roundEdges: boolean;
    gradient: boolean;
    select: EventEmitter<IBoxModel>;
    activate: EventEmitter<IBoxModel>;
    deactivate: EventEmitter<IBoxModel>;
    box: IBoxModel;
    counts: DataItem[];
    quartiles: [number, number, number];
    whiskers: [number, number];
    lineCoordinates: [IVector2D, IVector2D, IVector2D, IVector2D];
    tooltipTitle: string;
    ngOnChanges(changes: SimpleChanges): void;
    onClick(data: IBoxModel): void;
    update(): void;
    getBoxQuantiles(inputData: Array<number | Date>): [number, number, number];
    getLinesCoordinates(seriesName: string, whiskers: [number, number], quartiles: [number, number, number], barWidth: number): [IVector2D, IVector2D, IVector2D, IVector2D];
    updateTooltipSettings(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<BoxSeriesComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<BoxSeriesComponent, "g[ngx-charts-box-series]", never, { "dims": { "alias": "dims"; "required": false; }; "series": { "alias": "series"; "required": false; }; "xScale": { "alias": "xScale"; "required": false; }; "yScale": { "alias": "yScale"; "required": false; }; "colors": { "alias": "colors"; "required": false; }; "animations": { "alias": "animations"; "required": false; }; "strokeColor": { "alias": "strokeColor"; "required": false; }; "strokeWidth": { "alias": "strokeWidth"; "required": false; }; "tooltipDisabled": { "alias": "tooltipDisabled"; "required": false; }; "tooltipTemplate": { "alias": "tooltipTemplate"; "required": false; }; "tooltipPlacement": { "alias": "tooltipPlacement"; "required": false; }; "tooltipType": { "alias": "tooltipType"; "required": false; }; "roundEdges": { "alias": "roundEdges"; "required": false; }; "gradient": { "alias": "gradient"; "required": false; }; }, { "select": "select"; "activate": "activate"; "deactivate": "deactivate"; }, never, never, false, never>;
}

type LineCoordinates = [IVector2D, IVector2D, IVector2D, IVector2D];
declare function clonePoint(original: IPoint): IPoint;
declare function cloneVector2d(original: IVector2D): IVector2D;
declare function cloneLineCoordinates(original: LineCoordinates): LineCoordinates;
declare class BoxComponent implements OnChanges {
    protected cd: ChangeDetectorRef;
    strokeColor: string;
    strokeWidth: number;
    fill: string;
    data: IBoxModel;
    width: number;
    height: number;
    x: number;
    y: number;
    lineCoordinates: LineCoordinates;
    roundEdges: boolean;
    gradient: boolean;
    gradientStops: Gradient[];
    offset: number;
    isActive: boolean;
    animations: boolean;
    ariaLabel: string;
    noBarWhenZero: boolean;
    select: EventEmitter<IBoxModel>;
    activate: EventEmitter<IBoxModel>;
    deactivate: EventEmitter<IBoxModel>;
    BarOrientation: typeof BarOrientation;
    nativeElm: any;
    oldPath: string;
    boxPath: string;
    oldLineCoordinates: LineCoordinates;
    gradientId: string;
    gradientFill: string;
    initialized: boolean;
    hasGradient: boolean;
    hideBar: boolean;
    /** Mask Path to cut the line on the box part. */
    maskLine: string;
    /** Mask Path Id to keep track of the mask element */
    maskLineId: string;
    boxStrokeWidth: number;
    whiskerStrokeWidth: number;
    medianLineWidth: number;
    constructor(element: ElementRef, cd: ChangeDetectorRef);
    ngOnChanges(changes: SimpleChanges): void;
    update(): void;
    loadAnimation(): void;
    updatePathEl(): void;
    updateLineEl(): void;
    /**
     * See [D3 Selections](https://www.d3indepth.com/selections/)
     * @param d The joined data.
     * @param index The index of the element within the selection
     * @param node The node element (Line).
     */
    lineTween(attr: string, d: any, index: number, node: BaseType[] | ArrayLike<BaseType>): any;
    pathTween(d1: string, precision: number): () => (t: any) => string;
    getStartingPath(): string;
    getPath(): string;
    getStartingLineCoordinates(): LineCoordinates;
    getRadius(): number;
    getGradient(): Gradient[];
    getStartOpacity(): number;
    get edges(): boolean[];
    onMouseEnter(): void;
    onMouseLeave(): void;
    private checkToHideBar;
    static ɵfac: i0.ɵɵFactoryDeclaration<BoxComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<BoxComponent, "g[ngx-charts-box]", never, { "strokeColor": { "alias": "strokeColor"; "required": false; }; "strokeWidth": { "alias": "strokeWidth"; "required": false; }; "fill": { "alias": "fill"; "required": false; }; "data": { "alias": "data"; "required": false; }; "width": { "alias": "width"; "required": false; }; "height": { "alias": "height"; "required": false; }; "x": { "alias": "x"; "required": false; }; "y": { "alias": "y"; "required": false; }; "lineCoordinates": { "alias": "lineCoordinates"; "required": false; }; "roundEdges": { "alias": "roundEdges"; "required": false; }; "gradient": { "alias": "gradient"; "required": false; }; "gradientStops": { "alias": "gradientStops"; "required": false; }; "offset": { "alias": "offset"; "required": false; }; "isActive": { "alias": "isActive"; "required": false; }; "animations": { "alias": "animations"; "required": false; }; "ariaLabel": { "alias": "ariaLabel"; "required": false; }; "noBarWhenZero": { "alias": "noBarWhenZero"; "required": false; }; }, { "select": "select"; "activate": "activate"; "deactivate": "deactivate"; }, never, never, false, never>;
}

declare class BoxChartModule {
    static ɵfac: i0.ɵɵFactoryDeclaration<BoxChartModule, never>;
    static ɵmod: i0.ɵɵNgModuleDeclaration<BoxChartModule, [typeof BoxChartComponent, typeof BoxSeriesComponent, typeof BoxComponent], [typeof ChartCommonModule], [typeof BoxChartComponent, typeof BoxSeriesComponent, typeof BoxComponent]>;
    static ɵinj: i0.ɵɵInjectorDeclaration<BoxChartModule>;
}

declare class BubbleChartComponent extends BaseChartComponent {
    showGridLines: boolean;
    legend: boolean;
    legendTitle: string;
    legendPosition: LegendPosition;
    xAxis: boolean;
    yAxis: boolean;
    showXAxisLabel: boolean;
    showYAxisLabel: boolean;
    xAxisLabel: string;
    yAxisLabel: string;
    trimXAxisTicks: boolean;
    trimYAxisTicks: boolean;
    rotateXAxisTicks: boolean;
    maxXAxisTickLength: number;
    maxYAxisTickLength: number;
    xAxisTickFormatting: any;
    yAxisTickFormatting: any;
    xAxisTicks: any[];
    yAxisTicks: any[];
    roundDomains: boolean;
    maxRadius: number;
    minRadius: number;
    autoScale: boolean;
    schemeType: ScaleType;
    tooltipDisabled: boolean;
    xScaleMin: number;
    xScaleMax: number;
    yScaleMin: number;
    yScaleMax: number;
    wrapTicks: boolean;
    activate: EventEmitter<any>;
    deactivate: EventEmitter<any>;
    tooltipTemplate: TemplateRef<any>;
    dims: ViewDimensions;
    colors: ColorHelper;
    scaleType: ScaleType;
    margin: number[];
    bubblePadding: number[];
    data: BubbleChartSeries[];
    legendOptions: LegendOptions;
    transform: string;
    clipPath: string;
    clipPathId: string;
    seriesDomain: number[];
    xDomain: number[];
    yDomain: number[];
    rDomain: number[];
    xScaleType: ScaleType;
    yScaleType: ScaleType;
    yScale: any;
    xScale: any;
    rScale: any;
    xAxisHeight: number;
    yAxisWidth: number;
    activeEntries: any[];
    isSSR: boolean;
    ngOnInit(): void;
    ngOnChanges(): void;
    update(): void;
    hideCircles(): void;
    onClick(data: any, series?: any): void;
    getBubblePadding(): number[];
    setScales(): void;
    getYScale(domain: any, height: number): any;
    getXScale(domain: any, width: number): any;
    getRScale(domain: any, range: any): any;
    getLegendOptions(): LegendOptions;
    getXDomain(): number[];
    getYDomain(): number[];
    getRDomain(): [number, number];
    updateYAxisWidth({ width }: {
        width: number;
    }): void;
    updateXAxisHeight({ height }: {
        height: number;
    }): void;
    onActivate(item: any): void;
    onDeactivate(item: any): void;
    deactivateAll(): void;
    trackBy(index: number, item: any): string;
    static ɵfac: i0.ɵɵFactoryDeclaration<BubbleChartComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<BubbleChartComponent, "ngx-charts-bubble-chart", never, { "showGridLines": { "alias": "showGridLines"; "required": false; }; "legend": { "alias": "legend"; "required": false; }; "legendTitle": { "alias": "legendTitle"; "required": false; }; "legendPosition": { "alias": "legendPosition"; "required": false; }; "xAxis": { "alias": "xAxis"; "required": false; }; "yAxis": { "alias": "yAxis"; "required": false; }; "showXAxisLabel": { "alias": "showXAxisLabel"; "required": false; }; "showYAxisLabel": { "alias": "showYAxisLabel"; "required": false; }; "xAxisLabel": { "alias": "xAxisLabel"; "required": false; }; "yAxisLabel": { "alias": "yAxisLabel"; "required": false; }; "trimXAxisTicks": { "alias": "trimXAxisTicks"; "required": false; }; "trimYAxisTicks": { "alias": "trimYAxisTicks"; "required": false; }; "rotateXAxisTicks": { "alias": "rotateXAxisTicks"; "required": false; }; "maxXAxisTickLength": { "alias": "maxXAxisTickLength"; "required": false; }; "maxYAxisTickLength": { "alias": "maxYAxisTickLength"; "required": false; }; "xAxisTickFormatting": { "alias": "xAxisTickFormatting"; "required": false; }; "yAxisTickFormatting": { "alias": "yAxisTickFormatting"; "required": false; }; "xAxisTicks": { "alias": "xAxisTicks"; "required": false; }; "yAxisTicks": { "alias": "yAxisTicks"; "required": false; }; "roundDomains": { "alias": "roundDomains"; "required": false; }; "maxRadius": { "alias": "maxRadius"; "required": false; }; "minRadius": { "alias": "minRadius"; "required": false; }; "autoScale": { "alias": "autoScale"; "required": false; }; "schemeType": { "alias": "schemeType"; "required": false; }; "tooltipDisabled": { "alias": "tooltipDisabled"; "required": false; }; "xScaleMin": { "alias": "xScaleMin"; "required": false; }; "xScaleMax": { "alias": "xScaleMax"; "required": false; }; "yScaleMin": { "alias": "yScaleMin"; "required": false; }; "yScaleMax": { "alias": "yScaleMax"; "required": false; }; "wrapTicks": { "alias": "wrapTicks"; "required": false; }; }, { "activate": "activate"; "deactivate": "deactivate"; }, ["tooltipTemplate"], never, false, never>;
}

declare class BubbleSeriesComponent implements OnChanges, OnInit {
    private platformId;
    data: BubbleChartSeries;
    xScale: any;
    yScale: any;
    rScale: any;
    xScaleType: ScaleType;
    yScaleType: ScaleType;
    colors: ColorHelper;
    visibleValue: any;
    activeEntries: any[];
    xAxisLabel: string;
    yAxisLabel: string;
    tooltipDisabled: boolean;
    tooltipTemplate: TemplateRef<any>;
    select: EventEmitter<any>;
    activate: EventEmitter<any>;
    deactivate: EventEmitter<any>;
    areaPath: any;
    circles: any[];
    placementTypes: typeof PlacementTypes;
    styleTypes: typeof StyleTypes;
    isSSR: boolean;
    constructor(platformId: any);
    ngOnInit(): void;
    ngOnChanges(changes: SimpleChanges): void;
    update(): void;
    getCircles(): any[];
    getTooltipText(circle: any): string;
    onClick(data: any): void;
    isActive(entry: any): boolean;
    isVisible(circle: any): boolean;
    activateCircle(circle: any): void;
    deactivateCircle(circle: any): void;
    trackBy(index: any, circle: any): string;
    static ɵfac: i0.ɵɵFactoryDeclaration<BubbleSeriesComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<BubbleSeriesComponent, "g[ngx-charts-bubble-series]", never, { "data": { "alias": "data"; "required": false; }; "xScale": { "alias": "xScale"; "required": false; }; "yScale": { "alias": "yScale"; "required": false; }; "rScale": { "alias": "rScale"; "required": false; }; "xScaleType": { "alias": "xScaleType"; "required": false; }; "yScaleType": { "alias": "yScaleType"; "required": false; }; "colors": { "alias": "colors"; "required": false; }; "visibleValue": { "alias": "visibleValue"; "required": false; }; "activeEntries": { "alias": "activeEntries"; "required": false; }; "xAxisLabel": { "alias": "xAxisLabel"; "required": false; }; "yAxisLabel": { "alias": "yAxisLabel"; "required": false; }; "tooltipDisabled": { "alias": "tooltipDisabled"; "required": false; }; "tooltipTemplate": { "alias": "tooltipTemplate"; "required": false; }; }, { "select": "select"; "activate": "activate"; "deactivate": "deactivate"; }, never, never, false, never>;
}

declare class BubbleChartModule {
    static ɵfac: i0.ɵɵFactoryDeclaration<BubbleChartModule, never>;
    static ɵmod: i0.ɵɵNgModuleDeclaration<BubbleChartModule, [typeof BubbleChartComponent, typeof BubbleSeriesComponent], [typeof ChartCommonModule], [typeof BubbleChartComponent, typeof BubbleSeriesComponent]>;
    static ɵinj: i0.ɵɵInjectorDeclaration<BubbleChartModule>;
}

declare class HeatMapCellComponent implements OnChanges {
    fill: string;
    x: number;
    y: number;
    width: number;
    height: number;
    data: number;
    gradient: boolean;
    animations: boolean;
    select: EventEmitter<number>;
    activate: EventEmitter<number>;
    deactivate: EventEmitter<number>;
    element: HTMLElement;
    transform: string;
    startOpacity: number;
    gradientId: string;
    gradientUrl: string;
    gradientStops: Gradient[];
    barOrientation: typeof BarOrientation;
    constructor(element: ElementRef);
    ngOnChanges(changes: SimpleChanges): void;
    getGradientStops(): Gradient[];
    loadAnimation(): void;
    animateToCurrentForm(): void;
    onClick(): void;
    onMouseEnter(): void;
    onMouseLeave(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<HeatMapCellComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<HeatMapCellComponent, "g[ngx-charts-heat-map-cell]", never, { "fill": { "alias": "fill"; "required": false; }; "x": { "alias": "x"; "required": false; }; "y": { "alias": "y"; "required": false; }; "width": { "alias": "width"; "required": false; }; "height": { "alias": "height"; "required": false; }; "data": { "alias": "data"; "required": false; }; "gradient": { "alias": "gradient"; "required": false; }; "animations": { "alias": "animations"; "required": false; }; }, { "select": "select"; "activate": "activate"; "deactivate": "deactivate"; }, never, never, false, never>;
}

interface Cell {
    cell: DataItem;
    data: number;
    fill: string;
    height: number;
    label: string;
    row: Series;
    series: string;
    width: number;
    x: number;
    y: number;
}
declare class HeatCellSeriesComponent implements OnChanges, OnInit {
    data: any;
    colors: any;
    xScale: any;
    yScale: any;
    gradient: boolean;
    tooltipDisabled: boolean;
    tooltipText: any;
    tooltipTemplate: TemplateRef<any>;
    animations: boolean;
    select: EventEmitter<DataItem>;
    activate: EventEmitter<DataItem>;
    deactivate: EventEmitter<DataItem>;
    cells: Cell[];
    placementTypes: typeof PlacementTypes;
    styleTypes: typeof StyleTypes;
    ngOnInit(): void;
    ngOnChanges(changes: SimpleChanges): void;
    update(): void;
    getCells(): Cell[];
    getTooltipText({ label, data, series }: {
        label: string;
        data: number;
        series: string;
    }): string;
    trackBy(index: number, item: any): string;
    onClick(data: any): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<HeatCellSeriesComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<HeatCellSeriesComponent, "g[ngx-charts-heat-map-cell-series]", never, { "data": { "alias": "data"; "required": false; }; "colors": { "alias": "colors"; "required": false; }; "xScale": { "alias": "xScale"; "required": false; }; "yScale": { "alias": "yScale"; "required": false; }; "gradient": { "alias": "gradient"; "required": false; }; "tooltipDisabled": { "alias": "tooltipDisabled"; "required": false; }; "tooltipText": { "alias": "tooltipText"; "required": false; }; "tooltipTemplate": { "alias": "tooltipTemplate"; "required": false; }; "animations": { "alias": "animations"; "required": false; }; }, { "select": "select"; "activate": "activate"; "deactivate": "deactivate"; }, never, never, false, never>;
}

interface RectItem$1 {
    fill: string;
    height: number;
    rx: number;
    width: number;
    x: number;
    y: number;
}
declare class HeatMapComponent extends BaseChartComponent {
    legend: boolean;
    legendTitle: string;
    legendPosition: LegendPosition;
    xAxis: boolean;
    yAxis: boolean;
    showXAxisLabel: boolean;
    showYAxisLabel: boolean;
    xAxisLabel: string;
    yAxisLabel: string;
    gradient: boolean;
    innerPadding: number | number[] | string | string[];
    trimXAxisTicks: boolean;
    trimYAxisTicks: boolean;
    rotateXAxisTicks: boolean;
    maxXAxisTickLength: number;
    maxYAxisTickLength: number;
    xAxisTickFormatting: any;
    yAxisTickFormatting: any;
    xAxisTicks: any[];
    yAxisTicks: any[];
    tooltipDisabled: boolean;
    tooltipText: any;
    min: number;
    max: number;
    activeEntries: any[];
    wrapTicks: boolean;
    activate: EventEmitter<any>;
    deactivate: EventEmitter<any>;
    tooltipTemplate: TemplateRef<any>;
    dims: ViewDimensions;
    xDomain: string[];
    yDomain: string[];
    valueDomain: any[];
    xScale: any;
    yScale: any;
    colors: ColorHelper;
    colorScale: any;
    transform: string;
    rects: RectItem$1[];
    margin: number[];
    xAxisHeight: number;
    yAxisWidth: number;
    legendOptions: LegendOptions;
    scaleType: ScaleType;
    ngOnChanges(): void;
    update(): void;
    getXDomain(): string[];
    getYDomain(): string[];
    getValueDomain(): any[];
    /**
     * Converts the input to gap paddingInner in fraction
     * Supports the following inputs:
     *    Numbers: 8
     *    Strings: "8", "8px", "8%"
     *    Arrays: [8,2], "8,2", "[8,2]"
     *    Mixed: [8,"2%"], ["8px","2%"], "8,2%", "[8,2%]"
     *
     * @memberOf HeatMapComponent
     */
    getDimension(value: string | number | Array<string | number>, index: number, N: number, L: number): number;
    getXScale(): any;
    getYScale(): any;
    getRects(): RectItem$1[];
    onClick(data: any): void;
    setColors(): void;
    getLegendOptions(): LegendOptions;
    updateYAxisWidth({ width }: {
        width: number;
    }): void;
    updateXAxisHeight({ height }: {
        height: number;
    }): void;
    onActivate(event: any, group: any, fromLegend?: boolean): void;
    onDeactivate(event: any, group: any, fromLegend?: boolean): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<HeatMapComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<HeatMapComponent, "ngx-charts-heat-map", never, { "legend": { "alias": "legend"; "required": false; }; "legendTitle": { "alias": "legendTitle"; "required": false; }; "legendPosition": { "alias": "legendPosition"; "required": false; }; "xAxis": { "alias": "xAxis"; "required": false; }; "yAxis": { "alias": "yAxis"; "required": false; }; "showXAxisLabel": { "alias": "showXAxisLabel"; "required": false; }; "showYAxisLabel": { "alias": "showYAxisLabel"; "required": false; }; "xAxisLabel": { "alias": "xAxisLabel"; "required": false; }; "yAxisLabel": { "alias": "yAxisLabel"; "required": false; }; "gradient": { "alias": "gradient"; "required": false; }; "innerPadding": { "alias": "innerPadding"; "required": false; }; "trimXAxisTicks": { "alias": "trimXAxisTicks"; "required": false; }; "trimYAxisTicks": { "alias": "trimYAxisTicks"; "required": false; }; "rotateXAxisTicks": { "alias": "rotateXAxisTicks"; "required": false; }; "maxXAxisTickLength": { "alias": "maxXAxisTickLength"; "required": false; }; "maxYAxisTickLength": { "alias": "maxYAxisTickLength"; "required": false; }; "xAxisTickFormatting": { "alias": "xAxisTickFormatting"; "required": false; }; "yAxisTickFormatting": { "alias": "yAxisTickFormatting"; "required": false; }; "xAxisTicks": { "alias": "xAxisTicks"; "required": false; }; "yAxisTicks": { "alias": "yAxisTicks"; "required": false; }; "tooltipDisabled": { "alias": "tooltipDisabled"; "required": false; }; "tooltipText": { "alias": "tooltipText"; "required": false; }; "min": { "alias": "min"; "required": false; }; "max": { "alias": "max"; "required": false; }; "activeEntries": { "alias": "activeEntries"; "required": false; }; "wrapTicks": { "alias": "wrapTicks"; "required": false; }; }, { "activate": "activate"; "deactivate": "deactivate"; }, ["tooltipTemplate"], never, false, never>;
}

declare class HeatMapModule {
    static ɵfac: i0.ɵɵFactoryDeclaration<HeatMapModule, never>;
    static ɵmod: i0.ɵɵNgModuleDeclaration<HeatMapModule, [typeof HeatMapCellComponent, typeof HeatCellSeriesComponent, typeof HeatMapComponent], [typeof ChartCommonModule], [typeof HeatMapCellComponent, typeof HeatCellSeriesComponent, typeof HeatMapComponent]>;
    static ɵinj: i0.ɵɵInjectorDeclaration<HeatMapModule>;
}

interface RectItem {
    fill: string;
    height: number;
    rx: number;
    width: number;
    x: number;
    y: number;
    label: string;
    labelAnchor: string;
    tooltip: string;
    transform: string;
    data: any;
    active?: boolean;
}
declare class SankeyComponent extends BaseChartComponent {
    showLabels: boolean;
    gradient: boolean;
    tooltipDisabled: boolean;
    activeEntries: any[];
    labelFormatting: any;
    activate: EventEmitter<any>;
    deactivate: EventEmitter<any>;
    tooltipTemplate: TemplateRef<any>;
    dims: ViewDimensions;
    colors: ColorHelper;
    colorScale: any;
    transform: string;
    margin: number[];
    scaleType: ScaleType;
    valueDomain: any[];
    styleTypes: typeof StyleTypes;
    nodeRects: RectItem[];
    linkPaths: any[];
    chartHasActive: boolean;
    ngOnChanges(): void;
    update(): void;
    getNodeTooltipText(node: any): string;
    getLinkTooltipText(sourceNode: any, targetNode: any, value: number): string;
    getTextAnchor(node: any): TextAnchor;
    onClick(data: any): void;
    setColors(): void;
    getValueDomain(nodes: any): any[];
    activateLink(link: any): void;
    deactivateLink(link: any): void;
    activateRect(rect: any): void;
    deactivateRect(rect: any): void;
    get hasActive(): boolean;
    static ɵfac: i0.ɵɵFactoryDeclaration<SankeyComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<SankeyComponent, "ngx-charts-sankey", never, { "showLabels": { "alias": "showLabels"; "required": false; }; "gradient": { "alias": "gradient"; "required": false; }; "tooltipDisabled": { "alias": "tooltipDisabled"; "required": false; }; "activeEntries": { "alias": "activeEntries"; "required": false; }; "labelFormatting": { "alias": "labelFormatting"; "required": false; }; }, { "activate": "activate"; "deactivate": "deactivate"; }, ["tooltipTemplate"], never, false, never>;
}

declare class SankeyModule {
    static ɵfac: i0.ɵɵFactoryDeclaration<SankeyModule, never>;
    static ɵmod: i0.ɵɵNgModuleDeclaration<SankeyModule, [typeof SankeyComponent], [typeof ChartCommonModule], [typeof SankeyComponent]>;
    static ɵinj: i0.ɵɵInjectorDeclaration<SankeyModule>;
}

declare class LineComponent implements OnChanges, OnInit {
    private element;
    private platformId;
    path: string;
    stroke: string;
    data: Series;
    fill: string;
    animations: boolean;
    initialized: boolean;
    initialPath: string;
    isSSR: boolean;
    constructor(element: ElementRef, platformId: any);
    ngOnInit(): void;
    ngOnChanges(changes: SimpleChanges): void;
    updatePathEl(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<LineComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<LineComponent, "g[ngx-charts-line]", never, { "path": { "alias": "path"; "required": false; }; "stroke": { "alias": "stroke"; "required": false; }; "data": { "alias": "data"; "required": false; }; "fill": { "alias": "fill"; "required": false; }; "animations": { "alias": "animations"; "required": false; }; }, {}, never, never, false, never>;
}

declare class LineChartComponent extends BaseChartComponent implements OnInit {
    legend: boolean;
    legendTitle: string;
    legendPosition: LegendPosition;
    xAxis: boolean;
    yAxis: boolean;
    showXAxisLabel: boolean;
    showYAxisLabel: boolean;
    xAxisLabel: string;
    yAxisLabel: string;
    autoScale: boolean;
    timeline: boolean;
    gradient: boolean;
    showGridLines: boolean;
    curve: any;
    activeEntries: any[];
    schemeType: ScaleType;
    rangeFillOpacity: number;
    trimXAxisTicks: boolean;
    trimYAxisTicks: boolean;
    rotateXAxisTicks: boolean;
    maxXAxisTickLength: number;
    maxYAxisTickLength: number;
    xAxisTickFormatting: any;
    yAxisTickFormatting: any;
    xAxisTicks: any[];
    yAxisTicks: any[];
    roundDomains: boolean;
    tooltipDisabled: boolean;
    showRefLines: boolean;
    referenceLines: any;
    showRefLabels: boolean;
    xScaleMin: number;
    xScaleMax: number;
    yScaleMin: number;
    yScaleMax: number;
    wrapTicks: boolean;
    activate: EventEmitter<any>;
    deactivate: EventEmitter<any>;
    tooltipTemplate: TemplateRef<any>;
    seriesTooltipTemplate: TemplateRef<any>;
    dims: ViewDimensions;
    xSet: any;
    xDomain: any;
    yDomain: [number, number];
    seriesDomain: any;
    yScale: any;
    xScale: any;
    colors: ColorHelper;
    scaleType: ScaleType;
    transform: string;
    clipPath: string;
    clipPathId: string;
    areaPath: any;
    margin: number[];
    hoveredVertical: any;
    xAxisHeight: number;
    yAxisWidth: number;
    filteredDomain: any;
    legendOptions: any;
    hasRange: boolean;
    timelineWidth: any;
    timelineHeight: number;
    timelineXScale: any;
    timelineYScale: any;
    timelineXDomain: any;
    timelineTransform: any;
    timelinePadding: number;
    isSSR: boolean;
    ngOnInit(): void;
    ngOnChanges(): void;
    update(): void;
    updateTimeline(): void;
    getXDomain(): any[];
    getYDomain(): [number, number];
    getSeriesDomain(): string[];
    getXScale(domain: any, width: number): any;
    getYScale(domain: any, height: number): any;
    updateDomain(domain: any): void;
    updateHoveredVertical(item: any): void;
    hideCircles(): void;
    onClick(data: any): void;
    trackBy(index: number, item: any): string;
    setColors(): void;
    getLegendOptions(): LegendOptions;
    updateYAxisWidth({ width }: {
        width: number;
    }): void;
    updateXAxisHeight({ height }: {
        height: number;
    }): void;
    onActivate(item: any): void;
    onDeactivate(item: any): void;
    deactivateAll(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<LineChartComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<LineChartComponent, "ngx-charts-line-chart", never, { "legend": { "alias": "legend"; "required": false; }; "legendTitle": { "alias": "legendTitle"; "required": false; }; "legendPosition": { "alias": "legendPosition"; "required": false; }; "xAxis": { "alias": "xAxis"; "required": false; }; "yAxis": { "alias": "yAxis"; "required": false; }; "showXAxisLabel": { "alias": "showXAxisLabel"; "required": false; }; "showYAxisLabel": { "alias": "showYAxisLabel"; "required": false; }; "xAxisLabel": { "alias": "xAxisLabel"; "required": false; }; "yAxisLabel": { "alias": "yAxisLabel"; "required": false; }; "autoScale": { "alias": "autoScale"; "required": false; }; "timeline": { "alias": "timeline"; "required": false; }; "gradient": { "alias": "gradient"; "required": false; }; "showGridLines": { "alias": "showGridLines"; "required": false; }; "curve": { "alias": "curve"; "required": false; }; "activeEntries": { "alias": "activeEntries"; "required": false; }; "schemeType": { "alias": "schemeType"; "required": false; }; "rangeFillOpacity": { "alias": "rangeFillOpacity"; "required": false; }; "trimXAxisTicks": { "alias": "trimXAxisTicks"; "required": false; }; "trimYAxisTicks": { "alias": "trimYAxisTicks"; "required": false; }; "rotateXAxisTicks": { "alias": "rotateXAxisTicks"; "required": false; }; "maxXAxisTickLength": { "alias": "maxXAxisTickLength"; "required": false; }; "maxYAxisTickLength": { "alias": "maxYAxisTickLength"; "required": false; }; "xAxisTickFormatting": { "alias": "xAxisTickFormatting"; "required": false; }; "yAxisTickFormatting": { "alias": "yAxisTickFormatting"; "required": false; }; "xAxisTicks": { "alias": "xAxisTicks"; "required": false; }; "yAxisTicks": { "alias": "yAxisTicks"; "required": false; }; "roundDomains": { "alias": "roundDomains"; "required": false; }; "tooltipDisabled": { "alias": "tooltipDisabled"; "required": false; }; "showRefLines": { "alias": "showRefLines"; "required": false; }; "referenceLines": { "alias": "referenceLines"; "required": false; }; "showRefLabels": { "alias": "showRefLabels"; "required": false; }; "xScaleMin": { "alias": "xScaleMin"; "required": false; }; "xScaleMax": { "alias": "xScaleMax"; "required": false; }; "yScaleMin": { "alias": "yScaleMin"; "required": false; }; "yScaleMax": { "alias": "yScaleMax"; "required": false; }; "wrapTicks": { "alias": "wrapTicks"; "required": false; }; }, { "activate": "activate"; "deactivate": "deactivate"; }, ["tooltipTemplate", "seriesTooltipTemplate"], never, false, never>;
}

declare class LineSeriesComponent implements OnChanges {
    data: Series;
    xScale: any;
    yScale: any;
    colors: ColorHelper;
    scaleType: ScaleType;
    curve: any;
    activeEntries: any[];
    rangeFillOpacity: number;
    hasRange: boolean;
    animations: boolean;
    path: string;
    outerPath: string;
    areaPath: string;
    gradientId: string;
    gradientUrl: string;
    hasGradient: boolean;
    gradientStops: Gradient[];
    areaGradientStops: Gradient[];
    stroke: string;
    barOrientation: typeof BarOrientation;
    ngOnChanges(changes: SimpleChanges): void;
    update(): void;
    getLineGenerator(): any;
    getRangeGenerator(): any;
    getAreaGenerator(): any;
    sortData(data: any): any;
    updateGradients(): void;
    isActive(entry: any): boolean;
    isInactive(entry: any): boolean;
    static ɵfac: i0.ɵɵFactoryDeclaration<LineSeriesComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<LineSeriesComponent, "g[ngx-charts-line-series]", never, { "data": { "alias": "data"; "required": false; }; "xScale": { "alias": "xScale"; "required": false; }; "yScale": { "alias": "yScale"; "required": false; }; "colors": { "alias": "colors"; "required": false; }; "scaleType": { "alias": "scaleType"; "required": false; }; "curve": { "alias": "curve"; "required": false; }; "activeEntries": { "alias": "activeEntries"; "required": false; }; "rangeFillOpacity": { "alias": "rangeFillOpacity"; "required": false; }; "hasRange": { "alias": "hasRange"; "required": false; }; "animations": { "alias": "animations"; "required": false; }; }, {}, never, never, false, never>;
}

declare class LineChartModule {
    static ɵfac: i0.ɵɵFactoryDeclaration<LineChartModule, never>;
    static ɵmod: i0.ɵɵNgModuleDeclaration<LineChartModule, [typeof LineComponent, typeof LineChartComponent, typeof LineSeriesComponent], [typeof ChartCommonModule], [typeof LineComponent, typeof LineChartComponent, typeof LineSeriesComponent]>;
    static ɵinj: i0.ɵɵInjectorDeclaration<LineChartModule>;
}

declare class PolarChartComponent extends BaseChartComponent implements OnInit {
    legend: boolean;
    legendTitle: string;
    legendPosition: LegendPosition;
    xAxis: boolean;
    yAxis: boolean;
    showXAxisLabel: boolean;
    showYAxisLabel: boolean;
    xAxisLabel: string;
    yAxisLabel: string;
    autoScale: boolean;
    showGridLines: boolean;
    curve: any;
    activeEntries: any[];
    schemeType: ScaleType;
    rangeFillOpacity: number;
    trimYAxisTicks: boolean;
    maxYAxisTickLength: number;
    xAxisTickFormatting: (o: any) => any;
    yAxisTickFormatting: (o: any) => any;
    roundDomains: boolean;
    tooltipDisabled: boolean;
    showSeriesOnHover: boolean;
    gradient: boolean;
    yAxisMinScale: number;
    labelTrim: boolean;
    labelTrimSize: number;
    wrapTicks: boolean;
    activate: EventEmitter<any>;
    deactivate: EventEmitter<any>;
    tooltipTemplate: TemplateRef<any>;
    dims: ViewDimensions;
    yAxisDims: ViewDimensions;
    labelOffset: number;
    xDomain: any;
    yDomain: any;
    seriesDomain: any;
    yScale: any;
    xScale: any;
    yAxisScale: any;
    colors: ColorHelper;
    scaleType: ScaleType;
    transform: string;
    transformPlot: string;
    transformYAxis: string;
    transformXAxis: string;
    margin: number[];
    xAxisHeight: number;
    yAxisWidth: number;
    filteredDomain: any;
    legendOptions: any;
    thetaTicks: any[];
    radiusTicks: number[];
    outerRadius: number;
    orientation: typeof Orientation;
    isSSR: boolean;
    ngOnInit(): void;
    ngOnChanges(): void;
    update(): void;
    setDims(): void;
    setScales(): void;
    setTicks(): void;
    getXValues(): any[];
    getXDomain(values?: any[]): any[];
    getYValues(): any[];
    getYDomain(domain?: any[]): any[];
    getSeriesDomain(): any[];
    getXScale(domain: any, width: number): any;
    getYScale(domain: any, height: number): any;
    onClick(data: any, series?: any): void;
    setColors(): void;
    getLegendOptions(): {
        scaleType: ScaleType.Ordinal;
        colors: ColorHelper;
        domain: any;
        title: string;
        position: LegendPosition;
    } | {
        scaleType: ScaleType.Time | ScaleType.Linear | ScaleType.Quantile;
        colors: any;
        domain: any;
        title: any;
        position: LegendPosition;
    };
    updateYAxisWidth({ width }: {
        width: number;
    }): void;
    updateXAxisHeight({ height }: {
        height: number;
    }): void;
    onActivate(item: any): void;
    onDeactivate(item: any): void;
    deactivateAll(): void;
    trackBy(index: number, item: any): string;
    static ɵfac: i0.ɵɵFactoryDeclaration<PolarChartComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<PolarChartComponent, "ngx-charts-polar-chart", never, { "legend": { "alias": "legend"; "required": false; }; "legendTitle": { "alias": "legendTitle"; "required": false; }; "legendPosition": { "alias": "legendPosition"; "required": false; }; "xAxis": { "alias": "xAxis"; "required": false; }; "yAxis": { "alias": "yAxis"; "required": false; }; "showXAxisLabel": { "alias": "showXAxisLabel"; "required": false; }; "showYAxisLabel": { "alias": "showYAxisLabel"; "required": false; }; "xAxisLabel": { "alias": "xAxisLabel"; "required": false; }; "yAxisLabel": { "alias": "yAxisLabel"; "required": false; }; "autoScale": { "alias": "autoScale"; "required": false; }; "showGridLines": { "alias": "showGridLines"; "required": false; }; "curve": { "alias": "curve"; "required": false; }; "activeEntries": { "alias": "activeEntries"; "required": false; }; "schemeType": { "alias": "schemeType"; "required": false; }; "rangeFillOpacity": { "alias": "rangeFillOpacity"; "required": false; }; "trimYAxisTicks": { "alias": "trimYAxisTicks"; "required": false; }; "maxYAxisTickLength": { "alias": "maxYAxisTickLength"; "required": false; }; "xAxisTickFormatting": { "alias": "xAxisTickFormatting"; "required": false; }; "yAxisTickFormatting": { "alias": "yAxisTickFormatting"; "required": false; }; "roundDomains": { "alias": "roundDomains"; "required": false; }; "tooltipDisabled": { "alias": "tooltipDisabled"; "required": false; }; "showSeriesOnHover": { "alias": "showSeriesOnHover"; "required": false; }; "gradient": { "alias": "gradient"; "required": false; }; "yAxisMinScale": { "alias": "yAxisMinScale"; "required": false; }; "labelTrim": { "alias": "labelTrim"; "required": false; }; "labelTrimSize": { "alias": "labelTrimSize"; "required": false; }; "wrapTicks": { "alias": "wrapTicks"; "required": false; }; }, { "activate": "activate"; "deactivate": "deactivate"; }, ["tooltipTemplate"], never, false, never>;
}

interface PolarChartCircle {
    color: string;
    cx: number;
    cy: number;
    data: Series;
    label: string;
    value: number;
}
declare class PolarSeriesComponent implements OnChanges {
    name: any;
    data: any;
    xScale: any;
    yScale: any;
    colors: any;
    scaleType: any;
    curve: any;
    activeEntries: any[];
    rangeFillOpacity: number;
    tooltipDisabled: boolean;
    tooltipText: (o: any) => string;
    gradient: boolean;
    tooltipTemplate: TemplateRef<any>;
    animations: boolean;
    select: EventEmitter<any>;
    activate: EventEmitter<any>;
    deactivate: EventEmitter<any>;
    path: string;
    circles: PolarChartCircle[];
    circleRadius: number;
    areaPath: string;
    gradientId: string;
    gradientUrl: string;
    hasGradient: boolean;
    gradientStops: any[];
    areaGradientStops: any[];
    seriesColor: string;
    active: boolean;
    inactive: boolean;
    barOrientation: typeof BarOrientation;
    placementTypes: typeof PlacementTypes;
    styleTypes: typeof StyleTypes;
    ngOnChanges(changes: SimpleChanges): void;
    update(): void;
    getAngle(d: DataItem): any;
    getRadius(d: DataItem): any;
    getLineGenerator(): any;
    sortData(data: DataItem): any[];
    isActive(entry: DataItem): boolean;
    isInactive(entry: DataItem): boolean;
    defaultTooltipText({ label, value }: {
        label: string;
        value: number;
    }): string;
    updateGradients(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<PolarSeriesComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<PolarSeriesComponent, "g[ngx-charts-polar-series]", never, { "name": { "alias": "name"; "required": false; }; "data": { "alias": "data"; "required": false; }; "xScale": { "alias": "xScale"; "required": false; }; "yScale": { "alias": "yScale"; "required": false; }; "colors": { "alias": "colors"; "required": false; }; "scaleType": { "alias": "scaleType"; "required": false; }; "curve": { "alias": "curve"; "required": false; }; "activeEntries": { "alias": "activeEntries"; "required": false; }; "rangeFillOpacity": { "alias": "rangeFillOpacity"; "required": false; }; "tooltipDisabled": { "alias": "tooltipDisabled"; "required": false; }; "tooltipText": { "alias": "tooltipText"; "required": false; }; "gradient": { "alias": "gradient"; "required": false; }; "tooltipTemplate": { "alias": "tooltipTemplate"; "required": false; }; "animations": { "alias": "animations"; "required": false; }; }, { "select": "select"; "activate": "activate"; "deactivate": "deactivate"; }, never, never, false, never>;
}

declare class AdvancedPieChartComponent extends BaseChartComponent {
    gradient: boolean;
    activeEntries: any[];
    tooltipDisabled: boolean;
    tooltipText: any;
    label: string;
    activate: EventEmitter<any>;
    deactivate: EventEmitter<any>;
    tooltipTemplate: TemplateRef<any>;
    dims: ViewDimensions;
    domain: string[];
    outerRadius: number;
    innerRadius: number;
    transform: string;
    colors: ColorHelper;
    legendWidth: number;
    margin: number[];
    valueFormatting: (value: number) => any;
    nameFormatting: (value: string) => any;
    percentageFormatting: (value: number) => any;
    ngOnChanges(): void;
    update(): void;
    getDomain(): string[];
    onClick(data: DataItem): void;
    setColors(): void;
    onActivate(item: any, fromLegend?: boolean): void;
    onDeactivate(item: any, fromLegend?: boolean): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<AdvancedPieChartComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<AdvancedPieChartComponent, "ngx-charts-advanced-pie-chart", never, { "gradient": { "alias": "gradient"; "required": false; }; "activeEntries": { "alias": "activeEntries"; "required": false; }; "tooltipDisabled": { "alias": "tooltipDisabled"; "required": false; }; "tooltipText": { "alias": "tooltipText"; "required": false; }; "label": { "alias": "label"; "required": false; }; "valueFormatting": { "alias": "valueFormatting"; "required": false; }; "nameFormatting": { "alias": "nameFormatting"; "required": false; }; "percentageFormatting": { "alias": "percentageFormatting"; "required": false; }; }, { "activate": "activate"; "deactivate": "deactivate"; }, ["tooltipTemplate"], never, false, never>;
}

interface PieData extends DefaultArcObject {
    data: DataItem;
    index: number;
    pos: [number, number];
    value: number;
}
declare class PieLabelComponent implements OnChanges {
    platformId: any;
    data: PieData;
    radius: number;
    label: string;
    color: string;
    max: number;
    value: number;
    explodeSlices: boolean;
    animations: boolean;
    labelTrim: boolean;
    labelTrimSize: number;
    trimLabel: (label: string, max?: number) => string;
    line: string;
    styleTransform: string;
    attrTransform: string;
    textTransition: string;
    constructor(platformId: any);
    ngOnChanges(changes: SimpleChanges): void;
    setTransforms(): void;
    update(): void;
    get textX(): number;
    get textY(): number;
    textAnchor(): TextAnchor;
    midAngle(d: any): number;
    static ɵfac: i0.ɵɵFactoryDeclaration<PieLabelComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<PieLabelComponent, "g[ngx-charts-pie-label]", never, { "data": { "alias": "data"; "required": false; }; "radius": { "alias": "radius"; "required": false; }; "label": { "alias": "label"; "required": false; }; "color": { "alias": "color"; "required": false; }; "max": { "alias": "max"; "required": false; }; "value": { "alias": "value"; "required": false; }; "explodeSlices": { "alias": "explodeSlices"; "required": false; }; "animations": { "alias": "animations"; "required": false; }; "labelTrim": { "alias": "labelTrim"; "required": false; }; "labelTrimSize": { "alias": "labelTrimSize"; "required": false; }; }, {}, never, never, false, never>;
}

declare class PieArcComponent implements OnChanges {
    fill: string;
    startAngle: number;
    endAngle: number;
    innerRadius: number;
    outerRadius: number;
    cornerRadius: number;
    value: number;
    max: number;
    data: DataItem;
    explodeSlices: boolean;
    gradient: boolean;
    animate: boolean;
    pointerEvents: boolean;
    isActive: boolean;
    select: EventEmitter<any>;
    activate: EventEmitter<any>;
    deactivate: EventEmitter<any>;
    dblclick: EventEmitter<any>;
    barOrientation: typeof BarOrientation;
    element: HTMLElement;
    path: any;
    startOpacity: number;
    radialGradientId: string;
    gradientFill: string;
    initialized: boolean;
    private _timeout;
    constructor(element: ElementRef);
    ngOnChanges(changes: SimpleChanges): void;
    getGradient(): string;
    getPointerEvents(): string;
    update(): void;
    calculateArc(): any;
    loadAnimation(): void;
    updateAnimation(): void;
    onClick(): void;
    onDblClick(event: MouseEvent): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<PieArcComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<PieArcComponent, "g[ngx-charts-pie-arc]", never, { "fill": { "alias": "fill"; "required": false; }; "startAngle": { "alias": "startAngle"; "required": false; }; "endAngle": { "alias": "endAngle"; "required": false; }; "innerRadius": { "alias": "innerRadius"; "required": false; }; "outerRadius": { "alias": "outerRadius"; "required": false; }; "cornerRadius": { "alias": "cornerRadius"; "required": false; }; "value": { "alias": "value"; "required": false; }; "max": { "alias": "max"; "required": false; }; "data": { "alias": "data"; "required": false; }; "explodeSlices": { "alias": "explodeSlices"; "required": false; }; "gradient": { "alias": "gradient"; "required": false; }; "animate": { "alias": "animate"; "required": false; }; "pointerEvents": { "alias": "pointerEvents"; "required": false; }; "isActive": { "alias": "isActive"; "required": false; }; }, { "select": "select"; "activate": "activate"; "deactivate": "deactivate"; "dblclick": "dblclick"; }, never, never, false, never>;
}

declare class PieChartComponent extends BaseChartComponent {
    labels: boolean;
    legend: boolean;
    legendTitle: string;
    legendPosition: LegendPosition;
    explodeSlices: boolean;
    doughnut: boolean;
    arcWidth: number;
    gradient: boolean;
    activeEntries: any[];
    tooltipDisabled: boolean;
    labelFormatting: any;
    trimLabels: boolean;
    maxLabelLength: number;
    tooltipText: any;
    dblclick: EventEmitter<any>;
    margins: number[];
    select: EventEmitter<any>;
    activate: EventEmitter<any>;
    deactivate: EventEmitter<any>;
    tooltipTemplate: TemplateRef<any>;
    translation: string;
    outerRadius: number;
    innerRadius: number;
    data: DataItem[];
    colors: ColorHelper;
    domain: string[];
    dims: ViewDimensions;
    legendOptions: LegendOptions;
    ngOnChanges(): void;
    update(): void;
    getDomain(): string[];
    onClick(data: DataItem | string): void;
    setColors(): void;
    getLegendOptions(): LegendOptions;
    onActivate(item: any, fromLegend?: boolean): void;
    onDeactivate(item: any, fromLegend?: boolean): void;
    private hasNoOptionalMarginsSet;
    static ɵfac: i0.ɵɵFactoryDeclaration<PieChartComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<PieChartComponent, "ngx-charts-pie-chart", never, { "labels": { "alias": "labels"; "required": false; }; "legend": { "alias": "legend"; "required": false; }; "legendTitle": { "alias": "legendTitle"; "required": false; }; "legendPosition": { "alias": "legendPosition"; "required": false; }; "explodeSlices": { "alias": "explodeSlices"; "required": false; }; "doughnut": { "alias": "doughnut"; "required": false; }; "arcWidth": { "alias": "arcWidth"; "required": false; }; "gradient": { "alias": "gradient"; "required": false; }; "activeEntries": { "alias": "activeEntries"; "required": false; }; "tooltipDisabled": { "alias": "tooltipDisabled"; "required": false; }; "labelFormatting": { "alias": "labelFormatting"; "required": false; }; "trimLabels": { "alias": "trimLabels"; "required": false; }; "maxLabelLength": { "alias": "maxLabelLength"; "required": false; }; "tooltipText": { "alias": "tooltipText"; "required": false; }; "margins": { "alias": "margins"; "required": false; }; }, { "dblclick": "dblclick"; "select": "select"; "activate": "activate"; "deactivate": "deactivate"; }, ["tooltipTemplate"], never, false, never>;
}

declare class PieGridComponent extends BaseChartComponent {
    designatedTotal: number;
    tooltipDisabled: boolean;
    tooltipText: (o: any) => any;
    label: string;
    minWidth: number;
    activeEntries: any[];
    activate: EventEmitter<any>;
    deactivate: EventEmitter<any>;
    dims: ViewDimensions;
    data: PieGridData[];
    transform: string;
    series: any[];
    domain: string[];
    colorScale: ColorHelper;
    margin: number[];
    placementTypes: typeof PlacementTypes;
    styleTypes: typeof StyleTypes;
    tooltipTemplate: TemplateRef<any>;
    ngOnChanges(): void;
    update(): void;
    defaultTooltipText({ data }: {
        data: any;
    }): string;
    getDomain(): string[];
    getSeries(): any[];
    getTotal(): any;
    onClick(data: DataItem): void;
    setColors(): void;
    onActivate(item: any, fromLegend?: boolean): void;
    onDeactivate(item: any, fromLegend?: boolean): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<PieGridComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<PieGridComponent, "ngx-charts-pie-grid", never, { "designatedTotal": { "alias": "designatedTotal"; "required": false; }; "tooltipDisabled": { "alias": "tooltipDisabled"; "required": false; }; "tooltipText": { "alias": "tooltipText"; "required": false; }; "label": { "alias": "label"; "required": false; }; "minWidth": { "alias": "minWidth"; "required": false; }; "activeEntries": { "alias": "activeEntries"; "required": false; }; }, { "activate": "activate"; "deactivate": "deactivate"; }, ["tooltipTemplate"], never, false, never>;
}

interface PieArc {
    animate: boolean;
    class: string;
    data: PieGridDataItem;
    endAngle: number;
    fill: string;
    pointerEvents: boolean;
    startAngle: number;
}
declare class PieGridSeriesComponent implements OnChanges {
    colors: any;
    data: PieGridData[];
    innerRadius: number;
    outerRadius: number;
    animations: boolean;
    select: EventEmitter<any>;
    activate: EventEmitter<any>;
    deactivate: EventEmitter<any>;
    element: HTMLElement;
    layout: any;
    arcs: PieArc[];
    constructor(element: ElementRef);
    ngOnChanges(changes: SimpleChanges): void;
    update(): void;
    getArcs(): PieArc[];
    onClick(data: any): void;
    trackBy(index: any, item: any): string;
    label(arc: any): string;
    color(arc: any): string;
    static ɵfac: i0.ɵɵFactoryDeclaration<PieGridSeriesComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<PieGridSeriesComponent, "g[ngx-charts-pie-grid-series]", never, { "colors": { "alias": "colors"; "required": false; }; "data": { "alias": "data"; "required": false; }; "innerRadius": { "alias": "innerRadius"; "required": false; }; "outerRadius": { "alias": "outerRadius"; "required": false; }; "animations": { "alias": "animations"; "required": false; }; }, { "select": "select"; "activate": "activate"; "deactivate": "deactivate"; }, never, never, false, never>;
}

declare class PieSeriesComponent implements OnChanges {
    colors: ColorHelper;
    series: DataItem[];
    dims: ViewDimensions;
    innerRadius: number;
    outerRadius: number;
    explodeSlices: boolean;
    showLabels: boolean;
    gradient: boolean;
    activeEntries: any[];
    labelFormatting: any;
    trimLabels: boolean;
    maxLabelLength: number;
    tooltipText: (o: any) => any;
    tooltipDisabled: boolean;
    tooltipTemplate: TemplateRef<any>;
    animations: boolean;
    select: EventEmitter<any>;
    activate: EventEmitter<any>;
    deactivate: EventEmitter<any>;
    dblclick: EventEmitter<any>;
    max: number;
    data: PieData[];
    placementTypes: typeof PlacementTypes;
    styleTypes: typeof StyleTypes;
    ngOnChanges(changes: SimpleChanges): void;
    update(): void;
    midAngle(d: any): number;
    outerArc(): any;
    calculateLabelPositions(pieData: any): any;
    labelVisible(myArc: any): boolean;
    getTooltipTitle(a: any): any;
    labelText(myArc: any): string;
    label(myArc: any): string;
    defaultTooltipText(myArc: any): string;
    color(myArc: any): any;
    trackBy(index: any, item: any): string;
    onClick(data: any): void;
    isActive(entry: any): boolean;
    static ɵfac: i0.ɵɵFactoryDeclaration<PieSeriesComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<PieSeriesComponent, "g[ngx-charts-pie-series]", never, { "colors": { "alias": "colors"; "required": false; }; "series": { "alias": "series"; "required": false; }; "dims": { "alias": "dims"; "required": false; }; "innerRadius": { "alias": "innerRadius"; "required": false; }; "outerRadius": { "alias": "outerRadius"; "required": false; }; "explodeSlices": { "alias": "explodeSlices"; "required": false; }; "showLabels": { "alias": "showLabels"; "required": false; }; "gradient": { "alias": "gradient"; "required": false; }; "activeEntries": { "alias": "activeEntries"; "required": false; }; "labelFormatting": { "alias": "labelFormatting"; "required": false; }; "trimLabels": { "alias": "trimLabels"; "required": false; }; "maxLabelLength": { "alias": "maxLabelLength"; "required": false; }; "tooltipText": { "alias": "tooltipText"; "required": false; }; "tooltipDisabled": { "alias": "tooltipDisabled"; "required": false; }; "tooltipTemplate": { "alias": "tooltipTemplate"; "required": false; }; "animations": { "alias": "animations"; "required": false; }; }, { "select": "select"; "activate": "activate"; "deactivate": "deactivate"; "dblclick": "dblclick"; }, never, never, false, never>;
}

declare class PieChartModule {
    static ɵfac: i0.ɵɵFactoryDeclaration<PieChartModule, never>;
    static ɵmod: i0.ɵɵNgModuleDeclaration<PieChartModule, [typeof AdvancedPieChartComponent, typeof PieLabelComponent, typeof PieArcComponent, typeof PieChartComponent, typeof PieGridComponent, typeof PieGridSeriesComponent, typeof PieSeriesComponent], [typeof ChartCommonModule], [typeof AdvancedPieChartComponent, typeof PieLabelComponent, typeof PieArcComponent, typeof PieChartComponent, typeof PieGridComponent, typeof PieGridSeriesComponent, typeof PieSeriesComponent]>;
    static ɵinj: i0.ɵɵInjectorDeclaration<PieChartModule>;
}

declare class PolarChartModule {
    static ɵfac: i0.ɵɵFactoryDeclaration<PolarChartModule, never>;
    static ɵmod: i0.ɵɵNgModuleDeclaration<PolarChartModule, [typeof PolarChartComponent, typeof PolarSeriesComponent], [typeof ChartCommonModule, typeof PieChartModule, typeof LineChartModule], [typeof PolarChartComponent, typeof PolarSeriesComponent]>;
    static ɵinj: i0.ɵɵInjectorDeclaration<PolarChartModule>;
}

interface GridItem {
    data: GridData;
    height: number;
    width: number;
    x: number;
    y: number;
}
interface GridData {
    extra?: any;
    label: string;
    name: StringOrNumberOrDate;
    percent: number;
    total: number;
    value: number;
}
declare function gridSize(dims: ViewDimensions, len: number, minWidth: number): [number, number];
declare function gridLayout(dims: ViewDimensions, data: GridData[], minWidth: number, designatedTotal: number): GridItem[];

declare class CardComponent implements OnChanges, OnDestroy, OnInit {
    private cd;
    private zone;
    private platformId;
    color: string;
    bandColor: string;
    textColor: string;
    x: number;
    y: number;
    width: number;
    height: number;
    label: string;
    data: GridData;
    medianSize: number;
    valueFormatting: any;
    labelFormatting: any;
    animations: boolean;
    select: EventEmitter<any>;
    textEl: ElementRef;
    element: HTMLElement;
    value: string;
    transform: string;
    formattedLabel: string;
    cardWidth: number;
    cardHeight: number;
    textWidth: number;
    textFontSize: number;
    textTransform: string;
    initialized: boolean;
    animationReq: number;
    bandHeight: number;
    transformBand: string;
    textPadding: number[];
    labelFontSize: number;
    bandPath: string;
    constructor(element: ElementRef, cd: ChangeDetectorRef, zone: NgZone, platformId: any);
    ngOnChanges(changes: SimpleChanges): void;
    ngOnInit(): void;
    ngOnDestroy(): void;
    update(): void;
    paddedValue(value: string): string;
    startCount(): void;
    scaleText(): void;
    scaleTextSSR(): void;
    setPadding(): void;
    onClick(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<CardComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<CardComponent, "g[ngx-charts-card]", never, { "color": { "alias": "color"; "required": false; }; "bandColor": { "alias": "bandColor"; "required": false; }; "textColor": { "alias": "textColor"; "required": false; }; "x": { "alias": "x"; "required": false; }; "y": { "alias": "y"; "required": false; }; "width": { "alias": "width"; "required": false; }; "height": { "alias": "height"; "required": false; }; "label": { "alias": "label"; "required": false; }; "data": { "alias": "data"; "required": false; }; "medianSize": { "alias": "medianSize"; "required": false; }; "valueFormatting": { "alias": "valueFormatting"; "required": false; }; "labelFormatting": { "alias": "labelFormatting"; "required": false; }; "animations": { "alias": "animations"; "required": false; }; }, { "select": "select"; }, never, never, false, never>;
}

interface CardModel extends GridItem {
    color: string;
    tooltipText: string;
    textColor: string;
    bandColor: string;
    label: string;
}
declare class CardSeriesComponent implements OnChanges {
    data: CardModel[];
    dims: ViewDimensions;
    colors: ColorHelper;
    innerPadding: number;
    cardColor: string;
    bandColor: string;
    emptyColor: string;
    textColor: string;
    valueFormatting: any;
    labelFormatting: any;
    animations: boolean;
    select: EventEmitter<any>;
    cards: CardModel[];
    emptySlots: any[];
    medianSize: number;
    ngOnChanges(changes: SimpleChanges): void;
    update(): void;
    getCards(): CardModel[];
    trackBy(index: any, card: any): string;
    onClick(data: any): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<CardSeriesComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<CardSeriesComponent, "g[ngx-charts-card-series]", never, { "data": { "alias": "data"; "required": false; }; "dims": { "alias": "dims"; "required": false; }; "colors": { "alias": "colors"; "required": false; }; "innerPadding": { "alias": "innerPadding"; "required": false; }; "cardColor": { "alias": "cardColor"; "required": false; }; "bandColor": { "alias": "bandColor"; "required": false; }; "emptyColor": { "alias": "emptyColor"; "required": false; }; "textColor": { "alias": "textColor"; "required": false; }; "valueFormatting": { "alias": "valueFormatting"; "required": false; }; "labelFormatting": { "alias": "labelFormatting"; "required": false; }; "animations": { "alias": "animations"; "required": false; }; }, { "select": "select"; }, never, never, false, never>;
}

declare class NumberCardComponent extends BaseChartComponent {
    cardColor: string;
    bandColor: string;
    emptyColor: string;
    innerPadding: number;
    textColor: string;
    valueFormatting: any;
    labelFormatting: any;
    designatedTotal: number;
    dims: ViewDimensions;
    data: CardModel[];
    colors: ColorHelper;
    transform: string;
    domain: any[];
    margin: number[];
    ngOnChanges(): void;
    get clickable(): boolean;
    update(): void;
    getDomain(): string[];
    onClick(data: any): void;
    setColors(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<NumberCardComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<NumberCardComponent, "ngx-charts-number-card", never, { "cardColor": { "alias": "cardColor"; "required": false; }; "bandColor": { "alias": "bandColor"; "required": false; }; "emptyColor": { "alias": "emptyColor"; "required": false; }; "innerPadding": { "alias": "innerPadding"; "required": false; }; "textColor": { "alias": "textColor"; "required": false; }; "valueFormatting": { "alias": "valueFormatting"; "required": false; }; "labelFormatting": { "alias": "labelFormatting"; "required": false; }; "designatedTotal": { "alias": "designatedTotal"; "required": false; }; }, {}, never, never, false, never>;
}

declare class NumberCardModule {
    static ɵfac: i0.ɵɵFactoryDeclaration<NumberCardModule, never>;
    static ɵmod: i0.ɵɵNgModuleDeclaration<NumberCardModule, [typeof CardComponent, typeof CardSeriesComponent, typeof NumberCardComponent], [typeof ChartCommonModule], [typeof CardComponent, typeof CardSeriesComponent, typeof NumberCardComponent]>;
    static ɵinj: i0.ɵɵInjectorDeclaration<NumberCardModule>;
}

declare class TreeMapCellComponent implements OnChanges {
    data: DataItem;
    fill: string;
    x: number;
    y: number;
    width: number;
    height: number;
    label: string;
    value: any;
    valueFormatting: any;
    labelFormatting: any;
    gradient: boolean;
    animations: boolean;
    select: EventEmitter<any>;
    gradientStops: Gradient[];
    gradientId: string;
    gradientUrl: string;
    element: HTMLElement;
    transform: string;
    formattedLabel: string;
    formattedValue: string;
    initialized: boolean;
    orientation: typeof BarOrientation;
    constructor(element: ElementRef);
    ngOnChanges(): void;
    update(): void;
    loadAnimation(): void;
    getTextColor(): string;
    animateToCurrentForm(): void;
    onClick(): void;
    getGradientStops(): Gradient[];
    static ɵfac: i0.ɵɵFactoryDeclaration<TreeMapCellComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<TreeMapCellComponent, "g[ngx-charts-tree-map-cell]", never, { "data": { "alias": "data"; "required": false; }; "fill": { "alias": "fill"; "required": false; }; "x": { "alias": "x"; "required": false; }; "y": { "alias": "y"; "required": false; }; "width": { "alias": "width"; "required": false; }; "height": { "alias": "height"; "required": false; }; "label": { "alias": "label"; "required": false; }; "value": { "alias": "value"; "required": false; }; "valueFormatting": { "alias": "valueFormatting"; "required": false; }; "labelFormatting": { "alias": "labelFormatting"; "required": false; }; "gradient": { "alias": "gradient"; "required": false; }; "animations": { "alias": "animations"; "required": false; }; }, { "select": "select"; }, never, never, false, never>;
}

interface TreeMapCell {
    data: DataItem;
    fill: string;
    height: number;
    label: string;
    value: any;
    width: number;
    x: number;
    y: number;
}
declare class TreeMapCellSeriesComponent implements OnChanges {
    data: any;
    dims: ViewDimensions;
    colors: ColorHelper;
    valueFormatting: any;
    labelFormatting: any;
    gradient: boolean;
    tooltipDisabled: boolean;
    tooltipTemplate: TemplateRef<any>;
    animations: boolean;
    select: EventEmitter<any>;
    cells: TreeMapCell[];
    styleTypes: typeof StyleTypes;
    placementTypes: typeof PlacementTypes;
    ngOnChanges(changes: SimpleChanges): void;
    getCells(): TreeMapCell[];
    getTooltipText({ label, value }: {
        label: any;
        value: any;
    }): string;
    onClick(data: any): void;
    trackBy(index: any, item: any): string;
    static ɵfac: i0.ɵɵFactoryDeclaration<TreeMapCellSeriesComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<TreeMapCellSeriesComponent, "g[ngx-charts-tree-map-cell-series]", never, { "data": { "alias": "data"; "required": false; }; "dims": { "alias": "dims"; "required": false; }; "colors": { "alias": "colors"; "required": false; }; "valueFormatting": { "alias": "valueFormatting"; "required": false; }; "labelFormatting": { "alias": "labelFormatting"; "required": false; }; "gradient": { "alias": "gradient"; "required": false; }; "tooltipDisabled": { "alias": "tooltipDisabled"; "required": false; }; "tooltipTemplate": { "alias": "tooltipTemplate"; "required": false; }; "animations": { "alias": "animations"; "required": false; }; }, { "select": "select"; }, never, never, false, never>;
}

declare class TreeMapComponent extends BaseChartComponent {
    results: DataItem[];
    tooltipDisabled: boolean;
    valueFormatting: any;
    labelFormatting: any;
    gradient: boolean;
    select: EventEmitter<any>;
    tooltipTemplate: TemplateRef<any>;
    dims: ViewDimensions;
    domain: any;
    transform: any;
    colors: ColorHelper;
    treemap: any;
    data: DataItem;
    margin: number[];
    ngOnChanges(): void;
    update(): void;
    getDomain(): any[];
    onClick(data: DataItem): void;
    setColors(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<TreeMapComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<TreeMapComponent, "ngx-charts-tree-map", never, { "results": { "alias": "results"; "required": false; }; "tooltipDisabled": { "alias": "tooltipDisabled"; "required": false; }; "valueFormatting": { "alias": "valueFormatting"; "required": false; }; "labelFormatting": { "alias": "labelFormatting"; "required": false; }; "gradient": { "alias": "gradient"; "required": false; }; }, { "select": "select"; }, ["tooltipTemplate"], never, false, never>;
}

declare class TreeMapModule {
    static ɵfac: i0.ɵɵFactoryDeclaration<TreeMapModule, never>;
    static ɵmod: i0.ɵɵNgModuleDeclaration<TreeMapModule, [typeof TreeMapCellComponent, typeof TreeMapCellSeriesComponent, typeof TreeMapComponent], [typeof ChartCommonModule], [typeof TreeMapCellComponent, typeof TreeMapCellSeriesComponent, typeof TreeMapComponent]>;
    static ɵinj: i0.ɵɵInjectorDeclaration<TreeMapModule>;
}

declare enum ElementType {
    Value = "value",
    Units = "units"
}
declare class LinearGaugeComponent extends BaseChartComponent implements AfterViewInit {
    min: number;
    max: number;
    value: number;
    units: string;
    previousValue: number;
    valueFormatting: any;
    valueTextEl: ElementRef;
    unitsTextEl: ElementRef;
    dims: ViewDimensions;
    valueDomain: [number, number];
    valueScale: any;
    colors: ColorHelper;
    transform: string;
    margin: number[];
    transformLine: string;
    valueResizeScale: number;
    unitsResizeScale: number;
    valueTextTransform: string;
    valueTranslate: string;
    unitsTextTransform: string;
    unitsTranslate: string;
    displayValue: string;
    hasPreviousValue: boolean;
    barOrientation: typeof BarOrientation;
    ngAfterViewInit(): void;
    ngOnChanges(): void;
    update(): void;
    getValueDomain(): [number, number];
    getValueScale(): any;
    getDisplayValue(): string;
    scaleText(element: ElementType, repeat?: boolean): void;
    scaleTextSSR(element: any): void;
    onClick(): void;
    setColors(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<LinearGaugeComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<LinearGaugeComponent, "ngx-charts-linear-gauge", never, { "min": { "alias": "min"; "required": false; }; "max": { "alias": "max"; "required": false; }; "value": { "alias": "value"; "required": false; }; "units": { "alias": "units"; "required": false; }; "previousValue": { "alias": "previousValue"; "required": false; }; "valueFormatting": { "alias": "valueFormatting"; "required": false; }; }, {}, never, never, false, never>;
}

interface ArcItem {
    data: DataItem;
    endAngle: number;
    innerRadius: number;
    outerRadius: number;
}
declare class GaugeArcComponent {
    backgroundArc: ArcItem;
    valueArc: ArcItem;
    cornerRadius: number;
    colors: ColorHelper;
    isActive: boolean;
    tooltipDisabled: boolean;
    valueFormatting: (value: any) => string;
    tooltipTemplate: TemplateRef<any>;
    animations: boolean;
    select: EventEmitter<any>;
    activate: EventEmitter<any>;
    deactivate: EventEmitter<any>;
    placementTypes: typeof PlacementTypes;
    styleTypes: typeof StyleTypes;
    tooltipText(arc: ArcItem): string;
    static ɵfac: i0.ɵɵFactoryDeclaration<GaugeArcComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<GaugeArcComponent, "g[ngx-charts-gauge-arc]", never, { "backgroundArc": { "alias": "backgroundArc"; "required": false; }; "valueArc": { "alias": "valueArc"; "required": false; }; "cornerRadius": { "alias": "cornerRadius"; "required": false; }; "colors": { "alias": "colors"; "required": false; }; "isActive": { "alias": "isActive"; "required": false; }; "tooltipDisabled": { "alias": "tooltipDisabled"; "required": false; }; "valueFormatting": { "alias": "valueFormatting"; "required": false; }; "tooltipTemplate": { "alias": "tooltipTemplate"; "required": false; }; "animations": { "alias": "animations"; "required": false; }; }, { "select": "select"; "activate": "activate"; "deactivate": "deactivate"; }, never, never, false, never>;
}

interface Arcs {
    backgroundArc: ArcItem;
    valueArc: ArcItem;
}
declare class GaugeComponent extends BaseChartComponent implements AfterViewInit {
    legend: boolean;
    legendTitle: string;
    legendPosition: LegendPosition;
    min: number;
    max: number;
    textValue: string;
    units: string;
    bigSegments: number;
    smallSegments: number;
    results: any[];
    showAxis: boolean;
    startAngle: number;
    angleSpan: number;
    activeEntries: any[];
    axisTickFormatting: any;
    tooltipDisabled: boolean;
    valueFormatting: (value: any) => string;
    showText: boolean;
    margin: number[];
    activate: EventEmitter<any>;
    deactivate: EventEmitter<any>;
    tooltipTemplate: TemplateRef<any>;
    textEl: ElementRef;
    dims: ViewDimensions;
    domain: any[];
    valueDomain: [number, number];
    valueScale: any;
    colors: ColorHelper;
    transform: string;
    outerRadius: number;
    textRadius: number;
    resizeScale: number;
    rotation: string;
    textTransform: string;
    cornerRadius: number;
    arcs: Arcs[];
    displayValue: string;
    legendOptions: LegendOptions;
    ngOnChanges(): void;
    ngAfterViewInit(): void;
    update(): void;
    getArcs(): any[];
    getDomain(): string[];
    getValueDomain(): [number, number];
    getValueScale(): any;
    getDisplayValue(): string;
    scaleText(repeat?: boolean): void;
    onClick(data: any): void;
    getLegendOptions(): LegendOptions;
    setColors(): void;
    onActivate(item: any): void;
    onDeactivate(item: any): void;
    isActive(entry: any): boolean;
    trackBy(index: number, item: Arcs): any;
    static ɵfac: i0.ɵɵFactoryDeclaration<GaugeComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<GaugeComponent, "ngx-charts-gauge", never, { "legend": { "alias": "legend"; "required": false; }; "legendTitle": { "alias": "legendTitle"; "required": false; }; "legendPosition": { "alias": "legendPosition"; "required": false; }; "min": { "alias": "min"; "required": false; }; "max": { "alias": "max"; "required": false; }; "textValue": { "alias": "textValue"; "required": false; }; "units": { "alias": "units"; "required": false; }; "bigSegments": { "alias": "bigSegments"; "required": false; }; "smallSegments": { "alias": "smallSegments"; "required": false; }; "results": { "alias": "results"; "required": false; }; "showAxis": { "alias": "showAxis"; "required": false; }; "startAngle": { "alias": "startAngle"; "required": false; }; "angleSpan": { "alias": "angleSpan"; "required": false; }; "activeEntries": { "alias": "activeEntries"; "required": false; }; "axisTickFormatting": { "alias": "axisTickFormatting"; "required": false; }; "tooltipDisabled": { "alias": "tooltipDisabled"; "required": false; }; "valueFormatting": { "alias": "valueFormatting"; "required": false; }; "showText": { "alias": "showText"; "required": false; }; "margin": { "alias": "margin"; "required": false; }; }, { "activate": "activate"; "deactivate": "deactivate"; }, ["tooltipTemplate"], never, false, never>;
}

interface Big {
    line: string;
    text: string;
    textAnchor: string;
    textTransform: string;
}
interface Ticks {
    big: Big[];
    small: Array<{
        line: string;
    }>;
}
declare class GaugeAxisComponent implements OnChanges {
    bigSegments: number;
    smallSegments: number;
    min: number;
    max: number;
    angleSpan: number;
    startAngle: number;
    radius: number;
    valueScale: any;
    tickFormatting: any;
    ticks: Ticks;
    rotationAngle: number;
    rotate: string;
    ngOnChanges(changes: SimpleChanges): void;
    update(): void;
    getTicks(): Ticks;
    getTextAnchor(angle: number): TextAnchor;
    getTickPath(startDistance: number, tickLength: number, angle: number): any;
    static ɵfac: i0.ɵɵFactoryDeclaration<GaugeAxisComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<GaugeAxisComponent, "g[ngx-charts-gauge-axis]", never, { "bigSegments": { "alias": "bigSegments"; "required": false; }; "smallSegments": { "alias": "smallSegments"; "required": false; }; "min": { "alias": "min"; "required": false; }; "max": { "alias": "max"; "required": false; }; "angleSpan": { "alias": "angleSpan"; "required": false; }; "startAngle": { "alias": "startAngle"; "required": false; }; "radius": { "alias": "radius"; "required": false; }; "valueScale": { "alias": "valueScale"; "required": false; }; "tickFormatting": { "alias": "tickFormatting"; "required": false; }; }, {}, never, never, false, never>;
}

declare class PercentGaugeComponent extends BaseChartComponent {
    max: number;
    value: number;
    target: number;
    targetLabel: string;
    label: string;
    valueFormatting: any;
    showLabel: boolean;
    defaultMargin: number[];
    margin: number[];
    dims: ViewDimensions;
    colors: ColorHelper;
    radius: number;
    transform: string;
    targetTransform: string;
    targetColor: string;
    targetRadius: number;
    targetTextTransform: string;
    circleMaskId: string;
    circleTransform: string;
    ticks: any[];
    ticHeight: number;
    dashes: string;
    valueDomain: [number, number];
    valueFontSize: number;
    displayValue: string;
    percent: number;
    circumference: number;
    labelTransform: string;
    update(): void;
    generateCirclePoints(radius: number, numPoints: number): {
        x: number;
        y: number;
    }[];
    generateticks(): void;
    getValueDomain(): [number, number];
    getDisplayValue(): string;
    getPercentage(): number;
    onClick(): void;
    setColors(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<PercentGaugeComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<PercentGaugeComponent, "ngx-charts-percent-gauge", never, { "max": { "alias": "max"; "required": false; }; "value": { "alias": "value"; "required": false; }; "target": { "alias": "target"; "required": false; }; "targetLabel": { "alias": "targetLabel"; "required": false; }; "label": { "alias": "label"; "required": false; }; "valueFormatting": { "alias": "valueFormatting"; "required": false; }; "showLabel": { "alias": "showLabel"; "required": false; }; }, {}, never, never, false, never>;
}

declare class GaugeModule {
    static ɵfac: i0.ɵɵFactoryDeclaration<GaugeModule, never>;
    static ɵmod: i0.ɵɵNgModuleDeclaration<GaugeModule, [typeof LinearGaugeComponent, typeof GaugeComponent, typeof GaugeArcComponent, typeof GaugeAxisComponent, typeof PercentGaugeComponent], [typeof ChartCommonModule, typeof PieChartModule, typeof BarChartModule], [typeof LinearGaugeComponent, typeof GaugeComponent, typeof GaugeArcComponent, typeof GaugeAxisComponent, typeof PercentGaugeComponent]>;
    static ɵinj: i0.ɵɵInjectorDeclaration<GaugeModule>;
}

declare class NgxChartsModule {
    constructor();
    static ɵfac: i0.ɵɵFactoryDeclaration<NgxChartsModule, never>;
    static ɵmod: i0.ɵɵNgModuleDeclaration<NgxChartsModule, never, never, [typeof ChartCommonModule, typeof AreaChartModule, typeof BarChartModule, typeof BoxChartModule, typeof BubbleChartModule, typeof HeatMapModule, typeof SankeyModule, typeof LineChartModule, typeof PolarChartModule, typeof NumberCardModule, typeof PieChartModule, typeof TreeMapModule, typeof GaugeModule]>;
    static ɵinj: i0.ɵɵInjectorDeclaration<NgxChartsModule>;
}

declare enum D0Types {
    positive = "positive",
    negative = "negative"
}

declare function getDomain(values: any[], scaleType: ScaleType, autoScale: boolean, minVal?: number, maxVal?: number): number[];
declare function getScale(domain: number[], range: number[], scaleType: ScaleType, roundDomains: boolean): ScaleTime<number, number> | ScaleLinear<number, number> | ScalePoint<string>;

declare function reduceTicks(ticks: any[], maxTicks: number): any[];
declare function getTickLines(label: string, maxLength: number, maxLines: number): string[];

/**
 * Counts from a number to the end incrementally.
 */
declare function count(countFrom: number, countTo: number, countDecimals: number, countDuration: number, callback: any): number;
/**
 * Determine decimals places
 *
 * @export
 */
declare function decimalChecker(countTo: number): number;

declare function tickFormat(fieldType: any, groupByType: any): (label: string) => string;

declare function trimLabel(s: any, max?: number): string;

declare function calculateViewDimensions({ width, height, margins, showXAxis, showYAxis, xAxisHeight, yAxisWidth, showXLabel, showYLabel, showLegend, legendType, legendPosition, columns }: {
    width: any;
    height: any;
    margins: any;
    showXAxis?: boolean;
    showYAxis?: boolean;
    xAxisHeight?: number;
    yAxisWidth?: number;
    showXLabel?: boolean;
    showYLabel?: boolean;
    showLegend?: boolean;
    legendType?: ScaleType;
    legendPosition?: LegendPosition;
    columns?: number;
}): ViewDimensions;

/**
 * Formats a label given a date, number or string.
 *
 * @export
 */
declare function formatLabel(label: any): string;
/**
 * Escapes a label.
 *
 * @export
 */
declare function escapeLabel(label: any): string;

/**
 * Based on the data, return an array with unique values.
 *
 * @export
 * @returns array
 */
declare function getUniqueXDomainValues(results: any[]): any[];
/**
 * Get the scaleType of enumerable of values.
 * @returns  'time', 'linear' or 'ordinal'
 */
declare function getScaleType(values: any[], checkDateType?: boolean): ScaleType;
declare function getXDomainArray(values: Array<string | number | Date>, xScaleMin?: number, xScaleMax?: number): {
    domain: any[];
    xSet: any[];
    scaleType: string;
};

/**
 * Generates a short id.
 *
 * Description:
 *   A 4-character alphanumeric sequence (364 = 1.6 million)
 *   This should only be used for JavaScript specific models.
 *   http://stackoverflow.com/questions/6248666/how-to-generate-short-uid-like-ax4j9z-in-js
 *
 *   Example: `ebgf`
 */
declare function id(): string;

declare function sortLinear(data: any, property: string, direction?: string): any[];
declare function sortByDomain(data: any, property: string, direction: string, domain: any): any[];
declare function sortByTime(data: any, property: string, direction?: string): any[];

/**
 * Throttle a function
 *
 */
declare function throttle(func: any, wait: number, options?: any): () => any;
/**
 * Throttle decorator
 *
 *  class MyClass {
 *    throttleable(10)
 *    myFn() { ... }
 *  }
 */
declare function throttleable(duration: number, options?: any): (target: any, key: any, descriptor: any) => {
    configurable: boolean;
    enumerable: any;
    get: () => any;
};

/**
 * Converts a hex to RGB
 *
 * @export
 */
declare function hexToRgb(value: string): any;
/**
 * Accepts a color (string) and returns a inverted hex color (string)
 * http://stackoverflow.com/questions/9600295/automatically-change-text-color-to-assure-readability
 *
 * @export
 */
declare function invertColor(value: string): string;
/**
 * Given a rgb, it will darken/lighten
 * http://stackoverflow.com/questions/5560248/programmatically-lighten-or-darken-a-hex-color-or-rgb-and-blend-colors
 *
 * @export
 * @param \{ r, g, b }
 */
declare function shadeRGBColor({ r, g, b }: {
    r: any;
    g: any;
    b: any;
}, percent: number): string;

export { AdvancedLegendComponent, AdvancedPieChartComponent, AreaChartComponent, AreaChartModule, AreaChartNormalizedComponent, AreaChartStackedComponent, AreaComponent, AreaSeriesComponent, AxesModule, AxisLabelComponent, BarChartModule, BarChartType, BarComponent, BarHorizontal2DComponent, BarHorizontalComponent, BarHorizontalNormalizedComponent, BarHorizontalStackedComponent, BarLabelComponent, BarOrientation, BarVertical2DComponent, BarVerticalComponent, BarVerticalNormalizedComponent, BarVerticalStackedComponent, BaseChartComponent, BoxChartComponent, BoxChartModule, BoxComponent, BoxSeriesComponent, BubbleChartComponent, BubbleChartModule, BubbleSeriesComponent, CardComponent, CardSeriesComponent, ChartCommonModule, ChartComponent, CircleComponent, CircleSeriesComponent, ColorHelper, CountUpDirective, D0Types, GaugeArcComponent, GaugeAxisComponent, GaugeComponent, GaugeModule, GridPanelComponent, GridPanelSeriesComponent, HeatCellSeriesComponent, HeatMapCellComponent, HeatMapComponent, HeatMapModule, LegendComponent, LegendEntryComponent, LegendPosition, LegendType, LineChartComponent, LineChartModule, LineComponent, LineSeriesComponent, LinearGaugeComponent, NgxChartsModule, NumberCardComponent, NumberCardModule, Orientation, PercentGaugeComponent, PieArcComponent, PieChartComponent, PieChartModule, PieGridComponent, PieGridSeriesComponent, PieLabelComponent, PieSeriesComponent, PlacementTypes, PolarChartComponent, PolarChartModule, PolarSeriesComponent, SankeyComponent, SankeyModule, ScaleLegendComponent, ScaleType, SeriesHorizontal, SeriesType, SeriesVerticalComponent, ShowTypes, StyleTypes, SvgLinearGradientComponent, SvgRadialGradientComponent, TextAnchor, Timeline, TooltipArea, TooltipContentComponent, TooltipDirective, TooltipModule, TooltipService, TreeMapCellComponent, TreeMapCellSeriesComponent, TreeMapComponent, TreeMapModule, VisibilityObserver, XAxisComponent, XAxisTicksComponent, YAxisComponent, YAxisTicksComponent, calculateViewDimensions, cloneLineCoordinates, clonePoint, cloneVector2d, colorSets, count, decimalChecker, escapeLabel, formatLabel, getDomain, getScale, getScaleType, getTickLines, getUniqueXDomainValues, getXDomainArray, gridLayout, gridSize, hexToRgb, id, invertColor, reduceTicks, shadeRGBColor, sortByDomain, sortByTime, sortLinear, throttle, throttleable, tickFormat, trimLabel };
export type { AdvancedLegendItem, ArcItem, AreaChartDataItem, AreaChartSeries, Bar, BoxChartMultiSeries, BoxChartSeries, BubbleChartDataItem, BubbleChartMultiSeries, BubbleChartSeries, CardModel, Circle, Color, DataItem, Gradient, GridData, GridItem, IBoxModel, LegendEntry, LegendOptions, MultiSeries, PieArc, PieData, PieGridData, PieGridDataItem, SankeyData, SankeyObject, Series, SingleSeries, StringOrNumberOrDate, Tooltip, TreeMapData, TreeMapDataItem, ViewDimensions };