@visactor/vchart 1.2.0-beta.6 → 1.2.0-beta.7

package/build/es5/component/axis/interface.d.ts

@@ -0,0 +1,126 @@
+import type { Datum, IPadding, IPolarOrientType, IRectMarkSpec, IRuleMarkSpec, ISymbolMarkSpec, ITextMarkSpec, StringOrNumber } from '../../typings';
+import type { ICartesianAxisSpec } from './cartesian/interface';
+import type { IComponent } from '../interface';
+import type { IBaseScale } from '@visactor/vscale';
+import type { IModelSpec } from '../../model/interface';
+import type { IAnimationSpec } from '../../animation/spec';
+import type { AxisItem, AxisItemStateStyle } from '@visactor/vrender-components';
+export interface StatisticsDomain {
+    domain: any[];
+    index: {
+        [key in StringOrNumber]: number;
+    };
+}
+export interface IAxis extends IComponent {
+    valueToPosition: (value: any) => number;
+    getScale: () => IBaseScale;
+    getScales: () => IBaseScale[];
+    orient: ICartesianAxisSpec['orient'] | IPolarOrientType;
+    visible: boolean;
+    getStatisticsDomain: () => StatisticsDomain;
+}
+export interface IAxisItem<T> {
+    visible?: boolean;
+    style?: Omit<T, 'visible'>;
+}
+export interface IAxisItemTheme<T> {
+    visible?: boolean;
+    style?: Omit<T, 'visible'>;
+}
+export type AxisAnimationPreset = 'groupFadeIn' | 'fadeIn' | 'grow';
+export interface ICommonAxisSpec extends Omit<IModelSpec, 'orient'>, IAnimationSpec<string, string> {
+    type?: AxisType;
+    visible?: boolean;
+    inverse?: boolean;
+    tick?: ITick;
+    subTick?: ISubTick;
+    regionIndex?: number | number[];
+    regionId?: StringOrNumber | StringOrNumber[];
+    seriesIndex?: number | number[];
+    seriesId?: StringOrNumber | StringOrNumber[];
+    animation?: boolean;
+    select?: boolean;
+    hover?: boolean;
+    sampling?: boolean;
+}
+export interface ILinearAxisSpec {
+    min?: number;
+    max?: number;
+    range?: {
+        min?: number;
+        max?: number;
+    };
+    nice?: boolean;
+    niceType?: 'tickCountFirst' | 'accurateFirst';
+    zero?: boolean;
+    expand?: {
+        min?: number;
+        max?: number;
+    };
+}
+export interface IBandAxisSpec {
+    bandPadding?: number | number[];
+    paddingInner?: number | number[];
+    paddingOuter?: number | number[];
+    domain?: StringOrNumber[];
+}
+export interface IGrid extends IAxisItem<IRuleMarkSpec> {
+    alternateColor?: string | string[];
+    alignWithLabel?: boolean;
+    style?: IRuleMarkSpec | StyleCallback<IRuleMarkSpec | undefined>;
+}
+export interface ITick extends IAxisItem<IRuleMarkSpec> {
+    tickSize?: number;
+    inside?: boolean;
+    alignWithLabel?: boolean;
+    tickStep?: number;
+    tickCount?: number;
+    forceTickCount?: number;
+    style?: IRuleMarkSpec | StyleCallback<IRuleMarkSpec | undefined>;
+    state?: AxisItemStateStyle<IRuleMarkSpec>;
+    dataFilter?: (data: AxisItem[]) => AxisItem[];
+}
+export interface ISubTick extends IAxisItem<IRuleMarkSpec> {
+    tickCount?: number;
+    inside?: boolean;
+    tickSize?: number;
+    state?: AxisItemStateStyle<IRuleMarkSpec>;
+}
+export interface ILabel extends IAxisItem<ITextMarkSpec> {
+    formatMethod?: (text: string | string[], datum?: Datum) => string | string[];
+    space?: number;
+    inside?: boolean;
+    minGap?: number;
+    style?: ITextMarkSpec | StyleCallback<ITextMarkSpec | undefined>;
+    state?: AxisItemStateStyle<ITextMarkSpec>;
+    dataFilter?: (data: AxisItem[], layer: number) => AxisItem[];
+}
+export interface IDomainLine extends IAxisItem<IRuleMarkSpec> {
+    state?: AxisItemStateStyle<IRuleMarkSpec>;
+}
+export interface ITitle extends IAxisItem<ITextMarkSpec> {
+    position?: 'start' | 'middle' | 'end';
+    space?: number;
+    padding?: IPadding | number | number[];
+    background?: IAxisItem<IRectMarkSpec> & {
+        state?: AxisItemStateStyle<Partial<IRectMarkSpec>>;
+    };
+    shape?: IAxisItem<ISymbolMarkSpec> & {
+        space?: number;
+        state?: AxisItemStateStyle<Partial<ISymbolMarkSpec>>;
+    };
+    text?: string | string[];
+    angle?: number;
+    state?: AxisItemStateStyle<Partial<ITextMarkSpec>>;
+}
+export type StyleCallback<T> = (value: any, index: number, datum: Datum, data: Datum[]) => T;
+export type AxisType = 'linear' | 'ordinal' | 'band' | 'point' | 'time' | 'log';
+export interface IAxisCommonTheme {
+    grid?: IGrid;
+    subGrid?: IGrid;
+    domainLine?: IDomainLine;
+    label?: ILabel;
+    title?: ITitle;
+    tick?: ITick;
+    subTick?: ISubTick;
+}

