@swimlane/ngx-charts

  • Version 18.0.1
  • Published
  • 6.21 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: number) => any;

                                        property label

                                        label: string;

                                          property labelFormatting

                                          labelFormatting: (value: string) => any;

                                            property legendItems

                                            legendItems: AdvancedLegendItem[];

                                              property percentageFormatting

                                              percentageFormatting: (value: number) => any;

                                                property roundedTotal

                                                roundedTotal: number;

                                                  property select

                                                  select: any;

                                                    property total

                                                    total: number;

                                                      property valueFormatting

                                                      valueFormatting: (value: number) => any;

                                                        property width

                                                        width: number;

                                                          method getLegendItems

                                                          getLegendItems: () => AdvancedLegendItem[];

                                                            method getTotal

                                                            getTotal: () => number;

                                                              method ngOnChanges

                                                              ngOnChanges: (changes: any) => void;

                                                                method trackBy

                                                                trackBy: (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 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 trackBy

                                                                                                                                                                                                                                                                                trackBy: (index: number, item: Series) => StringOrNumberOrDate;

                                                                                                                                                                                                                                                                                  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 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 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 trackBy

                                                                                                                                                                                                                                                                                                                                                                                                                                        trackBy: (index: number, item: Series) => any;

                                                                                                                                                                                                                                                                                                                                                                                                                                          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 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 areaPath

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          areaPath: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            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 initialized

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              initialized: 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 startOpacity

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            startOpacity: number;

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        method update

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        update: () => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          method updatePathEl

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          updatePathEl: () => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            class BarHorizontal2DComponent

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            class BarHorizontal2DComponent extends BaseChartComponent {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property activate

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              activate: any;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property activeEntries

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                activeEntries: any[];

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property barPadding