@antv/g2

@antv/g2

Version 5.1.18
Published 10 days ago
7.5 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

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
        >;
        '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
        >;
        '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
        >;
        '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.wordCloud': import('./runtime').CompositeMarkComponent<
            import('./mark').WordCloudOptions
        >;
        '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>;
    '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
    >;
    '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
    >;
    '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.wordCloud': import('./runtime').CompositeMarkComponent<
        import('./mark').WordCloudOptions
    >;
    '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 '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 '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
    >;
};

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 '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 '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 '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
    >;
    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?: 'brushXFilter';
    reverse?: boolean;
} & Record<`${'mask'}${any}`, any>;

type BrushXHighlightInteraction

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

type BrushYFilterInteraction

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

type BrushYHighlightInteraction

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

type CartesianCoordinate

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

type Category10Palette

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

type Category20Palette

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

type CellMark

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

type Channel

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

type ChannelTypes

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

type ChartIndexInteraction

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

type ChartOptions

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

type ChordMark

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

type ClassicDarkTheme

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

type ClassicTheme

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

type ColumnEncode

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

type Component

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

type CompositeMark

type CompositeMark = BaseMark<CompositeMarkType>;

type CompositeMarkType

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

type Composition

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

type CompositionTypes

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

type ConnectorMark

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

type ConstantEncode

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

type ConstantScale

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

type ContrastReverseLabelTransform

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

type Coordinate

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

type CoordinateTransform

type CoordinateTransform = TransposeCoordinate | FisheyeCoordinate;

type CoordinateTransformTypes

type CoordinateTransformTypes = 'transpose' | 'fisheye';

type CoordinateTypes

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

type CustomCoordinate

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

type CustomDataTransform

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

type CustomEncode

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

type CustomInteraction

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

type CustomMark

type CustomMark = BaseMark<MarkComponent, ChannelTypes>;

type CustomPalette

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

type CustomScale

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

type CustomTheme

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

type CustomTransform

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

type DarkTheme

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

type Data

type Data = FetchConnector | InlineConnector;

type DataTransform

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

type DataTransformTypes

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

type DataTypes

type DataTypes = 'inline' | 'fetch';

type DensityMark

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

type DiffYOptions

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

type DiffYTransform

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

type DodgeXOptions

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

type DodgeXTransform

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

type EdgeMark

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

type ElementHighlightByColorInteraction

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

type ElementHighlightByXInteraction

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

type ElementHighlightInteraction

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

type ElementSelectByColorInteraction

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

type ElementSelectByXInteraction

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

type ElementSelectInteraction

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

type Encode

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

type Encodeable

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

type EncodeTypes

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

type FacetCircleComposition

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

type FacetContext

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

type FacetRectComposition

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

type FadeInAnimation

type FadeInAnimation = BaseAnimation<'fadeIn'>;

type FadeOutAnimation

type FadeOutAnimation = BaseAnimation<'fadeOut'>;

type FetchConnector

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

type FieldEncode

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

type FilterDataTransform

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

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

type FilterTransform

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

type FisheyeCoordinate

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

type FisheyeInteraction

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

type FlexXOptions

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

type FlexXTransform

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

type FoldTransform

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

type ForceGraphMark

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

type G2BaseComponent

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

type G2Context

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

type G2Spec

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

type GaugeMark

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

type GeoCoordinate

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

type GeoPathComposition

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

type GeoViewComposition

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

type GroupColorOptions

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

type GroupColorTransform

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

type GroupOptions

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

type GroupTransform

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

type GroupXOptions

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

type GroupXTransform

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

type GroupYOptions

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

type GroupYTransform

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

type GrowInXAnimation

type GrowInXAnimation = BaseAnimation<'growInX'>;

type GrowInYAnimation

type GrowInYAnimation = BaseAnimation<'growInY'>;

type GuideComponentComponent

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

type HeatmapMark

type HeatmapMark = BaseMark<'heatmap'>;

type HelixCoordinate

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

type IdentityScale

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

type ImageMark

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

type InlineConnector

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

type Interaction

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

type InteractionTypes

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

type IntervalMark

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

type JitterOptions

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

type JitterTransform

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

type JitterXOptions

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

type JitterXTransform

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

type JitterYOptions

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

type JitterYTransform

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

type JoinTransform

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

type KDEDataTransform

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

type LabelTransform

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

type LegendComponent

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

type LegendFilterInteraction

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

type LegendHighlightInteraction

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

type LightTheme

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

type LinearScale

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

type LineMark

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

type LineXMark

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

type LineYMark

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

type LinkMark

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

type LiquidMark

type LiquidMark = BaseMark<'liquid'>;

type LogDataTransform

type LogDataTransform = {};

type LogScale

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

type MapTransform

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

type Mark

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

type MarkComponent

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

type MarkTypes

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

type MaybeFunctionAttributeOptions

type MaybeFunctionAttributeOptions = Record<string, never>;

type MaybeGradientOptions

type MaybeGradientOptions = Record<string, never>;

type MaybeIdentityXOptions

type MaybeIdentityXOptions = Record<string, never>;

type MaybeIdentityYOptions

type MaybeIdentityYOptions = Record<string, never>;

type MaybeKeyOptions