package/build/es5/component/axis/mixin/band-axis-mixin.d.ts

@@ -0,0 +1,37 @@
+import type { BandScale } from '@visactor/vscale';
+import type { StringOrNumber } from '../../../typings';
+import type { IEvent } from '../../../event/interface';
+export interface BandAxisMixin {
+    _scale: BandScale;
+    _scales: BandScale[];
+    _spec: any;
+    event: IEvent;
+    isSeriesDataEnable: () => boolean;
+    computeStatisticsDomain: () => void;
+    collectData: (depth: number) => {
+        min: number;
+        max: number;
+        values: any[];
+    }[];
+    computeDomain: (data: {
+        min: number;
+        max: number;
+        values: any[];
+    }[]) => StringOrNumber[];
+    transformScaleDomain: () => void;
+}
+export declare class BandAxisMixin {
+    valueToPosition(value: any): number;
+    updateGroupScaleRange(): void;
+    getPosition(values: any[]): {
+        position: number;
+        bandScale: BandScale;
+    };
+    calcScales(DEFAULT_BAND_INNER_PADDING: number, DEFAULT_BAND_OUTER_PADDING: number): void;
+    computeBandDomain(data: {
+        min: number;
+        max: number;
+        values: any[];
+    }[]): StringOrNumber[];
+    protected updateScaleDomain(): void;
+}

package/build/es5/component/axis/mixin/linear-axis-mixin.d.ts

