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

package/build/es5/model/model-state-manager.d.ts

@@ -0,0 +1,9 @@
+import { StateManager } from '../compile/signal/state-manager';
+export declare class ModelStateManager extends StateManager {
+    _stateMap: {
+        layoutUpdateRank: number;
+        [key: string]: unknown;
+    };
+    protected _getDefaultStateMap(): Record<string, unknown>;
+    updateLayoutState(): Promise<void>;
+}

package/build/es5/model/tooltip-helper.d.ts

@@ -0,0 +1,27 @@
+import type { ITooltipActiveTypeAsKeys, ITooltipSpec } from '../component/tooltip/interface';
+import type { TooltipActiveType } from '../typings';
+import type { IModel } from './interface';
+import type { IMark } from '../mark/interface';
+export type TooltipTrigger = IModel | IMark;
+export interface ITooltipHelper {
+    spec: ITooltipSpec | undefined;
+    activeType: TooltipActiveType[];
+    activeTriggerSet: ITooltipActiveTypeAsKeys<Set<TooltipTrigger>, Set<TooltipTrigger>>;
+    ignoreTriggerSet: ITooltipActiveTypeAsKeys<Set<TooltipTrigger>, Set<TooltipTrigger>>;
+    getDefaultShapeType: () => string;
+    updateTooltipSpec: () => void;
+}
+export declare abstract class BaseTooltipHelper implements ITooltipHelper {
+    spec: ITooltipSpec | undefined;
+    activeType: TooltipActiveType[];
+    activeTriggerSet: {
+        mark: Set<TooltipTrigger>;
+        dimension: Set<TooltipTrigger>;
+    };
+    ignoreTriggerSet: {
+        mark: Set<TooltipTrigger>;
+        dimension: Set<TooltipTrigger>;
+    };
+    getDefaultShapeType(): string;
+    abstract updateTooltipSpec(): void;
+}

package/build/es5/plugin/chart/interface.d.ts

@@ -0,0 +1,6 @@
+export interface IChartPlugin {
+}
+export interface IChartPluginConstructor {
+    readonly type: 'chartPlugin';
+    new (): IChartPlugin;
+}

package/build/es5/plugin/components/axis-label-overlap-plugin.d.ts

@@ -0,0 +1,10 @@
+import { BasicComponentPlugin } from './basic-plugin';
+import type { IComponentPlugin, IComponentPluginService } from './interface';
+import type { CartesianAxis } from '../../component/axis/cartesian';
+export declare class AxisLabelOverlapPlugin extends BasicComponentPlugin implements IComponentPlugin {
+    Name: string;
+    constructor();
+    onDidLayoutVertical(service: IComponentPluginService, axis: CartesianAxis): void;
+    onDidLayoutHorizontal(service: IComponentPluginService, axis: CartesianAxis): void;
+    private _doOverlap;
+}

package/build/es5/plugin/components/axis-sync-plugin/axis-sync.d.ts

@@ -0,0 +1,11 @@
+import { BasicComponentPlugin } from '../basic-plugin';
+import type { IComponentPlugin, IComponentPluginService } from '../interface';
+import type { CartesianAxis, ILinearAxisSync } from '../../../component/axis/cartesian';
+export declare class AxisSyncPlugin extends BasicComponentPlugin implements IComponentPlugin {
+    Name: string;
+    constructor();
+    protected _checkEnableSync(axis: CartesianAxis): ILinearAxisSync | false;
+    private _getTargetAxis;
+    onInit(service: IComponentPluginService, axis: CartesianAxis): void;
+    onDidCompile(service: IComponentPluginService, axis: CartesianAxis): void;
+}

package/build/es5/plugin/components/axis-sync-plugin/index.d.ts

@@ -0,0 +1 @@
+export * from './axis-sync';

package/build/es5/plugin/components/axis-sync-plugin/tick-align-transform.d.ts

@@ -0,0 +1,7 @@
+import type { Datum } from '../../../typings';
+import type { CartesianAxis } from '../../../component';
+export interface ITickAlignOpt {
+    targetAxis: () => CartesianAxis;
+    currentAxis: () => CartesianAxis;
+}
+export declare const tickAlign: (data: Array<Datum>, op: ITickAlignOpt) => Datum[];

package/build/es5/plugin/components/axis-sync-plugin/zero-align-transform.d.ts

@@ -0,0 +1,15 @@
+import type { CartesianAxis } from '../../../component';
+import type { LinearAxisMixin } from '../../../component/axis/mixin/linear-axis-mixin';
+type ScaleInfo = {
+    total: number;
+    negative: number;
+    positive: number;
+    includeZero: boolean;
+    extendable_min: boolean;
+    extendable_max: boolean;
+    domain: number[];
+};
+export declare function isValidAlignDomain(domain: number[]): boolean;
+export declare function getScaleInfo(axis: LinearAxisMixin, domain: number[]): ScaleInfo;
+export declare const zeroAlign: (targetAxis: CartesianAxis, currentAxis: CartesianAxis) => void;
+export {};

package/build/es5/plugin/components/basic-plugin.d.ts

@@ -0,0 +1,9 @@
+import type { IComponentPlugin, IComponentPluginService } from './interface';
+export declare class BasicComponentPlugin implements IComponentPlugin {
+    readonly id: number;
+    readonly name: string;
+    protected service?: IComponentPluginService;
+    static Name: string;
+    constructor(name?: string);
+    onAdd(service: IComponentPluginService): void;
+}

package/build/es5/plugin/components/index.d.ts

@@ -0,0 +1,7 @@
+import { AxisLabelOverlapPlugin } from './axis-label-overlap-plugin';
+import { AxisSyncPlugin } from './axis-sync-plugin/';
+declare const _default: {
+    AxisLabelOverlapPlugin: typeof AxisLabelOverlapPlugin;
+    AxisSyncPlugin: typeof AxisSyncPlugin;
+};
+export default _default;

package/build/es5/plugin/components/interface.d.ts

@@ -0,0 +1,33 @@
+import type { IComponent } from '../../component/interface';
+type UniqueId = number;
+type MaybePromise<T> = T | PromiseLike<T>;
+interface IContext {
+    skipLayout: boolean;
+}
+export interface IComponentPlugin {
+    id: UniqueId;
+    name: string;
+    onAdd: (service: IComponentPluginService) => void;
+    init?: () => void;
+    dispose?: (service: IComponentPluginService) => void;
+    onInit?: (service: IComponentPluginService, ...params: any) => MaybePromise<void>;
+    onDidCompile?: (service: IComponentPluginService, ...params: any) => MaybePromise<void>;
+    onWillLayout?: (service: IComponentPluginService, ...params: any) => MaybePromise<void>;
+    onDidLayout?: (service: IComponentPluginService, ...params: any) => MaybePromise<void>;
+    onWillLayoutVertical?: (service: IComponentPluginService, context: IContext, ...params: any) => MaybePromise<void>;
+    onWillLayoutHorizontal?: (service: IComponentPluginService, context: IContext, ...params: any) => MaybePromise<void>;
+    onDidLayoutVertical?: (service: IComponentPluginService, ...params: any) => MaybePromise<void>;
+    onDidLayoutHorizontal?: (service: IComponentPluginService, ...params: any) => MaybePromise<void>;
+}
+export interface IComponentPluginService {
+    id: UniqueId;
+    component: IComponent;
+    load: (plugins: IComponentPlugin[]) => void;
+    add: (plugins: IComponentPlugin[]) => IComponentPlugin[] | null;
+    activate: (plugins: IComponentPlugin[]) => void;
+    get: (id: UniqueId) => IComponentPlugin | undefined;
+    getAll: () => IComponentPlugin[];
+    dispose: (pluginsId: UniqueId) => void;
+    disposeAll: () => void;
+}
+export {};

package/build/es5/plugin/components/plugin-service.d.ts

@@ -0,0 +1,15 @@
+import type { IComponentPlugin, IComponentPluginService } from './interface';
+import type { IComponent } from '../../component/interface';
+export declare class ComponentPluginService implements IComponentPluginService {
+    private plugins;
+    readonly id: number;
+    component: IComponent;
+    constructor(component: IComponent);
+    add(plugins: IComponentPlugin[]): IComponentPlugin[] | null;
+    load(plugins: IComponentPlugin[]): void;
+    activate(plugins: IComponentPlugin[]): void;
+    get(id: number): IComponentPlugin | undefined;
+    getAll(): IComponentPlugin[];
+    dispose(pluginsId: number): void;
+    disposeAll(): void;
+}

package/build/es5/plugin/interface.d.ts

@@ -0,0 +1,4 @@
+import type { IChartPlugin, IChartPluginConstructor } from './chart/interface';
+import type { ISeriesPlugin, ISeriesPluginConstructor } from './series/interface';
+export type IPlugin = IChartPlugin | ISeriesPlugin;
+export type IPluginConstructor = IChartPluginConstructor | ISeriesPluginConstructor;

package/build/es5/plugin/series/interface.d.ts

@@ -0,0 +1,9 @@
+import type { ISeries } from '../../series/interface';
+export interface ISeriesPlugin {
+    afterSeriesDataInit?: (series: ISeries) => void;
+    afterSeriesMarkInit?: (series: ISeries) => void;
+}
+export interface ISeriesPluginConstructor {
+    readonly type: 'seriesPlugin';
+    new (): ISeriesPlugin;
+}

package/build/es5/region/interface.d.ts

@@ -0,0 +1,53 @@
+import type { IMark } from '../mark/interface';
+import type { IModel, IModelOption, ILayoutItem, ILayoutItemSpec } from '../model/interface';
+import type { ISeries, SeriesType } from '../series/interface';
+import type { CoordinateType } from '../typings/coordinate';
+import type { IInteraction } from '../interaction/interface';
+import type { IProjectionSpec } from '../component/geo/interface';
+import type { ConvertToMarkStyleSpec, IRectMarkSpec } from '../typings/visual';
+import type { IAnimate } from '../animation/interface';
+import type { IGroupMark } from '../mark/group';
+import type { StringOrNumber } from '../typings';
+export interface IRegion extends IModel, ILayoutItem {
+    animate?: IAnimate;
+    interaction: IInteraction;
+    addSeries: (series: ISeries) => void;
+    removeSeries: (series: ISeries) => void;
+    getSeries: (opt?: ISeriesFilter) => ISeries[];
+    getSeriesInName: (name: string) => ISeries;
+    getSeriesInUserId: (userId: string) => ISeries;
+    getSeriesInId: (id: number) => ISeries;
+    getSeriesInType: (type: SeriesType) => ISeries[];
+    getSeriesInCoordinateType: (type: CoordinateType) => ISeries[];
+    getSeriesInDataName: (dataName: string) => ISeries[];
+    getMarks: () => IMark[];
+    getGroupMark: () => IGroupMark;
+}
+export type ISeriesFilter = {
+    name?: string;
+    userId?: StringOrNumber | StringOrNumber[];
+    specIndex?: number | number[];
+    id?: number;
+    type?: string;
+    coordinateType?: CoordinateType;
+    dataName?: string;
+};
+export interface IRegionConstructor {
+    new (spec: IRegionSpec, ctx: IModelOption): IRegion;
+}
+export interface IRegionSpec extends ILayoutItemSpec {
+    id?: StringOrNumber;
+    coordinate?: CoordinateType;
+    style?: ConvertToMarkStyleSpec<IRectMarkSpec>;
+}
+export interface IGeoRegionSpec extends IRegionSpec {
+    coordinate?: 'geo';
+    roam?: boolean;
+    longitudeField?: string;
+    latitudeField?: string;
+    projection?: Partial<Omit<IProjectionSpec, 'name'>>;
+    zoomLimit?: {
+        min?: number;
+        max?: number;
+    };
+}

package/build/es5/region/region.d.ts

@@ -0,0 +1,70 @@
+import type { IElement, IGroupMark as IVGrammarGroupMark } from '@visactor/vgrammar';
+import { BaseModel } from '../model/base-model';
+import type { ISeries } from '../series/interface';
+import type { IModelOption, ILayoutItem } from '../model/interface';
+import type { CoordinateType } from '../typings/coordinate';
+import type { IRegion, IRegionSpec } from './interface';
+import type { IGroupMark } from '../mark/group';
+import type { IInteraction, ITrigger } from '../interaction/interface';
+import type { IRectMark } from '../mark/rect';
+import type { IAnimate } from '../animation/interface';
+import type { StringOrNumber } from '../typings';
+export declare class Region extends BaseModel implements IRegion {
+    static type: string;
+    readonly modelType: string;
+    type: string;
+    protected _series: ISeries[];
+    layoutType: ILayoutItem['layoutType'];
+    layoutZIndex: number;
+    animate?: IAnimate;
+    interaction: IInteraction;
+    protected _groupMark: IGroupMark;
+    getGroupMark(): IGroupMark;
+    protected _backgroundMark?: IRectMark;
+    protected _foregroundMark?: IRectMark;
+    protected _trigger: ITrigger;
+    protected _spec: IRegionSpec;
+    constructor(spec: IRegionSpec, ctx: IModelOption);
+    protected _getClipDefaultValue(): boolean;
+    created(): void;
+    init(option: any): void;
+    initMark(): void;
+    protected _initBackgroundMarkStyle(): void;
+    protected _initForegroundMarkStyle(): void;
+    updateSpec(spec: any): {
+        change: boolean;
+        reMake: boolean;
+        reRender: boolean;
+        reSize: boolean;
+        reCompile: boolean;
+    };
+    reInit(theme?: any): void;
+    addSeries(s: ISeries): void;
+    removeSeries(s: ISeries): void;
+    getSeries(opt?: {
+        name?: string;
+        userId?: StringOrNumber | StringOrNumber[];
+        specIndex?: number | number[];
+        id?: StringOrNumber;
+        type?: string;
+        coordinateType?: CoordinateType;
+        dataName?: string;
+    }): ISeries[];
+    getSeriesInName(name: string): ISeries;
+    getSeriesInUserId(userId: string): ISeries;
+    getSeriesInId(id: number): ISeries;
+    getSeriesInType(type: string): ISeries[];
+    getSeriesInCoordinateType(coordinateType: CoordinateType): ISeries[];
+    getSeriesInDataName(dataName: string): ISeries[];
+    onRender(ctx: any): void;
+    initSeriesDataflow(): void;
+    seriesDataFilterOver: () => void;
+    release(): void;
+    createTrigger(): void;
+    initTrigger(): void;
+    initInteraction(): void;
+    compileMarks(group?: string | IVGrammarGroupMark): void;
+    compileSignal(): void;
+    compile(): void;
+    bindSceneNode(node: IElement): void;
+}

package/build/es5/scale/color-ordinal-scale.d.ts

@@ -0,0 +1,8 @@
+import { OrdinalScale } from '@visactor/vscale';
+import type { ColorSchemeItem, ProgressiveDataScheme } from '../theme/color-scheme/interface';
+export declare class ColorOrdinalScale extends OrdinalScale {
+    protected _range: Array<ColorSchemeItem> | ProgressiveDataScheme<ColorSchemeItem>;
+    range(value?: Array<ColorSchemeItem> | ProgressiveDataScheme<ColorSchemeItem>): this | any;
+    domain(value?: any[]): this | any;
+    protected _resetRange(): void;
+}

package/build/es5/scale/global-scale.d.ts

@@ -0,0 +1,37 @@
+import type { DataView } from '@visactor/vdataset';
+import type { IGlobalScale } from './interface';
+import type { IBaseScale } from '@visactor/vscale';
+import type { IChart } from '../chart/interface';
+import type { IChartSpec } from '../typings/spec';
+import type { IVisualScale, IVisualSpecScale } from '../typings';
+import type { StatisticOperations } from '../data/transforms/dimension-statistics';
+export declare class GlobalScale implements IGlobalScale {
+    private _scaleSpecMap;
+    private _scaleMap;
+    private _modelScaleSpecMap;
+    private _markAttributeScaleMap;
+    private _spec;
+    private readonly _chart;
+    constructor(spec: IChartSpec['scales'], chart: IChart);
+    private _createFromSpec;
+    private _setAttrFromSpec;
+    updateSpec(spec: IChartSpec['scales']): {
+        change: boolean;
+        reMake: boolean;
+        reRender: boolean;
+        reSize: boolean;
+        reCompile: boolean;
+    };
+    registerModelScale(spec: IVisualSpecScale<unknown, unknown>): void;
+    removeModelScale(filter: (spec: IVisualSpecScale<unknown, unknown>) => boolean): void;
+    getScale(user_id: string): IBaseScale | null;
+    getScaleSpec(user_id: string): IVisualSpecScale<unknown, unknown> | null;
+    getStatisticalFields: (dataId: string) => {
+        key: string;
+        operations: StatisticOperations;
+    }[];
+    private _getStatistics;
+    updateScaleDomain(defaultDomain: unknown[]): void;
+    private _updateMarkScale;
+    registerMarkAttributeScale(spec: IVisualScale, dataStatistics: DataView): IBaseScale;
+}

package/build/es5/scale/interface.d.ts

@@ -0,0 +1,19 @@
+import type { DataView } from '@visactor/vdataset';
+import type { IBaseScale } from '@visactor/vscale';
+import type { StatisticOperations } from '../data/transforms/dimension-statistics';
+import type { IChartSpec, IVisualScale, IVisualSpecScale } from '../typings';
+import type { IUpdateSpecResult } from '../model/interface';
+export interface IGlobalScale {
+    color?: any;
+    getScale: (user_id: string) => IBaseScale | null;
+    getScaleSpec: (user_id: string) => IVisualSpecScale<unknown, unknown> | null;
+    getStatisticalFields: (dataId: string) => {
+        key: string;
+        operations: StatisticOperations;
+    }[];
+    updateScaleDomain: (string: unknown[]) => void;
+    registerMarkAttributeScale: (spec: IVisualScale, dataStatistics: DataView) => IBaseScale;
+    registerModelScale: (spec: IVisualSpecScale<unknown, unknown>) => void;
+    removeModelScale: (filter: (spec: IVisualSpecScale<unknown, unknown>) => boolean) => void;
+    updateSpec: (spec: IChartSpec['scales']) => IUpdateSpecResult;
+}

package/build/es5/series/area/animation.d.ts

@@ -0,0 +1,7 @@
+import type { DirectionType } from '../../typings';
+import type { IAnimationTypeConfig } from '@visactor/vgrammar';
+export interface IAreaAnimationParams {
+    direction: DirectionType;
+}
+export type AreaAppearPreset = 'clipIn' | 'fadeIn' | 'grow';
+export declare function areaPresetAnimation(params: IAreaAnimationParams, preset: AreaAppearPreset | boolean): IAnimationTypeConfig;

package/build/es5/series/area/area.d.ts

