@antv/g2

  • Version 5.3.3
  • Published
  • 7.97 MB
  • 12 dependencies
  • MIT license

Install

npm i @antv/g2
yarn add @antv/g2
pnpm add @antv/g2

Overview

the Grammar of Graphics in Javascript

Index

Variables

Functions

Classes

Interfaces

Type Aliases

Variables

variable Academy

const Academy: TC<G2Theme>;

    variable AREA_CLASS_NAME

    const AREA_CLASS_NAME: string;

      variable Bin

      const Bin: TC<BinOptions>;
      • The Bin aggregate data. More threshold method. Performance.

      variable BinX

      const BinX: TC<BinXOptions>;

        variable Chart

        const Chart: new (options?: import('./api/runtime').RuntimeOptions) => API<
        G2Spec,
        {
        'data.fetch': import('./runtime').DataComponent<
        import('./data').FetchOptions
        >;
        'data.inline': import('./runtime').DataComponent<
        import('./data').InlineOptions
        >;
        'data.sortBy': import('./runtime').DataComponent<
        import('./data').SortByOptions
        >;
        'data.sort': import('./runtime').DataComponent<import('./data').SortOptions>;
        'data.filter': import('./runtime').DataComponent<
        import('./data').FilterDataOptions
        >;
        'data.pick': import('./runtime').DataComponent<import('./data').PickOptions>;
        'data.rename': import('./runtime').DataComponent<
        import('./data').RenameOptions
        >;
        'data.fold': import('./runtime').DataComponent<import('./data').FoldOptions>;
        'data.slice': import('./runtime').DataComponent<
        import('./data').SliceOptions
        >;
        'data.custom': import('./runtime').DataComponent<
        import('./data').CustomOptions
        >;
        'data.map': import('./runtime').DataComponent<import('./data').MapOptions>;
        'data.join': import('./runtime').DataComponent<import('./data').JoinOptions>;
        'data.kde': import('./runtime').DataComponent<import('./data').KDEOptions>;
        'data.log': import('./runtime').DataComponent<
        import('./data').LogDataOptions
        >;
        'data.wordCloud': import('./runtime').DataComponent<
        Partial<import('./data').WordCloudOptions>
        >;
        'data.ema': import('./runtime').DataComponent<import('./data').EMAOptions>;
        'transform.stackY': import('./runtime').TransformComponent<
        import('./exports').StackYOptions
        >;
        'transform.binX': import('./runtime').TransformComponent<
        import('./exports').BinXOptions
        >;
        'transform.bin': import('./runtime').TransformComponent<
        import('./exports').BinOptions
        >;
        'transform.dodgeX': import('./runtime').TransformComponent<
        import('./exports').DodgeXOptions
        >;
        'transform.jitter': import('./runtime').TransformComponent<
        import('./exports').JitterOptions
        >;
        'transform.jitterX': import('./runtime').TransformComponent<
        import('./exports').JitterXOptions
        >;
        'transform.jitterY': import('./runtime').TransformComponent<
        import('./exports').JitterYOptions
        >;
        'transform.symmetryY': import('./runtime').TransformComponent<
        import('./exports').SymmetryYOptions
        >;
        'transform.diffY': import('./runtime').TransformComponent<
        import('./exports').DiffYOptions
        >;
        'transform.stackEnter': import('./runtime').TransformComponent<
        import('./exports').StackEnterOptions
        >;
        'transform.normalizeY': import('./runtime').TransformComponent<
        import('./exports').NormalizeYOptions
        >;
        'transform.select': import('./runtime').TransformComponent<
        import('./exports').SelectOptions
        >;
        'transform.selectX': import('./runtime').TransformComponent<
        import('./exports').SelectXOptions
        >;
        'transform.selectY': import('./runtime').TransformComponent<
        import('./exports').SelectYOptions
        >;
        'transform.groupX': import('./runtime').TransformComponent<
        import('./exports').GroupXOptions
        >;
        'transform.groupY': import('./runtime').TransformComponent<
        import('./exports').GroupYOptions
        >;
        'transform.groupColor': import('./runtime').TransformComponent<
        import('./exports').GroupColorOptions
        >;
        'transform.group': import('./runtime').TransformComponent<
        import('./exports').GroupOptions
        >;
        'transform.sortX': import('./runtime').TransformComponent<
        import('./exports').SortXOptions
        >;
        'transform.sortY': import('./runtime').TransformComponent<
        import('./exports').SortYOptions
        >;
        'transform.sortColor': import('./runtime').TransformComponent<
        import('./exports').SortColorOptions
        >;
        'transform.flexX': import('./runtime').TransformComponent<
        import('./exports').FlexXOptions
        >;
        'transform.pack': import('./runtime').TransformComponent<
        import('./exports').PackOptions
        >;
        'transform.sample': import('./runtime').TransformComponent<
        import('./exports').SampleOptions
        >;
        'transform.filter': import('./runtime').TransformComponent<
        import('./exports').FilterOptions
        >;
        'coordinate.cartesian': import('./runtime').CoordinateComponent<
        import('./coordinate').CartesianOptions
        >;
        'coordinate.polar': import('./runtime').CoordinateComponent<
        import('./coordinate').PolarOptions
        >;
        'coordinate.transpose': import('./runtime').CoordinateComponent<
        import('./coordinate').TransposeOptions
        >;
        'coordinate.theta': import('./runtime').CoordinateComponent<
        import('./spec').ThetaCoordinate
        >;
        'coordinate.parallel': import('./runtime').CoordinateComponent<
        import('./coordinate').ParallelOptions
        >;
        'coordinate.fisheye': import('./runtime').CoordinateComponent<
        import('./spec').FisheyeCoordinate
        >;
        'coordinate.radial': import('./runtime').CoordinateComponent<
        import('./coordinate').RadialOptions
        >;
        'coordinate.radar': import('./runtime').CoordinateComponent<
        import('./spec').RadarCoordinate
        >;
        'coordinate.helix': import('./runtime').CoordinateComponent<
        import('./spec').HelixCoordinate
        >;
        'encode.constant': import('./runtime').EncodeComponent<
        import('./encode').ConstantOptions
        >;
        'encode.field': import('./runtime').EncodeComponent<
        import('./encode').FieldOptions
        >;
        'encode.transform': import('./runtime').EncodeComponent<
        import('./encode').TransformOptions
        >;
        'encode.column': import('./runtime').EncodeComponent<
        import('./encode').ColumnOptions
        >;
        'mark.interval': import('./exports').MarkComponent<
        import('./mark').IntervalOptions
        >;
        'mark.rect': import('./exports').MarkComponent<import('./mark').RectOptions>;
        'mark.line': import('./exports').MarkComponent<import('./mark').LineOptions>;
        'mark.point': import('./exports').MarkComponent<
        import('./mark').PointOptions
        >;
        'mark.text': import('./exports').MarkComponent<import('./mark').TextOptions>;
        'mark.cell': import('./exports').MarkComponent<import('./mark').CellOptions>;
        'mark.area': import('./exports').MarkComponent<import('./mark').AreaOptions>;
        'mark.link': import('./exports').MarkComponent<import('./mark').LinkOptions>;
        'mark.image': import('./exports').MarkComponent<
        import('./mark').ImageOptions
        >;
        'mark.polygon': import('./exports').MarkComponent<
        import('./mark').PolygonOptions
        >;
        'mark.box': import('./exports').MarkComponent<import('./mark').BoxOptions>;
        'mark.vector': import('./exports').MarkComponent<
        import('./mark').VectorOptions
        >;
        'mark.lineX': import('./exports').MarkComponent<
        import('./mark').LineXOptions
        >;
        'mark.lineY': import('./exports').MarkComponent<
        import('./mark').LineYOptions
        >;
        'mark.connector': import('./exports').MarkComponent<
        import('./mark').ConnectorOptions
        >;
        'mark.range': import('./exports').MarkComponent<
        import('./mark').RangeOptions
        >;
        'mark.rangeX': import('./exports').MarkComponent<
        import('./mark').RangeXOptions
        >;
        'mark.rangeY': import('./exports').MarkComponent<
        import('./mark').RangeYOptions
        >;
        'mark.path': import('./exports').MarkComponent<
        import('./mark/path').PathOptions
        >;
        'mark.shape': import('./exports').MarkComponent<
        import('./mark').ShapeOptions
        >;
        'mark.density': import('./exports').MarkComponent<
        import('./mark').DensityOptions
        >;
        'mark.heatmap': import('./exports').MarkComponent<
        import('./mark').HeatmapOptions
        >;
        'mark.wordCloud': import('./runtime').CompositeMarkComponent<
        import('./mark').WordCloudOptions
        >;
        'palette.category10': import('./runtime').PaletteComponent<
        import('./palette').Category10Options
        >;
        'palette.category20': import('./runtime').PaletteComponent<
        import('./palette').Category20Options
        >;
        'scale.linear': import('./runtime').ScaleComponent<
        import('./scale').LinearOptions
        >;
        'scale.ordinal': import('./runtime').ScaleComponent<
        import('./scale').OrdinalOptions
        >;
        'scale.band': import('./runtime').ScaleComponent<
        import('./scale').BandOptions
        >;
        'scale.identity': import('./runtime').ScaleComponent<
        import('./scale').IdentityOptions
        >;
        'scale.point': import('./runtime').ScaleComponent<
        import('./scale').PointOptions
        >;
        'scale.time': import('./runtime').ScaleComponent<
        import('./scale').TimeOptions
        >;
        'scale.log': import('./runtime').ScaleComponent<
        import('./scale').LogOptions
        >;
        'scale.pow': import('./runtime').ScaleComponent<
        import('./scale').PowOptions
        >;
        'scale.sqrt': import('./runtime').ScaleComponent<
        import('./scale').SqrtOptions
        >;
        'scale.threshold': import('./runtime').ScaleComponent<
        import('./scale').ThresholdOptions
        >;
        'scale.quantile': import('./runtime').ScaleComponent<
        import('./scale').QuantileOptions
        >;
        'scale.quantize': import('./runtime').ScaleComponent<
        import('./scale').QuantizeOptions
        >;
        'scale.sequential': import('./runtime').ScaleComponent<
        import('./scale').SequentialOptions
        >;
        'scale.constant': import('./runtime').ScaleComponent<
        import('./scale').ConstantOptions
        >;
        'theme.classic': import('./runtime').ThemeComponent<
        import('./runtime').G2Theme
        >;
        'theme.classicDark': import('./runtime').ThemeComponent<
        import('./runtime').G2Theme
        >;
        'theme.academy': import('./runtime').ThemeComponent<
        import('./runtime').G2Theme
        >;
        'theme.light': import('./runtime').ThemeComponent<
        import('./runtime').G2Theme
        >;
        'theme.dark': import('./runtime').ThemeComponent<
        import('./runtime').G2Theme
        >;
        'component.axisX': import('./exports').GuideComponentComponent<
        import('./exports').AxisOptions
        >;
        'component.axisY': import('./exports').GuideComponentComponent<
        import('./exports').AxisOptions
        >;
        'component.legendCategory': import('./exports').GuideComponentComponent<
        import('./component').LegendCategoryOptions
        >;
        'component.legendContinuous': import('./exports').GuideComponentComponent<
        import('./component').LegendContinuousOptions
        >;
        'component.legends': import('./exports').GuideComponentComponent<
        import('./component').LegendsOptions
        >;
        'component.title': import('./exports').GuideComponentComponent<
        import('./runtime').G2Title
        >;
        'component.sliderX': import('./exports').GuideComponentComponent<
        import('./component/slider').SliderOptions
        >;
        'component.sliderY': import('./exports').GuideComponentComponent<
        import('./component/slider').SliderOptions
        >;
        'component.scrollbarX': import('./exports').GuideComponentComponent<
        import('./component/scrollbar').ScrollbarOptions
        >;
        'component.scrollbarY': import('./exports').GuideComponentComponent<
        import('./component/scrollbar').ScrollbarOptions
        >;
        'animation.scaleInX': import('./runtime').AnimationComponent<
        import('./animation/types').Animation
        >;
        'animation.scaleOutX': import('./runtime').AnimationComponent<
        import('./animation/types').Animation
        >;
        'animation.scaleInY': import('./runtime').AnimationComponent<
        import('./animation/types').Animation
        >;
        'animation.scaleOutY': import('./runtime').AnimationComponent<
        import('./animation/types').Animation
        >;
        'animation.waveIn': import('./runtime').AnimationComponent<
        import('./animation/types').Animation
        >;
        'animation.fadeIn': import('./runtime').AnimationComponent<
        import('./animation/types').Animation
        >;
        'animation.fadeOut': import('./runtime').AnimationComponent<
        import('./animation/types').Animation
        >;
        'animation.zoomIn': import('./runtime').AnimationComponent<
        import('./animation/types').Animation
        >;
        'animation.zoomOut': import('./runtime').AnimationComponent<
        import('./animation/types').Animation
        >;
        'animation.pathIn': import('./runtime').AnimationComponent<
        import('./animation/types').Animation
        >;
        'animation.morphing': import('./runtime').AnimationComponent<
        import('./animation').MorphingOptions
        >;
        'animation.growInX': import('./runtime').AnimationComponent<
        import('./animation/types').Animation
        >;
        'animation.growInY': import('./runtime').AnimationComponent<
        import('./animation/types').Animation
        >;
        'interaction.elementHighlight': typeof import('./interaction').ElementHighlight;
        'interaction.elementHighlightByX': typeof import('./interaction').ElementHighlightByX;
        'interaction.elementHighlightByColor': typeof import('./interaction').ElementHighlightByColor;
        'interaction.elementSelect': typeof import('./interaction').ElementSelect;
        'interaction.elementSelectByX': typeof import('./interaction').ElementSelectByX;
        'interaction.elementSelectByColor': typeof import('./interaction').ElementSelectByColor;
        'interaction.fisheye': typeof import('./interaction').Fisheye;
        'interaction.chartIndex': typeof import('./interaction').ChartIndex;
        'interaction.tooltip': typeof import('./interaction').Tooltip;
        'interaction.legendFilter': typeof import('./interaction').LegendFilter;
        'interaction.legendHighlight': typeof import('./interaction').LegendHighlight;
        'interaction.brushHighlight': typeof import('./interaction').BrushHighlight;
        'interaction.brushXHighlight': typeof import('./interaction').BrushXHighlight;
        'interaction.brushYHighlight': typeof import('./interaction').BrushYHighlight;
        'interaction.brushAxisHighlight': typeof import('./interaction').BrushAxisHighlight;
        'interaction.brushFilter': typeof import('./interaction').BrushFilter;
        'interaction.brushXFilter': typeof import('./interaction').BrushXFilter;
        'interaction.brushYFilter': typeof import('./interaction').BrushYFilter;
        'interaction.sliderFilter': typeof import('./interaction').SliderFilter;
        'interaction.scrollbarFilter': typeof import('./interaction').ScrollbarFilter;
        'interaction.poptip': typeof import('./interaction').Poptip;
        'interaction.treemapDrillDown': typeof import('./interaction').TreemapDrillDown;
        'interaction.elementPointMove': typeof import('./interaction').ElementPointMove;
        'composition.spaceLayer': import('./runtime').CompositionComponent<
        import('./composition').SpaceLayerOptions
        >;
        'composition.spaceFlex': import('./runtime').CompositionComponent<
        import('./composition').SpaceFlexOptions
        >;
        'composition.facetRect': import('./runtime').CompositionComponent<
        import('./composition').FacetRectOptions
        >;
        'composition.repeatMatrix': import('./runtime').CompositionComponent<
        import('./spec').RepeatMatrixComposition
        >;
        'composition.facetCircle': import('./runtime').CompositionComponent<
        import('./spec').FacetCircleComposition
        >;
        'composition.timingKeyframe': import('./runtime').CompositionComponent<
        import('./composition').TimingKeyframeOptions
        >;
        'labelTransform.overlapHide': import('./runtime').LabelTransformComponent<
        import('./label-transform').OverlapHideOptions
        >;
        'labelTransform.overlapDodgeY': import('./runtime').LabelTransformComponent<
        import('./label-transform').OverlapDodgeYOptions
        >;
        'labelTransform.overflowHide': import('./runtime').LabelTransformComponent<
        import('./label-transform').OverflowHideOptions
        >;
        'labelTransform.contrastReverse': import('./runtime').LabelTransformComponent<
        import('./label-transform').ContrastReverseOptions
        >;
        'labelTransform.exceedAdjust': import('./runtime').LabelTransformComponent<
        import('./label-transform').ExceedAdjustOptions
        >;
        'data.venn': import('./runtime').DataComponent<import('./data').VennOptions>;
        'mark.boxplot': import('./runtime').CompositeMarkComponent<
        import('./mark/boxplot').BoxPlotOptions
        >;
        'mark.gauge': import('./runtime').CompositeMarkComponent<
        import('./mark').GaugeOptions
        >;
        'mark.liquid': import('./runtime').CompositeMarkComponent<
        import('./mark').LiquidOptions
        >;
        'data.arc': import('./runtime').DataComponent<import('./data').ArcOptions>;
        'data.cluster': import('./runtime').DataComponent<
        import('./data').ClusterOptions
        >;
        'mark.forceGraph': import('./runtime').CompositeMarkComponent<
        import('./mark').ForceGraphOptions
        >;
        'mark.tree': import('./runtime').CompositeMarkComponent<
        import('./mark').TreeOptions
        >;
        'mark.pack': import('./runtime').CompositionComponent<
        import('./mark').PackOptions
        >;
        'mark.sankey': import('./runtime').CompositeMarkComponent<
        import('./mark').SankeyOptions
        >;
        'mark.chord': import('./runtime').CompositeMarkComponent<
        import('./mark').ChordOptions
        >;
        'mark.treemap': import('./runtime').CompositionComponent<
        import('./mark').TreemapOptions
        >;
        'composition.geoView': import('./runtime').CompositionComponent<
        import('./composition/geoView').GeoViewOptions
        >;
        'composition.geoPath': import('./runtime').CompositionComponent<
        import('./composition/geoPath').GeoPathOptions
        >;
        }
        >;

          variable ChartEvent

          const ChartEvent: {
          BEFORE_RENDER: string;
          AFTER_RENDER: string;
          BEFORE_PAINT: string;
          AFTER_PAINT: string;
          BEFORE_CHANGE_DATA: string;
          AFTER_CHANGE_DATA: string;
          BEFORE_CLEAR: string;
          AFTER_CLEAR: string;
          BEFORE_DESTROY: string;
          AFTER_DESTROY: string;
          BEFORE_CHANGE_SIZE: string;
          AFTER_CHANGE_SIZE: string;
          POINTER_TAP: string;
          POINTER_DOWN: string;
          POINTER_UP: string;
          POINTER_OVER: string;
          POINTER_OUT: string;
          POINTER_MOVE: string;
          POINTER_ENTER: string;
          POINTER_LEAVE: string;
          POINTER_UPOUTSIDE: string;
          DRAG_START: string;
          DRAG: string;
          DRAG_END: string;
          DRAG_ENTER: string;
          DRAG_LEAVE: string;
          DRAG_OVER: string;
          DROP: string;
          CLICK: string;
          DBLCLICK: string;
          };

            variable Classic

            const Classic: TC<G2Theme>;
            • Default theme.

            variable ClassicDark

            const ClassicDark: TC<G2Theme>;
            • Dark theme.

            variable COMPONENT_CLASS_NAME

            const COMPONENT_CLASS_NAME: string;

              variable Dark

              const Dark: TC<G2Theme>;

                variable DiffY

                const DiffY: TC<DiffYOptions>;
                • The DiffY transform apply offset for y0 channels. Keep y unchanged, set y1 = max(otherY), if y1 > y, remove the data.

                variable DodgeX

                const DodgeX: TC<DodgeXOptions>;
                • The dodge group marks into series by color or series channel, and then produce new series channel for each series by specified order, say to form horizontal "columns" by specified channels.

                variable ELEMENT_CLASS_NAME

                const ELEMENT_CLASS_NAME: string;

                  variable Filter

                  const Filter: TC<FilterOptions>;
                  • The Filter transform filter channels.

                  variable FlexX

                  const FlexX: TC<FlexXOptions>;
                  • Produce flex options from data for x scale.

                  variable Group

                  const Group: TC<GroupOptions>;
                  • The Group transform group data by x and y channels, and aggregate.

                  variable GroupColor

                  const GroupColor: TC<GroupColorOptions>;
                  • The GroupColor transform group data by x channel, and aggregate.

                  variable GroupX

                  const GroupX: TC<GroupXOptions>;
                  • The GroupX transform group data by x channel, and aggregate.

                  variable GroupY

                  const GroupY: TC<GroupYOptions>;
                  • The GroupY transform group data by x channel, and aggregate.

                  variable Jitter

                  const Jitter: TC<JitterOptions>;
                  • The jitter transform produce dx and dy channels for marks (especially for point) with ordinal x and y dimension, say to make them jitter in their own space.

                  variable JitterX

                  const JitterX: TC<JitterXOptions>;
                  • The JitterX transform produce dy channels for marks (especially for point) with ordinal x and y dimension, say to make them jitter in their own space.

                  variable JitterY

                  const JitterY: TC<JitterYOptions>;
                  • The JitterY transform produce dy channels for marks (especially for point) with ordinal x and y dimension, say to make them jitter in their own space.

                  variable LABEL_CLASS_NAME

                  const LABEL_CLASS_NAME: string;

                    variable LABEL_LAYER_CLASS_NAME

                    const LABEL_LAYER_CLASS_NAME: string;

                      variable library

                      const library: {
                      'data.fetch': import('./runtime').DataComponent<import('./data').FetchOptions>;
                      'data.inline': import('./runtime').DataComponent<import('./data').InlineOptions>;
                      'data.sortBy': import('./runtime').DataComponent<import('./data').SortByOptions>;
                      'data.sort': import('./runtime').DataComponent<import('./data').SortOptions>;
                      'data.filter': import('./runtime').DataComponent<
                      import('./data').FilterDataOptions
                      >;
                      'data.pick': import('./runtime').DataComponent<import('./data').PickOptions>;
                      'data.rename': import('./runtime').DataComponent<import('./data').RenameOptions>;
                      'data.fold': import('./runtime').DataComponent<import('./data').FoldOptions>;
                      'data.slice': import('./runtime').DataComponent<import('./data').SliceOptions>;
                      'data.custom': import('./runtime').DataComponent<import('./data').CustomOptions>;
                      'data.map': import('./runtime').DataComponent<import('./data').MapOptions>;
                      'data.join': import('./runtime').DataComponent<import('./data').JoinOptions>;
                      'data.kde': import('./runtime').DataComponent<import('./data').KDEOptions>;
                      'data.log': import('./runtime').DataComponent<import('./data').LogDataOptions>;
                      'data.wordCloud': import('./runtime').DataComponent<
                      Partial<import('./data').WordCloudOptions>
                      >;
                      'data.ema': import('./runtime').DataComponent<import('./data').EMAOptions>;
                      'transform.stackY': import('./runtime').TransformComponent<
                      import('./exports').StackYOptions
                      >;
                      'transform.binX': import('./runtime').TransformComponent<
                      import('./exports').BinXOptions
                      >;
                      'transform.bin': import('./runtime').TransformComponent<
                      import('./exports').BinOptions
                      >;
                      'transform.dodgeX': import('./runtime').TransformComponent<
                      import('./exports').DodgeXOptions
                      >;
                      'transform.jitter': import('./runtime').TransformComponent<
                      import('./exports').JitterOptions
                      >;
                      'transform.jitterX': import('./runtime').TransformComponent<
                      import('./exports').JitterXOptions
                      >;
                      'transform.jitterY': import('./runtime').TransformComponent<
                      import('./exports').JitterYOptions
                      >;
                      'transform.symmetryY': import('./runtime').TransformComponent<
                      import('./exports').SymmetryYOptions
                      >;
                      'transform.diffY': import('./runtime').TransformComponent<
                      import('./exports').DiffYOptions
                      >;
                      'transform.stackEnter': import('./runtime').TransformComponent<
                      import('./exports').StackEnterOptions
                      >;
                      'transform.normalizeY': import('./runtime').TransformComponent<
                      import('./exports').NormalizeYOptions
                      >;
                      'transform.select': import('./runtime').TransformComponent<
                      import('./exports').SelectOptions
                      >;
                      'transform.selectX': import('./runtime').TransformComponent<
                      import('./exports').SelectXOptions
                      >;
                      'transform.selectY': import('./runtime').TransformComponent<
                      import('./exports').SelectYOptions
                      >;
                      'transform.groupX': import('./runtime').TransformComponent<
                      import('./exports').GroupXOptions
                      >;
                      'transform.groupY': import('./runtime').TransformComponent<
                      import('./exports').GroupYOptions
                      >;
                      'transform.groupColor': import('./runtime').TransformComponent<
                      import('./exports').GroupColorOptions
                      >;
                      'transform.group': import('./runtime').TransformComponent<
                      import('./exports').GroupOptions
                      >;
                      'transform.sortX': import('./runtime').TransformComponent<
                      import('./exports').SortXOptions
                      >;
                      'transform.sortY': import('./runtime').TransformComponent<
                      import('./exports').SortYOptions
                      >;
                      'transform.sortColor': import('./runtime').TransformComponent<
                      import('./exports').SortColorOptions
                      >;
                      'transform.flexX': import('./runtime').TransformComponent<
                      import('./exports').FlexXOptions
                      >;
                      'transform.pack': import('./runtime').TransformComponent<
                      import('./exports').PackOptions
                      >;
                      'transform.sample': import('./runtime').TransformComponent<
                      import('./exports').SampleOptions
                      >;
                      'transform.filter': import('./runtime').TransformComponent<
                      import('./exports').FilterOptions
                      >;
                      'coordinate.cartesian': import('./runtime').CoordinateComponent<
                      import('./coordinate').CartesianOptions
                      >;
                      'coordinate.polar': import('./runtime').CoordinateComponent<
                      import('./coordinate').PolarOptions
                      >;
                      'coordinate.transpose': import('./runtime').CoordinateComponent<
                      import('./coordinate').TransposeOptions
                      >;
                      'coordinate.theta': import('./runtime').CoordinateComponent<
                      import('./spec').ThetaCoordinate
                      >;
                      'coordinate.parallel': import('./runtime').CoordinateComponent<
                      import('./coordinate').ParallelOptions
                      >;
                      'coordinate.fisheye': import('./runtime').CoordinateComponent<
                      import('./spec').FisheyeCoordinate
                      >;
                      'coordinate.radial': import('./runtime').CoordinateComponent<
                      import('./coordinate').RadialOptions
                      >;
                      'coordinate.radar': import('./runtime').CoordinateComponent<
                      import('./spec').RadarCoordinate
                      >;
                      'coordinate.helix': import('./runtime').CoordinateComponent<
                      import('./spec').HelixCoordinate
                      >;
                      'encode.constant': import('./runtime').EncodeComponent<
                      import('./encode').ConstantOptions
                      >;
                      'encode.field': import('./runtime').EncodeComponent<
                      import('./encode').FieldOptions
                      >;
                      'encode.transform': import('./runtime').EncodeComponent<
                      import('./encode').TransformOptions
                      >;
                      'encode.column': import('./runtime').EncodeComponent<
                      import('./encode').ColumnOptions
                      >;
                      'mark.interval': import('./exports').MarkComponent<
                      import('./mark').IntervalOptions
                      >;
                      'mark.rect': import('./exports').MarkComponent<import('./mark').RectOptions>;
                      'mark.line': import('./exports').MarkComponent<import('./mark').LineOptions>;
                      'mark.point': import('./exports').MarkComponent<import('./mark').PointOptions>;
                      'mark.text': import('./exports').MarkComponent<import('./mark').TextOptions>;
                      'mark.cell': import('./exports').MarkComponent<import('./mark').CellOptions>;
                      'mark.area': import('./exports').MarkComponent<import('./mark').AreaOptions>;
                      'mark.link': import('./exports').MarkComponent<import('./mark').LinkOptions>;
                      'mark.image': import('./exports').MarkComponent<import('./mark').ImageOptions>;
                      'mark.polygon': import('./exports').MarkComponent<
                      import('./mark').PolygonOptions
                      >;
                      'mark.box': import('./exports').MarkComponent<import('./mark').BoxOptions>;
                      'mark.vector': import('./exports').MarkComponent<import('./mark').VectorOptions>;
                      'mark.lineX': import('./exports').MarkComponent<import('./mark').LineXOptions>;
                      'mark.lineY': import('./exports').MarkComponent<import('./mark').LineYOptions>;
                      'mark.connector': import('./exports').MarkComponent<
                      import('./mark').ConnectorOptions
                      >;
                      'mark.range': import('./exports').MarkComponent<import('./mark').RangeOptions>;
                      'mark.rangeX': import('./exports').MarkComponent<import('./mark').RangeXOptions>;
                      'mark.rangeY': import('./exports').MarkComponent<import('./mark').RangeYOptions>;
                      'mark.path': import('./exports').MarkComponent<
                      import('./mark/path').PathOptions
                      >;
                      'mark.shape': import('./exports').MarkComponent<import('./mark').ShapeOptions>;
                      'mark.density': import('./exports').MarkComponent<
                      import('./mark').DensityOptions
                      >;
                      'mark.heatmap': import('./exports').MarkComponent<
                      import('./mark').HeatmapOptions
                      >;
                      'mark.wordCloud': import('./runtime').CompositeMarkComponent<
                      import('./mark').WordCloudOptions
                      >;
                      'palette.category10': import('./runtime').PaletteComponent<
                      import('./palette').Category10Options
                      >;
                      'palette.category20': import('./runtime').PaletteComponent<
                      import('./palette').Category20Options
                      >;
                      'scale.linear': import('./runtime').ScaleComponent<
                      import('./scale').LinearOptions
                      >;
                      'scale.ordinal': import('./runtime').ScaleComponent<
                      import('./scale').OrdinalOptions
                      >;
                      'scale.band': import('./runtime').ScaleComponent<import('./scale').BandOptions>;
                      'scale.identity': import('./runtime').ScaleComponent<
                      import('./scale').IdentityOptions
                      >;
                      'scale.point': import('./runtime').ScaleComponent<
                      import('./scale').PointOptions
                      >;
                      'scale.time': import('./runtime').ScaleComponent<import('./scale').TimeOptions>;
                      'scale.log': import('./runtime').ScaleComponent<import('./scale').LogOptions>;
                      'scale.pow': import('./runtime').ScaleComponent<import('./scale').PowOptions>;
                      'scale.sqrt': import('./runtime').ScaleComponent<import('./scale').SqrtOptions>;
                      'scale.threshold': import('./runtime').ScaleComponent<
                      import('./scale').ThresholdOptions
                      >;
                      'scale.quantile': import('./runtime').ScaleComponent<
                      import('./scale').QuantileOptions
                      >;
                      'scale.quantize': import('./runtime').ScaleComponent<
                      import('./scale').QuantizeOptions
                      >;
                      'scale.sequential': import('./runtime').ScaleComponent<
                      import('./scale').SequentialOptions
                      >;
                      'scale.constant': import('./runtime').ScaleComponent<
                      import('./scale').ConstantOptions
                      >;
                      'theme.classic': import('./runtime').ThemeComponent<import('./runtime').G2Theme>;
                      'theme.classicDark': import('./runtime').ThemeComponent<
                      import('./runtime').G2Theme
                      >;
                      'theme.academy': import('./runtime').ThemeComponent<import('./runtime').G2Theme>;
                      'theme.light': import('./runtime').ThemeComponent<import('./runtime').G2Theme>;
                      'theme.dark': import('./runtime').ThemeComponent<import('./runtime').G2Theme>;
                      'component.axisX': import('./exports').GuideComponentComponent<
                      import('./exports').AxisOptions
                      >;
                      'component.axisY': import('./exports').GuideComponentComponent<
                      import('./exports').AxisOptions
                      >;
                      'component.legendCategory': import('./exports').GuideComponentComponent<
                      import('./component').LegendCategoryOptions
                      >;
                      'component.legendContinuous': import('./exports').GuideComponentComponent<
                      import('./component').LegendContinuousOptions
                      >;
                      'component.legends': import('./exports').GuideComponentComponent<
                      import('./component').LegendsOptions
                      >;
                      'component.title': import('./exports').GuideComponentComponent<
                      import('./runtime').G2Title
                      >;
                      'component.sliderX': import('./exports').GuideComponentComponent<
                      import('./component/slider').SliderOptions
                      >;
                      'component.sliderY': import('./exports').GuideComponentComponent<
                      import('./component/slider').SliderOptions
                      >;
                      'component.scrollbarX': import('./exports').GuideComponentComponent<
                      import('./component/scrollbar').ScrollbarOptions
                      >;
                      'component.scrollbarY': import('./exports').GuideComponentComponent<
                      import('./component/scrollbar').ScrollbarOptions
                      >;
                      'animation.scaleInX': import('./runtime').AnimationComponent<
                      import('./animation/types').Animation
                      >;
                      'animation.scaleOutX': import('./runtime').AnimationComponent<
                      import('./animation/types').Animation
                      >;
                      'animation.scaleInY': import('./runtime').AnimationComponent<
                      import('./animation/types').Animation
                      >;
                      'animation.scaleOutY': import('./runtime').AnimationComponent<
                      import('./animation/types').Animation
                      >;
                      'animation.waveIn': import('./runtime').AnimationComponent<
                      import('./animation/types').Animation
                      >;
                      'animation.fadeIn': import('./runtime').AnimationComponent<
                      import('./animation/types').Animation
                      >;
                      'animation.fadeOut': import('./runtime').AnimationComponent<
                      import('./animation/types').Animation
                      >;
                      'animation.zoomIn': import('./runtime').AnimationComponent<
                      import('./animation/types').Animation
                      >;
                      'animation.zoomOut': import('./runtime').AnimationComponent<
                      import('./animation/types').Animation
                      >;
                      'animation.pathIn': import('./runtime').AnimationComponent<
                      import('./animation/types').Animation
                      >;
                      'animation.morphing': import('./runtime').AnimationComponent<
                      import('./animation').MorphingOptions
                      >;
                      'animation.growInX': import('./runtime').AnimationComponent<
                      import('./animation/types').Animation
                      >;
                      'animation.growInY': import('./runtime').AnimationComponent<
                      import('./animation/types').Animation
                      >;
                      'interaction.elementHighlight': typeof import('./interaction').ElementHighlight;
                      'interaction.elementHighlightByX': typeof import('./interaction').ElementHighlightByX;
                      'interaction.elementHighlightByColor': typeof import('./interaction').ElementHighlightByColor;
                      'interaction.elementSelect': typeof import('./interaction').ElementSelect;
                      'interaction.elementSelectByX': typeof import('./interaction').ElementSelectByX;
                      'interaction.elementSelectByColor': typeof import('./interaction').ElementSelectByColor;
                      'interaction.fisheye': typeof import('./interaction').Fisheye;
                      'interaction.chartIndex': typeof import('./interaction').ChartIndex;
                      'interaction.tooltip': typeof import('./interaction').Tooltip;
                      'interaction.legendFilter': typeof import('./interaction').LegendFilter;
                      'interaction.legendHighlight': typeof import('./interaction').LegendHighlight;
                      'interaction.brushHighlight': typeof import('./interaction').BrushHighlight;
                      'interaction.brushXHighlight': typeof import('./interaction').BrushXHighlight;
                      'interaction.brushYHighlight': typeof import('./interaction').BrushYHighlight;
                      'interaction.brushAxisHighlight': typeof import('./interaction').BrushAxisHighlight;
                      'interaction.brushFilter': typeof import('./interaction').BrushFilter;
                      'interaction.brushXFilter': typeof import('./interaction').BrushXFilter;
                      'interaction.brushYFilter': typeof import('./interaction').BrushYFilter;
                      'interaction.sliderFilter': typeof import('./interaction').SliderFilter;
                      'interaction.scrollbarFilter': typeof import('./interaction').ScrollbarFilter;
                      'interaction.poptip': typeof import('./interaction').Poptip;
                      'interaction.treemapDrillDown': typeof import('./interaction').TreemapDrillDown;
                      'interaction.elementPointMove': typeof import('./interaction').ElementPointMove;
                      'composition.spaceLayer': import('./runtime').CompositionComponent<
                      import('./composition').SpaceLayerOptions
                      >;
                      'composition.spaceFlex': import('./runtime').CompositionComponent<
                      import('./composition').SpaceFlexOptions
                      >;
                      'composition.facetRect': import('./runtime').CompositionComponent<
                      import('./composition').FacetRectOptions
                      >;
                      'composition.repeatMatrix': import('./runtime').CompositionComponent<
                      import('./spec').RepeatMatrixComposition
                      >;
                      'composition.facetCircle': import('./runtime').CompositionComponent<
                      import('./spec').FacetCircleComposition
                      >;
                      'composition.timingKeyframe': import('./runtime').CompositionComponent<
                      import('./composition').TimingKeyframeOptions
                      >;
                      'labelTransform.overlapHide': import('./runtime').LabelTransformComponent<
                      import('./label-transform').OverlapHideOptions
                      >;
                      'labelTransform.overlapDodgeY': import('./runtime').LabelTransformComponent<
                      import('./label-transform').OverlapDodgeYOptions
                      >;
                      'labelTransform.overflowHide': import('./runtime').LabelTransformComponent<
                      import('./label-transform').OverflowHideOptions
                      >;
                      'labelTransform.contrastReverse': import('./runtime').LabelTransformComponent<
                      import('./label-transform').ContrastReverseOptions
                      >;
                      'labelTransform.exceedAdjust': import('./runtime').LabelTransformComponent<
                      import('./label-transform').ExceedAdjustOptions
                      >;
                      'data.venn': import('./runtime').DataComponent<import('./data').VennOptions>;
                      'mark.boxplot': import('./runtime').CompositeMarkComponent<
                      import('./mark/boxplot').BoxPlotOptions
                      >;
                      'mark.gauge': import('./runtime').CompositeMarkComponent<
                      import('./mark').GaugeOptions
                      >;
                      'mark.liquid': import('./runtime').CompositeMarkComponent<
                      import('./mark').LiquidOptions
                      >;
                      'data.arc': import('./runtime').DataComponent<import('./data').ArcOptions>;
                      'data.cluster': import('./runtime').DataComponent<
                      import('./data').ClusterOptions
                      >;
                      'mark.forceGraph': import('./runtime').CompositeMarkComponent<
                      import('./mark').ForceGraphOptions
                      >;
                      'mark.tree': import('./runtime').CompositeMarkComponent<
                      import('./mark').TreeOptions
                      >;
                      'mark.pack': import('./runtime').CompositionComponent<
                      import('./mark').PackOptions
                      >;
                      'mark.sankey': import('./runtime').CompositeMarkComponent<
                      import('./mark').SankeyOptions
                      >;
                      'mark.chord': import('./runtime').CompositeMarkComponent<
                      import('./mark').ChordOptions
                      >;
                      'mark.treemap': import('./runtime').CompositionComponent<
                      import('./mark').TreemapOptions
                      >;
                      'composition.geoView': import('./runtime').CompositionComponent<
                      import('./composition/geoView').GeoViewOptions
                      >;
                      'composition.geoPath': import('./runtime').CompositionComponent<
                      import('./composition/geoPath').GeoPathOptions
                      >;
                      };
                      • G2 standard library initial all the libs except 3D and auto.

                      variable Light

                      const Light: TC<G2Theme>;
                      • Default theme.

                      variable LinearAxis

                      const LinearAxis: GCC<AxisOptions>;

                        variable MAIN_LAYER_CLASS_NAME

                        const MAIN_LAYER_CLASS_NAME: string;

                          variable MASK_CLASS_NAME

                          const MASK_CLASS_NAME: string;

                            variable MaybeDefaultX

                            const MaybeDefaultX: TC<MaybeDefaultXOptions>;
                            • Add a default encode for rangeX when data is just an array

                            variable MaybeDefaultY

                            const MaybeDefaultY: TC<MaybeDefaultYOptions>;
                            • Add a default encode for rangeY when data is just an array

                            variable MaybeFunctionAttribute

                            const MaybeFunctionAttribute: TC<MaybeFunctionAttributeOptions>;
                            • Mark functional attribute constant.

                            variable MaybeGradient

                            const MaybeGradient: TC<MaybeGradientOptions>;
                            • Add 3 constant encode for size channel. This is useful for point geometry.

                            variable MaybeIdentityX

                            const MaybeIdentityX: TC<MaybeIdentityXOptions>;
                            • Add 3 constant encode for size channel. This is useful for point geometry.

                            variable MaybeIdentityY

                            const MaybeIdentityY: TC<MaybeIdentityYOptions>;
                            • Add 3 constant encode for size channel. This is useful for point geometry.

                            variable MaybeKey

                            const MaybeKey: TC<MaybeKeyOptions>;
                            • Infer key for every element.

                            variable MaybeSeries

                            const MaybeSeries: TC<MaybeSeriesOptions>;
                            • Assume color channel is series channel.

                            variable MaybeSize

                            const MaybeSize: TC<MaybeSizeOptions>;
                            • Add 3 constant encode for size channel. This is useful for point geometry.

                            variable MaybeStackY

                            const MaybeStackY: TC<MaybeStackYOptions>;
                            • Add zero constant encode for x channel. This is useful for interval geometry.

                            variable MaybeTitle

                            const MaybeTitle: TC<MaybeTitleOptions>;
                            • Infer title channel from x-position channel.

                            variable MaybeTooltip

                            const MaybeTooltip: TC<MaybeTooltipOptions>;
                            • Infer tooltip channel from specified channel.

                            variable MaybeTuple

                            const MaybeTuple: TC<MaybeTupleOptions>;
                            • Add 3 constant encode for size channel. This is useful for point geometry.

                            variable MaybeTupleX

                            const MaybeTupleX: TC<MaybeTupleXOptions>;
                            • Add 3 constant encode for size channel. This is useful for point geometry.

                            variable MaybeTupleY

                            const MaybeTupleY: TC<MaybeTupleYOptions>;
                            • Add 3 constant encode for size channel. This is useful for point geometry.

                            variable MaybeVisualPosition

                            const MaybeVisualPosition: TC<MaybeVisualPositionOptions>;
                            • Set visual position with style.x and style.y. The priority of style.x, style.y is higher than data.

                            variable MaybeZeroPadding

                            const MaybeZeroPadding: TC<MaybeZeroPaddingOptions>;
                            • Set padding of x and y scale to zero.

                            variable MaybeZeroX

                            const MaybeZeroX: TC<MaybeZeroXOptions>;
                            • Add zero constant encode for x channel. This is useful for interval geometry.

                            variable MaybeZeroY

                            const MaybeZeroY: TC<MaybeZeroYOptions>;
                            • Add zero constant encode for y channel.

                            variable MaybeZeroY1

                            const MaybeZeroY1: TC<MaybeZeroY1Options>;
                            • Add zero constant encode for y1 channel.

                            variable MaybeZeroZ

                            const MaybeZeroZ: TC<MaybeZeroZOptions>;
                            • Add zero constant encode for z channel.

                            variable NormalizeY

                            const NormalizeY: TC<NormalizeYOptions>;
                            • Group marks into series by specified channels, and then transform each series's value, say to transform them relative to some basis to apply a moving average.

                            variable Pack

                            const Pack: TC<PackOptions>;
                            • Uniform pack to avid overlap. Improve or change algorithm to increase space usage. Take some special case into account.

                            variable PLOT_CLASS_NAME

                            const PLOT_CLASS_NAME: string;

                              variable Sample

                              const Sample: TC<SampleOptions>;
                              • The sample transform groups marks with specified groupBy fields, and sample data for each group when data.length >= threshold(default = 2000).

                              variable Select

                              const Select: TC<SelectOptions>;
                              • The select transform groups marks with specified channels, and filter index by specified selector for each series, say to pull a single or multiple values out of each series.

                              variable SelectX

                              const SelectX: TC<SelectXOptions>;
                              • The selectX transform filter index by y channel.

                              variable SelectY

                              const SelectY: TC<SelectYOptions>;
                              • The selectY transform filter index by y channel.

                              variable SortColor

                              const SortColor: TC<SortColorOptions>;
                              • Sort domain of x scale of mark groups by groups.

                              variable SortX

                              const SortX: TC<SortXOptions>;
                              • Sort domain of x scale of mark groups by groups.

                              variable SortY

                              const SortY: TC<SortYOptions>;
                              • Sort domain of x scale of mark groups by groups.

                              variable StackEnter

                              const StackEnter: TC<StackEnterOptions>;
                              • Group marks by channels into groups and stacking their enterDelay to make marks show up groups by groups. It will update enterDelay channel for each mark by its enterDuration and group. Support orderBy. Sort among groups(e.g. reverse). Stack enter in groups rather than between groups? Auto inter this statistic for scaleInY animation in stacked interval? All the groups shared the enterDuration?

                              variable StackY

                              const StackY: TC<StackYOptions>;
                              • The stack transform group marks into series by color channel, and then produce new y channel for each series by specified order, say to form vertical "stacks" by specified channels.

                              variable SymmetryY

                              const SymmetryY: TC<SymmetryYOptions>;
                              • The SymmetryY transform apply offset for y channels, say to transform them to be symmetry.

                              variable VIEW_CLASS_NAME

                              const VIEW_CLASS_NAME: string;

                                Functions

                                function corelib

                                corelib: () => {
                                readonly 'data.fetch': import('../runtime').DataComponent<
                                import('../data').FetchOptions
                                >;
                                readonly 'data.inline': import('../runtime').DataComponent<
                                import('../data').InlineOptions
                                >;
                                readonly 'data.sortBy': import('../runtime').DataComponent<
                                import('../data').SortByOptions
                                >;
                                readonly 'data.sort': import('../runtime').DataComponent<
                                import('../data').SortOptions
                                >;
                                readonly 'data.filter': import('../runtime').DataComponent<
                                import('../data').FilterDataOptions
                                >;
                                readonly 'data.pick': import('../runtime').DataComponent<
                                import('../data').PickOptions
                                >;
                                readonly 'data.rename': import('../runtime').DataComponent<
                                import('../data').RenameOptions
                                >;
                                readonly 'data.fold': import('../runtime').DataComponent<
                                import('../data').FoldOptions
                                >;
                                readonly 'data.slice': import('../runtime').DataComponent<
                                import('../data').SliceOptions
                                >;
                                readonly 'data.custom': import('../runtime').DataComponent<
                                import('../data').CustomOptions
                                >;
                                readonly 'data.map': import('../runtime').DataComponent<
                                import('../data').MapOptions
                                >;
                                readonly 'data.join': import('../runtime').DataComponent<
                                import('../data').JoinOptions
                                >;
                                readonly 'data.kde': import('../runtime').DataComponent<
                                import('../data').KDEOptions
                                >;
                                readonly 'data.log': import('../runtime').DataComponent<
                                import('../data').LogDataOptions
                                >;
                                readonly 'data.wordCloud': import('../runtime').DataComponent<
                                Partial<import('../data').WordCloudOptions>
                                >;
                                readonly 'data.ema': import('../runtime').DataComponent<
                                import('../data').EMAOptions
                                >;
                                readonly 'transform.stackY': import('../runtime').TransformComponent<
                                import('../transform').StackYOptions
                                >;
                                readonly 'transform.binX': import('../runtime').TransformComponent<
                                import('../transform').BinXOptions
                                >;
                                readonly 'transform.bin': import('../runtime').TransformComponent<
                                import('../transform').BinOptions
                                >;
                                readonly 'transform.dodgeX': import('../runtime').TransformComponent<
                                import('../transform').DodgeXOptions
                                >;
                                readonly 'transform.jitter': import('../runtime').TransformComponent<
                                import('../transform').JitterOptions
                                >;
                                readonly 'transform.jitterX': import('../runtime').TransformComponent<
                                import('../transform').JitterXOptions
                                >;
                                readonly 'transform.jitterY': import('../runtime').TransformComponent<
                                import('../transform').JitterYOptions
                                >;
                                readonly 'transform.symmetryY': import('../runtime').TransformComponent<
                                import('../transform').SymmetryYOptions
                                >;
                                readonly 'transform.diffY': import('../runtime').TransformComponent<
                                import('../transform').DiffYOptions
                                >;
                                readonly 'transform.stackEnter': import('../runtime').TransformComponent<
                                import('../transform').StackEnterOptions
                                >;
                                readonly 'transform.normalizeY': import('../runtime').TransformComponent<
                                import('../transform').NormalizeYOptions
                                >;
                                readonly 'transform.select': import('../runtime').TransformComponent<
                                import('../transform').SelectOptions
                                >;
                                readonly 'transform.selectX': import('../runtime').TransformComponent<
                                import('../transform').SelectXOptions
                                >;
                                readonly 'transform.selectY': import('../runtime').TransformComponent<
                                import('../transform').SelectYOptions
                                >;
                                readonly 'transform.groupX': import('../runtime').TransformComponent<
                                import('../transform').GroupXOptions
                                >;
                                readonly 'transform.groupY': import('../runtime').TransformComponent<
                                import('../transform').GroupYOptions
                                >;
                                readonly 'transform.groupColor': import('../runtime').TransformComponent<
                                import('../transform').GroupColorOptions
                                >;
                                readonly 'transform.group': import('../runtime').TransformComponent<
                                import('../transform').GroupOptions
                                >;
                                readonly 'transform.sortX': import('../runtime').TransformComponent<
                                import('../transform').SortXOptions
                                >;
                                readonly 'transform.sortY': import('../runtime').TransformComponent<
                                import('../transform').SortYOptions
                                >;
                                readonly 'transform.sortColor': import('../runtime').TransformComponent<
                                import('../transform').SortColorOptions
                                >;
                                readonly 'transform.flexX': import('../runtime').TransformComponent<
                                import('../transform').FlexXOptions
                                >;
                                readonly 'transform.pack': import('../runtime').TransformComponent<
                                import('../transform').PackOptions
                                >;
                                readonly 'transform.sample': import('../runtime').TransformComponent<
                                import('../transform').SampleOptions
                                >;
                                readonly 'transform.filter': import('../runtime').TransformComponent<
                                import('../transform').FilterOptions
                                >;
                                readonly 'coordinate.cartesian': import('../runtime').CoordinateComponent<
                                import('../coordinate').CartesianOptions
                                >;
                                readonly 'coordinate.polar': import('../runtime').CoordinateComponent<
                                import('../coordinate').PolarOptions
                                >;
                                readonly 'coordinate.transpose': import('../runtime').CoordinateComponent<
                                import('../coordinate').TransposeOptions
                                >;
                                readonly 'coordinate.theta': import('../runtime').CoordinateComponent<
                                import('..').ThetaCoordinate
                                >;
                                readonly 'coordinate.parallel': import('../runtime').CoordinateComponent<
                                import('../coordinate').ParallelOptions
                                >;
                                readonly 'coordinate.fisheye': import('../runtime').CoordinateComponent<
                                import('..').FisheyeCoordinate
                                >;
                                readonly 'coordinate.radial': import('../runtime').CoordinateComponent<
                                import('../coordinate').RadialOptions
                                >;
                                readonly 'coordinate.radar': import('../runtime').CoordinateComponent<
                                import('..').RadarCoordinate
                                >;
                                readonly 'coordinate.helix': import('../runtime').CoordinateComponent<
                                import('..').HelixCoordinate
                                >;
                                readonly 'encode.constant': import('../runtime').EncodeComponent<
                                import('../encode').ConstantOptions
                                >;
                                readonly 'encode.field': import('../runtime').EncodeComponent<
                                import('../encode').FieldOptions
                                >;
                                readonly 'encode.transform': import('../runtime').EncodeComponent<
                                import('../encode').TransformOptions
                                >;
                                readonly 'encode.column': import('../runtime').EncodeComponent<
                                import('../encode').ColumnOptions
                                >;
                                readonly 'mark.interval': import('..').MarkComponent<
                                import('../mark').IntervalOptions
                                >;
                                readonly 'mark.rect': import('..').MarkComponent<import('../mark').RectOptions>;
                                readonly 'mark.line': import('..').MarkComponent<import('../mark').LineOptions>;
                                readonly 'mark.point': import('..').MarkComponent<
                                import('../mark').PointOptions
                                >;
                                readonly 'mark.text': import('..').MarkComponent<import('../mark').TextOptions>;
                                readonly 'mark.cell': import('..').MarkComponent<import('../mark').CellOptions>;
                                readonly 'mark.area': import('..').MarkComponent<import('../mark').AreaOptions>;
                                readonly 'mark.link': import('..').MarkComponent<import('../mark').LinkOptions>;
                                readonly 'mark.image': import('..').MarkComponent<
                                import('../mark').ImageOptions
                                >;
                                readonly 'mark.polygon': import('..').MarkComponent<
                                import('../mark').PolygonOptions
                                >;
                                readonly 'mark.box': import('..').MarkComponent<import('../mark').BoxOptions>;
                                readonly 'mark.vector': import('..').MarkComponent<
                                import('../mark').VectorOptions
                                >;
                                readonly 'mark.lineX': import('..').MarkComponent<
                                import('../mark').LineXOptions
                                >;
                                readonly 'mark.lineY': import('..').MarkComponent<
                                import('../mark').LineYOptions
                                >;
                                readonly 'mark.connector': import('..').MarkComponent<
                                import('../mark').ConnectorOptions
                                >;
                                readonly 'mark.range': import('..').MarkComponent<
                                import('../mark').RangeOptions
                                >;
                                readonly 'mark.rangeX': import('..').MarkComponent<
                                import('../mark').RangeXOptions
                                >;
                                readonly 'mark.rangeY': import('..').MarkComponent<
                                import('../mark').RangeYOptions
                                >;
                                readonly 'mark.path': import('..').MarkComponent<
                                import('../mark/path').PathOptions
                                >;
                                readonly 'mark.shape': import('..').MarkComponent<
                                import('../mark').ShapeOptions
                                >;
                                readonly 'mark.density': import('..').MarkComponent<
                                import('../mark').DensityOptions
                                >;
                                readonly 'mark.heatmap': import('..').MarkComponent<
                                import('../mark').HeatmapOptions
                                >;
                                readonly 'mark.wordCloud': import('../runtime').CompositeMarkComponent<
                                import('../mark').WordCloudOptions
                                >;
                                readonly 'palette.category10': import('../runtime').PaletteComponent<
                                import('../palette').Category10Options
                                >;
                                readonly 'palette.category20': import('../runtime').PaletteComponent<
                                import('../palette').Category20Options
                                >;
                                readonly 'scale.linear': import('../runtime').ScaleComponent<
                                import('../scale').LinearOptions
                                >;
                                readonly 'scale.ordinal': import('../runtime').ScaleComponent<
                                import('../scale').OrdinalOptions
                                >;
                                readonly 'scale.band': import('../runtime').ScaleComponent<
                                import('../scale').BandOptions
                                >;
                                readonly 'scale.identity': import('../runtime').ScaleComponent<
                                import('../scale').IdentityOptions
                                >;
                                readonly 'scale.point': import('../runtime').ScaleComponent<
                                import('../scale').PointOptions
                                >;
                                readonly 'scale.time': import('../runtime').ScaleComponent<
                                import('../scale').TimeOptions
                                >;
                                readonly 'scale.log': import('../runtime').ScaleComponent<
                                import('../scale').LogOptions
                                >;
                                readonly 'scale.pow': import('../runtime').ScaleComponent<
                                import('../scale').PowOptions
                                >;
                                readonly 'scale.sqrt': import('../runtime').ScaleComponent<
                                import('../scale').SqrtOptions
                                >;
                                readonly 'scale.threshold': import('../runtime').ScaleComponent<
                                import('../scale').ThresholdOptions
                                >;
                                readonly 'scale.quantile': import('../runtime').ScaleComponent<
                                import('../scale').QuantileOptions
                                >;
                                readonly 'scale.quantize': import('../runtime').ScaleComponent<
                                import('../scale').QuantizeOptions
                                >;
                                readonly 'scale.sequential': import('../runtime').ScaleComponent<
                                import('../scale').SequentialOptions
                                >;
                                readonly 'scale.constant': import('../runtime').ScaleComponent<
                                import('../scale').ConstantOptions
                                >;
                                readonly 'theme.classic': import('../runtime').ThemeComponent<
                                import('../runtime').G2Theme
                                >;
                                readonly 'theme.classicDark': import('../runtime').ThemeComponent<
                                import('../runtime').G2Theme
                                >;
                                readonly 'theme.academy': import('../runtime').ThemeComponent<
                                import('../runtime').G2Theme
                                >;
                                readonly 'theme.light': import('../runtime').ThemeComponent<
                                import('../runtime').G2Theme
                                >;
                                readonly 'theme.dark': import('../runtime').ThemeComponent<
                                import('../runtime').G2Theme
                                >;
                                readonly 'component.axisX': import('..').GuideComponentComponent<
                                import('..').AxisOptions
                                >;
                                readonly 'component.axisY': import('..').GuideComponentComponent<
                                import('..').AxisOptions
                                >;
                                readonly 'component.legendCategory': import('..').GuideComponentComponent<
                                import('../component').LegendCategoryOptions
                                >;
                                readonly 'component.legendContinuous': import('..').GuideComponentComponent<
                                import('../component').LegendContinuousOptions
                                >;
                                readonly 'component.legends': import('..').GuideComponentComponent<
                                import('../component').LegendsOptions
                                >;
                                readonly 'component.title': import('..').GuideComponentComponent<
                                import('../runtime').G2Title
                                >;
                                readonly 'component.sliderX': import('..').GuideComponentComponent<
                                import('../component/slider').SliderOptions
                                >;
                                readonly 'component.sliderY': import('..').GuideComponentComponent<
                                import('../component/slider').SliderOptions
                                >;
                                readonly 'component.scrollbarX': import('..').GuideComponentComponent<
                                import('../component/scrollbar').ScrollbarOptions
                                >;
                                readonly 'component.scrollbarY': import('..').GuideComponentComponent<
                                import('../component/scrollbar').ScrollbarOptions
                                >;
                                readonly 'animation.scaleInX': import('../runtime').AnimationComponent<
                                import('../animation/types').Animation
                                >;
                                readonly 'animation.scaleOutX': import('../runtime').AnimationComponent<
                                import('../animation/types').Animation
                                >;
                                readonly 'animation.scaleInY': import('../runtime').AnimationComponent<
                                import('../animation/types').Animation
                                >;
                                readonly 'animation.scaleOutY': import('../runtime').AnimationComponent<
                                import('../animation/types').Animation
                                >;
                                readonly 'animation.waveIn': import('../runtime').AnimationComponent<
                                import('../animation/types').Animation
                                >;
                                readonly 'animation.fadeIn': import('../runtime').AnimationComponent<
                                import('../animation/types').Animation
                                >;
                                readonly 'animation.fadeOut': import('../runtime').AnimationComponent<
                                import('../animation/types').Animation
                                >;
                                readonly 'animation.zoomIn': import('../runtime').AnimationComponent<
                                import('../animation/types').Animation
                                >;
                                readonly 'animation.zoomOut': import('../runtime').AnimationComponent<
                                import('../animation/types').Animation
                                >;
                                readonly 'animation.pathIn': import('../runtime').AnimationComponent<
                                import('../animation/types').Animation
                                >;
                                readonly 'animation.morphing': import('../runtime').AnimationComponent<
                                import('../animation').MorphingOptions
                                >;
                                readonly 'animation.growInX': import('../runtime').AnimationComponent<
                                import('../animation/types').Animation
                                >;
                                readonly 'animation.growInY': import('../runtime').AnimationComponent<
                                import('../animation/types').Animation
                                >;
                                readonly 'interaction.elementHighlight': typeof ElementHighlight;
                                readonly 'interaction.elementHighlightByX': typeof ElementHighlightByX;
                                readonly 'interaction.elementHighlightByColor': typeof ElementHighlightByColor;
                                readonly 'interaction.elementSelect': typeof ElementSelect;
                                readonly 'interaction.elementSelectByX': typeof ElementSelectByX;
                                readonly 'interaction.elementSelectByColor': typeof ElementSelectByColor;
                                readonly 'interaction.fisheye': typeof ChartFisheye;
                                readonly 'interaction.chartIndex': typeof ChartIndex;
                                readonly 'interaction.tooltip': typeof Tooltip;
                                readonly 'interaction.legendFilter': typeof LegendFilter;
                                readonly 'interaction.legendHighlight': typeof LegendHighlight;
                                readonly 'interaction.brushHighlight': typeof BrushHighlight;
                                readonly 'interaction.brushXHighlight': typeof BrushXHighlight;
                                readonly 'interaction.brushYHighlight': typeof BrushYHighlight;
                                readonly 'interaction.brushAxisHighlight': typeof BrushAxisHighlight;
                                readonly 'interaction.brushFilter': typeof BrushFilter;
                                readonly 'interaction.brushXFilter': typeof BrushXFilter;
                                readonly 'interaction.brushYFilter': typeof BrushYFilter;
                                readonly 'interaction.sliderFilter': typeof SliderFilter;
                                readonly 'interaction.scrollbarFilter': typeof ScrollbarFilter;
                                readonly 'interaction.poptip': typeof Poptip;
                                readonly 'interaction.treemapDrillDown': typeof TreemapDrillDown;
                                readonly 'interaction.elementPointMove': typeof ElementPointMove;
                                readonly 'composition.spaceLayer': import('../runtime').CompositionComponent<
                                import('../composition').SpaceLayerOptions
                                >;
                                readonly 'composition.spaceFlex': import('../runtime').CompositionComponent<
                                import('../composition').SpaceFlexOptions
                                >;
                                readonly 'composition.facetRect': import('../runtime').CompositionComponent<
                                import('../composition').FacetRectOptions
                                >;
                                readonly 'composition.repeatMatrix': import('../runtime').CompositionComponent<
                                import('..').RepeatMatrixComposition
                                >;
                                readonly 'composition.facetCircle': import('../runtime').CompositionComponent<
                                import('..').FacetCircleComposition
                                >;
                                readonly 'composition.timingKeyframe': import('../runtime').CompositionComponent<
                                import('../composition').TimingKeyframeOptions
                                >;
                                readonly 'labelTransform.overlapHide': import('../runtime').LabelTransformComponent<
                                import('../label-transform').OverlapHideOptions
                                >;
                                readonly 'labelTransform.overlapDodgeY': import('../runtime').LabelTransformComponent<
                                import('../label-transform').OverlapDodgeYOptions
                                >;
                                readonly 'labelTransform.overflowHide': import('../runtime').LabelTransformComponent<
                                import('../label-transform').OverflowHideOptions
                                >;
                                readonly 'labelTransform.contrastReverse': import('../runtime').LabelTransformComponent<
                                import('../label-transform').ContrastReverseOptions
                                >;
                                readonly 'labelTransform.exceedAdjust': import('../runtime').LabelTransformComponent<
                                import('../label-transform').ExceedAdjustOptions
                                >;
                                };

                                  function dataOf

                                  dataOf: (element: G2Element, viewData?: any) => any;
                                  • Get element's original data.

                                    Parameter elemenet

                                    G2 element.

                                    Parameter elemenet

                                    View data, if not provided, will get from element's ancestor view.

                                    Returns

                                    The original data of the element.

                                  function extend

                                  extend: <Spec extends G2Spec = G2Spec, Library extends G2Library = G2Library>(
                                  Runtime: new (options: RuntimeOptions) => Runtime<Spec>,
                                  library: Library
                                  ) => new (options?: RuntimeOptions) => API<Spec, Library>;

                                    function geolib

                                    geolib: () => {
                                    readonly 'composition.geoView': import('../runtime').CompositionComponent<
                                    import('../composition/geoView').GeoViewOptions
                                    >;
                                    readonly 'composition.geoPath': import('../runtime').CompositionComponent<
                                    import('../composition/geoPath').GeoPathOptions
                                    >;
                                    };

                                      function graphlib

                                      graphlib: () => {
                                      readonly 'data.arc': import('../runtime').DataComponent<
                                      import('../data').ArcOptions
                                      >;
                                      readonly 'data.cluster': import('../runtime').DataComponent<
                                      import('../data').ClusterOptions
                                      >;
                                      readonly 'mark.forceGraph': import('../runtime').CompositeMarkComponent<
                                      import('../mark').ForceGraphOptions
                                      >;
                                      readonly 'mark.tree': import('../runtime').CompositeMarkComponent<
                                      import('../mark').TreeOptions
                                      >;
                                      readonly 'mark.pack': import('../runtime').CompositionComponent<
                                      import('../mark').PackOptions
                                      >;
                                      readonly 'mark.sankey': import('../runtime').CompositeMarkComponent<
                                      import('../mark').SankeyOptions
                                      >;
                                      readonly 'mark.chord': import('../runtime').CompositeMarkComponent<
                                      import('../mark').ChordOptions
                                      >;
                                      readonly 'mark.treemap': import('../runtime').CompositionComponent<
                                      import('../mark').TreemapOptions
                                      >;
                                      };

                                        function litelib

                                        litelib: () => {
                                        readonly 'data.inline': import('../runtime').DataComponent<
                                        import('../data').InlineOptions
                                        >;
                                        readonly 'coordinate.cartesian': import('../runtime').CoordinateComponent<
                                        import('../coordinate').CartesianOptions
                                        >;
                                        readonly 'encode.constant': import('../runtime').EncodeComponent<
                                        import('../encode').ConstantOptions
                                        >;
                                        readonly 'encode.field': import('../runtime').EncodeComponent<
                                        import('../encode').FieldOptions
                                        >;
                                        readonly 'encode.transform': import('../runtime').EncodeComponent<
                                        import('../encode').TransformOptions
                                        >;
                                        readonly 'encode.column': import('../runtime').EncodeComponent<
                                        import('../encode').ColumnOptions
                                        >;
                                        readonly 'mark.interval': import('..').MarkComponent<
                                        import('../mark').IntervalOptions
                                        >;
                                        readonly 'shape.label.label': import('..').ShapeComponent<
                                        import('../shape').LabelShapeOptions
                                        >;
                                        readonly 'palette.category10': import('../runtime').PaletteComponent<
                                        import('../palette').Category10Options
                                        >;
                                        readonly 'palette.category20': import('../runtime').PaletteComponent<
                                        import('../palette').Category20Options
                                        >;
                                        readonly 'scale.linear': import('../runtime').ScaleComponent<
                                        import('../scale').LinearOptions
                                        >;
                                        readonly 'scale.ordinal': import('../runtime').ScaleComponent<
                                        import('../scale').OrdinalOptions
                                        >;
                                        readonly 'scale.band': import('../runtime').ScaleComponent<
                                        import('../scale').BandOptions
                                        >;
                                        readonly 'scale.identity': import('../runtime').ScaleComponent<
                                        import('../scale').IdentityOptions
                                        >;
                                        readonly 'scale.point': import('../runtime').ScaleComponent<
                                        import('../scale').PointOptions
                                        >;
                                        readonly 'scale.time': import('../runtime').ScaleComponent<
                                        import('../scale').TimeOptions
                                        >;
                                        readonly 'scale.log': import('../runtime').ScaleComponent<
                                        import('../scale').LogOptions
                                        >;
                                        readonly 'scale.pow': import('../runtime').ScaleComponent<
                                        import('../scale').PowOptions
                                        >;
                                        readonly 'scale.sqrt': import('../runtime').ScaleComponent<
                                        import('../scale').SqrtOptions
                                        >;
                                        readonly 'scale.threshold': import('../runtime').ScaleComponent<
                                        import('../scale').ThresholdOptions
                                        >;
                                        readonly 'scale.quantile': import('../runtime').ScaleComponent<
                                        import('../scale').QuantileOptions
                                        >;
                                        readonly 'scale.quantize': import('../runtime').ScaleComponent<
                                        import('../scale').QuantizeOptions
                                        >;
                                        readonly 'scale.sequential': import('../runtime').ScaleComponent<
                                        import('../scale').SequentialOptions
                                        >;
                                        readonly 'scale.constant': import('../runtime').ScaleComponent<
                                        import('../scale').ConstantOptions
                                        >;
                                        readonly 'theme.classic': import('../runtime').ThemeComponent<
                                        import('../runtime').G2Theme
                                        >;
                                        readonly 'component.axisX': import('..').GuideComponentComponent<
                                        import('..').AxisOptions
                                        >;
                                        readonly 'component.axisY': import('..').GuideComponentComponent<
                                        import('..').AxisOptions
                                        >;
                                        readonly 'component.axisRadar': import('..').GuideComponentComponent<
                                        import('../component/axisRadar').AxisRadarOptions
                                        >;
                                        readonly 'component.axisLinear': import('..').GuideComponentComponent<
                                        import('..').AxisOptions
                                        >;
                                        readonly 'component.axisArc': import('..').GuideComponentComponent<
                                        import('..').AxisOptions
                                        >;
                                        readonly 'component.legendCategory': import('..').GuideComponentComponent<
                                        import('../component').LegendCategoryOptions
                                        >;
                                        readonly 'component.legendContinuous': import('..').GuideComponentComponent<
                                        import('../component').LegendContinuousOptions
                                        >;
                                        readonly 'component.legendContinuousBlock': import('..').GuideComponentComponent<
                                        import('../component').LegendContinuousOptions
                                        >;
                                        readonly 'component.legendContinuousBlockSize': import('..').GuideComponentComponent<
                                        import('../component').LegendContinuousOptions
                                        >;
                                        readonly 'component.legendContinuousSize': import('..').GuideComponentComponent<
                                        import('../component').LegendContinuousOptions
                                        >;
                                        readonly 'component.legends': import('..').GuideComponentComponent<
                                        import('../component').LegendsOptions
                                        >;
                                        readonly 'component.title': import('..').GuideComponentComponent<
                                        import('../runtime').G2Title
                                        >;
                                        readonly 'component.sliderX': import('..').GuideComponentComponent<
                                        import('../component/slider').SliderOptions
                                        >;
                                        readonly 'component.sliderY': import('..').GuideComponentComponent<
                                        import('../component/slider').SliderOptions
                                        >;
                                        readonly 'component.scrollbarX': import('..').GuideComponentComponent<
                                        import('../component/scrollbar').ScrollbarOptions
                                        >;
                                        readonly 'component.scrollbarY': import('..').GuideComponentComponent<
                                        import('../component/scrollbar').ScrollbarOptions
                                        >;
                                        readonly 'animation.scaleInX': import('../runtime').AnimationComponent<
                                        import('../animation/types').Animation
                                        >;
                                        readonly 'animation.scaleOutX': import('../runtime').AnimationComponent<
                                        import('../animation/types').Animation
                                        >;
                                        readonly 'animation.scaleInY': import('../runtime').AnimationComponent<
                                        import('../animation/types').Animation
                                        >;
                                        readonly 'animation.scaleOutY': import('../runtime').AnimationComponent<
                                        import('../animation/types').Animation
                                        >;
                                        readonly 'animation.waveIn': import('../runtime').AnimationComponent<
                                        import('../animation/types').Animation
                                        >;
                                        readonly 'animation.fadeIn': import('../runtime').AnimationComponent<
                                        import('../animation/types').Animation
                                        >;
                                        readonly 'animation.fadeOut': import('../runtime').AnimationComponent<
                                        import('../animation/types').Animation
                                        >;
                                        readonly 'animation.morphing': import('../runtime').AnimationComponent<
                                        import('../animation').MorphingOptions
                                        >;
                                        readonly 'interaction.tooltip': typeof Tooltip;
                                        readonly 'interaction.legendFilter': typeof LegendFilter;
                                        readonly 'interaction.legendHighlight': typeof LegendHighlight;
                                        readonly 'interaction.sliderFilter': typeof SliderFilter;
                                        readonly 'interaction.scrollbarFilter': typeof ScrollbarFilter;
                                        readonly 'interaction.poptip': typeof Poptip;
                                        readonly 'interaction.event': typeof Event;
                                        readonly 'composition.mark': import('../runtime').CompositionComponent<
                                        import('../composition').MarkOptions
                                        >;
                                        readonly 'composition.view': import('../runtime').CompositionComponent<
                                        import('../composition').ViewOptions
                                        >;
                                        };
                                        • In test stage, don't use it.

                                        function plotlib

                                        plotlib: () => {
                                        readonly 'data.venn': import('../runtime').DataComponent<
                                        import('../data').VennOptions
                                        >;
                                        readonly 'mark.boxplot': import('../runtime').CompositeMarkComponent<
                                        import('../mark/boxplot').BoxPlotOptions
                                        >;
                                        readonly 'mark.gauge': import('../runtime').CompositeMarkComponent<
                                        import('../mark').GaugeOptions
                                        >;
                                        readonly 'mark.wordCloud': import('../runtime').CompositeMarkComponent<
                                        import('../mark').WordCloudOptions
                                        >;
                                        readonly 'mark.liquid': import('../runtime').CompositeMarkComponent<
                                        import('../mark').LiquidOptions
                                        >;
                                        };

                                          function register

                                          register: (
                                          key: `${G2ComponentNamespaces | 'symbol'}.${any}`,
                                          component: G2Component | SymbolFactor
                                          ) => void;

                                            function render

                                            render: <T extends G2ViewTree = G2ViewTree>(
                                            options: T,
                                            context?: G2Context,
                                            resolve?: () => void,
                                            reject?: (e?: any) => void
                                            ) => HTMLElement;

                                              function renderToMountedElement

                                              renderToMountedElement: <T extends G2ViewTree = G2ViewTree>(
                                              options: T,
                                              context?: G2Context,
                                              resolve?: () => void,
                                              reject?: (e?: any) => never
                                              ) => DisplayObject;

                                                function select

                                                select: <T = any>(node: DisplayObject) => Selection<T>;

                                                  function selectG2Elements

                                                  selectG2Elements: (root: DisplayObject) => DisplayObject[];
                                                  • Given root of chart returns elements to be manipulated

                                                  function selectPlotArea

                                                  selectPlotArea: (root: DisplayObject) => DisplayObject;

                                                    function seriesOf

                                                    seriesOf: (elemenet: G2Element) => string;
                                                    • Get element's series name.

                                                      Parameter elemenet

                                                      G2 element.

                                                      Returns

                                                      The series name of the element.

                                                    function stdlib

                                                    stdlib: () => {
                                                    readonly 'data.fetch': import('../runtime').DataComponent<
                                                    import('../data').FetchOptions
                                                    >;
                                                    readonly 'data.inline': import('../runtime').DataComponent<
                                                    import('../data').InlineOptions
                                                    >;
                                                    readonly 'data.sortBy': import('../runtime').DataComponent<
                                                    import('../data').SortByOptions
                                                    >;
                                                    readonly 'data.sort': import('../runtime').DataComponent<
                                                    import('../data').SortOptions
                                                    >;
                                                    readonly 'data.filter': import('../runtime').DataComponent<
                                                    import('../data').FilterDataOptions
                                                    >;
                                                    readonly 'data.pick': import('../runtime').DataComponent<
                                                    import('../data').PickOptions
                                                    >;
                                                    readonly 'data.rename': import('../runtime').DataComponent<
                                                    import('../data').RenameOptions
                                                    >;
                                                    readonly 'data.fold': import('../runtime').DataComponent<
                                                    import('../data').FoldOptions
                                                    >;
                                                    readonly 'data.slice': import('../runtime').DataComponent<
                                                    import('../data').SliceOptions
                                                    >;
                                                    readonly 'data.custom': import('../runtime').DataComponent<
                                                    import('../data').CustomOptions
                                                    >;
                                                    readonly 'data.map': import('../runtime').DataComponent<
                                                    import('../data').MapOptions
                                                    >;
                                                    readonly 'data.join': import('../runtime').DataComponent<
                                                    import('../data').JoinOptions
                                                    >;
                                                    readonly 'data.kde': import('../runtime').DataComponent<
                                                    import('../data').KDEOptions
                                                    >;
                                                    readonly 'data.log': import('../runtime').DataComponent<
                                                    import('../data').LogDataOptions
                                                    >;
                                                    readonly 'data.wordCloud': import('../runtime').DataComponent<
                                                    Partial<import('../data').WordCloudOptions>
                                                    >;
                                                    readonly 'data.ema': import('../runtime').DataComponent<
                                                    import('../data').EMAOptions
                                                    >;
                                                    readonly 'transform.stackY': import('../runtime').TransformComponent<
                                                    import('..').StackYOptions
                                                    >;
                                                    readonly 'transform.binX': import('../runtime').TransformComponent<
                                                    import('..').BinXOptions
                                                    >;
                                                    readonly 'transform.bin': import('../runtime').TransformComponent<
                                                    import('..').BinOptions
                                                    >;
                                                    readonly 'transform.dodgeX': import('../runtime').TransformComponent<
                                                    import('..').DodgeXOptions
                                                    >;
                                                    readonly 'transform.jitter': import('../runtime').TransformComponent<
                                                    import('..').JitterOptions
                                                    >;
                                                    readonly 'transform.jitterX': import('../runtime').TransformComponent<
                                                    import('..').JitterXOptions
                                                    >;
                                                    readonly 'transform.jitterY': import('../runtime').TransformComponent<
                                                    import('..').JitterYOptions
                                                    >;
                                                    readonly 'transform.symmetryY': import('../runtime').TransformComponent<
                                                    import('..').SymmetryYOptions
                                                    >;
                                                    readonly 'transform.diffY': import('../runtime').TransformComponent<
                                                    import('..').DiffYOptions
                                                    >;
                                                    readonly 'transform.stackEnter': import('../runtime').TransformComponent<
                                                    import('..').StackEnterOptions
                                                    >;
                                                    readonly 'transform.normalizeY': import('../runtime').TransformComponent<
                                                    import('..').NormalizeYOptions
                                                    >;
                                                    readonly 'transform.select': import('../runtime').TransformComponent<
                                                    import('..').SelectOptions
                                                    >;
                                                    readonly 'transform.selectX': import('../runtime').TransformComponent<
                                                    import('..').SelectXOptions
                                                    >;
                                                    readonly 'transform.selectY': import('../runtime').TransformComponent<
                                                    import('..').SelectYOptions
                                                    >;
                                                    readonly 'transform.groupX': import('../runtime').TransformComponent<
                                                    import('..').GroupXOptions
                                                    >;
                                                    readonly 'transform.groupY': import('../runtime').TransformComponent<
                                                    import('..').GroupYOptions
                                                    >;
                                                    readonly 'transform.groupColor': import('../runtime').TransformComponent<
                                                    import('..').GroupColorOptions
                                                    >;
                                                    readonly 'transform.group': import('../runtime').TransformComponent<
                                                    import('..').GroupOptions
                                                    >;
                                                    readonly 'transform.sortX': import('../runtime').TransformComponent<
                                                    import('..').SortXOptions
                                                    >;
                                                    readonly 'transform.sortY': import('../runtime').TransformComponent<
                                                    import('..').SortYOptions
                                                    >;
                                                    readonly 'transform.sortColor': import('../runtime').TransformComponent<
                                                    import('..').SortColorOptions
                                                    >;
                                                    readonly 'transform.flexX': import('../runtime').TransformComponent<
                                                    import('..').FlexXOptions
                                                    >;
                                                    readonly 'transform.pack': import('../runtime').TransformComponent<
                                                    import('..').PackOptions
                                                    >;
                                                    readonly 'transform.sample': import('../runtime').TransformComponent<
                                                    import('..').SampleOptions
                                                    >;
                                                    readonly 'transform.filter': import('../runtime').TransformComponent<
                                                    import('..').FilterOptions
                                                    >;
                                                    readonly 'coordinate.cartesian': import('../runtime').CoordinateComponent<
                                                    import('../coordinate').CartesianOptions
                                                    >;
                                                    readonly 'coordinate.polar': import('../runtime').CoordinateComponent<
                                                    import('../coordinate').PolarOptions
                                                    >;
                                                    readonly 'coordinate.transpose': import('../runtime').CoordinateComponent<
                                                    import('../coordinate').TransposeOptions
                                                    >;
                                                    readonly 'coordinate.theta': import('../runtime').CoordinateComponent<
                                                    import('..').ThetaCoordinate
                                                    >;
                                                    readonly 'coordinate.parallel': import('../runtime').CoordinateComponent<
                                                    import('../coordinate').ParallelOptions
                                                    >;
                                                    readonly 'coordinate.fisheye': import('../runtime').CoordinateComponent<
                                                    import('..').FisheyeCoordinate
                                                    >;
                                                    readonly 'coordinate.radial': import('../runtime').CoordinateComponent<
                                                    import('../coordinate').RadialOptions
                                                    >;
                                                    readonly 'coordinate.radar': import('../runtime').CoordinateComponent<
                                                    import('..').RadarCoordinate
                                                    >;
                                                    readonly 'coordinate.helix': import('../runtime').CoordinateComponent<
                                                    import('..').HelixCoordinate
                                                    >;
                                                    readonly 'encode.constant': import('../runtime').EncodeComponent<
                                                    import('../encode').ConstantOptions
                                                    >;
                                                    readonly 'encode.field': import('../runtime').EncodeComponent<
                                                    import('../encode').FieldOptions
                                                    >;
                                                    readonly 'encode.transform': import('../runtime').EncodeComponent<
                                                    import('../encode').TransformOptions
                                                    >;
                                                    readonly 'encode.column': import('../runtime').EncodeComponent<
                                                    import('../encode').ColumnOptions
                                                    >;
                                                    readonly 'mark.interval': import('..').MarkComponent<
                                                    import('../mark').IntervalOptions
                                                    >;
                                                    readonly 'mark.rect': import('..').MarkComponent<import('../mark').RectOptions>;
                                                    readonly 'mark.line': import('..').MarkComponent<import('../mark').LineOptions>;
                                                    readonly 'mark.point': import('..').MarkComponent<
                                                    import('../mark').PointOptions
                                                    >;
                                                    readonly 'mark.text': import('..').MarkComponent<import('../mark').TextOptions>;
                                                    readonly 'mark.cell': import('..').MarkComponent<import('../mark').CellOptions>;
                                                    readonly 'mark.area': import('..').MarkComponent<import('../mark').AreaOptions>;
                                                    readonly 'mark.link': import('..').MarkComponent<import('../mark').LinkOptions>;
                                                    readonly 'mark.image': import('..').MarkComponent<
                                                    import('../mark').ImageOptions
                                                    >;
                                                    readonly 'mark.polygon': import('..').MarkComponent<
                                                    import('../mark').PolygonOptions
                                                    >;
                                                    readonly 'mark.box': import('..').MarkComponent<import('../mark').BoxOptions>;
                                                    readonly 'mark.vector': import('..').MarkComponent<
                                                    import('../mark').VectorOptions
                                                    >;
                                                    readonly 'mark.lineX': import('..').MarkComponent<
                                                    import('../mark').LineXOptions
                                                    >;
                                                    readonly 'mark.lineY': import('..').MarkComponent<
                                                    import('../mark').LineYOptions
                                                    >;
                                                    readonly 'mark.connector': import('..').MarkComponent<
                                                    import('../mark').ConnectorOptions
                                                    >;
                                                    readonly 'mark.range': import('..').MarkComponent<
                                                    import('../mark').RangeOptions
                                                    >;
                                                    readonly 'mark.rangeX': import('..').MarkComponent<
                                                    import('../mark').RangeXOptions
                                                    >;
                                                    readonly 'mark.rangeY': import('..').MarkComponent<
                                                    import('../mark').RangeYOptions
                                                    >;
                                                    readonly 'mark.path': import('..').MarkComponent<
                                                    import('../mark/path').PathOptions
                                                    >;
                                                    readonly 'mark.shape': import('..').MarkComponent<
                                                    import('../mark').ShapeOptions
                                                    >;
                                                    readonly 'mark.density': import('..').MarkComponent<
                                                    import('../mark').DensityOptions
                                                    >;
                                                    readonly 'mark.heatmap': import('..').MarkComponent<
                                                    import('../mark').HeatmapOptions
                                                    >;
                                                    readonly 'mark.wordCloud': import('../runtime').CompositeMarkComponent<
                                                    import('../mark').WordCloudOptions
                                                    >;
                                                    readonly 'palette.category10': import('../runtime').PaletteComponent<
                                                    import('../palette').Category10Options
                                                    >;
                                                    readonly 'palette.category20': import('../runtime').PaletteComponent<
                                                    import('../palette').Category20Options
                                                    >;
                                                    readonly 'scale.linear': import('../runtime').ScaleComponent<
                                                    import('../scale').LinearOptions
                                                    >;
                                                    readonly 'scale.ordinal': import('../runtime').ScaleComponent<
                                                    import('../scale').OrdinalOptions
                                                    >;
                                                    readonly 'scale.band': import('../runtime').ScaleComponent<
                                                    import('../scale').BandOptions
                                                    >;
                                                    readonly 'scale.identity': import('../runtime').ScaleComponent<
                                                    import('../scale').IdentityOptions
                                                    >;
                                                    readonly 'scale.point': import('../runtime').ScaleComponent<
                                                    import('../scale').PointOptions
                                                    >;
                                                    readonly 'scale.time': import('../runtime').ScaleComponent<
                                                    import('../scale').TimeOptions
                                                    >;
                                                    readonly 'scale.log': import('../runtime').ScaleComponent<
                                                    import('../scale').LogOptions
                                                    >;
                                                    readonly 'scale.pow': import('../runtime').ScaleComponent<
                                                    import('../scale').PowOptions
                                                    >;
                                                    readonly 'scale.sqrt': import('../runtime').ScaleComponent<
                                                    import('../scale').SqrtOptions
                                                    >;
                                                    readonly 'scale.threshold': import('../runtime').ScaleComponent<
                                                    import('../scale').ThresholdOptions
                                                    >;
                                                    readonly 'scale.quantile': import('../runtime').ScaleComponent<
                                                    import('../scale').QuantileOptions
                                                    >;
                                                    readonly 'scale.quantize': import('../runtime').ScaleComponent<
                                                    import('../scale').QuantizeOptions
                                                    >;
                                                    readonly 'scale.sequential': import('../runtime').ScaleComponent<
                                                    import('../scale').SequentialOptions
                                                    >;
                                                    readonly 'scale.constant': import('../runtime').ScaleComponent<
                                                    import('../scale').ConstantOptions
                                                    >;
                                                    readonly 'theme.classic': import('../runtime').ThemeComponent<
                                                    import('../runtime').G2Theme
                                                    >;
                                                    readonly 'theme.classicDark': import('../runtime').ThemeComponent<
                                                    import('../runtime').G2Theme
                                                    >;
                                                    readonly 'theme.academy': import('../runtime').ThemeComponent<
                                                    import('../runtime').G2Theme
                                                    >;
                                                    readonly 'theme.light': import('../runtime').ThemeComponent<
                                                    import('../runtime').G2Theme
                                                    >;
                                                    readonly 'theme.dark': import('../runtime').ThemeComponent<
                                                    import('../runtime').G2Theme
                                                    >;
                                                    readonly 'component.axisX': import('..').GuideComponentComponent<
                                                    import('..').AxisOptions
                                                    >;
                                                    readonly 'component.axisY': import('..').GuideComponentComponent<
                                                    import('..').AxisOptions
                                                    >;
                                                    readonly 'component.legendCategory': import('..').GuideComponentComponent<
                                                    import('../component').LegendCategoryOptions
                                                    >;
                                                    readonly 'component.legendContinuous': import('..').GuideComponentComponent<
                                                    import('../component').LegendContinuousOptions
                                                    >;
                                                    readonly 'component.legends': import('..').GuideComponentComponent<
                                                    import('../component').LegendsOptions
                                                    >;
                                                    readonly 'component.title': import('..').GuideComponentComponent<
                                                    import('../runtime').G2Title
                                                    >;
                                                    readonly 'component.sliderX': import('..').GuideComponentComponent<
                                                    import('../component/slider').SliderOptions
                                                    >;
                                                    readonly 'component.sliderY': import('..').GuideComponentComponent<
                                                    import('../component/slider').SliderOptions
                                                    >;
                                                    readonly 'component.scrollbarX': import('..').GuideComponentComponent<
                                                    import('../component/scrollbar').ScrollbarOptions
                                                    >;
                                                    readonly 'component.scrollbarY': import('..').GuideComponentComponent<
                                                    import('../component/scrollbar').ScrollbarOptions
                                                    >;
                                                    readonly 'animation.scaleInX': import('../runtime').AnimationComponent<
                                                    import('../animation/types').Animation
                                                    >;
                                                    readonly 'animation.scaleOutX': import('../runtime').AnimationComponent<
                                                    import('../animation/types').Animation
                                                    >;
                                                    readonly 'animation.scaleInY': import('../runtime').AnimationComponent<
                                                    import('../animation/types').Animation
                                                    >;
                                                    readonly 'animation.scaleOutY': import('../runtime').AnimationComponent<
                                                    import('../animation/types').Animation
                                                    >;
                                                    readonly 'animation.waveIn': import('../runtime').AnimationComponent<
                                                    import('../animation/types').Animation
                                                    >;
                                                    readonly 'animation.fadeIn': import('../runtime').AnimationComponent<
                                                    import('../animation/types').Animation
                                                    >;
                                                    readonly 'animation.fadeOut': import('../runtime').AnimationComponent<
                                                    import('../animation/types').Animation
                                                    >;
                                                    readonly 'animation.zoomIn': import('../runtime').AnimationComponent<
                                                    import('../animation/types').Animation
                                                    >;
                                                    readonly 'animation.zoomOut': import('../runtime').AnimationComponent<
                                                    import('../animation/types').Animation
                                                    >;
                                                    readonly 'animation.pathIn': import('../runtime').AnimationComponent<
                                                    import('../animation/types').Animation
                                                    >;
                                                    readonly 'animation.morphing': import('../runtime').AnimationComponent<
                                                    import('../animation').MorphingOptions
                                                    >;
                                                    readonly 'animation.growInX': import('../runtime').AnimationComponent<
                                                    import('../animation/types').Animation
                                                    >;
                                                    readonly 'animation.growInY': import('../runtime').AnimationComponent<
                                                    import('../animation/types').Animation
                                                    >;
                                                    readonly 'interaction.elementHighlight': typeof import('../interaction').ElementHighlight;
                                                    readonly 'interaction.elementHighlightByX': typeof import('../interaction').ElementHighlightByX;
                                                    readonly 'interaction.elementHighlightByColor': typeof import('../interaction').ElementHighlightByColor;
                                                    readonly 'interaction.elementSelect': typeof import('../interaction').ElementSelect;
                                                    readonly 'interaction.elementSelectByX': typeof import('../interaction').ElementSelectByX;
                                                    readonly 'interaction.elementSelectByColor': typeof import('../interaction').ElementSelectByColor;
                                                    readonly 'interaction.fisheye': typeof import('../interaction').Fisheye;
                                                    readonly 'interaction.chartIndex': typeof import('../interaction').ChartIndex;
                                                    readonly 'interaction.tooltip': typeof import('../interaction').Tooltip;
                                                    readonly 'interaction.legendFilter': typeof import('../interaction').LegendFilter;
                                                    readonly 'interaction.legendHighlight': typeof import('../interaction').LegendHighlight;
                                                    readonly 'interaction.brushHighlight': typeof import('../interaction').BrushHighlight;
                                                    readonly 'interaction.brushXHighlight': typeof import('../interaction').BrushXHighlight;
                                                    readonly 'interaction.brushYHighlight': typeof import('../interaction').BrushYHighlight;
                                                    readonly 'interaction.brushAxisHighlight': typeof import('../interaction').BrushAxisHighlight;
                                                    readonly 'interaction.brushFilter': typeof import('../interaction').BrushFilter;
                                                    readonly 'interaction.brushXFilter': typeof import('../interaction').BrushXFilter;
                                                    readonly 'interaction.brushYFilter': typeof import('../interaction').BrushYFilter;
                                                    readonly 'interaction.sliderFilter': typeof import('../interaction').SliderFilter;
                                                    readonly 'interaction.scrollbarFilter': typeof import('../interaction').ScrollbarFilter;
                                                    readonly 'interaction.poptip': typeof import('../interaction').Poptip;
                                                    readonly 'interaction.treemapDrillDown': typeof import('../interaction').TreemapDrillDown;
                                                    readonly 'interaction.elementPointMove': typeof import('../interaction').ElementPointMove;
                                                    readonly 'composition.spaceLayer': import('../runtime').CompositionComponent<
                                                    import('../composition').SpaceLayerOptions
                                                    >;
                                                    readonly 'composition.spaceFlex': import('../runtime').CompositionComponent<
                                                    import('../composition').SpaceFlexOptions
                                                    >;
                                                    readonly 'composition.facetRect': import('../runtime').CompositionComponent<
                                                    import('../composition').FacetRectOptions
                                                    >;
                                                    readonly 'composition.repeatMatrix': import('../runtime').CompositionComponent<
                                                    import('..').RepeatMatrixComposition
                                                    >;
                                                    readonly 'composition.facetCircle': import('../runtime').CompositionComponent<
                                                    import('..').FacetCircleComposition
                                                    >;
                                                    readonly 'composition.timingKeyframe': import('../runtime').CompositionComponent<
                                                    import('../composition').TimingKeyframeOptions
                                                    >;
                                                    readonly 'labelTransform.overlapHide': import('../runtime').LabelTransformComponent<
                                                    import('../label-transform').OverlapHideOptions
                                                    >;
                                                    readonly 'labelTransform.overlapDodgeY': import('../runtime').LabelTransformComponent<
                                                    import('../label-transform').OverlapDodgeYOptions
                                                    >;
                                                    readonly 'labelTransform.overflowHide': import('../runtime').LabelTransformComponent<
                                                    import('../label-transform').OverflowHideOptions
                                                    >;
                                                    readonly 'labelTransform.contrastReverse': import('../runtime').LabelTransformComponent<
                                                    import('../label-transform').ContrastReverseOptions
                                                    >;
                                                    readonly 'labelTransform.exceedAdjust': import('../runtime').LabelTransformComponent<
                                                    import('../label-transform').ExceedAdjustOptions
                                                    >;
                                                    readonly 'data.venn': import('../runtime').DataComponent<
                                                    import('../data').VennOptions
                                                    >;
                                                    readonly 'mark.boxplot': import('../runtime').CompositeMarkComponent<
                                                    import('../mark/boxplot').BoxPlotOptions
                                                    >;
                                                    readonly 'mark.gauge': import('../runtime').CompositeMarkComponent<
                                                    import('../mark').GaugeOptions
                                                    >;
                                                    readonly 'mark.liquid': import('../runtime').CompositeMarkComponent<
                                                    import('../mark').LiquidOptions
                                                    >;
                                                    readonly 'data.arc': import('../runtime').DataComponent<
                                                    import('../data').ArcOptions
                                                    >;
                                                    readonly 'data.cluster': import('../runtime').DataComponent<
                                                    import('../data').ClusterOptions
                                                    >;
                                                    readonly 'mark.forceGraph': import('../runtime').CompositeMarkComponent<
                                                    import('../mark').ForceGraphOptions
                                                    >;
                                                    readonly 'mark.tree': import('../runtime').CompositeMarkComponent<
                                                    import('../mark').TreeOptions
                                                    >;
                                                    readonly 'mark.pack': import('../runtime').CompositionComponent<
                                                    import('../mark').PackOptions
                                                    >;
                                                    readonly 'mark.sankey': import('../runtime').CompositeMarkComponent<
                                                    import('../mark').SankeyOptions
                                                    >;
                                                    readonly 'mark.chord': import('../runtime').CompositeMarkComponent<
                                                    import('../mark').ChordOptions
                                                    >;
                                                    readonly 'mark.treemap': import('../runtime').CompositionComponent<
                                                    import('../mark').TreemapOptions
                                                    >;
                                                    readonly 'composition.geoView': import('../runtime').CompositionComponent<
                                                    import('../composition/geoView').GeoViewOptions
                                                    >;
                                                    readonly 'composition.geoPath': import('../runtime').CompositionComponent<
                                                    import('../composition/geoPath').GeoPathOptions
                                                    >;
                                                    };

                                                      Classes

                                                      class Runtime

                                                      class Runtime<Spec extends G2Spec = G2Spec> extends CompositionNode {}

                                                        constructor

                                                        constructor(options: RuntimeOptions);

                                                          method changeSize

                                                          changeSize: (width: number, height: number) => Promise<Runtime<Spec>>;

                                                            method clear

                                                            clear: () => void;

                                                              method destroy

                                                              destroy: () => void;

                                                                method emit

                                                                emit: (event: string, ...args: any[]) => this;

                                                                  method forceFit

                                                                  forceFit: () => Promise<Runtime<Spec>>;

                                                                    method getContainer

                                                                    getContainer: () => HTMLElement;

                                                                      method getContext

                                                                      getContext: () => G2Context;

                                                                        method getDataByXY

                                                                        getDataByXY: (
                                                                        point: { x: number; y: number },
                                                                        options?: {
                                                                        shared?: boolean;
                                                                        series?: boolean;
                                                                        facet?: boolean;
                                                                        startX?: number;
                                                                        startY?: number;
                                                                        }
                                                                        ) => any[];

                                                                          method off

                                                                          off: (event?: string, callback?: (...args: any[]) => any) => this;

                                                                            method on

                                                                            on: (event: string, callback: (...args: any[]) => any, once?: boolean) => this;

                                                                              method once

                                                                              once: (event: string, callback: (...args: any[]) => any) => this;

                                                                                method options

                                                                                options: { (): Spec; (options: Spec): Runtime<Spec> };
                                                                                • Returns

                                                                                  {Spec}

                                                                                • Parameter options

                                                                                  Returns

                                                                                  {Runtime}

                                                                                method render

                                                                                render: () => Promise<Runtime<Spec>>;

                                                                                  class Selection

                                                                                  class Selection<T = any> {}
                                                                                  • A simple implementation of d3-selection for @antv/g. It has the core features of d3-selection and extended ability. Every methods of selection returns new selection if elements are mutated(e.g. append, remove), otherwise return the selection itself(e.g. attr, style).

                                                                                    See Also

                                                                                    • https://github.com/d3/d3-selection

                                                                                    • https://github.com/antvis/g Nested selections. More useful functor.

                                                                                  constructor

                                                                                  constructor(
                                                                                  elements?: Iterable<any>,
                                                                                  data?: T[] | [T, any[]][],
                                                                                  parent?: any,
                                                                                  document?: any,
                                                                                  selections?: [
                                                                                  Selection<any>,
                                                                                  Selection<any>,
                                                                                  Selection<any>,
                                                                                  Selection<any>,
                                                                                  Selection<any>
                                                                                  ],
                                                                                  transitions?: any[],
                                                                                  updateElements?: any[]
                                                                                  );

                                                                                    property registry

                                                                                    static registry: Record<string, new () => G2Element>;

                                                                                      method append

                                                                                      append: (node: string | ((data: T, i: number) => G2Element)) => Selection<T>;

                                                                                        method attr

                                                                                        attr: (key: string, value: any) => Selection<T>;

                                                                                          method call

                                                                                          call: (
                                                                                          callback: (selection: Selection<T>, ...args: any[]) => any,
                                                                                          ...args: any[]
                                                                                          ) => Selection<T>;

                                                                                            method createElement

                                                                                            createElement: (type: string) => G2Element;

                                                                                              method data

                                                                                              data: <T = any>(
                                                                                              data: T[],
                                                                                              id?: (d: T, index?: number) => any,
                                                                                              groupId?: (d: T, index?: number) => any
                                                                                              ) => Selection<T>;
                                                                                              • Bind data to elements, and produce three selection: Enter: Selection with empty elements and data to be bind to elements. Update: Selection with elements to be updated. Exit: Selection with elements to be removed.

                                                                                              method each

                                                                                              each: (callback: (datum: T, index: number, element: any) => any) => Selection<T>;

                                                                                                method join

                                                                                                join: (
                                                                                                enter?: (selection: Selection<T>) => any,
                                                                                                update?: (selection: Selection<T>) => any,
                                                                                                exit?: (selection: Selection<T>) => any,
                                                                                                merge?: (selection: Selection<T>) => any,
                                                                                                split?: (selection: Selection<T>) => any
                                                                                                ) => Selection<T>;
                                                                                                • Apply callback for each selection(enter, update, exit) and merge them into one selection.

                                                                                                method maybeAppend

                                                                                                maybeAppend: (
                                                                                                id: string,
                                                                                                node: string | (() => G2Element),
                                                                                                className?: string
                                                                                                ) => Selection<any>;

                                                                                                  method merge

                                                                                                  merge: (other: Selection<T>) => Selection<T>;

                                                                                                    method node

                                                                                                    node: () => G2Element;

                                                                                                      method nodes

                                                                                                      nodes: () => G2Element[];

                                                                                                        method on

                                                                                                        on: (event: string, handler: any) => this;

                                                                                                          method parent

                                                                                                          parent: () => DisplayObject;

                                                                                                            method remove

                                                                                                            remove: () => Selection<T>;

                                                                                                              method select

                                                                                                              select: (selector: string | G2Element) => Selection<T>;
                                                                                                              • Replace with querySelector which has bug now.

                                                                                                              method selectAll

                                                                                                              selectAll: (selector: string | G2Element[]) => Selection<T>;

                                                                                                                method selectFacetAll

                                                                                                                selectFacetAll: (selector: string | G2Element[]) => Selection<T>;

                                                                                                                  method style

                                                                                                                  style: (key: string, value: any) => Selection<T>;

                                                                                                                    method transition

                                                                                                                    transition: (value: any) => Selection<T>;

                                                                                                                      method transitions

                                                                                                                      transitions: () => (GAnimation | GAnimation[])[];

                                                                                                                        Interfaces

                                                                                                                        interface Chart

                                                                                                                        interface Chart extends API<G2Spec, typeof library> {}

                                                                                                                          interface CompositionNode

                                                                                                                          interface CompositionNode extends CompositionAPI<typeof library> {}

                                                                                                                            interface MarkNode

                                                                                                                            interface MarkNode extends Node {}

                                                                                                                              interface SymbolFactor

                                                                                                                              interface SymbolFactor {}

                                                                                                                                property style

                                                                                                                                style?: string[];

                                                                                                                                  call signature

                                                                                                                                  (x: number, y: number, r: number): PathArray;

                                                                                                                                    Type Aliases

                                                                                                                                    type AcademyTheme

                                                                                                                                    type AcademyTheme = {
                                                                                                                                    type?: 'academy';
                                                                                                                                    } & ThemeOptions;

                                                                                                                                      type Animation

                                                                                                                                      type Animation =
                                                                                                                                      | FadeInAnimation
                                                                                                                                      | FadeOutAnimation
                                                                                                                                      | ScaleInXAnimation
                                                                                                                                      | ScaleOutXAnimation
                                                                                                                                      | ScaleInYAnimation
                                                                                                                                      | ScaleOutYAnimation
                                                                                                                                      | WaveInAnimation
                                                                                                                                      | MorphingAnimation
                                                                                                                                      | ZoomInAnimation
                                                                                                                                      | ZoomOutYAnimation
                                                                                                                                      | PathInAnimation
                                                                                                                                      | GrowInXAnimation
                                                                                                                                      | GrowInYAnimation;

                                                                                                                                        type AnimationTypes

                                                                                                                                        type AnimationTypes =
                                                                                                                                        | 'fadeIn'
                                                                                                                                        | 'fadeOut'
                                                                                                                                        | 'scaleInX'
                                                                                                                                        | 'scaleOutX'
                                                                                                                                        | 'scaleInY'
                                                                                                                                        | 'scaleOutY'
                                                                                                                                        | 'waveIn'
                                                                                                                                        | 'morphing'
                                                                                                                                        | 'zoomIn'
                                                                                                                                        | 'zoomOut'
                                                                                                                                        | 'pathIn'
                                                                                                                                        | 'growInX'
                                                                                                                                        | 'growInY';

                                                                                                                                          type AreaMark

                                                                                                                                          type AreaMark = BaseMark<'area', ChannelTypes>;

                                                                                                                                            type AtheisticChanelTypes

                                                                                                                                            type AtheisticChanelTypes = 'size' | 'color' | 'shape' | 'opacity';

                                                                                                                                              type AxisComponent

                                                                                                                                              type AxisComponent = {
                                                                                                                                              type?: 'axisX' | 'axisY' | 'axisZ';
                                                                                                                                              tickCount?: number;
                                                                                                                                              labelFormatter?: any;
                                                                                                                                              tickFilter?: any;
                                                                                                                                              title?: any;
                                                                                                                                              state?: Partial<
                                                                                                                                              Record<
                                                                                                                                              'active' | 'selected' | 'inactive' | 'unselected',
                                                                                                                                              Record<string, any>
                                                                                                                                              >
                                                                                                                                              >;
                                                                                                                                              scale?: Record<string, any>;
                                                                                                                                              [key: string]: any;
                                                                                                                                              };

                                                                                                                                                type AxisOptions

                                                                                                                                                type AxisOptions = {
                                                                                                                                                position?: GCP;
                                                                                                                                                plane?: GuideComponentPlane;
                                                                                                                                                zIndex?: number;
                                                                                                                                                title?: string | string[];
                                                                                                                                                direction?: 'left' | 'center' | 'right';
                                                                                                                                                labelFormatter?: (datum: any, index: number, array: any[]) => string;
                                                                                                                                                labelFilter?: (datum: any, index: number, array: any[]) => boolean;
                                                                                                                                                tickFormatter?: (
                                                                                                                                                datum: any,
                                                                                                                                                index: number,
                                                                                                                                                array: any[],
                                                                                                                                                vector: [number, number]
                                                                                                                                                ) => DisplayObject;
                                                                                                                                                tickFilter?: (datum: any, index: number, array: any[]) => boolean;
                                                                                                                                                tickMethod?: (
                                                                                                                                                start: number | Date,
                                                                                                                                                end: number | Date,
                                                                                                                                                tickCount: number
                                                                                                                                                ) => number[];
                                                                                                                                                tickCount?: number;
                                                                                                                                                grid: any;
                                                                                                                                                important: Record<string, any>;
                                                                                                                                                /**
                                                                                                                                                * Rotation origin.
                                                                                                                                                */
                                                                                                                                                origin?: Vector3;
                                                                                                                                                /**
                                                                                                                                                * EulerAngles of rotation.
                                                                                                                                                */
                                                                                                                                                eulerAngles?: Vector3;
                                                                                                                                                [key: string]: any;
                                                                                                                                                };

                                                                                                                                                  type BandScale

                                                                                                                                                  type BandScale = BaseScale<'band', BandOptions>;

                                                                                                                                                    type BaseCoordinate

                                                                                                                                                    type BaseCoordinate<T> = T & {
                                                                                                                                                    transform?: CoordinateTransform[];
                                                                                                                                                    };

                                                                                                                                                      type BaseMark

                                                                                                                                                      type BaseMark<T extends MarkTypes, C extends string = ChannelTypes> = {
                                                                                                                                                      type?: T | string;
                                                                                                                                                      class?: string;
                                                                                                                                                      key?: string;
                                                                                                                                                      x?: number;
                                                                                                                                                      y?: number;
                                                                                                                                                      width?: number;
                                                                                                                                                      height?: number;
                                                                                                                                                      paddingLeft?: Padding;
                                                                                                                                                      paddingRight?: Padding;
                                                                                                                                                      paddingBottom?: Padding;
                                                                                                                                                      paddingTop?: Padding;
                                                                                                                                                      padding?: Padding;
                                                                                                                                                      inset?: number;
                                                                                                                                                      insetLeft?: number;
                                                                                                                                                      insetBottom?: number;
                                                                                                                                                      insetTop?: number;
                                                                                                                                                      insetRight?: number;
                                                                                                                                                      margin?: number;
                                                                                                                                                      marginLeft?: number;
                                                                                                                                                      marginBottom?: number;
                                                                                                                                                      marginTop?: number;
                                                                                                                                                      marginRight?: number;
                                                                                                                                                      facet?: boolean;
                                                                                                                                                      frame?: boolean;
                                                                                                                                                      zIndex?: number;
                                                                                                                                                      cartesian?: boolean;
                                                                                                                                                      clip?: boolean;
                                                                                                                                                      data?: Data;
                                                                                                                                                      transform?: Transform[];
                                                                                                                                                      layout?: Record<string, any>;
                                                                                                                                                      encode?: Partial<Record<C, Encode | Encode[]>>;
                                                                                                                                                      scale?: Partial<Record<C, Scale>>;
                                                                                                                                                      coordinate?: Coordinate;
                                                                                                                                                      style?: Record<string, any>;
                                                                                                                                                      viewStyle?: Record<string, any>;
                                                                                                                                                      state?: Partial<
                                                                                                                                                      Record<
                                                                                                                                                      'active' | 'selected' | 'inactive' | 'unselected',
                                                                                                                                                      Record<string, any>
                                                                                                                                                      >
                                                                                                                                                      >;
                                                                                                                                                      animate?: Closeable<
                                                                                                                                                      Partial<Record<'enter' | 'update' | 'exit', Closeable<Animation>>>
                                                                                                                                                      >;
                                                                                                                                                      labels?: Record<string, any>[];
                                                                                                                                                      tooltip?: TooltipComponent;
                                                                                                                                                      axis?: Closeable<
                                                                                                                                                      Partial<Record<PositionChannelTypes, Closeable<AxisComponent>>>
                                                                                                                                                      >;
                                                                                                                                                      legend?: Closeable<
                                                                                                                                                      Partial<Record<AtheisticChanelTypes, Closeable<LegendComponent>>>
                                                                                                                                                      >;
                                                                                                                                                      slider?: Closeable<
                                                                                                                                                      Partial<Record<PositionChannelTypes, Closeable<SliderComponent>>>
                                                                                                                                                      >;
                                                                                                                                                      scrollbar?: Closeable<
                                                                                                                                                      Partial<Record<PositionChannelTypes, Closeable<ScrollbarComponent>>>
                                                                                                                                                      >;
                                                                                                                                                      title?: string | TitleComponent;
                                                                                                                                                      interaction?: Literal2Object<Interaction> & Record<string, any>;
                                                                                                                                                      theme?: Theme;
                                                                                                                                                      };

                                                                                                                                                        type BaseScale

                                                                                                                                                        type BaseScale<T extends ScaleTypes, O> = {
                                                                                                                                                        type?: T;
                                                                                                                                                        palette?: Palette['type'] | string;
                                                                                                                                                        rangeMax?: number;
                                                                                                                                                        rangeMin?: number;
                                                                                                                                                        domainMax?: number;
                                                                                                                                                        domainMin?: number;
                                                                                                                                                        key?: string;
                                                                                                                                                        facet?: boolean;
                                                                                                                                                        independent?: boolean;
                                                                                                                                                        zero?: boolean;
                                                                                                                                                        offset?: (t: number) => number;
                                                                                                                                                        relations?: [any, any][];
                                                                                                                                                        groupTransform?: (scales: QuantitativeScale[]) => void;
                                                                                                                                                        } & O;

                                                                                                                                                          type BinOptions

                                                                                                                                                          type BinOptions = Omit<BinTransform, 'type'> & {
                                                                                                                                                          groupChannels?: string[];
                                                                                                                                                          binChannels?: string[];
                                                                                                                                                          };

                                                                                                                                                            type BinTransform

                                                                                                                                                            type BinTransform = {
                                                                                                                                                            type?: 'bin';
                                                                                                                                                            thresholdsX?: number;
                                                                                                                                                            thresholdsY?: number;
                                                                                                                                                            } & {
                                                                                                                                                            [key in ChannelTypes]?: Reducer;
                                                                                                                                                            };

                                                                                                                                                              type BinXOptions

                                                                                                                                                              type BinXOptions = Omit<BinXTransform, 'type'>;

                                                                                                                                                                type BinXTransform

                                                                                                                                                                type BinXTransform = {
                                                                                                                                                                type?: 'binX';
                                                                                                                                                                thresholds?: number;
                                                                                                                                                                } & {
                                                                                                                                                                [key in ChannelTypes]?: Reducer;
                                                                                                                                                                };

                                                                                                                                                                  type BoxMark

                                                                                                                                                                  type BoxMark = BaseMark<'box', ChannelTypes>;

                                                                                                                                                                    type BoxPlotMark

                                                                                                                                                                    type BoxPlotMark = BaseMark<'box', ChannelTypes>;

                                                                                                                                                                      type BrushAxisHighlightInteraction

                                                                                                                                                                      type BrushAxisHighlightInteraction = {
                                                                                                                                                                      type?: 'brushAxisHighlight';
                                                                                                                                                                      reverse?: boolean;
                                                                                                                                                                      brushKey?: string;
                                                                                                                                                                      } & Record<`${'mask'}${any}`, any>;

                                                                                                                                                                        type BrushFilterInteraction

                                                                                                                                                                        type BrushFilterInteraction = {
                                                                                                                                                                        type?: 'brushFilter';
                                                                                                                                                                        reverse?: boolean;
                                                                                                                                                                        } & Record<`${'mask'}${any}`, any>;

                                                                                                                                                                          type BrushHighlightInteraction

                                                                                                                                                                          type BrushHighlightInteraction = {
                                                                                                                                                                          type?: 'brushHighlight';
                                                                                                                                                                          brushKey?: string;
                                                                                                                                                                          reverse?: boolean;
                                                                                                                                                                          series?: boolean;
                                                                                                                                                                          facet?: boolean;
                                                                                                                                                                          } & Record<`${'mask'}${any}`, any>;

                                                                                                                                                                            type BrushXFilterInteraction

                                                                                                                                                                            type BrushXFilterInteraction = {
                                                                                                                                                                            type?: 'brushXFilter';
                                                                                                                                                                            reverse?: boolean;
                                                                                                                                                                            } & Record<`${'mask'}${any}`, any>;

                                                                                                                                                                              type BrushXHighlightInteraction

                                                                                                                                                                              type BrushXHighlightInteraction = {
                                                                                                                                                                              type?: 'brushXHighlight';
                                                                                                                                                                              brushKey?: string;
                                                                                                                                                                              reverse?: boolean;
                                                                                                                                                                              series?: boolean;
                                                                                                                                                                              facet?: boolean;
                                                                                                                                                                              } & Record<`${'mask'}${any}`, any>;

                                                                                                                                                                                type BrushYFilterInteraction

                                                                                                                                                                                type BrushYFilterInteraction = {
                                                                                                                                                                                type?: 'brushYFilter';
                                                                                                                                                                                reverse?: boolean;
                                                                                                                                                                                } & Record<`${'mask'}${any}`, any>;

                                                                                                                                                                                  type BrushYHighlightInteraction

                                                                                                                                                                                  type BrushYHighlightInteraction = {
                                                                                                                                                                                  type?: 'brushYHighlight';
                                                                                                                                                                                  brushKey?: string;
                                                                                                                                                                                  reverse?: boolean;
                                                                                                                                                                                  series?: boolean;
                                                                                                                                                                                  facet?: boolean;
                                                                                                                                                                                  } & Record<`${'mask'}${any}`, any>;

                                                                                                                                                                                    type CartesianCoordinate

                                                                                                                                                                                    type CartesianCoordinate = BaseCoordinate<{
                                                                                                                                                                                    type?: 'cartesian';
                                                                                                                                                                                    }>;

                                                                                                                                                                                      type Category10Palette

                                                                                                                                                                                      type Category10Palette = {
                                                                                                                                                                                      type?: 'category10';
                                                                                                                                                                                      };

                                                                                                                                                                                        type Category20Palette

                                                                                                                                                                                        type Category20Palette = {
                                                                                                                                                                                        type?: 'category20';
                                                                                                                                                                                        };

                                                                                                                                                                                          type CellMark

                                                                                                                                                                                          type CellMark = BaseMark<'cell', ChannelTypes>;

                                                                                                                                                                                            type Channel

                                                                                                                                                                                            type Channel = {
                                                                                                                                                                                            name?: string;
                                                                                                                                                                                            scale?: string;
                                                                                                                                                                                            quantitative?: string;
                                                                                                                                                                                            ordinal?: string;
                                                                                                                                                                                            scaleName?: string;
                                                                                                                                                                                            required?: boolean;
                                                                                                                                                                                            value?: Primitive[];
                                                                                                                                                                                            type?: string;
                                                                                                                                                                                            independent?: boolean;
                                                                                                                                                                                            field?: string | string[];
                                                                                                                                                                                            visual?: boolean;
                                                                                                                                                                                            range?: any[];
                                                                                                                                                                                            scaleKey?: string;
                                                                                                                                                                                            };

                                                                                                                                                                                              type ChannelTypes

                                                                                                                                                                                              type ChannelTypes =
                                                                                                                                                                                              | 'x'
                                                                                                                                                                                              | 'y'
                                                                                                                                                                                              | 'z'
                                                                                                                                                                                              | 'x1'
                                                                                                                                                                                              | 'y1'
                                                                                                                                                                                              | 'series'
                                                                                                                                                                                              | 'color'
                                                                                                                                                                                              | 'opacity'
                                                                                                                                                                                              | 'shape'
                                                                                                                                                                                              | 'size'
                                                                                                                                                                                              | 'key'
                                                                                                                                                                                              | 'groupKey'
                                                                                                                                                                                              | 'position'
                                                                                                                                                                                              | 'series'
                                                                                                                                                                                              | 'enterType'
                                                                                                                                                                                              | 'enterEasing'
                                                                                                                                                                                              | 'enterDuration'
                                                                                                                                                                                              | 'enterDelay'
                                                                                                                                                                                              | 'updateType'
                                                                                                                                                                                              | 'updateEasing'
                                                                                                                                                                                              | 'updateDuration'
                                                                                                                                                                                              | 'updateDelay'
                                                                                                                                                                                              | 'exitType'
                                                                                                                                                                                              | 'exitEasing'
                                                                                                                                                                                              | 'exitDuration'
                                                                                                                                                                                              | 'exitDelay'
                                                                                                                                                                                              | `position${number}`;

                                                                                                                                                                                                type ChartIndexInteraction

                                                                                                                                                                                                type ChartIndexInteraction = {
                                                                                                                                                                                                type?: 'chartIndex';
                                                                                                                                                                                                wait?: number;
                                                                                                                                                                                                leading?: boolean;
                                                                                                                                                                                                trailing?: boolean;
                                                                                                                                                                                                } & Record<`${'rule' | 'label'}${any}`, any>;

                                                                                                                                                                                                  type ChartOptions

                                                                                                                                                                                                  type ChartOptions = Omit<RuntimeOptions, 'lib'>;

                                                                                                                                                                                                    type ChordMark

                                                                                                                                                                                                    type ChordMark = BaseMark<
                                                                                                                                                                                                    'chord',
                                                                                                                                                                                                    | 'source'
                                                                                                                                                                                                    | 'target'
                                                                                                                                                                                                    | 'value'
                                                                                                                                                                                                    | `node${Capitalize<ChannelTypes>}`
                                                                                                                                                                                                    | `link${Capitalize<ChannelTypes>}`
                                                                                                                                                                                                    | ChannelTypes
                                                                                                                                                                                                    > & {
                                                                                                                                                                                                    layout?: {
                                                                                                                                                                                                    nodes?: (graph: any) => any;
                                                                                                                                                                                                    links?: (graph: any) => any;
                                                                                                                                                                                                    y?: number;
                                                                                                                                                                                                    id?: (node: any) => any;
                                                                                                                                                                                                    sortBy?: 'id' | 'weight' | 'frequency' | null | ((a: any, b: any) => number);
                                                                                                                                                                                                    nodeWidthRatio?: number;
                                                                                                                                                                                                    nodePaddingRatio?: number;
                                                                                                                                                                                                    sourceWeight?(edge: any): number;
                                                                                                                                                                                                    targetWeight?(edge: any): number;
                                                                                                                                                                                                    };
                                                                                                                                                                                                    nodeLabels: Record<string, any>[];
                                                                                                                                                                                                    linkLabels: Record<string, any>[];
                                                                                                                                                                                                    };

                                                                                                                                                                                                      type ClassicDarkTheme

                                                                                                                                                                                                      type ClassicDarkTheme = {
                                                                                                                                                                                                      type?: 'classicDark';
                                                                                                                                                                                                      } & ThemeOptions;

                                                                                                                                                                                                        type ClassicTheme

                                                                                                                                                                                                        type ClassicTheme = {
                                                                                                                                                                                                        type?: 'classic';
                                                                                                                                                                                                        } & ThemeOptions;

                                                                                                                                                                                                          type ColumnEncode

                                                                                                                                                                                                          type ColumnEncode = {
                                                                                                                                                                                                          type?: 'column';
                                                                                                                                                                                                          value?: Primitive[];
                                                                                                                                                                                                          };

                                                                                                                                                                                                            type Component

                                                                                                                                                                                                            type Component =
                                                                                                                                                                                                            | TitleComponent
                                                                                                                                                                                                            | AxisComponent
                                                                                                                                                                                                            | LegendComponent
                                                                                                                                                                                                            | ScrollbarComponent
                                                                                                                                                                                                            | SliderComponent
                                                                                                                                                                                                            | TooltipComponent;

                                                                                                                                                                                                              type CompositeMark

                                                                                                                                                                                                              type CompositeMark = BaseMark<CompositeMarkType>;

                                                                                                                                                                                                                type CompositeMarkType

                                                                                                                                                                                                                type CompositeMarkType = (
                                                                                                                                                                                                                options: Record<string, any>,
                                                                                                                                                                                                                context: Record<string, any>
                                                                                                                                                                                                                ) => any[];

                                                                                                                                                                                                                  type Composition

                                                                                                                                                                                                                  type Composition =
                                                                                                                                                                                                                  | ViewComposition
                                                                                                                                                                                                                  | GeoViewComposition
                                                                                                                                                                                                                  | GeoPathComposition
                                                                                                                                                                                                                  | SpaceLayerComposition
                                                                                                                                                                                                                  | SpaceFlexComposition
                                                                                                                                                                                                                  | RepeatMatrixComposition
                                                                                                                                                                                                                  | FacetRectComposition
                                                                                                                                                                                                                  | FacetCircleComposition
                                                                                                                                                                                                                  | TimingKeyframeComposition;

                                                                                                                                                                                                                    type CompositionTypes

                                                                                                                                                                                                                    type CompositionTypes =
                                                                                                                                                                                                                    | 'view'
                                                                                                                                                                                                                    | 'getView'
                                                                                                                                                                                                                    | 'geoPath'
                                                                                                                                                                                                                    | 'spaceLayer'
                                                                                                                                                                                                                    | 'spaceFlex'
                                                                                                                                                                                                                    | 'facetRect'
                                                                                                                                                                                                                    | 'facetCircle'
                                                                                                                                                                                                                    | 'repeatMatrix'
                                                                                                                                                                                                                    | 'timingKeyframe';

                                                                                                                                                                                                                      type ConnectorMark

                                                                                                                                                                                                                      type ConnectorMark = BaseMark<'connector', ChannelTypes>;

                                                                                                                                                                                                                        type ConstantEncode

                                                                                                                                                                                                                        type ConstantEncode = {
                                                                                                                                                                                                                        type?: 'constant';
                                                                                                                                                                                                                        value?: any;
                                                                                                                                                                                                                        };

                                                                                                                                                                                                                          type ConstantScale

                                                                                                                                                                                                                          type ConstantScale = BaseScale<'constant', ConstantOptions>;

                                                                                                                                                                                                                            type ContrastReverseLabelTransform

                                                                                                                                                                                                                            type ContrastReverseLabelTransform = {
                                                                                                                                                                                                                            type: 'contrastReverse';
                                                                                                                                                                                                                            /**
                                                                                                                                                                                                                            * Transform when the contrast ratio < threshold.
                                                                                                                                                                                                                            * Default is `4.5`.
                                                                                                                                                                                                                            */
                                                                                                                                                                                                                            threshold?: number;
                                                                                                                                                                                                                            /**
                                                                                                                                                                                                                            * The optional color palette, default is [#000, #fff].
                                                                                                                                                                                                                            */
                                                                                                                                                                                                                            palette?: string[];
                                                                                                                                                                                                                            };

                                                                                                                                                                                                                              type Coordinate

                                                                                                                                                                                                                              type Coordinate =
                                                                                                                                                                                                                              | PolarCoordinate
                                                                                                                                                                                                                              | HelixCoordinate
                                                                                                                                                                                                                              | ThetaCoordinate
                                                                                                                                                                                                                              | CustomCoordinate
                                                                                                                                                                                                                              | CartesianCoordinate
                                                                                                                                                                                                                              | ParallelCoordinate
                                                                                                                                                                                                                              | RadialCoordinate
                                                                                                                                                                                                                              | RadarCoordinate
                                                                                                                                                                                                                              | GeoCoordinate;

                                                                                                                                                                                                                                type CoordinateTransform

                                                                                                                                                                                                                                type CoordinateTransform = TransposeCoordinate | FisheyeCoordinate;

                                                                                                                                                                                                                                  type CoordinateTransformTypes

                                                                                                                                                                                                                                  type CoordinateTransformTypes = 'transpose' | 'fisheye';

                                                                                                                                                                                                                                    type CoordinateTypes

                                                                                                                                                                                                                                    type CoordinateTypes =
                                                                                                                                                                                                                                    | 'polar'
                                                                                                                                                                                                                                    | 'helix'
                                                                                                                                                                                                                                    | 'transpose'
                                                                                                                                                                                                                                    | 'theta'
                                                                                                                                                                                                                                    | 'cartesian'
                                                                                                                                                                                                                                    | 'cartesian3D'
                                                                                                                                                                                                                                    | 'parallel'
                                                                                                                                                                                                                                    | 'fisheye'
                                                                                                                                                                                                                                    | 'radial'
                                                                                                                                                                                                                                    | 'radar'
                                                                                                                                                                                                                                    | string;

                                                                                                                                                                                                                                      type CustomCoordinate

                                                                                                                                                                                                                                      type CustomCoordinate = BaseCoordinate<{
                                                                                                                                                                                                                                      type: CoordinateComponent;
                                                                                                                                                                                                                                      [key: string]: any;
                                                                                                                                                                                                                                      }>;

                                                                                                                                                                                                                                        type CustomDataTransform

                                                                                                                                                                                                                                        type CustomDataTransform = {
                                                                                                                                                                                                                                        type?: 'custom';
                                                                                                                                                                                                                                        callback?: (d: any) => any;
                                                                                                                                                                                                                                        };

                                                                                                                                                                                                                                          type CustomEncode

                                                                                                                                                                                                                                          type CustomEncode = {
                                                                                                                                                                                                                                          type?: EncodeComponent;
                                                                                                                                                                                                                                          [key: string]: any;
                                                                                                                                                                                                                                          };

                                                                                                                                                                                                                                            type CustomInteraction

                                                                                                                                                                                                                                            type CustomInteraction = {
                                                                                                                                                                                                                                            type?: InteractionComponent;
                                                                                                                                                                                                                                            [key: string]: any;
                                                                                                                                                                                                                                            };

                                                                                                                                                                                                                                              type CustomMark

                                                                                                                                                                                                                                              type CustomMark = BaseMark<MarkComponent, ChannelTypes>;

                                                                                                                                                                                                                                                type CustomPalette

                                                                                                                                                                                                                                                type CustomPalette = {
                                                                                                                                                                                                                                                type?: PaletteComponent;
                                                                                                                                                                                                                                                [key: string]: any;
                                                                                                                                                                                                                                                };

                                                                                                                                                                                                                                                  type CustomScale

                                                                                                                                                                                                                                                  type CustomScale = BaseScale<
                                                                                                                                                                                                                                                  ScaleComponent,
                                                                                                                                                                                                                                                  {
                                                                                                                                                                                                                                                  [key: string]: any;
                                                                                                                                                                                                                                                  }
                                                                                                                                                                                                                                                  >;

                                                                                                                                                                                                                                                    type CustomTheme

                                                                                                                                                                                                                                                    type CustomTheme = {
                                                                                                                                                                                                                                                    type?: ThemeComponent;
                                                                                                                                                                                                                                                    } & ThemeOptions;

                                                                                                                                                                                                                                                      type CustomTransform

                                                                                                                                                                                                                                                      type CustomTransform = {
                                                                                                                                                                                                                                                      type?: DataComponent;
                                                                                                                                                                                                                                                      [key: string]: any;
                                                                                                                                                                                                                                                      };

                                                                                                                                                                                                                                                        type DarkTheme

                                                                                                                                                                                                                                                        type DarkTheme = {
                                                                                                                                                                                                                                                        type?: 'dark';
                                                                                                                                                                                                                                                        } & ThemeOptions;

                                                                                                                                                                                                                                                          type Data

                                                                                                                                                                                                                                                          type Data = FetchConnector | InlineConnector;

                                                                                                                                                                                                                                                            type DataTransform

                                                                                                                                                                                                                                                            type DataTransform =
                                                                                                                                                                                                                                                            | SortByTransform
                                                                                                                                                                                                                                                            | SortTransform
                                                                                                                                                                                                                                                            | PickTransform
                                                                                                                                                                                                                                                            | RenameTransform
                                                                                                                                                                                                                                                            | FoldTransform
                                                                                                                                                                                                                                                            | JoinTransform
                                                                                                                                                                                                                                                            | FilterDataTransform
                                                                                                                                                                                                                                                            | MapTransform
                                                                                                                                                                                                                                                            | SliceTransform
                                                                                                                                                                                                                                                            | KDEDataTransform
                                                                                                                                                                                                                                                            | VennDataTransform
                                                                                                                                                                                                                                                            | LogDataTransform
                                                                                                                                                                                                                                                            | CustomTransform
                                                                                                                                                                                                                                                            | EMADataTransform;

                                                                                                                                                                                                                                                              type DataTransformTypes

                                                                                                                                                                                                                                                              type DataTransformTypes =
                                                                                                                                                                                                                                                              | 'sortBy'
                                                                                                                                                                                                                                                              | 'sort'
                                                                                                                                                                                                                                                              | 'pick'
                                                                                                                                                                                                                                                              | 'rename'
                                                                                                                                                                                                                                                              | 'fold'
                                                                                                                                                                                                                                                              | 'join'
                                                                                                                                                                                                                                                              | 'filter'
                                                                                                                                                                                                                                                              | 'map'
                                                                                                                                                                                                                                                              | 'slice'
                                                                                                                                                                                                                                                              | 'kde'
                                                                                                                                                                                                                                                              | 'venn'
                                                                                                                                                                                                                                                              | 'log'
                                                                                                                                                                                                                                                              | 'custom'
                                                                                                                                                                                                                                                              | 'ema'
                                                                                                                                                                                                                                                              | DataComponent;

                                                                                                                                                                                                                                                                type DataTypes

                                                                                                                                                                                                                                                                type DataTypes = 'inline' | 'fetch';

                                                                                                                                                                                                                                                                  type DensityMark

                                                                                                                                                                                                                                                                  type DensityMark = BaseMark<'density', ChannelTypes | 'series'>;

                                                                                                                                                                                                                                                                    type DiffYOptions

                                                                                                                                                                                                                                                                    type DiffYOptions = Omit<DiffYTransform, 'type'>;

                                                                                                                                                                                                                                                                      type DiffYTransform

                                                                                                                                                                                                                                                                      type DiffYTransform = {
                                                                                                                                                                                                                                                                      type?: 'diffY';
                                                                                                                                                                                                                                                                      groupBy?: string | string[];
                                                                                                                                                                                                                                                                      };

                                                                                                                                                                                                                                                                        type DodgeXOptions

                                                                                                                                                                                                                                                                        type DodgeXOptions = Omit<DodgeXTransform, 'type'>;

                                                                                                                                                                                                                                                                          type DodgeXTransform

                                                                                                                                                                                                                                                                          type DodgeXTransform = {
                                                                                                                                                                                                                                                                          type?: 'dodgeX';
                                                                                                                                                                                                                                                                          groupBy?: string | string[];
                                                                                                                                                                                                                                                                          reverse?: boolean;
                                                                                                                                                                                                                                                                          orderBy?: TransformOrder;
                                                                                                                                                                                                                                                                          padding?: number;
                                                                                                                                                                                                                                                                          };

                                                                                                                                                                                                                                                                            type EdgeMark

                                                                                                                                                                                                                                                                            type EdgeMark = BaseMark<'edge', ChannelTypes>;

                                                                                                                                                                                                                                                                              type ElementHighlightByColorInteraction

                                                                                                                                                                                                                                                                              type ElementHighlightByColorInteraction = {
                                                                                                                                                                                                                                                                              type?: 'elementHighlightByColor';
                                                                                                                                                                                                                                                                              color?: string;
                                                                                                                                                                                                                                                                              background?: boolean;
                                                                                                                                                                                                                                                                              link?: boolean;
                                                                                                                                                                                                                                                                              offset?: number;
                                                                                                                                                                                                                                                                              delay?: number;
                                                                                                                                                                                                                                                                              } & Record<`${'link' | 'background'}${any}`, any>;

                                                                                                                                                                                                                                                                                type ElementHighlightByXInteraction

                                                                                                                                                                                                                                                                                type ElementHighlightByXInteraction = {
                                                                                                                                                                                                                                                                                type?: 'elementHighlightByX';
                                                                                                                                                                                                                                                                                link?: boolean;
                                                                                                                                                                                                                                                                                background?: boolean;
                                                                                                                                                                                                                                                                                offset?: number;
                                                                                                                                                                                                                                                                                delay?: number;
                                                                                                                                                                                                                                                                                } & Record<`${'link' | 'background'}${any}`, any>;

                                                                                                                                                                                                                                                                                  type ElementHighlightInteraction

                                                                                                                                                                                                                                                                                  type ElementHighlightInteraction = {
                                                                                                                                                                                                                                                                                  type?: 'elementHighlight';
                                                                                                                                                                                                                                                                                  link?: boolean;
                                                                                                                                                                                                                                                                                  background?: boolean;
                                                                                                                                                                                                                                                                                  offset?: number;
                                                                                                                                                                                                                                                                                  region?: boolean;
                                                                                                                                                                                                                                                                                  } & Record<`${'link' | 'background' | 'state'}${any}`, any>;

                                                                                                                                                                                                                                                                                    type ElementSelectByColorInteraction

                                                                                                                                                                                                                                                                                    type ElementSelectByColorInteraction = {
                                                                                                                                                                                                                                                                                    type?: 'elementSelectByColor';
                                                                                                                                                                                                                                                                                    single?: boolean;
                                                                                                                                                                                                                                                                                    offset?: number;
                                                                                                                                                                                                                                                                                    background?: boolean;
                                                                                                                                                                                                                                                                                    } & Record<`${'link' | 'background'}${any}`, any>;

                                                                                                                                                                                                                                                                                      type ElementSelectByXInteraction

                                                                                                                                                                                                                                                                                      type ElementSelectByXInteraction = {
                                                                                                                                                                                                                                                                                      type?: 'elementSelectByX';
                                                                                                                                                                                                                                                                                      region?: boolean;
                                                                                                                                                                                                                                                                                      single?: boolean;
                                                                                                                                                                                                                                                                                      background?: boolean;
                                                                                                                                                                                                                                                                                      offset?: number;
                                                                                                                                                                                                                                                                                      } & Record<`${'link' | 'background'}${any}`, any>;

                                                                                                                                                                                                                                                                                        type ElementSelectInteraction

                                                                                                                                                                                                                                                                                        type ElementSelectInteraction = {
                                                                                                                                                                                                                                                                                        type?: 'elementSelect';
                                                                                                                                                                                                                                                                                        single?: boolean;
                                                                                                                                                                                                                                                                                        background?: boolean;
                                                                                                                                                                                                                                                                                        offset?: number;
                                                                                                                                                                                                                                                                                        multipleSelectHotkey?: string;
                                                                                                                                                                                                                                                                                        region?: boolean;
                                                                                                                                                                                                                                                                                        } & Record<`${'link' | 'background' | 'state'}${any}`, any>;

                                                                                                                                                                                                                                                                                          type EMADataTransform

                                                                                                                                                                                                                                                                                          type EMADataTransform = {
                                                                                                                                                                                                                                                                                          type?: 'ema';
                                                                                                                                                                                                                                                                                          field?: string;
                                                                                                                                                                                                                                                                                          alpha?: number;
                                                                                                                                                                                                                                                                                          as?: string;
                                                                                                                                                                                                                                                                                          };

                                                                                                                                                                                                                                                                                            type Encode

                                                                                                                                                                                                                                                                                            type Encode =
                                                                                                                                                                                                                                                                                            | ConstantEncode
                                                                                                                                                                                                                                                                                            | FieldEncode
                                                                                                                                                                                                                                                                                            | TransformEncode
                                                                                                                                                                                                                                                                                            | ColumnEncode
                                                                                                                                                                                                                                                                                            | ConstantEncode['value']
                                                                                                                                                                                                                                                                                            | FieldEncode['value']
                                                                                                                                                                                                                                                                                            | TransformEncode['value'];

                                                                                                                                                                                                                                                                                              type Encodeable

                                                                                                                                                                                                                                                                                              type Encodeable<T> = T | ((d: any, index?: number, data?: any[], column?: any) => T);

                                                                                                                                                                                                                                                                                                type EncodeTypes

                                                                                                                                                                                                                                                                                                type EncodeTypes = 'constant' | 'field' | 'transform' | 'column' | EncodeComponent;

                                                                                                                                                                                                                                                                                                  type ExceedAdjustLabel

                                                                                                                                                                                                                                                                                                  type ExceedAdjustLabel = {
                                                                                                                                                                                                                                                                                                  type: 'exceedAdjust';
                                                                                                                                                                                                                                                                                                  };

                                                                                                                                                                                                                                                                                                    type FacetCircleComposition

                                                                                                                                                                                                                                                                                                    type FacetCircleComposition = {
                                                                                                                                                                                                                                                                                                    type?: 'facetCircle';
                                                                                                                                                                                                                                                                                                    padding?: Padding;
                                                                                                                                                                                                                                                                                                    paddingLeft?: Padding;
                                                                                                                                                                                                                                                                                                    paddingRight?: Padding;
                                                                                                                                                                                                                                                                                                    paddingTop?: Padding;
                                                                                                                                                                                                                                                                                                    paddingBottom?: Padding;
                                                                                                                                                                                                                                                                                                    margin?: number;
                                                                                                                                                                                                                                                                                                    marginLeft?: number;
                                                                                                                                                                                                                                                                                                    marginBottom?: number;
                                                                                                                                                                                                                                                                                                    marginTop?: number;
                                                                                                                                                                                                                                                                                                    marginRight?: number;
                                                                                                                                                                                                                                                                                                    transform?: Transform;
                                                                                                                                                                                                                                                                                                    title?: string | TitleComponent;
                                                                                                                                                                                                                                                                                                    data?: Data;
                                                                                                                                                                                                                                                                                                    key?: string;
                                                                                                                                                                                                                                                                                                    encode?: {
                                                                                                                                                                                                                                                                                                    position?: string;
                                                                                                                                                                                                                                                                                                    };
                                                                                                                                                                                                                                                                                                    scale?: {
                                                                                                                                                                                                                                                                                                    x?: Scale;
                                                                                                                                                                                                                                                                                                    y?: Scale;
                                                                                                                                                                                                                                                                                                    color?: Scale;
                                                                                                                                                                                                                                                                                                    };
                                                                                                                                                                                                                                                                                                    children?: Node[] | ((facet: FacetContext) => Node);
                                                                                                                                                                                                                                                                                                    axis?: Record<string, any> | boolean;
                                                                                                                                                                                                                                                                                                    legend?: Record<string, any> | boolean;
                                                                                                                                                                                                                                                                                                    [key: string]: any;
                                                                                                                                                                                                                                                                                                    };

                                                                                                                                                                                                                                                                                                      type FacetContext

                                                                                                                                                                                                                                                                                                      type FacetContext = {
                                                                                                                                                                                                                                                                                                      columnField?: string | number;
                                                                                                                                                                                                                                                                                                      columnIndex?: number;
                                                                                                                                                                                                                                                                                                      columnValue?: string | number;
                                                                                                                                                                                                                                                                                                      columnValuesLength?: number;
                                                                                                                                                                                                                                                                                                      rowField?: string | number;
                                                                                                                                                                                                                                                                                                      rowIndex?: number;
                                                                                                                                                                                                                                                                                                      rowValue?: string | number;
                                                                                                                                                                                                                                                                                                      rowValuesLength?: number;
                                                                                                                                                                                                                                                                                                      };

                                                                                                                                                                                                                                                                                                        type FacetRectComposition

                                                                                                                                                                                                                                                                                                        type FacetRectComposition = {
                                                                                                                                                                                                                                                                                                        type?: 'facetRect';
                                                                                                                                                                                                                                                                                                        transform?: Transform;
                                                                                                                                                                                                                                                                                                        data?: Data;
                                                                                                                                                                                                                                                                                                        padding?: Padding;
                                                                                                                                                                                                                                                                                                        paddingLeft?: Padding;
                                                                                                                                                                                                                                                                                                        paddingRight?: Padding;
                                                                                                                                                                                                                                                                                                        paddingTop?: Padding;
                                                                                                                                                                                                                                                                                                        paddingBottom?: Padding;
                                                                                                                                                                                                                                                                                                        margin?: number;
                                                                                                                                                                                                                                                                                                        marginLeft?: number;
                                                                                                                                                                                                                                                                                                        marginBottom?: number;
                                                                                                                                                                                                                                                                                                        marginTop?: number;
                                                                                                                                                                                                                                                                                                        marginRight?: number;
                                                                                                                                                                                                                                                                                                        key?: string;
                                                                                                                                                                                                                                                                                                        title?: string | TitleComponent;
                                                                                                                                                                                                                                                                                                        encode?: {
                                                                                                                                                                                                                                                                                                        x?: string;
                                                                                                                                                                                                                                                                                                        y?: string;
                                                                                                                                                                                                                                                                                                        };
                                                                                                                                                                                                                                                                                                        scale?: {
                                                                                                                                                                                                                                                                                                        x?: Scale;
                                                                                                                                                                                                                                                                                                        y?: Scale;
                                                                                                                                                                                                                                                                                                        color?: Scale;
                                                                                                                                                                                                                                                                                                        };
                                                                                                                                                                                                                                                                                                        shareData?: boolean;
                                                                                                                                                                                                                                                                                                        shareSize?: boolean;
                                                                                                                                                                                                                                                                                                        children?: Node[] | ((facet: FacetContext) => Node);
                                                                                                                                                                                                                                                                                                        axis?: Record<string, any> | boolean;
                                                                                                                                                                                                                                                                                                        legend?: Record<string, any> | boolean;
                                                                                                                                                                                                                                                                                                        [key: string]: any;
                                                                                                                                                                                                                                                                                                        };

                                                                                                                                                                                                                                                                                                          type FadeInAnimation

                                                                                                                                                                                                                                                                                                          type FadeInAnimation = BaseAnimation<'fadeIn'>;

                                                                                                                                                                                                                                                                                                            type FadeOutAnimation

                                                                                                                                                                                                                                                                                                            type FadeOutAnimation = BaseAnimation<'fadeOut'>;

                                                                                                                                                                                                                                                                                                              type FetchConnector

                                                                                                                                                                                                                                                                                                              type FetchConnector = {
                                                                                                                                                                                                                                                                                                              type?: 'fetch';
                                                                                                                                                                                                                                                                                                              value?: string;
                                                                                                                                                                                                                                                                                                              format?: 'json' | 'csv';
                                                                                                                                                                                                                                                                                                              delimiter?: string;
                                                                                                                                                                                                                                                                                                              /** Automatically infer the data to Javascript type */
                                                                                                                                                                                                                                                                                                              autoType?: boolean;
                                                                                                                                                                                                                                                                                                              transform?: DataTransform[];
                                                                                                                                                                                                                                                                                                              };

                                                                                                                                                                                                                                                                                                                type FieldEncode

                                                                                                                                                                                                                                                                                                                type FieldEncode = {
                                                                                                                                                                                                                                                                                                                type?: 'field';
                                                                                                                                                                                                                                                                                                                value?: string;
                                                                                                                                                                                                                                                                                                                };

                                                                                                                                                                                                                                                                                                                  type FilterDataTransform

                                                                                                                                                                                                                                                                                                                  type FilterDataTransform = {
                                                                                                                                                                                                                                                                                                                  type?: 'filter';
                                                                                                                                                                                                                                                                                                                  /**
                                                                                                                                                                                                                                                                                                                  * The filter condition, same with [Array.prototype.filter](https://developer.mozilla.org/zh-CN/docs/Web/JavaScript/Reference/Global_Objects/Array/filter).
                                                                                                                                                                                                                                                                                                                  */
                                                                                                                                                                                                                                                                                                                  callback?: (v: any, idx: number, arr: any[]) => boolean;
                                                                                                                                                                                                                                                                                                                  };

                                                                                                                                                                                                                                                                                                                    type FilterOptions

                                                                                                                                                                                                                                                                                                                    type FilterOptions = Omit<FilterTransform, 'type'>;

                                                                                                                                                                                                                                                                                                                      type FilterTransform

                                                                                                                                                                                                                                                                                                                      type FilterTransform = {
                                                                                                                                                                                                                                                                                                                      type?: 'filter';
                                                                                                                                                                                                                                                                                                                      } & {
                                                                                                                                                                                                                                                                                                                      [key in ChannelTypes]?: any[] | ((v: Primitive) => boolean);
                                                                                                                                                                                                                                                                                                                      };

                                                                                                                                                                                                                                                                                                                        type FisheyeCoordinate

                                                                                                                                                                                                                                                                                                                        type FisheyeCoordinate = {
                                                                                                                                                                                                                                                                                                                        type?: 'fisheye';
                                                                                                                                                                                                                                                                                                                        focusX?: number;
                                                                                                                                                                                                                                                                                                                        focusY?: number;
                                                                                                                                                                                                                                                                                                                        distortionX?: number;
                                                                                                                                                                                                                                                                                                                        distortionY?: number;
                                                                                                                                                                                                                                                                                                                        visual?: boolean;
                                                                                                                                                                                                                                                                                                                        };

                                                                                                                                                                                                                                                                                                                          type FisheyeInteraction

                                                                                                                                                                                                                                                                                                                          type FisheyeInteraction = {
                                                                                                                                                                                                                                                                                                                          type?: 'fisheye';
                                                                                                                                                                                                                                                                                                                          wait?: number;
                                                                                                                                                                                                                                                                                                                          leading?: boolean;
                                                                                                                                                                                                                                                                                                                          trailing?: boolean;
                                                                                                                                                                                                                                                                                                                          } & Omit<FisheyeCoordinate, 'type'>;

                                                                                                                                                                                                                                                                                                                            type FlexXOptions

                                                                                                                                                                                                                                                                                                                            type FlexXOptions = Omit<FlexXTransform, 'type'>;

                                                                                                                                                                                                                                                                                                                              type FlexXTransform

                                                                                                                                                                                                                                                                                                                              type FlexXTransform = {
                                                                                                                                                                                                                                                                                                                              type?: 'flexX';
                                                                                                                                                                                                                                                                                                                              field?: string | ((d: any) => Primitive[]);
                                                                                                                                                                                                                                                                                                                              channel?: string;
                                                                                                                                                                                                                                                                                                                              reducer?: 'sum' | ((I: number[], V: Primitive[]) => Primitive);
                                                                                                                                                                                                                                                                                                                              };

                                                                                                                                                                                                                                                                                                                                type FoldTransform

                                                                                                                                                                                                                                                                                                                                type FoldTransform = {
                                                                                                                                                                                                                                                                                                                                type?: 'fold';
                                                                                                                                                                                                                                                                                                                                /**
                                                                                                                                                                                                                                                                                                                                * Set fields will be folded.
                                                                                                                                                                                                                                                                                                                                */
                                                                                                                                                                                                                                                                                                                                fields?: string[];
                                                                                                                                                                                                                                                                                                                                /**
                                                                                                                                                                                                                                                                                                                                * Fold key field, default is `key`.
                                                                                                                                                                                                                                                                                                                                */
                                                                                                                                                                                                                                                                                                                                key?: string;
                                                                                                                                                                                                                                                                                                                                /**
                                                                                                                                                                                                                                                                                                                                * Fold value field, default is `value`.
                                                                                                                                                                                                                                                                                                                                */
                                                                                                                                                                                                                                                                                                                                value?: string;
                                                                                                                                                                                                                                                                                                                                };

                                                                                                                                                                                                                                                                                                                                  type ForceGraphMark

                                                                                                                                                                                                                                                                                                                                  type ForceGraphMark = BaseMark<
                                                                                                                                                                                                                                                                                                                                  'forceGraph',
                                                                                                                                                                                                                                                                                                                                  | 'source'
                                                                                                                                                                                                                                                                                                                                  | 'target'
                                                                                                                                                                                                                                                                                                                                  | 'color'
                                                                                                                                                                                                                                                                                                                                  | 'value'
                                                                                                                                                                                                                                                                                                                                  | `node${Capitalize<ChannelTypes>}`
                                                                                                                                                                                                                                                                                                                                  | `link${Capitalize<ChannelTypes>}`
                                                                                                                                                                                                                                                                                                                                  > & {
                                                                                                                                                                                                                                                                                                                                  layout?: Record<string, any>;
                                                                                                                                                                                                                                                                                                                                  nodeLabels: Record<string, any>[];
                                                                                                                                                                                                                                                                                                                                  linkLabels: Record<string, any>[];
                                                                                                                                                                                                                                                                                                                                  };

                                                                                                                                                                                                                                                                                                                                    type G2BaseComponent

                                                                                                                                                                                                                                                                                                                                    type G2BaseComponent<
                                                                                                                                                                                                                                                                                                                                    R = any,
                                                                                                                                                                                                                                                                                                                                    O = Record<string, unknown>,
                                                                                                                                                                                                                                                                                                                                    P = Record<string, unknown>,
                                                                                                                                                                                                                                                                                                                                    C = Record<string, unknown>
                                                                                                                                                                                                                                                                                                                                    > = {
                                                                                                                                                                                                                                                                                                                                    (options?: O, context?: C): R;
                                                                                                                                                                                                                                                                                                                                    props?: P;
                                                                                                                                                                                                                                                                                                                                    };

                                                                                                                                                                                                                                                                                                                                      type G2Context

                                                                                                                                                                                                                                                                                                                                      type G2Context = {
                                                                                                                                                                                                                                                                                                                                      library?: G2Library;
                                                                                                                                                                                                                                                                                                                                      canvas?: Canvas;
                                                                                                                                                                                                                                                                                                                                      emitter?: EventEmitter;
                                                                                                                                                                                                                                                                                                                                      group?: DisplayObject;
                                                                                                                                                                                                                                                                                                                                      animations?: GAnimation[];
                                                                                                                                                                                                                                                                                                                                      views?: G2ViewDescriptor[];
                                                                                                                                                                                                                                                                                                                                      /**
                                                                                                                                                                                                                                                                                                                                      * Tell G2 how to create a canvas-like element, some marks will use it later such as wordcloud & heatmap.
                                                                                                                                                                                                                                                                                                                                      * Use `document.createElement('canvas')` instead if not provided.
                                                                                                                                                                                                                                                                                                                                      */
                                                                                                                                                                                                                                                                                                                                      createCanvas?: () => HTMLCanvasElement;
                                                                                                                                                                                                                                                                                                                                      };

                                                                                                                                                                                                                                                                                                                                        type G2Spec

                                                                                                                                                                                                                                                                                                                                        type G2Spec = (Mark | Composition | AxisComponent | LegendComponent) & {
                                                                                                                                                                                                                                                                                                                                        width?: number;
                                                                                                                                                                                                                                                                                                                                        height?: number;
                                                                                                                                                                                                                                                                                                                                        depth?: number;
                                                                                                                                                                                                                                                                                                                                        autoFit?: boolean;
                                                                                                                                                                                                                                                                                                                                        };

                                                                                                                                                                                                                                                                                                                                          type GaugeMark

                                                                                                                                                                                                                                                                                                                                          type GaugeMark = BaseMark<
                                                                                                                                                                                                                                                                                                                                          'gauge',
                                                                                                                                                                                                                                                                                                                                          | `arc${Capitalize<ChannelTypes>}`
                                                                                                                                                                                                                                                                                                                                          | `indicator${Capitalize<ChannelTypes>}`
                                                                                                                                                                                                                                                                                                                                          | `pointer${Capitalize<ChannelTypes>}`
                                                                                                                                                                                                                                                                                                                                          | `pin${Capitalize<ChannelTypes>}`
                                                                                                                                                                                                                                                                                                                                          | ChannelTypes
                                                                                                                                                                                                                                                                                                                                          >;

                                                                                                                                                                                                                                                                                                                                            type GeoCoordinate

                                                                                                                                                                                                                                                                                                                                            type GeoCoordinate = BaseCoordinate<{
                                                                                                                                                                                                                                                                                                                                            type: string;
                                                                                                                                                                                                                                                                                                                                            [key: string]: any;
                                                                                                                                                                                                                                                                                                                                            }>;

                                                                                                                                                                                                                                                                                                                                              type GeoPathComposition

                                                                                                                                                                                                                                                                                                                                              type GeoPathComposition = Omit<ViewComposition, 'type'> & {
                                                                                                                                                                                                                                                                                                                                              type?: 'geoPath';
                                                                                                                                                                                                                                                                                                                                              coordinate?: Record<string, any>;
                                                                                                                                                                                                                                                                                                                                              [key: string]: any;
                                                                                                                                                                                                                                                                                                                                              };

                                                                                                                                                                                                                                                                                                                                                type GeoViewComposition

                                                                                                                                                                                                                                                                                                                                                type GeoViewComposition = Omit<ViewComposition, 'type'> & {
                                                                                                                                                                                                                                                                                                                                                type?: 'geoView';
                                                                                                                                                                                                                                                                                                                                                coordinate?: Record<string, any>;
                                                                                                                                                                                                                                                                                                                                                [key: string]: any;
                                                                                                                                                                                                                                                                                                                                                };

                                                                                                                                                                                                                                                                                                                                                  type GroupColorOptions

                                                                                                                                                                                                                                                                                                                                                  type GroupColorOptions = Omit<GroupColorTransform, 'type'>;

                                                                                                                                                                                                                                                                                                                                                    type GroupColorTransform

                                                                                                                                                                                                                                                                                                                                                    type GroupColorTransform = {
                                                                                                                                                                                                                                                                                                                                                    type?: 'groupColor';
                                                                                                                                                                                                                                                                                                                                                    } & {
                                                                                                                                                                                                                                                                                                                                                    [key in ChannelTypes]?: Reducer;
                                                                                                                                                                                                                                                                                                                                                    };

                                                                                                                                                                                                                                                                                                                                                      type GroupOptions

                                                                                                                                                                                                                                                                                                                                                      type GroupOptions = Omit<
                                                                                                                                                                                                                                                                                                                                                      GroupTransform & {
                                                                                                                                                                                                                                                                                                                                                      groupBy?: (
                                                                                                                                                                                                                                                                                                                                                      I: number[],
                                                                                                                                                                                                                                                                                                                                                      mark: G2Mark,
                                                                                                                                                                                                                                                                                                                                                      options?: Record<string, any>
                                                                                                                                                                                                                                                                                                                                                      ) => number[][];
                                                                                                                                                                                                                                                                                                                                                      },
                                                                                                                                                                                                                                                                                                                                                      'type'
                                                                                                                                                                                                                                                                                                                                                      >;

                                                                                                                                                                                                                                                                                                                                                        type GroupTransform

                                                                                                                                                                                                                                                                                                                                                        type GroupTransform = {
                                                                                                                                                                                                                                                                                                                                                        type?: 'group';
                                                                                                                                                                                                                                                                                                                                                        channels?: string | string[];
                                                                                                                                                                                                                                                                                                                                                        } & {
                                                                                                                                                                                                                                                                                                                                                        [key in ChannelTypes]?: Reducer;
                                                                                                                                                                                                                                                                                                                                                        };

                                                                                                                                                                                                                                                                                                                                                          type GroupXOptions

                                                                                                                                                                                                                                                                                                                                                          type GroupXOptions = Omit<GroupXTransform, 'type'>;

                                                                                                                                                                                                                                                                                                                                                            type GroupXTransform

                                                                                                                                                                                                                                                                                                                                                            type GroupXTransform = {
                                                                                                                                                                                                                                                                                                                                                            type?: 'groupX';
                                                                                                                                                                                                                                                                                                                                                            } & {
                                                                                                                                                                                                                                                                                                                                                            [key in ChannelTypes]?: Reducer;
                                                                                                                                                                                                                                                                                                                                                            };

                                                                                                                                                                                                                                                                                                                                                              type GroupYOptions

                                                                                                                                                                                                                                                                                                                                                              type GroupYOptions = Omit<GroupYTransform, 'type'>;

                                                                                                                                                                                                                                                                                                                                                                type GroupYTransform

                                                                                                                                                                                                                                                                                                                                                                type GroupYTransform = {
                                                                                                                                                                                                                                                                                                                                                                type?: 'groupY';
                                                                                                                                                                                                                                                                                                                                                                } & {
                                                                                                                                                                                                                                                                                                                                                                [key in ChannelTypes]?: Reducer;
                                                                                                                                                                                                                                                                                                                                                                };

                                                                                                                                                                                                                                                                                                                                                                  type GrowInXAnimation

                                                                                                                                                                                                                                                                                                                                                                  type GrowInXAnimation = BaseAnimation<'growInX'>;

                                                                                                                                                                                                                                                                                                                                                                    type GrowInYAnimation

                                                                                                                                                                                                                                                                                                                                                                    type GrowInYAnimation = BaseAnimation<'growInY'>;

                                                                                                                                                                                                                                                                                                                                                                      type GuideComponentComponent

                                                                                                                                                                                                                                                                                                                                                                      type GuideComponentComponent<O = Record<string, unknown>> = G2BaseComponent<
                                                                                                                                                                                                                                                                                                                                                                      GuideComponent,
                                                                                                                                                                                                                                                                                                                                                                      O,
                                                                                                                                                                                                                                                                                                                                                                      GuideComponentProps
                                                                                                                                                                                                                                                                                                                                                                      >;

                                                                                                                                                                                                                                                                                                                                                                        type HeatmapMark

                                                                                                                                                                                                                                                                                                                                                                        type HeatmapMark = BaseMark<'heatmap'>;

                                                                                                                                                                                                                                                                                                                                                                          type HelixCoordinate

                                                                                                                                                                                                                                                                                                                                                                          type HelixCoordinate = BaseCoordinate<{
                                                                                                                                                                                                                                                                                                                                                                          type?: 'helix';
                                                                                                                                                                                                                                                                                                                                                                          startAngle?: number;
                                                                                                                                                                                                                                                                                                                                                                          endAngle?: number;
                                                                                                                                                                                                                                                                                                                                                                          innerRadius?: number;
                                                                                                                                                                                                                                                                                                                                                                          outerRadius?: number;
                                                                                                                                                                                                                                                                                                                                                                          }>;

                                                                                                                                                                                                                                                                                                                                                                            type IdentityScale

                                                                                                                                                                                                                                                                                                                                                                            type IdentityScale = BaseScale<'identity', IdentityOptions>;

                                                                                                                                                                                                                                                                                                                                                                              type ImageMark

                                                                                                                                                                                                                                                                                                                                                                              type ImageMark = BaseMark<'image', ChannelTypes | 'src'>;

                                                                                                                                                                                                                                                                                                                                                                                type InlineConnector

                                                                                                                                                                                                                                                                                                                                                                                type InlineConnector =
                                                                                                                                                                                                                                                                                                                                                                                | {
                                                                                                                                                                                                                                                                                                                                                                                type?: 'inline';
                                                                                                                                                                                                                                                                                                                                                                                value?: any;
                                                                                                                                                                                                                                                                                                                                                                                transform?: DataTransform[];
                                                                                                                                                                                                                                                                                                                                                                                }
                                                                                                                                                                                                                                                                                                                                                                                | any;

                                                                                                                                                                                                                                                                                                                                                                                  type Interaction

                                                                                                                                                                                                                                                                                                                                                                                  type Interaction =
                                                                                                                                                                                                                                                                                                                                                                                  | ElementHighlightInteraction
                                                                                                                                                                                                                                                                                                                                                                                  | ElementHighlightByColorInteraction
                                                                                                                                                                                                                                                                                                                                                                                  | ElementHighlightByXInteraction
                                                                                                                                                                                                                                                                                                                                                                                  | ElementSelectByColorInteraction
                                                                                                                                                                                                                                                                                                                                                                                  | ElementSelectByXInteraction
                                                                                                                                                                                                                                                                                                                                                                                  | ElementSelectInteraction
                                                                                                                                                                                                                                                                                                                                                                                  | TooltipInteraction
                                                                                                                                                                                                                                                                                                                                                                                  | FisheyeInteraction
                                                                                                                                                                                                                                                                                                                                                                                  | ChartIndexInteraction
                                                                                                                                                                                                                                                                                                                                                                                  | CustomInteraction
                                                                                                                                                                                                                                                                                                                                                                                  | LegendFilterInteraction
                                                                                                                                                                                                                                                                                                                                                                                  | LegendHighlightInteraction
                                                                                                                                                                                                                                                                                                                                                                                  | BrushHighlightInteraction
                                                                                                                                                                                                                                                                                                                                                                                  | BrushXHighlightInteraction
                                                                                                                                                                                                                                                                                                                                                                                  | BrushYHighlightInteraction
                                                                                                                                                                                                                                                                                                                                                                                  | BrushAxisHighlightInteraction
                                                                                                                                                                                                                                                                                                                                                                                  | BrushFilterInteraction
                                                                                                                                                                                                                                                                                                                                                                                  | BrushYFilterInteraction
                                                                                                                                                                                                                                                                                                                                                                                  | BrushXFilterInteraction
                                                                                                                                                                                                                                                                                                                                                                                  | SliderFilterInteraction
                                                                                                                                                                                                                                                                                                                                                                                  | PoptipInteraction;

                                                                                                                                                                                                                                                                                                                                                                                    type InteractionTypes

                                                                                                                                                                                                                                                                                                                                                                                    type InteractionTypes =
                                                                                                                                                                                                                                                                                                                                                                                    | 'elementHighlight'
                                                                                                                                                                                                                                                                                                                                                                                    | 'elementHighlightByX'
                                                                                                                                                                                                                                                                                                                                                                                    | 'elementHighlightByColor'
                                                                                                                                                                                                                                                                                                                                                                                    | 'fisheye'
                                                                                                                                                                                                                                                                                                                                                                                    | 'chartIndex'
                                                                                                                                                                                                                                                                                                                                                                                    | 'elementSelect'
                                                                                                                                                                                                                                                                                                                                                                                    | 'elementSelectByX'
                                                                                                                                                                                                                                                                                                                                                                                    | 'elementSelectByColor'
                                                                                                                                                                                                                                                                                                                                                                                    | 'fisheye'
                                                                                                                                                                                                                                                                                                                                                                                    | 'tooltip'
                                                                                                                                                                                                                                                                                                                                                                                    | 'legendFilter'
                                                                                                                                                                                                                                                                                                                                                                                    | 'legendHighlight'
                                                                                                                                                                                                                                                                                                                                                                                    | 'brushXHighlight'
                                                                                                                                                                                                                                                                                                                                                                                    | 'brushYHighlight'
                                                                                                                                                                                                                                                                                                                                                                                    | 'brushHighlight'
                                                                                                                                                                                                                                                                                                                                                                                    | 'brushFilter'
                                                                                                                                                                                                                                                                                                                                                                                    | 'brushXFilter'
                                                                                                                                                                                                                                                                                                                                                                                    | 'brushYFilter'
                                                                                                                                                                                                                                                                                                                                                                                    | 'sliderFilter'
                                                                                                                                                                                                                                                                                                                                                                                    | 'poptip'
                                                                                                                                                                                                                                                                                                                                                                                    | InteractionComponent;

                                                                                                                                                                                                                                                                                                                                                                                      type IntervalMark

                                                                                                                                                                                                                                                                                                                                                                                      type IntervalMark = BaseMark<'interval', ChannelTypes | 'series'>;

                                                                                                                                                                                                                                                                                                                                                                                        type JitterOptions

                                                                                                                                                                                                                                                                                                                                                                                        type JitterOptions = Omit<JitterTransform, 'type'>;

                                                                                                                                                                                                                                                                                                                                                                                          type JitterTransform

                                                                                                                                                                                                                                                                                                                                                                                          type JitterTransform = {
                                                                                                                                                                                                                                                                                                                                                                                          type?: 'jitter';
                                                                                                                                                                                                                                                                                                                                                                                          padding?: number;
                                                                                                                                                                                                                                                                                                                                                                                          paddingX?: number;
                                                                                                                                                                                                                                                                                                                                                                                          paddingY?: number;
                                                                                                                                                                                                                                                                                                                                                                                          random?: () => number;
                                                                                                                                                                                                                                                                                                                                                                                          };

                                                                                                                                                                                                                                                                                                                                                                                            type JitterXOptions

                                                                                                                                                                                                                                                                                                                                                                                            type JitterXOptions = Omit<JitterXTransform, 'type'>;

                                                                                                                                                                                                                                                                                                                                                                                              type JitterXTransform

                                                                                                                                                                                                                                                                                                                                                                                              type JitterXTransform = {
                                                                                                                                                                                                                                                                                                                                                                                              type?: 'jitterX';
                                                                                                                                                                                                                                                                                                                                                                                              padding?: number;
                                                                                                                                                                                                                                                                                                                                                                                              random?: () => number;
                                                                                                                                                                                                                                                                                                                                                                                              };

                                                                                                                                                                                                                                                                                                                                                                                                type JitterYOptions

                                                                                                                                                                                                                                                                                                                                                                                                type JitterYOptions = Omit<JitterYTransform, 'type'>;

                                                                                                                                                                                                                                                                                                                                                                                                  type JitterYTransform

                                                                                                                                                                                                                                                                                                                                                                                                  type JitterYTransform = {
                                                                                                                                                                                                                                                                                                                                                                                                  type?: 'jitterY';
                                                                                                                                                                                                                                                                                                                                                                                                  padding?: number;
                                                                                                                                                                                                                                                                                                                                                                                                  random?: () => number;
                                                                                                                                                                                                                                                                                                                                                                                                  };

                                                                                                                                                                                                                                                                                                                                                                                                    type JoinTransform

                                                                                                                                                                                                                                                                                                                                                                                                    type JoinTransform = {
                                                                                                                                                                                                                                                                                                                                                                                                    type?: 'join';
                                                                                                                                                                                                                                                                                                                                                                                                    /**
                                                                                                                                                                                                                                                                                                                                                                                                    * The dataset to be joined.
                                                                                                                                                                                                                                                                                                                                                                                                    */
                                                                                                                                                                                                                                                                                                                                                                                                    join: Record<string, any>[];
                                                                                                                                                                                                                                                                                                                                                                                                    /**
                                                                                                                                                                                                                                                                                                                                                                                                    * Join keys of 2 dataset, [k1, k2] means join on ds1.k1 === ds2.k2.
                                                                                                                                                                                                                                                                                                                                                                                                    */
                                                                                                                                                                                                                                                                                                                                                                                                    on: [string | ((d: any) => string), string | ((d: any) => string)];
                                                                                                                                                                                                                                                                                                                                                                                                    /**
                                                                                                                                                                                                                                                                                                                                                                                                    * Select fields from joined dataset.
                                                                                                                                                                                                                                                                                                                                                                                                    */
                                                                                                                                                                                                                                                                                                                                                                                                    select: string[];
                                                                                                                                                                                                                                                                                                                                                                                                    /**
                                                                                                                                                                                                                                                                                                                                                                                                    * Rename the select fields, default: keep the original name.
                                                                                                                                                                                                                                                                                                                                                                                                    */
                                                                                                                                                                                                                                                                                                                                                                                                    as?: string[];
                                                                                                                                                                                                                                                                                                                                                                                                    /**
                                                                                                                                                                                                                                                                                                                                                                                                    * When not matched, use `unknown` instead.
                                                                                                                                                                                                                                                                                                                                                                                                    */
                                                                                                                                                                                                                                                                                                                                                                                                    unknown?: any;
                                                                                                                                                                                                                                                                                                                                                                                                    };

                                                                                                                                                                                                                                                                                                                                                                                                      type KDEDataTransform

                                                                                                                                                                                                                                                                                                                                                                                                      type KDEDataTransform = {
                                                                                                                                                                                                                                                                                                                                                                                                      type?: 'kde';
                                                                                                                                                                                                                                                                                                                                                                                                      /**
                                                                                                                                                                                                                                                                                                                                                                                                      * Kernel Density Estimation field.
                                                                                                                                                                                                                                                                                                                                                                                                      */
                                                                                                                                                                                                                                                                                                                                                                                                      field: string;
                                                                                                                                                                                                                                                                                                                                                                                                      /**
                                                                                                                                                                                                                                                                                                                                                                                                      * Group data by fields.
                                                                                                                                                                                                                                                                                                                                                                                                      */
                                                                                                                                                                                                                                                                                                                                                                                                      groupBy: string[];
                                                                                                                                                                                                                                                                                                                                                                                                      /**
                                                                                                                                                                                                                                                                                                                                                                                                      * Generate new fieds, default: ['y', 'size']
                                                                                                                                                                                                                                                                                                                                                                                                      */
                                                                                                                                                                                                                                                                                                                                                                                                      as?: ['y', 'size'];
                                                                                                                                                                                                                                                                                                                                                                                                      /**
                                                                                                                                                                                                                                                                                                                                                                                                      * Defaults to smallest value in the array minus some threshold.
                                                                                                                                                                                                                                                                                                                                                                                                      */
                                                                                                                                                                                                                                                                                                                                                                                                      min?: number;
                                                                                                                                                                                                                                                                                                                                                                                                      /**
                                                                                                                                                                                                                                                                                                                                                                                                      * Defaults to largest value in the array plus some threshold.
                                                                                                                                                                                                                                                                                                                                                                                                      */
                                                                                                                                                                                                                                                                                                                                                                                                      max?: number;
                                                                                                                                                                                                                                                                                                                                                                                                      /**
                                                                                                                                                                                                                                                                                                                                                                                                      * Number of points to represent the pdf. Defaults to 10.
                                                                                                                                                                                                                                                                                                                                                                                                      */
                                                                                                                                                                                                                                                                                                                                                                                                      size?: number;
                                                                                                                                                                                                                                                                                                                                                                                                      /**
                                                                                                                                                                                                                                                                                                                                                                                                      * Determine how many points to the left and right does an element affect,
                                                                                                                                                                                                                                                                                                                                                                                                      * similar to bandwidth in kernel density estimation. Defaults to 2.
                                                                                                                                                                                                                                                                                                                                                                                                      */
                                                                                                                                                                                                                                                                                                                                                                                                      width?: number;
                                                                                                                                                                                                                                                                                                                                                                                                      };

                                                                                                                                                                                                                                                                                                                                                                                                        type LabelTransform

                                                                                                                                                                                                                                                                                                                                                                                                        type LabelTransform =
                                                                                                                                                                                                                                                                                                                                                                                                        | OverlapHideLabelTransform
                                                                                                                                                                                                                                                                                                                                                                                                        | OverlapDodgeYLabelTransform
                                                                                                                                                                                                                                                                                                                                                                                                        | ContrastReverseLabelTransform
                                                                                                                                                                                                                                                                                                                                                                                                        | OverflowHideLabelTransform;

                                                                                                                                                                                                                                                                                                                                                                                                          type LegendComponent

                                                                                                                                                                                                                                                                                                                                                                                                          type LegendComponent = {
                                                                                                                                                                                                                                                                                                                                                                                                          type?: 'legends';
                                                                                                                                                                                                                                                                                                                                                                                                          tickCount?: number;
                                                                                                                                                                                                                                                                                                                                                                                                          labelFormatter?: any;
                                                                                                                                                                                                                                                                                                                                                                                                          tickFilter?: any;
                                                                                                                                                                                                                                                                                                                                                                                                          title?: any;
                                                                                                                                                                                                                                                                                                                                                                                                          position?: string;
                                                                                                                                                                                                                                                                                                                                                                                                          state?: Partial<
                                                                                                                                                                                                                                                                                                                                                                                                          Record<
                                                                                                                                                                                                                                                                                                                                                                                                          'active' | 'selected' | 'inactive' | 'unselected',
                                                                                                                                                                                                                                                                                                                                                                                                          Record<string, any>
                                                                                                                                                                                                                                                                                                                                                                                                          >
                                                                                                                                                                                                                                                                                                                                                                                                          >;
                                                                                                                                                                                                                                                                                                                                                                                                          scale?: Record<string, any>;
                                                                                                                                                                                                                                                                                                                                                                                                          [key: string]: any;
                                                                                                                                                                                                                                                                                                                                                                                                          };

                                                                                                                                                                                                                                                                                                                                                                                                            type LegendFilterInteraction

                                                                                                                                                                                                                                                                                                                                                                                                            type LegendFilterInteraction = {
                                                                                                                                                                                                                                                                                                                                                                                                            type?: 'legendFilter';
                                                                                                                                                                                                                                                                                                                                                                                                            };

                                                                                                                                                                                                                                                                                                                                                                                                              type LegendHighlightInteraction

                                                                                                                                                                                                                                                                                                                                                                                                              type LegendHighlightInteraction = {
                                                                                                                                                                                                                                                                                                                                                                                                              type?: 'legendHighlight';
                                                                                                                                                                                                                                                                                                                                                                                                              };

                                                                                                                                                                                                                                                                                                                                                                                                                type LightTheme

                                                                                                                                                                                                                                                                                                                                                                                                                type LightTheme = {
                                                                                                                                                                                                                                                                                                                                                                                                                type?: 'light';
                                                                                                                                                                                                                                                                                                                                                                                                                } & ThemeOptions;

                                                                                                                                                                                                                                                                                                                                                                                                                  type LinearScale

                                                                                                                                                                                                                                                                                                                                                                                                                  type LinearScale = BaseScale<'linear', LinearOptions>;

                                                                                                                                                                                                                                                                                                                                                                                                                    type LineMark

                                                                                                                                                                                                                                                                                                                                                                                                                    type LineMark = BaseMark<'line', ChannelTypes | 'position' | `position${number}`>;

                                                                                                                                                                                                                                                                                                                                                                                                                      type LineXMark

                                                                                                                                                                                                                                                                                                                                                                                                                      type LineXMark = BaseMark<'lineX', ChannelTypes>;

                                                                                                                                                                                                                                                                                                                                                                                                                        type LineYMark

                                                                                                                                                                                                                                                                                                                                                                                                                        type LineYMark = BaseMark<'lineY', ChannelTypes>;

                                                                                                                                                                                                                                                                                                                                                                                                                          type LinkMark

                                                                                                                                                                                                                                                                                                                                                                                                                          type LinkMark = BaseMark<'link', ChannelTypes>;

                                                                                                                                                                                                                                                                                                                                                                                                                            type LiquidMark

                                                                                                                                                                                                                                                                                                                                                                                                                            type LiquidMark = BaseMark<'liquid'>;

                                                                                                                                                                                                                                                                                                                                                                                                                              type LogDataTransform

                                                                                                                                                                                                                                                                                                                                                                                                                              type LogDataTransform = {};

                                                                                                                                                                                                                                                                                                                                                                                                                                type LogScale

                                                                                                                                                                                                                                                                                                                                                                                                                                type LogScale = BaseScale<'log', LogOptions>;

                                                                                                                                                                                                                                                                                                                                                                                                                                  type MapTransform

                                                                                                                                                                                                                                                                                                                                                                                                                                  type MapTransform = {
                                                                                                                                                                                                                                                                                                                                                                                                                                  type?: 'map';
                                                                                                                                                                                                                                                                                                                                                                                                                                  callback?: (d: any) => any;
                                                                                                                                                                                                                                                                                                                                                                                                                                  };

                                                                                                                                                                                                                                                                                                                                                                                                                                    type Mark

                                                                                                                                                                                                                                                                                                                                                                                                                                    type Mark =
                                                                                                                                                                                                                                                                                                                                                                                                                                    | IntervalMark
                                                                                                                                                                                                                                                                                                                                                                                                                                    | RectMark
                                                                                                                                                                                                                                                                                                                                                                                                                                    | LineMark
                                                                                                                                                                                                                                                                                                                                                                                                                                    | PointMark
                                                                                                                                                                                                                                                                                                                                                                                                                                    | TextMark
                                                                                                                                                                                                                                                                                                                                                                                                                                    | CellMark
                                                                                                                                                                                                                                                                                                                                                                                                                                    | AreaMark
                                                                                                                                                                                                                                                                                                                                                                                                                                    | NodeMark
                                                                                                                                                                                                                                                                                                                                                                                                                                    | EdgeMark
                                                                                                                                                                                                                                                                                                                                                                                                                                    | ImageMark
                                                                                                                                                                                                                                                                                                                                                                                                                                    | PolygonMark
                                                                                                                                                                                                                                                                                                                                                                                                                                    | BoxMark
                                                                                                                                                                                                                                                                                                                                                                                                                                    | VectorMark
                                                                                                                                                                                                                                                                                                                                                                                                                                    | LineXMark
                                                                                                                                                                                                                                                                                                                                                                                                                                    | LineYMark
                                                                                                                                                                                                                                                                                                                                                                                                                                    | RangeMark
                                                                                                                                                                                                                                                                                                                                                                                                                                    | RangeXMark
                                                                                                                                                                                                                                                                                                                                                                                                                                    | RangeYMark
                                                                                                                                                                                                                                                                                                                                                                                                                                    | ConnectorMark
                                                                                                                                                                                                                                                                                                                                                                                                                                    | SankeyMark
                                                                                                                                                                                                                                                                                                                                                                                                                                    | ChordMark
                                                                                                                                                                                                                                                                                                                                                                                                                                    | PathMark
                                                                                                                                                                                                                                                                                                                                                                                                                                    | TreemapMark
                                                                                                                                                                                                                                                                                                                                                                                                                                    | PackMark
                                                                                                                                                                                                                                                                                                                                                                                                                                    | BoxPlotMark
                                                                                                                                                                                                                                                                                                                                                                                                                                    | ShapeMark
                                                                                                                                                                                                                                                                                                                                                                                                                                    | ForceGraphMark
                                                                                                                                                                                                                                                                                                                                                                                                                                    | TreeMark
                                                                                                                                                                                                                                                                                                                                                                                                                                    | WordCloudMark
                                                                                                                                                                                                                                                                                                                                                                                                                                    | DensityMark
                                                                                                                                                                                                                                                                                                                                                                                                                                    | CustomMark
                                                                                                                                                                                                                                                                                                                                                                                                                                    | CompositeMark;

                                                                                                                                                                                                                                                                                                                                                                                                                                      type MarkComponent

                                                                                                                                                                                                                                                                                                                                                                                                                                      type MarkComponent<O extends MarkOptions = MarkOptions> = {
                                                                                                                                                                                                                                                                                                                                                                                                                                      (options?: O): Mark;
                                                                                                                                                                                                                                                                                                                                                                                                                                      props?: MarkProps;
                                                                                                                                                                                                                                                                                                                                                                                                                                      };

                                                                                                                                                                                                                                                                                                                                                                                                                                        type MarkTypes

                                                                                                                                                                                                                                                                                                                                                                                                                                        type MarkTypes =
                                                                                                                                                                                                                                                                                                                                                                                                                                        | 'auto'
                                                                                                                                                                                                                                                                                                                                                                                                                                        | 'interval'
                                                                                                                                                                                                                                                                                                                                                                                                                                        | 'rect'
                                                                                                                                                                                                                                                                                                                                                                                                                                        | 'line'
                                                                                                                                                                                                                                                                                                                                                                                                                                        | 'point'
                                                                                                                                                                                                                                                                                                                                                                                                                                        | 'text'
                                                                                                                                                                                                                                                                                                                                                                                                                                        | 'cell'
                                                                                                                                                                                                                                                                                                                                                                                                                                        | 'area'
                                                                                                                                                                                                                                                                                                                                                                                                                                        | 'node'
                                                                                                                                                                                                                                                                                                                                                                                                                                        | 'edge'
                                                                                                                                                                                                                                                                                                                                                                                                                                        | 'link'
                                                                                                                                                                                                                                                                                                                                                                                                                                        | 'image'
                                                                                                                                                                                                                                                                                                                                                                                                                                        | 'polygon'
                                                                                                                                                                                                                                                                                                                                                                                                                                        | 'box'
                                                                                                                                                                                                                                                                                                                                                                                                                                        | 'vector'
                                                                                                                                                                                                                                                                                                                                                                                                                                        | 'lineX'
                                                                                                                                                                                                                                                                                                                                                                                                                                        | 'lineY'
                                                                                                                                                                                                                                                                                                                                                                                                                                        | 'connector'
                                                                                                                                                                                                                                                                                                                                                                                                                                        | 'range'
                                                                                                                                                                                                                                                                                                                                                                                                                                        | 'rangeX'
                                                                                                                                                                                                                                                                                                                                                                                                                                        | 'rangeY'
                                                                                                                                                                                                                                                                                                                                                                                                                                        | 'sankey'
                                                                                                                                                                                                                                                                                                                                                                                                                                        | 'chord'
                                                                                                                                                                                                                                                                                                                                                                                                                                        | 'path'
                                                                                                                                                                                                                                                                                                                                                                                                                                        | 'treemap'
                                                                                                                                                                                                                                                                                                                                                                                                                                        | 'pack'
                                                                                                                                                                                                                                                                                                                                                                                                                                        | 'boxplot'
                                                                                                                                                                                                                                                                                                                                                                                                                                        | 'shape'
                                                                                                                                                                                                                                                                                                                                                                                                                                        | 'forceGraph'
                                                                                                                                                                                                                                                                                                                                                                                                                                        | 'tree'
                                                                                                                                                                                                                                                                                                                                                                                                                                        | 'wordCloud'
                                                                                                                                                                                                                                                                                                                                                                                                                                        | 'gauge'
                                                                                                                                                                                                                                                                                                                                                                                                                                        | 'density'
                                                                                                                                                                                                                                                                                                                                                                                                                                        | 'heatmap'
                                                                                                                                                                                                                                                                                                                                                                                                                                        | 'liquid'
                                                                                                                                                                                                                                                                                                                                                                                                                                        | MarkComponent
                                                                                                                                                                                                                                                                                                                                                                                                                                        | CompositeMarkType;

                                                                                                                                                                                                                                                                                                                                                                                                                                          type MaybeFunctionAttributeOptions

                                                                                                                                                                                                                                                                                                                                                                                                                                          type MaybeFunctionAttributeOptions = Record<string, never>;

                                                                                                                                                                                                                                                                                                                                                                                                                                            type MaybeGradientOptions

                                                                                                                                                                                                                                                                                                                                                                                                                                            type MaybeGradientOptions = Record<string, never>;

                                                                                                                                                                                                                                                                                                                                                                                                                                              type MaybeIdentityXOptions

                                                                                                                                                                                                                                                                                                                                                                                                                                              type MaybeIdentityXOptions = Record<string, never>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                type MaybeIdentityYOptions

                                                                                                                                                                                                                                                                                                                                                                                                                                                type MaybeIdentityYOptions = Record<string, never>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                  type MaybeKeyOptions

                                                                                                                                                                                                                                                                                                                                                                                                                                                  type MaybeKeyOptions = Record<string, never>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                    type MaybeSeriesOptions

                                                                                                                                                                                                                                                                                                                                                                                                                                                    type MaybeSeriesOptions = Record<string, never>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                      type MaybeSizeOptions

                                                                                                                                                                                                                                                                                                                                                                                                                                                      type MaybeSizeOptions = Record<string, never>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                        type MaybeStackYOptions

                                                                                                                                                                                                                                                                                                                                                                                                                                                        type MaybeStackYOptions = {
                                                                                                                                                                                                                                                                                                                                                                                                                                                        series?: boolean;
                                                                                                                                                                                                                                                                                                                                                                                                                                                        };

                                                                                                                                                                                                                                                                                                                                                                                                                                                          type MaybeTitleOptions

                                                                                                                                                                                                                                                                                                                                                                                                                                                          type MaybeTitleOptions = {
                                                                                                                                                                                                                                                                                                                                                                                                                                                          channel?: string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                          };

                                                                                                                                                                                                                                                                                                                                                                                                                                                            type MaybeTooltipOptions

                                                                                                                                                                                                                                                                                                                                                                                                                                                            type MaybeTooltipOptions = {
                                                                                                                                                                                                                                                                                                                                                                                                                                                            channel: string | string[];
                                                                                                                                                                                                                                                                                                                                                                                                                                                            };

                                                                                                                                                                                                                                                                                                                                                                                                                                                              type MaybeTupleOptions

                                                                                                                                                                                                                                                                                                                                                                                                                                                              type MaybeTupleOptions = Record<string, never>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                type MaybeTupleXOptions

                                                                                                                                                                                                                                                                                                                                                                                                                                                                type MaybeTupleXOptions = Record<string, never>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                  type MaybeTupleYOptions

                                                                                                                                                                                                                                                                                                                                                                                                                                                                  type MaybeTupleYOptions = Record<string, never>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                    type MaybeVisualPositionOptions

                                                                                                                                                                                                                                                                                                                                                                                                                                                                    type MaybeVisualPositionOptions = Record<string, never>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                      type MaybeZeroPaddingOptions

                                                                                                                                                                                                                                                                                                                                                                                                                                                                      type MaybeZeroPaddingOptions = Record<string, never>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                        type MaybeZeroXOptions

                                                                                                                                                                                                                                                                                                                                                                                                                                                                        type MaybeZeroXOptions = Record<string, never>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                          type MaybeZeroY1Options

                                                                                                                                                                                                                                                                                                                                                                                                                                                                          type MaybeZeroY1Options = Record<string, never>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                            type MaybeZeroYOptions

                                                                                                                                                                                                                                                                                                                                                                                                                                                                            type MaybeZeroYOptions = Record<string, never>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                              type MorphingAnimation

                                                                                                                                                                                                                                                                                                                                                                                                                                                                              type MorphingAnimation = BaseAnimation<'morphing'>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                type NodeMark

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                type NodeMark = BaseMark<'node', ChannelTypes>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  type NormalizeYOptions

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  type NormalizeYOptions = Omit<NormalizeYTransform, 'type'>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    type NormalizeYTransform

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    type NormalizeYTransform = {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    type?: 'normalizeY';
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    series?: boolean;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    groupBy?: string | string[];
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    basis?:
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    | 'deviation'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    | 'first'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    | 'last'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    | 'max'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    | 'mean'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    | 'median'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    | 'min'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    | 'sum';
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    };

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      type OrdinalScale

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      type OrdinalScale = BaseScale<'ordinal', OrdinalOptions>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        type OverflowHideLabelTransform

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        type OverflowHideLabelTransform = {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        type: 'overflowHide';
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        };

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          type OverlapDodgeYLabelTransform

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          type OverlapDodgeYLabelTransform = {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          type?: 'overlapDodgeY';
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          maxIterations?: number;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          maxError?: number;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          padding?: number;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          };

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            type OverlapHideLabelTransform

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            type OverlapHideLabelTransform = {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            type?: 'overlapHide';
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            /**
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            * The hide priority, is the comparator for label.sort().
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            */
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            priority?: (a: DisplayObject, b: DisplayObject) => number;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            };

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              type PackMark

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              type PackMark = BaseMark<'pack', 'value' | ChannelTypes> & {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              layout?: Record<string, any>;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              };

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                type PackOptions

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                type PackOptions = Omit<PackTransform, 'type'>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  type PackTransform

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  type PackTransform = {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  type?: 'pack';
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  padding?: number;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  direction?: 'row' | 'col';
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  };

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    type Palette

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    type Palette = Category10Palette | Category20Palette | CustomPalette;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      type PaletteTypes

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      type PaletteTypes = 'category10' | 'category20' | PaletteComponent;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        type ParallelCoordinate

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        type ParallelCoordinate = BaseCoordinate<{
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        type?: 'parallel';
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        }>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          type PathInAnimation

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          type PathInAnimation = BaseAnimation<'pathIn'>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            type PathMark

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            type PathMark = BaseMark<'path', ChannelTypes | 'd'>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              type PickTransform

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              type PickTransform = {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              type?: 'pick';
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              fields?: string[];
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              };

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                type PointMark

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                type PointMark = BaseMark<'point'>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  type PointScale

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  type PointScale = BaseScale<'point', PointOptions>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    type PolarCoordinate

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    type PolarCoordinate = BaseCoordinate<{
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    type?: 'polar';
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    startAngle?: number;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    endAngle?: number;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    innerRadius?: number;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    outerRadius?: number;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    }>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      type PolygonMark

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      type PolygonMark = BaseMark<'polygon', ChannelTypes>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        type PoptipInteraction

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        type PoptipInteraction = {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        type?: 'poptip';
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        offsetX?: number;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        offsetY?: number;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        } & Record<`tip${any}`, any>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          type PositionChannelTypes

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          type PositionChannelTypes = 'x' | 'y' | 'z' | 'position' | `position${number}`;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            type PowScale

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            type PowScale = BaseScale<'pow', PowOptions>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              type QuantileScale

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              type QuantileScale = BaseScale<'quantile', QuantileOptions>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                type QuantizeScale

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                type QuantizeScale = BaseScale<'quantize', QuantizeOptions>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  type RadarCoordinate

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  type RadarCoordinate = BaseCoordinate<{
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  type?: 'radar';
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  startAngle?: number;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  endAngle?: number;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  innerRadius?: number;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  outerRadius?: number;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  }>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    type RadialCoordinate

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    type RadialCoordinate = BaseCoordinate<{
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    type?: 'radial';
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    startAngle?: number;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    endAngle?: number;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    innerRadius?: number;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    outerRadius?: number;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    }>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      type RangeMark

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      type RangeMark = BaseMark<'range', ChannelTypes>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        type RangeXMark

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        type RangeXMark = BaseMark<'rangeX', ChannelTypes>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          type RangeYMark

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          type RangeYMark = BaseMark<'rangeY', ChannelTypes>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            type RectMark

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            type RectMark = BaseMark<'rect', ChannelTypes>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              type Reducer

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              type Reducer =
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              | 'mean'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              | 'max'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              | 'count'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              | 'min'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              | 'median'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              | 'sum'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              | 'first'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              | 'last'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              | ((I: number[], V: Primitive[]) => Primitive);

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                type RenameTransform

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                type RenameTransform = {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                type?: 'rename';
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                [key: string]: string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                };

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  type RepeatMatrixComposition

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  type RepeatMatrixComposition = {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  type?: 'repeatMatrix';
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  padding?: Padding;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  paddingLeft?: Padding;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  paddingRight?: Padding;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  paddingTop?: Padding;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  paddingBottom?: Padding;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  margin?: number;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  marginLeft?: number;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  marginBottom?: number;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  marginTop?: number;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  marginRight?: number;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  transform?: Transform;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  title?: string | TitleComponent;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  data?: Data;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  key?: string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  encode?: {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  x?: string[] | string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  y?: string[] | string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  position?: string[];
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  };
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  scale?: {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  x?: Scale;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  y?: Scale;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  color?: Scale;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  };
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  axis?: Record<string, any> | boolean;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  legend?: Record<string, any> | boolean;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  children?: Node[] | ((facet: FacetContext) => Node);
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  [key: string]: any;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  };

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    type SampleFunction

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    type SampleFunction = (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    I: number[],
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    X: number[],
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Y: number[],
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    thresholds: number
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    ) => number[];

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      type SampleOptions

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      type SampleOptions = Omit<SampleTransform, 'type'>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        type SampleTransform

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        type SampleTransform = {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        type?: 'sample';
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        /**
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        * Sample strategy. Default is 'median'.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        */
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        strategy?: 'lttb' | 'median' | 'max' | 'min' | 'first' | 'last' | SampleFunction;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        /**
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        * The thresholds of sample, when data size great then thresholds, sample will take effect.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        * Default is 2000.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        */
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        thresholds?: number;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        /**
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        * Group data by fields, for series data.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        */
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        groupBy?: string | string[];
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        };

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          type SankeyMark

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          type SankeyMark = BaseMark<
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          'sankey',
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          | 'source'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          | 'target'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          | 'value'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          | `node${Capitalize<ChannelTypes>}`
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          | `link${Capitalize<ChannelTypes>}`
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          | ChannelTypes
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          > & {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          layout?: {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          nodeId?: (node: any) => string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          nodes?: (graph: any) => any;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          links?: (graph: any) => any;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          /**
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          * sankey.nodeSort(undefined) is the default and resorts by ascending breadth during each iteration.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          * sankey.nodeSort(null) specifies the input order of nodes and never sorts.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          * sankey.nodeSort(function) specifies the given order as a comparator function and sorts once on initialization.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          */
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          nodeSort?: null | undefined | ((a: any, b: any) => number);
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          /**
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          * sankey.linkSort(undefined) is the default, indicating that vertical order of links within each node will be determined automatically by the layout. If
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          * sankey.linkSort(null) will resort by the input.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          * sankey.linkSort(function) specifies the given order as a comparator function and sorts once on initialization.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          */
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          linkSort?: null | undefined | ((a: any, b: any) => number);
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          nodeAlign?:
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          | 'left'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          | 'center'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          | 'right'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          | 'justify'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          | ((node: any, n: number) => number);
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          nodeWidth?: number;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          nodePadding?: number;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          iterations?: number;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          nodeDepth?: (datum: any, maxDepth: number) => number;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          };
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          nodeLabels: Record<string, any>[];
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          linkLabels: Record<string, any>[];
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          };

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            type Scale

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            type Scale =
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            | LinearScale
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            | OrdinalScale
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            | IdentityScale
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            | BandScale
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            | PointScale
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            | TimeScale
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            | LogScale
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            | PowScale
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            | SqrtScale
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            | ThresholdScale
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            | QuantizeScale
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            | QuantileScale
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            | SequentialScale
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            | CustomScale
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            | ConstantScale;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              type ScaleInXAnimation

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              type ScaleInXAnimation = BaseAnimation<'scaleInX'>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                type ScaleInYAnimation

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                type ScaleInYAnimation = BaseAnimation<'scaleInY'>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  type ScaleOutXAnimation

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  type ScaleOutXAnimation = BaseAnimation<'scaleOutX'>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    type ScaleOutYAnimation

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    type ScaleOutYAnimation = BaseAnimation<'scaleOutY'>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      type ScaleTypes

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      type ScaleTypes =
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      | 'linear'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      | 'ordinal'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      | 'identity'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      | 'band'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      | 'point'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      | 'time'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      | 'log'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      | 'pow'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      | 'sqrt'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      | 'threshold'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      | 'quantize'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      | 'quantile'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      | 'sequential'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      | 'constant'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      | ScaleComponent;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        type ScrollbarComponent

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        type ScrollbarComponent = any;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          type SelectOptions

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          type SelectOptions = Omit<SelectTransform, 'type'>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            type Selector

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            type Selector =
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            | 'min'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            | 'max'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            | 'first'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            | 'last'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            | 'mean'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            | 'median'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            | ((I: number[], V: number[]) => number[]);

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              type SelectTransform

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              type SelectTransform = {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              type?: 'select';
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              groupBy?: string | string[];
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              channel?: ChannelTypes;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              selector?: Selector;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              };

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                type SelectXOptions

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                type SelectXOptions = Omit<SelectXTransform, 'type'>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  type SelectXTransform

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  type SelectXTransform = {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  type?: 'selectX';
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  groupBy?: string | string[];
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  selector?: Selector;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  };

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    type SelectYOptions

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    type SelectYOptions = Omit<SelectYTransform, 'type'>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      type SelectYTransform

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      type SelectYTransform = {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      type?: 'selectY';
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      groupBy?: string | string[];
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      selector?: Selector;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      };

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        type SequentialScale

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        type SequentialScale = BaseScale<'sequential', SequentialOptions>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          type ShapeComponent

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          type ShapeComponent<O = Record<string, unknown>> = G2BaseComponent<
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Shape,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          O,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          ShapeProps,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          ShapeContext
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          >;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            type ShapeMark

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            type ShapeMark = BaseMark<'shape', ChannelTypes>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              type SingleMark

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              type SingleMark = (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              I: number[],
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              scale: Record<string, Scale>,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              channel: MarkChannel,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              coordinate: Coordinate
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              ) => [I: number[], point2d: Vector2[][], series?: number[][]];

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                type SliceTransform

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                type SliceTransform = {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                type?: 'slice';
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                /**
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                * The start index for slice. Default is 0.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                */
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                start?: number;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                /**
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                * The end index for slice. Default is arr.length - 1
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                */
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                end?: number;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                };

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  type SliderComponent

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  type SliderComponent = any;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    type SliderFilterInteraction

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    type SliderFilterInteraction = {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    type?: 'sliderFilter';
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    wait?: number;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    leading?: boolean;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    trailing?: boolean;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    };

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      type SortByTransform

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      type SortByTransform = {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      type?: 'sortBy';
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      /** type: [field, order]; order: true => ascend, false => descend */
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      fields?: (string | [string, boolean?])[];
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      };

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        type SortColorOptions

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        type SortColorOptions = Omit<SortColorTransform, 'type'>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          type SortColorTransform

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          type SortColorTransform = {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          type?: 'sortColor';
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          reverse?: boolean;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          by?: string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          slice?: number | [number, number];
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          reducer?:
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          | 'max'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          | 'min'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          | 'sum'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          | 'first'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          | 'last'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          | 'mean'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          | 'median'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          | ((I: number[], V: Primitive[]) => Primitive);
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          };

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            type SortTransform

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            type SortTransform = {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            type?: 'sort';
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            /**
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            * The sort comparator, same with [Array.prototype.sort](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/sort).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            */
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            callback?: (a: any, b: any) => number;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            };

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              type SortXOptions

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              type SortXOptions = Omit<SortXTransform, 'type'>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                type SortXTransform

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                type SortXTransform = {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                type?: 'sortX';
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                reverse?: boolean;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                by?: string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                slice?: number | [number, number];
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                ordinal?: boolean;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                reducer?:
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                | 'max'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                | 'min'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                | 'sum'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                | 'first'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                | 'last'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                | 'mean'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                | 'median'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                | ((I: number[], V: Primitive[]) => Primitive);
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                };

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  type SortYOptions

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  type SortYOptions = Omit<SortYTransform, 'type'>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    type SortYTransform

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    type SortYTransform = {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    type?: 'sortY';
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    reverse?: boolean;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    by?: string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    slice?: number | [number, number];
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    reducer?:
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    | 'max'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    | 'min'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    | 'sum'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    | 'first'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    | 'last'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    | 'mean'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    | 'median'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    | ((I: number[], V: Primitive[]) => Primitive);
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    };

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      type SpaceFlexComposition

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      type SpaceFlexComposition = {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      type?: 'spaceFlex';
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      key?: string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      data?: Data;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      direction?: 'col' | 'row';
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      ratio?: number[];
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      padding?: Padding;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      children?: Node[];
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      [key: string]: any;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      };

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        type SpaceLayerComposition

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        type SpaceLayerComposition = {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        type?: 'spaceLayer';
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        key?: string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        data?: any;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        children?: Node[];
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        [key: string]: any;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        };

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          type SqrtScale

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          type SqrtScale = BaseScale<'sqrt', SqrtOptions>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            type StackEnterOptions

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            type StackEnterOptions = Omit<StackEnterTransform, 'type'>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              type StackEnterTransform

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              type StackEnterTransform = {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              type?: 'stackEnter';
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              groupBy?: string[] | string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              orderBy?: string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              reverse?: boolean;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              duration?: number;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              reducer?: (I: number[], V: any[]) => any;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              };

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                type StackYOptions

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                type StackYOptions = Omit<StackYTransform, 'type'>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  type StackYTransform

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  type StackYTransform = {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  type?: 'stackY';
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  groupBy?: string | string[];
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  reverse?: boolean;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  orderBy?: TransformOrder;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  y?: 'y' | 'y1';
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  y1?: 'y' | 'y1';
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  series?: boolean;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  };

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    type SymmetryYOptions

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    type SymmetryYOptions = Omit<SymmetryYTransform, 'type'>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      type SymmetryYTransform

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      type SymmetryYTransform = {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      type?: 'symmetryY';
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      groupBy?: string | string[];
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      };

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        type TextMark

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        type TextMark = BaseMark<
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        'text',
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        ChannelTypes | 'text' | 'fontSize' | 'fontWeight' | 'rotate'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        >;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          type Theme

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          type Theme =
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          | ClassicTheme
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          | ClassicDarkTheme
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          | LightTheme
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          | DarkTheme
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          | AcademyTheme
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          | CustomTheme;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            type ThemeTypes

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            type ThemeTypes =
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            | 'classic'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            | 'classicDark'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            | 'light'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            | 'dark'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            | 'academy'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            | ThemeComponent;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              type ThetaCoordinate

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              type ThetaCoordinate = BaseCoordinate<{
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              type?: 'theta';
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              startAngle?: number;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              endAngle?: number;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              innerRadius?: number;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              outerRadius?: number;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              }>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                type ThresholdScale

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                type ThresholdScale = BaseScale<'threshold', ThresholdOptions>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  type TimeScale

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  type TimeScale = BaseScale<'time', TimeOptions>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    type TimingKeyframeComposition

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    type TimingKeyframeComposition = {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    type?: 'timingKeyframe';
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    duration?: number;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    key?: string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    easing?: string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    iterationCount?: 'infinite' | number;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    direction?: 'normal' | 'reverse' | 'alternate' | 'reverse-alternate';
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    children?: Node[];
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    [key: string]: any;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    };

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      type TitleComponent

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      type TitleComponent = {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      /**
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      * Height of title, default is 36.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      */
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      size?: number;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      /**
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      * Text of title.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      */
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      title?: string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      /**
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      * Text of subtitle.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      */
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      subtitle?: string | null;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      /**
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      * Align method for title.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      */
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      align?: 'left' | 'center' | 'right';
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      /**
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      * The vertical spacing between title and subtitle, default is 2.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      */
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      spacing?: number;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      } & UsePrefix<'title' | 'subtitle', Record<string, any>>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        type TooltipComponent

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        type TooltipComponent =
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        | TooltipItem
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        | TooltipItem[]
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        | {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        title?: Encodeable<TooltipTitle>;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        items?: TooltipItem[] | null | false;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        [key: string]: any;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        }
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        | null
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        | false;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          type TooltipInteraction

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          type TooltipInteraction = {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          type?: 'tooltip';
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          shared?: boolean;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          series?: boolean;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          facet?: boolean;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          body?: boolean;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          crosshairs?: boolean;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          marker?: boolean;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          groupName?: boolean;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          disableNative?: boolean;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          offset?: [number, number];
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          position?: TooltipStyleProps['position'];
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          bounding?: BBox;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          mount?: string | HTMLElement;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          css?: Record<string, any>;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          enterable?: boolean;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          sort?: (d: TooltipItemValue) => any;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          filter?: (d: TooltipItemValue) => any;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          render?: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          event: any, // @todo
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          options: {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          title: 'string';
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          items: TooltipItemValue[];
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          }
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          ) => HTMLElement | string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          } & Record<`crosshairs${any}`, any> &
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Record<`marker${any}`, any>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            type TooltipItem

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            type TooltipItem =
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            | string
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            | {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            name?: string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            color?: string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            channel?: string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            field?: string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            value?: string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            valueFormatter?: string | ((d: any) => string);
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            }
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            | Encodeable<Primitive>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            | Encodeable<TooltipItemValue>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              type TooltipItemValue

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              type TooltipItemValue = {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              name?: string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              color?: string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              value?: Primitive;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              };

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                type TooltipTitle

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                type TooltipTitle =
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                | string
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                | {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                field?: string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                channel?: string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                value?: string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                };

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  type Transform

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  type Transform =
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  | StackYTransform
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  | DodgeXTransform
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  | NormalizeYTransform
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  | StackEnterTransform
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  | JitterTransform
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  | JitterXTransform
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  | JitterYTransform
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  | SymmetryYTransform
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  | DiffYTransform
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  | SelectTransform
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  | SelectXTransform
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  | SelectYTransform
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  | GroupXTransform
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  | GroupYTransform
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  | GroupColorTransform
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  | SortXTransform
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  | SortYTransform
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  | SortColorTransform
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  | GroupTransform
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  | PackTransform
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  | BinXTransform
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  | BinTransform
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  | SampleTransform
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  | FlexXTransform
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  | FilterTransform;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    type TransformEncode

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    type TransformEncode = {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    type?: 'transform';
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    value?: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    value: Record<string, Primitive>,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    index: number,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    array: Record<string, Primitive>[]
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    ) => Primitive;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    };

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      type TransformOrder

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      type TransformOrder =
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      | 'value'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      | 'sum'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      | 'series'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      | 'maxIndex'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      | string[]
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      | null
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      | ((data: Record<string, Primitive>) => Primitive);

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        type TransformTypes

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        type TransformTypes =
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        | 'dodgeX'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        | 'stackY'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        | 'normalizeY'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        | 'stackEnter'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        | 'jitter'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        | 'jitterX'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        | 'jitterY'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        | 'symmetryY'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        | 'diffY'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        | 'select'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        | 'selectY'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        | 'selectX'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        | 'groupX'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        | 'groupY'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        | 'group'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        | 'groupColor'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        | 'sortX'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        | 'sortColor'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        | 'sortY'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        | 'flexX'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        | 'pack'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        | 'sample'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        | 'filter'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        | 'kde'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        | TransformComponent;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          type TransposeCoordinate

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          type TransposeCoordinate = {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          type?: 'transpose';
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          };

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            type TreemapMark

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            type TreemapMark = BaseMark<'treemap', 'value' | ChannelTypes> & {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            layout?: Record<string, any>;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            };

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              type TreeMark

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              type TreeMark = BaseMark<'tree', 'value' | ChannelTypes> & {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              layout?: {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              /**
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              * Layout field. Default: 'value'.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              */
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              field?: string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              /**
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              * Sets this cluster layout’s node size to the specified two-element array of numbers [width, height] and returns this cluster layout.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              * Default: null.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              */
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              nodeSize?: any;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              /**
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              * The separation accessor is used to separate neighboring leaves. Default: (a, b) => a.parent == b.parent ? 1 : 2;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              */
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              separation?: (a: any, b: any) => number;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              /**
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              * Sort function by compare 2 nodes.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              */
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              sortBy?: (a: any, b: any) => number;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              /**
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              * Layout infomation saved into fields. Default: ['x', 'y'].
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              */
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              as?: [string, string];
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              };
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              nodeLabels: Record<string, any>[];
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              linkLabels: Record<string, any>[];
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              };

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                type Vector2

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                type Vector2 = [number, number];

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  type Vector3

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  type Vector3 = [number, number, number];

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    type VectorMark

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    type VectorMark = BaseMark<'vector', ChannelTypes | 'rotate' | 'size'>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      type VennDataTransform

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      type VennDataTransform = {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      type?: 'venn';
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      /**
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      * Canvas padding for 4 direction.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      * Default is `0`.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      */
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      padding?: number;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      /**
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      * Set the sets field.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      * Default is `sets`.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      */
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      sets?: string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      /**
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      * Set the size field for each set.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      * Default is `size`.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      */
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      size?: string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      /**
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      * Set the generated fields, includes: [key, x, y, path]
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      */
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      as?: [string, string];
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      };

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        type ViewComposition

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        type ViewComposition = {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        type?: 'view';
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        x?: number;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        y?: number;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        z?: number;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        width?: number;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        height?: number;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        depth?: number;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        data?: Data;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        key?: string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        class?: string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        padding?: Padding;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        paddingLeft?: Padding;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        paddingRight?: Padding;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        paddingTop?: Padding;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        paddingBottom?: Padding;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        margin?: number;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        marginLeft?: number;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        marginBottom?: number;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        marginTop?: number;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        marginRight?: number;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        inset?: number;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        insetLeft?: number;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        insetTop?: number;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        insetBottom?: number;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        insetRight?: number;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        coordinate?: Coordinate;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        interaction?: Literal2Object<Interaction> & Record<string, any>;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        transform?: Transform[];
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        theme?: Theme;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        children?: (Mark | AxisComponent | LegendComponent)[];
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        scale?: Record<string, Scale>;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        frame?: boolean;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        labelTransform?: LabelTransform[];
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        axis?: Closeable<
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Partial<Record<PositionChannelTypes, Closeable<AxisComponent>>>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        >;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        legend?: Closeable<
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Partial<Record<AtheisticChanelTypes, Closeable<LegendComponent>>>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        >;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        tooltip?: TooltipComponent;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        slider?: Closeable<
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Partial<Record<PositionChannelTypes, Closeable<SliderComponent>>>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        >;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        scrollbar?: Closeable<
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Partial<Record<PositionChannelTypes, Closeable<ScrollbarComponent>>>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        >;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        title?: string | TitleComponent;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        style?: Record<string, any>;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        clip?: boolean;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        };

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          type WaveInAnimation

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          type WaveInAnimation = BaseAnimation<'waveIn'>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            type WordCloudMark

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            type WordCloudMark = BaseMark<'wordCloud', 'value' | ChannelTypes | 'text'> & {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            layout?: {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            /**
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            * @description If specified, sets the rectangular [width, height] of the layout
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            * @default [1, 1]
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            */
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            size?: [number, number];
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            font?: string | ((word: any) => string);
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            fontStyle?: string | ((word: any) => string);
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            fontWeight?: any | ((word: any) => any);
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            fontSize?: number | [number, number] | ((word: any) => number);
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            padding?: number | ((word: any) => number);
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            /**
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            * @description sets the text accessor function, which indicates the text for each word
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            * @default (d) => d.text
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            */
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            text?: (word: any) => number;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            rotate?: number | ((word: any) => number);
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            timeInterval?: number;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            random?: number | (() => number);
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            /**
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            * @description sets the current type of spiral used for positioning words. This can either be one of the two built-in spirals, "archimedean" and "rectangular"
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            * @default "archimedean"
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            */
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            spiral?:
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            | 'archimedean'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            | 'rectangular'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            | ((size: [number, number]) => (t: number) => number[]);
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            imageMask?: HTMLImageElement | string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            on?:
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            | ((
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            type: 'end',
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            details?: {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            cloud: any;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            words: any;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            bounds: any;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            }
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            ) => void)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            | ((
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            type: 'word',
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            details?: {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            cloud: any;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            word: any;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            }
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            ) => void);
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            };
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            };

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              type ZoomInAnimation

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              type ZoomInAnimation = BaseAnimation<'zoomIn'>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                type ZoomOutYAnimation

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                type ZoomOutYAnimation = BaseAnimation<'zoomOut'>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Package Files (90)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Dependencies (12)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Dev Dependencies (49)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  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/@antv/g2.

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