@@ -0,0 +1,59 @@
+import type { LinearScale } from '@visactor/vscale';
+import type { IAxisLocationCfg } from '../cartesian/interface';
+import type { ITick } from '../interface';
+import type { IEvent } from '../../../event/interface';
+export declare const e10: number;
+export declare const e5: number;
+export declare const e2: number;
+export interface LinearAxisMixin {
+    _scale: LinearScale;
+    _scales: LinearScale[];
+    _spec: any;
+    _nice: boolean;
+    _zero: boolean;
+    _domain: {
+        min?: number;
+        max?: number;
+    };
+    _expand?: {
+        max?: number;
+        min?: number;
+    };
+    _tick: ITick | undefined;
+    isSeriesDataEnable: any;
+    computeStatisticsDomain: any;
+    computeDomain: any;
+    collectData: any;
+    event: IEvent;
+}
+export declare class LinearAxisMixin {
+    protected _extend: {
+        [key: string]: number;
+    };
+    setExtraAttrFromSpec(): void;
+    transformScaleDomain(): void;
+    setLinearScaleNice(): void;
+    setLogScaleNice(): void;
+    setScaleNice(): void;
+    dataToPosition(values: any[], cfg?: IAxisLocationCfg): number;
+    valueToPosition(value: any): number;
+    computeLinearDomain(data: {
+        min: number;
+        max: number;
+        values: any[];
+    }[]): number[];
+    protected expandDomain(domain: number[]): void;
+    protected niceDomain(domain: number[]): number[];
+    protected niceMinMax(): void;
+    protected includeZero(domain: number[]): void;
+    setExtendDomain(key: string, value: number | undefined): void;
+    protected extendDomain(domain: number[]): void;
+    getDomainSpec(): {
+        min?: number;
+        max?: number;
+    };
+    protected setDomainMinMax(domain: number[]): void;
+    setZero(zero: boolean): void;
+    protected updateScaleDomain(): void;
+    protected updateScaleDomainByModel(domain?: number[]): void;
+}

package/build/es5/component/axis/polar/axis.d.ts

@@ -0,0 +1,80 @@
+import type { IBaseScale } from '@visactor/vscale';
+import type { LayoutItem } from '../../../model/layout-item';
+import type { IPolarAxis, IPolarAxisCommonTheme } from './interface';
+import type { IComponentOption } from '../../interface';
+import { ComponentTypeEnum } from '../../interface';
+import type { IPolarSeries } from '../../../series/interface';
+import type { IPoint, IPolarOrientType, IPolarPoint, StringOrNumber } from '../../../typings';
+import type { IEffect } from '../../../model/interface';
+import { AxisComponent } from '../base-axis';
+import type { ITick } from '../interface';
+export declare abstract class PolarAxis extends AxisComponent implements IPolarAxis {
+    static type: ComponentTypeEnum;
+    type: ComponentTypeEnum;
+    name: string;
+    layoutType: LayoutItem['layoutType'];
+    layoutZIndex: number;
+    protected _tick: ITick | undefined;
+    protected _center: IPoint | null;
+    get center(): IPoint;
+    protected _startAngle: number;
+    get startAngle(): number;
+    protected _endAngle: number;
+    get endAngle(): number;
+    protected _theme: IPolarAxisCommonTheme;
+    protected _orient: IPolarOrientType;
+    get orient(): IPolarOrientType;
+    protected _groupScales: IBaseScale[];
+    getGroupScales(): IBaseScale[];
+    protected _refAngleAxis: IPolarAxis;
+    setRefAngleAxis(axes: IPolarAxis): this;
+    private _axisStyle;
+    static createAxis(spec: any, options: IComponentOption): IPolarAxis;
+    static createComponent(spec: any, options: IComponentOption): IPolarAxis | IPolarAxis[];
+    effect: IEffect;
+    setAttrFromSpec(): void;
+    setLayoutStartPosition(pos: Partial<IPoint>): void;
+    onLayoutEnd(ctx: any): void;
+    onRender(ctx: any): void;
+    changeRegions(): void;
+    protected _initData(): void;
+    protected initEvent(): void;
+    protected updateScaleRange(): void;
+    protected collectData(depth: number): {
+        min: number;
+        max: number;
+        values: any[];
+    }[];
+    protected abstract computeDomain(data: {
+        min: number;
+        max: number;
+        values: any[];
+    }[]): StringOrNumber[];
+    protected updateSeriesScale(): void;
+    protected getSeriesStatisticsField(s: IPolarSeries): string[];
+    protected initGroupScales(): void;
+    protected axisHelper(): {
+        dataToPosition: (values: any[]) => number;
+        coordToPoint: (point: IPolarPoint) => IPoint;
+        pointToCoord: (point: IPoint) => IPolarPoint;
+        center: () => IPoint;
+        getScale: (depth: number) => IBaseScale;
+        getAxisId: () => number;
+    };
+    dataToPosition(values: any[]): number;
+    positionToData(position: IPoint): any;
+    coordToPoint(point: IPolarPoint): IPoint;
+    pointToCoord(point: IPoint): IPolarPoint;
+    getCenter(): IPoint;
+    getOuterRadius(): number;
+    getInnerRadius(): number;
+    tickValues(): number[];
+    updateLayoutAttribute(): void;
+    private _layoutAngleAxis;
+    private _layoutRadiusAxis;
+    private computeLayoutOuterRadius;
+    private computeLayoutInnerRadius;
+    private getRefLayoutRect;
+    private getRefSeriesRadius;
+    private _update;
+}