@@ -0,0 +1,21 @@
+import { LineLikeSeriesMixin } from '../mixin/line-mixin';
+import type { IAreaMark } from '../../mark/area';
+import { CartesianSeries } from '../cartesian/cartesian';
+import type { Maybe, IInvalidType } from '../../typings';
+import type { SeriesMarkMap } from '../interface';
+import { SeriesTypeEnum } from '../interface';
+import type { IAreaSeriesSpec, IAreaSeriesTheme } from './interface';
+export interface AreaSeries extends Pick<LineLikeSeriesMixin, 'initLineMark' | 'initSymbolMark' | 'initLabelMarkStyle' | 'initLineMarkStyle' | 'initSymbolMarkStyle' | '_lineMark' | '_symbolMark'>, CartesianSeries<IAreaSeriesSpec> {
+}
+export declare class AreaSeries extends CartesianSeries<IAreaSeriesSpec> {
+    static readonly type: string;
+    type: SeriesTypeEnum;
+    static readonly mark: SeriesMarkMap;
+    protected _theme: Maybe<IAreaSeriesTheme>;
+    protected _areaMark: IAreaMark;
+    protected _stack: boolean;
+    protected _invalidType: IInvalidType;
+    initMark(): void;
+    initMarkStyle(): void;
+    initAnimation(): void;
+}

package/build/es5/series/area/interface.d.ts

@@ -0,0 +1,18 @@
+import type { ICartesianSeriesSpec, ICartesianSeriesTheme } from '../cartesian/interface';
+import type { IMarkSpec, IMarkTheme } from '../../typings/spec/common';
+import type { ISymbolMarkSpec, ILineMarkSpec, IAreaMarkSpec } from '../../typings/visual';
+import type { SeriesMarkNameEnum } from '../interface';
+import type { ILineLikeSeriesTheme } from '../mixin/line-mixin';
+import type { IAnimationSpec } from '../../animation/spec';
+import type { AreaAppearPreset } from './animation';
+import type { IMarkProgressiveConfig } from '../../mark/interface';
+export interface IAreaSeriesSpec extends ICartesianSeriesSpec, IAnimationSpec<string, AreaAppearPreset>, IMarkProgressiveConfig {
+    type: 'area';
+    [SeriesMarkNameEnum.point]?: IMarkSpec<ISymbolMarkSpec>;
+    [SeriesMarkNameEnum.line]?: IMarkSpec<ILineMarkSpec>;
+    [SeriesMarkNameEnum.area]?: IMarkSpec<IAreaMarkSpec>;
+    seriesMark?: 'point' | 'line' | 'area';
+}
+export interface IAreaSeriesTheme extends ICartesianSeriesTheme, ILineLikeSeriesTheme {
+    [SeriesMarkNameEnum.area]?: Partial<IMarkTheme<IAreaMarkSpec>>;
+}

package/build/es5/series/bar/animation.d.ts

@@ -0,0 +1,12 @@
+import type { DirectionType } from '../../typings';
+import type { IAnimationTypeConfig } from '@visactor/vgrammar';
+export interface IBarAnimationParams {
+    xField: string;
+    yField: string;
+    direction: DirectionType;
+    growFrom: () => number;
+}
+export type BarAppearPreset = 'grow' | 'fadeIn' | 'scaleIn';
+export declare const barGrowIn: (params: IBarAnimationParams, isOverall?: boolean) => IAnimationTypeConfig;
+export declare const barGrowOut: (params: IBarAnimationParams, isOverall?: boolean) => IAnimationTypeConfig;
+export declare function barPresetAnimation(params: IBarAnimationParams, preset: BarAppearPreset | boolean): IAnimationTypeConfig;

package/build/es5/series/bar/bar-3d.d.ts

@@ -0,0 +1,11 @@
+import { MarkTypeEnum } from '../../mark/interface';
+import type { SeriesMarkMap } from '../interface';
+import { SeriesTypeEnum, SeriesMarkNameEnum } from '../interface';
+import { BarSeries } from './bar';
+export declare class Bar3dSeries extends BarSeries {
+    static readonly type: string;
+    type: SeriesTypeEnum;
+    static readonly mark: SeriesMarkMap;
+    protected _barMarkName: SeriesMarkNameEnum;
+    protected _barMarkType: MarkTypeEnum;
+}

package/build/es5/series/bar/bar.d.ts

@@ -0,0 +1,40 @@
+import { CartesianSeries } from '../cartesian/cartesian';
+import { MarkTypeEnum } from '../../mark/interface';
+import type { Maybe, Datum, DirectionType } from '../../typings';
+import type { IBarSeriesSpec, IBarSeriesTheme } from './interface';
+import type { IAxisHelper } from '../../component/axis/cartesian/interface';
+import type { IRectMark } from '../../mark/rect';
+import type { IModelInitOption } from '../../model/interface';
+import type { ITextMark } from '../../mark/text';
+import type { SeriesMarkMap } from '../interface';
+import { SeriesMarkNameEnum } from '../interface';
+import { SeriesTypeEnum } from '../interface';
+export declare const DefaultBandWidth = 6;
+export declare class BarSeries<T extends IBarSeriesSpec = IBarSeriesSpec> extends CartesianSeries<T> {
+    static readonly type: string;
+    type: SeriesTypeEnum;
+    protected _barMarkName: SeriesMarkNameEnum;
+    protected _barMarkType: MarkTypeEnum;
+    static readonly mark: SeriesMarkMap;
+    protected _theme: Maybe<IBarSeriesTheme>;
+    protected _stack: boolean;
+    protected _bandPosition: number;
+    protected _rectMark: IRectMark;
+    initMark(): void;
+    initMarkStyle(): void;
+    initLabelMarkStyle(textMark: ITextMark): void;
+    init(option: IModelInitOption): void;
+    initBandRectMarkStyle(): void;
+    initLinearRectMarkStyle(): void;
+    initAnimation(): void;
+    protected _getBarWidth(axisHelper: IAxisHelper): number;
+    protected _getPosition(direction: DirectionType, datum: Datum): number;
+    updateSpec(spec: IBarSeriesSpec): {
+        change: boolean;
+        reMake: boolean;
+        reRender: boolean;
+        reSize: boolean;
+        reCompile: boolean;
+    };
+    getDefaultShapeType(): string;
+}

package/build/es5/series/bar/interface.d.ts

@@ -0,0 +1,34 @@
+import type { ICartesianSeriesSpec, ICartesianSeriesTheme } from '../cartesian/interface';
+import type { IMarkSpec, IMarkTheme } from '../../typings/spec/common';
+import type { IRect3dMarkSpec, IRectMarkSpec } from '../../typings/visual';
+import type { IAnimationSpec } from '../../animation/spec';
+import type { BarAppearPreset } from './animation';
+import type { ILabelSpec } from '../../component/label';
+import type { IMarkProgressiveConfig } from '../../mark/interface';
+import type { SeriesMarkNameEnum } from '../interface';
+import type { MaybeArray } from '../../typings';
+type BarMarks = 'bar';
+export interface IBarSeriesSpec extends ICartesianSeriesSpec, IAnimationSpec<BarMarks, BarAppearPreset>, IMarkProgressiveConfig {
+    type: 'bar';
+    [SeriesMarkNameEnum.bar]?: IMarkSpec<IRectMarkSpec>;
+    [SeriesMarkNameEnum.label]?: ILabelSpec & {
+        position?: 'outside' | 'top' | 'bottom' | 'left' | 'right' | 'inside' | 'inside-top' | 'inside-bottom' | 'inside-right' | 'inside-left';
+    };
+    barWidth?: number | string;
+    barMinWidth?: number | string;
+    barMaxWidth?: number | string;
+    barGapInGroup?: MaybeArray<number | string>;
+}
+export interface IBarSeriesTheme extends ICartesianSeriesTheme {
+    [SeriesMarkNameEnum.bar]?: Partial<IMarkTheme<IRectMarkSpec>>;
+    barWidth?: number;
+    barMinWidth?: number;
+    barMaxWidth?: number;
+}
+export type IBar3dSeriesSpec = {
+    type: 'bar3d';
+} & Omit<IBarSeriesSpec, 'type'> & ICartesianSeriesSpec & IAnimationSpec<BarMarks, BarAppearPreset>;
+export interface IBar3dSeriesTheme extends ICartesianSeriesTheme {
+    [SeriesMarkNameEnum.bar3d]?: Partial<IMarkTheme<IRect3dMarkSpec>>;
+}
+export {};