@swimlane/ngx-charts/index.d.ts

Declarative Charting Framework for Angular

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": "xAxisLa