package/build/es5/component/axis/polar/band-axis.d.ts

@@ -0,0 +1,31 @@
+import { BandScale } from '@visactor/vscale';
+import { ComponentTypeEnum } from '../../interface';
+import { PolarAxis } from './axis';
+import { BandAxisMixin } from '../mixin/band-axis-mixin';
+import type { StringOrNumber } from '../../../typings';
+export interface PolarBandAxis extends Pick<BandAxisMixin, 'valueToPosition' | 'updateGroupScaleRange' | 'getPosition' | 'calcScales' | 'computeBandDomain'>, PolarAxis {
+}
+export declare class PolarBandAxis extends PolarAxis {
+    static type: ComponentTypeEnum;
+    type: ComponentTypeEnum;
+    protected _scale: BandScale;
+    protected _scales: BandScale[];
+    protected computeDomain(data: {
+        min: number;
+        max: number;
+        values: any[];
+    }[]): StringOrNumber[];
+    dataToPosition(values: any[]): number;
+    protected updateScaleRange(): void;
+    protected axisHelper(): {
+        getBandwidth: (depth: number) => number;
+        dataToPosition: (values: any[]) => number;
+        coordToPoint: (point: import("../../../typings").IPolarPoint) => import("../../../typings").IPoint;
+        pointToCoord: (point: import("../../../typings").IPoint) => import("../../../typings").IPolarPoint;
+        center: () => import("../../../typings").IPoint;
+        getScale: (depth: number) => import("@visactor/vscale").IBaseScale;
+        getAxisId: () => number;
+    };
+    protected initScales(): void;
+    transformScaleDomain(): void;
+}

package/build/es5/component/axis/polar/config.d.ts

@@ -0,0 +1,2 @@
+export declare const DEFAULT_BAND_INNER_PADDING = 0;
+export declare const DEFAULT_BAND_OUTER_PADDING = 0;

package/build/es5/component/axis/polar/index.d.ts

@@ -0,0 +1,4 @@
+export * from './axis';
+export * from './linear-axis';
+export * from './band-axis';
+export * from './interface';

package/build/es5/component/axis/polar/interface/common.d.ts

@@ -0,0 +1,31 @@
+import type { IBaseScale } from '@visactor/vscale';
+import type { IComponent } from '../../../interface';
+import type { IPoint, IPolarOrientType, IPolarPoint } from '../../../../typings';
+import type { IGrid } from '../../interface';
+export type IPolarGrid = IGrid & {
+    smooth?: boolean;
+};
+export interface IPolarAxisHelper {
+    dataToPosition: (values: any, cfg?: any) => number;
+    coordToPoint: (point: IPolarPoint) => IPoint;
+    pointToCoord: (point: IPoint) => IPolarPoint;
+    center: () => IPoint;
+    getScale: (depth?: number) => IBaseScale;
+    getBandwidth?: (depth?: number) => number;
+    getAxisId: () => number;
+}
+export interface IPolarAxis extends IComponent {
+    orient: IPolarOrientType;
+    startAngle: number;
+    endAngle: number;
+    getScale: () => IBaseScale;
+    setRefAngleAxis: (axes: IPolarAxis) => this;
+    tickValues: () => number[];
+    getCenter: () => IPoint;
+    getOuterRadius: () => number;
+    getInnerRadius: () => number;
+    dataToPosition: (values: any[]) => number;
+    positionToData: (position: IPoint) => any;
+    coordToPoint: (point: IPolarPoint) => IPoint;
+    pointToCoord: (point: IPoint) => IPolarPoint;
+}

package/build/es5/component/axis/polar/interface/index.d.ts

@@ -0,0 +1,4 @@
+export * from './common';
+export * from './spec';
+export * from './theme';
+export * from '../../cartesian/interface/common';

package/build/es5/component/axis/polar/interface/spec.d.ts

@@ -0,0 +1,16 @@
+import type { IPolarOrientType } from '../../../../typings';
+import type { IBandAxisSpec, IDomainLine, ILinearAxisSpec, ITitle, ILabel, ICommonAxisSpec } from '../../interface';
+import type { IPolarGrid } from './common';
+export type IPolarAxisSpec = IPolarLinearAxisSpec | IPolarBandAxisSpec;
+export type IPolarAxisCommonSpec = ICommonAxisSpec & {
+    inside?: boolean;
+    orient: IPolarOrientType;
+    grid?: IPolarGrid;
+    radius?: number;
+    subGrid?: IPolarGrid;
+    domainLine?: IDomainLine;
+    label?: ILabel;
+    title?: ITitle;
+};
+export type IPolarLinearAxisSpec = IPolarAxisCommonSpec & ILinearAxisSpec;
+export type IPolarBandAxisSpec = IPolarAxisCommonSpec & IBandAxisSpec;

package/build/es5/component/axis/polar/interface/theme.d.ts

@@ -0,0 +1,11 @@
+import type { IDomainLine, ITick, ITitle, ILabel } from '../../interface';
+import type { IPolarGrid } from './common';
+export interface IPolarAxisCommonTheme {
+    grid?: IPolarGrid;
+    subGrid?: IPolarGrid;
+    domainLine?: IDomainLine;
+    label?: ILabel;
+    title?: ITitle;
+    tick?: ITick;
+    subTick?: ITick;
+}

package/build/es5/component/axis/polar/linear-axis.d.ts

@@ -0,0 +1,23 @@
+import { LinearScale } from '@visactor/vscale';
+import { ComponentTypeEnum } from '../../interface';
+import { PolarAxis } from './axis';
+import type { IPolarLinearAxisSpec } from './interface/spec';
+import { LinearAxisMixin } from '../mixin/linear-axis-mixin';
+export interface PolarLinearAxis extends Pick<LinearAxisMixin, 'setExtraAttrFromSpec' | 'transformScaleDomain' | 'valueToPosition' | 'computeLinearDomain' | 'setScaleNice'>, PolarAxis {
+}
+export declare class PolarLinearAxis extends PolarAxis {
+    static type: ComponentTypeEnum;
+    type: ComponentTypeEnum;
+    protected _zero: boolean;
+    protected _nice: boolean;
+    protected _scale: LinearScale;
+    protected _groupScales: LinearScale[];
+    protected _spec: IPolarLinearAxisSpec;
+    setAttrFromSpec(): void;
+    protected initScales(): void;
+    protected computeDomain(data: {
+        min: number;
+        max: number;
+        values: any[];
+    }[]): number[];
+}

package/build/es5/component/axis/utils.d.ts

@@ -0,0 +1,28 @@
+import type { ITheme } from './../../theme/interface';
+import type { IOrientType, IPolarOrientType } from '../../typings';
+import type { AxisType, ICommonAxisSpec, ILinearAxisSpec } from './interface';
+export declare const DEFAULT_TITLE_STYLE: {
+    left: {
+        textAlign: string;
+        textBaseline: string;
+    };
+    right: {
+        textAlign: string;
+        textBaseline: string;
+    };
+    radius: {};
+    angle: {};
+};
+export declare function transformAxisLineStyle(lineCfg: any): any;
+export declare function getAxisLabelOffset(axisSpec: ICommonAxisSpec): number;
+export declare function getLinearAxisSpecDomain(axisSpec: ILinearAxisSpec, defaultDomain?: {
+    min?: number;
+    max?: number;
+}): {
+    min: number;
+    max: number;
+};
+export declare function isValidCartesianAxis(spec: any): boolean;
+export declare function isValidPolarAxis(spec: any): boolean;
+export declare const getCartesianAxisTheme: (orient: IOrientType, type: AxisType, theme: ITheme) => any;
+export declare const getPolarAxisTheme: (orient: IPolarOrientType, type: AxisType, theme: ITheme) => any;

package/build/es5/component/base/base-component.d.ts

@@ -0,0 +1,34 @@
+import type { IGroup, INode } from '@visactor/vrender';
+import { BaseModel } from '../../model/base-model';
+import type { IRegion } from '../../region/interface';
+import type { IComponent, IComponentOption } from '../interface';
+import type { BaseEventParams } from '../../event/interface';
+import type { IComponentPluginService, IComponentPlugin } from '../../plugin/components/interface';
+import type { IGroupMark } from '@visactor/vgrammar';
+import type { IAnimate } from '../../animation/interface';
+export declare abstract class BaseComponent extends BaseModel implements IComponent {
+    name: string;
+    readonly modelType: string;
+    pluginService?: IComponentPluginService;
+    protected _option: IComponentOption;
+    protected _regions: IRegion[];
+    getRegions(): IRegion[];
+    protected _container: IGroup;
+    created(): void;
+    animate?: IAnimate;
+    constructor(spec: any, options: IComponentOption);
+    abstract changeRegions(regions: IRegion[]): void;
+    protected callPlugin(cb: (plugin: IComponentPlugin) => void): void;
+    protected eventPos(markEventParams: BaseEventParams): {
+        x: number;
+        y: number;
+    };
+    setCurrentTheme(theme: any, noRender?: boolean): Promise<void>;
+    protected _initTheme(theme?: any): void;
+    protected getContainer(): IGroup;
+    release(): void;
+    clear(): void;
+    compile(): void;
+    compileMarks(group?: string | IGroupMark): void;
+    protected _delegateEvent: (component: INode, event: any, type: string) => void;
+}

package/build/es5/component/base/index.d.ts

@@ -0,0 +1 @@
+export * from './base-component';

package/build/es5/component/base/util.d.ts

@@ -0,0 +1,3 @@
+import type { ITheme } from '../../theme';
+import { ComponentTypeEnum } from '../interface';
+export declare function getComponentThemeFromGlobalTheme(type: ComponentTypeEnum, theme: ITheme, componentSpec: any): any;

package/build/es5/component/brush/brush.d.ts

@@ -0,0 +1,66 @@
+import type { LayoutItem } from '../../model/layout-item';
+import { BaseComponent } from '../base';
+import type { IComponentOption } from '../interface';
+import { ComponentTypeEnum } from '../interface';
+import { Brush as BrushComponent } from '@visactor/vrender-components';
+import type { IModelRenderOption } from '../../model/interface';
+import type { IRegion } from '../../region/interface';
+import type { ISeries } from '../../series/interface';
+import type { IElement } from '@visactor/vgrammar';
+import type { BrushInteractiveRangeAttr, IBrush } from './interface';
+export declare class Brush extends BaseComponent implements IBrush {
+    layoutType: LayoutItem['layoutType'];
+    static type: ComponentTypeEnum;
+    type: ComponentTypeEnum;
+    name: string;
+    layoutZIndex: LayoutItem['layoutZIndex'];
+    static speckey: string;
+    protected _brushComponents: BrushComponent[];
+    protected _relativeRegions: IRegion[];
+    protected _linkedSeries: ISeries[];
+    private _itemMap;
+    private _linkedItemMap;
+    protected _inBrushElementsMap: {
+        [brushName: string]: {
+            [elementKey: string]: IElement;
+        };
+    };
+    protected _outOfBrushElementsMap: {
+        [elementKey: string]: IElement;
+    };
+    protected _linkedInBrushElementsMap: {
+        [brushName: string]: {
+            [elementKey: string]: IElement;
+        };
+    };
+    protected _linkedOutOfBrushElementsMap: {
+        [elementKey: string]: IElement;
+    };
+    private _needInitOutState;
+    private _isFristState;
+    private _cacheInteractiveRangeAttrs;
+    static createComponent(spec: any, options: IComponentOption): Brush[];
+    created(): void;
+    protected _extendDataInBrush(elementsMap: {
+        [brushName: string]: {
+            [elementKey: string]: IElement;
+        };
+    }): any[];
+    protected _extendDatumOutOfBrush(elementsMap: {
+        [elementKey: string]: IElement;
+    }): any[];
+    protected _getBrushInteractiveAttr(region: IRegion): BrushInteractiveRangeAttr;
+    protected _createOrUpdateBrushComponent(region: IRegion, componentIndex: number): void;
+    private _transformBrushedMarkAttr;
+    private _reconfigItem;
+    private _reconfigLinkedItem;
+    private _isBrushContainItem;
+    protected _bindRegions(): void;
+    protected _bindLinkedSeries(): void;
+    private _initNeedOperatedItem;
+    protected _initMarkBrushState(componentIndex: number, stateName: string): void;
+    protected initEvent(): void;
+    onRender(ctx: IModelRenderOption): void;
+    changeRegions(regions: IRegion[]): void;
+    onLayoutEnd(ctx: any): void;
+}

package/build/es5/component/brush/index.d.ts

@@ -0,0 +1,2 @@
+export * from './brush';
+export * from './interface';

package/build/es5/component/brush/interface.d.ts

@@ -0,0 +1,47 @@
+import type { SymbolType } from '@visactor/vrender';
+import type { IPolygonMarkSpec } from '../../typings';
+import type { IComponent } from '../interface';
+export type IBrush = IComponent;
+interface IBrushDataBindSpec {
+    regionIndex?: number | number[];
+    regionId?: string | string[];
+    seriesIndex?: number | number[];
+    seriesId?: string | string[];
+    brushLinkSeriesIndex?: number | number[];
+    brushLinkSeriesId?: string | string[];
+}
+export interface IBrushTheme {
+    style?: Partial<IPolygonMarkSpec>;
+    inBrush?: selectedItemStyle;
+    outOfBrush?: selectedItemStyle;
+    brushMode?: IBrushMode;
+    brushType?: IBrushType;
+    brushMoved?: boolean;
+    removeOnClick?: boolean;
+    delayType?: IDelayType;
+    delayTime?: number;
+    sizeThreshold?: number;
+}
+export interface IBrushSpec extends IBrushTheme, IBrushDataBindSpec {
+    visible?: boolean;
+}
+export type IBrushType = 'x' | 'y' | 'rect' | 'polygon';
+export type IBrushMode = 'single' | 'multiple';
+export type IDelayType = 'debounce' | 'throttle';
+export type selectedItemStyle = {
+    symbol?: SymbolType;
+    symbolSize?: number;
+    color?: string;
+    colorAlpha?: number;
+} & Partial<IPolygonMarkSpec>;
+export type BrushInteractiveRangeAttr = {
+    interactiveRange: {
+        minY: number;
+        maxY: number;
+        minX: number;
+        maxX: number;
+    };
+    xRange: [number, number];
+    yRange: [number, number];
+};
+export {};