@types/chartist

  • Version 0.11.0
  • Published
  • 33 kB
  • No dependencies
  • MIT license

Install

npm i @types/chartist
yarn add @types/chartist
pnpm add @types/chartist

Overview

TypeScript definitions for Chartist

Index

Variables

Interfaces

Type Aliases

Variables

variable Chartist

var Chartist: Chartist.ChartistStatic;

    Interfaces

    interface ChartistEasingStatic

    interface ChartistEasingStatic {}

      property easeInBack

      easeInBack: IChartistEasingDefinition;

        property easeInCirc

        easeInCirc: IChartistEasingDefinition;

          property easeInCubic

          easeInCubic: IChartistEasingDefinition;

            property easeInExpo

            easeInExpo: IChartistEasingDefinition;

              property easeInOutBack

              easeInOutBack: IChartistEasingDefinition;

                property easeInOutCirc

                easeInOutCirc: IChartistEasingDefinition;

                  property easeInOutCubic

                  easeInOutCubic: IChartistEasingDefinition;

                    property easeInOutExpo

                    easeInOutExpo: IChartistEasingDefinition;

                      property easeInOutQuad

                      easeInOutQuad: IChartistEasingDefinition;

                        property easeInOutQuart

                        easeInOutQuart: IChartistEasingDefinition;

                          property easeInOutQuint

                          easeInOutQuint: IChartistEasingDefinition;

                            property easeInOutSine

                            easeInOutSine: IChartistEasingDefinition;

                              property easeInQuad

                              easeInQuad: IChartistEasingDefinition;

                                property easeInQuart

                                easeInQuart: IChartistEasingDefinition;

                                  property easeInQuint

                                  easeInQuint: IChartistEasingDefinition;

                                    property easeInSine

                                    easeInSine: IChartistEasingDefinition;

                                      property easeOutBack

                                      easeOutBack: IChartistEasingDefinition;

                                        property easeOutCirc

                                        easeOutCirc: IChartistEasingDefinition;

                                          property easeOutCubic

                                          easeOutCubic: IChartistEasingDefinition;

                                            property easeOutExpo

                                            easeOutExpo: IChartistEasingDefinition;

                                              property easeOutQuad

                                              easeOutQuad: IChartistEasingDefinition;

                                                property easeOutQuart

                                                easeOutQuart: IChartistEasingDefinition;

                                                  property easeOutQuint

                                                  easeOutQuint: IChartistEasingDefinition;

                                                    property easeOutSine

                                                    easeOutSine: IChartistEasingDefinition;

                                                      interface ChartistInterpolationStatic

                                                      interface ChartistInterpolationStatic {}

                                                        method cardinal

                                                        cardinal: (options?: IChartistCardinalInterpolationOptions) => Function;
                                                        • Cardinal / Catmull-Rome spline interpolation is the default smoothing function in Chartist. It produces nice results where the splines will always meet the points. It produces some artifacts though when data values are increased or decreased rapidly. The line may not follow a very accurate path and if the line should be accurate this smoothing function does not produce the best results.

                                                        method none

                                                        none: (options?: IChartistInterpolationOptions) => Function;
                                                        • This interpolation function does not smooth the path and the result is only containing lines and no curves.

                                                        method simple

                                                        simple: (options?: IChartistSimpleInterpolationOptions) => Function;
                                                        • Simple smoothing creates horizontal handles that are positioned with a fraction of the length between two data points. You can use the divisor option to specify the amount of smoothing.

                                                        method step

                                                        step: (options?: IChartistStepInterpolationOptions) => Function;
                                                        • Step interpolation will cause the line chart to move in steps rather than diagonal or smoothed lines. This interpolation will create additional points that will also be drawn when the showPoint option is enabled.

                                                        interface ChartistStatic

                                                        interface ChartistStatic {}

                                                          property AutoScaleAxis

                                                          AutoScaleAxis: IAutoScaleAxisStatic;

                                                            property Bar

                                                            Bar: IChartistBarChart;

                                                              property Candle

                                                              Candle: IChartistCandleChart;

                                                                property escapingMap

                                                                escapingMap: IChartistEscapeMap;
                                                                • A map with characters to escape for strings to be safely used as attribute values.

                                                                property FixedScaleAxis

                                                                FixedScaleAxis: IFixedScaleAxisStatic;

                                                                  property Interpolation

                                                                  Interpolation: ChartistInterpolationStatic;

                                                                    property Line

                                                                    Line: IChartistLineChart;

                                                                      property noop

                                                                      noop: Function;

                                                                        property Pie

                                                                        Pie: IChartistPieChart;

                                                                          property plugins

                                                                          plugins: any;

                                                                            property precision

                                                                            precision: number;
                                                                            • Precision level used internally in Chartist for rounding. If you require more decimal places you can increase this number.

                                                                            property StepAxis

                                                                            StepAxis: IStepAxisStatic;

                                                                              property Svg

                                                                              Svg: ChartistSvgStatic;

                                                                                method alphaNumerate

                                                                                alphaNumerate: (n: number) => string;

                                                                                  method createSvg

                                                                                  createSvg: (
                                                                                  container: Node,
                                                                                  width: string,
                                                                                  height: string,
                                                                                  className: string
                                                                                  ) => Object;

                                                                                    method deserialize

                                                                                    deserialize: (data: string) => Object | string | number;

                                                                                      method ensureUnit

                                                                                      ensureUnit: (value: number, unit: string) => string;

                                                                                        method extend

                                                                                        extend: (target: Object, ...sources: Object[]) => Object;

                                                                                          method getMultiValue

                                                                                          getMultiValue: (value: any, dimension?: any) => number;

                                                                                            method mapAdd

                                                                                            mapAdd: (addend: number) => (num: number) => number;

                                                                                              method mapMultiply

                                                                                              mapMultiply: (factor: number) => (num: number) => number;

                                                                                                method quantity

                                                                                                quantity: (input: string | number) => Object;

                                                                                                  method query

                                                                                                  query: (query: Node | string) => Node;

                                                                                                    method replaceAll

                                                                                                    replaceAll: (str: string, subStr: string, newSubStr: string) => string;

                                                                                                      method roundWithPrecision

                                                                                                      roundWithPrecision: (value: number, digits?: number) => number;

                                                                                                        method serialize

                                                                                                        serialize: (data: Object | string | number) => string;

                                                                                                          method serialMap

                                                                                                          serialMap: (arr: Array<any>, cb: Function) => Array<any>;

                                                                                                            method sum

                                                                                                            sum: (previous: number, current: number) => number;

                                                                                                              method times

                                                                                                              times: (length: number) => Array<any>;

                                                                                                                interface ChartistSvgStatic

                                                                                                                interface ChartistSvgStatic {}

                                                                                                                  property Easing

                                                                                                                  Easing: ChartistEasingStatic;

                                                                                                                    method isSupported

                                                                                                                    isSupported: (feature: string) => boolean;
                                                                                                                    • This method checks for support of a given SVG feature like Extensibility, SVG-animation or the like. Check http://www.w3.org/TR/SVG11/feature for a detailed list.

                                                                                                                    construct signature

                                                                                                                    new (
                                                                                                                    name?: HTMLElement | string,
                                                                                                                    attributes?: Object,
                                                                                                                    className?: string,
                                                                                                                    parent?: Object,
                                                                                                                    insertFirst?: boolean
                                                                                                                    ): IChartistSvg;

                                                                                                                      interface IAutoScaleAxisStatic

                                                                                                                      interface IAutoScaleAxisStatic {}

                                                                                                                        interface IBarChartAxis

                                                                                                                        interface IBarChartAxis {}

                                                                                                                          property labelInterpolationFnc

                                                                                                                          labelInterpolationFnc?: Function;

                                                                                                                            property labelOffset

                                                                                                                            labelOffset?: {
                                                                                                                            x?: number;
                                                                                                                            y?: number;
                                                                                                                            };

                                                                                                                              property offset

                                                                                                                              offset?: number;

                                                                                                                                property onlyInteger

                                                                                                                                onlyInteger?: boolean;

                                                                                                                                  property position

                                                                                                                                  position?: string;

                                                                                                                                    property scaleMinSpace

                                                                                                                                    scaleMinSpace?: number;

                                                                                                                                      property showGrid

                                                                                                                                      showGrid?: boolean;

                                                                                                                                        property showLabel

                                                                                                                                        showLabel?: boolean;

                                                                                                                                          interface IBarChartClasses

                                                                                                                                          interface IBarChartClasses {}

                                                                                                                                            property bar

                                                                                                                                            bar?: string;

                                                                                                                                              property chart

                                                                                                                                              chart?: string;

                                                                                                                                                property end

                                                                                                                                                end?: string;

                                                                                                                                                  property grid

                                                                                                                                                  grid?: string;

                                                                                                                                                    property gridGroup

                                                                                                                                                    gridGroup?: string;

                                                                                                                                                      property horizontal

                                                                                                                                                      horizontal?: string;

                                                                                                                                                        property horizontalBars

                                                                                                                                                        horizontalBars?: string;

                                                                                                                                                          property label

                                                                                                                                                          label?: string;

                                                                                                                                                            property labelGroup

                                                                                                                                                            labelGroup?: string;

                                                                                                                                                              property series

                                                                                                                                                              series?: string;

                                                                                                                                                                property start

                                                                                                                                                                start?: string;

                                                                                                                                                                  property vertical

                                                                                                                                                                  vertical?: string;

                                                                                                                                                                    interface IBarChartOptions

                                                                                                                                                                    interface IBarChartOptions extends IChartOptions {}

                                                                                                                                                                      property axisX

                                                                                                                                                                      axisX?: IBarChartAxis;

                                                                                                                                                                        property axisY

                                                                                                                                                                        axisY?: IBarChartAxis;

                                                                                                                                                                          property chartPadding

                                                                                                                                                                          chartPadding?: IChartPadding;

                                                                                                                                                                            property classNames

                                                                                                                                                                            classNames?: IBarChartClasses;
                                                                                                                                                                            • Override the class names that are used to generate the SVG structure of the chart

                                                                                                                                                                            property distributeSeries

                                                                                                                                                                            distributeSeries?: boolean;

                                                                                                                                                                              property height

                                                                                                                                                                              height?: number | string;

                                                                                                                                                                                property high

                                                                                                                                                                                high?: number;

                                                                                                                                                                                  property horizontalBars

                                                                                                                                                                                  horizontalBars?: boolean;

                                                                                                                                                                                    property low

                                                                                                                                                                                    low?: number;

                                                                                                                                                                                      property onlyInteger

                                                                                                                                                                                      onlyInteger?: boolean;

                                                                                                                                                                                        property seriesBarDistance

                                                                                                                                                                                        seriesBarDistance?: number;

                                                                                                                                                                                          property stackBars

                                                                                                                                                                                          stackBars?: boolean;
                                                                                                                                                                                          • If set to true this property will cause the series bars to be stacked and form a total for each series point. This will also influence the y-axis and the overall bounds of the chart. In stacked mode the seriesBarDistance property will have no effect.

                                                                                                                                                                                          property stackMode

                                                                                                                                                                                          stackMode?: 'overlap' | 'accumulate';

                                                                                                                                                                                            property ticks

                                                                                                                                                                                            ticks?: Array<string | number>;

                                                                                                                                                                                              property width

                                                                                                                                                                                              width?: number | string;

                                                                                                                                                                                                interface ICandleChartAxis

                                                                                                                                                                                                interface ICandleChartAxis {}

                                                                                                                                                                                                  property labelInterpolationFnc

                                                                                                                                                                                                  labelInterpolationFnc?: Function;
                                                                                                                                                                                                  • Interpolation function that allows you to intercept the value from the axis label

                                                                                                                                                                                                  property labelOffset

                                                                                                                                                                                                  labelOffset?: {
                                                                                                                                                                                                  x?: number;
                                                                                                                                                                                                  y?: number;
                                                                                                                                                                                                  };
                                                                                                                                                                                                  • Allows you to correct label positioning on this axis by positive or negative x and y offset.

                                                                                                                                                                                                  property offset

                                                                                                                                                                                                  offset?: number;
                                                                                                                                                                                                  • The offset of the chart drawing area to the border of the container

                                                                                                                                                                                                  property position

                                                                                                                                                                                                  position?: string;
                                                                                                                                                                                                  • Position where labels are placed. Can be set to start or end where start is equivalent to left or top on vertical axis and end is equivalent to right or bottom on horizontal axis.

                                                                                                                                                                                                  property showGrid

                                                                                                                                                                                                  showGrid?: boolean;
                                                                                                                                                                                                  • If the axis grid should be drawn or not

                                                                                                                                                                                                  property showLabel

                                                                                                                                                                                                  showLabel?: boolean;
                                                                                                                                                                                                  • If labels should be shown or not

                                                                                                                                                                                                  property type

                                                                                                                                                                                                  type?: any;
                                                                                                                                                                                                  • Set the axis type to be used to project values on this axis. If not defined, Chartist.StepAxis will be used for the X-Axis, where the ticks option will be set to the labels in the data and the stretch option will be set to the global fullWidth option. This type can be changed to any axis constructor available (e.g. Chartist.FixedScaleAxis), where all axis options should be present here.

                                                                                                                                                                                                  interface ICandleChartClasses

                                                                                                                                                                                                  interface ICandleChartClasses {}

                                                                                                                                                                                                    property candleNegative

                                                                                                                                                                                                    candleNegative?: string;

                                                                                                                                                                                                      property candlePositive

                                                                                                                                                                                                      candlePositive?: string;

                                                                                                                                                                                                        property chart

                                                                                                                                                                                                        chart?: string;

                                                                                                                                                                                                          property end

                                                                                                                                                                                                          end?: string;

                                                                                                                                                                                                            property grid

                                                                                                                                                                                                            grid?: string;

                                                                                                                                                                                                              property gridBackground

                                                                                                                                                                                                              gridBackground?: string;

                                                                                                                                                                                                                property gridGroup

                                                                                                                                                                                                                gridGroup?: string;

                                                                                                                                                                                                                  property horizontal

                                                                                                                                                                                                                  horizontal?: string;

                                                                                                                                                                                                                    property label

                                                                                                                                                                                                                    label?: string;

                                                                                                                                                                                                                      property labelGroup

                                                                                                                                                                                                                      labelGroup?: string;

                                                                                                                                                                                                                        property series

                                                                                                                                                                                                                        series?: string;

                                                                                                                                                                                                                          property start

                                                                                                                                                                                                                          start?: string;

                                                                                                                                                                                                                            property vertical

                                                                                                                                                                                                                            vertical?: string;

                                                                                                                                                                                                                              interface ICandleChartOptions

                                                                                                                                                                                                                              interface ICandleChartOptions extends IChartOptions {}

                                                                                                                                                                                                                                property axisX

                                                                                                                                                                                                                                axisX?: ICandleChartAxis;
                                                                                                                                                                                                                                • Options for X-Axis

                                                                                                                                                                                                                                property axisY

                                                                                                                                                                                                                                axisY?: ICandleChartAxis;
                                                                                                                                                                                                                                • Options for Y-Axis

                                                                                                                                                                                                                                property candleWickWidth

                                                                                                                                                                                                                                candleWickWidth?: number | string;
                                                                                                                                                                                                                                • Width of candle wick in pixel (IMO is 1 px best minimum value)

                                                                                                                                                                                                                                property candleWidth

                                                                                                                                                                                                                                candleWidth?: number | string;
                                                                                                                                                                                                                                • Width of candle body in pixel (IMO is 2 px best minimum value)

                                                                                                                                                                                                                                property chartPadding

                                                                                                                                                                                                                                chartPadding?: IChartPadding | number;
                                                                                                                                                                                                                                • Padding of the chart drawing area to the container element and labels as a number or padding object {top: 5, right: 5, bottom: 5, left: 5}

                                                                                                                                                                                                                                property classNames

                                                                                                                                                                                                                                classNames?: ICandleChartClasses;
                                                                                                                                                                                                                                • Override the class names that get used to generate the SVG structure of the chart

                                                                                                                                                                                                                                property fullWidth

                                                                                                                                                                                                                                fullWidth?: boolean | string;
                                                                                                                                                                                                                                • When set to true, the last grid line on the x-axis is not drawn and the chart elements will expand to the full available width of the chart. For the last label to be drawncorrectly you might need to add chart padding or offset the last label with a draw event handler.

                                                                                                                                                                                                                                property height

                                                                                                                                                                                                                                height?: number | string;
                                                                                                                                                                                                                                • Specify a fixed height for the chart as a string (i.e. '100px' or '50%')

                                                                                                                                                                                                                                property hight

                                                                                                                                                                                                                                hight?: number | string;
                                                                                                                                                                                                                                • Overriding the natural high of the chart allows you to zoom in or limit the charts highest displayed value

                                                                                                                                                                                                                                property low

                                                                                                                                                                                                                                low?: number | string;
                                                                                                                                                                                                                                • Overriding the natural low of the chart allows you to zoom in or limit the charts lowest displayed value

                                                                                                                                                                                                                                property useOneThirdAsCandleWickWidth

                                                                                                                                                                                                                                useOneThirdAsCandleWickWidth?: boolean | string;
                                                                                                                                                                                                                                • Use 1/3 of candle body width as width for the candle wick, otherwise the candleWickWidth is being used.

                                                                                                                                                                                                                                property useStepLengthAsCandleWidth

                                                                                                                                                                                                                                useStepLengthAsCandleWidth?: boolean | string;
                                                                                                                                                                                                                                • Use calculated x-axis step length, depending on the number of quotes to display, as candle width. Otherwise the candleWidth is being used.

                                                                                                                                                                                                                                property width

                                                                                                                                                                                                                                width?: number | string;
                                                                                                                                                                                                                                • Specify a fixed width for the chart as a string (i.e. '100px' or '50%')

                                                                                                                                                                                                                                interface IChartAxis

                                                                                                                                                                                                                                interface IChartAxis {}

                                                                                                                                                                                                                                  property axisLength

                                                                                                                                                                                                                                  axisLength: number;

                                                                                                                                                                                                                                    property chartRect

                                                                                                                                                                                                                                    chartRect: IChartRect;

                                                                                                                                                                                                                                      property counterUnits

                                                                                                                                                                                                                                      counterUnits: IChartUnits;

                                                                                                                                                                                                                                        property divisor

                                                                                                                                                                                                                                        divisor: number;

                                                                                                                                                                                                                                          property gridOffset

                                                                                                                                                                                                                                          gridOffset: number;

                                                                                                                                                                                                                                            property options

                                                                                                                                                                                                                                            options: unknown;

                                                                                                                                                                                                                                              property range

                                                                                                                                                                                                                                              range: {
                                                                                                                                                                                                                                              min: number;
                                                                                                                                                                                                                                              max: number;
                                                                                                                                                                                                                                              };

                                                                                                                                                                                                                                                property stepLength

                                                                                                                                                                                                                                                stepLength: number;

                                                                                                                                                                                                                                                  property ticks

                                                                                                                                                                                                                                                  ticks: number[];

                                                                                                                                                                                                                                                    property units

                                                                                                                                                                                                                                                    units: IChartUnits;

                                                                                                                                                                                                                                                      interface IChartDrawBarData

                                                                                                                                                                                                                                                      interface IChartDrawBarData {}

                                                                                                                                                                                                                                                        property axisX

                                                                                                                                                                                                                                                        axisX: IChartAxis;

                                                                                                                                                                                                                                                          property axisY

                                                                                                                                                                                                                                                          axisY: IChartAxis;

                                                                                                                                                                                                                                                            property chartRect

                                                                                                                                                                                                                                                            chartRect: IChartRect;

                                                                                                                                                                                                                                                              property element

                                                                                                                                                                                                                                                              element: IChartistSvg;

                                                                                                                                                                                                                                                                property group

                                                                                                                                                                                                                                                                group: IChartistSvg;

                                                                                                                                                                                                                                                                  property index

                                                                                                                                                                                                                                                                  index: number;

                                                                                                                                                                                                                                                                    property meta

                                                                                                                                                                                                                                                                    meta: unknown;

                                                                                                                                                                                                                                                                      property series

                                                                                                                                                                                                                                                                      series: number[];

                                                                                                                                                                                                                                                                        property seriesIndex

                                                                                                                                                                                                                                                                        seriesIndex: number;

                                                                                                                                                                                                                                                                          property type

                                                                                                                                                                                                                                                                          type: 'bar';

                                                                                                                                                                                                                                                                            property value

                                                                                                                                                                                                                                                                            value: {
                                                                                                                                                                                                                                                                            x?: number;
                                                                                                                                                                                                                                                                            y?: number;
                                                                                                                                                                                                                                                                            };

                                                                                                                                                                                                                                                                              property x1

                                                                                                                                                                                                                                                                              x1: number;

                                                                                                                                                                                                                                                                                property x2

                                                                                                                                                                                                                                                                                x2: number;

                                                                                                                                                                                                                                                                                  property y1

                                                                                                                                                                                                                                                                                  y1: number;

                                                                                                                                                                                                                                                                                    property y2

                                                                                                                                                                                                                                                                                    y2: number;

                                                                                                                                                                                                                                                                                      interface IChartDrawGridData

                                                                                                                                                                                                                                                                                      interface IChartDrawGridData {}

                                                                                                                                                                                                                                                                                        property axis

                                                                                                                                                                                                                                                                                        axis: IChartAxis;

                                                                                                                                                                                                                                                                                          property element

                                                                                                                                                                                                                                                                                          element: IChartistSvg;

                                                                                                                                                                                                                                                                                            property group

                                                                                                                                                                                                                                                                                            group: IChartistSvg;

                                                                                                                                                                                                                                                                                              property index

                                                                                                                                                                                                                                                                                              index: number;

                                                                                                                                                                                                                                                                                                property type

                                                                                                                                                                                                                                                                                                type: 'grid';

                                                                                                                                                                                                                                                                                                  property x1

                                                                                                                                                                                                                                                                                                  x1: number;

                                                                                                                                                                                                                                                                                                    property x2

                                                                                                                                                                                                                                                                                                    x2: number;

                                                                                                                                                                                                                                                                                                      property y1

                                                                                                                                                                                                                                                                                                      y1: number;

                                                                                                                                                                                                                                                                                                        property y2

                                                                                                                                                                                                                                                                                                        y2: number;

                                                                                                                                                                                                                                                                                                          interface IChartDrawLabelData

                                                                                                                                                                                                                                                                                                          interface IChartDrawLabelData {}

                                                                                                                                                                                                                                                                                                            property axis

                                                                                                                                                                                                                                                                                                            axis: IChartAxis;

                                                                                                                                                                                                                                                                                                              property element

                                                                                                                                                                                                                                                                                                              element: IChartistSvg;

                                                                                                                                                                                                                                                                                                                property group

                                                                                                                                                                                                                                                                                                                group: IChartistSvg;

                                                                                                                                                                                                                                                                                                                  property height

                                                                                                                                                                                                                                                                                                                  height: number;

                                                                                                                                                                                                                                                                                                                    property index

                                                                                                                                                                                                                                                                                                                    index: number;

                                                                                                                                                                                                                                                                                                                      property text

                                                                                                                                                                                                                                                                                                                      text: number;

                                                                                                                                                                                                                                                                                                                        property type

                                                                                                                                                                                                                                                                                                                        type: 'label';

                                                                                                                                                                                                                                                                                                                          property width

                                                                                                                                                                                                                                                                                                                          width: number;

                                                                                                                                                                                                                                                                                                                            property x

                                                                                                                                                                                                                                                                                                                            x: number;

                                                                                                                                                                                                                                                                                                                              property y

                                                                                                                                                                                                                                                                                                                              y: number;

                                                                                                                                                                                                                                                                                                                                interface IChartistAnimationOptions

                                                                                                                                                                                                                                                                                                                                interface IChartistAnimationOptions {}

                                                                                                                                                                                                                                                                                                                                  property begin

                                                                                                                                                                                                                                                                                                                                  begin?: string;

                                                                                                                                                                                                                                                                                                                                    property dur

                                                                                                                                                                                                                                                                                                                                    dur: string | number;

                                                                                                                                                                                                                                                                                                                                      property easing

                                                                                                                                                                                                                                                                                                                                      easing?: IChartistEasingDefinition | string;

                                                                                                                                                                                                                                                                                                                                        property fill

                                                                                                                                                                                                                                                                                                                                        fill?: string;

                                                                                                                                                                                                                                                                                                                                          property from

                                                                                                                                                                                                                                                                                                                                          from: string | number;

                                                                                                                                                                                                                                                                                                                                            property id

                                                                                                                                                                                                                                                                                                                                            id?: string;

                                                                                                                                                                                                                                                                                                                                              property to

                                                                                                                                                                                                                                                                                                                                              to: string | number;

                                                                                                                                                                                                                                                                                                                                                interface IChartistAnimations

                                                                                                                                                                                                                                                                                                                                                interface IChartistAnimations {}

                                                                                                                                                                                                                                                                                                                                                  index signature

                                                                                                                                                                                                                                                                                                                                                  [Key: string]: IChartistAnimationOptions;

                                                                                                                                                                                                                                                                                                                                                    interface IChartistAutoScaleAxis

                                                                                                                                                                                                                                                                                                                                                    interface IChartistAutoScaleAxis extends ILineChartAxis {}

                                                                                                                                                                                                                                                                                                                                                      property high

                                                                                                                                                                                                                                                                                                                                                      high?: number;

                                                                                                                                                                                                                                                                                                                                                        property low

                                                                                                                                                                                                                                                                                                                                                        low?: number;

                                                                                                                                                                                                                                                                                                                                                          property onlyInteger

                                                                                                                                                                                                                                                                                                                                                          onlyInteger?: boolean;

                                                                                                                                                                                                                                                                                                                                                            property referenceValue

                                                                                                                                                                                                                                                                                                                                                            referenceValue?: number;

                                                                                                                                                                                                                                                                                                                                                              property scaleMinSpace

                                                                                                                                                                                                                                                                                                                                                              scaleMinSpace?: number;

                                                                                                                                                                                                                                                                                                                                                                property type

                                                                                                                                                                                                                                                                                                                                                                type?: IAutoScaleAxisStatic;

                                                                                                                                                                                                                                                                                                                                                                  interface IChartistBarChart

                                                                                                                                                                                                                                                                                                                                                                  interface IChartistBarChart extends IChartistBase<IBarChartOptions> {}

                                                                                                                                                                                                                                                                                                                                                                    construct signature

                                                                                                                                                                                                                                                                                                                                                                    new (
                                                                                                                                                                                                                                                                                                                                                                    target: any,
                                                                                                                                                                                                                                                                                                                                                                    data: IChartistData,
                                                                                                                                                                                                                                                                                                                                                                    options?: IBarChartOptions,
                                                                                                                                                                                                                                                                                                                                                                    responsiveOptions?: Array<IResponsiveOptionTuple<IBarChartOptions>>
                                                                                                                                                                                                                                                                                                                                                                    ): IChartistBarChart;

                                                                                                                                                                                                                                                                                                                                                                      interface IChartistBase

                                                                                                                                                                                                                                                                                                                                                                      interface IChartistBase<T extends IChartOptions> {}

                                                                                                                                                                                                                                                                                                                                                                        property container

                                                                                                                                                                                                                                                                                                                                                                        container: any;

                                                                                                                                                                                                                                                                                                                                                                          property data

                                                                                                                                                                                                                                                                                                                                                                          data: IChartistData;

                                                                                                                                                                                                                                                                                                                                                                            property defaultOptions

                                                                                                                                                                                                                                                                                                                                                                            defaultOptions: T;

                                                                                                                                                                                                                                                                                                                                                                              property eventEmitter

                                                                                                                                                                                                                                                                                                                                                                              eventEmitter: any;

                                                                                                                                                                                                                                                                                                                                                                                property options

                                                                                                                                                                                                                                                                                                                                                                                options: T;

                                                                                                                                                                                                                                                                                                                                                                                  property plugins

                                                                                                                                                                                                                                                                                                                                                                                  plugins?: Array<any>;

                                                                                                                                                                                                                                                                                                                                                                                    property resizeListener

                                                                                                                                                                                                                                                                                                                                                                                    resizeListener: any;

                                                                                                                                                                                                                                                                                                                                                                                      property responsiveOptions

                                                                                                                                                                                                                                                                                                                                                                                      responsiveOptions: Array<IResponsiveOptionTuple<T>>;

                                                                                                                                                                                                                                                                                                                                                                                        property supportsAnimations

                                                                                                                                                                                                                                                                                                                                                                                        supportsAnimations: boolean;

                                                                                                                                                                                                                                                                                                                                                                                          property supportsForeignObject

                                                                                                                                                                                                                                                                                                                                                                                          supportsForeignObject: boolean;

                                                                                                                                                                                                                                                                                                                                                                                            method detach

                                                                                                                                                                                                                                                                                                                                                                                            detach: () => void;

                                                                                                                                                                                                                                                                                                                                                                                              method off

                                                                                                                                                                                                                                                                                                                                                                                              off: (event: string, handler?: Function) => IChartistBase<T>;
                                                                                                                                                                                                                                                                                                                                                                                              • Use this function to un-register event handlers. If the handler function parameter is omitted all handlers for the given event will be un-registered.

                                                                                                                                                                                                                                                                                                                                                                                                off

                                                                                                                                                                                                                                                                                                                                                                                                Parameter event

                                                                                                                                                                                                                                                                                                                                                                                                Name of the event for which a handler should be removed

                                                                                                                                                                                                                                                                                                                                                                                                Parameter handler

                                                                                                                                                                                                                                                                                                                                                                                                The handler function that that was previously used to register a new event handler. This handler will be removed from the event handler list. If this parameter is omitted then all event handlers for the given event are removed from the list.

                                                                                                                                                                                                                                                                                                                                                                                              method on

                                                                                                                                                                                                                                                                                                                                                                                              on: (event: string, handler: Function) => IChartistBase<T>;
                                                                                                                                                                                                                                                                                                                                                                                              • Use this function to register event handlers. The handler callbacks are synchronous and will run in the main thread rather than the event loop.

                                                                                                                                                                                                                                                                                                                                                                                                on

                                                                                                                                                                                                                                                                                                                                                                                                Parameter event

                                                                                                                                                                                                                                                                                                                                                                                                Name of the event. Check the examples for supported events.

                                                                                                                                                                                                                                                                                                                                                                                                Parameter handler

                                                                                                                                                                                                                                                                                                                                                                                                The handler function that will be called when an event with the given name was emitted. This function will receive a data argument which contains event data. See the example for more details.

                                                                                                                                                                                                                                                                                                                                                                                              method update

                                                                                                                                                                                                                                                                                                                                                                                              update: (data: Object, options?: T, override?: boolean) => void;

                                                                                                                                                                                                                                                                                                                                                                                                interface IChartistCandleChart

                                                                                                                                                                                                                                                                                                                                                                                                interface IChartistCandleChart extends IChartistBase<ICandleChartOptions> {}

                                                                                                                                                                                                                                                                                                                                                                                                  construct signature

                                                                                                                                                                                                                                                                                                                                                                                                  new (
                                                                                                                                                                                                                                                                                                                                                                                                  target: any,
                                                                                                                                                                                                                                                                                                                                                                                                  data: IChartistData,
                                                                                                                                                                                                                                                                                                                                                                                                  options?: ICandleChartOptions,
                                                                                                                                                                                                                                                                                                                                                                                                  responsiveOptions?: Array<IResponsiveOptionTuple<ICandleChartOptions>>
                                                                                                                                                                                                                                                                                                                                                                                                  ): IChartistCandleChart;

                                                                                                                                                                                                                                                                                                                                                                                                    interface IChartistCardinalInterpolationOptions

                                                                                                                                                                                                                                                                                                                                                                                                    interface IChartistCardinalInterpolationOptions
                                                                                                                                                                                                                                                                                                                                                                                                    extends IChartistInterpolationOptions {}

                                                                                                                                                                                                                                                                                                                                                                                                      property tension

                                                                                                                                                                                                                                                                                                                                                                                                      tension?: number;

                                                                                                                                                                                                                                                                                                                                                                                                        interface IChartistData

                                                                                                                                                                                                                                                                                                                                                                                                        interface IChartistData {}

                                                                                                                                                                                                                                                                                                                                                                                                          property labels

                                                                                                                                                                                                                                                                                                                                                                                                          labels?: Array<string> | Array<number> | Array<Date>;

                                                                                                                                                                                                                                                                                                                                                                                                            property series

                                                                                                                                                                                                                                                                                                                                                                                                            series:
                                                                                                                                                                                                                                                                                                                                                                                                            | Array<IChartistSeriesData>
                                                                                                                                                                                                                                                                                                                                                                                                            | Array<Array<IChartistSeriesData>>
                                                                                                                                                                                                                                                                                                                                                                                                            | Array<Array<IChartistData>>
                                                                                                                                                                                                                                                                                                                                                                                                            | Array<number>
                                                                                                                                                                                                                                                                                                                                                                                                            | Array<Array<number>>;

                                                                                                                                                                                                                                                                                                                                                                                                              interface IChartistEasingDefinition

                                                                                                                                                                                                                                                                                                                                                                                                              interface IChartistEasingDefinition {}

                                                                                                                                                                                                                                                                                                                                                                                                                property 0

                                                                                                                                                                                                                                                                                                                                                                                                                0: number;

                                                                                                                                                                                                                                                                                                                                                                                                                  property 1

                                                                                                                                                                                                                                                                                                                                                                                                                  1: number;

                                                                                                                                                                                                                                                                                                                                                                                                                    property 2

                                                                                                                                                                                                                                                                                                                                                                                                                    2: number;

                                                                                                                                                                                                                                                                                                                                                                                                                      property 3

                                                                                                                                                                                                                                                                                                                                                                                                                      3: number;

                                                                                                                                                                                                                                                                                                                                                                                                                        interface IChartistEscapeMap

                                                                                                                                                                                                                                                                                                                                                                                                                        interface IChartistEscapeMap {}

                                                                                                                                                                                                                                                                                                                                                                                                                          index signature

                                                                                                                                                                                                                                                                                                                                                                                                                          [Key: string]: string;

                                                                                                                                                                                                                                                                                                                                                                                                                            interface IChartistFixedScaleAxis

                                                                                                                                                                                                                                                                                                                                                                                                                            interface IChartistFixedScaleAxis extends ILineChartAxis {}

                                                                                                                                                                                                                                                                                                                                                                                                                              property divisor

                                                                                                                                                                                                                                                                                                                                                                                                                              divisor?: number;

                                                                                                                                                                                                                                                                                                                                                                                                                                property high

                                                                                                                                                                                                                                                                                                                                                                                                                                high?: number;

                                                                                                                                                                                                                                                                                                                                                                                                                                  property low

                                                                                                                                                                                                                                                                                                                                                                                                                                  low?: number;

                                                                                                                                                                                                                                                                                                                                                                                                                                    property ticks

                                                                                                                                                                                                                                                                                                                                                                                                                                    ticks?: Array<string> | Array<number>;

                                                                                                                                                                                                                                                                                                                                                                                                                                      property type

                                                                                                                                                                                                                                                                                                                                                                                                                                      type?: IFixedScaleAxisStatic;

                                                                                                                                                                                                                                                                                                                                                                                                                                        interface IChartistInterpolationOptions

                                                                                                                                                                                                                                                                                                                                                                                                                                        interface IChartistInterpolationOptions {}

                                                                                                                                                                                                                                                                                                                                                                                                                                          property fillHoles

                                                                                                                                                                                                                                                                                                                                                                                                                                          fillHoles?: boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                            interface IChartistLineChart

                                                                                                                                                                                                                                                                                                                                                                                                                                            interface IChartistLineChart extends IChartistBase<ILineChartOptions> {}

                                                                                                                                                                                                                                                                                                                                                                                                                                              construct signature

                                                                                                                                                                                                                                                                                                                                                                                                                                              new (
                                                                                                                                                                                                                                                                                                                                                                                                                                              target: any,
                                                                                                                                                                                                                                                                                                                                                                                                                                              data: IChartistData,
                                                                                                                                                                                                                                                                                                                                                                                                                                              options?: ILineChartOptions,
                                                                                                                                                                                                                                                                                                                                                                                                                                              responsiveOptions?: Array<IResponsiveOptionTuple<ILineChartOptions>>
                                                                                                                                                                                                                                                                                                                                                                                                                                              ): IChartistLineChart;

                                                                                                                                                                                                                                                                                                                                                                                                                                                interface IChartistPieChart

                                                                                                                                                                                                                                                                                                                                                                                                                                                interface IChartistPieChart extends IChartistBase<IPieChartOptions> {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                  construct signature

                                                                                                                                                                                                                                                                                                                                                                                                                                                  new (
                                                                                                                                                                                                                                                                                                                                                                                                                                                  target: any,
                                                                                                                                                                                                                                                                                                                                                                                                                                                  data: IChartistData,
                                                                                                                                                                                                                                                                                                                                                                                                                                                  options?: IPieChartOptions,
                                                                                                                                                                                                                                                                                                                                                                                                                                                  responsiveOptions?: Array<IResponsiveOptionTuple<IPieChartOptions>>
                                                                                                                                                                                                                                                                                                                                                                                                                                                  ): IChartistPieChart;

                                                                                                                                                                                                                                                                                                                                                                                                                                                    interface IChartistSeriesData

                                                                                                                                                                                                                                                                                                                                                                                                                                                    interface IChartistSeriesData {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                      property className

                                                                                                                                                                                                                                                                                                                                                                                                                                                      className?: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                        property data

                                                                                                                                                                                                                                                                                                                                                                                                                                                        data?: Array<number> | Array<{ x: number | Date; y: number }>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                          property meta

                                                                                                                                                                                                                                                                                                                                                                                                                                                          meta?: any;

                                                                                                                                                                                                                                                                                                                                                                                                                                                            property name

                                                                                                                                                                                                                                                                                                                                                                                                                                                            name?: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                              property value

                                                                                                                                                                                                                                                                                                                                                                                                                                                              value?: number;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                interface IChartistSimpleInterpolationOptions

                                                                                                                                                                                                                                                                                                                                                                                                                                                                interface IChartistSimpleInterpolationOptions
                                                                                                                                                                                                                                                                                                                                                                                                                                                                extends IChartistInterpolationOptions {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property divisor

                                                                                                                                                                                                                                                                                                                                                                                                                                                                  divisor?: number;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                    interface IChartistStepAxis

                                                                                                                                                                                                                                                                                                                                                                                                                                                                    interface IChartistStepAxis extends ILineChartAxis {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property stretch

                                                                                                                                                                                                                                                                                                                                                                                                                                                                      stretch?: boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property ticks

                                                                                                                                                                                                                                                                                                                                                                                                                                                                        ticks?: Array<string> | Array<number>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property type

                                                                                                                                                                                                                                                                                                                                                                                                                                                                          type?: IStepAxisStatic;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                            interface IChartistStepInterpolationOptions

                                                                                                                                                                                                                                                                                                                                                                                                                                                                            interface IChartistStepInterpolationOptions extends IChartistInterpolationOptions {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property postpone

                                                                                                                                                                                                                                                                                                                                                                                                                                                                              postpone?: boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                interface IChartistSvg

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                interface IChartistSvg {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  method addClass

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  addClass: (names: string) => IChartistSvg;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • Adds one or a space separated list of classes to the current element and ensures the classes are only existing once.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    addClass

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Parameter names

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    A white space separated list of class names

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  method animate

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  animate: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  animations: IChartistAnimations,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  guided: boolean,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  eventEmitter: Object
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  ) => IChartistSvg;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • The animate function lets you animate the current element with SMIL animations. You can add animations for multiple attributes at the same time by using an animation definition object. This object should contain SMIL animation attributes.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  method append

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  append: (element: IChartistSvg, insertFirst?: boolean) => IChartistSvg;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • This method will append an element to the current element as a child.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  method attr

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  attr: (attributes: Object | string, ns?: string) => Object | string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • Set attributes on the current SVG element of the wrapper you're currently working on.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  method classes

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  classes: () => Array<string>;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • Returns an array of class names that are attached to the current wrapper element. This method can not be chained further.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  method elem

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  elem: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  name: string,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  attributes?: Object,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  className?: string,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  insertFirst?: boolean
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  ) => IChartistSvg;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • Create a new SVG element whose wrapper object will be selected for further operations. This way you can also create nested groups easily.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  method empty

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  empty: () => IChartistSvg;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • This method will clear all child nodes of the current wrapper object.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  method foreignObject

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  foreignObject: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  content: any,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  attributes?: Object,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  className?: string,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  insertFirst?: boolean
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  ) => IChartistSvg;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • This method creates a foreignObject (see https://developer.mozilla.org/en-US/docs/Web/SVG/Element/foreignObject) that allows to embed HTML content into a SVG graphic. With the help of foreignObjects you can enable the usage of regular HTML elements inside of SVG where they are subject for SVG positioning and transformation but the Browser will use the HTML rendering capabilities for the containing DOM.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  method getBBoxProperty

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  getBBoxProperty: (node: SVGElement, prop: string) => string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • "Safe" way to get property value from svg BoundingBox. This is a workaround. Firefox throws an NS_ERROR_FAILURE error if getBBox() is called on an invisible node. THIS IS A WORKAROUND

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  method height

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  height: () => number;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • Get element height with fallback to svg BoundingBox or parent container dimensions

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  method parent

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  parent: () => IChartistSvg;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • Returns the parent Chartist.SVG wrapper object

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  method querySelector

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  querySelector: (selector: string) => IChartistSvg;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • Find the first child SVG element of the current element that matches a CSS selector. The returned object is a Chartist.Svg wrapper.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  method querySelectorAll

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  querySelectorAll: (selector: string) => any;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • Find the all child SVG elements of the current element that match a CSS selector. The returned object is a Chartist.Svg.List wrapper.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  method remove

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  remove: () => IChartistSvg;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • This method will cause the current wrapper to remove itself from its parent wrapper. Use this method if you'd like to get rid of an element in a given DOM structure.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  method removeAllClasses

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  removeAllClasses: () => IChartistSvg;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • Removes all classes from the current element.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  method removeClass

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  removeClass: (names: string) => IChartistSvg;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • Removes one or a space separated list of classes from the current element.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    removeClass

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Parameter names

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    A white space separated list of class names

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  method replace

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  replace: () => IChartistSvg;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • This method will replace the element with a new element that can be created outside of the current DOM.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  method root

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  root: () => IChartistSvg;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • This method returns a Chartist.Svg wrapper around the root SVG element of the current tree.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  method text

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  text: (t: string) => IChartistSvg;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • This method adds a new text element to the current Chartist.Svg wrapper.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  interface IChartOptions

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  interface IChartOptions {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property plugins

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    plugins?: Array<any>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property reverseData

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      reverseData?: boolean;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • If true the whole data is reversed including labels, the series order as well as the whole series data arrays.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      interface IChartPadding

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      interface IChartPadding {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property bottom

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        bottom?: number;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property left

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          left?: number;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property right

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            right?: number;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property top

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              top?: number;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                interface IChartRect

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                interface IChartRect {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property height

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  height: () => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property padding

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    padding: IChartPadding;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property width

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      width: () => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property x1

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        x1: number;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property x2

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          x2: number;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property y1

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            y1: number;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property y2

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              y2: number;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                interface IChartUnits

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                interface IChartUnits {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property dir

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  dir: 'vertical' | 'horizontal';

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property len

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    len: 'height' | 'width';

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property pos

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      pos: 'x' | 'y';

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property rectEnd

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        rectEnd: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property rectOffset

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          rectOffset: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property rectStart

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            rectStart: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              interface IFixedScaleAxisStatic

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              interface IFixedScaleAxisStatic {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                interface ILineChartAxis

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                interface ILineChartAxis {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property labelInterpolationFnc

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  labelInterpolationFnc?: Function;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property labelOffset

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    labelOffset?: {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    x?: number;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    y?: number;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    };

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property offset

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      offset?: number;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property position

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        position?: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property showGrid

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          showGrid?: boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property showLabel

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            showLabel?: boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              interface ILineChartClasses

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              interface ILineChartClasses {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property area

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                area?: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property chart

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  chart?: string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • Default is 'ct-chart-line'

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property end

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  end?: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property grid

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    grid?: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property gridBackground

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      gridBackground?: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property gridGroup

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        gridGroup?: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property horizontal

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          horizontal?: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property label

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            label?: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property labelGroup

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              labelGroup?: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property line

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                line?: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property point

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  point?: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property series

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    series?: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property start

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      start?: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property vertical

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        vertical?: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          interface ILineChartOptions

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          interface ILineChartOptions extends IChartOptions {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property areaBase

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            areaBase?: number;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property axisX

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              axisX?: IChartistStepAxis | IChartistFixedScaleAxis | IChartistAutoScaleAxis;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property axisY

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                axisY?: IChartistStepAxis | IChartistFixedScaleAxis | IChartistAutoScaleAxis;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property chartPadding

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  chartPadding?: IChartPadding;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property classNames

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    classNames?: ILineChartClasses;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property fullWidth

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      fullWidth?: boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property height

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        height?: number | string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property high

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          high?: number;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property lineSmooth

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            lineSmooth?: Function | boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property low

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              low?: number;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property series

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                series?: {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                [key: string]: {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                lineSmooth?: Function | boolean;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                showLine?: boolean;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                showPoint?: boolean;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                showArea?: boolean;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                areaBase?: number;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                };
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                };

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property showArea

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  showArea?: boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property showLine

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    showLine?: boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property showPoint

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      showPoint?: boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property ticks

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        ticks?: Array<string | number>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property width

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          width?: number | string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            interface IPieChartClasses

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            interface IPieChartClasses {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property chartDonut

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              chartDonut?: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property chartPie

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                chartPie?: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property label

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  label?: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property series

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    series?: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property sliceDonut

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      sliceDonut?: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property slicePie

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        slicePie?: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          interface IPieChartOptions

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          interface IPieChartOptions extends IChartOptions {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property chartPadding

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            chartPadding?: IChartPadding | number;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • Padding of the chart drawing area to the container element and labels as a number or padding object {top: 5, right: 5, bottom: 5, left: 5}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property classNames

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            classNames?: IPieChartClasses;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • Override the class names that are used to generate the SVG structure of the chart

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property donut

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            donut?: boolean;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • If specified the donut CSS classes will be used and strokes will be drawn instead of pie slices.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property donutSolid

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            donutSolid?: boolean;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • If specified the donut segments will be drawn as shapes instead of strokes.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property donutWidth

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            donutWidth?: number | string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • Specify the donut stroke width, currently done in javascript for convenience. May move to CSS styles in the future. This option can be set as number or string to specify a relative width (i.e. 100 or '30%').

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property height

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            height?: number | string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • Specify a fixed height for the chart as a string (i.e. '100px' or '50%')

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property ignoreEmptyValues

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            ignoreEmptyValues?: boolean;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • If true empty values will be ignored to avoid drawing unncessary slices and labels

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property labelDirection

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            labelDirection?: string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • Label direction can be 'neutral', 'explode' or 'implode'. Default is 'neutral'. The labels anchor will be positioned based on those settings as well as the fact if the labels are on the right or left side of the center of the chart. Usually explode is useful when labels are positioned far away from the center.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property labelInterpolationFnc

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            labelInterpolationFnc?: Function;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • An interpolation function for the label value

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property labelOffset

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            labelOffset?: number;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • Label position offset from the standard position which is half distance of the radius. This value can be either positive or negative. Positive values will position the label away from the center.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property labelPosition

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            labelPosition?: string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • This option can be set to 'inside', 'outside' or 'center'. Positioned with 'inside' the labels will be placed on half the distance of the radius to the border of the Pie by respecting the 'labelOffset'. The 'outside' option will place the labels at the border of the pie and 'center' will place the labels in the absolute center point of the chart. The 'center' option only makes sense in conjunction with the 'labelOffset' option.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property reverseData

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            reverseData?: boolean;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • If true the whole data is reversed including labels, the series order as well as the whole series data arrays.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property showLabel

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            showLabel?: boolean;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • Specify if a label should be shown or not

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property startAngle

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            startAngle?: number;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • The start angle of the pie chart in degrees where 0 points north. A higher value offsets the start angle clockwise.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property total

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            total?: number;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • An optional total you can specify. By specifying a total value, the sum of the values in the series must be this total in order to draw a full pie. You can use this parameter to draw only parts of a pie or gauge charts.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property width

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            width?: number | string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • Specify a fixed width for the chart as a string (i.e. '100px' or '50%')

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            interface IResponsiveOptionTuple

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            interface IResponsiveOptionTuple<T extends IChartOptions>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            extends Array<string | T> {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property 0

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              0: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property 1

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                1: T;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  interface IStepAxisStatic

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  interface IStepAxisStatic {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Type Aliases

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    type ChartDrawData

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    type ChartDrawData = IChartDrawLabelData | IChartDrawGridData | IChartDrawBarData;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Package Files (1)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Dependencies (0)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      No dependencies.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Dev Dependencies (0)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      No dev dependencies.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Peer Dependencies (0)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      No peer dependencies.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Badge

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      To add a badge like this onejsDocs.io badgeto 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/@types/chartist.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • Markdown
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        [![jsDocs.io](https://img.shields.io/badge/jsDocs.io-reference-blue)](https://www.jsdocs.io/package/@types/chartist)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • HTML
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        <a href="https://www.jsdocs.io/package/@types/chartist"><img src="https://img.shields.io/badge/jsDocs.io-reference-blue" alt="jsDocs.io"></a>