@swimlane/ngx-charts

  • Version 20.1.0
  • Published
  • 6.03 MB
  • 13 dependencies
  • MIT license

Install

npm i @swimlane/ngx-charts
yarn add @swimlane/ngx-charts
pnpm add @swimlane/ngx-charts

Overview

Declarative Charting Framework for Angular

Index

Variables

Functions

Classes

Interfaces

Enums

Type Aliases

Variables

variable colorSets

let colorSets: Color[];

    Functions

    function calculateViewDimensions

    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;

      function count

      count: (
      countFrom: number,
      countTo: number,
      countDecimals: number,
      countDuration: number,
      callback: any
      ) => number;
      • Counts from a number to the end incrementally.

      function decimalChecker

      decimalChecker: (countTo: number) => number;
      • Determine decimals places

      function escapeLabel

      escapeLabel: (label: any) => string;
      • Escapes a label.

      function formatLabel

      formatLabel: (label: any) => string;
      • Formats a label given a date, number or string.

      function getDomain

      getDomain: (
      values: any[],
      scaleType: ScaleType,
      autoScale: boolean,
      minVal?: number,
      maxVal?: number
      ) => number[];

        function getScale

        getScale: (
        domain: number[],
        range: number[],
        scaleType: ScaleType,
        roundDomains: boolean
        ) => ScaleTime<number, number> | ScaleLinear<number, number> | ScalePoint<string>;

          function getScaleType

          getScaleType: (values: any[], checkDateType?: boolean) => ScaleType;
          • Get the scaleType of enumerable of values.

            Returns

            'time', 'linear' or 'ordinal'

          function getUniqueXDomainValues

          getUniqueXDomainValues: (results: any[]) => any[];
          • Based on the data, return an array with unique values.

            Returns

            array

          function getXDomainArray

          getXDomainArray: (
          values: Array<string | number | Date>,
          xScaleMin?: number,
          xScaleMax?: number
          ) => { domain: any[]; xSet: any[]; scaleType: string };

            function gridLayout

            gridLayout: (
            dims: ViewDimensions,
            data: GridData[],
            minWidth: number,
            designatedTotal: number
            ) => GridItem[];

              function gridSize

              gridSize: (
              dims: ViewDimensions,
              len: number,
              minWidth: number
              ) => [number, number];

                function hexToRgb

                hexToRgb: (value: string) => any;
                • Converts a hex to RGB

                function id

                id: () => 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

                function invertColor

                invertColor: (value: string) => string;
                • Accepts a color (string) and returns a inverted hex color (string) http://stackoverflow.com/questions/9600295/automatically-change-text-color-to-assure-readability

                function reduceTicks

                reduceTicks: (ticks: any[], maxTicks: number) => any[];

                  function shadeRGBColor

                  shadeRGBColor: (
                  { r, g, b }: { r: any; g: any; b: any },
                  percent: number
                  ) => 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

                    Parameter

                    { r, g, b }

                  function sortByDomain

                  sortByDomain: (
                  data: any,
                  property: string,
                  direction: string,
                  domain: any
                  ) => any[];

                    function sortByTime

                    sortByTime: (data: any, property: string, direction?: string) => any[];

                      function sortLinear

                      sortLinear: (data: any, property: string, direction?: string) => any[];

                        function throttle

                        throttle: (func: any, wait: number, options?: any) => () => any;
                        • Throttle a function

                        function throttleable

                        throttleable: (
                        duration: number,
                        options?: any
                        ) => (
                        target: any,
                        key: any,
                        descriptor: any
                        ) => { configurable: boolean; enumerable: any; get: () => any };
                        • Throttle decorator

                          class MyClass { throttleable(10) myFn() { ... } }

                        function tickFormat

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

                          function trimLabel

                          trimLabel: (s: any, max?: number) => string;

                            Classes

                            class AdvancedLegendComponent

                            class AdvancedLegendComponent implements OnChanges {}

                              property activate

                              activate: EventEmitter<DataItem>;

                                property animations

                                animations: boolean;

                                  property colors

                                  colors: ColorHelper;

                                    property data

                                    data: DataItem[];

                                      property deactivate

                                      deactivate: EventEmitter<DataItem>;

                                        property defaultValueFormatting

                                        defaultValueFormatting: (value: StringOrNumberOrDate) => string;

                                          property label

                                          label: string;

                                            property labelFormatting

                                            labelFormatting: (value: string) => string;

                                              property legendItems

                                              legendItems: AdvancedLegendItem[];

                                                property ɵcmp

                                                static ɵcmp: i0.ɵɵComponentDeclaration<
                                                AdvancedLegendComponent,
                                                'ngx-charts-advanced-legend',
                                                never,
                                                {
                                                width: 'width';
                                                data: 'data';
                                                colors: 'colors';
                                                label: 'label';
                                                animations: 'animations';
                                                valueFormatting: 'valueFormatting';
                                                labelFormatting: 'labelFormatting';
                                                percentageFormatting: 'percentageFormatting';
                                                },
                                                { select: 'select'; activate: 'activate'; deactivate: 'deactivate' },
                                                never,
                                                never
                                                >;

                                                  property ɵfac

                                                  static ɵfac: i0.ɵɵFactoryDeclaration<AdvancedLegendComponent, never>;

                                                    property percentageFormatting

                                                    percentageFormatting: (value: number) => number;

                                                      property roundedTotal

                                                      roundedTotal: number;

                                                        property select

                                                        select: EventEmitter<DataItem>;

                                                          property total

                                                          total: number;

                                                            property valueFormatting

                                                            valueFormatting: (value: StringOrNumberOrDate) => any;

                                                              property width

                                                              width: number;

                                                                method getLegendItems

                                                                getLegendItems: () => AdvancedLegendItem[];

                                                                  method getTotal

                                                                  getTotal: () => number;

                                                                    method ngOnChanges

                                                                    ngOnChanges: (changes: SimpleChanges) => void;

                                                                      method trackBy

                                                                      trackBy: (index: number, item: AdvancedLegendItem) => string;

                                                                        method update

                                                                        update: () => void;

                                                                          class AdvancedPieChartComponent

                                                                          class AdvancedPieChartComponent extends BaseChartComponent {}

                                                                            property activate

                                                                            activate: EventEmitter<any>;

                                                                              property activeEntries

                                                                              activeEntries: any[];

                                                                                property colors

                                                                                colors: ColorHelper;

                                                                                  property deactivate

                                                                                  deactivate: EventEmitter<any>;

                                                                                    property dims

                                                                                    dims: ViewDimensions;

                                                                                      property domain

                                                                                      domain: string[];

                                                                                        property gradient

                                                                                        gradient: boolean;

                                                                                          property innerRadius

                                                                                          innerRadius: number;

                                                                                            property label

                                                                                            label: string;

                                                                                              property legendWidth

                                                                                              legendWidth: number;

                                                                                                property margin

                                                                                                margin: number[];

                                                                                                  property nameFormatting

                                                                                                  nameFormatting: (value: string) => any;

                                                                                                    property outerRadius

                                                                                                    outerRadius: number;

                                                                                                      property ɵcmp

                                                                                                      static ɵcmp: i0.ɵɵComponentDeclaration<
                                                                                                      AdvancedPieChartComponent,
                                                                                                      'ngx-charts-advanced-pie-chart',
                                                                                                      never,
                                                                                                      {
                                                                                                      gradient: 'gradient';
                                                                                                      activeEntries: 'activeEntries';
                                                                                                      tooltipDisabled: 'tooltipDisabled';
                                                                                                      tooltipText: 'tooltipText';
                                                                                                      label: 'label';
                                                                                                      valueFormatting: 'valueFormatting';
                                                                                                      nameFormatting: 'nameFormatting';
                                                                                                      percentageFormatting: 'percentageFormatting';
                                                                                                      },
                                                                                                      { activate: 'activate'; deactivate: 'deactivate' },
                                                                                                      ['tooltipTemplate'],
                                                                                                      never
                                                                                                      >;

                                                                                                        property ɵfac

                                                                                                        static ɵfac: i0.ɵɵFactoryDeclaration<AdvancedPieChartComponent, never>;

                                                                                                          property percentageFormatting

                                                                                                          percentageFormatting: (value: number) => any;

                                                                                                            property tooltipDisabled

                                                                                                            tooltipDisabled: boolean;

                                                                                                              property tooltipTemplate

                                                                                                              tooltipTemplate: TemplateRef<any>;

                                                                                                                property tooltipText

                                                                                                                tooltipText: any;

                                                                                                                  property transform

                                                                                                                  transform: string;

                                                                                                                    property valueFormatting

                                                                                                                    valueFormatting: (value: number) => any;

                                                                                                                      method getDomain

                                                                                                                      getDomain: () => string[];

                                                                                                                        method onActivate

                                                                                                                        onActivate: (item: any, fromLegend?: boolean) => void;

                                                                                                                          method onClick

                                                                                                                          onClick: (data: DataItem) => void;

                                                                                                                            method onDeactivate

                                                                                                                            onDeactivate: (item: any, fromLegend?: boolean) => void;

                                                                                                                              method setColors

                                                                                                                              setColors: () => void;

                                                                                                                                method update

                                                                                                                                update: () => void;

                                                                                                                                  class AreaChartComponent

                                                                                                                                  class AreaChartComponent extends BaseChartComponent {}

                                                                                                                                    property activate

                                                                                                                                    activate: EventEmitter<any>;

                                                                                                                                      property activeEntries

                                                                                                                                      activeEntries: any[];

                                                                                                                                        property autoScale

                                                                                                                                        autoScale: boolean;

                                                                                                                                          property baseValue

                                                                                                                                          baseValue: any;

                                                                                                                                            property clipPath

                                                                                                                                            clipPath: string;

                                                                                                                                              property clipPathId

                                                                                                                                              clipPathId: string;

                                                                                                                                                property colors

                                                                                                                                                colors: ColorHelper;

                                                                                                                                                  property curve

                                                                                                                                                  curve: CurveFactory;

                                                                                                                                                    property deactivate

                                                                                                                                                    deactivate: EventEmitter<any>;

                                                                                                                                                      property dims

                                                                                                                                                      dims: ViewDimensions;

                                                                                                                                                        property filteredDomain

                                                                                                                                                        filteredDomain: any;

                                                                                                                                                          property gradient

                                                                                                                                                          gradient: boolean;

                                                                                                                                                            property hoveredVertical

                                                                                                                                                            hoveredVertical: any;

                                                                                                                                                              property legend

                                                                                                                                                              legend: boolean;

                                                                                                                                                                property legendOptions

                                                                                                                                                                legendOptions: LegendOptions;

                                                                                                                                                                  property legendPosition

                                                                                                                                                                  legendPosition: LegendPosition;

                                                                                                                                                                    property legendTitle

                                                                                                                                                                    legendTitle: string;

                                                                                                                                                                      property margin

                                                                                                                                                                      margin: number[];

                                                                                                                                                                        property maxXAxisTickLength

                                                                                                                                                                        maxXAxisTickLength: number;

                                                                                                                                                                          property maxYAxisTickLength

                                                                                                                                                                          maxYAxisTickLength: number;

                                                                                                                                                                            property ɵcmp

                                                                                                                                                                            static ɵcmp: i0.ɵɵComponentDeclaration<
                                                                                                                                                                            AreaChartComponent,
                                                                                                                                                                            'ngx-charts-area-chart',
                                                                                                                                                                            never,
                                                                                                                                                                            {
                                                                                                                                                                            legend: 'legend';
                                                                                                                                                                            legendTitle: 'legendTitle';
                                                                                                                                                                            legendPosition: 'legendPosition';
                                                                                                                                                                            xAxis: 'xAxis';
                                                                                                                                                                            yAxis: 'yAxis';
                                                                                                                                                                            baseValue: 'baseValue';
                                                                                                                                                                            autoScale: 'autoScale';
                                                                                                                                                                            showXAxisLabel: 'showXAxisLabel';
                                                                                                                                                                            showYAxisLabel: 'showYAxisLabel';
                                                                                                                                                                            xAxisLabel: 'xAxisLabel';
                                                                                                                                                                            yAxisLabel: 'yAxisLabel';
                                                                                                                                                                            timeline: 'timeline';
                                                                                                                                                                            gradient: 'gradient';
                                                                                                                                                                            showGridLines: 'showGridLines';
                                                                                                                                                                            curve: 'curve';
                                                                                                                                                                            activeEntries: 'activeEntries';
                                                                                                                                                                            schemeType: 'schemeType';
                                                                                                                                                                            trimXAxisTicks: 'trimXAxisTicks';
                                                                                                                                                                            trimYAxisTicks: 'trimYAxisTicks';
                                                                                                                                                                            rotateXAxisTicks: 'rotateXAxisTicks';
                                                                                                                                                                            maxXAxisTickLength: 'maxXAxisTickLength';
                                                                                                                                                                            maxYAxisTickLength: 'maxYAxisTickLength';
                                                                                                                                                                            xAxisTickFormatting: 'xAxisTickFormatting';
                                                                                                                                                                            yAxisTickFormatting: 'yAxisTickFormatting';
                                                                                                                                                                            xAxisTicks: 'xAxisTicks';
                                                                                                                                                                            yAxisTicks: 'yAxisTicks';
                                                                                                                                                                            roundDomains: 'roundDomains';
                                                                                                                                                                            tooltipDisabled: 'tooltipDisabled';
                                                                                                                                                                            xScaleMin: 'xScaleMin';
                                                                                                                                                                            xScaleMax: 'xScaleMax';
                                                                                                                                                                            yScaleMin: 'yScaleMin';
                                                                                                                                                                            yScaleMax: 'yScaleMax';
                                                                                                                                                                            },
                                                                                                                                                                            { activate: 'activate'; deactivate: 'deactivate' },
                                                                                                                                                                            ['tooltipTemplate', 'seriesTooltipTemplate'],
                                                                                                                                                                            never
                                                                                                                                                                            >;

                                                                                                                                                                              property ɵfac

                                                                                                                                                                              static ɵfac: i0.ɵɵFactoryDeclaration<AreaChartComponent, never>;

                                                                                                                                                                                property rotateXAxisTicks

                                                                                                                                                                                rotateXAxisTicks: boolean;

                                                                                                                                                                                  property roundDomains

                                                                                                                                                                                  roundDomains: boolean;

                                                                                                                                                                                    property scaleType

                                                                                                                                                                                    scaleType: ScaleType;

                                                                                                                                                                                      property schemeType

                                                                                                                                                                                      schemeType: ScaleType;

                                                                                                                                                                                        property series

                                                                                                                                                                                        series: Series;

                                                                                                                                                                                          property seriesDomain

                                                                                                                                                                                          seriesDomain: string[];

                                                                                                                                                                                            property seriesTooltipTemplate

                                                                                                                                                                                            seriesTooltipTemplate: TemplateRef<any>;

                                                                                                                                                                                              property showGridLines

                                                                                                                                                                                              showGridLines: boolean;

                                                                                                                                                                                                property showXAxisLabel

                                                                                                                                                                                                showXAxisLabel: boolean;

                                                                                                                                                                                                  property showYAxisLabel

                                                                                                                                                                                                  showYAxisLabel: boolean;

                                                                                                                                                                                                    property timeline

                                                                                                                                                                                                    timeline: boolean;

                                                                                                                                                                                                      property timelineHeight

                                                                                                                                                                                                      timelineHeight: number;

                                                                                                                                                                                                        property timelinePadding

                                                                                                                                                                                                        timelinePadding: number;

                                                                                                                                                                                                          property timelineTransform

                                                                                                                                                                                                          timelineTransform: any;

                                                                                                                                                                                                            property timelineWidth

                                                                                                                                                                                                            timelineWidth: number;

                                                                                                                                                                                                              property timelineXDomain

                                                                                                                                                                                                              timelineXDomain: any[];

                                                                                                                                                                                                                property timelineXScale

                                                                                                                                                                                                                timelineXScale: any;

                                                                                                                                                                                                                  property timelineYScale

                                                                                                                                                                                                                  timelineYScale: any;

                                                                                                                                                                                                                    property tooltipDisabled

                                                                                                                                                                                                                    tooltipDisabled: boolean;

                                                                                                                                                                                                                      property tooltipTemplate

                                                                                                                                                                                                                      tooltipTemplate: TemplateRef<any>;

                                                                                                                                                                                                                        property trackBy

                                                                                                                                                                                                                        trackBy: TrackByFunction<Series>;

                                                                                                                                                                                                                          property transform

                                                                                                                                                                                                                          transform: string;

                                                                                                                                                                                                                            property trimXAxisTicks

                                                                                                                                                                                                                            trimXAxisTicks: boolean;

                                                                                                                                                                                                                              property trimYAxisTicks

                                                                                                                                                                                                                              trimYAxisTicks: boolean;

                                                                                                                                                                                                                                property xAxis

                                                                                                                                                                                                                                xAxis: boolean;

                                                                                                                                                                                                                                  property xAxisHeight

                                                                                                                                                                                                                                  xAxisHeight: number;

                                                                                                                                                                                                                                    property xAxisLabel

                                                                                                                                                                                                                                    xAxisLabel: string;

                                                                                                                                                                                                                                      property xAxisTickFormatting

                                                                                                                                                                                                                                      xAxisTickFormatting: any;

                                                                                                                                                                                                                                        property xAxisTicks

                                                                                                                                                                                                                                        xAxisTicks: any[];

                                                                                                                                                                                                                                          property xDomain

                                                                                                                                                                                                                                          xDomain: any[];

                                                                                                                                                                                                                                            property xScale

                                                                                                                                                                                                                                            xScale: any;

                                                                                                                                                                                                                                              property xScaleMax

                                                                                                                                                                                                                                              xScaleMax: any;

                                                                                                                                                                                                                                                property xScaleMin

                                                                                                                                                                                                                                                xScaleMin: any;

                                                                                                                                                                                                                                                  property xSet

                                                                                                                                                                                                                                                  xSet: any;

                                                                                                                                                                                                                                                    property yAxis

                                                                                                                                                                                                                                                    yAxis: boolean;

                                                                                                                                                                                                                                                      property yAxisLabel

                                                                                                                                                                                                                                                      yAxisLabel: string;

                                                                                                                                                                                                                                                        property yAxisTickFormatting

                                                                                                                                                                                                                                                        yAxisTickFormatting: any;

                                                                                                                                                                                                                                                          property yAxisTicks

                                                                                                                                                                                                                                                          yAxisTicks: any[];

                                                                                                                                                                                                                                                            property yAxisWidth

                                                                                                                                                                                                                                                            yAxisWidth: number;

                                                                                                                                                                                                                                                              property yDomain

                                                                                                                                                                                                                                                              yDomain: [number, number];

                                                                                                                                                                                                                                                                property yScale

                                                                                                                                                                                                                                                                yScale: any;

                                                                                                                                                                                                                                                                  property yScaleMax

                                                                                                                                                                                                                                                                  yScaleMax: number;

                                                                                                                                                                                                                                                                    property yScaleMin

                                                                                                                                                                                                                                                                    yScaleMin: number;

                                                                                                                                                                                                                                                                      method deactivateAll

                                                                                                                                                                                                                                                                      deactivateAll: () => void;

                                                                                                                                                                                                                                                                        method getLegendOptions

                                                                                                                                                                                                                                                                        getLegendOptions: () => LegendOptions;

                                                                                                                                                                                                                                                                          method getScaleType

                                                                                                                                                                                                                                                                          getScaleType: (values: any) => ScaleType;

                                                                                                                                                                                                                                                                            method getSeriesDomain

                                                                                                                                                                                                                                                                            getSeriesDomain: () => string[];

                                                                                                                                                                                                                                                                              method getXDomain

                                                                                                                                                                                                                                                                              getXDomain: () => any[];

                                                                                                                                                                                                                                                                                method getXScale

                                                                                                                                                                                                                                                                                getXScale: (domain: any, width: number) => number;

                                                                                                                                                                                                                                                                                  method getYDomain

                                                                                                                                                                                                                                                                                  getYDomain: () => [number, number];

                                                                                                                                                                                                                                                                                    method getYScale

                                                                                                                                                                                                                                                                                    getYScale: (domain: [number, number], height: number) => any;

                                                                                                                                                                                                                                                                                      method hideCircles

                                                                                                                                                                                                                                                                                      hideCircles: () => void;

                                                                                                                                                                                                                                                                                        method onActivate

                                                                                                                                                                                                                                                                                        onActivate: (item: any) => void;

                                                                                                                                                                                                                                                                                          method onClick

                                                                                                                                                                                                                                                                                          onClick: (data: any, series?: Series) => void;

                                                                                                                                                                                                                                                                                            method onDeactivate

                                                                                                                                                                                                                                                                                            onDeactivate: (item: any) => void;

                                                                                                                                                                                                                                                                                              method setColors

                                                                                                                                                                                                                                                                                              setColors: () => void;

                                                                                                                                                                                                                                                                                                method update

                                                                                                                                                                                                                                                                                                update: () => void;

                                                                                                                                                                                                                                                                                                  method updateDomain

                                                                                                                                                                                                                                                                                                  updateDomain: (domain: any) => void;

                                                                                                                                                                                                                                                                                                    method updateHoveredVertical

                                                                                                                                                                                                                                                                                                    updateHoveredVertical: (item: any) => void;

                                                                                                                                                                                                                                                                                                      method updateTimeline

                                                                                                                                                                                                                                                                                                      updateTimeline: () => void;

                                                                                                                                                                                                                                                                                                        method updateXAxisHeight

                                                                                                                                                                                                                                                                                                        updateXAxisHeight: ({ height }: { height: number }) => void;

                                                                                                                                                                                                                                                                                                          method updateYAxisWidth

                                                                                                                                                                                                                                                                                                          updateYAxisWidth: ({ width }: { width: number }) => void;

                                                                                                                                                                                                                                                                                                            class AreaChartModule

                                                                                                                                                                                                                                                                                                            class AreaChartModule {}

                                                                                                                                                                                                                                                                                                              property ɵfac

                                                                                                                                                                                                                                                                                                              static ɵfac: i0.ɵɵFactoryDeclaration<AreaChartModule, never>;

                                                                                                                                                                                                                                                                                                                property ɵinj

                                                                                                                                                                                                                                                                                                                static ɵinj: i0.ɵɵInjectorDeclaration<AreaChartModule>;

                                                                                                                                                                                                                                                                                                                  property ɵmod

                                                                                                                                                                                                                                                                                                                  static ɵmod: i0.ɵɵNgModuleDeclaration<
                                                                                                                                                                                                                                                                                                                  AreaChartModule,
                                                                                                                                                                                                                                                                                                                  [
                                                                                                                                                                                                                                                                                                                  typeof i1.AreaChartComponent,
                                                                                                                                                                                                                                                                                                                  typeof i2.AreaChartNormalizedComponent,
                                                                                                                                                                                                                                                                                                                  typeof i3.AreaChartStackedComponent,
                                                                                                                                                                                                                                                                                                                  typeof i4.AreaSeriesComponent
                                                                                                                                                                                                                                                                                                                  ],
                                                                                                                                                                                                                                                                                                                  [typeof i5.ChartCommonModule],
                                                                                                                                                                                                                                                                                                                  [
                                                                                                                                                                                                                                                                                                                  typeof i1.AreaChartComponent,
                                                                                                                                                                                                                                                                                                                  typeof i2.AreaChartNormalizedComponent,
                                                                                                                                                                                                                                                                                                                  typeof i3.AreaChartStackedComponent,
                                                                                                                                                                                                                                                                                                                  typeof i4.AreaSeriesComponent
                                                                                                                                                                                                                                                                                                                  ]
                                                                                                                                                                                                                                                                                                                  >;

                                                                                                                                                                                                                                                                                                                    class AreaChartNormalizedComponent

                                                                                                                                                                                                                                                                                                                    class AreaChartNormalizedComponent extends BaseChartComponent {}

                                                                                                                                                                                                                                                                                                                      property activate

                                                                                                                                                                                                                                                                                                                      activate: EventEmitter<any>;

                                                                                                                                                                                                                                                                                                                        property activeEntries

                                                                                                                                                                                                                                                                                                                        activeEntries: any[];

                                                                                                                                                                                                                                                                                                                          property clipPath

                                                                                                                                                                                                                                                                                                                          clipPath: string;

                                                                                                                                                                                                                                                                                                                            property clipPathId

                                                                                                                                                                                                                                                                                                                            clipPathId: string;

                                                                                                                                                                                                                                                                                                                              property colors

                                                                                                                                                                                                                                                                                                                              colors: ColorHelper;

                                                                                                                                                                                                                                                                                                                                property curve

                                                                                                                                                                                                                                                                                                                                curve: any;

                                                                                                                                                                                                                                                                                                                                  property deactivate

                                                                                                                                                                                                                                                                                                                                  deactivate: EventEmitter<any>;

                                                                                                                                                                                                                                                                                                                                    property dims

                                                                                                                                                                                                                                                                                                                                    dims: ViewDimensions;

                                                                                                                                                                                                                                                                                                                                      property filteredDomain

                                                                                                                                                                                                                                                                                                                                      filteredDomain: any;

                                                                                                                                                                                                                                                                                                                                        property gradient

                                                                                                                                                                                                                                                                                                                                        gradient: any;

                                                                                                                                                                                                                                                                                                                                          property hoveredVertical

                                                                                                                                                                                                                                                                                                                                          hoveredVertical: any;

                                                                                                                                                                                                                                                                                                                                            property legend

                                                                                                                                                                                                                                                                                                                                            legend: boolean;

                                                                                                                                                                                                                                                                                                                                              property legendOptions

                                                                                                                                                                                                                                                                                                                                              legendOptions: LegendOptions;

                                                                                                                                                                                                                                                                                                                                                property legendPosition

                                                                                                                                                                                                                                                                                                                                                legendPosition: LegendPosition;

                                                                                                                                                                                                                                                                                                                                                  property legendTitle

                                                                                                                                                                                                                                                                                                                                                  legendTitle: string;

                                                                                                                                                                                                                                                                                                                                                    property margin

                                                                                                                                                                                                                                                                                                                                                    margin: number[];

                                                                                                                                                                                                                                                                                                                                                      property maxXAxisTickLength

                                                                                                                                                                                                                                                                                                                                                      maxXAxisTickLength: number;

                                                                                                                                                                                                                                                                                                                                                        property maxYAxisTickLength

                                                                                                                                                                                                                                                                                                                                                        maxYAxisTickLength: number;

                                                                                                                                                                                                                                                                                                                                                          property ɵcmp

                                                                                                                                                                                                                                                                                                                                                          static ɵcmp: i0.ɵɵComponentDeclaration<
                                                                                                                                                                                                                                                                                                                                                          AreaChartNormalizedComponent,
                                                                                                                                                                                                                                                                                                                                                          'ngx-charts-area-chart-normalized',
                                                                                                                                                                                                                                                                                                                                                          never,
                                                                                                                                                                                                                                                                                                                                                          {
                                                                                                                                                                                                                                                                                                                                                          legend: 'legend';
                                                                                                                                                                                                                                                                                                                                                          legendTitle: 'legendTitle';
                                                                                                                                                                                                                                                                                                                                                          legendPosition: 'legendPosition';
                                                                                                                                                                                                                                                                                                                                                          xAxis: 'xAxis';
                                                                                                                                                                                                                                                                                                                                                          yAxis: 'yAxis';
                                                                                                                                                                                                                                                                                                                                                          showXAxisLabel: 'showXAxisLabel';
                                                                                                                                                                                                                                                                                                                                                          showYAxisLabel: 'showYAxisLabel';
                                                                                                                                                                                                                                                                                                                                                          xAxisLabel: 'xAxisLabel';
                                                                                                                                                                                                                                                                                                                                                          yAxisLabel: 'yAxisLabel';
                                                                                                                                                                                                                                                                                                                                                          timeline: 'timeline';
                                                                                                                                                                                                                                                                                                                                                          gradient: 'gradient';
                                                                                                                                                                                                                                                                                                                                                          showGridLines: 'showGridLines';
                                                                                                                                                                                                                                                                                                                                                          curve: 'curve';
                                                                                                                                                                                                                                                                                                                                                          activeEntries: 'activeEntries';
                                                                                                                                                                                                                                                                                                                                                          schemeType: 'schemeType';
                                                                                                                                                                                                                                                                                                                                                          trimXAxisTicks: 'trimXAxisTicks';
                                                                                                                                                                                                                                                                                                                                                          trimYAxisTicks: 'trimYAxisTicks';
                                                                                                                                                                                                                                                                                                                                                          rotateXAxisTicks: 'rotateXAxisTicks';
                                                                                                                                                                                                                                                                                                                                                          maxXAxisTickLength: 'maxXAxisTickLength';
                                                                                                                                                                                                                                                                                                                                                          maxYAxisTickLength: 'maxYAxisTickLength';
                                                                                                                                                                                                                                                                                                                                                          xAxisTickFormatting: 'xAxisTickFormatting';
                                                                                                                                                                                                                                                                                                                                                          yAxisTickFormatting: 'yAxisTickFormatting';
                                                                                                                                                                                                                                                                                                                                                          xAxisTicks: 'xAxisTicks';
                                                                                                                                                                                                                                                                                                                                                          yAxisTicks: 'yAxisTicks';
                                                                                                                                                                                                                                                                                                                                                          roundDomains: 'roundDomains';
                                                                                                                                                                                                                                                                                                                                                          tooltipDisabled: 'tooltipDisabled';
                                                                                                                                                                                                                                                                                                                                                          },
                                                                                                                                                                                                                                                                                                                                                          { activate: 'activate'; deactivate: 'deactivate' },
                                                                                                                                                                                                                                                                                                                                                          ['tooltipTemplate', 'seriesTooltipTemplate'],
                                                                                                                                                                                                                                                                                                                                                          never
                                                                                                                                                                                                                                                                                                                                                          >;

                                                                                                                                                                                                                                                                                                                                                            property ɵfac

                                                                                                                                                                                                                                                                                                                                                            static ɵfac: i0.ɵɵFactoryDeclaration<AreaChartNormalizedComponent, never>;

                                                                                                                                                                                                                                                                                                                                                              property rotateXAxisTicks

                                                                                                                                                                                                                                                                                                                                                              rotateXAxisTicks: boolean;

                                                                                                                                                                                                                                                                                                                                                                property roundDomains

                                                                                                                                                                                                                                                                                                                                                                roundDomains: boolean;

                                                                                                                                                                                                                                                                                                                                                                  property scaleType

                                                                                                                                                                                                                                                                                                                                                                  scaleType: ScaleType;

                                                                                                                                                                                                                                                                                                                                                                    property schemeType

                                                                                                                                                                                                                                                                                                                                                                    schemeType: ScaleType;

                                                                                                                                                                                                                                                                                                                                                                      property seriesDomain

                                                                                                                                                                                                                                                                                                                                                                      seriesDomain: any;

                                                                                                                                                                                                                                                                                                                                                                        property seriesTooltipTemplate

                                                                                                                                                                                                                                                                                                                                                                        seriesTooltipTemplate: TemplateRef<any>;

                                                                                                                                                                                                                                                                                                                                                                          property seriesType

                                                                                                                                                                                                                                                                                                                                                                          seriesType: typeof SeriesType;

                                                                                                                                                                                                                                                                                                                                                                            property showGridLines

                                                                                                                                                                                                                                                                                                                                                                            showGridLines: boolean;

                                                                                                                                                                                                                                                                                                                                                                              property showXAxisLabel

                                                                                                                                                                                                                                                                                                                                                                              showXAxisLabel: boolean;

                                                                                                                                                                                                                                                                                                                                                                                property showYAxisLabel

                                                                                                                                                                                                                                                                                                                                                                                showYAxisLabel: boolean;

                                                                                                                                                                                                                                                                                                                                                                                  property timeline

                                                                                                                                                                                                                                                                                                                                                                                  timeline: any;

                                                                                                                                                                                                                                                                                                                                                                                    property timelineHeight

                                                                                                                                                                                                                                                                                                                                                                                    timelineHeight: number;

                                                                                                                                                                                                                                                                                                                                                                                      property timelinePadding

                                                                                                                                                                                                                                                                                                                                                                                      timelinePadding: number;

                                                                                                                                                                                                                                                                                                                                                                                        property timelineTransform

                                                                                                                                                                                                                                                                                                                                                                                        timelineTransform: any;

                                                                                                                                                                                                                                                                                                                                                                                          property timelineWidth

                                                                                                                                                                                                                                                                                                                                                                                          timelineWidth: any;

                                                                                                                                                                                                                                                                                                                                                                                            property timelineXDomain

                                                                                                                                                                                                                                                                                                                                                                                            timelineXDomain: any;

                                                                                                                                                                                                                                                                                                                                                                                              property timelineXScale

                                                                                                                                                                                                                                                                                                                                                                                              timelineXScale: any;

                                                                                                                                                                                                                                                                                                                                                                                                property timelineYScale

                                                                                                                                                                                                                                                                                                                                                                                                timelineYScale: any;

                                                                                                                                                                                                                                                                                                                                                                                                  property tooltipAreas

                                                                                                                                                                                                                                                                                                                                                                                                  tooltipAreas: any[];

                                                                                                                                                                                                                                                                                                                                                                                                    property tooltipDisabled

                                                                                                                                                                                                                                                                                                                                                                                                    tooltipDisabled: boolean;

                                                                                                                                                                                                                                                                                                                                                                                                      property tooltipTemplate

                                                                                                                                                                                                                                                                                                                                                                                                      tooltipTemplate: TemplateRef<any>;

                                                                                                                                                                                                                                                                                                                                                                                                        property trackBy

                                                                                                                                                                                                                                                                                                                                                                                                        trackBy: TrackByFunction<Series>;

                                                                                                                                                                                                                                                                                                                                                                                                          property transform

                                                                                                                                                                                                                                                                                                                                                                                                          transform: string;

                                                                                                                                                                                                                                                                                                                                                                                                            property trimXAxisTicks

                                                                                                                                                                                                                                                                                                                                                                                                            trimXAxisTicks: boolean;

                                                                                                                                                                                                                                                                                                                                                                                                              property trimYAxisTicks

                                                                                                                                                                                                                                                                                                                                                                                                              trimYAxisTicks: boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                property xAxis

                                                                                                                                                                                                                                                                                                                                                                                                                xAxis: boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                  property xAxisHeight

                                                                                                                                                                                                                                                                                                                                                                                                                  xAxisHeight: number;

                                                                                                                                                                                                                                                                                                                                                                                                                    property xAxisLabel

                                                                                                                                                                                                                                                                                                                                                                                                                    xAxisLabel: string;

                                                                                                                                                                                                                                                                                                                                                                                                                      property xAxisTickFormatting

                                                                                                                                                                                                                                                                                                                                                                                                                      xAxisTickFormatting: any;

                                                                                                                                                                                                                                                                                                                                                                                                                        property xAxisTicks

                                                                                                                                                                                                                                                                                                                                                                                                                        xAxisTicks: any[];

                                                                                                                                                                                                                                                                                                                                                                                                                          property xDomain

                                                                                                                                                                                                                                                                                                                                                                                                                          xDomain: any[];

                                                                                                                                                                                                                                                                                                                                                                                                                            property xScale

                                                                                                                                                                                                                                                                                                                                                                                                                            xScale: any;

                                                                                                                                                                                                                                                                                                                                                                                                                              property xSet

                                                                                                                                                                                                                                                                                                                                                                                                                              xSet: any[];

                                                                                                                                                                                                                                                                                                                                                                                                                                property yAxis

                                                                                                                                                                                                                                                                                                                                                                                                                                yAxis: boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                  property yAxisLabel

                                                                                                                                                                                                                                                                                                                                                                                                                                  yAxisLabel: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                    property yAxisTickFormatting

                                                                                                                                                                                                                                                                                                                                                                                                                                    yAxisTickFormatting: any;

                                                                                                                                                                                                                                                                                                                                                                                                                                      property yAxisTicks

                                                                                                                                                                                                                                                                                                                                                                                                                                      yAxisTicks: any[];

                                                                                                                                                                                                                                                                                                                                                                                                                                        property yAxisWidth

                                                                                                                                                                                                                                                                                                                                                                                                                                        yAxisWidth: number;

                                                                                                                                                                                                                                                                                                                                                                                                                                          property yDomain

                                                                                                                                                                                                                                                                                                                                                                                                                                          yDomain: [number, number];

                                                                                                                                                                                                                                                                                                                                                                                                                                            property yScale

                                                                                                                                                                                                                                                                                                                                                                                                                                            yScale: any;

                                                                                                                                                                                                                                                                                                                                                                                                                                              method deactivateAll

                                                                                                                                                                                                                                                                                                                                                                                                                                              deactivateAll: () => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                method getLegendOptions

                                                                                                                                                                                                                                                                                                                                                                                                                                                getLegendOptions: () => LegendOptions;

                                                                                                                                                                                                                                                                                                                                                                                                                                                  method getSeriesDomain

                                                                                                                                                                                                                                                                                                                                                                                                                                                  getSeriesDomain: () => string[];

                                                                                                                                                                                                                                                                                                                                                                                                                                                    method getXDomain

                                                                                                                                                                                                                                                                                                                                                                                                                                                    getXDomain: () => any[];

                                                                                                                                                                                                                                                                                                                                                                                                                                                      method getXScale

                                                                                                                                                                                                                                                                                                                                                                                                                                                      getXScale: (domain: any, width: number) => any;

                                                                                                                                                                                                                                                                                                                                                                                                                                                        method getYScale

                                                                                                                                                                                                                                                                                                                                                                                                                                                        getYScale: (domain: any, height: number) => any;

                                                                                                                                                                                                                                                                                                                                                                                                                                                          method hideCircles

                                                                                                                                                                                                                                                                                                                                                                                                                                                          hideCircles: () => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                            method onActivate

                                                                                                                                                                                                                                                                                                                                                                                                                                                            onActivate: (item: any) => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                              method onClick

                                                                                                                                                                                                                                                                                                                                                                                                                                                              onClick: (data: any, series?: any) => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                method onDeactivate

                                                                                                                                                                                                                                                                                                                                                                                                                                                                onDeactivate: (item: any) => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                  method setColors

                                                                                                                                                                                                                                                                                                                                                                                                                                                                  setColors: () => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                    method update

                                                                                                                                                                                                                                                                                                                                                                                                                                                                    update: () => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                      method updateDomain

                                                                                                                                                                                                                                                                                                                                                                                                                                                                      updateDomain: (domain: any) => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                        method updateHoveredVertical

                                                                                                                                                                                                                                                                                                                                                                                                                                                                        updateHoveredVertical: (item: any) => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                          method updateTimeline

                                                                                                                                                                                                                                                                                                                                                                                                                                                                          updateTimeline: () => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                            method updateXAxisHeight

                                                                                                                                                                                                                                                                                                                                                                                                                                                                            updateXAxisHeight: ({ height }: { height: number }) => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                              method updateYAxisWidth

                                                                                                                                                                                                                                                                                                                                                                                                                                                                              updateYAxisWidth: ({ width }: { width: number }) => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                class AreaChartStackedComponent

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                class AreaChartStackedComponent extends BaseChartComponent {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property activate

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  activate: EventEmitter<any>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property activeEntries

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    activeEntries: any[];

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property clipPath

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      clipPath: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property clipPathId

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        clipPathId: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property colors

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          colors: ColorHelper;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property curve

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            curve: any;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property deactivate

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              deactivate: EventEmitter<any>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property dims

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                dims: ViewDimensions;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property filteredDomain

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  filteredDomain: any;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property gradient

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    gradient: boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property hoveredVertical

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      hoveredVertical: any;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property legend

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        legend: boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property legendOptions

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          legendOptions: any;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property legendPosition

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            legendPosition: LegendPosition;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property legendTitle

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              legendTitle: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property margin

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                margin: number[];

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property maxXAxisTickLength

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  maxXAxisTickLength: number;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property maxYAxisTickLength

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    maxYAxisTickLength: number;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property ɵcmp

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      static ɵcmp: i0.ɵɵComponentDeclaration<
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      AreaChartStackedComponent,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      'ngx-charts-area-chart-stacked',
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      never,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      legend: 'legend';
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      legendTitle: 'legendTitle';
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      legendPosition: 'legendPosition';
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      xAxis: 'xAxis';
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      yAxis: 'yAxis';
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      showXAxisLabel: 'showXAxisLabel';
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      showYAxisLabel: 'showYAxisLabel';
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      xAxisLabel: 'xAxisLabel';
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      yAxisLabel: 'yAxisLabel';
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      timeline: 'timeline';
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      gradient: 'gradient';
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      showGridLines: 'showGridLines';
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      curve: 'curve';
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      activeEntries: 'activeEntries';
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      schemeType: 'schemeType';
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      trimXAxisTicks: 'trimXAxisTicks';
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      trimYAxisTicks: 'trimYAxisTicks';
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      rotateXAxisTicks: 'rotateXAxisTicks';
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      maxXAxisTickLength: 'maxXAxisTickLength';
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      maxYAxisTickLength: 'maxYAxisTickLength';
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      xAxisTickFormatting: 'xAxisTickFormatting';
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      yAxisTickFormatting: 'yAxisTickFormatting';
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      xAxisTicks: 'xAxisTicks';
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      yAxisTicks: 'yAxisTicks';
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      roundDomains: 'roundDomains';
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      tooltipDisabled: 'tooltipDisabled';
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      xScaleMin: 'xScaleMin';
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      xScaleMax: 'xScaleMax';
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      yScaleMin: 'yScaleMin';
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      yScaleMax: 'yScaleMax';
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      },
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      { activate: 'activate'; deactivate: 'deactivate' },
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      ['tooltipTemplate', 'seriesTooltipTemplate'],
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      never
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      >;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property ɵfac

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        static ɵfac: i0.ɵɵFactoryDeclaration<AreaChartStackedComponent, never>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property rotateXAxisTicks

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          rotateXAxisTicks: boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property roundDomains

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            roundDomains: boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property scaleType

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              scaleType: ScaleType;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property schemeType

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                schemeType: ScaleType;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property seriesDomain

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  seriesDomain: any;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property seriesTooltipTemplate

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    seriesTooltipTemplate: TemplateRef<any>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property seriesType

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      seriesType: typeof SeriesType;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property showGridLines

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        showGridLines: boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property showXAxisLabel

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          showXAxisLabel: boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property showYAxisLabel

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            showYAxisLabel: boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property timeline

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              timeline: boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property timelineHeight

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                timelineHeight: number;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property timelinePadding

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  timelinePadding: number;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property timelineTransform

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    timelineTransform: any;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property timelineWidth

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      timelineWidth: number;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property timelineXDomain

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        timelineXDomain: any;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property timelineXScale

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          timelineXScale: any;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property timelineYScale

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            timelineYScale: any;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property tooltipDisabled

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              tooltipDisabled: boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property tooltipTemplate

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                tooltipTemplate: TemplateRef<any>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property transform

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  transform: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property trimXAxisTicks

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    trimXAxisTicks: boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property trimYAxisTicks

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      trimYAxisTicks: boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property xAxis

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        xAxis: boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property xAxisHeight

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          xAxisHeight: number;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property xAxisLabel

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            xAxisLabel: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property xAxisTickFormatting

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              xAxisTickFormatting: any;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property xAxisTicks

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                xAxisTicks: any[];

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property xDomain

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  xDomain: any[];

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property xScale

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    xScale: any;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property xScaleMax

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      xScaleMax: any;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property xScaleMin

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        xScaleMin: any;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property xSet

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          xSet: any[];

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property yAxis

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            yAxis: boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property yAxisLabel

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              yAxisLabel: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property yAxisTickFormatting

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                yAxisTickFormatting: any;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property yAxisTicks

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  yAxisTicks: any[];

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property yAxisWidth

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    yAxisWidth: number;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property yDomain

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      yDomain: [number, number];

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property yScale

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        yScale: any;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property yScaleMax

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          yScaleMax: number;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property yScaleMin

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            yScaleMin: number;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              method deactivateAll

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              deactivateAll: () => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                method getLegendOptions

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                getLegendOptions: () => LegendOptions;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  method getSeriesDomain

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  getSeriesDomain: () => string[];

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    method getXDomain

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    getXDomain: () => any[];

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      method getXScale

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      getXScale: (domain: any, width: number) => any;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        method getYDomain

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        getYDomain: () => [number, number];

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          method getYScale

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          getYScale: (domain: any, height: number) => any;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            method hideCircles

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            hideCircles: () => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              method onActivate

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              onActivate: (item: any) => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                method onClick

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                onClick: (data: any, series?: any) => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  method onDeactivate

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  onDeactivate: (item: any) => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    method setColors

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    setColors: () => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      method trackBy

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      trackBy: (index: any, item: any) => string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        method update

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        update: () => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          method updateDomain

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          updateDomain: (domain: any) => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            method updateHoveredVertical

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            updateHoveredVertical: (item: any) => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              method updateTimeline

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              updateTimeline: () => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                method updateXAxisHeight

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                updateXAxisHeight: ({ height }: { height: number }) => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  method updateYAxisWidth

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  updateYAxisWidth: ({ width }: { width: number }) => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    class AreaComponent

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    class AreaComponent implements OnChanges {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      constructor

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      constructor(element: ElementRef);

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property animations

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        animations: boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property animationsLoaded

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          animationsLoaded: boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property areaPath

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            areaPath: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property barOrientation

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              barOrientation: typeof BarOrientation;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                </