type MaybeKeyOptions = Record<string, never>;

type MaybeSeriesOptions

type MaybeSeriesOptions = Record<string, never>;

type MaybeSizeOptions

type MaybeSizeOptions = Record<string, never>;

type MaybeStackYOptions

type MaybeStackYOptions = {
    series?: boolean;
};

type MaybeTitleOptions

type MaybeTitleOptions = {
    channel?: string;
};

type MaybeTooltipOptions

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

type MaybeTupleOptions

type MaybeTupleOptions = Record<string, never>;

type MaybeTupleXOptions

type MaybeTupleXOptions = Record<string, never>;

type MaybeTupleYOptions

type MaybeTupleYOptions = Record<string, never>;

type MaybeVisualPositionOptions

type MaybeVisualPositionOptions = Record<string, never>;

type MaybeZeroPaddingOptions

type MaybeZeroPaddingOptions = Record<string, never>;

type MaybeZeroXOptions

type MaybeZeroXOptions = Record<string, never>;

type MaybeZeroY1Options

type MaybeZeroY1Options = Record<string, never>;

type MaybeZeroYOptions

type MaybeZeroYOptions = Record<string, never>;

type MorphingAnimation

type MorphingAnimation = BaseAnimation<'morphing'>;

type NodeMark

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

type NormalizeYOptions

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

type NormalizeYTransform

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

type OrdinalScale

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

type OverflowHideLabelTransform

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

type OverlapDodgeYLabelTransform

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

type OverlapHideLabelTransform

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

type PackMark

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

type PackOptions

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

type PackTransform

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

type Palette

type Palette = Category10Palette | Category20Palette | CustomPalette;

type PaletteTypes

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

type ParallelCoordinate

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

type PathInAnimation

type PathInAnimation = BaseAnimation<'pathIn'>;

type PathMark

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

type PickTransform

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

type PointMark

type PointMark = BaseMark<'point'>;

type PointScale

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

type PolarCoordinate

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

type PolygonMark

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

type PoptipInteraction

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

type PositionChannelTypes

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

type PowScale

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

type QuantileScale

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

type QuantizeScale

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

type RadarCoordinate

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

type RadialCoordinate

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

type RangeMark

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

type RangeXMark

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

type RangeYMark

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

type RectMark

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

type Reducer

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

type RenameTransform

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

type RepeatMatrixComposition

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

type SampleFunction

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

type SampleOptions

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

type SampleTransform

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

type SankeyMark

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

type Scale

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

type ScaleInXAnimation

type ScaleInXAnimation = BaseAnimation<'scaleInX'>;

type ScaleInYAnimation

type ScaleInYAnimation = BaseAnimation<'scaleInY'>;

type ScaleOutXAnimation

type ScaleOutXAnimation = BaseAnimation<'scaleOutX'>;

type ScaleOutYAnimation

type ScaleOutYAnimation = BaseAnimation<'scaleOutY'>;

type ScaleTypes

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

type ScrollbarComponent

type ScrollbarComponent = any;

type SelectOptions

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

type Selector

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

type SelectTransform

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

type SelectXOptions

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

type SelectXTransform

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

type SelectYOptions

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

type SelectYTransform

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

type SequentialScale

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

type ShapeComponent

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

type ShapeMark

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

type SingleMark

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

type SliceTransform

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

type SliderComponent

type SliderComponent = any;

type SliderFilterInteraction

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

type SortByTransform

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

type SortColorOptions

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

type SortColorTransform

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

type SortTransform

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

type SortXOptions

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

type SortXTransform

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

type SortYOptions

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

type SortYTransform

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

type SpaceFlexComposition

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

type SpaceLayerComposition

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

type SqrtScale

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

type StackEnterOptions

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

type StackEnterTransform

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

type StackYOptions

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

type StackYTransform

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

type SymmetryYOptions

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

type SymmetryYTransform

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

type TextMark

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

type Theme

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

type ThemeTypes

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

type ThetaCoordinate

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

type ThresholdScale

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

type TimeScale

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

type TimingKeyframeComposition

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

type TitleComponent

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

type TooltipComponent

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

type TooltipInteraction

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

type TooltipItem

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

type TooltipItemValue

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

type TooltipTitle

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

type Transform

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

type TransformEncode

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

type TransformOrder

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

type TransformTypes

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

type TransposeCoordinate

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

type TreemapMark

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

type TreeMark

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

type Vector2

type Vector2 = [number, number];

type Vector3

type Vector3 = [number, number, number];

type VectorMark

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

type VennDataTransform

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

type ViewComposition

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

type WaveInAnimation

type WaveInAnimation = BaseAnimation<'waveIn'>;

type WordCloudMark

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

type ZoomInAnimation

type ZoomInAnimation = BaseAnimation<'zoomIn'>;

type ZoomOutYAnimation

type ZoomOutYAnimation = BaseAnimation<'zoomOut'>;

Package Files (86)

Dev Dependencies (60)

Peer Dependencies (0)

No peer dependencies.

Badge

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

You may also use Shields.io to create a custom badge linking to https://www.jsdocs.io/package/@antv/g2.

Markdown

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

HTML

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

Updated 10 days ago.
Package analyzed in 14740 ms.
Missing or incorrect documentation? Open an issue for this package.