@swimlane/ngx-charts

  • Version 19.0.1
  • Published
  • 5.17 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
        ) => any;

          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 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: any;

                              property animations

                              animations: boolean;

                                property colors

                                colors: ColorHelper;

                                  property data

                                  data: DataItem[];

                                    property deactivate

                                    deactivate: any;

                                      property defaultValueFormatting

                                      defaultValueFormatting: (value: StringOrNumberOrDate) => string;

                                        property label

                                        label: string;

                                          property labelFormatting

                                          labelFormatting: (value: string) => string;

                                            property legendItems

                                            legendItems: AdvancedLegendItem[];

                                              property percentageFormatting

                                              percentageFormatting: (value: number) => number;

                                                property roundedTotal

                                                roundedTotal: number;

                                                  property select

                                                  select: any;

                                                    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: any) => void;

                                                                method trackBy

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

                                                                  method update

                                                                  update: () => void;

                                                                    class AdvancedPieChartComponent

                                                                    class AdvancedPieChartComponent extends BaseChartComponent {}

                                                                      property activate

                                                                      activate: any;

                                                                        property activeEntries

                                                                        activeEntries: any[];

                                                                          property colors

                                                                          colors: ColorHelper;

                                                                            property deactivate

                                                                            deactivate: 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 percentageFormatting

                                                                                                percentageFormatting: (value: number) => any;

                                                                                                  property tooltipDisabled

                                                                                                  tooltipDisabled: boolean;

                                                                                                    property tooltipTemplate

                                                                                                    tooltipTemplate: 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: 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: any;

                                                                                                                                          property deactivate

                                                                                                                                          deactivate: 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 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: 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: any;

                                                                                                                                                                                                          property trackBy

                                                                                                                                                                                                          trackBy: 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 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: any, height: number) => number;

                                                                                                                                                                                                                                                                        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 {}

                                                                                                                                                                                                                                                                                                class AreaChartNormalizedComponent

                                                                                                                                                                                                                                                                                                class AreaChartNormalizedComponent extends BaseChartComponent {}

                                                                                                                                                                                                                                                                                                  property activate

                                                                                                                                                                                                                                                                                                  activate: any;

                                                                                                                                                                                                                                                                                                    property activeEntries

                                                                                                                                                                                                                                                                                                    activeEntries: any[];

                                                                                                                                                                                                                                                                                                      property clipPath

                                                                                                                                                                                                                                                                                                      clipPath: string;

                                                                                                                                                                                                                                                                                                        property clipPathId

                                                                                                                                                                                                                                                                                                        clipPathId: string;

                                                                                                                                                                                                                                                                                                          property colors

                                                                                                                                                                                                                                                                                                          colors: ColorHelper;

                                                                                                                                                                                                                                                                                                            property curve

                                                                                                                                                                                                                                                                                                            curve: any;

                                                                                                                                                                                                                                                                                                              property deactivate

                                                                                                                                                                                                                                                                                                              deactivate: 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 rotateXAxisTicks

                                                                                                                                                                                                                                                                                                                                      rotateXAxisTicks: boolean;

                                                                                                                                                                                                                                                                                                                                        property roundDomains

                                                                                                                                                                                                                                                                                                                                        roundDomains: boolean;

                                                                                                                                                                                                                                                                                                                                          property scaleType

                                                                                                                                                                                                                                                                                                                                          scaleType: ScaleType;

                                                                                                                                                                                                                                                                                                                                            property schemeType

                                                                                                                                                                                                                                                                                                                                            schemeType: ScaleType;

                                                                                                                                                                                                                                                                                                                                              property seriesDomain

                                                                                                                                                                                                                                                                                                                                              seriesDomain: any;

                                                                                                                                                                                                                                                                                                                                                property seriesTooltipTemplate

                                                                                                                                                                                                                                                                                                                                                seriesTooltipTemplate: 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: any;

                                                                                                                                                                                                                                                                                                                                                                                property trackBy

                                                                                                                                                                                                                                                                                                                                                                                trackBy: 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 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: any;

                                                                                                                                                                                                                                                                                                                                                                                                                                                            property activeEntries

                                                                                                                                                                                                                                                                                                                                                                                                                                                            activeEntries: any[];

                                                                                                                                                                                                                                                                                                                                                                                                                                                              property clipPath

                                                                                                                                                                                                                                                                                                                                                                                                                                                              clipPath: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                property clipPathId

                                                                                                                                                                                                                                                                                                                                                                                                                                                                clipPathId: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property colors

                                                                                                                                                                                                                                                                                                                                                                                                                                                                  colors: ColorHelper;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property curve

                                                                                                                                                                                                                                                                                                                                                                                                                                                                    curve: any;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property deactivate

                                                                                                                                                                                                                                                                                                                                                                                                                                                                      deactivate: 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 rotateXAxisTicks

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              rotateXAxisTicks: boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property roundDomains

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                roundDomains: boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property scaleType

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  scaleType: ScaleType;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property schemeType

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    schemeType: ScaleType;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property seriesDomain

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      seriesDomain: any;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property seriesTooltipTemplate

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        seriesTooltipTemplate: 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: 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: any);

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property animations

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            animations: boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property animationsLoaded

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              animationsLoaded: boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property areaPath

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                areaPath: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property barOrientation

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  barOrientation: typeof BarOrientation;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property data

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    data: AreaChartSeries;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property element

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      element: HTMLElement;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property endOpacity

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        endOpacity: number;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property fill

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          fill: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property gradient

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            gradient: boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property gradientFill

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              gradientFill: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property gradientId

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                gradientId: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property gradientStops

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  gradientStops: Gradient[];

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property hasGradient

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    hasGradient: boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property opacity

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      opacity: number;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property path

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        path: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property select

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          select: any;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property startingPath

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            startingPath: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property startOpacity

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              startOpacity: number;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property stops

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                stops: Gradient[];

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  method getGradient

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  getGradient: () => Gradient[];

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    method loadAnimation

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    loadAnimation: () => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      method ngOnChanges

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      ngOnChanges: () => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        method update

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        update: () => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          method updatePathEl

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          updatePathEl: () => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            class AreaSeriesComponent

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            class AreaSeriesComponent implements OnChanges {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property activeEntries

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              activeEntries: any[];

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property animations

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                animations: boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property baseValue

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  baseValue: any;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property colors

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    colors: ColorHelper;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property curve

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      curve: any;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property data

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        data: AreaChartSeries;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property gradient

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          gradient: boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property gradientStops

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            gradientStops: Gradient[];

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property hasGradient

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              hasGradient: boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property normalized

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                normalized: boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property opacity

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  opacity: number;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property path

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    path: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property scaleType

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      scaleType: ScaleType;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property select

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        select: any;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property stacked

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          stacked: boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property startingPath

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            startingPath: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property xScale

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              xScale: any;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property yScale

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                yScale: any;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  method isActive

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  isActive: (entry: any) => boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    method isInactive

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    isInactive: (entry: any) => boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      method ngOnChanges

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      ngOnChanges: (changes: any) => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        method update

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        update: () => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          method updateGradient

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          updateGradient: () => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            class AxesModule

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            class AxesModule {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              class AxisLabelComponent

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              class AxisLabelComponent implements OnChanges {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                constructor

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                constructor(element: any);

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property element

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  element: any;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property height

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    height: number;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property label

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      label: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property margin

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        margin: number;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property offset

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          offset: number;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property orient

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            orient: Orientation;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property strokeWidth

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              strokeWidth: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property textAnchor

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                textAnchor: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property textHeight

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  textHeight: number;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property transform

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    transform: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property width

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      width: number;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property x

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        x: number;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property y

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          y: number;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            method ngOnChanges

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            ngOnChanges: (changes: any) => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              method update

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              update: () => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                class BarChartModule

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                class BarChartModule {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  class BarComponent

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  class BarComponent implements OnChanges {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    constructor

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    constructor(element: any);

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property activate

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      activate: any;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property animations

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        animations: boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property ariaLabel

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          ariaLabel: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property data

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            data: DataItem;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property deactivate

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              deactivate: any;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property edges

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                readonly edges: boolean[];

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property element

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  element: HTMLElement;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property fill

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    fill: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property gradient

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      gradient: boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property gradientFill

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        gradientFill: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property gradientId

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          gradientId: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property gradientStops

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            gradientStops: Gradient[];

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property hasGradient

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              hasGradient: boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property height

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                height: number;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property hideBar

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  hideBar: boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property isActive

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    isActive: boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property noBarWhenZero

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      noBarWhenZero: boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property offset

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        offset: number;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property orientation

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          orientation: BarOrientation;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property path

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            path: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property roundEdges

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              roundEdges: boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property select

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                select: any;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property stops

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  stops: Gradient[];

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property width

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    width: number;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property x

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      x: number;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property y

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        y: number;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          method getGradient

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          getGradient: () => Gradient[];

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            method getPath

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            getPath: () => string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              method getRadius

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              getRadius: () => number;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                method getStartingPath

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                getStartingPath: () => string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  method getStartOpacity

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  getStartOpacity: () => number;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    method loadAnimation

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    loadAnimation: () => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      method ngOnChanges

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      ngOnChanges: (changes: any) => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        method onMouseEnter

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        onMouseEnter: () => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          method onMouseLeave

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          onMouseLeave: