@swimlane/ngx-charts

@swimlane/ngx-charts

Version 25.0.3
Published 2 days ago
2.37 MB
15 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

variable colorSets

const 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 cloneLineCoordinates

cloneLineCoordinates: (original: LineCoordinates) => LineCoordinates;

function clonePoint

clonePoint: (original: IPoint) => IPoint;

function cloneVector2d

cloneVector2d: (original: IVector2D) => IVector2D;

function count

count: (
    countFrom: number,
    countTo: number,
    countDecimals: number,
    countDuration: number,
    callback: any
) => number;

Counts from a number to the end incrementally.

function decimalChecker

decimalChecker: (countTo: number) => number;

Determine decimals places

function escapeLabel

escapeLabel: (label: any) => string;

Escapes a label.

function formatLabel

formatLabel: (label: any) => string;

Formats a label given a date, number or string.

function getDomain

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

function getScale

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

function getScaleType

getScaleType: (values: any[], checkDateType?: boolean) => ScaleType;

Get the scaleType of enumerable of values.
Returns
'time', 'linear' or 'ordinal'

function getTickLines

getTickLines: (label: string, maxLength: number, maxLines: number) => string[];

function getUniqueXDomainValues

getUniqueXDomainValues: (results: any[]) => any[];

Based on the data, return an array with unique values.
Returns
array

function getXDomainArray

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

function gridLayout

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

function gridSize

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

function hexToRgb

hexToRgb: (value: string) => any;

Converts a hex to RGB

function id

id: () => string;

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

function invertColor

invertColor: (value: string) => string;

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

function maxCharsForPixelWidth

maxCharsForPixelWidth: (maxWidthPx: number, charWidth?: number) => number;

Max whole characters that fit in a pixel width (SSR / axis layout).

function reduceTicks

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

function shadeRGBColor

shadeRGBColor: (
    { r, g, b }: { r: any; g: any; b: any },
    percent: number
) => string;

Given a rgb, it will darken/lighten http://stackoverflow.com/questions/5560248/programmatically-lighten-or-darken-a-hex-color-or-rgb-and-blend-colors
Parameter
{ r, g, b }

function sortByDomain

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

function sortByTime

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

function sortLinear

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

function throttle

throttle: (func: any, wait: number, options?: any) => () => any;

Throttle a function

function throttleable

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

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

function tickFormat

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

function trimLabel

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

Classes

class AdvancedLegendComponent

class AdvancedLegendComponent implements OnChanges {}

property activate

activate: EventEmitter<DataItem>;

property animations

animations: boolean;

property colors

colors: ColorHelper;

property data

data: DataItem[];

property deactivate

deactivate: EventEmitter<DataItem>;

property defaultValueFormatting

defaultValueFormatting: (value: StringOrNumberOrDate) => string;

property label

label: string;

property labelFormatting

labelFormatting: (value: string) => string;

property legendItems

legendItems: AdvancedLegendItem[];

property ɵcmp

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

property ɵfac

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

property percentageFormatting

percentageFormatting: (value: number) => number;

property roundedTotal

roundedTotal: number;

property roundPercentages

roundPercentages: boolean;

property select

select: EventEmitter<DataItem>;

property total

total: number;

property valueFormatting

valueFormatting: (value: StringOrNumberOrDate) => any;

property width

width: number;

method getLegendItems

getLegendItems: () => AdvancedLegendItem[];

method getPercentage

getPercentage: (value: number) => number;

method getTotal

getTotal: () => number;

method ngOnChanges

ngOnChanges: (changes: SimpleChanges) => void;

method trackBy

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

method update

update: () => void;

class AdvancedPieChartComponent

class AdvancedPieChartComponent extends BaseChartComponent {}

property activate

activate: EventEmitter<any>;

property activeEntries

activeEntries: any[];

property colors

colors: ColorHelper;

property deactivate

deactivate: EventEmitter<any>;

property dims

dims: ViewDimensions;

property domain

domain: string[];

property gradient

gradient: boolean;

property innerRadius

innerRadius: number;

property label

label: string;

property legendWidth

legendWidth: number;

property margin

margin: number[];

property nameFormatting

nameFormatting: (value: string) => any;

property outerRadius

outerRadius: number;

property ɵcmp

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

property ɵfac

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

property percentageFormatting

percentageFormatting: (value: number) => any;

property tooltipDisabled

tooltipDisabled: boolean;

property tooltipTemplate

tooltipTemplate: TemplateRef<any>;

property tooltipText

tooltipText: any;

property transform

transform: string;

property valueFormatting

valueFormatting: (value: number) => any;

method getDomain

getDomain: () => string[];

method ngOnChanges

ngOnChanges: () => void;

method onActivate

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

method onClick

onClick: (data: DataItem) => void;

method onDeactivate

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

method setColors

setColors: () => void;

method update

update: () => void;

class AreaChartComponent

class AreaChartComponent extends BaseChartComponent {}

property activate

activate: EventEmitter<any>;

property activeEntries

activeEntries: any[];

property autoScale

autoScale: boolean;

property baseValue

baseValue: any;

property clipPath

clipPath: string;

property clipPathId

clipPathId: string;

property colors

colors: ColorHelper;

property curve

curve: CurveFactory;

property deactivate

deactivate: EventEmitter<any>;

property dims

dims: ViewDimensions;

property filteredDomain

filteredDomain: any;

property gradient

gradient: boolean;

property hoveredVertical

hoveredVertical: any;

property legend

legend: boolean;

property legendOptions

legendOptions: LegendOptions;

property legendPosition

legendPosition: LegendPosition;

property legendTitle

legendTitle: string;

property margin

margin: number[];

property maxXAxisTickLength

maxXAxisTickLength: number;

property maxYAxisTickLength

maxYAxisTickLength: number;

property ɵcmp

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

property ɵfac

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

property referenceLines

referenceLines: any[];

property rotateXAxisTicks

rotateXAxisTicks: boolean;

property roundDomains

roundDomains: boolean;

property scaleType

scaleType: ScaleType;

property schemeType

schemeType: ScaleType;

property series

series: Series;

property seriesDomain

seriesDomain: string[];

property seriesTooltipTemplate

seriesTooltipTemplate: TemplateRef<any>;

property showGridLines

showGridLines: boolean;

property showRefLabels

showRefLabels: boolean;

property showRefLines

showRefLines: boolean;

property showXAxisLabel

showXAxisLabel: boolean;

property showYAxisLabel

showYAxisLabel: boolean;

property timeline

timeline: boolean;

property timelineHeight

timelineHeight: number;

property timelinePadding

timelinePadding: number;

property timelineTransform

timelineTransform: any;

property timelineWidth

timelineWidth: number;

property timelineXDomain

timelineXDomain: any[];

property timelineXScale

timelineXScale: any;

property timelineYScale

timelineYScale: any;

property tooltipDisabled

tooltipDisabled: boolean;

property tooltipTemplate

tooltipTemplate: TemplateRef<any>;

property trackBy

trackBy: TrackByFunction<Series>;

property transform

transform: string;

property trimXAxisTicks

trimXAxisTicks: boolean;

property trimYAxisTicks

trimYAxisTicks: boolean;

property wrapTicks

wrapTicks: boolean;

property xAxis

xAxis: boolean;

property xAxisHeight

xAxisHeight: number;

property xAxisLabel

xAxisLabel: string;

property xAxisTickFormatting

xAxisTickFormatting: any;

property xAxisTicks

xAxisTicks: any[];

property xDomain

xDomain: any[];

property xScale

xScale: any;

property xScaleMax

xScaleMax: any;

property xScaleMin

xScaleMin: any;

property xSet

xSet: any;

property yAxis

yAxis: boolean;

property yAxisLabel

yAxisLabel: string;

property yAxisTickFormatting

yAxisTickFormatting: any;

property yAxisTicks

yAxisTicks: any[];

property yAxisWidth

yAxisWidth: number;

property yDomain

yDomain: [number, number];

property yScale

yScale: any;

property yScaleMax

yScaleMax: number;

property yScaleMin

yScaleMin: number;

method deactivateAll

deactivateAll: () => void;

method getLegendOptions

getLegendOptions: () => LegendOptions;

method getScaleType

getScaleType: (values: any) => ScaleType;

method getSeriesDomain

getSeriesDomain: () => string[];

method getXDomain

getXDomain: () => any[];

method getXScale

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

method getYDomain

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

method getYScale

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

method hideCircles

hideCircles: () => void;

method onActivate

onActivate: (item: any) => void;

method onClick

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

method onDeactivate

onDeactivate: (item: any) => void;

method setColors

setColors: () => void;

method update

update: () => void;

method updateDomain

updateDomain: (domain: any) => void;

method updateHoveredVertical

updateHoveredVertical: (item: any) => void;

method updateTimeline

updateTimeline: () => void;

method updateXAxisHeight

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

method updateYAxisWidth

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

class AreaChartModule

class AreaChartModule {}

property ɵfac

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

property ɵinj

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

property ɵmod

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

class AreaChartNormalizedComponent

class AreaChartNormalizedComponent extends BaseChartComponent {}

property activate

activate: EventEmitter<any>;

property activeEntries

activeEntries: any[];

property clipPath

clipPath: string;

property clipPathId

clipPathId: string;

property colors

colors: ColorHelper;

property curve

curve: any;

property deactivate

deactivate: EventEmitter<any>;

property dims

dims: ViewDimensions;

property filteredDomain

filteredDomain: any;

property gradient

gradient: any;

property hoveredVertical

hoveredVertical: any;

property legend

legend: boolean;

property legendOptions

legendOptions: LegendOptions;

property legendPosition

legendPosition: LegendPosition;

property legendTitle

legendTitle: string;

property margin

margin: number[];

property maxXAxisTickLength

maxXAxisTickLength: number;

property maxYAxisTickLength

maxYAxisTickLength: number;

property ɵcmp

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

property ɵfac

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

property rotateXAxisTicks

rotateXAxisTicks: boolean;

property roundDomains

roundDomains: boolean;

property scaleType

scaleType: ScaleType;

property schemeType

schemeType: ScaleType;

property seriesDomain

seriesDomain: any;

property seriesTooltipTemplate

seriesTooltipTemplate: TemplateRef<any>;

property seriesType

seriesType: typeof SeriesType;

property showGridLines

showGridLines: boolean;

property showXAxisLabel

showXAxisLabel: boolean;

property showYAxisLabel

showYAxisLabel: boolean;

property timeline

timeline: any;

property timelineHeight

timelineHeight: number;

property timelinePadding

timelinePadding: number;

property timelineTransform

timelineTransform: any;

property timelineWidth

timelineWidth: any;

property timelineXDomain

timelineXDomain: any;

property timelineXScale

timelineXScale: any;

property timelineYScale

timelineYScale: any;

property tooltipAreas

tooltipAreas: any[];

property tooltipDisabled

tooltipDisabled: boolean;

property tooltipTemplate

tooltipTemplate: TemplateRef<any>;

property trackBy

trackBy: TrackByFunction<Series>;

property transform

transform: string;

property trimXAxisTicks

trimXAxisTicks: boolean;

property trimYAxisTicks

trimYAxisTicks: boolean;

property wrapTicks

wrapTicks: boolean;

property xAxis

xAxis: boolean;

property xAxisHeight

xAxisHeight: number;

property xAxisLabel

xAxisLabel: string;

property xAxisTickFormatting

xAxisTickFormatting: any;

property xAxisTicks

xAxisTicks: any[];

property xDomain

xDomain: any[];

property xScale

xScale: any;

property xSet

xSet: any[];

property yAxis

yAxis: boolean;

property yAxisLabel

yAxisLabel: string;

property yAxisTickFormatting

yAxisTickFormatting: any;

property yAxisTicks

yAxisTicks: any[];

property yAxisWidth

yAxisWidth: number;

property yDomain

yDomain: [number, number];

property yScale

yScale: any;

method deactivateAll

deactivateAll: () => void;

method getLegendOptions

getLegendOptions: () => LegendOptions;

method getSeriesDomain

getSeriesDomain: () => string[];

method getXDomain

getXDomain: () => any[];

method getXScale

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

method getYScale

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

method hideCircles

hideCircles: () => void;

method onActivate

onActivate: (item: any) => void;

method onClick

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

method onDeactivate

onDeactivate: (item: any) => void;

method setColors

setColors: () => void;

method update

update: () => void;

method updateDomain

updateDomain: (domain: any) => void;

method updateHoveredVertical

updateHoveredVertical: (item: any) => void;

method updateTimeline

updateTimeline: () => void;

method updateXAxisHeight

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

method updateYAxisWidth

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

class AreaChartStackedComponent

class AreaChartStackedComponent extends BaseChartComponent {}

property activate

activate: EventEmitter<any>;

property activeEntries

activeEntries: any[];

property clipPath

clipPath: string;

property clipPathId

clipPathId: string;

property colors

colors: ColorHelper;

property curve

curve: any;

property deactivate

deactivate: EventEmitter<any>;

property dims

dims: ViewDimensions;

property filteredDomain

filteredDomain: any;

property gradient

gradient: boolean;

property hoveredVertical

hoveredVertical: any;

property legend

legend: boolean;

property legendOptions

legendOptions: any;

property legendPosition

legendPosition: LegendPosition;

property legendTitle

legendTitle: string;

property margin

margin: number[];

property maxXAxisTickLength

maxXAxisTickLength: number;

property maxYAxisTickLength

maxYAxisTickLength: number;

property ɵcmp

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

property ɵfac

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

property rotateXAxisTicks

rotateXAxisTicks: boolean;

property roundDomains

roundDomains: boolean;

property scaleType

scaleType: ScaleType;

property schemeType

schemeType: ScaleType;

property seriesDomain

seriesDomain: any;

property seriesTooltipTemplate

seriesTooltipTemplate: TemplateRef<any>;

property seriesType

seriesType: typeof SeriesType;

property showGridLines

showGridLines: boolean;

property showXAxisLabel

showXAxisLabel: boolean;

property showYAxisLabel

showYAxisLabel: boolean;

property timeline

timeline: boolean;

property timelineHeight

timelineHeight: number;

property timelinePadding

timelinePadding: number;

property timelineTransform

timelineTransform: any;

property timelineWidth

timelineWidth: number;

property timelineXDomain

timelineXDomain: any;

property timelineXScale

timelineXScale: any;

property timelineYScale

timelineYScale: any;

property tooltipDisabled

tooltipDisabled: boolean;

property tooltipTemplate

tooltipTemplate: TemplateRef<any>;

property transform

transform: string;

property trimXAxisTicks

trimXAxisTicks: boolean;

property trimYAxisTicks

trimYAxisTicks: boolean;

property wrapTicks

wrapTicks: boolean;

property xAxis

xAxis: boolean;

property xAxisHeight

xAxisHeight: number;

property xAxisLabel

xAxisLabel: string;

property xAxisTickFormatting

xAxisTickFormatting: any;

property xAxisTicks

xAxisTicks: any[];

property xDomain

xDomain: any[];

property xScale

xScale: any;

property xScaleMax

xScaleMax: any;

property xScaleMin

xScaleMin: any;

property xSet

xSet: any[];

property yAxis

yAxis: boolean;

property yAxisLabel

yAxisLabel: string;

property yAxisTickFormatting

yAxisTickFormatting: any;

property yAxisTicks

yAxisTicks: any[];

property yAxisWidth

yAxisWidth: number;

property yDomain

yDomain: [number, number];

property yScale

yScale: any;

property yScaleMax

yScaleMax: number;

property yScaleMin

yScaleMin: number;

method deactivateAll

deactivateAll: () => void;

method getLegendOptions

getLegendOptions: () => LegendOptions;

method getSeriesDomain

getSeriesDomain: () => string[];

method getXDomain

getXDomain: () => any[];

method getXScale

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

method getYDomain

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

method getYScale

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

method hideCircles

hideCircles: () => void;

method onActivate

onActivate: (item: any) => void;

method onClick

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

method onDeactivate

onDeactivate: (item: any) => void;

method setColors

setColors: () => void;

method trackBy

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

method update

update: () => void;

method updateDomain

updateDomain: (domain: any) => void;

method updateHoveredVertical

updateHoveredVertical: (item: any) => void;

method updateTimeline

updateTimeline: () => void;

method updateXAxisHeight

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

method updateYAxisWidth

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

class AreaComponent

class AreaComponent implements OnChanges {}

constructor

constructor(element: ElementRef);

property animations

animations: boolean;

property animationsLoaded

animationsLoaded: boolean;

property areaPath

areaPath: string;

property barOrientation

barOrientation: typeof BarOrientation;

property data

data: AreaChartSeries;

property element

element: HTMLElement;

property endOpacity

endOpacity: number;

property fill

fill: string;

property gradient

gradient: boolean;

property gradientFill

gradientFill: string;

property gradientId

gradientId: string;

property gradientStops

gradientStops: Gradient[];

property hasGradient

hasGradient: boolean;

property opacity

opacity: number;

property ɵcmp

static ɵcmp: i0.ɵɵComponentDeclaration<
    AreaComponent,
    'g[ngx-charts-area]',
    never,
    {
        data: { alias: 'data'; required: false };
        path: { alias: 'path'; required: false };
        startingPath: { alias: 'startingPath'; required: false };
        fill: { alias: 'fill'; required: false };
        opacity: { alias: 'opacity'; required: false };
        startOpacity: { alias: 'startOpacity'; required: false };
        endOpacity: { alias: 'endOpacity'; required: false };
        gradient: { alias: 'gradient'; required: false };
        stops: { alias: 'stops'; required: false };
        animations: { alias: 'animations'; required: false };
    },
    { select: 'select' },
    never,
    never,
    false,
    never
>;

property ɵfac

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

property path

path: string;

property select

select: EventEmitter<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 ɵcmp

static ɵcmp: i0.ɵɵComponentDeclaration<
    AreaSeriesComponent,
    'g[ngx-charts-area-series]',
    never,
    {
        data: { alias: 'data'; required: false };
        xScale: { alias: 'xScale'; required: false };
        yScale: { alias: 'yScale'; required: false };
        baseValue: { alias: 'baseValue'; required: false };
        colors: { alias: 'colors'; required: false };
        scaleType: { alias: 'scaleType'; required: false };
        stacked: { alias: 'stacked'; required: false };
        normalized: { alias: 'normalized'; required: false };
        gradient: { alias: 'gradient'; required: false };
        curve: { alias: 'curve'; required: false };
        activeEntries: { alias: 'activeEntries'; required: false };
        animations: { alias: 'animations'; required: false };
    },
    { select: 'select' },
    never,
    never,
    false,
    never
>;

property ɵfac

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

property path

path: string;

property scaleType

scaleType: ScaleType;

property select

select: EventEmitter<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: SimpleChanges) => void;

method update

update: () => void;

method updateGradient

updateGradient: () => void;

class AxesModule

class AxesModule {}

property ɵfac

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

property ɵinj

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

property ɵmod

static ɵmod: i0.ɵɵNgModuleDeclaration<
    AxesModule,
    [
        typeof AxisLabelComponent,
        typeof XAxisComponent,
        typeof XAxisTicksComponent,
        typeof YAxisComponent,
        typeof YAxisTicksComponent
    ],
    [any],
    [
        typeof AxisLabelComponent,
        typeof XAxisComponent,
        typeof XAxisTicksComponent,
        typeof YAxisComponent,
        typeof YAxisTicksComponent
    ]
>;

class AxisLabelComponent

class AxisLabelComponent implements OnChanges {}

constructor

constructor(element: ElementRef);

property element

element: ElementRef;

property height

height: number;

property label

label: string;

property margin

margin: number;

property offset

offset: number;

property orient

orient: Orientation;

property ɵcmp

static ɵcmp: i0.ɵɵComponentDeclaration<
    AxisLabelComponent,
    'g[ngx-charts-axis-label]',
    never,
    {
        orient: { alias: 'orient'; required: false };
        label: { alias: 'label'; required: false };
        offset: { alias: 'offset'; required: false };
        width: { alias: 'width'; required: false };
        height: { alias: 'height'; required: false };
    },
    {},
    never,
    never,
    false,
    never
>;

property ɵfac

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

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

method update

update: () => void;

class BarChartModule

class BarChartModule {}

property ɵfac

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

property ɵinj

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

property ɵmod

static ɵmod: i0.ɵɵNgModuleDeclaration<
    BarChartModule,
    [
        typeof BarComponent,
        typeof BarHorizontalComponent,
        typeof BarHorizontal2DComponent,
        typeof BarHorizontalNormalizedComponent,
        typeof BarHorizontalStackedComponent,
        typeof BarVerticalComponent,
        typeof BarVertical2DComponent,
        typeof BarVerticalNormalizedComponent,
        typeof BarVerticalStackedComponent,
        typeof BarLabelComponent,
        typeof SeriesHorizontal,
        typeof SeriesVerticalComponent
    ],
    [typeof ChartCommonModule],
    [
        typeof BarComponent,
        typeof BarHorizontalComponent,
        typeof BarHorizontal2DComponent,
        typeof BarHorizontalNormalizedComponent,
        typeof BarHorizontalStackedComponent,
        typeof BarVerticalComponent,
        typeof BarVertical2DComponent,
        typeof BarVerticalNormalizedComponent,
        typeof BarVerticalStackedComponent,
        typeof BarLabelComponent,
        typeof SeriesHorizontal,
        typeof SeriesVerticalComponent
    ]
>;

class BarComponent

class BarComponent implements OnChanges {}

constructor

constructor(element: ElementRef);

property activate

activate: EventEmitter<DataItem>;

property animations

animations: boolean;

property ariaLabel

ariaLabel: string;

property data

data: DataItem;

property deactivate

deactivate: EventEmitter<DataItem>;

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 ɵcmp

static ɵcmp: i0.ɵɵComponentDeclaration<
    BarComponent,
    'g[ngx-charts-bar]',
    never,
    {
        fill: { alias: 'fill'; required: false };
        data: { alias: 'data'; required: false };
        width: { alias: 'width'; required: false };
        height: { alias: 'height'; required: false };
        x: { alias: 'x'; required: false };
        y: { alias: 'y'; required: false };
        orientation: { alias: 'orientation'; required: false };
        roundEdges: { alias: 'roundEdges'; required: false };
        gradient: { alias: 'gradient'; required: false };
        offset: { alias: 'offset'; required: false };
        isActive: { alias: 'isActive'; required: false };
        stops: { alias: 'stops'; required: false };
        animations: { alias: 'animations'; required: false };
        ariaLabel: { alias: 'ariaLabel'; required: false };
        noBarWhenZero: { alias: 'noBarWhenZero'; required: false };
    },
    { select: 'select'; activate: 'activate'; deactivate: 'deactivate' },
    never,
    never,
    false,
    never
>;

property ɵfac

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

property path

path: string;

property roundEdges

roundEdges: boolean;

property select

select: EventEmitter<DataItem>;

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

property activeEntries

activeEntries: any[];

property barOrientation

barOrientation: typeof BarOrientation;

property barPadding

barPadding: number;

property colors

colors: ColorHelper;

property dataLabelFormatting

dataLabelFormatting: any;

property dataLabelMaxWidth

dataLabelMaxWidth: any;

property deactivate

deactivate: EventEmitter<any>;

property dims

dims: ViewDimensions;

property gradient

gradient: boolean;

property groupDomain

groupDomain: string[];

property groupPadding

groupPadding: number;

property groupScale

groupScale: any;

property innerDomain

innerDomain: string[];

property innerScale

innerScale: any;

property isSSR

isSSR: boolean;

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 noBarWhenZero

noBarWhenZero: boolean;

property ɵcmp

static ɵcmp: i0.ɵɵComponentDeclaration<
    BarHorizontal2DComponent,
    'ngx-charts-bar-horizontal-2d',
    never,
    {
        legend: { alias: 'legend'; required: false };
        legendTitle: { alias: 'legendTitle'; required: false };
        legendPosition: { alias: 'legendPosition'; required: false };
        xAxis: { alias: 'xAxis'; required: false };
        yAxis: { alias: 'yAxis'; required: false };
        showXAxisLabel: { alias: 'showXAxisLabel'; required: false };
        showYAxisLabel: { alias: 'showYAxisLabel'; required: false };
        xAxisLabel: { alias: 'xAxisLabel'; required: false };
        yAxisLabel: { alias: 'yAxisLabel'; required: false };
        tooltipDisabled: { alias: 'tooltipDisabled'; required: false };
        gradient: { alias: 'gradient'; required: false };
        showGridLines: { alias: 'showGridLines'; required: false };
        activeEntries: { alias: 'activeEntries'; required: false };
        schemeType: { alias: 'schemeType'; required: false };
        trimXAxisTicks: { alias: 'trimXAxisTicks'; required: false };
        trimYAxisTicks: { alias: 'trimYAxisTicks'; required: false };
        rotateXAxisTicks: { alias: 'rotateXAxisTicks'; required: false };
        maxXAxisTickLength: { alias: 'maxXAxisTickLength'; required: false };
        maxYAxisTickLength: { alias: 'maxYAxisTickLength'; required: false };
        xAxisTickFormatting: { alias: 'xAxisTickFormatting'; required: false };
        yAxisTickFormatting: { alias: 'yAxisTickFormatting'; required: false };
        xAxisTicks: { alias: 'xAxisTicks'; required: false };
        yAxisTicks: { alias: 'yAxisTicks'; required: false };
        groupPadding: { alias: 'groupPadding'; required: false };
        barPadding: { alias: 'barPadding'; required: false };
        roundDomains: { alias: 'roundDomains'; required: false };
        roundEdges: { alias: 'roundEdges'; required: false };
        xScaleMax: { alias: 'xScaleMax'; required: false };
        showDataLabel: { alias: 'showDataLabel'; required: false };
        dataLabelFormatting: { alias: 'dataLabelFormatting'; required: false };
        noBarWhenZero: { alias: 'noBarWhenZero'; required: false };
        wrapTicks: { alias: 'wrapTicks'; required: false };
    },
    { activate: 'activate'; deactivate: 'deactivate' },
    ['tooltipTemplate'],
    never,
    false,
    never
>;

property ɵfac

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

property rotateXAxisTicks

rotateXAxisTicks: boolean;

property roundDomains

roundDomains: boolean;

property roundEdges

roundEdges: boolean;

property schemeType

schemeType: ScaleType;

property showDataLabel

showDataLabel: boolean;

property showGridLines

showGridLines: boolean;

property showXAxisLabel

showXAxisLabel: boolean;

property showYAxisLabel

showYAxisLabel: boolean;

property tooltipDisabled

tooltipDisabled: boolean;

property tooltipTemplate

tooltipTemplate: TemplateRef<any>;

property trackBy

trackBy: TrackByFunction<DataItem>;

property transform

transform: string;

property trimXAxisTicks

trimXAxisTicks: boolean;

property trimYAxisTicks

trimYAxisTicks: boolean;

property valueDomain

valueDomain: [number, number];

property valueScale

valueScale: any;

property wrapTicks

wrapTicks: boolean;

property xAxis

xAxis: any;

property xAxisHeight

xAxisHeight: number;

property xAxisLabel

xAxisLabel: string;

property xAxisTickFormatting

xAxisTickFormatting: any;

property xAxisTicks

xAxisTicks: any[];

property xScaleMax

xScaleMax: number;

property yAxis

yAxis: any;

property yAxisLabel

yAxisLabel: string;

property yAxisTickFormatting

yAxisTickFormatting: any;

property yAxisTicks

yAxisTicks: any[];

property yAxisWidth

yAxisWidth: number;

method getGroupDomain

getGroupDomain: () => string[];

method getGroupScale

getGroupScale: () => any;

method getInnerDomain

getInnerDomain: () => string[];

method getInnerScale

getInnerScale: () => any;

method getLegendOptions

getLegendOptions: () => LegendOptions;

method getValueDomain

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

method getValueScale

getValueScale: () => any;

method groupTransform

groupTransform: (group: DataItem) => string;

method ngOnChanges

ngOnChanges: () => void;

method ngOnInit

ngOnInit: () => void;

method onActivate

onActivate: (event: any, group: DataItem, fromLegend?: boolean) => void;

method onClick

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

method onDataLabelMaxWidthChanged

onDataLabelMaxWidthChanged: (event: any, groupIndex: number) => void;

method onDeactivate

onDeactivate: (event: any, group: DataItem, fromLegend?: boolean) => void;

method seedYAxisWidthFromResults

seedYAxisWidthFromResults: () => void;

Approx Y-axis width from category labels when not yet measured (SSR-safe).

method setColors

setColors: () => void;

method update

update: () => void;

method updateXAxisHeight

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

method updateYAxisWidth

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

class BarHorizontalComponent

class BarHorizontalComponent extends BaseChartComponent {}

property activate

activate: EventEmitter<any>;

property activeEntries

activeEntries: any[];

property barPadding

barPadding: number;

property colors

colors: ColorHelper;

property dataLabelFormatting

dataLabelFormatting: any;

property dataLabelMaxWidth

dataLabelMaxWidth: any;

property deactivate

deactivate: EventEmitter<any>;

property dims

dims: ViewDimensions;

property gradient

gradient: boolean;

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 noBarWhenZero

noBarWhenZero: boolean;

property ɵcmp

static ɵcmp: i0.ɵɵComponentDeclaration<
    BarHorizontalComponent,
    'ngx-charts-bar-horizontal',
    never,
    {
        legend: { alias: 'legend'; required: false };
        legendTitle: { alias: 'legendTitle'; required: false };
        legendPosition: { alias: 'legendPosition'; required: false };
        xAxis: { alias: 'xAxis'; required: false };
        yAxis: { alias: 'yAxis'; required: false };
        showXAxisLabel: { alias: 'showXAxisLabel'; required: false };
        showYAxisLabel: { alias: 'showYAxisLabel'; required: false };
        xAxisLabel: { alias: 'xAxisLabel'; required: false };
        yAxisLabel: { alias: 'yAxisLabel'; required: false };
        tooltipDisabled: { alias: 'tooltipDisabled'; required: false };
        referenceLines: { alias: 'referenceLines'; required: false };
        showRefLines: { alias: 'showRefLines'; required: false };
        showRefLabels: { alias: 'showRefLabels'; required: false };
        gradient: { alias: 'gradient'; required: false };
        showGridLines: { alias: 'showGridLines'; required: false };
        activeEntries: { alias: 'activeEntries'; required: false };
        schemeType: { alias: 'schemeType'; required: false };
        trimXAxisTicks: { alias: 'trimXAxisTicks'; required: false };
        trimYAxisTicks: { alias: 'trimYAxisTicks'; required: false };
        rotateXAxisTicks: { alias: 'rotateXAxisTicks'; required: false };
        maxXAxisTickLength: { alias: 'maxXAxisTickLength'; required: false };
        maxYAxisTickLength: { alias: 'maxYAxisTickLength'; required: false };
        xAxisTickFormatting: { alias: 'xAxisTickFormatting'; required: false };
        yAxisTickFormatting: { alias: 'yAxisTickFormatting'; required: false };
        xAxisTicks: { alias: 'xAxisTicks'; required: false };
        yAxisTicks: { alias: 'yAxisTicks'; required: false };
        barPadding: { alias: 'barPadding'; required: false };
        roundDomains: { alias: 'roundDomains'; required: false };
        roundEdges: { alias: 'roundEdges'; required: false };
        xScaleMax: { alias: 'xScaleMax'; required: false };
        xScaleMin: { alias: 'xScaleMin'; required: false };
        showDataLabel: { alias: 'showDataLabel'; required: false };
        dataLabelFormatting: { alias: 'dataLabelFormatting'; required: false };
        noBarWhenZero: { alias: 'noBarWhenZero'; required: false };
        wrapTicks: { alias: 'wrapTicks'; required: false };
    },
    { activate: 'activate'; deactivate: 'deactivate' },
    ['tooltipTemplate'],
    never,
    false,
    never
>;

property ɵfac

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

property referenceLines

referenceLines: any;

property rotateXAxisTicks

rotateXAxisTicks: boolean;

property roundDomains

roundDomains: boolean;

property roundEdges

roundEdges: boolean;

property schemeType

schemeType: ScaleType;

property showDataLabel

showDataLabel: boolean;

property showGridLines

showGridLines: boolean;

property showRefLabels

showRefLabels: boolean;

property showRefLines

showRefLines: boolean;

property showXAxisLabel

showXAxisLabel: boolean;

property showYAxisLabel

showYAxisLabel: boolean;

property tooltipDisabled

tooltipDisabled: boolean;

property tooltipTemplate

tooltipTemplate: TemplateRef<any>;

property transform

transform: string;

property trimXAxisTicks

trimXAxisTicks: boolean;

property trimYAxisTicks

trimYAxisTicks: boolean;

property wrapTicks

wrapTicks: boolean;

property xAxis

xAxis: any;

property xAxisHeight

xAxisHeight: number;

property xAxisLabel

xAxisLabel: string;

property xAxisTickFormatting

xAxisTickFormatting: any;

property xAxisTicks

xAxisTicks: any[];

property xDomain

xDomain: [number, number];

property xScale

xScale: any;

property xScaleMax

xScaleMax: number;

property xScaleMin

xScaleMin: number;

property yAxis

yAxis: any;

property yAxisLabel

yAxisLabel: string;

property yAxisTickFormatting

yAxisTickFormatting: any;

property yAxisTicks

yAxisTicks: any[];

property yAxisWidth

yAxisWidth: number;

property yDomain

yDomain: string[];

property yScale

yScale: any;

method getLegendOptions

getLegendOptions: () => LegendOptions;

method getXDomain

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

method getXScale

getXScale: () => any;

method getYDomain

getYDomain: () => string[];

method getYScale

getYScale: () => any;

method ngOnChanges

ngOnChanges: () => void;

method onActivate

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

method onClick

onClick: (data: any) => void;

method onDataLabelMaxWidthChanged

onDataLabelMaxWidthChanged: (event: any) => void;

method onDeactivate

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

method seedYAxisWidthFromResults

seedYAxisWidthFromResults: () => void;

Approx Y-axis width from category labels when not yet measured (SSR-safe).

method setColors

setColors: () => void;

method update

update: () => void;

method updateXAxisHeight

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

method updateYAxisWidth

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

class BarHorizontalNormalizedComponent

class BarHorizontalNormalizedComponent extends BaseChartComponent {}

property activate

activate: EventEmitter<any>;

property activeEntries

activeEntries: any[];

property barChartType

barChartType: typeof BarChartType;

property barPadding

barPadding: number;

property colors

colors: ColorHelper;

property deactivate

deactivate: EventEmitter<any>;

property dims

dims: ViewDimensions;

property gradient

gradient: boolean;

property groupDomain

groupDomain: string[];

property innerDomain

innerDomain: string[];

property isSSR

isSSR: boolean;

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 noBarWhenZero

noBarWhenZero: boolean;

property ɵcmp

static ɵcmp: i0.ɵɵComponentDeclaration<
    BarHorizontalNormalizedComponent,
    'ngx-charts-bar-horizontal-normalized',
    never,
    {
        legend: { alias: 'legend'; required: false };
        legendTitle: { alias: 'legendTitle'; required: false };
        legendPosition: { alias: 'legendPosition'; required: false };
        xAxis: { alias: 'xAxis'; required: false };
        yAxis: { alias: 'yAxis'; required: false };
        showXAxisLabel: { alias: 'showXAxisLabel'; required: false };
        showYAxisLabel: { alias: 'showYAxisLabel'; required: false };
        xAxisLabel: { alias: 'xAxisLabel'; required: false };
        yAxisLabel: { alias: 'yAxisLabel'; required: false };
        tooltipDisabled: { alias: 'tooltipDisabled'; required: false };
        gradient: { alias: 'gradient'; required: false };
        showGridLines: { alias: 'showGridLines'; required: false };
        activeEntries: { alias: 'activeEntries'; required: false };
        schemeType: { alias: 'schemeType'; required: false };
        trimXAxisTicks: { alias: 'trimXAxisTicks'; required: false };
        trimYAxisTicks: { alias: 'trimYAxisTicks'; required: false };
        rotateXAxisTicks: { alias: 'rotateXAxisTicks'; required: false };
        maxXAxisTickLength: { alias: 'maxXAxisTickLength'; required: false };
        maxYAxisTickLength: { alias: 'maxYAxisTickLength'; required: false };
        xAxisTickFormatting: { alias: 'xAxisTickFormatting'; required: false };
        yAxisTickFormatting: { alias: 'yAxisTickFormatting'; required: false };
        xAxisTicks: { alias: 'xAxisTicks'; required: false };
        yAxisTicks: { alias: 'yAxisTicks'; required: false };
        barPadding: { alias: 'barPadding'; required: false };
        roundDomains: { alias: 'roundDomains'; required: false };
        noBarWhenZero: { alias: 'noBarWhenZero'; required: false };
        wrapTicks: { alias: 'wrapTicks'; required: false };
    },
    { activate: 'activate'; deactivate: 'deactivate' },
    ['tooltipTemplate'],
    never,
    false,
    never
>;

property ɵfac

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

property rotateXAxisTicks

rotateXAxisTicks: boolean;

property roundDomains

roundDomains: boolean;

property schemeType

schemeType: ScaleType;

property showGridLines

showGridLines: boolean;

property showXAxisLabel

showXAxisLabel: boolean;

property showYAxisLabel

showYAxisLabel: boolean;

property tooltipDisabled

tooltipDisabled: boolean;

property tooltipTemplate

tooltipTemplate: TemplateRef<any>;

property trackBy

trackBy: TrackByFunction<Series>;

property transform

transform: string;

property trimXAxisTicks

trimXAxisTicks: boolean;

property trimYAxisTicks

trimYAxisTicks: boolean;

property valueDomain

valueDomain: [number, number];

property wrapTicks

wrapTicks: boolean;

property xAxis

xAxis: any;

property xAxisHeight

xAxisHeight: number;

property xAxisLabel

xAxisLabel: string;

property xAxisTickFormatting

xAxisTickFormatting: any;

property xAxisTicks

xAxisTicks: any[];

property xScale

xScale: any;

property yAxis

yAxis: any;

property yAxisLabel

yAxisLabel: string;

property yAxisTickFormatting

yAxisTickFormatting: any;

property yAxisTicks

yAxisTicks: any[];

property yAxisWidth

yAxisWidth: number;

property yScale

yScale: any;

method getGroupDomain

getGroupDomain: () => string[];

method getInnerDomain

getInnerDomain: () => string[];

method getLegendOptions

getLegendOptions: () => LegendOptions;

method getXScale

getXScale: () => any;

method getYScale

getYScale: () => any;

method groupTransform

groupTransform: (group: Series) => string;

method ngOnInit

ngOnInit: () => void;

method onActivate

onActivate: (event: any, group: Series, fromLegend?: boolean) => void;

method onClick

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

method onDeactivate

onDeactivate: (event: any, group: Series, fromLegend?: boolean) => void;

method seedYAxisWidthFromResults

seedYAxisWidthFromResults: () => void;

Approx Y-axis width from category labels when not yet measured (SSR-safe).

method setColors

setColors: () => void;

method update

update: () => void;

method updateXAxisHeight

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

method updateYAxisWidth

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

class BarHorizontalStackedComponent

class BarHorizontalStackedComponent extends BaseChartComponent {}

property activate

activate: EventEmitter<any>;

property activeEntries

activeEntries: any[];

property barChartType

barChartType: typeof BarChartType;

property barPadding

barPadding: number;

property colors

colors: ColorHelper;

property dataLabelFormatting

dataLabelFormatting: any;

property dataLabelMaxWidth

dataLabelMaxWidth: any;

property deactivate

deactivate: EventEmitter<any>;

property dims

dims: ViewDimensions;

property gradient

gradient: boolean;

property groupDomain

groupDomain: string[];

property innerDomain

innerDomain: string[];

property isSSR

isSSR: boolean;

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 noBarWhenZero

noBarWhenZero: boolean;

property ɵcmp

static ɵcmp: i0.ɵɵComponentDeclaration<
    BarHorizontalStackedComponent,
    'ngx-charts-bar-horizontal-stacked',
    never,
    {
        legend: { alias: 'legend'; required: false };
        legendTitle: { alias: 'legendTitle'; required: false };
        legendPosition: { alias: 'legendPosition'; required: false };
        xAxis: { alias: 'xAxis'; required: false };
        yAxis: { alias: 'yAxis'; required: false };
        showXAxisLabel: { alias: 'showXAxisLabel'; required: false };
        showYAxisLabel: { alias: 'showYAxisLabel'; required: false };
        xAxisLabel: { alias: 'xAxisLabel'; required: false };
        yAxisLabel: { alias: 'yAxisLabel'; required: false };
        tooltipDisabled: { alias: 'tooltipDisabled'; required: false };
        gradient: { alias: 'gradient'; required: false };
        showGridLines: { alias: 'showGridLines'; required: false };
        activeEntries: { alias: 'activeEntries'; required: false };
        schemeType: { alias: 'schemeType'; required: false };
        trimXAxisTicks: { alias: 'trimXAxisTicks'; required: false };
        trimYAxisTicks: { alias: 'trimYAxisTicks'; required: false };
        rotateXAxisTicks: { alias: 'rotateXAxisTicks'; required: false };
        maxXAxisTickLength: { alias: 'maxXAxisTickLength'; required: false };
        maxYAxisTickLength: { alias: 'maxYAxisTickLength'; required: false };
        xAxisTickFormatting: { alias: 'xAxisTickFormatting'; required: false };
        yAxisTickFormatting: { alias: 'yAxisTickFormatting'; required: false };
        xAxisTicks: { alias: 'xAxisTicks'; required: false };
        yAxisTicks: { alias: 'yAxisTicks'; required: false };
        barPadding: { alias: 'barPadding'; required: false };
        roundDomains: { alias: 'roundDomains'; required: false };
        xScaleMax: { alias: 'xScaleMax'; required: false };
        showDataLabel: { alias: 'showDataLabel'; required: false };
        dataLabelFormatting: { alias: 'dataLabelFormatting'; required: false };
        noBarWhenZero: { alias: 'noBarWhenZero'; required: false };
        wrapTicks: { alias: 'wrapTicks'; required: false };
    },
    { activate: 'activate'; deactivate: 'deactivate' },
    ['tooltipTemplate'],
    never,
    false,
    never
>;

property ɵfac

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

property rotateXAxisTicks

rotateXAxisTicks: boolean;

property roundDomains

roundDomains: boolean;

property schemeType

schemeType: ScaleType;

property showDataLabel

showDataLabel: boolean;

property showGridLines

showGridLines: boolean;

property showXAxisLabel

showXAxisLabel: boolean;

property showYAxisLabel

showYAxisLabel: boolean;

property tooltipDisabled

tooltipDisabled: boolean;

property tooltipTemplate

tooltipTemplate: TemplateRef<any>;

property trackBy

trackBy: TrackByFunction<Series>;

property transform

transform: string;

property trimXAxisTicks

trimXAxisTicks: boolean;

property trimYAxisTicks

trimYAxisTicks: boolean;

property valueDomain

valueDomain: [number, number];

property wrapTicks

wrapTicks: boolean;

property xAxis

xAxis: any;

property xAxisHeight

xAxisHeight: number;

property xAxisLabel

xAxisLabel: string;

property xAxisTickFormatting

xAxisTickFormatting: any;

property xAxisTicks

xAxisTicks: any[];

property xScale

xScale: any;

property xScaleMax

xScaleMax: number;

property yAxis

yAxis: any;

property yAxisLabel

yAxisLabel: string;

property yAxisTickFormatting

yAxisTickFormatting: any;

property yAxisTicks

yAxisTicks: any[];

property yAxisWidth

yAxisWidth: number;

property yScale

yScale: any;

method getGroupDomain

getGroupDomain: () => string[];

method getInnerDomain

getInnerDomain: () => string[];

method getLegendOptions

getLegendOptions: () => LegendOptions;

method getValueDomain

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

method getXScale

getXScale: () => any;

method getYScale

getYScale: () => any;

method groupTransform

groupTransform: (group: Series) => string;

method ngOnInit

ngOnInit: () => void;

method onActivate

onActivate: (event: any, group: Series, fromLegend?: boolean) => void;

method onClick

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

method onDataLabelMaxWidthChanged

onDataLabelMaxWidthChanged: (event: any, groupIndex: number) => void;

method onDeactivate

onDeactivate: (event: any, group: Series, fromLegend?: boolean) => void;

method seedYAxisWidthFromResults

seedYAxisWidthFromResults: () => void;

Approx Y-axis width from category labels when not yet measured (SSR-safe).

method setColors

setColors: () => void;

method update

update: () => void;

method updateXAxisHeight

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

method updateYAxisWidth

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

class BarLabelComponent

class BarLabelComponent implements OnChanges {}

constructor

constructor(element: ElementRef);

property barHeight

barHeight: any;

property barWidth

barWidth: any;

property barX

barX: any;

property barY

barY: any;

property dimensionsChanged

dimensionsChanged: EventEmitter<any>;

property element

element: any;

property formatedValue

formatedValue: string;

property horizontalPadding

horizontalPadding: number;

property orientation

orientation: BarOrientation;

property ɵcmp

static ɵcmp: i0.ɵɵComponentDeclaration<
    BarLabelComponent,
    'g[ngx-charts-bar-label]',
    never,
    {
        value: { alias: 'value'; required: false };
        valueFormatting: { alias: 'valueFormatting'; required: false };
        barX: { alias: 'barX'; required: false };
        barY: { alias: 'barY'; required: false };
        barWidth: { alias: 'barWidth'; required: false };
        barHeight: { alias: 'barHeight'; required: false };
        orientation: { alias: 'orientation'; required: false };
    },
    { dimensionsChanged: 'dimensionsChanged' },
    never,
    never,
    false,
    never
>;

property ɵfac

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

property textAnchor

textAnchor: string;

property transform

transform: string;

property value

value: any;

property valueFormatting

valueFormatting: any;

property verticalPadding

verticalPadding: number;

property x

x: number;

property y

y: number;

method getSize

getSize: () => any;

method ngAfterViewInit

ngAfterViewInit: () => void;

method ngOnChanges

ngOnChanges: (changes: SimpleChanges) => void;

method update

update: () => void;

class BarVertical2DComponent

class BarVertical2DComponent extends BaseChartComponent {}

property activate

activate: EventEmitter<any>;

property activeEntries

activeEntries: any[];

property barOrientation

barOrientation: typeof BarOrientation;

property barPadding

barPadding: number;

property colors

colors: ColorHelper;

property dataLabelFormatting

dataLabelFormatting: any;

property dataLabelMaxHeight

dataLabelMaxHeight: any;

property deactivate

deactivate: EventEmitter<any>;

property dims

dims: ViewDimensions;

property gradient

gradient: boolean;

property groupDomain

groupDomain: string[];

property groupPadding

groupPadding: number;

property groupScale

groupScale: any;

property innerDomain

innerDomain: string[];

property innerScale

innerScale: any;

property isSSR

isSSR: boolean;

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 noBarWhenZero

noBarWhenZero: boolean;

property ɵcmp

static ɵcmp: i0.ɵɵComponentDeclaration<
    BarVertical2DComponent,
    'ngx-charts-bar-vertical-2d',
    never,
    {
        legend: { alias: 'legend'; required: false };
        legendTitle: { alias: 'legendTitle'; required: false };
        legendPosition: { alias: 'legendPosition'; required: false };
        xAxis: { alias: 'xAxis'; required: false };
        yAxis: { alias: 'yAxis'; required: false };
        showXAxisLabel: { alias: 'showXAxisLabel'; required: false };
        showYAxisLabel: { alias: 'showYAxisLabel'; required: false };
        xAxisLabel: { alias: 'xAxisLabel'; required: false };
        yAxisLabel: { alias: 'yAxisLabel'; required: false };
        tooltipDisabled: { alias: 'tooltipDisabled'; required: false };
        scaleType: { alias: 'scaleType'; required: false };
        gradient: { alias: 'gradient'; required: false };
        showGridLines: { alias: 'showGridLines'; required: false };
        activeEntries: { alias: 'activeEntries'; required: false };
        schemeType: { alias: 'schemeType'; required: false };
        trimXAxisTicks: { alias: 'trimXAxisTicks'; required: false };
        trimYAxisTicks: { alias: 'trimYAxisTicks'; required: false };
        rotateXAxisTicks: { alias: 'rotateXAxisTicks'; required: false };
        maxXAxisTickLength: { alias: 'maxXAxisTickLength'; required: false };
        maxYAxisTickLength: { alias: 'maxYAxisTickLength'; required: false };
        xAxisTickFormatting: { alias: 'xAxisTickFormatting'; required: false };
        yAxisTickFormatting: { alias: 'yAxisTickFormatting'; required: false };
        xAxisTicks: { alias: 'xAxisTicks'; required: false };
        yAxisTicks: { alias: 'yAxisTicks'; required: false };
        groupPadding: { alias: 'groupPadding'; required: false };
        barPadding: { alias: 'barPadding'; required: false };
        roundDomains: { alias: 'roundDomains'; required: false };
        roundEdges: { alias: 'roundEdges'; required: false };
        yScaleMax: { alias: 'yScaleMax'; required: false };
        showDataLabel: { alias: 'showDataLabel'; required: false };
        dataLabelFormatting: { alias: 'dataLabelFormatting'; required: false };
        noBarWhenZero: { alias: 'noBarWhenZero'; required: false };
        wrapTicks: { alias: 'wrapTicks'; required: false };
    },
    { activate: 'activate'; deactivate: 'deactivate' },
    ['tooltipTemplate'],
    never,
    false,
    never
>;

property ɵfac

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

property rotateXAxisTicks

rotateXAxisTicks: boolean;

property roundDomains

roundDomains: boolean;

property roundEdges

roundEdges: boolean;

property scaleType

scaleType: ScaleType;

property schemeType

schemeType: ScaleType;

property showDataLabel

showDataLabel: boolean;

property showGridLines

showGridLines: boolean;

property showXAxisLabel

showXAxisLabel: boolean;

property showYAxisLabel

showYAxisLabel: boolean;

property tooltipDisabled

tooltipDisabled: boolean;

property tooltipTemplate

tooltipTemplate: TemplateRef<any>;

property trackBy

trackBy: TrackByFunction<DataItem>;

property transform

transform: string;

property trimXAxisTicks

trimXAxisTicks: boolean;

property trimYAxisTicks

trimYAxisTicks: boolean;

property valueDomain

valueDomain: [number, number];

property valueScale

valueScale: any;

property wrapTicks

wrapTicks: boolean;

property xAxis

xAxis: any;

property xAxisHeight

xAxisHeight: number;

property xAxisLabel

xAxisLabel: string;

property xAxisTickFormatting

xAxisTickFormatting: any;

property xAxisTicks

xAxisTicks: any[];

property yAxis

yAxis: any;

property yAxisLabel

yAxisLabel: string;

property yAxisTickFormatting

yAxisTickFormatting: any;

property yAxisTicks

yAxisTicks: any[];

property yAxisWidth

yAxisWidth: number;

property yScaleMax

yScaleMax: number;

method getGroupDomain

getGroupDomain: () => string[];

method getGroupScale

getGroupScale: () => any;

method getInnerDomain

getInnerDomain: () => string[];

method getInnerScale

getInnerScale: () => any;

method getLegendOptions

getLegendOptions: () => LegendOptions;

method getValueDomain

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

method getValueScale

getValueScale: () => any;

method groupTransform

groupTransform: (group: DataItem) => string;

method ngOnInit

ngOnInit: () => void;

method onActivate

onActivate: (event: any, group: DataItem, fromLegend?: boolean) => void;

method onClick

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

method onDataLabelMaxHeightChanged

onDataLabelMaxHeightChanged: (event: any, groupIndex: number) => void;

method onDeactivate

onDeactivate: (event: any, group: DataItem, fromLegend?: boolean) => void;

method setColors

setColors: () => void;

method update

update: () => void;

method updateXAxisHeight

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

method updateYAxisWidth

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

class BarVerticalComponent

class BarVerticalComponent extends BaseChartComponent {}

property activate

activate: EventEmitter<any>;

property activeEntries

activeEntries: any[];

property barPadding

barPadding: number;

property colors

colors: ColorHelper;

property dataLabelFormatting

dataLabelFormatting: any;

property dataLabelMaxHeight

dataLabelMaxHeight: any;

property deactivate

deactivate: EventEmitter<any>;

property dims

dims: ViewDimensions;

property gradient

gradient: boolean;

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 noBarWhenZero

noBarWhenZero: boolean;

property ɵcmp

static ɵcmp: i0.ɵɵComponentDeclaration<
    BarVerticalComponent,
    'ngx-charts-bar-vertical',
    never,
    {
        legend: { alias: 'legend'; required: false };
        legendTitle: { alias: 'legendTitle'; required: false };
        legendPosition: { alias: 'legendPosition'; required: false };
        xAxis: { alias: 'xAxis'; required: false };
        yAxis: { alias: 'yAxis'; required: false };
        showXAxisLabel: { alias: 'showXAxisLabel'; required: false };
        showYAxisLabel: { alias: 'showYAxisLabel'; required: false };
        xAxisLabel: { alias: 'xAxisLabel'; required: false };
        yAxisLabel: { alias: 'yAxisLabel'; required: false };
        tooltipDisabled: { alias: 'tooltipDisabled'; required: false };
        gradient: { alias: 'gradient'; required: false };
        referenceLines: { alias: 'referenceLines'; required: false };
        showRefLines: { alias: 'showRefLines'; required: false };
        showRefLabels: { alias: 'showRefLabels'; required: false };
        showGridLines: { alias: 'showGridLines'; required: false };
        activeEntries: { alias: 'activeEntries'; required: false };
        schemeType: { alias: 'schemeType'; required: false };
        trimXAxisTicks: { alias: 'trimXAxisTicks'; required: false };
        trimYAxisTicks: { alias: 'trimYAxisTicks'; required: false };
        rotateXAxisTicks: { alias: 'rotateXAxisTicks'; required: false };
        maxXAxisTickLength: { alias: 'maxXAxisTickLength'; required: false };
        maxYAxisTickLength: { alias: 'maxYAxisTickLength'; required: false };
        xAxisTickFormatting: { alias: 'xAxisTickFormatting'; required: false };
        yAxisTickFormatting: { alias: 'yAxisTickFormatting'; required: false };
        xAxisTicks: { alias: 'xAxisTicks'; required: false };
        yAxisTicks: { alias: 'yAxisTicks'; required: false };
        barPadding: { alias: 'barPadding'; required: false };
        roundDomains: { alias: 'roundDomains'; required: false };
        roundEdges: { alias: 'roundEdges'; required: false };
        yScaleMax: { alias: 'yScaleMax'; required: false };
        yScaleMin: { alias: 'yScaleMin'; required: false };
        showDataLabel: { alias: 'showDataLabel'; required: false };
        dataLabelFormatting: { alias: 'dataLabelFormatting'; required: false };
        noBarWhenZero: { alias: 'noBarWhenZero'; required: false };
        wrapTicks: { alias: 'wrapTicks'; required: false };
    },
    { activate: 'activate'; deactivate: 'deactivate' },
    ['tooltipTemplate'],
    never,
    false,
    never
>;

property ɵfac

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

property referenceLines

referenceLines: any[];

property rotateXAxisTicks

rotateXAxisTicks: boolean;

property roundDomains

roundDomains: boolean;

property roundEdges

roundEdges: boolean;

property schemeType

schemeType: ScaleType;

property showDataLabel

showDataLabel: boolean;

property showGridLines

showGridLines: boolean;

property showRefLabels

showRefLabels: any;

property showRefLines

showRefLines: any;

property showXAxisLabel

showXAxisLabel: boolean;

property showYAxisLabel

showYAxisLabel: boolean;

property tooltipDisabled

tooltipDisabled: boolean;

property tooltipTemplate

tooltipTemplate: TemplateRef<any>;

property transform

transform: string;

property trimXAxisTicks

trimXAxisTicks: boolean;

property trimYAxisTicks

trimYAxisTicks: boolean;

property wrapTicks

wrapTicks: boolean;

property xAxis

xAxis: any;

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 yAxis

yAxis: any;

property yAxisLabel

yAxisLabel: string;

property yAxisTickFormatting

yAxisTickFormatting: any;

property yAxisTicks

yAxisTicks: any[];

property yAxisWidth

yAxisWidth: number;

property yDomain

yDomain: any;

property yScale

yScale: any;

property yScaleMax

yScaleMax: number;

property yScaleMin

yScaleMin: number;

method getLegendOptions

getLegendOptions: () => {
    scaleType: any;
    colors: any;
    domain: any[];
    title: any;
    position: LegendPosition;
};

method getXDomain

getXDomain: () => any[];

method getXScale

getXScale: () => any;

method getYDomain

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

method getYScale

getYScale: () => any;

method ngOnChanges

ngOnChanges: () => void;

method onActivate

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

method onClick

onClick: (data: DataItem | string) => void;

method onDataLabelMaxHeightChanged

onDataLabelMaxHeightChanged: (event: any) => void;

method onDeactivate

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

method setColors

setColors: () => void;

method update

update: () => void;

method updateXAxisHeight

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

method updateYAxisWidth

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

class BarVerticalNormalizedComponent

class BarVerticalNormalizedComponent extends BaseChartComponent {}

property activate

activate: EventEmitter<any>;

property activeEntries

activeEntries: any[];

property barChartType

barChartType: typeof BarChartType;

property barPadding

barPadding: number;

property colors

colors: ColorHelper;

property deactivate

deactivate: EventEmitter<any>;

property dims

dims: ViewDimensions;

property gradient

gradient: boolean;

property groupDomain

groupDomain: string[];

property innerDomain

innerDomain: string[];

property isSSR

isSSR: boolean;

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 noBarWhenZero

noBarWhenZero: boolean;

property ɵcmp

static ɵcmp: i0.ɵɵComponentDeclaration<
    BarVerticalNormalizedComponent,
    'ngx-charts-bar-vertical-normalized',
    never,
    {
        legend: { alias: 'legend'; required: false };
        legendTitle: { alias: 'legendTitle'; required: false };
        legendPosition: { alias: 'legendPosition'; required: false };
        xAxis: { alias: 'xAxis'; required: false };
        yAxis: { alias: 'yAxis'; required: false };
        showXAxisLabel: { alias: 'showXAxisLabel'; required: false };
        showYAxisLabel: { alias: 'showYAxisLabel'; required: false };
        xAxisLabel: { alias: 'xAxisLabel'; required: false };
        yAxisLabel: { alias: 'yAxisLabel'; required: false };
        tooltipDisabled: { alias: 'tooltipDisabled'; required: false };
        gradient: { alias: 'gradient'; required: false };
        showGridLines: { alias: 'showGridLines'; required: false };
        activeEntries: { alias: 'activeEntries'; required: false };
        schemeType: { alias: 'schemeType'; required: false };
        trimXAxisTicks: { alias: 'trimXAxisTicks'; required: false };
        trimYAxisTicks: { alias: 'trimYAxisTicks'; required: false };
        rotateXAxisTicks: { alias: 'rotateXAxisTicks'; required: false };
        maxXAxisTickLength: { alias: 'maxXAxisTickLength'; required: false };
        maxYAxisTickLength: { alias: 'maxYAxisTickLength'; required: false };
        xAxisTickFormatting: { alias: 'xAxisTickFormatting'; required: false };
        yAxisTickFormatting: { alias: 'yAxisTickFormatting'; required: false };
        xAxisTicks: { alias: 'xAxisTicks'; required: false };
        yAxisTicks: { alias: 'yAxisTicks'; required: false };
        barPadding: { alias: 'barPadding'; required: false };
        roundDomains: { alias: 'roundDomains'; required: false };
        noBarWhenZero: { alias: 'noBarWhenZero'; required: false };
        wrapTicks: { alias: 'wrapTicks'; required: false };
    },
    { activate: 'activate'; deactivate: 'deactivate' },
    ['tooltipTemplate'],
    never,
    false,
    never
>;

property ɵfac

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

property rotateXAxisTicks

rotateXAxisTicks: boolean;

property roundDomains

roundDomains: boolean;

property schemeType

schemeType: ScaleType;

property showGridLines

showGridLines: boolean;

property showXAxisLabel

showXAxisLabel: boolean;

property showYAxisLabel

showYAxisLabel: boolean;

property tooltipDisabled

tooltipDisabled: boolean;

property tooltipTemplate

tooltipTemplate: TemplateRef<any>;

property trackBy

trackBy: TrackByFunction<Series>;

property transform

transform: string;

property trimXAxisTicks

trimXAxisTicks: boolean;

property trimYAxisTicks

trimYAxisTicks: boolean;

property valueDomain

valueDomain: [number, number];

property wrapTicks

wrapTicks: boolean;

property xAxis

xAxis: any;

property xAxisHeight

xAxisHeight: number;

property xAxisLabel

xAxisLabel: string;

property xAxisTickFormatting

xAxisTickFormatting: any;

property xAxisTicks

xAxisTicks: any[];

property xScale

xScale: any;

property yAxis

yAxis: any;

property yAxisLabel

yAxisLabel: string;

property yAxisTickFormatting

yAxisTickFormatting: any;

property yAxisTicks

yAxisTicks: any[];

property yAxisWidth

yAxisWidth: number;

property yScale

yScale: any;

method getGroupDomain

getGroupDomain: () => string[];

method getInnerDomain

getInnerDomain: () => string[];

method getLegendOptions

getLegendOptions: () => LegendOptions;

method getXScale

getXScale: () => any;

method getYScale

getYScale: () => any;

method groupTransform

groupTransform: (group: Series) => string;

method ngOnInit

ngOnInit: () => void;

method onActivate

onActivate: (event: any, group: Series, fromLegend?: boolean) => void;

method onClick

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

method onDeactivate

onDeactivate: (event: any, group: Series, fromLegend?: boolean) => void;

method setColors

setColors: () => void;

method update

update: () => void;

method updateXAxisHeight

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

method updateYAxisWidth

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

class BarVerticalStackedComponent

class BarVerticalStackedComponent extends BaseChartComponent {}

property activate

activate: EventEmitter<any>;

property activeEntries

activeEntries: any[];

property barChartType

barChartType: typeof BarChartType;

property barPadding

barPadding: number;

property colors

colors: ColorHelper;

property dataLabelFormatting

dataLabelFormatting: any;

property dataLabelMaxHeight

dataLabelMaxHeight: any;

property deactivate

deactivate: EventEmitter<any>;

property dims

dims: ViewDimensions;

property gradient

gradient: boolean;

property groupDomain

groupDomain: string[];

property innerDomain

innerDomain: string[];

property isSSR

isSSR: boolean;

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 noBarWhenZero

noBarWhenZero: boolean;

property ɵcmp

static ɵcmp: i0.ɵɵComponentDeclaration<
    BarVerticalStackedComponent,
    'ngx-charts-bar-vertical-stacked',
    never,
    {
        legend: { alias: 'legend'; required: false };
        legendTitle: { alias: 'legendTitle'; required: false };
        legendPosition: { alias: 'legendPosition'; required: false };
        xAxis: { alias: 'xAxis'; required: false };
        yAxis: { alias: 'yAxis'; required: false };
        showXAxisLabel: { alias: 'showXAxisLabel'; required: false };
        showYAxisLabel: { alias: 'showYAxisLabel'; required: false };
        xAxisLabel: { alias: 'xAxisLabel'; required: false };
        yAxisLabel: { alias: 'yAxisLabel'; required: false };
        tooltipDisabled: { alias: 'tooltipDisabled'; required: false };
        gradient: { alias: 'gradient'; required: false };
        showGridLines: { alias: 'showGridLines'; required: false };
        activeEntries: { alias: 'activeEntries'; required: false };
        schemeType: { alias: 'schemeType'; required: false };
        trimXAxisTicks: { alias: 'trimXAxisTicks'; required: false };
        trimYAxisTicks: { alias: 'trimYAxisTicks'; required: false };
        rotateXAxisTicks: { alias: 'rotateXAxisTicks'; required: false };
        maxXAxisTickLength: { alias: 'maxXAxisTickLength'; required: false };
        maxYAxisTickLength: { alias: 'maxYAxisTickLength'; required: false };
        xAxisTickFormatting: { alias: 'xAxisTickFormatting'; required: false };
        yAxisTickFormatting: { alias: 'yAxisTickFormatting'; required: false };
        xAxisTicks: { alias: 'xAxisTicks'; required: false };
        yAxisTicks: { alias: 'yAxisTicks'; required: false };
        barPadding: { alias: 'barPadding'; required: false };
        roundDomains: { alias: 'roundDomains'; required: false };
        yScaleMax: { alias: 'yScaleMax'; required: false };
        showDataLabel: { alias: 'showDataLabel'; required: false };
        dataLabelFormatting: { alias: 'dataLabelFormatting'; required: false };
        noBarWhenZero: { alias: 'noBarWhenZero'; required: false };
        wrapTicks: { alias: 'wrapTicks'; required: false };
    },
    { activate: 'activate'; deactivate: 'deactivate' },
    ['tooltipTemplate'],
    never,
    false,
    never
>;

property ɵfac

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

property rotateXAxisTicks

rotateXAxisTicks: boolean;

property roundDomains

roundDomains: boolean;

property schemeType

schemeType: ScaleType;

property showDataLabel

showDataLabel: boolean;

property showGridLines

showGridLines: boolean;

property showXAxisLabel

showXAxisLabel: boolean;

property showYAxisLabel

showYAxisLabel: boolean;

property tickFormatting

tickFormatting: (label: string) => string;

property tooltipDisabled

tooltipDisabled: boolean;

property tooltipTemplate

tooltipTemplate: TemplateRef<any>;

property trackBy

trackBy: TrackByFunction<Series>;

property transform

transform: string;

property trimXAxisTicks

trimXAxisTicks: boolean;

property trimYAxisTicks

trimYAxisTicks: boolean;

property valueDomain

valueDomain: [number, number];

property wrapTicks

wrapTicks: boolean;

property xAxis

xAxis: any;

property xAxisHeight

xAxisHeight: number;

property xAxisLabel

xAxisLabel: string;

property xAxisTickFormatting

xAxisTickFormatting: any;

property xAxisTicks

xAxisTicks: any[];

property xScale

xScale: any;

property yAxis

yAxis: any;

property yAxisLabel

yAxisLabel: string;

property yAxisTickFormatting

yAxisTickFormatting: any;

property yAxisTicks

yAxisTicks: any[];

property yAxisWidth

yAxisWidth: number;

property yScale

yScale: any;

property yScaleMax

yScaleMax: number;

method getGroupDomain

getGroupDomain: () => string[];

method getInnerDomain

getInnerDomain: () => string[];

method getLegendOptions

getLegendOptions: () => LegendOptions;

method getValueDomain

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

method getXScale

getXScale: () => any;

method getYScale

getYScale: () => any;

method groupTransform

groupTransform: (group: Series) => string;

method ngOnChanges

ngOnChanges: () => void;

method ngOnInit

ngOnInit: () => void;

method onActivate

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

method onClick

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

method onDataLabelMaxHeightChanged

onDataLabelMaxHeightChanged: (event: any, groupIndex: number) => void;

method onDeactivate

onDeactivate: (event: any, group: Series, fromLegend?: boolean) => void;

method setColors

setColors: () => void;

method update

update: () => void;

method updateXAxisHeight

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

method updateYAxisWidth

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

class BaseChartComponent

class BaseChartComponent implements OnChanges, AfterViewInit, OnDestroy, OnInit {}

constructor

constructor(
    chartElement: ElementRef,
    zone: NgZone,
    cd: ChangeDetectorRef,
    platformId: any
);

property animations

animations: boolean;

property cd

protected cd: ChangeDetectorRef;

property chartElement

protected chartElement: ElementRef;

property customColors

customColors: any;

property height

height: number;

property ɵcmp

static ɵcmp: i0.ɵɵComponentDeclaration<
    BaseChartComponent,
    'base-chart',
    never,
    {
        results: { alias: 'results'; required: false };
        view: { alias: 'view'; required: false };
        scheme: { alias: 'scheme'; required: false };
        schemeType: { alias: 'schemeType'; required: false };
        customColors: { alias: 'customColors'; required: false };
        animations: { alias: 'animations'; required: false };
    },
    { select: 'select' },
    never,
    never,
    false,
    never
>;

property ɵfac

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

property platformId

platformId: any;

property resizeSubscription

resizeSubscription: any;

property results

results: any;

property scheme

scheme: string | Color;

property schemeType

schemeType: ScaleType;

property select

select: EventEmitter<any>;

property view

view: [number, number];

property visibilityObserver

visibilityObserver: VisibilityObserver;

property width

width: number;

property zone

protected zone: NgZone;

method formatDates

formatDates: () => void;

Converts all date objects that appear as name into formatted date strings

method getContainerDims

getContainerDims: () => ViewDimensions;

method ngAfterViewInit

ngAfterViewInit: () => void;

method ngOnChanges

ngOnChanges: (changes: SimpleChanges) => void;

method ngOnDestroy

ngOnDestroy: () => void;

method ngOnInit

ngOnInit: () => void;

method unbindEvents

protected unbindEvents: () => void;

method update

update: () => void;

class BoxChartComponent

class BoxChartComponent extends BaseChartComponent {}

property activate

activate: EventEmitter<IBoxModel>;

property colors

colors: ColorHelper;

Color data.

property deactivate

deactivate: EventEmitter<IBoxModel>;

property dims

dims: ViewDimensions;

Chart Dimensions, this came from Base Chart Component.

property gradient

gradient: boolean;

property legend

legend: boolean;

Show or hide the legend.

property legendOptions

legendOptions: LegendOptions;

Legend Options object to handle positioning, title, colors and domain.

property legendOptionsConfig

legendOptionsConfig: LegendOptions;

I think it is better to handle legend options as single Input object of type ILegendOptions

property legendPosition

legendPosition: LegendPosition;

property legendTitle

legendTitle: string;

property margin

margin: [number, number, number, number];

Chart Margins (For each side, counterclock wise).

property ɵcmp

static ɵcmp: i0.ɵɵComponentDeclaration<
    BoxChartComponent,
    'ngx-charts-box-chart',
    never,
    {
        legend: { alias: 'legend'; required: false };
        legendPosition: { alias: 'legendPosition'; required: false };
        legendTitle: { alias: 'legendTitle'; required: false };
        legendOptionsConfig: { alias: 'legendOptionsConfig'; required: false };
        showGridLines: { alias: 'showGridLines'; required: false };
        xAxis: { alias: 'xAxis'; required: false };
        yAxis: { alias: 'yAxis'; required: false };
        showXAxisLabel: { alias: 'showXAxisLabel'; required: false };
        showYAxisLabel: { alias: 'showYAxisLabel'; required: false };
        roundDomains: { alias: 'roundDomains'; required: false };
        xAxisLabel: { alias: 'xAxisLabel'; required: false };
        yAxisLabel: { alias: 'yAxisLabel'; required: false };
        roundEdges: { alias: 'roundEdges'; required: false };
        strokeColor: { alias: 'strokeColor'; required: false };
        strokeWidth: { alias: 'strokeWidth'; required: false };
        tooltipDisabled: { alias: 'tooltipDisabled'; required: false };
        gradient: { alias: 'gradient'; required: false };
        wrapTicks: { alias: 'wrapTicks'; required: false };
    },
    { select: 'select'; activate: 'activate'; deactivate: 'deactivate' },
    ['tooltipTemplate'],
    never,
    false,
    never
>;

property ɵfac

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

property results

results: BoxChartMultiSeries;

Input Data, this came from Base Chart Component.

property roundDomains

roundDomains: boolean;

property roundEdges

roundEdges: boolean;

property select

select: EventEmitter<IBoxModel>;

property seriesDomain

seriesDomain: string[];

property showGridLines

showGridLines: boolean;

property showXAxisLabel

showXAxisLabel: boolean;

property showYAxisLabel

showYAxisLabel: boolean;

property strokeColor

strokeColor: string;

property strokeWidth

strokeWidth: number;

property tooltipDisabled

tooltipDisabled: boolean;

property tooltipTemplate

tooltipTemplate: TemplateRef<any>;

property transform

transform: string;

Transform string css attribute for the chart container

property wrapTicks

wrapTicks: boolean;

property xAxis

xAxis: boolean;

property xAxisHeight

xAxisHeight: number;

Chart X axis dimension.

property xAxisLabel

xAxisLabel: string;

property xDomain

xDomain: StringOrNumberOrDate[];

property xScale

xScale: ScaleBand<string>;

property yAxis

yAxis: boolean;

property yAxisLabel

yAxisLabel: string;

property yAxisWidth

yAxisWidth: number;

Chart Y axis dimension.

property yDomain

yDomain: number[];

property yScale

yScale: ScaleLinear<number, number>;

method getSeriesDomain

getSeriesDomain: () => string[];

method getUniqueBoxChartXDomainValues

getUniqueBoxChartXDomainValues: (
    results: BoxChartMultiSeries
) => (string | number | Date)[];

method getXDomain

getXDomain: () => Array<string | number | Date>;

method getXScale

getXScale: (
    domain: Array<string | number | Date>,
    width: number
) => ScaleBand<string>;

method getYDomain

getYDomain: () => number[];

method getYScale

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

method ngOnChanges

ngOnChanges: () => void;

method onActivate

onActivate: (data: IBoxModel) => void;

method onClick

onClick: (data: IBoxModel) => void;

method onDeactivate

onDeactivate: (data: IBoxModel) => void;

method setColors

setColors: () => void;

method setScales

setScales: () => void;

method trackBy

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

method update

update: () => void;

method updateXAxisHeight

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

method updateYAxisWidth

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

class BoxChartModule

class BoxChartModule {}

property ɵfac

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

property ɵinj

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

property ɵmod

static ɵmod: i0.ɵɵNgModuleDeclaration<
    BoxChartModule,
    [typeof BoxChartComponent, typeof BoxSeriesComponent, typeof BoxComponent],
    [typeof ChartCommonModule],
    [typeof BoxChartComponent, typeof BoxSeriesComponent, typeof BoxComponent]
>;

class BoxComponent

class BoxComponent implements OnChanges {}

constructor

constructor(element: ElementRef, cd: ChangeDetectorRef);

property activate

activate: EventEmitter<IBoxModel>;

property animations

animations: boolean;

property ariaLabel

ariaLabel: string;

property BarOrientation

BarOrientation: typeof BarOrientation;

property boxPath

boxPath: string;

property boxStrokeWidth

boxStrokeWidth: number;

property cd

protected cd: ChangeDetectorRef;

property data

data: IBoxModel;

property deactivate

deactivate: EventEmitter<IBoxModel>;

property edges

readonly edges: boolean[];

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 initialized

initialized: boolean;

property isActive

isActive: boolean;

property lineCoordinates

lineCoordinates: LineCoordinates;

property maskLine

maskLine: string;

Mask Path to cut the line on the box part.

property maskLineId

maskLineId: string;

Mask Path Id to keep track of the mask element

property medianLineWidth

medianLineWidth: number;

property nativeElm

nativeElm: any;

property noBarWhenZero

noBarWhenZero: boolean;

property offset

offset: number;

property oldLineCoordinates

oldLineCoordinates: LineCoordinates;

property oldPath

oldPath: string;

property ɵcmp

static ɵcmp: i0.ɵɵComponentDeclaration<
    BoxComponent,
    'g[ngx-charts-box]',
    never,
    {
        strokeColor: { alias: 'strokeColor'; required: false };
        strokeWidth: { alias: 'strokeWidth'; required: false };
        fill: { alias: 'fill'; required: false };
        data: { alias: 'data'; required: false };
        width: { alias: 'width'; required: false };
        height: { alias: 'height'; required: false };
        x: { alias: 'x'; required: false };
        y: { alias: 'y'; required: false };
        lineCoordinates: { alias: 'lineCoordinates'; required: false };
        roundEdges: { alias: 'roundEdges'; required: false };
        gradient: { alias: 'gradient'; required: false };
        gradientStops: { alias: 'gradientStops'; required: false };
        offset: { alias: 'offset'; required: false };
        isActive: { alias: 'isActive'; required: false };
        animations: { alias: 'animations'; required: false };
        ariaLabel: { alias: 'ariaLabel'; required: false };
        noBarWhenZero: { alias: 'noBarWhenZero'; required: false };
    },
    { select: 'select'; activate: 'activate'; deactivate: 'deactivate' },
    never,
    never,
    false,
    never
>;

property ɵfac

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

property roundEdges

roundEdges: boolean;

property select

select: EventEmitter<IBoxModel>;

property strokeColor

strokeColor: string;

property strokeWidth

strokeWidth: number;

property whiskerStrokeWidth

whiskerStrokeWidth: number;

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 getStartingLineCoordinates

getStartingLineCoordinates: () => LineCoordinates;

method getStartingPath

getStartingPath: () => string;

method getStartOpacity

getStartOpacity: () => number;

method lineTween

lineTween: (
    attr: string,
    d: any,
    index: number,
    node: BaseType[] | ArrayLike<BaseType>
) => any;

See [D3 Selections](https://www.d3indepth.com/selections/)
Parameter d
The joined data.
Parameter index
The index of the element within the selection
Parameter node
The node element (Line).

method loadAnimation

loadAnimation: () => void;

method ngOnChanges

ngOnChanges: (changes: SimpleChanges) => void;

method onMouseEnter

onMouseEnter: () => void;

method onMouseLeave

onMouseLeave: () => void;

method pathTween

pathTween: (d1: string, precision: number) => () => (t: any) => string;

method update

update: () => void;

method updateLineEl

updateLineEl: () => void;

method updatePathEl

updatePathEl: () => void;

class BoxSeriesComponent

class BoxSeriesComponent implements OnChanges, OnInit {}

constructor

constructor(platformId: any);

property activate

activate: EventEmitter<IBoxModel>;

property animations

animations: boolean;

property box

box: IBoxModel;

property colors

colors: ColorHelper;

property counts

counts: DataItem[];

property deactivate

deactivate: EventEmitter<IBoxModel>;

property dims

dims: ViewDimensions;

property gradient

gradient: boolean;

property isSSR

isSSR: boolean;

property lineCoordinates

lineCoordinates: [IVector2D, IVector2D, IVector2D, IVector2D];

property ɵcmp

static ɵcmp: i0.ɵɵComponentDeclaration<
    BoxSeriesComponent,
    'g[ngx-charts-box-series]',
    never,
    {
        dims: { alias: 'dims'; required: false };
        series: { alias: 'series'; required: false };
        xScale: { alias: 'xScale'; required: false };
        yScale: { alias: 'yScale'; required: false };
        colors: { alias: 'colors'; required: false };
        animations: { alias: 'animations'; required: false };
        strokeColor: { alias: 'strokeColor'; required: false };
        strokeWidth: { alias: 'strokeWidth'; required: false };
        tooltipDisabled: { alias: 'tooltipDisabled'; required: false };
        tooltipTemplate: { alias: 'tooltipTemplate'; required: false };
        tooltipPlacement: { alias: 'tooltipPlacement'; required: false };
        tooltipType: { alias: 'tooltipType'; required: false };
        roundEdges: { alias: 'roundEdges'; required: false };
        gradient: { alias: 'gradient'; required: false };
    },
    { select: 'select'; activate: 'activate'; deactivate: 'deactivate' },
    never,
    never,
    false,
    never
>;

property ɵfac

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

property quartiles

quartiles: [number, number, number];

property roundEdges

roundEdges: boolean;

property select

select: EventEmitter<IBoxModel>;

property series

series: BoxChartSeries;

property strokeColor

strokeColor: string;

property strokeWidth

strokeWidth: number;

property tooltipDisabled

tooltipDisabled: boolean;

property tooltipPlacement

tooltipPlacement: PlacementTypes;

property tooltipTemplate

tooltipTemplate: TemplateRef<any>;

property tooltipTitle

tooltipTitle: string;

property tooltipType

tooltipType: StyleTypes;

property whiskers

whiskers: [number, number];

property xScale

xScale: ScaleBand<string>;

property yScale

yScale: ScaleLinear<number, number>;

method getBoxQuantiles

getBoxQuantiles: (inputData: Array<number | Date>) => [number, number, number];

method getLinesCoordinates

getLinesCoordinates: (
    seriesName: string,
    whiskers: [number, number],
    quartiles: [number, number, number],
    barWidth: number
) => [IVector2D, IVector2D, IVector2D, IVector2D];

method ngOnChanges

ngOnChanges: (changes: SimpleChanges) => void;

method ngOnInit

ngOnInit: () => void;

method onClick

onClick: (data: IBoxModel) => void;

method update

update: () => void;

method updateTooltipSettings

updateTooltipSettings: () => void;

class BubbleChartComponent

class BubbleChartComponent extends BaseChartComponent {}

property activate

activate: EventEmitter<any>;

property activeEntries

activeEntries: any[];

property autoScale

autoScale: boolean;

property bubblePadding

bubblePadding: number[];

property clipPath

clipPath: string;

property clipPathId

clipPathId: string;

property colors

colors: ColorHelper;

property data

data: BubbleChartSeries[];

property deactivate

deactivate: EventEmitter<any>;

property dims

dims: ViewDimensions;

property isSSR

isSSR: boolean;

property legend

legend: boolean;

property legendOptions

legendOptions: LegendOptions;

property legendPosition

legendPosition: LegendPosition;

property legendTitle

legendTitle: string;

property margin

margin: number[];

property maxRadius

maxRadius: number;

property maxXAxisTickLength

maxXAxisTickLength: number;

property maxYAxisTickLength

maxYAxisTickLength: number;

property minRadius

minRadius: number;

property ɵcmp

static ɵcmp: i0.ɵɵComponentDeclaration<
    BubbleChartComponent,
    'ngx-charts-bubble-chart',
    never,
    {
        showGridLines: { alias: 'showGridLines'; required: false };
        legend: { alias: 'legend'; required: false };
        legendTitle: { alias: 'legendTitle'; required: false };
        legendPosition: { alias: 'legendPosition'; required: false };
        xAxis: { alias: 'xAxis'; required: false };
        yAxis: { alias: 'yAxis'; required: false };
        showXAxisLabel: { alias: 'showXAxisLabel'; required: false };
        showYAxisLabel: { alias: 'showYAxisLabel'; required: false };
        xAxisLabel: { alias: 'xAxisLabel'; required: false };
        yAxisLabel: { alias: 'yAxisLabel'; required: false };
        trimXAxisTicks: { alias: 'trimXAxisTicks'; required: false };
        trimYAxisTicks: { alias: 'trimYAxisTicks'; required: false };
        rotateXAxisTicks: { alias: 'rotateXAxisTicks'; required: false };
        maxXAxisTickLength: { alias: 'maxXAxisTickLength'; required: false };
        maxYAxisTickLength: { alias: 'maxYAxisTickLength'; required: false };
        xAxisTickFormatting: { alias: 'xAxisTickFormatting'; required: false };
        yAxisTickFormatting: { alias: 'yAxisTickFormatting'; required: false };
        xAxisTicks: { alias: 'xAxisTicks'; required: false };
        yAxisTicks: { alias: 'yAxisTicks'; required: false };
        roundDomains: { alias: 'roundDomains'; required: false };
        maxRadius: { alias: 'maxRadius'; required: false };
        minRadius: { alias: 'minRadius'; required: false };
        autoScale: { alias: 'autoScale'; required: false };
        schemeType: { alias: 'schemeType'; required: false };
        tooltipDisabled: { alias: 'tooltipDisabled'; required: false };
        xScaleMin: { alias: 'xScaleMin'; required: false };
        xScaleMax: { alias: 'xScaleMax'; required: false };
        yScaleMin: { alias: 'yScaleMin'; required: false };
        yScaleMax: { alias: 'yScaleMax'; required: false };
        wrapTicks: { alias: 'wrapTicks'; required: false };
    },
    { activate: 'activate'; deactivate: 'deactivate' },
    ['tooltipTemplate'],
    never,
    false,
    never
>;

property ɵfac

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

property rDomain

rDomain: number[];

property rotateXAxisTicks

rotateXAxisTicks: boolean;

property roundDomains

roundDomains: boolean;

property rScale

rScale: any;

property scaleType

scaleType: ScaleType;

property schemeType

schemeType: ScaleType;

property seriesDomain

seriesDomain: number[];

property showGridLines

showGridLines: boolean;

property showXAxisLabel

showXAxisLabel: boolean;

property showYAxisLabel

showYAxisLabel: boolean;

property tooltipDisabled

tooltipDisabled: boolean;

property tooltipTemplate

tooltipTemplate: TemplateRef<any>;

property transform

transform: string;

property trimXAxisTicks

trimXAxisTicks: boolean;

property trimYAxisTicks

trimYAxisTicks: boolean;

property wrapTicks

wrapTicks: boolean;

property xAxis

xAxis: boolean;

property xAxisHeight

xAxisHeight: number;

property xAxisLabel

xAxisLabel: string;

property xAxisTickFormatting

xAxisTickFormatting: any;

property xAxisTicks

xAxisTicks: any[];

property xDomain

xDomain: number[];

property xScale

xScale: any;

property xScaleMax

xScaleMax: number;

property xScaleMin

xScaleMin: number;

property xScaleType

xScaleType: ScaleType;

property yAxis

yAxis: boolean;

property yAxisLabel

yAxisLabel: string;

property yAxisTickFormatting

yAxisTickFormatting: any;

property yAxisTicks

yAxisTicks: any[];

property yAxisWidth

yAxisWidth: number;

property yDomain

yDomain: number[];

property yScale

yScale: any;

property yScaleMax

yScaleMax: number;

property yScaleMin

yScaleMin: number;

property yScaleType

yScaleType: ScaleType;

method deactivateAll

deactivateAll: () => void;

method getBubblePadding

getBubblePadding: () => number[];

method getLegendOptions

getLegendOptions: () => LegendOptions;

method getRDomain

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

method getRScale

getRScale: (domain: any, range: any) => any;

method getXDomain

getXDomain: () => number[];

method getXScale

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

method getYDomain

getYDomain: () => number[];

method getYScale

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

method hideCircles

hideCircles: () => void;

method ngOnChanges

ngOnChanges: () => void;

method ngOnInit

ngOnInit: () => void;

method onActivate

onActivate: (item: any) => void;

method onClick

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

method onDeactivate

onDeactivate: (item: any) => void;

method setScales

setScales: () => void;

method trackBy

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

method update

update: () => void;

method updateXAxisHeight

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

method updateYAxisWidth

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

class BubbleChartModule

class BubbleChartModule {}

property ɵfac

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

property ɵinj

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

property ɵmod

static ɵmod: i0.ɵɵNgModuleDeclaration<
    BubbleChartModule,
    [typeof BubbleChartComponent, typeof BubbleSeriesComponent],
    [typeof ChartCommonModule],
    [typeof BubbleChartComponent, typeof BubbleSeriesComponent]
>;

class BubbleSeriesComponent

class BubbleSeriesComponent implements OnChanges, OnInit {}

constructor

constructor(platformId: any);

property activate

activate: EventEmitter<any>;

property activeEntries

activeEntries: any[];

property areaPath

areaPath: any;

property circles

circles: any[];

property colors

colors: ColorHelper;

property data

data: BubbleChartSeries;

property deactivate

deactivate: EventEmitter<any>;

property isSSR

isSSR: boolean;

property ɵcmp

static ɵcmp: i0.ɵɵComponentDeclaration<
    BubbleSeriesComponent,
    'g[ngx-charts-bubble-series]',
    never,
    {
        data: { alias: 'data'; required: false };
        xScale: { alias: 'xScale'; required: false };
        yScale: { alias: 'yScale'; required: false };
        rScale: { alias: 'rScale'; required: false };
        xScaleType: { alias: 'xScaleType'; required: false };
        yScaleType: { alias: 'yScaleType'; required: false };
        colors: { alias: 'colors'; required: false };
        visibleValue: { alias: 'visibleValue'; required: false };
        activeEntries: { alias: 'activeEntries'; required: false };
        xAxisLabel: { alias: 'xAxisLabel'; required: false };
        yAxisLabel: { alias: 'yAxisLabel'; required: false };
        tooltipDisabled: { alias: 'tooltipDisabled'; required: false };
        tooltipTemplate: { alias: 'tooltipTemplate'; required: false };
    },
    { select: 'select'; activate: 'activate'; deactivate: 'deactivate' },
    never,
    never,
    false,
    never
>;

property ɵfac

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

property placementTypes

placementTypes: typeof PlacementTypes;

property rScale

rScale: any;

property select

select: EventEmitter<any>;

property styleTypes

styleTypes: typeof StyleTypes;

property tooltipDisabled

tooltipDisabled: boolean;

property tooltipTemplate

tooltipTemplate: TemplateRef<any>;

property visibleValue

visibleValue: any;

property xAxisLabel

xAxisLabel: string;

property xScale

xScale: any;

property xScaleType

xScaleType: ScaleType;

property yAxisLabel

yAxisLabel: string;

property yScale

yScale: any;

property yScaleType

yScaleType: ScaleType;

method activateCircle

activateCircle: (circle: any) => void;

method deactivateCircle

deactivateCircle: (circle: any) => void;

method getCircles

getCircles: () => any[];

method getTooltipText

getTooltipText: (circle: any) => string;

method isActive

isActive: (entry: any) => boolean;

method isVisible

isVisible: (circle: any) => boolean;

method ngOnChanges

ngOnChanges: (changes: SimpleChanges) => void;

method ngOnInit

ngOnInit: () => void;

method onClick

onClick: (data: any) => void;

method trackBy

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

method update

update: () => void;

class CardComponent

class CardComponent implements OnChanges, OnDestroy, OnInit {}

constructor

constructor(
    element: ElementRef,
    cd: ChangeDetectorRef,
    zone: NgZone,
    platformId: any
);

property animationReq

animationReq: number;

property animations

animations: boolean;

property bandColor

bandColor: string;

property bandHeight

bandHeight: number;

property bandPath

bandPath: string;

property cardHeight

cardHeight: number;

property cardWidth

cardWidth: number;

property color

color: string;

property data

data: GridData;

property element

element: HTMLElement;

property formattedLabel

formattedLabel: string;

property height

height: number;

property initialized

initialized: boolean;

property label

label: string;

property labelFontSize

labelFontSize: number;

property labelFormatting

labelFormatting: any;

property medianSize

medianSize: number;

property ɵcmp

static ɵcmp: i0.ɵɵComponentDeclaration<
    CardComponent,
    'g[ngx-charts-card]',
    never,
    {
        color: { alias: 'color'; required: false };
        bandColor: { alias: 'bandColor'; required: false };
        textColor: { alias: 'textColor'; required: false };
        x: { alias: 'x'; required: false };
        y: { alias: 'y'; required: false };
        width: { alias: 'width'; required: false };
        height: { alias: 'height'; required: false };
        label: { alias: 'label'; required: false };
        data: { alias: 'data'; required: false };
        medianSize: { alias: 'medianSize'; required: false };
        valueFormatting: { alias: 'valueFormatting'; required: false };
        labelFormatting: { alias: 'labelFormatting'; required: false };
        animations: { alias: 'animations'; required: false };
    },
    { select: 'select' },
    never,
    never,
    false,
    never
>;

property ɵfac

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

property select

select: EventEmitter<any>;

property textColor

textColor: string;

property textEl

textEl: ElementRef;

property textFontSize

textFontSize: number;

property textPadding

textPadding: number[];

property textTransform

textTransform: string;

property textWidth

textWidth: number;

property transform

transform: string;

property transformBand

transformBand: string;

property value

value: string;

property valueFormatting

valueFormatting: any;

property width

width: number;

property x

x: number;

property y

y: number;

method ngOnChanges

ngOnChanges: (changes: SimpleChanges) => void;

method ngOnDestroy

ngOnDestroy: () => void;

method ngOnInit

ngOnInit: () => void;

method onClick

onClick: () => void;

method paddedValue

paddedValue: (value: string) => string;

method scaleText

scaleText: () => void;

method scaleTextSSR

scaleTextSSR: () => void;

method setPadding

setPadding: () => void;

method startCount

startCount: () => void;

method update

update: () => void;

class CardSeriesComponent

class CardSeriesComponent implements OnChanges {}

property animations

animations: boolean;

property bandColor

bandColor: string;

property cardColor

cardColor: string;

property cards

cards: CardModel[];

property colors

colors: ColorHelper;

property data

data: CardModel[];

property dims

dims: ViewDimensions;

property emptyColor

emptyColor: string;

property emptySlots

emptySlots: any[];

property innerPadding

innerPadding: number;

property labelFormatting

labelFormatting: any;

property medianSize

medianSize: number;

property ɵcmp

static ɵcmp: i0.ɵɵComponentDeclaration<
    CardSeriesComponent,
    'g[ngx-charts-card-series]',
    never,
    {
        data: { alias: 'data'; required: false };
        dims: { alias: 'dims'; required: false };
        colors: { alias: 'colors'; required: false };
        innerPadding: { alias: 'innerPadding'; required: false };
        cardColor: { alias: 'cardColor'; required: false };
        bandColor: { alias: 'bandColor'; required: false };
        emptyColor: { alias: 'emptyColor'; required: false };
        textColor: { alias: 'textColor'; required: false };
        valueFormatting: { alias: 'valueFormatting'; required: false };
        labelFormatting: { alias: 'labelFormatting'; required: false };
        animations: { alias: 'animations'; required: false };
    },
    { select: 'select' },
    never,
    never,
    false,
    never
>;

property ɵfac

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

property select

select: EventEmitter<any>;

property textColor

textColor: string;

property valueFormatting

valueFormatting: any;

method getCards

getCards: () => CardModel[];

method ngOnChanges

ngOnChanges: (changes: SimpleChanges) => void;

method onClick

onClick: (data: any) => void;

method trackBy

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

method update

update: () => void;

class ChartCommonModule

class ChartCommonModule {}

property ɵfac

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

property ɵinj

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

property ɵmod

static ɵmod: i0.ɵɵNgModuleDeclaration<
    ChartCommonModule,
    [
        typeof AreaComponent,
        typeof BaseChartComponent,
        typeof CountUpDirective,
        typeof TooltipArea,
        typeof ChartComponent,
        typeof LegendComponent,
        typeof LegendEntryComponent,
        typeof ScaleLegendComponent,
        typeof CircleComponent,
        typeof CircleSeriesComponent,
        typeof GridPanelComponent,
        typeof GridPanelSeriesComponent,
        typeof SvgLinearGradientComponent,
        typeof SvgRadialGradientComponent,
        typeof Timeline,
        typeof AdvancedLegendComponent,
        typeof VisibilityObserver
    ],
    [any, typeof AxesModule, typeof TooltipModule],
    [
        any,
        typeof AxesModule,
        typeof TooltipModule,
        typeof AreaComponent,
        typeof BaseChartComponent,
        typeof CountUpDirective,
        typeof TooltipArea,
        typeof ChartComponent,
        typeof LegendComponent,
        typeof LegendEntryComponent,
        typeof ScaleLegendComponent,
        typeof CircleComponent,
        typeof CircleSeriesComponent,
        typeof GridPanelComponent,
        typeof GridPanelSeriesComponent,
        typeof SvgLinearGradientComponent,
        typeof SvgRadialGradientComponent,
        typeof Timeline,
        typeof AdvancedLegendComponent,
        typeof VisibilityObserver
    ]
>;

class ChartComponent

class ChartComponent implements OnChanges {}

property activeEntries

activeEntries: any[];

property animations

animations: boolean;

property chartWidth

chartWidth: number;

property legendLabelActivate

legendLabelActivate: EventEmitter<{ name: string }>;

property legendLabelClick

legendLabelClick: EventEmitter<string>;

property legendLabelDeactivate

legendLabelDeactivate: EventEmitter<{ name: string }>;

property legendOptions

legendOptions: LegendOptions;

property LegendPosition

readonly LegendPosition: typeof LegendPosition;

property legendType

legendType: LegendType;

property LegendType

readonly LegendType: typeof LegendType;

property legendWidth

legendWidth: number;

property ɵcmp

static ɵcmp: i0.ɵɵComponentDeclaration<
    ChartComponent,
    'ngx-charts-chart',
    never,
    {
        view: { alias: 'view'; required: false };
        showLegend: { alias: 'showLegend'; required: false };
        legendOptions: { alias: 'legendOptions'; required: false };
        legendType: { alias: 'legendType'; required: false };
        activeEntries: { alias: 'activeEntries'; required: false };
        animations: { alias: 'animations'; required: false };
    },
    {
        legendLabelClick: 'legendLabelClick';
        legendLabelActivate: 'legendLabelActivate';
        legendLabelDeactivate: 'legendLabelDeactivate';
    },
    never,
    ['*'],
    false,
    never
>;

property ɵfac

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

property showLegend

showLegend: boolean;

property title

title: string;

property view

view: [number, number];

method getLegendType

getLegendType: () => LegendType;

method ngOnChanges

ngOnChanges: (changes: SimpleChanges) => void;

method update

update: () => void;

class CircleComponent

class CircleComponent implements OnChanges {}

property activate

activate: EventEmitter<string | number>;

property circleOpacity

circleOpacity: number;

property classNames

classNames: string | string[];

property cx

cx: number;

property cy

cy: number;

property data

data: string | number;

property deactivate

deactivate: EventEmitter<string | number>;

property fill

fill: string;

property ɵcmp

static ɵcmp: i0.ɵɵComponentDeclaration<
    CircleComponent,
    'g[ngx-charts-circle]',
    never,
    {
        cx: { alias: 'cx'; required: false };
        cy: { alias: 'cy'; required: false };
        r: { alias: 'r'; required: false };
        fill: { alias: 'fill'; required: false };
        stroke: { alias: 'stroke'; required: false };
        data: { alias: 'data'; required: false };
        classNames: { alias: 'classNames'; required: false };
        circleOpacity: { alias: 'circleOpacity'; required: false };
        pointerEvents: { alias: 'pointerEvents'; required: false };
    },
    { select: 'select'; activate: 'activate'; deactivate: 'deactivate' },
    never,
    never,
    false,
    never
>;

property ɵfac

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

property pointerEvents

pointerEvents: string;

property r

r: number;

property select

select: EventEmitter<string | number>;

property stroke

stroke: string;

method ngOnChanges

ngOnChanges: (changes: SimpleChanges) => void;

method onClick

onClick: () => void;

method onMouseEnter

onMouseEnter: () => void;

method onMouseLeave

onMouseLeave: () => void;

class CircleSeriesComponent

class CircleSeriesComponent implements OnChanges, OnInit {}

constructor

constructor(platformId: any);

property activate

activate: EventEmitter<{ name: StringOrNumberOrDate }>;

property activeEntries

activeEntries: any[];

property areaPath

areaPath: any;

property barOrientation

barOrientation: typeof BarOrientation;

property barVisible

barVisible: boolean;

property circle

circle: Circle;

property colors

colors: ColorHelper;

property data

data: Series;

property deactivate

deactivate: EventEmitter<{ name: StringOrNumberOrDate }>;

property gradientFill

gradientFill: string;

property gradientId

gradientId: string;

property isSSR

isSSR: boolean;

property ɵcmp

static ɵcmp: i0.ɵɵComponentDeclaration<
    CircleSeriesComponent,
    'g[ngx-charts-circle-series]',
    never,
    {
        data: { alias: 'data'; required: false };
        type: { alias: 'type'; required: false };
        xScale: { alias: 'xScale'; required: false };
        yScale: { alias: 'yScale'; required: false };
        colors: { alias: 'colors'; required: false };
        scaleType: { alias: 'scaleType'; required: false };
        visibleValue: { alias: 'visibleValue'; required: false };
        activeEntries: { alias: 'activeEntries'; required: false };
        tooltipDisabled: { alias: 'tooltipDisabled'; required: false };
        tooltipTemplate: { alias: 'tooltipTemplate'; required: false };
    },
    { select: 'select'; activate: 'activate'; deactivate: 'deactivate' },
    never,
    never,
    false,
    never
>;

property ɵfac

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

property placementTypes

placementTypes: typeof PlacementTypes;

property scaleType

scaleType: ScaleType;

property select

select: EventEmitter<DataItem>;

property styleTypes

styleTypes: typeof StyleTypes;

property tooltipDisabled

tooltipDisabled: boolean;

property tooltipTemplate

tooltipTemplate: TemplateRef<any>;

property type

type: SeriesType;

property visibleValue

visibleValue: boolean;

property xScale

xScale: any;

property yScale

yScale: any;

method activateCircle

activateCircle: () => void;

method deactivateCircle

deactivateCircle: () => void;

method getActiveCircle

getActiveCircle: () => Circle;

method getGradientStops

getGradientStops: (color: string) => Gradient[];

method getTooltipMinMaxText

getTooltipMinMaxText: (min: number, max: number) => string;

method getTooltipText

getTooltipText: ({
    tooltipLabel,
    value,
    seriesName,
    min,
    max,
}: {
    tooltipLabel: string;
    value: any;
    seriesName: string;
    min: number;
    max: number;
}) => string;

method isActive

isActive: (entry: any) => boolean;

method mapDataPointToCircle

mapDataPointToCircle: (d: any, i: number) => Circle;

method ngOnChanges

ngOnChanges: () => void;

method ngOnInit

ngOnInit: () => void;

method onClick

onClick: (data: DataItem) => void;

method update

update: () => void;

class ColorHelper

class ColorHelper {}

constructor

constructor(
    scheme: string | Color,
    type: ScaleType,
    domain: string[] | number[],
    customColors?: any
);

property colorDomain

colorDomain: string[];

property customColors

customColors: any;

property domain

domain: string[] | number[];

property scale

scale: any;

property scaleType

scaleType: ScaleType;

method generateColorScheme

generateColorScheme: (
    scheme: string | Color,
    type: ScaleType,
    domain: number[] | string[]
) => any;

method getColor

getColor: (value: StringOrNumberOrDate) => string;

method getLinearGradientStops

getLinearGradientStops: (
    value: number | string,
    start?: number | string
) => Gradient[];

class CountUpDirective

class CountUpDirective implements OnDestroy {}

Count up component
Loosely inspired by: - https://github.com/izupet/angular2-counto - https://inorganik.github.io/countUp.js/

constructor

constructor(cd: ChangeDetectorRef, element: ElementRef);

property countChange

countChange: EventEmitter<any>;

property countDecimals

countDecimals: number;

property countDuration

countDuration: number;

property countFinish

countFinish: EventEmitter<any>;

property countFrom

countFrom: any;

property countPrefix

countPrefix: string;

property countSuffix

countSuffix: string;

property countTo

countTo: any;

property formattedValue

formattedValue: string;

property nativeElement

nativeElement: any;

property ɵcmp

static ɵcmp: i0.ɵɵComponentDeclaration<
    CountUpDirective,
    '[ngx-charts-count-up]',
    never,
    {
        countDuration: { alias: 'countDuration'; required: false };
        countPrefix: { alias: 'countPrefix'; required: false };
        countSuffix: { alias: 'countSuffix'; required: false };
        valueFormatting: { alias: 'valueFormatting'; required: false };
        countDecimals: { alias: 'countDecimals'; required: false };
        countTo: { alias: 'countTo'; required: false };
        countFrom: { alias: 'countFrom'; required: false };
    },
    { countChange: 'countChange'; countFinish: 'countFinish' },
    never,
    never,
    false,
    never
>;

property ɵfac

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

property value

value: any;

property valueFormatting

valueFormatting: any;

method ngOnDestroy

ngOnDestroy: () => void;

method start

start: () => void;

class GaugeArcComponent

class GaugeArcComponent {}

property activate

activate: EventEmitter<any>;

property animations

animations: boolean;

property backgroundArc

backgroundArc: ArcItem;

property colors

colors: ColorHelper;

property cornerRadius

cornerRadius: number;

property deactivate

deactivate: EventEmitter<any>;

property isActive

isActive: boolean;

property ɵcmp

static ɵcmp: i0.ɵɵComponentDeclaration<
    GaugeArcComponent,
    'g[ngx-charts-gauge-arc]',
    never,
    {
        backgroundArc: { alias: 'backgroundArc'; required: false };
        valueArc: { alias: 'valueArc'; required: false };
        cornerRadius: { alias: 'cornerRadius'; required: false };
        colors: { alias: 'colors'; required: false };
        isActive: { alias: 'isActive'; required: false };
        tooltipDisabled: { alias: 'tooltipDisabled'; required: false };
        valueFormatting: { alias: 'valueFormatting'; required: false };
        tooltipTemplate: { alias: 'tooltipTemplate'; required: false };
        animations: { alias: 'animations'; required: false };
    },
    { select: 'select'; activate: 'activate'; deactivate: 'deactivate' },
    never,
    never,
    false,
    never
>;

property ɵfac

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

property placementTypes

placementTypes: typeof PlacementTypes;

property select

select: EventEmitter<any>;

property styleTypes

styleTypes: typeof StyleTypes;

property tooltipDisabled

tooltipDisabled: boolean;

property tooltipTemplate

tooltipTemplate: TemplateRef<any>;

property valueArc

valueArc: ArcItem;

property valueFormatting

valueFormatting: (value: any) => string;

method tooltipText

tooltipText: (arc: ArcItem) => string;

class GaugeAxisComponent

class GaugeAxisComponent implements OnChanges {}

property angleSpan

angleSpan: number;

property bigSegments

bigSegments: number;

property max

max: number;

property min

min: number;

property ɵcmp

static ɵcmp: i0.ɵɵComponentDeclaration<
    GaugeAxisComponent,
    'g[ngx-charts-gauge-axis]',
    never,
    {
        bigSegments: { alias: 'bigSegments'; required: false };
        smallSegments: { alias: 'smallSegments'; required: false };
        min: { alias: 'min'; required: false };
        max: { alias: 'max'; required: false };
        angleSpan: { alias: 'angleSpan'; required: false };
        startAngle: { alias: 'startAngle'; required: false };
        radius: { alias: 'radius'; required: false };
        valueScale: { alias: 'valueScale'; required: false };
        tickFormatting: { alias: 'tickFormatting'; required: false };
    },
    {},
    never,
    never,
    false,
    never
>;

property ɵfac

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

property radius

radius: number;

property rotate

rotate: string;

property rotationAngle

rotationAngle: number;

property smallSegments

smallSegments: number;

property startAngle

startAngle: number;

property tickFormatting

tickFormatting: any;

property ticks

ticks: Ticks;

property valueScale

valueScale: any;

method getTextAnchor

getTextAnchor: (angle: number) => TextAnchor;

method getTickPath

getTickPath: (startDistance: number, tickLength: number, angle: number) => any;

method getTicks

getTicks: () => Ticks;

method ngOnChanges

ngOnChanges: (changes: SimpleChanges) => void;

method update

update: () => void;

class GaugeComponent

class GaugeComponent extends BaseChartComponent implements AfterViewInit {}

property activate

activate: EventEmitter<any>;

property activeEntries

activeEntries: any[];

property angleSpan

angleSpan: number;

property arcs

arcs: Arcs[];

property axisTickFormatting

axisTickFormatting: any;

property bigSegments

bigSegments: number;

property colors

colors: ColorHelper;

property cornerRadius

cornerRadius: number;

property deactivate

deactivate: EventEmitter<any>;

property dims

dims: ViewDimensions;

property displayValue

displayValue: string;

property domain

domain: any[];

property legend

legend: boolean;

property legendOptions

legendOptions: LegendOptions;

property legendPosition

legendPosition: LegendPosition;

property legendTitle

legendTitle: string;

property margin

margin: number[];

property max

max: number;

property min

min: number;

property outerRadius

outerRadius: number;

property ɵcmp

static ɵcmp: i0.ɵɵComponentDeclaration<
    GaugeComponent,
    'ngx-charts-gauge',
    never,
    {
        legend: { alias: 'legend'; required: false };
        legendTitle: { alias: 'legendTitle'; required: false };
        legendPosition: { alias: 'legendPosition'; required: false };
        min: { alias: 'min'; required: false };
        max: { alias: 'max'; required: false };
        textValue: { alias: 'textValue'; required: false };
        units: { alias: 'units'; required: false };
        bigSegments: { alias: 'bigSegments'; required: false };
        smallSegments: { alias: 'smallSegments'; required: false };
        results: { alias: 'results'; required: false };
        showAxis: { alias: 'showAxis'; required: false };
        startAngle: { alias: 'startAngle'; required: false };
        angleSpan: { alias: 'angleSpan'; required: false };
        activeEntries: { alias: 'activeEntries'; required: false };
        axisTickFormatting: { alias: 'axisTickFormatting'; required: false };
        tooltipDisabled: { alias: 'tooltipDisabled'; required: false };
        valueFormatting: { alias: 'valueFormatting'; required: false };
        showText: { alias: 'showText'; required: false };
        margin: { alias: 'margin'; required: false };
    },
    { activate: 'activate'; deactivate: 'deactivate' },
    ['tooltipTemplate'],
    never,
    false,
    never
>;

property ɵfac

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

property resizeScale

resizeScale: number;

property results

results: any[];

property rotation

rotation: string;

property showAxis

showAxis: boolean;

property showText

showText: boolean;

property smallSegments

smallSegments: number;

property startAngle

startAngle: number;

property textEl

textEl: ElementRef;

property textRadius

textRadius: number;

property textTransform

textTransform: string;

property textValue

textValue: string;

property tooltipDisabled

tooltipDisabled: boolean;

property tooltipTemplate

tooltipTemplate: TemplateRef<any>;

property transform

transform: string;

property units

units: string;

property valueDomain

valueDomain: [number, number];

property valueFormatting

valueFormatting: (value: any) => string;

property valueScale

valueScale: any;

method getArcs

getArcs: () => any[];

method getDisplayValue

getDisplayValue: () => string;

method getDomain

getDomain: () => string[];

method getLegendOptions

getLegendOptions: () => LegendOptions;

method getValueDomain

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

method getValueScale

getValueScale: () => any;

method isActive

isActive: (entry: any) => boolean;

method ngAfterViewInit

ngAfterViewInit: () => void;

method ngOnChanges

ngOnChanges: () => void;

method onActivate

onActivate: (item: any) => void;

method onClick

onClick: (data: any) => void;

method onDeactivate

onDeactivate: (item: any) => void;

method scaleText

scaleText: (repeat?: boolean) => void;

method setColors

setColors: () => void;

method trackBy

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

method update

update: () => void;

class GaugeModule

class GaugeModule {}

property ɵfac

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

property ɵinj

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

property ɵmod

static ɵmod: i0.ɵɵNgModuleDeclaration<
    GaugeModule,
    [
        typeof LinearGaugeComponent,
        typeof GaugeComponent,
        typeof GaugeArcComponent,
        typeof GaugeAxisComponent,
        typeof PercentGaugeComponent
    ],
    [typeof ChartCommonModule, typeof PieChartModule, typeof BarChartModule],
    [
        typeof LinearGaugeComponent,
        typeof GaugeComponent,
        typeof GaugeArcComponent,
        typeof GaugeAxisComponent,
        typeof PercentGaugeComponent
    ]
>;

class GridPanelComponent

class GridPanelComponent {}

property height

height: number;

property ɵcmp

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

property ɵfac

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

property width

width: number;

property x

x: number;

property y

y: number;

class GridPanelSeriesComponent

class GridPanelSeriesComponent implements OnChanges {}

property data

data: any[];

property dims

dims: ViewDimensions;

property gridPanels

gridPanels: GridPanel[];

property orient

orient: BarOrientation;

property ɵcmp

static ɵcmp: i0.ɵɵComponentDeclaration<
    GridPanelSeriesComponent,
    'g[ngx-charts-grid-panel-series]',
    never,
    {
        data: { alias: 'data'; required: false };
        dims: { alias: 'dims'; required: false };
        xScale: { alias: 'xScale'; required: false };
        yScale: { alias: 'yScale'; required: false };
        orient: { alias: 'orient'; required: false };
    },
    {},
    never,
    never,
    false,
    never
>;

property ɵfac

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

property xScale

xScale: any;

property yScale

yScale: any;

method getGridPanels

getGridPanels: () => GridPanel[];

method ngOnChanges

ngOnChanges: (changes: SimpleChanges) => void;

method update

update: () => void;

class HeatCellSeriesComponent

class HeatCellSeriesComponent implements OnChanges, OnInit {}

property activate

activate: EventEmitter<DataItem>;

property animations

animations: boolean;

property cells

cells: Cell[];

property colors

colors: any;

property data

data: any;

property deactivate

deactivate: EventEmitter<DataItem>;

property gradient

gradient: boolean;

property ɵcmp

static ɵcmp: i0.ɵɵComponentDeclaration<
    HeatCellSeriesComponent,
    'g[ngx-charts-heat-map-cell-series]',
    never,
    {
        data: { alias: 'data'; required: false };
        colors: { alias: 'colors'; required: false };
        xScale: { alias: 'xScale'; required: false };
        yScale: { alias: 'yScale'; required: false };
        gradient: { alias: 'gradient'; required: false };
        tooltipDisabled: { alias: 'tooltipDisabled'; required: false };
        tooltipText: { alias: 'tooltipText'; required: false };
        tooltipTemplate: { alias: 'tooltipTemplate'; required: false };
        animations: { alias: 'animations'; required: false };
    },
    { select: 'select'; activate: 'activate'; deactivate: 'deactivate' },
    never,
    never,
    false,
    never
>;

property ɵfac

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

property placementTypes

placementTypes: typeof PlacementTypes;

property select

select: EventEmitter<DataItem>;

property styleTypes

styleTypes: typeof StyleTypes;

property tooltipDisabled

tooltipDisabled: boolean;

property tooltipTemplate

tooltipTemplate: TemplateRef<any>;

property tooltipText

tooltipText: any;

property xScale

xScale: any;

property yScale

yScale: any;

method getCells

getCells: () => Cell[];

method getTooltipText

getTooltipText: ({
    label,
    data,
    series,
}: {
    label: string;
    data: number;
    series: string;
}) => string;

method ngOnChanges

ngOnChanges: (changes: SimpleChanges) => void;

method ngOnInit

ngOnInit: () => void;

method onClick

onClick: (data: any) => void;

method trackBy

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

method update

update: () => void;

class HeatMapCellComponent

class HeatMapCellComponent implements OnChanges {}

constructor

constructor(element: ElementRef);

property activate

activate: EventEmitter<number>;

property animations

animations: boolean;

property barOrientation

barOrientation: typeof BarOrientation;

property data

data: number;

property deactivate

deactivate: EventEmitter<number>;

property element

element: HTMLElement;

property fill

fill: string;

property gradient

gradient: boolean;

property gradientId

gradientId: string;

property gradientStops

gradientStops: Gradient[];

property gradientUrl

gradientUrl: string;

property height

height: number;

property ɵcmp

static ɵcmp: i0.ɵɵComponentDeclaration<
    HeatMapCellComponent,
    'g[ngx-charts-heat-map-cell]',
    never,
    {
        fill: { alias: 'fill'; required: false };
        x: { alias: 'x'; required: false };
        y: { alias: 'y'; required: false };
        width: { alias: 'width'; required: false };
        height: { alias: 'height'; required: false };
        data: { alias: 'data'; required: false };
        gradient: { alias: 'gradient'; required: false };
        animations: { alias: 'animations'; required: false };
    },
    { select: 'select'; activate: 'activate'; deactivate: 'deactivate' },
    never,
    never,
    false,
    never
>;

property ɵfac

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

property select

select: EventEmitter<number>;

property startOpacity

startOpacity: number;

property transform

transform: string;

property width

width: number;

property x

x: number;

property y

y: number;

method animateToCurrentForm

animateToCurrentForm: () => void;

method getGradientStops

getGradientStops: () => Gradient[];

method loadAnimation

loadAnimation: () => void;

method ngOnChanges

ngOnChanges: (changes: SimpleChanges) => void;

method onClick

onClick: () => void;

method onMouseEnter

onMouseEnter: () => void;

method onMouseLeave

onMouseLeave: () => void;

class HeatMapComponent

class HeatMapComponent extends BaseChartComponent {}

property activate

activate: EventEmitter<any>;

property activeEntries

activeEntries: any[];

property colors

colors: ColorHelper;

property colorScale

colorScale: any;

property deactivate

deactivate: EventEmitter<any>;

property dims

dims: ViewDimensions;

property gradient

gradient: boolean;

property innerPadding

innerPadding: string | number | string[] | number[];

property legend

legend: boolean;

property legendOptions

legendOptions: LegendOptions;

property legendPosition

legendPosition: LegendPosition;

property legendTitle

legendTitle: string;

property margin

margin: number[];

property max

max: number;

property maxXAxisTickLength

maxXAxisTickLength: number;

property maxYAxisTickLength

maxYAxisTickLength: number;

property min

min: number;

property ɵcmp

static ɵcmp: i0.ɵɵComponentDeclaration<
    HeatMapComponent,
    'ngx-charts-heat-map',
    never,
    {
        legend: { alias: 'legend'; required: false };
        legendTitle: { alias: 'legendTitle'; required: false };
        legendPosition: { alias: 'legendPosition'; required: false };
        xAxis: { alias: 'xAxis'; required: false };
        yAxis: { alias: 'yAxis'; required: false };
        showXAxisLabel: { alias: 'showXAxisLabel'; required: false };
        showYAxisLabel: { alias: 'showYAxisLabel'; required: false };
        xAxisLabel: { alias: 'xAxisLabel'; required: false };
        yAxisLabel: { alias: 'yAxisLabel'; required: false };
        gradient: { alias: 'gradient'; required: false };
        innerPadding: { alias: 'innerPadding'; required: false };
        trimXAxisTicks: { alias: 'trimXAxisTicks'; required: false };
        trimYAxisTicks: { alias: 'trimYAxisTicks'; required: false };
        rotateXAxisTicks: { alias: 'rotateXAxisTicks'; required: false };
        maxXAxisTickLength: { alias: 'maxXAxisTickLength'; required: false };
        maxYAxisTickLength: { alias: 'maxYAxisTickLength'; required: false };
        xAxisTickFormatting: { alias: 'xAxisTickFormatting'; required: false };
        yAxisTickFormatting: { alias: 'yAxisTickFormatting'; required: false };
        xAxisTicks: { alias: 'xAxisTicks'; required: false };
        yAxisTicks: { alias: 'yAxisTicks'; required: false };
        tooltipDisabled: { alias: 'tooltipDisabled'; required: false };
        tooltipText: { alias: 'tooltipText'; required: false };
        min: { alias: 'min'; required: false };
        max: { alias: 'max'; required: false };
        activeEntries: { alias: 'activeEntries'; required: false };
        wrapTicks: { alias: 'wrapTicks'; required: false };
    },
    { activate: 'activate'; deactivate: 'deactivate' },
    ['tooltipTemplate'],
    never,
    false,
    never
>;

property ɵfac

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

property rects

rects: RectItem$1[];

property rotateXAxisTicks

rotateXAxisTicks: boolean;

property scaleType

scaleType: ScaleType;

property showXAxisLabel

showXAxisLabel: boolean;

property showYAxisLabel

showYAxisLabel: boolean;

property tooltipDisabled

tooltipDisabled: boolean;

property tooltipTemplate

tooltipTemplate: TemplateRef<any>;

property tooltipText

tooltipText: any;

property transform

transform: string;

property trimXAxisTicks

trimXAxisTicks: boolean;

property trimYAxisTicks

trimYAxisTicks: boolean;

property valueDomain

valueDomain: any[];

property wrapTicks

wrapTicks: boolean;

property xAxis

xAxis: boolean;

property xAxisHeight

xAxisHeight: number;

property xAxisLabel

xAxisLabel: string;

property xAxisTickFormatting

xAxisTickFormatting: any;

property xAxisTicks

xAxisTicks: any[];

property xDomain

xDomain: string[];

property xScale

xScale: any;

property yAxis

yAxis: boolean;

property yAxisLabel

yAxisLabel: string;

property yAxisTickFormatting

yAxisTickFormatting: any;

property yAxisTicks

yAxisTicks: any[];

property yAxisWidth

yAxisWidth: number;

property yDomain

yDomain: string[];

property yScale

yScale: any;

method getDimension

getDimension: (
    value: string | number | Array<string | number>,
    index: number,
    N: number,
    L: number
) => number;

Converts the input to gap paddingInner in fraction Supports the following inputs: Numbers: 8 Strings: "8", "8px", "8%" Arrays: [8,2], "8,2", "[8,2]" Mixed: [8,"2%"], ["8px","2%"], "8,2%", "[8,2%]"
HeatMapComponent

method getLegendOptions

getLegendOptions: () => LegendOptions;

method getRects

getRects: () => RectItem$1[];

method getValueDomain

getValueDomain: () => any[];

method getXDomain

getXDomain: () => string[];

method getXScale

getXScale: () => any;

method getYDomain

getYDomain: () => string[];

method getYScale

getYScale: () => any;

method ngOnChanges

ngOnChanges: () => void;

method onActivate

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

method onClick

onClick: (data: any) => void;

method onDeactivate

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

method setColors

setColors: () => void;

method update

update: () => void;

method updateXAxisHeight

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

method updateYAxisWidth

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

class HeatMapModule

class HeatMapModule {}

property ɵfac

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

property ɵinj

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

property ɵmod

static ɵmod: i0.ɵɵNgModuleDeclaration<
    HeatMapModule,
    [
        typeof HeatMapCellComponent,
        typeof HeatCellSeriesComponent,
        typeof HeatMapComponent
    ],
    [typeof ChartCommonModule],
    [
        typeof HeatMapCellComponent,
        typeof HeatCellSeriesComponent,
        typeof HeatMapComponent
    ]
>;

class LegendComponent

class LegendComponent implements OnChanges {}

constructor

constructor(cd: ChangeDetectorRef);

property activeEntries

activeEntries: any;

property colors

colors: ColorHelper;

property data

data: string[];

property height

height: number;

property horizontal

horizontal: boolean;

property labelActivate

labelActivate: EventEmitter<{ name: string }>;

property labelClick

labelClick: EventEmitter<string>;

property labelDeactivate

labelDeactivate: EventEmitter<{ name: string }>;

property legendEntries

legendEntries: LegendEntry[];

property ɵcmp

static ɵcmp: i0.ɵɵComponentDeclaration<
    LegendComponent,
    'ngx-charts-legend',
    never,
    {
        data: { alias: 'data'; required: false };
        title: { alias: 'title'; required: false };
        colors: { alias: 'colors'; required: false };
        height: { alias: 'height'; required: false };
        width: { alias: 'width'; required: false };
        activeEntries: { alias: 'activeEntries'; required: false };
        horizontal: { alias: 'horizontal'; required: false };
    },
    {
        labelClick: 'labelClick';
        labelActivate: 'labelActivate';
        labelDeactivate: 'labelDeactivate';
    },
    never,
    never,
    false,
    never
>;

property ɵfac

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

property title

title: string;

property width

width: number;

method activate

activate: (item: { name: string }) => void;

method deactivate

deactivate: (item: { name: string }) => void;

method getLegendEntries

getLegendEntries: () => LegendEntry[];

method isActive

isActive: (entry: LegendEntry) => boolean;

method ngOnChanges

ngOnChanges: (changes: SimpleChanges) => void;

method trackBy

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

method update

update: () => void;

class LegendEntryComponent

class LegendEntryComponent {}

property activate

activate: EventEmitter<{ name: string }>;

property color

color: string;

property deactivate

deactivate: EventEmitter<{ name: string }>;

property formattedLabel

formattedLabel: string;

property isActive

isActive: boolean;

property label

label: string;

property ɵcmp

static ɵcmp: i0.ɵɵComponentDeclaration<
    LegendEntryComponent,
    'ngx-charts-legend-entry',
    never,
    {
        color: { alias: 'color'; required: false };
        label: { alias: 'label'; required: false };
        formattedLabel: { alias: 'formattedLabel'; required: false };
        isActive: { alias: 'isActive'; required: false };
    },
    {
        select: 'select';
        activate: 'activate';
        deactivate: 'deactivate';
        toggle: 'toggle';
    },
    never,
    never,
    false,
    never
>;

property ɵfac

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

property select

select: EventEmitter<string>;

property toggle

toggle: EventEmitter<string>;

property trimmedLabel

readonly trimmedLabel: string;

method onMouseEnter

onMouseEnter: () => void;

method onMouseLeave

onMouseLeave: () => void;

class LinearGaugeComponent

class LinearGaugeComponent extends BaseChartComponent implements AfterViewInit {}

property barOrientation

barOrientation: typeof BarOrientation;

property colors

colors: ColorHelper;

property dims

dims: ViewDimensions;

property displayValue

displayValue: string;

property hasPreviousValue

hasPreviousValue: boolean;

property margin

margin: number[];

property max

max: number;

property min

min: number;

property ɵcmp

static ɵcmp: i0.ɵɵComponentDeclaration<
    LinearGaugeComponent,
    'ngx-charts-linear-gauge',
    never,
    {
        min: { alias: 'min'; required: false };
        max: { alias: 'max'; required: false };
        value: { alias: 'value'; required: false };
        units: { alias: 'units'; required: false };
        previousValue: { alias: 'previousValue'; required: false };
        valueFormatting: { alias: 'valueFormatting'; required: false };
    },
    {},
    never,
    never,
    false,
    never
>;

property ɵfac

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

property previousValue

previousValue: number;

property transform

transform: string;

property transformLine

transformLine: string;

property units

units: string;

property unitsResizeScale

unitsResizeScale: number;

property unitsTextEl

unitsTextEl: ElementRef;

property unitsTextTransform

unitsTextTransform: string;

property unitsTranslate

unitsTranslate: string;

property value

value: number;

property valueDomain

valueDomain: [number, number];

property valueFormatting

valueFormatting: any;

property valueResizeScale

valueResizeScale: number;

property valueScale

valueScale: any;

property valueTextEl

valueTextEl: ElementRef;

property valueTextTransform

valueTextTransform: string;

property valueTranslate

valueTranslate: string;

method getDisplayValue

getDisplayValue: () => string;

method getValueDomain

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

method getValueScale

getValueScale: () => any;

method ngAfterViewInit

ngAfterViewInit: () => void;

method ngOnChanges

ngOnChanges: () => void;

method onClick

onClick: () => void;

method scaleText

scaleText: (element: ElementType, repeat?: boolean) => void;

method scaleTextSSR

scaleTextSSR: (element: any) => void;

method setColors

setColors: () => void;

method update

update: () => void;

class LineChartComponent

class LineChartComponent extends BaseChartComponent implements OnInit {}

property activate

activate: EventEmitter<any>;

property activeEntries

activeEntries: any[];

property areaPath

areaPath: any;

property autoScale

autoScale: boolean;

property clipPath

clipPath: string;

property clipPathId

clipPathId: string;

property colors

colors: ColorHelper;

property curve

curve: any;

property deactivate

deactivate: EventEmitter<any>;

property dims

dims: ViewDimensions;

property filteredDomain

filteredDomain: any;

property gradient

gradient: boolean;

property hasRange

hasRange: boolean;

property hoveredVertical

hoveredVertical: any;

property isSSR

isSSR: boolean;

property legend

legend: boolean;

property legendOptions

legendOptions: any;

property legendPosition

legendPosition: LegendPosition;

property legendTitle

legendTitle: string;

property margin

margin: number[];

property maxXAxisTickLength

maxXAxisTickLength: number;

property maxYAxisTickLength

maxYAxisTickLength: number;

property ɵcmp

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

property ɵfac

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

property rangeFillOpacity

rangeFillOpacity: number;

property referenceLines

referenceLines: any;

property rotateXAxisTicks

rotateXAxisTicks: boolean;

property roundDomains

roundDomains: boolean;

property scaleType

scaleType: ScaleType;

property schemeType

schemeType: ScaleType;

property seriesDomain

seriesDomain: any;

property seriesTooltipTemplate

seriesTooltipTemplate: TemplateRef<any>;

property showGridLines

showGridLines: boolean;

property showRefLabels

showRefLabels: boolean;

property showRefLines

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

property timelineXDomain

timelineXDomain: any;

property timelineXScale

timelineXScale: any;

property timelineYScale

timelineYScale: any;

property tooltipDisabled

tooltipDisabled: boolean;

property tooltipTemplate

tooltipTemplate: TemplateRef<any>;

property transform

transform: string;

property trimXAxisTicks

trimXAxisTicks: boolean;

property trimYAxisTicks

trimYAxisTicks: boolean;

property wrapTicks

wrapTicks: 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: number;

property xScaleMin

xScaleMin: number;

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 ngOnChanges

ngOnChanges: () => void;

method ngOnInit

ngOnInit: () => void;

method onActivate

onActivate: (item: any) => void;

method onClick

onClick: (data: any) => void;

method onDeactivate

onDeactivate: (item: any) => void;

method setColors

setColors: () => void;

method trackBy

trackBy: (index: number, 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 LineChartModule

class LineChartModule {}

property ɵfac

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

property ɵinj

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

property ɵmod

static ɵmod: i0.ɵɵNgModuleDeclaration<
    LineChartModule,
    [
        typeof LineComponent,
        typeof LineChartComponent,
        typeof LineSeriesComponent
    ],
    [typeof ChartCommonModule],
    [typeof LineComponent, typeof LineChartComponent, typeof LineSeriesComponent]
>;

class LineComponent

class LineComponent implements OnChanges, OnInit {}

constructor

constructor(element: ElementRef, platformId: any);

property animations

animations: boolean;

property data

data: Series;

property fill

fill: string;

property initialized

initialized: boolean;

property initialPath

initialPath: string;

property isSSR

isSSR: boolean;

property ɵcmp

static ɵcmp: i0.ɵɵComponentDeclaration<
    LineComponent,
    'g[ngx-charts-line]',
    never,
    {
        path: { alias: 'path'; required: false };
        stroke: { alias: 'stroke'; required: false };
        data: { alias: 'data'; required: false };
        fill: { alias: 'fill'; required: false };
        animations: { alias: 'animations'; required: false };
    },
    {},
    never,
    never,
    false,
    never
>;

property ɵfac

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

property path

path: string;

property stroke

stroke: string;

method ngOnChanges

ngOnChanges: (changes: SimpleChanges) => void;

method ngOnInit

ngOnInit: () => void;

method updatePathEl

updatePathEl: () => void;

class LineSeriesComponent

class LineSeriesComponent implements OnChanges {}

property activeEntries

activeEntries: any[];

property animations

animations: boolean;

property areaGradientStops

areaGradientStops: Gradient[];

property areaPath

areaPath: string;

property barOrientation

barOrientation: typeof BarOrientation;

property colors

colors: ColorHelper;

property curve

curve: any;

property data

data: Series;

property gradientId

gradientId: string;

property gradientStops

gradientStops: Gradient[];

property gradientUrl

gradientUrl: string;

property hasGradient

hasGradient: boolean;

property hasRange

hasRange: boolean;

property outerPath

outerPath: string;

property ɵcmp

static ɵcmp: i0.ɵɵComponentDeclaration<
    LineSeriesComponent,
    'g[ngx-charts-line-series]',
    never,
    {
        data: { alias: 'data'; required: false };
        xScale: { alias: 'xScale'; required: false };
        yScale: { alias: 'yScale'; required: false };
        colors: { alias: 'colors'; required: false };
        scaleType: { alias: 'scaleType'; required: false };
        curve: { alias: 'curve'; required: false };
        activeEntries: { alias: 'activeEntries'; required: false };
        rangeFillOpacity: { alias: 'rangeFillOpacity'; required: false };
        hasRange: { alias: 'hasRange'; required: false };
        animations: { alias: 'animations'; required: false };
    },
    {},
    never,
    never,
    false,
    never
>;

property ɵfac

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

property path

path: string;

property rangeFillOpacity

rangeFillOpacity: number;

property scaleType

scaleType: ScaleType;

property stroke

stroke: string;

property xScale

xScale: any;

property yScale

yScale: any;

method getAreaGenerator

getAreaGenerator: () => any;

method getLineGenerator

getLineGenerator: () => any;

method getRangeGenerator

getRangeGenerator: () => any;

method isActive

isActive: (entry: any) => boolean;

method isInactive

isInactive: (entry: any) => boolean;

method ngOnChanges

ngOnChanges: (changes: SimpleChanges) => void;

method sortData

sortData: (data: any) => any;

method update

update: () => void;

method updateGradients

updateGradients: () => void;

class NgxChartsModule

class NgxChartsModule {}

constructor

constructor();

property ɵfac

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

property ɵinj

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

property ɵmod

static ɵmod: i0.ɵɵNgModuleDeclaration<
    NgxChartsModule,
    never,
    never,
    [
        typeof ChartCommonModule,
        typeof AreaChartModule,
        typeof BarChartModule,
        typeof BoxChartModule,
        typeof BubbleChartModule,
        typeof HeatMapModule,
        typeof SankeyModule,
        typeof LineChartModule,
        typeof PolarChartModule,
        typeof NumberCardModule,
        typeof PieChartModule,
        typeof TreeMapModule,
        typeof GaugeModule
    ]
>;

class NumberCardComponent

class NumberCardComponent extends BaseChartComponent {}

property bandColor

bandColor: string;

property cardColor

cardColor: string;

property clickable

readonly clickable: boolean;

property colors

colors: ColorHelper;

property data

data: CardModel[];

property designatedTotal

designatedTotal: number;

property dims

dims: ViewDimensions;

property domain

domain: any[];

property emptyColor

emptyColor: string;

property innerPadding

innerPadding: number;

property labelFormatting

labelFormatting: any;

property margin

margin: number[];

property ɵcmp

static ɵcmp: i0.ɵɵComponentDeclaration<
    NumberCardComponent,
    'ngx-charts-number-card',
    never,
    {
        cardColor: { alias: 'cardColor'; required: false };
        bandColor: { alias: 'bandColor'; required: false };
        emptyColor: { alias: 'emptyColor'; required: false };
        innerPadding: { alias: 'innerPadding'; required: false };
        textColor: { alias: 'textColor'; required: false };
        valueFormatting: { alias: 'valueFormatting'; required: false };
        labelFormatting: { alias: 'labelFormatting'; required: false };
        designatedTotal: { alias: 'designatedTotal'; required: false };
    },
    {},
    never,
    never,
    false,
    never
>;

property ɵfac

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

property textColor

textColor: string;

property transform

transform: string;

property valueFormatting

valueFormatting: any;

method getDomain

getDomain: () => string[];

method ngOnChanges

ngOnChanges: () => void;

method onClick

onClick: (data: any) => void;

method setColors

setColors: () => void;

method update

update: () => void;

class NumberCardModule

class NumberCardModule {}

property ɵfac

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

property ɵinj

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

property ɵmod

static ɵmod: i0.ɵɵNgModuleDeclaration<
    NumberCardModule,
    [
        typeof CardComponent,
        typeof CardSeriesComponent,
        typeof NumberCardComponent
    ],
    [typeof ChartCommonModule],
    [
        typeof CardComponent,
        typeof CardSeriesComponent,
        typeof NumberCardComponent
    ]
>;

class PercentGaugeComponent

class PercentGaugeComponent extends BaseChartComponent {}

property circleMaskId

circleMaskId: string;

property circleTransform

circleTransform: string;

property circumference

circumference: number;

property colors

colors: ColorHelper;

property dashes

dashes: string;

property defaultMargin

defaultMargin: number[];

property dims

dims: ViewDimensions;

property displayValue

displayValue: string;

property label

label: string;

property labelTransform

labelTransform: string;

property margin

margin: number[];

property max

max: number;

property ɵcmp

static ɵcmp: i0.ɵɵComponentDeclaration<
    PercentGaugeComponent,
    'ngx-charts-percent-gauge',
    never,
    {
        max: { alias: 'max'; required: false };
        value: { alias: 'value'; required: false };
        target: { alias: 'target'; required: false };
        targetLabel: { alias: 'targetLabel'; required: false };
        label: { alias: 'label'; required: false };
        valueFormatting: { alias: 'valueFormatting'; required: false };
        showLabel: { alias: 'showLabel'; required: false };
    },
    {},
    never,
    never,
    false,
    never
>;

property ɵfac

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

property percent

percent: number;

property radius

radius: number;

property showLabel

showLabel: boolean;

property target

target: number;

property targetColor

targetColor: string;

property targetLabel

targetLabel: string;

property targetRadius

targetRadius: number;

property targetTextTransform

targetTextTransform: string;

property targetTransform

targetTransform: string;

property ticHeight

ticHeight: number;

property ticks

ticks: any[];

property transform

transform: string;

property value

value: number;

property valueDomain

valueDomain: [number, number];

property valueFontSize

valueFontSize: number;

property valueFormatting

valueFormatting: any;

method generateCirclePoints

generateCirclePoints: (
    radius: number,
    numPoints: number
) => { x: number; y: number }[];

method generateticks

generateticks: () => void;

method getDisplayValue

getDisplayValue: () => string;

method getPercentage

getPercentage: () => number;

method getValueDomain

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

method onClick

onClick: () => void;

method setColors

setColors: () => void;

method update

update: () => void;

class PieArcComponent

class PieArcComponent implements OnChanges {}

constructor

constructor(element: ElementRef);

property activate

activate: EventEmitter<any>;

property animate

animate: boolean;

property barOrientation

barOrientation: typeof BarOrientation;

property cornerRadius

cornerRadius: number;

property data

data: DataItem;

property dblclick

dblclick: EventEmitter<any>;

property deactivate

deactivate: EventEmitter<any>;

property element

element: HTMLElement;

property endAngle

endAngle: number;

property explodeSlices

explodeSlices: boolean;

property fill

fill: string;

property gradient

gradient: boolean;

property gradientFill

gradientFill: string;

property initialized

initialized: boolean;

property innerRadius

innerRadius: number;

property isActive

isActive: boolean;

property max

max: number;

property outerRadius

outerRadius: number;

property ɵcmp

static ɵcmp: i0.ɵɵComponentDeclaration<
    PieArcComponent,
    'g[ngx-charts-pie-arc]',
    never,
    {
        fill: { alias: 'fill'; required: false };
        startAngle: { alias: 'startAngle'; required: false };
        endAngle: { alias: 'endAngle'; required: false };
        innerRadius: { alias: 'innerRadius'; required: false };
        outerRadius: { alias: 'outerRadius'; required: false };
        cornerRadius: { alias: 'cornerRadius'; required: false };
        value: { alias: 'value'; required: false };
        max: { alias: 'max'; required: false };
        data: { alias: 'data'; required: false };
        explodeSlices: { alias: 'explodeSlices'; required: false };
        gradient: { alias: 'gradient'; required: false };
        animate: { alias: 'animate'; required: false };
        pointerEvents: { alias: 'pointerEvents'; required: false };
        isActive: { alias: 'isActive'; required: false };
    },
    {
        select: 'select';
        activate: 'activate';
        deactivate: 'deactivate';
        dblclick: 'dblclick';
    },
    never,
    never,
    false,
    never
>;

property ɵfac

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

property path

path: any;

property pointerEvents

pointerEvents: boolean;

property radialGradientId

radialGradientId: string;

property select

select: EventEmitter<any>;

property startAngle

startAngle: number;

property startOpacity

startOpacity: number;

property value

value: number;

method calculateArc

calculateArc: () => any;

method getGradient

getGradient: () => string;

method getPointerEvents

getPointerEvents: () => string;

method loadAnimation

loadAnimation: () => void;

method ngOnChanges

ngOnChanges: (changes: SimpleChanges) => void;

method onClick

onClick: () => void;

method onDblClick

onDblClick: (event: MouseEvent) => void;

method update

update: () => void;

method updateAnimation

updateAnimation: () => void;

class PieChartComponent

class PieChartComponent extends BaseChartComponent {}

property activate

activate: EventEmitter<any>;

property activeEntries

activeEntries: any[];

property arcWidth

arcWidth: number;

property colors

colors: ColorHelper;

property data

data: DataItem[];

property dblclick

dblclick: EventEmitter<any>;

property deactivate

deactivate: EventEmitter<any>;

property dims

dims: ViewDimensions;

property domain

domain: string[];

property doughnut

doughnut: boolean;

property explodeSlices

explodeSlices: boolean;

property gradient

gradient: boolean;

property innerRadius

innerRadius: number;

property labelFormatting

labelFormatting: any;

property labels

labels: boolean;

property legend

legend: boolean;

property legendOptions

legendOptions: LegendOptions;

property legendPosition

legendPosition: LegendPosition;

property legendTitle

legendTitle: string;

property margins

margins: number[];

property maxLabelLength

maxLabelLength: number;

property outerRadius

outerRadius: number;

property ɵcmp

static ɵcmp: i0.ɵɵComponentDeclaration<
    PieChartComponent,
    'ngx-charts-pie-chart',
    never,
    {
        labels: { alias: 'labels'; required: false };
        legend: { alias: 'legend'; required: false };
        legendTitle: { alias: 'legendTitle'; required: false };
        legendPosition: { alias: 'legendPosition'; required: false };
        explodeSlices: { alias: 'explodeSlices'; required: false };
        doughnut: { alias: 'doughnut'; required: false };
        arcWidth: { alias: 'arcWidth'; required: false };
        gradient: { alias: 'gradient'; required: false };
        activeEntries: { alias: 'activeEntries'; required: false };
        tooltipDisabled: { alias: 'tooltipDisabled'; required: false };
        labelFormatting: { alias: 'labelFormatting'; required: false };
        trimLabels: { alias: 'trimLabels'; required: false };
        maxLabelLength: { alias: 'maxLabelLength'; required: false };
        tooltipText: { alias: 'tooltipText'; required: false };
        margins: { alias: 'margins'; required: false };
    },
    {
        dblclick: 'dblclick';
        select: 'select';
        activate: 'activate';
        deactivate: 'deactivate';
    },
    ['tooltipTemplate'],
    never,
    false,
    never
>;

property ɵfac

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

property select

select: EventEmitter<any>;

property tooltipDisabled

tooltipDisabled: boolean;

property tooltipTemplate

tooltipTemplate: TemplateRef<any>;

property tooltipText

tooltipText: any;

property translation

translation: string;

property trimLabels

trimLabels: boolean;

method getDomain

getDomain: () => string[];

method getLegendOptions

getLegendOptions: () => LegendOptions;

method ngOnChanges

ngOnChanges: () => void;

method onActivate

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

method onClick

onClick: (data: DataItem | string) => void;

method onDeactivate

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

method setColors

setColors: () => void;

method update

update: () => void;

class PieChartModule

class PieChartModule {}

property ɵfac

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

property ɵinj

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

property ɵmod

static ɵmod: i0.ɵɵNgModuleDeclaration<
    PieChartModule,
    [
        typeof AdvancedPieChartComponent,
        typeof PieLabelComponent,
        typeof PieArcComponent,
        typeof PieChartComponent,
        typeof PieGridComponent,
        typeof PieGridSeriesComponent,
        typeof PieSeriesComponent
    ],
    [typeof ChartCommonModule],
    [
        typeof AdvancedPieChartComponent,
        typeof PieLabelComponent,
        typeof PieArcComponent,
        typeof PieChartComponent,
        typeof PieGridComponent,
        typeof PieGridSeriesComponent,
        typeof PieSeriesComponent
    ]
>;

class PieGridComponent

class PieGridComponent extends BaseChartComponent {}

property activate

activate: EventEmitter<any>;

property activeEntries

activeEntries: any[];

property colorScale

colorScale: ColorHelper;

property data

data: PieGridData[];

property deactivate

deactivate: EventEmitter<any>;

property designatedTotal

designatedTotal: number;

property dims

dims: ViewDimensions;

property domain

domain: string[];

property label

label: string;

property margin

margin: number[];

property minWidth

minWidth: number;

property ɵcmp

static ɵcmp: i0.ɵɵComponentDeclaration<
    PieGridComponent,
    'ngx-charts-pie-grid',
    never,
    {
        designatedTotal: { alias: 'designatedTotal'; required: false };
        tooltipDisabled: { alias: 'tooltipDisabled'; required: false };
        tooltipText: { alias: 'tooltipText'; required: false };
        label: { alias: 'label'; required: false };
        minWidth: { alias: 'minWidth'; required: false };
        activeEntries: { alias: 'activeEntries'; required: false };
    },
    { activate: 'activate'; deactivate: 'deactivate' },
    ['tooltipTemplate'],
    never,
    false,
    never
>;

property ɵfac

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

property placementTypes

placementTypes: typeof PlacementTypes;

property series

series: any[];

property styleTypes

styleTypes: typeof StyleTypes;

property tooltipDisabled

tooltipDisabled: boolean;

property tooltipTemplate

tooltipTemplate: TemplateRef<any>;

property tooltipText

tooltipText: (o: any) => any;

property transform

transform: string;

method defaultTooltipText

defaultTooltipText: ({ data }: { data: any }) => string;

method getDomain

getDomain: () => string[];

method getSeries

getSeries: () => any[];

method getTotal

getTotal: () => any;

method ngOnChanges

ngOnChanges: () => void;

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 PieGridSeriesComponent

class PieGridSeriesComponent implements OnChanges {}

constructor

constructor(element: ElementRef);

property activate

activate: EventEmitter<any>;

property animations

animations: boolean;

property arcs

arcs: PieArc[];

property colors

colors: any;

property data

data: PieGridData[];

property deactivate

deactivate: EventEmitter<any>;

property element

element: HTMLElement;

property innerRadius

innerRadius: number;

property layout

layout: any;

property outerRadius

outerRadius: number;

property ɵcmp

static ɵcmp: i0.ɵɵComponentDeclaration<
    PieGridSeriesComponent,
    'g[ngx-charts-pie-grid-series]',
    never,
    {
        colors: { alias: 'colors'; required: false };
        data: { alias: 'data'; required: false };
        innerRadius: { alias: 'innerRadius'; required: false };
        outerRadius: { alias: 'outerRadius'; required: false };
        animations: { alias: 'animations'; required: false };
    },
    { select: 'select'; activate: 'activate'; deactivate: 'deactivate' },
    never,
    never,
    false,
    never
>;

property ɵfac

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

property select

select: EventEmitter<any>;

method color

color: (arc: any) => string;

method getArcs

getArcs: () => PieArc[];

method label

label: (arc: any) => string;

method ngOnChanges

ngOnChanges: (changes: SimpleChanges) => void;

method onClick

onClick: (data: any) => void;

method trackBy

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

method update

update: () => void;

class PieLabelComponent

class PieLabelComponent implements OnChanges {}

constructor

constructor(platformId: any);

property animations

animations: boolean;

property attrTransform

attrTransform: string;

property color

color: string;

property data

data: PieData;

property explodeSlices

explodeSlices: boolean;

property label

label: string;

property labelTrim

labelTrim: boolean;

property labelTrimSize

labelTrimSize: number;

property line

line: string;

property max

max: number;

property ɵcmp

static ɵcmp: i0.ɵɵComponentDeclaration<
    PieLabelComponent,
    'g[ngx-charts-pie-label]',
    never,
    {
        data: { alias: 'data'; required: false };
        radius: { alias: 'radius'; required: false };
        label: { alias: 'label'; required: false };
        color: { alias: 'color'; required: false };
        max: { alias: 'max'; required: false };
        value: { alias: 'value'; required: false };
        explodeSlices: { alias: 'explodeSlices'; required: false };
        animations: { alias: 'animations'; required: false };
        labelTrim: { alias: 'labelTrim'; required: false };
        labelTrimSize: { alias: 'labelTrimSize'; required: false };
    },
    {},
    never,
    never,
    false,
    never
>;

property ɵfac

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

property platformId

platformId: any;

property radius

radius: number;

property styleTransform

styleTransform: string;

property textTransition

textTransition: string;

property textX

readonly textX: number;

property textY

readonly textY: number;

property trimLabel

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

property value

value: number;

method midAngle

midAngle: (d: any) => number;

method ngOnChanges

ngOnChanges: (changes: SimpleChanges) => void;

method setTransforms

setTransforms: () => void;

method textAnchor

textAnchor: () => TextAnchor;

method update

update: () => void;

class PieSeriesComponent

class PieSeriesComponent implements OnChanges {}

property activate

activate: EventEmitter<any>;

property activeEntries

activeEntries: any[];

property animations

animations: boolean;

property colors

colors: ColorHelper;

property data

data: PieData[];

property dblclick

dblclick: EventEmitter<any>;

property deactivate

deactivate: EventEmitter<any>;

property dims

dims: ViewDimensions;

property explodeSlices

explodeSlices: boolean;

property gradient

gradient: boolean;

property innerRadius

innerRadius: number;

property labelFormatting

labelFormatting: any;

property max

max: number;

property maxLabelLength

maxLabelLength: number;

property outerRadius

outerRadius: number;

property ɵcmp

static ɵcmp: i0.ɵɵComponentDeclaration<
    PieSeriesComponent,
    'g[ngx-charts-pie-series]',
    never,
    {
        colors: { alias: 'colors'; required: false };
        series: { alias: 'series'; required: false };
        dims: { alias: 'dims'; required: false };
        innerRadius: { alias: 'innerRadius'; required: false };
        outerRadius: { alias: 'outerRadius'; required: false };
        explodeSlices: { alias: 'explodeSlices'; required: false };
        showLabels: { alias: 'showLabels'; required: false };
        gradient: { alias: 'gradient'; required: false };
        activeEntries: { alias: 'activeEntries'; required: false };
        labelFormatting: { alias: 'labelFormatting'; required: false };
        trimLabels: { alias: 'trimLabels'; required: false };
        maxLabelLength: { alias: 'maxLabelLength'; required: false };
        tooltipText: { alias: 'tooltipText'; required: false };
        tooltipDisabled: { alias: 'tooltipDisabled'; required: false };
        tooltipTemplate: { alias: 'tooltipTemplate'; required: false };
        animations: { alias: 'animations'; required: false };
    },
    {
        select: 'select';
        activate: 'activate';
        deactivate: 'deactivate';
        dblclick: 'dblclick';
    },
    never,
    never,
    false,
    never
>;

property ɵfac

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

property placementTypes

placementTypes: typeof PlacementTypes;

property select

select: EventEmitter<any>;

property series

series: DataItem[];

property showLabels

showLabels: boolean;

property styleTypes

styleTypes: typeof StyleTypes;

property tooltipDisabled

tooltipDisabled: boolean;

property tooltipTemplate

tooltipTemplate: TemplateRef<any>;

property tooltipText

tooltipText: (o: any) => any;

property trimLabels

trimLabels: boolean;

method calculateLabelPositions

calculateLabelPositions: (pieData: any) => any;

method color

color: (myArc: any) => any;

method defaultTooltipText

defaultTooltipText: (myArc: any) => string;

method getTooltipTitle

getTooltipTitle: (a: any) => any;

method isActive

isActive: (entry: any) => boolean;

method label

label: (myArc: any) => string;

method labelText

labelText: (myArc: any) => string;

method labelVisible

labelVisible: (myArc: any) => boolean;

method midAngle

midAngle: (d: any) => number;

method ngOnChanges

ngOnChanges: (changes: SimpleChanges) => void;

method onClick

onClick: (data: any) => void;

method outerArc

outerArc: () => any;

method trackBy

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

method update

update: () => void;

class PolarChartComponent

class PolarChartComponent extends BaseChartComponent implements OnInit {}

property activate

activate: EventEmitter<any>;

property activeEntries

activeEntries: any[];

property autoScale

autoScale: boolean;

property colors

colors: ColorHelper;

property curve

curve: any;

property deactivate

deactivate: EventEmitter<any>;

property dims

dims: ViewDimensions;

property filteredDomain

filteredDomain: any;

property gradient

gradient: boolean;

property isSSR

isSSR: boolean;

property labelOffset

labelOffset: number;

property labelTrim

labelTrim: boolean;

property labelTrimSize

labelTrimSize: number;

property legend

legend: boolean;

property legendOptions

legendOptions: any;

property legendPosition

legendPosition: LegendPosition;

property legendTitle

legendTitle: string;

property margin

margin: number[];

property maxYAxisTickLength

maxYAxisTickLength: number;

property orientation

orientation: typeof Orientation;

property outerRadius

outerRadius: number;

property ɵcmp

static ɵcmp: i0.ɵɵComponentDeclaration<
    PolarChartComponent,
    'ngx-charts-polar-chart',
    never,
    {
        legend: { alias: 'legend'; required: false };
        legendTitle: { alias: 'legendTitle'; required: false };
        legendPosition: { alias: 'legendPosition'; required: false };
        xAxis: { alias: 'xAxis'; required: false };
        yAxis: { alias: 'yAxis'; required: false };
        showXAxisLabel: { alias: 'showXAxisLabel'; required: false };
        showYAxisLabel: { alias: 'showYAxisLabel'; required: false };
        xAxisLabel: { alias: 'xAxisLabel'; required: false };
        yAxisLabel: { alias: 'yAxisLabel'; required: false };
        autoScale: { alias: 'autoScale'; required: false };
        showGridLines: { alias: 'showGridLines'; required: false };
        curve: { alias: 'curve'; required: false };
        activeEntries: { alias: 'activeEntries'; required: false };
        schemeType: { alias: 'schemeType'; required: false };
        rangeFillOpacity: { alias: 'rangeFillOpacity'; required: false };
        trimYAxisTicks: { alias: 'trimYAxisTicks'; required: false };
        maxYAxisTickLength: { alias: 'maxYAxisTickLength'; required: false };
        xAxisTickFormatting: { alias: 'xAxisTickFormatting'; required: false };
        yAxisTickFormatting: { alias: 'yAxisTickFormatting'; required: false };
        roundDomains: { alias: 'roundDomains'; required: false };
        tooltipDisabled: { alias: 'tooltipDisabled'; required: false };
        showSeriesOnHover: { alias: 'showSeriesOnHover'; required: false };
        gradient: { alias: 'gradient'; required: false };
        yAxisMinScale: { alias: 'yAxisMinScale'; required: false };
        labelTrim: { alias: 'labelTrim'; required: false };
        labelTrimSize: { alias: 'labelTrimSize'; required: false };
        wrapTicks: { alias: 'wrapTicks'; required: false };
    },
    { activate: 'activate'; deactivate: 'deactivate' },
    ['tooltipTemplate'],
    never,
    false,
    never
>;

property ɵfac

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

property radiusTicks

radiusTicks: number[];

property rangeFillOpacity

rangeFillOpacity: number;

property roundDomains

roundDomains: boolean;

property scaleType

scaleType: ScaleType;

property schemeType

schemeType: ScaleType;

property seriesDomain

seriesDomain: any;

property showGridLines

showGridLines: boolean;

property showSeriesOnHover

showSeriesOnHover: boolean;

property showXAxisLabel

showXAxisLabel: boolean;

property showYAxisLabel

showYAxisLabel: boolean;

property thetaTicks

thetaTicks: any[];

property tooltipDisabled

tooltipDisabled: boolean;

property tooltipTemplate

tooltipTemplate: TemplateRef<any>;

property transform

transform: string;

property transformPlot

transformPlot: string;

property transformXAxis

transformXAxis: string;

property transformYAxis

transformYAxis: string;

property trimYAxisTicks

trimYAxisTicks: boolean;

property wrapTicks

wrapTicks: boolean;

property xAxis

xAxis: boolean;

property xAxisHeight

xAxisHeight: number;

property xAxisLabel

xAxisLabel: string;

property xAxisTickFormatting

xAxisTickFormatting: (o: any) => any;

property xDomain

xDomain: any;

property xScale

xScale: any;

property yAxis

yAxis: boolean;

property yAxisDims

yAxisDims: ViewDimensions;

property yAxisLabel

yAxisLabel: string;

property yAxisMinScale

yAxisMinScale: number;

property yAxisScale

yAxisScale: any;

property yAxisTickFormatting

yAxisTickFormatting: (o: any) => any;

property yAxisWidth

yAxisWidth: number;

property yDomain

yDomain: any;

property yScale

yScale: any;

method deactivateAll

deactivateAll: () => void;

method getLegendOptions

getLegendOptions: () =>
    | {
          scaleType: ScaleType.Ordinal;
          colors: ColorHelper;
          domain: any;
          title: string;
          position: LegendPosition;
      }
    | {
          scaleType: ScaleType.Time | ScaleType.Linear | ScaleType.Quantile;
          colors: any;
          domain: any;
          title: any;
          position: LegendPosition;
      };

method getSeriesDomain

getSeriesDomain: () => any[];

method getXDomain

getXDomain: (values?: any[]) => any[];

method getXScale

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

method getXValues

getXValues: () => any[];

method getYDomain

getYDomain: (domain?: any[]) => any[];

method getYScale

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

method getYValues

getYValues: () => any[];

method ngOnChanges

ngOnChanges: () => void;

method ngOnInit

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

setDims: () => void;

method setScales

setScales: () => void;

method setTicks

setTicks: () => void;

method trackBy

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

method update

update: () => void;

method updateXAxisHeight

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

method updateYAxisWidth

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

class PolarChartModule

class PolarChartModule {}

property ɵfac

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

property ɵinj

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

property ɵmod

static ɵmod: i0.ɵɵNgModuleDeclaration<
    PolarChartModule,
    [typeof PolarChartComponent, typeof PolarSeriesComponent],
    [typeof ChartCommonModule, typeof PieChartModule, typeof LineChartModule],
    [typeof PolarChartComponent, typeof PolarSeriesComponent]
>;

class PolarSeriesComponent

class PolarSeriesComponent implements OnChanges {}

property activate

activate: EventEmitter<any>;

property active

active: boolean;

property activeEntries

activeEntries: any[];

property animations

animations: boolean;

property areaGradientStops

areaGradientStops: any[];

property areaPath

areaPath: string;

property barOrientation

barOrientation: typeof BarOrientation;

property circleRadius

circleRadius: number;

property circles

circles: PolarChartCircle[];

property colors

colors: any;

property curve

curve: any;

property data

data: any;

property deactivate

deactivate: EventEmitter<any>;

property gradient

gradient: boolean;

property gradientId

gradientId: string;

property gradientStops

gradientStops: any[];

property gradientUrl

gradientUrl: string;

property hasGradient

hasGradient: boolean;

property inactive

inactive: boolean;

property name

name: any;

property ɵcmp

static ɵcmp: i0.ɵɵComponentDeclaration<
    PolarSeriesComponent,
    'g[ngx-charts-polar-series]',
    never,
    {
        name: { alias: 'name'; required: false };
        data: { alias: 'data'; required: false };
        xScale: { alias: 'xScale'; required: false };
        yScale: { alias: 'yScale'; required: false };
        colors: { alias: 'colors'; required: false };
        scaleType: { alias: 'scaleType'; required: false };
        curve: { alias: 'curve'; required: false };
        activeEntries: { alias: 'activeEntries'; required: false };
        rangeFillOpacity: { alias: 'rangeFillOpacity'; required: false };
        tooltipDisabled: { alias: 'tooltipDisabled'; required: false };
        tooltipText: { alias: 'tooltipText'; required: false };
        gradient: { alias: 'gradient'; required: false };
        tooltipTemplate: { alias: 'tooltipTemplate'; required: false };
        animations: { alias: 'animations'; required: false };
    },
    { select: 'select'; activate: 'activate'; deactivate: 'deactivate' },
    never,
    never,
    false,
    never
>;

property ɵfac

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

property path

path: string;

property placementTypes

placementTypes: typeof PlacementTypes;

property rangeFillOpacity

rangeFillOpacity: number;

property scaleType

scaleType: any;

property select

select: EventEmitter<any>;

property seriesColor

seriesColor: string;

property styleTypes

styleTypes: typeof StyleTypes;

property tooltipDisabled

tooltipDisabled: boolean;

property tooltipTemplate

tooltipTemplate: TemplateRef<any>;

property tooltipText

tooltipText: (o: any) => string;

property xScale

xScale: any;

property yScale

yScale: any;

method defaultTooltipText

defaultTooltipText: ({
    label,
    value,
}: {
    label: string;
    value: number;
}) => string;

method getAngle

getAngle: (d: DataItem) => any;

method getLineGenerator

getLineGenerator: () => any;

method getRadius

getRadius: (d: DataItem) => any;

method isActive

isActive: (entry: DataItem) => boolean;

method isInactive

isInactive: (entry: DataItem) => boolean;

method ngOnChanges

ngOnChanges: (changes: SimpleChanges) => void;

method sortData

sortData: (data: DataItem) => any[];

method update

update: () => void;

method updateGradients

updateGradients: () => void;

class SankeyComponent

class SankeyComponent extends BaseChartComponent {}

property activate

activate: EventEmitter<any>;

property activeEntries

activeEntries: any[];

property chartHasActive

chartHasActive: boolean;

property colors

colors: ColorHelper;

property colorScale

colorScale: any;

property deactivate

deactivate: EventEmitter<any>;

property dims

dims: ViewDimensions;

property gradient

gradient: boolean;

property hasActive

readonly hasActive: boolean;

property labelElements

labelElements: QueryList<ElementRef<SVGTextElement>>;

property labelFormatting

labelFormatting: any;

property labelWidthMap

labelWidthMap: Map<string, number>;

property linkPaths

linkPaths: any[];

property margin

margin: number[];

property nodeLayerMap

nodeLayerMap: Map<number, any[]>;

property nodeRects

nodeRects: RectItem[];

property ɵcmp

static ɵcmp: i0.ɵɵComponentDeclaration<
    SankeyComponent,
    'ngx-charts-sankey',
    never,
    {
        showLabels: { alias: 'showLabels'; required: false };
        gradient: { alias: 'gradient'; required: false };
        tooltipDisabled: { alias: 'tooltipDisabled'; required: false };
        activeEntries: { alias: 'activeEntries'; required: false };
        labelFormatting: { alias: 'labelFormatting'; required: false };
        truncateLabels: { alias: 'truncateLabels'; required: false };
    },
    { activate: 'activate'; deactivate: 'deactivate' },
    ['tooltipTemplate'],
    never,
    false,
    never
>;

property ɵfac

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

property scaleType

scaleType: ScaleType;

property showLabels

showLabels: boolean;

property styleTypes

styleTypes: typeof StyleTypes;

property tooltipDisabled

tooltipDisabled: boolean;

property tooltipTemplate

tooltipTemplate: TemplateRef<any>;

property transform

transform: string;

property truncateLabels

truncateLabels: boolean;

property valueDomain

valueDomain: any[];

method activateLink

activateLink: (link: any) => void;

method activateRect

activateRect: (rect: any) => void;

method calculateAvailableSpaceForLabel

calculateAvailableSpaceForLabel: (rect: RectItem) => number;

method deactivateLink

deactivateLink: (link: any) => void;

method deactivateRect

deactivateRect: (rect: any) => void;

method fixOverlappingLabels

fixOverlappingLabels: () => void;

handle label overlapping between nodes on layer1 and layer2

method getAdjacentLayerNodes

getAdjacentLayerNodes: (node: any, isLeftSideNode: boolean) => any[];

method getLinkTooltipText

getLinkTooltipText: (sourceNode: any, targetNode: any, value: number) => string;

method getNodeLayerMap

getNodeLayerMap: (nodes: any[]) => Map<number, any[]>;

method getNodeTooltipText

getNodeTooltipText: (node: any) => string;

method getTextAnchor

getTextAnchor: (node: any) => TextAnchor;

method getValueDomain

getValueDomain: (nodes: any) => any[];

method ngOnChanges

ngOnChanges: () => void;

method onClick

onClick: (data: any) => void;

method setColors

setColors: () => void;

method truncateLabelsBasedOnAdjacentNodes

truncateLabelsBasedOnAdjacentNodes: () => void;

Truncate labels to prevent overflow outside the chart

method update

update: () => void;

class SankeyModule

class SankeyModule {}

property ɵfac

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

property ɵinj

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

property ɵmod

static ɵmod: i0.ɵɵNgModuleDeclaration<
    SankeyModule,
    [typeof SankeyComponent],
    [typeof ChartCommonModule],
    [typeof SankeyComponent]
>;

class ScaleLegendComponent

class ScaleLegendComponent implements OnChanges {}

property colors

colors: any;

property gradient

gradient: string;

property height

height: number;

property horizontal

horizontal: boolean;

property ɵcmp

static ɵcmp: i0.ɵɵComponentDeclaration<
    ScaleLegendComponent,
    'ngx-charts-scale-legend',
    never,
    {
        valueRange: { alias: 'valueRange'; required: false };
        colors: { alias: 'colors'; required: false };
        height: { alias: 'height'; required: false };
        width: { alias: 'width'; required: false };
        horizontal: { alias: 'horizontal'; required: false };
    },
    {},
    never,
    never,
    false,
    never
>;

property ɵfac

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

property valueRange

valueRange: number[];

property width

width: number;

method gradientString

gradientString: (colors: string[], splits: number[]) => string;

Generates the string used in the gradient stylesheet properties
Parameter colors
array of colors
Parameter splits
array of splits on a scale of (0, 1)

method ngOnChanges

ngOnChanges: (changes: SimpleChanges) => void;

class SeriesHorizontal

class SeriesHorizontal implements OnChanges, OnInit {}

constructor

constructor(platformId: any);

property activate

activate: EventEmitter<any>;

property activeEntries

activeEntries: DataItem[];

property animations

animations: boolean;

property barOrientation

barOrientation: typeof BarOrientation;

property bars

bars: Bar[];

property barsForDataLabels

barsForDataLabels: {
    x: number;
    y: number;
    width: number;
    height: number;
    total: number;
    series: string;
}[];

property colors

colors: ColorHelper;

property dataLabelFormatting

dataLabelFormatting: any;

property dataLabelWidthChanged

dataLabelWidthChanged: EventEmitter<{ size: Event; index: number }>;

property deactivate

deactivate: EventEmitter<any>;

property dims

dims: ViewDimensions;

property gradient

gradient: boolean;

property isSSR

isSSR: boolean;

property noBarWhenZero

noBarWhenZero: boolean;

property ɵcmp

static ɵcmp: i0.ɵɵComponentDeclaration<
    SeriesHorizontal,
    'g[ngx-charts-series-horizontal]',
    never,
    {
        dims: { alias: 'dims'; required: false };
        type: { alias: 'type'; required: false };
        series: { alias: 'series'; required: false };
        xScale: { alias: 'xScale'; required: false };
        yScale: { alias: 'yScale'; required: false };
        colors: { alias: 'colors'; required: false };
        tooltipDisabled: { alias: 'tooltipDisabled'; required: false };
        gradient: { alias: 'gradient'; required: false };
        activeEntries: { alias: 'activeEntries'; required: false };
        seriesName: { alias: 'seriesName'; required: false };
        tooltipTemplate: { alias: 'tooltipTemplate'; required: false };
        roundEdges: { alias: 'roundEdges'; required: false };
        animations: { alias: 'animations'; required: false };
        showDataLabel: { alias: 'showDataLabel'; required: false };
        dataLabelFormatting: { alias: 'dataLabelFormatting'; required: false };
        noBarWhenZero: { alias: 'noBarWhenZero'; required: false };
    },
    {
        select: 'select';
        activate: 'activate';
        deactivate: 'deactivate';
        dataLabelWidthChanged: 'dataLabelWidthChanged';
    },
    never,
    never,
    false,
    never
>;

property ɵfac

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

property roundEdges

roundEdges: boolean;

property select

select: EventEmitter<DataItem>;

property series

series: DataItem[];

property seriesName

seriesName: StringOrNumberOrDate;

property showDataLabel

showDataLabel: boolean;

property tooltipDisabled

tooltipDisabled: boolean;

property tooltipPlacement

tooltipPlacement: PlacementTypes;

property tooltipTemplate

tooltipTemplate: TemplateRef<any>;

property tooltipType

tooltipType: StyleTypes;

property type

type: BarChartType;

property xScale

xScale: any;

property yScale

yScale: any;

method click

click: (data: DataItem) => void;

method getLabel

getLabel: (dataItem: DataItem) => StringOrNumberOrDate;

method isActive

isActive: (entry: DataItem) => boolean;

method ngOnChanges

ngOnChanges: () => void;

method ngOnInit

ngOnInit: () => void;

method trackBy

trackBy: (index: number, bar: Bar) => string;

method trackDataLabelBy

trackDataLabelBy: (index: number, barLabel: any) => string;

method update

update: () => void;

method updateDataLabels

updateDataLabels: () => void;

method updateTooltipSettings

updateTooltipSettings: () => void;

class SeriesVerticalComponent

class SeriesVerticalComponent implements OnChanges {}

constructor

constructor(platformId: any);

property activate

activate: EventEmitter<any>;

property activeEntries

activeEntries: DataItem[];

property animations

animations: boolean;

property barOrientation

barOrientation: typeof BarOrientation;

property bars

bars: Bar[];

property barsForDataLabels

barsForDataLabels: {
    x: number;
    y: number;
    width: number;
    height: number;
    total: number;
    series: string;
}[];

property colors

colors: ColorHelper;

property dataLabelFormatting

dataLabelFormatting: any;

property dataLabelHeightChanged

dataLabelHeightChanged: EventEmitter<any>;

property deactivate

deactivate: EventEmitter<any>;

property dims

dims: ViewDimensions;

property gradient

gradient: boolean;

property isSSR

isSSR: boolean;

property noBarWhenZero

noBarWhenZero: boolean;

property ɵcmp

static ɵcmp: i0.ɵɵComponentDeclaration<
    SeriesVerticalComponent,
    'g[ngx-charts-series-vertical]',
    never,
    {
        dims: { alias: 'dims'; required: false };
        type: { alias: 'type'; required: false };
        series: { alias: 'series'; required: false };
        xScale: { alias: 'xScale'; required: false };
        yScale: { alias: 'yScale'; required: false };
        colors: { alias: 'colors'; required: false };
        gradient: { alias: 'gradient'; required: false };
        activeEntries: { alias: 'activeEntries'; required: false };
        seriesName: { alias: 'seriesName'; required: false };
        tooltipDisabled: { alias: 'tooltipDisabled'; required: false };
        tooltipTemplate: { alias: 'tooltipTemplate'; required: false };
        roundEdges: { alias: 'roundEdges'; required: false };
        animations: { alias: 'animations'; required: false };
        showDataLabel: { alias: 'showDataLabel'; required: false };
        dataLabelFormatting: { alias: 'dataLabelFormatting'; required: false };
        noBarWhenZero: { alias: 'noBarWhenZero'; required: false };
    },
    {
        select: 'select';
        activate: 'activate';
        deactivate: 'deactivate';
        dataLabelHeightChanged: 'dataLabelHeightChanged';
    },
    never,
    never,
    false,
    never
>;

property ɵfac

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

property roundEdges

roundEdges: boolean;

property select

select: EventEmitter<DataItem>;

property series

series: DataItem[];

property seriesName

seriesName: StringOrNumberOrDate;

property showDataLabel

showDataLabel: boolean;

property tooltipDisabled

tooltipDisabled: boolean;

property tooltipPlacement

tooltipPlacement: PlacementTypes;

property tooltipTemplate

tooltipTemplate: TemplateRef<any>;

property tooltipType

tooltipType: StyleTypes;

property type

type: BarChartType;

property xScale

xScale: any;

property yScale

yScale: any;

method getLabel

getLabel: (dataItem: DataItem) => StringOrNumberOrDate;

method isActive

isActive: (entry: DataItem) => boolean;

method ngOnChanges

ngOnChanges: () => void;

method ngOnInit

ngOnInit: () => void;

method onClick

onClick: (data: DataItem) => void;

method trackBy

trackBy: (index: number, bar: Bar) => string;

method trackDataLabelBy

trackDataLabelBy: (index: number, barLabel: any) => string;

method update

update: () => void;

method updateDataLabels

updateDataLabels: () => void;

method updateTooltipSettings

updateTooltipSettings: () => void;

class SvgLinearGradientComponent

class SvgLinearGradientComponent implements OnChanges {}

property name

name: string;

property orientation

orientation: BarOrientation;

property ɵcmp

static ɵcmp: i0.ɵɵComponentDeclaration<
    SvgLinearGradientComponent,
    'g[ngx-charts-svg-linear-gradient]',
    never,
    {
        orientation: { alias: 'orientation'; required: false };
        name: { alias: 'name'; required: false };
        stops: { alias: 'stops'; required: false };
    },
    {},
    never,
    never,
    false,
    never
>;

property ɵfac

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

property stops

stops: Gradient[];

property x1

x1: string;

property x2

x2: string;

property y1

y1: string;

property y2

y2: string;

method ngOnChanges

ngOnChanges: (changes: SimpleChanges) => void;

class SvgRadialGradientComponent

class SvgRadialGradientComponent implements OnChanges {}

property color

color: string;

property cx

cx: number;

property cy

cy: number;

property endOpacity

endOpacity: number;

property name

name: string;

property ɵcmp

static ɵcmp: i0.ɵɵComponentDeclaration<
    SvgRadialGradientComponent,
    'g[ngx-charts-svg-radial-gradient]',
    never,
    {
        color: { alias: 'color'; required: false };
        name: { alias: 'name'; required: false };
        startOpacity: { alias: 'startOpacity'; required: false };
        endOpacity: { alias: 'endOpacity'; required: false };
        cx: { alias: 'cx'; required: false };
        cy: { alias: 'cy'; required: false };
        stops: { alias: 'stops'; required: false };
    },
    {},
    never,
    never,
    false,
    never
>;

property ɵfac

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

property r

r: string;

property startOpacity

startOpacity: number;

property stops

stops: Gradient[];

method ngOnChanges

ngOnChanges: (changes: SimpleChanges) => void;

class Timeline

class Timeline implements OnChanges {}

constructor

constructor(element: ElementRef, cd: ChangeDetectorRef);

property autoScale

autoScale: boolean;

property brush

brush: any;

property customColors

customColors: any;

property dims

dims: ViewDimensions;

property element

element: HTMLElement;

property filter

filter: string;

property filterId

filterId: string;

property height

height: number;

property initialized

initialized: boolean;

property legend

legend: boolean;

property onDomainChange

onDomainChange: EventEmitter<any>;

property ɵcmp

static ɵcmp: i0.ɵɵComponentDeclaration<
    Timeline,
    'g[ngx-charts-timeline]',
    never,
    {
        view: { alias: 'view'; required: false };
        results: { alias: 'results'; required: false };
        scheme: { alias: 'scheme'; required: false };
        customColors: { alias: 'customColors'; required: false };
        legend: { alias: 'legend'; required: false };
        autoScale: { alias: 'autoScale'; required: false };
        scaleType: { alias: 'scaleType'; required: false };
        height: { alias: 'height'; required: false };
    },
    { select: 'select'; onDomainChange: 'onDomainChange' },
    never,
    ['*'],
    false,
    never
>;

property ɵfac

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

property results

results: any;

property scaleType

scaleType: ScaleType;

property scheme

scheme: any;

property select

select: EventEmitter<any>;

property transform

transform: string;

property view

view: [number, number];

property xDomain

xDomain: any[];

property xScale

xScale: any;

method addBrush

addBrush: () => void;

method getDims

getDims: () => ViewDimensions;

method getXDomain

getXDomain: () => any[];

method getXScale

getXScale: () => any;

method ngOnChanges

ngOnChanges: (changes: SimpleChanges) => void;

method update

update: () => void;

method updateBrush

updateBrush: () => void;

class TooltipArea

class TooltipArea implements OnInit {}

constructor

constructor(platformId: any);

property anchorOpacity

anchorOpacity: number;

property anchorPos

anchorPos: number;

property anchorValues

anchorValues: Tooltip[];

property colors

colors: ColorHelper;

property dims

dims: ViewDimensions;

property hover

hover: EventEmitter<{ value: any }>;

property isSSR

isSSR: boolean;

property lastAnchorPos

lastAnchorPos: number;

property ɵcmp

static ɵcmp: i0.ɵɵComponentDeclaration<
    TooltipArea,
    'g[ngx-charts-tooltip-area]',
    never,
    {
        dims: { alias: 'dims'; required: false };
        xSet: { alias: 'xSet'; required: false };
        xScale: { alias: 'xScale'; required: false };
        yScale: { alias: 'yScale'; required: false };
        results: { alias: 'results'; required: false };
        colors: { alias: 'colors'; required: false };
        showPercentage: { alias: 'showPercentage'; required: false };
        tooltipDisabled: { alias: 'tooltipDisabled'; required: false };
        tooltipTemplate: { alias: 'tooltipTemplate'; required: false };
    },
    { hover: 'hover' },
    never,
    never,
    false,
    never
>;

property ɵfac

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

property placementTypes

placementTypes: typeof PlacementTypes;

property results

results: any[];

property showPercentage

showPercentage: boolean;

property styleTypes

styleTypes: typeof StyleTypes;

property tooltipAnchor

tooltipAnchor: any;

property tooltipDisabled

tooltipDisabled: boolean;

property tooltipTemplate

tooltipTemplate: TemplateRef<any>;

property xScale

xScale: any;

property xSet

xSet: any[];

property yScale

yScale: any;

method findClosestPointIndex

findClosestPointIndex: (xPos: number) => number;

method getToolTipText

getToolTipText: (tooltipItem: Tooltip) => string;

method getValues

getValues: (xVal: any) => Tooltip[];

method hideTooltip

hideTooltip: () => void;

method mouseMove

mouseMove: (event: any) => void;

method ngOnInit

ngOnInit: () => void;

method showTooltip

showTooltip: () => void;

class TooltipContentComponent

class TooltipContentComponent implements AfterViewInit {}

constructor

constructor(element: ElementRef, renderer: Renderer2, platformId: any);

property alignment

alignment: PlacementTypes;

property caretElm

caretElm: ElementRef;

property context

context: any;

property cssClass

cssClass: string;

property cssClasses

readonly cssClasses: string;

property element

element: ElementRef;

property host

host: ElementRef;

property ɵcmp

static ɵcmp: i0.ɵɵComponentDeclaration<
    TooltipContentComponent,
    'ngx-tooltip-content',
    never,
    {
        host: { alias: 'host'; required: false };
        showCaret: { alias: 'showCaret'; required: false };
        type: { alias: 'type'; required: false };
        placement: { alias: 'placement'; required: false };
        alignment: { alias: 'alignment'; required: false };
        spacing: { alias: 'spacing'; required: false };
        cssClass: { alias: 'cssClass'; required: false };
        title: { alias: 'title'; required: false };
        template: { alias: 'template'; required: false };
        context: { alias: 'context'; required: false };
    },
    {},
    never,
    never,
    false,
    never
>;

property ɵfac

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

property placement

placement: PlacementTypes;

property showCaret

showCaret: boolean;

property spacing

spacing: number;

property template

template: TemplateRef<any>;

property title

title: string;

property type

type: StyleTypes;

method checkFlip

checkFlip: (hostDim: DOMRect, elmDim: DOMRect) => void;

method ngAfterViewInit

ngAfterViewInit: () => void;

method onWindowResize

onWindowResize: () => void;

method position

position: () => void;

method positionCaret

positionCaret: (hostDim: DOMRect, elmDim: DOMRect) => void;

method positionContent

positionContent: (
    nativeElm: HTMLElement,
    hostDim: DOMRect,
    elmDim: DOMRect
) => void;

class TooltipDirective

class TooltipDirective implements OnDestroy {}

constructor

constructor(
    tooltipService: TooltipService,
    viewContainerRef: ViewContainerRef,
    renderer: Renderer2
);

property hide

hide: EventEmitter<boolean>;

property ɵdir

static ɵdir: i0.ɵɵDirectiveDeclaration<
    TooltipDirective,
    '[ngx-tooltip]',
    never,
    {
        tooltipCssClass: { alias: 'tooltipCssClass'; required: false };
        tooltipTitle: { alias: 'tooltipTitle'; required: false };
        tooltipAppendToBody: { alias: 'tooltipAppendToBody'; required: false };
        tooltipSpacing: { alias: 'tooltipSpacing'; required: false };
        tooltipDisabled: { alias: 'tooltipDisabled'; required: false };
        tooltipShowCaret: { alias: 'tooltipShowCaret'; required: false };
        tooltipPlacement: { alias: 'tooltipPlacement'; required: false };
        tooltipAlignment: { alias: 'tooltipAlignment'; required: false };
        tooltipType: { alias: 'tooltipType'; required: false };
        tooltipCloseOnClickOutside: {
            alias: 'tooltipCloseOnClickOutside';
            required: false;
        };
        tooltipCloseOnMouseLeave: {
            alias: 'tooltipCloseOnMouseLeave';
            required: false;
        };
        tooltipHideTimeout: { alias: 'tooltipHideTimeout'; required: false };
        tooltipShowTimeout: { alias: 'tooltipShowTimeout'; required: false };
        tooltipTemplate: { alias: 'tooltipTemplate'; required: false };
        tooltipShowEvent: { alias: 'tooltipShowEvent'; required: false };
        tooltipContext: { alias: 'tooltipContext'; required: false };
        tooltipImmediateExit: { alias: 'tooltipImmediateExit'; required: false };
    },
    { show: 'show'; hide: 'hide' },
    never,
    never,
    false,
    never
>;

property ɵfac

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

property show

show: EventEmitter<boolean>;

property tooltipAlignment

tooltipAlignment: PlacementTypes;

property tooltipAppendToBody

tooltipAppendToBody: boolean;

property tooltipCloseOnClickOutside

tooltipCloseOnClickOutside: boolean;

property tooltipCloseOnMouseLeave

tooltipCloseOnMouseLeave: boolean;

property tooltipContext

tooltipContext: any;

property tooltipCssClass

tooltipCssClass: string;

property tooltipDisabled

tooltipDisabled: boolean;

property tooltipHideTimeout

tooltipHideTimeout: number;

property tooltipImmediateExit

tooltipImmediateExit: boolean;

property tooltipPlacement

tooltipPlacement: PlacementTypes;

property tooltipShowCaret

tooltipShowCaret: boolean;

property tooltipShowEvent

tooltipShowEvent: number;

property tooltipShowTimeout

tooltipShowTimeout: number;

property tooltipSpacing

tooltipSpacing: number;

property tooltipTemplate

tooltipTemplate: TemplateRef<any>;

property tooltipTitle

tooltipTitle?: string;

property tooltipType

tooltipType: StyleTypes;

method addHideListeners

addHideListeners: (tooltip: HTMLElement) => void;

method hideTooltip

hideTooltip: (immediate?: boolean) => void;

method ngOnDestroy

ngOnDestroy: () => void;

method onBlur

onBlur: () => void;

method onFocus

onFocus: () => void;

method onMouseClick

onMouseClick: () => void;

method onMouseEnter

onMouseEnter: () => void;

method onMouseLeave

onMouseLeave: (target: any) => void;

method showTooltip

showTooltip: (immediate?: boolean) => void;

class TooltipModule

class TooltipModule {}

property ɵfac

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

property ɵinj

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

property ɵmod

static ɵmod: i0.ɵɵNgModuleDeclaration<
    TooltipModule,
    [typeof TooltipContentComponent, typeof TooltipDirective],
    [any],
    [typeof TooltipContentComponent, typeof TooltipDirective]
>;

class TooltipService

class TooltipService extends InjectionRegisteryService<TooltipContentComponent> {}

constructor

constructor(injectionService: InjectionService);

property ɵfac

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

property ɵprov

static ɵprov: i0.ɵɵInjectableDeclaration<TooltipService>;

property type

type: any;

class TreeMapCellComponent

class TreeMapCellComponent implements OnChanges {}

constructor

constructor(element: ElementRef);

property animations

animations: boolean;

property data

data: DataItem;

property element

element: HTMLElement;

property fill

fill: string;

property formattedLabel

formattedLabel: string;

property formattedValue

formattedValue: string;

property gradient

gradient: boolean;

property gradientId

gradientId: string;

property gradientStops

gradientStops: Gradient[];

property gradientUrl

gradientUrl: string;

property height

height: number;

property initialized

initialized: boolean;

property label

label: string;

property labelFormatting

labelFormatting: any;

property orientation

orientation: typeof BarOrientation;

property ɵcmp

static ɵcmp: i0.ɵɵComponentDeclaration<
    TreeMapCellComponent,
    'g[ngx-charts-tree-map-cell]',
    never,
    {
        data: { alias: 'data'; required: false };
        fill: { alias: 'fill'; required: false };
        x: { alias: 'x'; required: false };
        y: { alias: 'y'; required: false };
        width: { alias: 'width'; required: false };
        height: { alias: 'height'; required: false };
        label: { alias: 'label'; required: false };
        value: { alias: 'value'; required: false };
        valueFormatting: { alias: 'valueFormatting'; required: false };
        labelFormatting: { alias: 'labelFormatting'; required: false };
        gradient: { alias: 'gradient'; required: false };
        animations: { alias: 'animations'; required: false };
    },
    { select: 'select' },
    never,
    never,
    false,
    never
>;

property ɵfac

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

property select

select: EventEmitter<any>;

property transform

transform: string;

property value

value: any;

property valueFormatting

valueFormatting: any;

property width

width: number;

property x

x: number;

property y

y: number;

method animateToCurrentForm

animateToCurrentForm: () => void;

method getGradientStops

getGradientStops: () => Gradient[];

method getTextColor

getTextColor: () => string;

method loadAnimation

loadAnimation: () => void;

method ngOnChanges

ngOnChanges: () => void;

method onClick

onClick: () => void;

method update

update: () => void;

class TreeMapCellSeriesComponent

class TreeMapCellSeriesComponent implements OnChanges {}

property animations

animations: boolean;

property cells

cells: TreeMapCell[];

property colors

colors: ColorHelper;

property data

data: any;

property dims

dims: ViewDimensions;

property gradient

gradient: boolean;

property labelFormatting

labelFormatting: any;

property ɵcmp

static ɵcmp: i0.ɵɵComponentDeclaration<
    TreeMapCellSeriesComponent,
    'g[ngx-charts-tree-map-cell-series]',
    never,
    {
        data: { alias: 'data'; required: false };
        dims: { alias: 'dims'; required: false };
        colors: { alias: 'colors'; required: false };
        valueFormatting: { alias: 'valueFormatting'; required: false };
        labelFormatting: { alias: 'labelFormatting'; required: false };
        gradient: { alias: 'gradient'; required: false };
        tooltipDisabled: { alias: 'tooltipDisabled'; required: false };
        tooltipTemplate: { alias: 'tooltipTemplate'; required: false };
        animations: { alias: 'animations'; required: false };
    },
    { select: 'select' },
    never,
    never,
    false,
    never
>;

property ɵfac

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

property placementTypes

placementTypes: typeof PlacementTypes;

property select

select: EventEmitter<any>;

property styleTypes

styleTypes: typeof StyleTypes;

property tooltipDisabled

tooltipDisabled: boolean;

property tooltipTemplate

tooltipTemplate: TemplateRef<any>;

property valueFormatting

valueFormatting: any;

method getCells

getCells: () => TreeMapCell[];

method getTooltipText

getTooltipText: ({ label, value }: { label: any; value: any }) => string;

method ngOnChanges

ngOnChanges: (changes: SimpleChanges) => void;

method onClick

onClick: (data: any) => void;

method trackBy

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

class TreeMapComponent

class TreeMapComponent extends BaseChartComponent {}

property colors

colors: ColorHelper;

property data

data: DataItem;

property dims

dims: ViewDimensions;

property domain

domain: any;

property gradient

gradient: boolean;

property labelFormatting

labelFormatting: any;

property margin

margin: number[];

property ɵcmp

static ɵcmp: i0.ɵɵComponentDeclaration<
    TreeMapComponent,
    'ngx-charts-tree-map',
    never,
    {
        results: { alias: 'results'; required: false };
        tooltipDisabled: { alias: 'tooltipDisabled'; required: false };
        valueFormatting: { alias: 'valueFormatting'; required: false };
        labelFormatting: { alias: 'labelFormatting'; required: false };
        gradient: { alias: 'gradient'; required: false };
    },
    { select: 'select' },
    ['tooltipTemplate'],
    never,
    false,
    never
>;

property ɵfac

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

property results

results: DataItem[];

property select

select: EventEmitter<any>;

property tooltipDisabled

tooltipDisabled: boolean;

property tooltipTemplate

tooltipTemplate: TemplateRef<any>;

property transform

transform: any;

property treemap

treemap: any;

property valueFormatting

valueFormatting: any;

method getDomain

getDomain: () => any[];

method ngOnChanges

ngOnChanges: () => void;

method onClick

onClick: (data: DataItem) => void;

method setColors

setColors: () => void;

method update

update: () => void;

class TreeMapModule

class TreeMapModule {}

property ɵfac

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

property ɵinj

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

property ɵmod

static ɵmod: i0.ɵɵNgModuleDeclaration<
    TreeMapModule,
    [
        typeof TreeMapCellComponent,
        typeof TreeMapCellSeriesComponent,
        typeof TreeMapComponent
    ],
    [typeof ChartCommonModule],
    [
        typeof TreeMapCellComponent,
        typeof TreeMapCellSeriesComponent,
        typeof TreeMapComponent
    ]
>;

class VisibilityObserver

class VisibilityObserver {}

Visibility Observer

constructor

constructor(element: ElementRef, zone: NgZone);

property isVisible

isVisible: boolean;

property ɵdir

static ɵdir: i0.ɵɵDirectiveDeclaration<
    VisibilityObserver,
    'visibility-observer',
    never,
    {},
    { visible: 'visible' },
    never,
    never,
    false,
    never
>;

property ɵfac

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

property timeout

timeout: any;

property visible

visible: EventEmitter<any>;

method destroy

destroy: () => void;

method onVisibilityChange

onVisibilityChange: () => void;

method runCheck

runCheck: () => void;

class XAxisComponent

class XAxisComponent implements OnChanges {}

property dimensionsChanged

dimensionsChanged: EventEmitter<any>;

property dims

dims: ViewDimensions;

property fill

fill: string;

property labelOffset

labelOffset: number;

property labelText

labelText: string;

property maxTickLength

maxTickLength: number;

property orientation

readonly orientation: typeof Orientation;

property ɵcmp

static ɵcmp: i0.ɵɵComponentDeclaration<
    XAxisComponent,
    'g[ngx-charts-x-axis]',
    never,
    {
        xScale: { alias: 'xScale'; required: false };
        dims: { alias: 'dims'; required: false };
        trimTicks: { alias: 'trimTicks'; required: false };
        rotateTicks: { alias: 'rotateTicks'; required: false };
        maxTickLength: { alias: 'maxTickLength'; required: false };
        tickFormatting: { alias: 'tickFormatting'; required: false };
        showGridLines: { alias: 'showGridLines'; required: false };
        showLabel: { alias: 'showLabel'; required: false };
        labelText: { alias: 'labelText'; required: false };
        ticks: { alias: 'ticks'; required: false };
        xAxisTickCount: { alias: 'xAxisTickCount'; required: false };
        xOrient: { alias: 'xOrient'; required: false };
        referenceLines: { alias: 'referenceLines'; required: false };
        showRefLines: { alias: 'showRefLines'; required: false };
        showRefLabels: { alias: 'showRefLabels'; required: false };
        xAxisOffset: { alias: 'xAxisOffset'; required: false };
        wrapTicks: { alias: 'wrapTicks'; required: false };
    },
    { dimensionsChanged: 'dimensionsChanged' },
    never,
    never,
    false,
    never
>;

property ɵfac

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

property padding

padding: number;

property referenceLines

referenceLines: any[];

property rotateTicks

rotateTicks: boolean;

property showGridLines

showGridLines: boolean;

property showLabel

showLabel: boolean;

property showRefLabels

showRefLabels: boolean;

property showRefLines

showRefLines: boolean;

property stroke

stroke: string;

property strokeWidth

strokeWidth: string;

property tickArguments

tickArguments: number[];

property tickFormatting

tickFormatting: any;

property ticks

ticks: any[];

property ticksComponent

ticksComponent: XAxisTicksComponent;

property tickStroke

tickStroke: string;

property transform

transform: string;

property trimTicks

trimTicks: boolean;

property wrapTicks

wrapTicks: boolean;

property xAxisClassName

xAxisClassName: string;

property xAxisOffset

xAxisOffset: number;

property xAxisTickCount

xAxisTickCount: number;

property xOrient

xOrient: Orientation;

property xScale

xScale: any;

method emitTicksHeight

emitTicksHeight: ({ height }: { height: any }) => void;

method ngOnChanges

ngOnChanges: (changes: SimpleChanges) => void;

method update

update: () => void;

class XAxisTicksComponent

class XAxisTicksComponent implements OnChanges, AfterViewInit {}

constructor

constructor(platformId: any);

property adjustedScale

adjustedScale: any;

property approxHeight

approxHeight: number;

property dimensionsChanged

dimensionsChanged: EventEmitter<any>;

property dx

dx: string;

property gridLineHeight

gridLineHeight: number;

property height

height: number;

property innerTickSize

innerTickSize: number;

property isWrapTicksSupported

readonly isWrapTicksSupported: any;

property maxAllowedLength

maxAllowedLength: number;

property maxPossibleLengthForTickIfWrapped

maxPossibleLengthForTickIfWrapped: number;

property maxTickLength

maxTickLength: number;

property maxTicksLength

maxTicksLength: number;

property orient

orient: Orientation;

property outerTickSize

outerTickSize: number;

property ɵcmp

static ɵcmp: i0.ɵɵComponentDeclaration<
    XAxisTicksComponent,
    'g[ngx-charts-x-axis-ticks]',
    never,
    {
        scale: { alias: 'scale'; required: false };
        orient: { alias: 'orient'; required: false };
        tickArguments: { alias: 'tickArguments'; required: false };
        tickValues: { alias: 'tickValues'; required: false };
        tickStroke: { alias: 'tickStroke'; required: false };
        trimTicks: { alias: 'trimTicks'; required: false };
        maxTickLength: { alias: 'maxTickLength'; required: false };
        tickFormatting: { alias: 'tickFormatting'; required: false };
        showGridLines: { alias: 'showGridLines'; required: false };
        gridLineHeight: { alias: 'gridLineHeight'; required: false };
        width: { alias: 'width'; required: false };
        rotateTicks: { alias: 'rotateTicks'; required: false };
        wrapTicks: { alias: 'wrapTicks'; required: false };
        referenceLines: { alias: 'referenceLines'; required: false };
        showRefLabels: { alias: 'showRefLabels'; required: false };
        showRefLines: { alias: 'showRefLines'; required: false };
    },
    { dimensionsChanged: 'dimensionsChanged' },
    never,
    never,
    false,
    never
>;

property ɵfac

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

property referenceAreaPath

referenceAreaPath: string;

property referenceLineLength

referenceLineLength: number;

property referenceLines

referenceLines: any[];

property refMax

refMax: number;

property refMin

refMin: number;

property rotateLabels

rotateLabels: boolean;

property rotateTicks

rotateTicks: boolean;

property scale

scale: any;

property showGridLines

showGridLines: boolean;

property showRefLabels

showRefLabels: boolean;

property showRefLines

showRefLines: boolean;

property ssrHeight

ssrHeight: number;

property textAnchor

textAnchor: TextAnchor;

property textTransform

textTransform: string;

property tickArguments

tickArguments: number[];

property tickFormat

tickFormat: (o: any) => any;

property tickFormatting

tickFormatting: any;

property tickPadding

tickPadding: number;

property ticks

ticks: any[];

property ticksElement

ticksElement: ElementRef;

property tickSpacing

tickSpacing: number;

property tickStroke

tickStroke: string;

property tickValues

tickValues: string[] | number[];

property transform

transform: (o: any) => string;

property trimTicks

trimTicks: boolean;

property verticalSpacing

verticalSpacing: number;

property width

width: number;

property wrapTicks

wrapTicks: boolean;

property x1

x1: number;

property x2

x2: number;

property y1

y1: number;

property y2

y2: number;

method approximateTicksHeight

static approximateTicksHeight: (options: XAxisTicksEstimateOptions) => number;

Tick label height without DOM measurement. SSR serializes before the deferred dimensionsChanged emission is applied, so charts seed their x-axis height from this during update().

method getMaxPossibleLengthForTick

getMaxPossibleLengthForTick: (longestLabel: string) => number;

method getMaxTicks

getMaxTicks: (tickWidth: number) => number;

method getRotationAngle

getRotationAngle: (ticks: any[]) => number;

method getSsrHeight

getSsrHeight: (angle: number | null) => number;

Estimated rendered height of the tick labels, matching what getBoundingClientRect reports in the browser: the rotated text run plus the projected glyph height, or the wrapped line stack.

method getTicks

getTicks: () => any[];

method gridLineTransform

gridLineTransform: () => string;

method ngAfterViewInit

ngAfterViewInit: () => void;

method ngOnChanges

ngOnChanges: (changes: SimpleChanges) => void;

method setReferencelines

setReferencelines: () => void;

method tickChunks

tickChunks: (label: string) => string[];

method tickTransform

tickTransform: (tick: number) => string;

method tickTrim

tickTrim: (label: string) => string;

method update

update: () => void;

method updateDims

updateDims: () => void;

class YAxisComponent

class YAxisComponent implements OnChanges {}

property dimensionsChanged

dimensionsChanged: EventEmitter<any>;

property dims

dims: ViewDimensions;

property fill

fill: string;

property labelOffset

labelOffset: number;

property labelText

labelText: string;

property maxTickLength

maxTickLength: number;

property offset

offset: number;

property ɵcmp

static ɵcmp: i0.ɵɵComponentDeclaration<
    YAxisComponent,
    'g[ngx-charts-y-axis]',
    never,
    {
        yScale: { alias: 'yScale'; required: false };
        dims: { alias: 'dims'; required: false };
        trimTicks: { alias: 'trimTicks'; required: false };
        maxTickLength: { alias: 'maxTickLength'; required: false };
        tickFormatting: { alias: 'tickFormatting'; required: false };
        ticks: { alias: 'ticks'; required: false };
        showGridLines: { alias: 'showGridLines'; required: false };
        showLabel: { alias: 'showLabel'; required: false };
        labelText: { alias: 'labelText'; required: false };
        yAxisTickCount: { alias: 'yAxisTickCount'; required: false };
        yOrient: { alias: 'yOrient'; required: false };
        referenceLines: { alias: 'referenceLines'; required: false };
        showRefLines: { alias: 'showRefLines'; required: false };
        showRefLabels: { alias: 'showRefLabels'; required: false };
        yAxisOffset: { alias: 'yAxisOffset'; required: false };
        wrapTicks: { alias: 'wrapTicks'; required: false };
    },
    { dimensionsChanged: 'dimensionsChanged' },
    never,
    never,
    false,
    never
>;

property ɵfac

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

property padding

padding: number;

property referenceLines

referenceLines: any;

property showGridLines

showGridLines: boolean;

property showLabel

showLabel: boolean;

property showRefLabels

showRefLabels: boolean;

property showRefLines

showRefLines: boolean;

property stroke

stroke: string;

property strokeWidth

strokeWidth: number;

property tickArguments

tickArguments: number[];

property tickFormatting

tickFormatting: any;

property ticks

ticks: any[];

property ticksComponent

ticksComponent: YAxisTicksComponent;

property tickStroke

tickStroke: string;

property transform

transform: string;

property trimTicks

trimTicks: boolean;

property wrapTicks

wrapTicks: boolean;

property yAxisClassName

yAxisClassName: string;

property yAxisOffset

yAxisOffset: number;

property yAxisTickCount

yAxisTickCount: any;

property yOrient

yOrient: Orientation;

property yScale

yScale: any;

method emitTicksWidth

emitTicksWidth: ({ width }: { width: any }) => void;

method ngOnChanges

ngOnChanges: (changes: SimpleChanges) => void;

method update

update: () => void;

class YAxisTicksComponent

class YAxisTicksComponent implements OnChanges, AfterViewInit {}

constructor

constructor(platformId: any);

property adjustedScale

adjustedScale: any;

property APPROX_CHAR_WIDTH

static readonly APPROX_CHAR_WIDTH: number;

property AXIS_LAYOUT_INSET

static readonly AXIS_LAYOUT_INSET: number;

property dimensionsChanged

dimensionsChanged: EventEmitter<any>;

property dy

dy: string;

property gridLineWidth

gridLineWidth: number;

property height

height: number;

property INNER_TICK_SIZE

static readonly INNER_TICK_SIZE: number;

property innerTickSize

innerTickSize: number;

property maxTickLength

maxTickLength: number;

property orient

orient: Orientation;

property Orientation

readonly Orientation: typeof Orientation;

property outerTickSize

outerTickSize: number;

property ɵcmp

static ɵcmp: i0.ɵɵComponentDeclaration<
    YAxisTicksComponent,
    'g[ngx-charts-y-axis-ticks]',
    never,
    {
        scale: { alias: 'scale'; required: false };
        orient: { alias: 'orient'; required: false };
        tickArguments: { alias: 'tickArguments'; required: false };
        tickValues: { alias: 'tickValues'; required: false };
        tickStroke: { alias: 'tickStroke'; required: false };
        trimTicks: { alias: 'trimTicks'; required: false };
        maxTickLength: { alias: 'maxTickLength'; required: false };
        tickFormatting: { alias: 'tickFormatting'; required: false };
        showGridLines: { alias: 'showGridLines'; required: false };
        gridLineWidth: { alias: 'gridLineWidth'; required: false };
        height: { alias: 'height'; required: false };
        referenceLines: { alias: 'referenceLines'; required: false };
        showRefLabels: { alias: 'showRefLabels'; required: false };
        showRefLines: { alias: 'showRefLines'; required: false };
        wrapTicks: { alias: 'wrapTicks'; required: false };
    },
    { dimensionsChanged: 'dimensionsChanged' },
    never,
    never,
    false,
    never
>;

property ɵfac

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

property referenceAreaPath

referenceAreaPath: string;

property referenceLineLength

referenceLineLength: number;

property referenceLines

referenceLines: any;

property refMax

refMax: number;

property refMin

refMin: number;

property rotateLabels

rotateLabels: boolean;

property scale

scale: any;

property showGridLines

showGridLines: boolean;

property showRefLabels

showRefLabels: boolean;

property showRefLines

showRefLines: boolean;

property textAnchor

textAnchor: TextAnchor;

property TICK_PADDING

static readonly TICK_PADDING: number;

property tickArguments

tickArguments: number[];

property tickFormat

tickFormat: (o: any) => string;

property tickFormatting

tickFormatting: any;

property tickPadding

tickPadding: number;

property ticks

ticks: any[];

property ticksElement

ticksElement: ElementRef;

property tickSpacing

tickSpacing: number;

property tickStroke

tickStroke: string;

property tickValues

tickValues: string[] | number[];

property transform

transform: (o: any) => string;

property TRIM_CHAR_WIDTH

static readonly TRIM_CHAR_WIDTH: number;

property trimTicks

trimTicks: boolean;

property verticalSpacing

verticalSpacing: number;

property VIEW_DIMS_Y_AXIS_SPACER

static readonly VIEW_DIMS_Y_AXIS_SPACER: number;

property width

width: number;

property wrapTicks

wrapTicks: boolean;

property x1

x1: number;

property x2

x2: number;

property Y_AXIS_PADDING

static readonly Y_AXIS_PADDING: number;

property y1

y1: number;

property y2

y2: number;

method approximateTickLabelsWidth

static approximateTickLabelsWidth: (
    labels: string[],
    trimTicks?: boolean,
    maxTickLength?: number,
    wrapTicks?: boolean
) => number;

method approximateTicksWidth

static approximateTicksWidth: (options: YAxisTicksEstimateOptions) => number;

Tick label width without DOM measurement. SSR serializes before the tick component's dimensionsChanged emission is applied, so charts seed their y-axis width from this during update().

method effectiveMaxTickLength

static effectiveMaxTickLength: (
    yAxisWidth: number,
    maxTickLength: number,
    trimTicks?: boolean,
    label?: string
) => number;

method getApproximateAxisWidth

getApproximateAxisWidth: () => number;

method getMaxTicks

getMaxTicks: (tickHeight: number) => number;

method getTicks

getTicks: () => any[];

method gridLineTransform

gridLineTransform: () => string;

method labelLeftFromLayout

static labelLeftFromLayout: (
    marginsLeft: number,
    yAxisWidth: number,
    textWidth: number
) => number;

method ngAfterViewInit

ngAfterViewInit: () => void;

method ngOnChanges

ngOnChanges: (changes: SimpleChanges) => void;

method requiredYAxisWidth

static requiredYAxisWidth: (textWidth: number) => number;

method resolveAxisLayout

static resolveAxisLayout: (
    labels: string[],
    trimTicks?: boolean,
    maxTickLength?: number,
    wrapTicks?: boolean
) => { yAxisWidth: number; maxTickLength: number };

method setReferencelines

setReferencelines: () => void;

method tickChunks

tickChunks: (label: string) => string[];

method tickTransform

tickTransform: (tick: number) => string;

method tickTrim

tickTrim: (label: string) => string;

method update

update: () => void;

method updateDims

updateDims: () => void;

Interfaces

interface AdvancedLegendItem

interface AdvancedLegendItem {}

property color

color: string;

property data

data: DataItem;

property displayLabel

displayLabel: string;

property label

label: string;

property originalLabel

originalLabel: string;

property percentage

percentage: string;

property value

value: StringOrNumberOrDate;

interface ArcItem

interface ArcItem {}

property data

data: DataItem;

property endAngle

endAngle: number;

property innerRadius

innerRadius: number;

property outerRadius

outerRadius: number;

interface AreaChartDataItem

interface AreaChartDataItem extends DataItem {}

property d0

d0: number;

property d1

d1: number;

interface AreaChartSeries

interface AreaChartSeries {}

property name

name: StringOrNumberOrDate;

property series

series: AreaChartDataItem[];

interface Bar

interface Bar {}

property ariaLabel

ariaLabel: string;

property color

color: string;

property data

data: DataItem;

property formattedLabel

formattedLabel: string;

property gradientStops

gradientStops: Gradient[];

property height

height: number;

property label

label: string;

property roundEdges

roundEdges: boolean;

property tooltipText

tooltipText: string;

property value

value: number;

property width

width: number;

property x

x: number;

property y

y: number;

interface BoxChartMultiSeries

interface BoxChartMultiSeries extends Array<BoxChartSeries> {}

interface BoxChartSeries

interface BoxChartSeries {}

property name

name: StringOrNumberOrDate;

property series

series: DataItem[];

interface BubbleChartDataItem

interface BubbleChartDataItem {}

property extra

extra?: any;

property name

name: StringOrNumberOrDate;

property r

r: number;

property x

x: StringOrNumberOrDate;

property y

y: StringOrNumberOrDate;

interface BubbleChartMultiSeries

interface BubbleChartMultiSeries extends Array<BubbleChartSeries> {}

interface BubbleChartSeries

interface BubbleChartSeries {}

property name

name: StringOrNumberOrDate;

property series

series: BubbleChartDataItem[];

interface CardModel

interface CardModel extends GridItem {}

property bandColor

bandColor: string;

property color

color: string;

property label

label: string;

property textColor

textColor: string;

property tooltipText

tooltipText: string;

interface Circle

interface Circle {}

property classNames

classNames: string[];

property color

color: string;

property cx

cx: number;

property cy

cy: number;

property data

data: DataItem;

property gradientStops

gradientStops: Gradient[];

property height

height: number;

property label

label: string;

property max

max: number;

property min

min: number;

property opacity

opacity: number;

property radius

radius: number;

property seriesName

seriesName: string;

property tooltipLabel

tooltipLabel: string;

property value

value: string | number;

interface Color

interface Color {}

property domain

domain: string[];

property group

group: ScaleType;

property name

name: string;

property selectable

selectable: boolean;

interface DataItem

interface DataItem {}

property extra

extra?: any;

property label

label?: string;

property max

max?: number;

property min

min?: number;

property name

name: StringOrNumberOrDate;

property value

value: number;

interface Gradient

interface Gradient {}

property color

color: string;

property offset

offset: number;

property opacity

opacity: number;

property originalOffset

originalOffset?: number;

interface GridData

interface GridData {}

property extra

extra?: any;

property label

label: string;

property name

name: StringOrNumberOrDate;

property percent

percent: number;

property total

total: number;

property value

value: number;

interface GridItem

interface GridItem {}

property data

data: GridData;

property height

height: number;

property width

width: number;

property x

x: number;

property y

y: number;

interface IBoxModel

interface IBoxModel {}

property ariaLabel

ariaLabel?: string;

property color

color?: string;

property data

data: DataItem[];

property formattedLabel

formattedLabel: string;

property gradientStops

gradientStops?: Array<{
    offset: number;
    color: string;
    opacity: number;
}>;

property height

height: number;

property label

label: StringOrNumberOrDate;

property lineCoordinates

lineCoordinates: IVector2D[];

property quartiles

quartiles: number[];

property roundEdges

roundEdges: boolean;

property tooltipText

tooltipText?: string;

property value

value: number | Date;

property width

width: number;

property x

x: number;

property y

y: number;

interface LegendEntry

interface LegendEntry {}

property color

color: string;

property formattedLabel

formattedLabel: string;

property label

label: string;

interface LegendOptions

interface LegendOptions {}

property colors

colors: any;

property domain

domain: any[];

property position

position: LegendPosition;

property scaleType

scaleType: ScaleType;

property title

title: string;

interface MultiSeries

interface MultiSeries extends Array<Series> {}

interface PieArc

interface PieArc {}

property animate

animate: boolean;

property class

class: string;

property data

data: PieGridDataItem;

property endAngle

endAngle: number;

property fill

fill: string;

property pointerEvents

pointerEvents: boolean;

property startAngle

startAngle: number;

interface PieData

interface PieData extends DefaultArcObject {}

property data

data: DataItem;

property index

index: number;

property pos

pos: [number, number];

property value

value: number;

interface PieGridData

interface PieGridData {}

property data

data: PieGridDataItem;

property height

height: number;

property width

width: number;

property x

x: number;

property y

y: number;

interface PieGridDataItem

interface PieGridDataItem extends DataItem {}

property percent

percent: number;

property total

total: number;

property value

value: number;

interface SankeyData

interface SankeyData extends Array<SankeyObject> {}

interface SankeyObject

interface SankeyObject {}

property source

source: string;

property target

target: string;

property value

value: number;

interface Series

interface Series {}

property name

name: StringOrNumberOrDate;

property series

series: DataItem[];

interface SingleSeries

interface SingleSeries extends Array<DataItem> {}

interface Tooltip {}

property color

color: string;

property d0

d0: number;

property d1

d1: number;

property max

max: number;

property min

min: number;

property name

name: any;

property series

series: any;

property value

value: any;

interface TreeMapData

interface TreeMapData extends Array<TreeMapDataItem> {}

interface TreeMapDataItem

interface TreeMapDataItem {}

property children

children?: TreeMapDataItem[];

property extra

extra?: any;

property name

name: StringOrNumberOrDate;

property size

size?: number;

interface ViewDimensions

interface ViewDimensions {}

property height

height: number;

property width

width: number;

property xOffset

xOffset?: number;

property yOffset

yOffset?: number;

interface XAxisTicksEstimateOptions

interface XAxisTicksEstimateOptions {}

property maxTickLength

maxTickLength?: number;

property rotateTicks

rotateTicks?: boolean;

property scale

scale: any;

property tickFormatting

tickFormatting?: (value: any) => string;

property tickValues

tickValues?: string[] | number[];

property trimTicks

trimTicks?: boolean;

property width

width: number;

property wrapTicks

wrapTicks?: boolean;

interface YAxisTicksEstimateOptions

interface YAxisTicksEstimateOptions {}

property height

height: number;

property maxTickLength

maxTickLength?: number;

property scale

scale: any;

property tickFormatting

tickFormatting?: (value: any) => string;

property tickValues

tickValues?: string[] | number[];

property trimTicks

trimTicks?: boolean;

property wrapTicks

wrapTicks?: boolean;

Enums

enum BarChartType

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

member Normalized

Normalized = 'normalized'

member Stacked

Stacked = 'stacked'

member Standard

Standard = 'standard'

enum BarOrientation

enum BarOrientation {
    Vertical = 'vertical',
    Horizontal = 'horizontal',
}

member Horizontal

Horizontal = 'horizontal'

member Vertical

Vertical = 'vertical'

enum D0Types

enum D0Types {
    positive = 'positive',
    negative = 'negative',
}

member negative

negative = 'negative'

member positive

positive = 'positive'

enum LegendPosition

enum LegendPosition {
    Right = 'right',
    Below = 'below',
}

member Below

Below = 'below'

member Right

Right = 'right'

enum LegendType

enum LegendType {
    ScaleLegend = 'scaleLegend',
    Legend = 'legend',
}

member Legend

Legend = 'legend'

member ScaleLegend

ScaleLegend = 'scaleLegend'

enum Orientation

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

member Bottom

Bottom = 'bottom'

member Left

Left = 'left'

member Right

Right = 'right'

member Top

Top = 'top'

enum PlacementTypes

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

member Bottom

Bottom = 'bottom'

member Center

Center = 'center'

member Left

Left = 'left'

member Right

Right = 'right'

member Top

Top = 'top'

enum ScaleType

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

member Linear

Linear = 'linear'

member Ordinal

Ordinal = 'ordinal'

member Quantile

Quantile = 'quantile'

member Time

Time = 'time'

enum SeriesType

enum SeriesType {
    Standard = 'standard',
    Stacked = 'stacked',
}

member Stacked

Stacked = 'stacked'

member Standard

Standard = 'standard'

enum ShowTypes

enum ShowTypes {
    all,
    focus,
    mouseover,
}

member all

all

member focus

focus

member mouseover

mouseover

enum StyleTypes

enum StyleTypes {
    popover = 'popover',
    tooltip = 'tooltip',
}

member popover

popover = 'popover'

member tooltip

tooltip = 'tooltip'

enum TextAnchor

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

member End

End = 'end'

member Middle

Middle = 'middle'

member Start

Start = 'start'

Type Aliases

type StringOrNumberOrDate

type StringOrNumberOrDate = string | number | Date;

Package Files (1)

types/swimlane-ngx-charts.d.ts

Dependencies (15)

Dev Dependencies (0)

No dev dependencies.

Peer Dependencies (8)

Badge

To add a badge like this oneto your package's README, use the codes available below.

You may also use Shields.io to create a custom badge linking to https://www.jsdocs.io/package/@swimlane/ngx-charts.

Markdown

[![jsDocs.io](https://img.shields.io/badge/jsDocs.io-reference-blue)](https://www.jsdocs.io/package/@swimlane/ngx-charts)

HTML

<a href="https://www.jsdocs.io/package/@swimlane/ngx-charts"><img src="https://img.shields.io/badge/jsDocs.io-reference-blue" alt="jsDocs.io"></a>

Updated 2 seconds ago.
Package analyzed in 23703 ms.
Missing or incorrect documentation? Open an issue for this package.

@swimlane/ngx-charts

Install

Overview

Index

Variables

Functions

Classes

Interfaces

Enums

Type Aliases

Variables

variable colorSets

Functions

function calculateViewDimensions

function cloneLineCoordinates

function clonePoint

function cloneVector2d

function count

function decimalChecker

function escapeLabel

function formatLabel

function getDomain

function getScale

function getScaleType

Returns

function getTickLines

function getUniqueXDomainValues

Returns

function getXDomainArray

function gridLayout

function gridSize

function hexToRgb

function id

function invertColor

function maxCharsForPixelWidth

function reduceTicks

function shadeRGBColor

Parameter

function sortByDomain

function sortByTime

function sortLinear

function throttle

function throttleable

function tickFormat

function trimLabel

Classes

class AdvancedLegendComponent

property activate

property animations

property colors

property data

property deactivate

property defaultValueFormatting

property label

property labelFormatting

property legendItems

property ɵcmp

property ɵfac

property percentageFormatting

property roundedTotal

property roundPercentages

property select

property total

property valueFormatting

property width

method getLegendItems

method getPercentage

method getTotal

method ngOnChanges

method trackBy

method update

class AdvancedPieChartComponent

property activate

property activeEntries

property colors

property deactivate

property dims

property domain

property gradient

property innerRadius