@antv/g2

  • Version 5.2.1
  • Published
  • 7.58 MB
  • 22 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>
        >;
        '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
        >;
        '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>
                      >;
                      '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
                      >;
                      '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 '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 '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 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 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}.${any}`,
                                          component: G2Component
                                          ) => 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 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 '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 '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 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 {}

                                                                                                                          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][];
                                                                                                                                              } & 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?: