import { Props, VNodeChild } from "@pyreon/core";
import { BarSeriesOption, BoxplotSeriesOption, CandlestickSeriesOption, ComposeOption, DataZoomComponentOption, EChartsOption, EChartsOption as EChartsOption$1, FunnelSeriesOption, GaugeSeriesOption, GraphSeriesOption, GridComponentOption, HeatmapSeriesOption, LegendComponentOption, LineSeriesOption, PieSeriesOption, RadarSeriesOption, SankeySeriesOption, ScatterSeriesOption, SetOptionOpts, SunburstSeriesOption, TitleComponentOption, ToolboxComponentOption, TooltipComponentOption, TreeSeriesOption, TreemapSeriesOption, VisualMapComponentOption } from "echarts";
import { Signal } from "@pyreon/reactivity";

//#region ../../node_modules/.bun/echarts@6.0.0/node_modules/echarts/types/dist/shared.d.ts
interface GradientObject {
  id?: number;
  type: string;
  colorStops: GradientColorStop[];
  global?: boolean;
}
interface GradientColorStop {
  offset: number;
  color: string;
}
interface RadialGradientObject extends GradientObject {
  type: 'radial';
  x: number;
  y: number;
  r: number;
}
interface LinearGradientObject extends GradientObject {
  type: 'linear';
  x: number;
  y: number;
  x2: number;
  y2: number;
}
declare type Dictionary<T> = {
  [key: string]: T;
};
declare type NullUndefined = null | undefined;
declare type ImageLike = HTMLImageElement | HTMLCanvasElement | HTMLVideoElement;
declare type TextVerticalAlign = 'top' | 'middle' | 'bottom';
declare type TextAlign = 'left' | 'center' | 'right';
declare type FontWeight = 'normal' | 'bold' | 'bolder' | 'lighter' | number;
declare type FontStyle = 'normal' | 'italic' | 'oblique';
declare type BuiltinTextPosition = 'left' | 'right' | 'top' | 'bottom' | 'inside' | 'insideLeft' | 'insideRight' | 'insideTop' | 'insideBottom' | 'insideTopLeft' | 'insideTopRight' | 'insideBottomLeft' | 'insideBottomRight';
declare type ZREventProperties = {
  zrX: number;
  zrY: number;
  zrDelta: number;
  zrEventControl: 'no_globalout' | 'only_globalout';
  zrByTouch: boolean;
};
declare type ZRRawMouseEvent = MouseEvent & ZREventProperties;
declare type ZRRawTouchEvent = TouchEvent & ZREventProperties;
declare type ZRRawPointerEvent = TouchEvent & ZREventProperties;
declare type ZRRawEvent = ZRRawMouseEvent | ZRRawTouchEvent | ZRRawPointerEvent;
declare type ElementEventName = 'click' | 'dblclick' | 'mousewheel' | 'mouseout' | 'mouseover' | 'mouseup' | 'mousedown' | 'mousemove' | 'contextmenu' | 'drag' | 'dragstart' | 'dragend' | 'dragenter' | 'dragleave' | 'dragover' | 'drop' | 'globalout';
declare type PropType<TObj, TProp extends keyof TObj> = TObj[TProp];
declare type MapToType<T extends Dictionary<any>, S> = { [P in keyof T]: T[P] extends Dictionary<any> ? MapToType<T[P], S> : S };
declare type WithThisType<Func extends (...args: any) => any, This> = (this: This, ...args: Parameters<Func>) => ReturnType<Func>;
declare type SVGVNodeAttrs = Record<string, string | number | undefined | boolean>;
interface SVGVNode {
  tag: string;
  attrs: SVGVNodeAttrs;
  children?: SVGVNode[];
  text?: string;
  elm?: Node;
  key: string;
}
declare type ImagePatternRepeat = 'repeat' | 'repeat-x' | 'repeat-y' | 'no-repeat';
interface PatternObjectBase {
  id?: number;
  type?: 'pattern';
  x?: number;
  y?: number;
  rotation?: number;
  scaleX?: number;
  scaleY?: number;
}
interface ImagePatternObject extends PatternObjectBase {
  image: ImageLike | string;
  repeat?: ImagePatternRepeat;
  imageWidth?: number;
  imageHeight?: number;
}
interface SVGPatternObject extends PatternObjectBase {
  svgElement?: SVGVNode;
  svgWidth?: number;
  svgHeight?: number;
}
declare type PatternObject = ImagePatternObject | SVGPatternObject;
declare type EventCallbackSingleParam<EvtParam = any> = EvtParam extends any ? (params: EvtParam) => boolean | void : never;
declare type EventCallback<EvtParams = any[]> = EvtParams extends any[] ? (...args: EvtParams) => boolean | void : never;
declare type EventQuery = string | Object;
declare type CbThis<Ctx, Impl> = unknown extends Ctx ? Impl : Ctx;
declare type DefaultEventDefinition = Dictionary<EventCallback<any[]>>;
interface EventProcessor<EvtDef = DefaultEventDefinition> {
  normalizeQuery?: (query: EventQuery) => EventQuery;
  filter?: (eventType: keyof EvtDef, query: EventQuery) => boolean;
  afterTrigger?: (eventType: keyof EvtDef) => void;
}
declare class Eventful<EvtDef extends DefaultEventDefinition = DefaultEventDefinition> {
  private _$handlers;
  protected _$eventProcessor: EventProcessor<EvtDef>;
  constructor(eventProcessors?: EventProcessor<EvtDef>);
  on<Ctx, EvtNm extends keyof EvtDef>(event: EvtNm, handler: WithThisType<EvtDef[EvtNm], CbThis<Ctx, this>>, context?: Ctx): this;
  on<Ctx, EvtNm extends keyof EvtDef>(event: EvtNm, query: EventQuery, handler: WithThisType<EvtDef[EvtNm], CbThis<Ctx, this>>, context?: Ctx): this;
  isSilent(eventName: keyof EvtDef): boolean;
  off(eventType?: keyof EvtDef, handler?: Function): this;
  trigger<EvtNm extends keyof EvtDef>(eventType: EvtNm, ...args: Parameters<EvtDef[EvtNm]>): this;
  triggerWithContext(type: keyof EvtDef, ...args: any[]): this;
}
declare type VectorArray = number[];
declare type MatrixArray = number[];
interface PointLike {
  x: number;
  y: number;
}
declare class Point {
  x: number;
  y: number;
  constructor(x?: number, y?: number);
  copy(other: PointLike): this;
  clone(): Point;
  set(x: number, y: number): this;
  equal(other: PointLike): boolean;
  add(other: PointLike): this;
  scale(scalar: number): void;
  scaleAndAdd(other: PointLike, scalar: number): void;
  sub(other: PointLike): this;
  dot(other: PointLike): number;
  len(): number;
  lenSquare(): number;
  normalize(): this;
  distance(other: PointLike): number;
  distanceSquare(other: Point): number;
  negate(): this;
  transform(m: MatrixArray): this;
  toArray(out: number[]): number[];
  fromArray(input: number[]): void;
  static set(p: PointLike, x: number, y: number): void;
  static copy(p: PointLike, p2: PointLike): void;
  static len(p: PointLike): number;
  static lenSquare(p: PointLike): number;
  static dot(p0: PointLike, p1: PointLike): number;
  static add(out: PointLike, p0: PointLike, p1: PointLike): void;
  static sub(out: PointLike, p0: PointLike, p1: PointLike): void;
  static scale(out: PointLike, p0: PointLike, scalar: number): void;
  static scaleAndAdd(out: PointLike, p0: PointLike, p1: PointLike, scalar: number): void;
  static lerp(out: PointLike, p0: PointLike, p1: PointLike, t: number): void;
}
declare class BoundingRect {
  x: number;
  y: number;
  width: number;
  height: number;
  constructor(x: number, y: number, width: number, height: number);
  static set<TTarget extends RectLike>(target: TTarget, x: number, y: number, width: number, height: number): TTarget;
  union(other: BoundingRect): void;
  applyTransform(m: MatrixArray): void;
  calculateTransform(b: RectLike): MatrixArray;
  intersect(b: RectLike, mtv?: PointLike, opt?: BoundingRectIntersectOpt): boolean;
  static intersect(a: RectLike, b: RectLike, mtv?: PointLike, opt?: BoundingRectIntersectOpt): boolean;
  static contain(rect: RectLike, x: number, y: number): boolean;
  contain(x: number, y: number): boolean;
  clone(): BoundingRect;
  copy(other: RectLike): void;
  plain(): RectLike;
  isFinite(): boolean;
  isZero(): boolean;
  static create(rect: RectLike): BoundingRect;
  static copy<TTarget extends RectLike>(target: TTarget, source: RectLike): TTarget;
  static applyTransform(target: RectLike, source: RectLike, m: MatrixArray): void;
}
declare type RectLike = {
  x: number;
  y: number;
  width: number;
  height: number;
};
interface BoundingRectIntersectOpt {
  direction?: number;
  bidirectional?: boolean;
  touchThreshold?: number;
  outIntersectRect?: RectLike;
  clamp?: boolean;
}
interface ExtendedCanvasRenderingContext2D extends CanvasRenderingContext2D {
  dpr?: number;
}
declare class PathProxy {
  dpr: number;
  data: number[] | Float32Array;
  private _version;
  private _saveData;
  private _pendingPtX;
  private _pendingPtY;
  private _pendingPtDist;
  private _ctx;
  private _xi;
  private _yi;
  private _x0;
  private _y0;
  private _len;
  private _pathSegLen;
  private _pathLen;
  private _ux;
  private _uy;
  static CMD: {
    M: number;
    L: number;
    C: number;
    Q: number;
    A: number;
    Z: number;
    R: number;
  };
  constructor(notSaveData?: boolean);
  increaseVersion(): void;
  getVersion(): number;
  setScale(sx: number, sy: number, segmentIgnoreThreshold?: number): void;
  setDPR(dpr: number): void;
  setContext(ctx: ExtendedCanvasRenderingContext2D): void;
  getContext(): ExtendedCanvasRenderingContext2D;
  beginPath(): this;
  reset(): void;
  moveTo(x: number, y: number): this;
  lineTo(x: number, y: number): this;
  bezierCurveTo(x1: number, y1: number, x2: number, y2: number, x3: number, y3: number): this;
  quadraticCurveTo(x1: number, y1: number, x2: number, y2: number): this;
  arc(cx: number, cy: number, r: number, startAngle: number, endAngle: number, anticlockwise?: boolean): this;
  arcTo(x1: number, y1: number, x2: number, y2: number, radius: number): this;
  rect(x: number, y: number, w: number, h: number): this;
  closePath(): this;
  fill(ctx: CanvasRenderingContext2D): void;
  stroke(ctx: CanvasRenderingContext2D): void;
  len(): number;
  setData(data: Float32Array | number[]): void;
  appendPath(path: PathProxy | PathProxy[]): void;
  addData(cmd: number, a?: number, b?: number, c?: number, d?: number, e?: number, f?: number, g?: number, h?: number): void;
  private _drawPendingPt;
  private _expandData;
  toStatic(): void;
  getBoundingRect(): BoundingRect;
  private _calculateLength;
  rebuildPath(ctx: PathRebuilder, percent: number): void;
  clone(): PathProxy;
  canSave(): boolean;
  private static initDefaultProps;
}
interface PathRebuilder {
  moveTo(x: number, y: number): void;
  lineTo(x: number, y: number): void;
  bezierCurveTo(x: number, y: number, x2: number, y2: number, x3: number, y3: number): void;
  quadraticCurveTo(x: number, y: number, x2: number, y2: number): void;
  arc(cx: number, cy: number, r: number, startAngle: number, endAngle: number, anticlockwise: boolean): void;
  ellipse(cx: number, cy: number, radiusX: number, radiusY: number, rotation: number, startAngle: number, endAngle: number, anticlockwise: boolean): void;
  rect(x: number, y: number, width: number, height: number): void;
  closePath(): void;
}
declare type easingFunc = (percent: number) => number;
declare type AnimationEasing = keyof typeof easingFuncs | easingFunc;
declare const easingFuncs: {
  linear(k: number): number;
  quadraticIn(k: number): number;
  quadraticOut(k: number): number;
  quadraticInOut(k: number): number;
  cubicIn(k: number): number;
  cubicOut(k: number): number;
  cubicInOut(k: number): number;
  quarticIn(k: number): number;
  quarticOut(k: number): number;
  quarticInOut(k: number): number;
  quinticIn(k: number): number;
  quinticOut(k: number): number;
  quinticInOut(k: number): number;
  sinusoidalIn(k: number): number;
  sinusoidalOut(k: number): number;
  sinusoidalInOut(k: number): number;
  exponentialIn(k: number): number;
  exponentialOut(k: number): number;
  exponentialInOut(k: number): number;
  circularIn(k: number): number;
  circularOut(k: number): number;
  circularInOut(k: number): number;
  elasticIn(k: number): number;
  elasticOut(k: number): number;
  elasticInOut(k: number): number;
  backIn(k: number): number;
  backOut(k: number): number;
  backInOut(k: number): number;
  bounceIn(k: number): number;
  bounceOut(k: number): number;
  bounceInOut(k: number): number;
};
interface Stage {
  update?: () => void;
}
interface AnimationOption {
  stage?: Stage;
}
declare class Animation extends Eventful {
  stage: Stage;
  private _head;
  private _tail;
  private _running;
  private _time;
  private _pausedTime;
  private _pauseStart;
  private _paused;
  constructor(opts?: AnimationOption);
  addClip(clip: Clip): void;
  addAnimator(animator: Animator<any>): void;
  removeClip(clip: Clip): void;
  removeAnimator(animator: Animator<any>): void;
  update(notTriggerFrameAndStageUpdate?: boolean): void;
  _startLoop(): void;
  start(): void;
  stop(): void;
  pause(): void;
  resume(): void;
  clear(): void;
  isFinished(): boolean;
  animate<T>(target: T, options: {
    loop?: boolean;
  }): Animator<T>;
}
declare type OnframeCallback = (percent: number) => void;
declare type ondestroyCallback = () => void;
declare type onrestartCallback = () => void;
interface ClipProps {
  life?: number;
  delay?: number;
  loop?: boolean;
  easing?: AnimationEasing;
  onframe?: OnframeCallback;
  ondestroy?: ondestroyCallback;
  onrestart?: onrestartCallback;
}
declare class Clip {
  private _life;
  private _delay;
  private _inited;
  private _startTime;
  private _pausedTime;
  private _paused;
  animation: Animation;
  loop: boolean;
  easing: AnimationEasing;
  easingFunc: (p: number) => number;
  next: Clip;
  prev: Clip;
  onframe: OnframeCallback;
  ondestroy: ondestroyCallback;
  onrestart: onrestartCallback;
  constructor(opts: ClipProps);
  step(globalTime: number, deltaTime: number): boolean;
  pause(): void;
  resume(): void;
  setEasing(easing: AnimationEasing): void;
}
declare type ValueType = 0 | 1 | 2 | 3 | 4 | 5 | 6;
declare type Keyframe = {
  time: number;
  value: unknown;
  percent: number;
  rawValue: unknown;
  easing?: AnimationEasing;
  easingFunc?: (percent: number) => number;
  additiveValue?: unknown;
};
declare class Track {
  keyframes: Keyframe[];
  propName: string;
  valType: ValueType;
  discrete: boolean;
  _invalid: boolean;
  private _finished;
  private _needsSort;
  private _additiveTrack;
  private _additiveValue;
  private _lastFr;
  private _lastFrP;
  constructor(propName: string);
  isFinished(): boolean;
  setFinished(): void;
  needsAnimate(): boolean;
  getAdditiveTrack(): Track;
  addKeyframe(time: number, rawValue: unknown, easing?: AnimationEasing): Keyframe;
  prepare(maxTime: number, additiveTrack?: Track): void;
  step(target: any, percent: number): void;
  private _addToTarget;
}
declare type DoneCallback = () => void;
declare type AbortCallback = () => void;
declare type OnframeCallback$1<T> = (target: T, percent: number) => void;
declare class Animator<T> {
  animation?: Animation;
  targetName?: string;
  scope?: string;
  __fromStateTransition?: string;
  private _tracks;
  private _trackKeys;
  private _target;
  private _loop;
  private _delay;
  private _maxTime;
  private _force;
  private _paused;
  private _started;
  private _allowDiscrete;
  private _additiveAnimators;
  private _doneCbs;
  private _onframeCbs;
  private _abortedCbs;
  private _clip;
  constructor(target: T, loop: boolean, allowDiscreteAnimation?: boolean, additiveTo?: Animator<any>[]);
  getMaxTime(): number;
  getDelay(): number;
  getLoop(): boolean;
  getTarget(): T;
  changeTarget(target: T): void;
  when(time: number, props: Dictionary<any>, easing?: AnimationEasing): this;
  whenWithKeys(time: number, props: Dictionary<any>, propNames: string[], easing?: AnimationEasing): this;
  pause(): void;
  resume(): void;
  isPaused(): boolean;
  duration(duration: number): this;
  private _doneCallback;
  private _abortedCallback;
  private _setTracksFinished;
  private _getAdditiveTrack;
  start(easing?: AnimationEasing): this;
  stop(forwardToLast?: boolean): void;
  delay(time: number): this;
  during(cb: OnframeCallback$1<T>): this;
  done(cb: DoneCallback): this;
  aborted(cb: AbortCallback): this;
  getClip(): Clip;
  getTrack(propName: string): Track;
  getTracks(): Track[];
  stopTracks(propNames: string[], forwardToLast?: boolean): boolean;
  saveTo(target: T, trackKeys?: readonly string[], firstOrLast?: boolean): void;
  __changeFinalValue(finalProps: Dictionary<any>, trackKeys?: readonly string[]): void;
}
interface PathStyleProps extends CommonStyleProps {
  fill?: string | PatternObject | LinearGradientObject | RadialGradientObject;
  stroke?: string | PatternObject | LinearGradientObject | RadialGradientObject;
  decal?: PatternObject;
  strokePercent?: number;
  strokeNoScale?: boolean;
  fillOpacity?: number;
  strokeOpacity?: number;
  lineDash?: false | number[] | 'solid' | 'dashed' | 'dotted';
  lineDashOffset?: number;
  lineWidth?: number;
  lineCap?: CanvasLineCap;
  lineJoin?: CanvasLineJoin;
  miterLimit?: number;
  strokeFirst?: boolean;
}
interface PathProps extends DisplayableProps {
  strokeContainThreshold?: number;
  segmentIgnoreThreshold?: number;
  subPixelOptimize?: boolean;
  style?: PathStyleProps;
  shape?: Dictionary<any>;
  autoBatch?: boolean;
  __value?: (string | number)[] | (string | number);
  buildPath?: (ctx: PathProxy | CanvasRenderingContext2D, shapeCfg: Dictionary<any>, inBatch?: boolean) => void;
}
declare type PathKey = keyof PathProps;
declare type PathPropertyType = PropType<PathProps, PathKey>;
declare type PathStatePropNames = DisplayableStatePropNames | 'shape';
declare type PathState = Pick<PathProps, PathStatePropNames> & {
  hoverLayer?: boolean;
};
interface Path<Props extends PathProps = PathProps> {
  animate(key?: '', loop?: boolean): Animator<this>;
  animate(key: 'style', loop?: boolean): Animator<this['style']>;
  animate(key: 'shape', loop?: boolean): Animator<this['shape']>;
  getState(stateName: string): PathState;
  ensureState(stateName: string): PathState;
  states: Dictionary<PathState>;
  stateProxy: (stateName: string) => PathState;
}
declare class Path<Props extends PathProps = PathProps> extends Displayable<Props> {
  path: PathProxy;
  strokeContainThreshold: number;
  segmentIgnoreThreshold: number;
  subPixelOptimize: boolean;
  style: PathStyleProps;
  autoBatch: boolean;
  private _rectStroke;
  protected _normalState: PathState;
  protected _decalEl: Path;
  shape: Dictionary<any>;
  constructor(opts?: Props);
  update(): void;
  getDecalElement(): Path<PathProps>;
  protected _init(props?: Props): void;
  protected getDefaultStyle(): Props['style'];
  protected getDefaultShape(): {};
  protected canBeInsideText(): boolean;
  protected getInsideTextFill(): "#333" | "#ccc" | "#eee";
  protected getInsideTextStroke(textFill?: string): string;
  buildPath(ctx: PathProxy | CanvasRenderingContext2D, shapeCfg: Dictionary<any>, inBatch?: boolean): void;
  pathUpdated(): void;
  getUpdatedPathProxy(inBatch?: boolean): PathProxy;
  createPathProxy(): void;
  hasStroke(): boolean;
  hasFill(): boolean;
  getBoundingRect(): BoundingRect;
  contain(x: number, y: number): boolean;
  dirtyShape(): void;
  dirty(): void;
  animateShape(loop: boolean): Animator<this["shape"]>;
  updateDuringAnimation(targetKey: string): void;
  attrKV(key: PathKey, value: PathPropertyType): void;
  setShape(obj: Props['shape']): this;
  setShape<T extends keyof Props['shape']>(obj: T, value: Props['shape'][T]): this;
  shapeChanged(): boolean;
  createStyle(obj?: Props['style']): Props["style"];
  protected _innerSaveToNormal(toState: PathState): void;
  protected _applyStateObj(stateName: string, state: PathState, normalState: PathState, keepCurrentStates: boolean, transition: boolean, animationCfg: ElementAnimateConfig): void;
  protected _mergeStates(states: PathState[]): PathState;
  getAnimationStyleProps(): MapToType<PathProps, boolean>;
  isZeroArea(): boolean;
  static extend<Shape extends Dictionary<any>>(defaultProps: {
    type?: string;
    shape?: Shape;
    style?: PathStyleProps;
    beforeBrush?: Displayable['beforeBrush'];
    afterBrush?: Displayable['afterBrush'];
    getBoundingRect?: Displayable['getBoundingRect'];
    calculateTextPosition?: Element$1['calculateTextPosition'];
    buildPath(this: Path, ctx: CanvasRenderingContext2D | PathProxy, shape: Shape, inBatch?: boolean): void;
    init?(this: Path, opts: PathProps): void;
  }): {
    new (opts?: PathProps & {
      shape: Shape;
    }): Path;
  };
  protected static initDefaultProps: void;
}
declare class Transformable {
  parent: Transformable;
  x: number;
  y: number;
  scaleX: number;
  scaleY: number;
  skewX: number;
  skewY: number;
  rotation: number;
  anchorX: number;
  anchorY: number;
  originX: number;
  originY: number;
  globalScaleRatio: number;
  transform: MatrixArray;
  invTransform: MatrixArray;
  getLocalTransform(m?: MatrixArray): MatrixArray;
  setPosition(arr: number[]): void;
  setScale(arr: number[]): void;
  setSkew(arr: number[]): void;
  setOrigin(arr: number[]): void;
  needLocalTransform(): boolean;
  updateTransform(): void;
  private _resolveGlobalScaleRatio;
  getComputedTransform(): MatrixArray;
  setLocalTransform(m: VectorArray): void;
  decomposeTransform(): void;
  getGlobalScale(out?: VectorArray): VectorArray;
  transformCoordToLocal(x: number, y: number): number[];
  transformCoordToGlobal(x: number, y: number): number[];
  getLineScale(): number;
  copyTransform(source: Transformable): void;
  static getLocalTransform(target: Transformable, m?: MatrixArray): MatrixArray;
  private static initDefaultProps;
}
declare const TRANSFORMABLE_PROPS: readonly ["x", "y", "originX", "originY", "anchorX", "anchorY", "rotation", "scaleX", "scaleY", "skewX", "skewY"];
declare type TransformProp = (typeof TRANSFORMABLE_PROPS)[number];
interface TSpanStyleProps extends PathStyleProps {
  x?: number;
  y?: number;
  text?: string;
  font?: string;
  fontSize?: number;
  fontWeight?: FontWeight;
  fontStyle?: FontStyle;
  fontFamily?: string;
  textAlign?: CanvasTextAlign;
  textBaseline?: CanvasTextBaseline;
}
interface TSpanProps extends DisplayableProps {
  style?: TSpanStyleProps;
}
declare class TSpan extends Displayable<TSpanProps> {
  style: TSpanStyleProps;
  hasStroke(): boolean;
  hasFill(): boolean;
  createStyle(obj?: TSpanStyleProps): TSpanStyleProps;
  setBoundingRect(rect: BoundingRect): void;
  getBoundingRect(): BoundingRect;
  protected static initDefaultProps: void;
}
interface ImageStyleProps extends CommonStyleProps {
  image?: string | ImageLike;
  x?: number;
  y?: number;
  width?: number;
  height?: number;
  sx?: number;
  sy?: number;
  sWidth?: number;
  sHeight?: number;
}
interface ImageProps extends DisplayableProps {
  style?: ImageStyleProps;
  onload?: (image: ImageLike) => void;
}
declare class ZRImage extends Displayable<ImageProps> {
  style: ImageStyleProps;
  __image: ImageLike;
  __imageSrc: string;
  onload: (image: ImageLike) => void;
  createStyle(obj?: ImageStyleProps): ImageStyleProps;
  private _getSize;
  getWidth(): number;
  getHeight(): number;
  getAnimationStyleProps(): MapToType<ImageProps, boolean>;
  getBoundingRect(): BoundingRect;
}
declare class RectShape {
  r?: number | number[];
  x: number;
  y: number;
  width: number;
  height: number;
}
interface RectProps extends PathProps {
  shape?: Partial<RectShape>;
}
declare class Rect extends Path<RectProps> {
  shape: RectShape;
  constructor(opts?: RectProps);
  getDefaultShape(): RectShape;
  buildPath(ctx: CanvasRenderingContext2D, shape: RectShape): void;
  isZeroArea(): boolean;
}
interface GroupProps extends ElementProps {}
declare class Group extends Element$1<GroupProps> {
  readonly isGroup = true;
  private _children;
  constructor(opts?: GroupProps);
  childrenRef(): Element$1<ElementProps>[];
  children(): Element$1<ElementProps>[];
  childAt(idx: number): Element$1;
  childOfName(name: string): Element$1;
  childCount(): number;
  add(child: Element$1): Group;
  addBefore(child: Element$1, nextSibling: Element$1): this;
  replace(oldChild: Element$1, newChild: Element$1): this;
  replaceAt(child: Element$1, index: number): this;
  _doAdd(child: Element$1): void;
  remove(child: Element$1): this;
  removeAll(): this;
  eachChild<Context>(cb: (this: Context, el: Element$1, index?: number) => void, context?: Context): this;
  traverse<T>(cb: (this: T, el: Element$1) => boolean | void, context?: T): this;
  addSelfToZr(zr: ZRenderType): void;
  removeSelfFromZr(zr: ZRenderType): void;
  getBoundingRect(includeChildren?: Element$1[]): BoundingRect;
}
interface GroupLike extends Element$1 {
  childrenRef(): Element$1[];
}
interface TextStylePropsPart {
  text?: string;
  fill?: string;
  stroke?: string;
  strokeNoScale?: boolean;
  opacity?: number;
  fillOpacity?: number;
  strokeOpacity?: number;
  lineWidth?: number;
  lineDash?: false | number[];
  lineDashOffset?: number;
  borderDash?: false | number[];
  borderDashOffset?: number;
  font?: string;
  textFont?: string;
  fontStyle?: FontStyle;
  fontWeight?: FontWeight;
  fontFamily?: string;
  fontSize?: number | string;
  align?: TextAlign;
  verticalAlign?: TextVerticalAlign;
  lineHeight?: number;
  width?: number | string;
  height?: number;
  tag?: string;
  textShadowColor?: string;
  textShadowBlur?: number;
  textShadowOffsetX?: number;
  textShadowOffsetY?: number;
  backgroundColor?: string | {
    image: ImageLike | string;
  };
  padding?: number | number[];
  margin?: number | number[];
  borderColor?: string;
  borderWidth?: number;
  borderRadius?: number | number[];
  shadowColor?: string;
  shadowBlur?: number;
  shadowOffsetX?: number;
  shadowOffsetY?: number;
}
interface TextStyleProps extends TextStylePropsPart {
  text?: string;
  x?: number;
  y?: number;
  width?: number;
  rich?: Dictionary<TextStylePropsPart>;
  overflow?: 'break' | 'breakAll' | 'truncate' | 'none';
  lineOverflow?: 'truncate';
  ellipsis?: string;
  placeholder?: string;
  truncateMinChar?: number;
}
interface TextProps extends DisplayableProps {
  style?: TextStyleProps;
  zlevel?: number;
  z?: number;
  z2?: number;
  culling?: boolean;
  cursor?: string;
}
declare type TextState = Pick<TextProps, DisplayableStatePropNames> & ElementCommonState;
declare type DefaultTextStyle = Pick<TextStyleProps, 'fill' | 'stroke' | 'align' | 'verticalAlign'> & {
  autoStroke?: boolean;
  overflowRect?: BoundingRect | NullUndefined;
};
interface ZRText {
  animate(key?: '', loop?: boolean): Animator<this>;
  animate(key: 'style', loop?: boolean): Animator<this['style']>;
  getState(stateName: string): TextState;
  ensureState(stateName: string): TextState;
  states: Dictionary<TextState>;
  stateProxy: (stateName: string) => TextState;
}
declare class ZRText extends Displayable<TextProps> implements GroupLike {
  type: string;
  style: TextStyleProps;
  overlap: 'hidden' | 'show' | 'blur';
  innerTransformable: Transformable;
  isTruncated: boolean;
  private _children;
  private _childCursor;
  private _defaultStyle;
  constructor(opts?: TextProps);
  childrenRef(): (ZRImage | Rect | TSpan)[];
  update(): void;
  updateTransform(): void;
  getLocalTransform(m?: MatrixArray): MatrixArray;
  getComputedTransform(): MatrixArray;
  private _updateSubTexts;
  addSelfToZr(zr: ZRenderType): void;
  removeSelfFromZr(zr: ZRenderType): void;
  getBoundingRect(): BoundingRect;
  setDefaultTextStyle(defaultTextStyle: DefaultTextStyle): void;
  setTextContent(textContent: never): void;
  protected _mergeStyle(targetStyle: TextStyleProps, sourceStyle: TextStyleProps): TextStyleProps;
  private _mergeRich;
  getAnimationStyleProps(): MapToType<TextProps, boolean>;
  private _getOrCreateChild;
  private _updatePlainTexts;
  private _updateRichTexts;
  private _placeToken;
  private _renderBackground;
  static makeFont(style: TextStylePropsPart): string;
}
interface TextPositionCalculationResult {
  x: number;
  y: number;
  align: TextAlign;
  verticalAlign: TextVerticalAlign;
}
declare class PolylineShape {
  points: VectorArray[];
  percent?: number;
  smooth?: number;
  smoothConstraint?: VectorArray[];
}
interface PolylineProps extends PathProps {
  shape?: Partial<PolylineShape>;
}
declare class Polyline extends Path<PolylineProps> {
  shape: PolylineShape;
  constructor(opts?: PolylineProps);
  getDefaultStyle(): {
    stroke: string;
    fill: string;
  };
  getDefaultShape(): PolylineShape;
  buildPath(ctx: CanvasRenderingContext2D, shape: PolylineShape): void;
}
interface ElementAnimateConfig {
  duration?: number;
  delay?: number;
  easing?: AnimationEasing;
  during?: (percent: number) => void;
  done?: Function;
  aborted?: Function;
  scope?: string;
  force?: boolean;
  additive?: boolean;
  setToFinal?: boolean;
}
interface ElementTextConfig {
  position?: BuiltinTextPosition | (number | string)[];
  rotation?: number;
  layoutRect?: RectLike;
  offset?: number[];
  origin?: (number | string)[] | 'center';
  distance?: number;
  local?: boolean;
  insideFill?: string;
  insideStroke?: string;
  outsideFill?: string;
  outsideStroke?: string;
  inside?: boolean;
  autoOverflowArea?: boolean;
}
interface ElementTextGuideLineConfig {
  anchor?: Point;
  showAbove?: boolean;
  candidates?: ('left' | 'top' | 'right' | 'bottom')[];
}
interface ElementEvent {
  type: ElementEventName;
  event: ZRRawEvent;
  target: Element$1;
  topTarget: Element$1;
  cancelBubble: boolean;
  offsetX: number;
  offsetY: number;
  gestureEvent: string;
  pinchX: number;
  pinchY: number;
  pinchScale: number;
  wheelDelta: number;
  zrByTouch: boolean;
  which: number;
  stop: (this: ElementEvent) => void;
}
declare type ElementEventCallback<Ctx, Impl> = (this: CbThis$1<Ctx, Impl>, e: ElementEvent) => boolean | void;
declare type CbThis$1<Ctx, Impl> = unknown extends Ctx ? Impl : Ctx;
interface ElementEventHandlerProps {
  onclick: ElementEventCallback<unknown, unknown>;
  ondblclick: ElementEventCallback<unknown, unknown>;
  onmouseover: ElementEventCallback<unknown, unknown>;
  onmouseout: ElementEventCallback<unknown, unknown>;
  onmousemove: ElementEventCallback<unknown, unknown>;
  onmousewheel: ElementEventCallback<unknown, unknown>;
  onmousedown: ElementEventCallback<unknown, unknown>;
  onmouseup: ElementEventCallback<unknown, unknown>;
  oncontextmenu: ElementEventCallback<unknown, unknown>;
  ondrag: ElementEventCallback<unknown, unknown>;
  ondragstart: ElementEventCallback<unknown, unknown>;
  ondragend: ElementEventCallback<unknown, unknown>;
  ondragenter: ElementEventCallback<unknown, unknown>;
  ondragleave: ElementEventCallback<unknown, unknown>;
  ondragover: ElementEventCallback<unknown, unknown>;
  ondrop: ElementEventCallback<unknown, unknown>;
}
interface ElementProps extends Partial<ElementEventHandlerProps>, Partial<Pick<Transformable, TransformProp>> {
  name?: string;
  ignore?: boolean;
  isGroup?: boolean;
  draggable?: boolean | 'horizontal' | 'vertical';
  silent?: boolean;
  ignoreHostSilent?: boolean;
  ignoreClip?: boolean;
  globalScaleRatio?: number;
  textConfig?: ElementTextConfig;
  textContent?: ZRText;
  clipPath?: Path;
  drift?: Element$1['drift'];
  extra?: Dictionary<unknown>;
  anid?: string;
}
declare const PRIMARY_STATES_KEYS: ["x" | "y" | "originX" | "originY" | "anchorX" | "anchorY" | "rotation" | "scaleX" | "scaleY" | "skewX" | "skewY", "ignore"];
declare type ElementStatePropNames = (typeof PRIMARY_STATES_KEYS)[number] | 'textConfig';
declare type ElementState = Pick<ElementProps, ElementStatePropNames> & ElementCommonState;
declare type ElementCommonState = {
  hoverLayer?: boolean;
};
declare type ElementCalculateTextPosition = (out: TextPositionCalculationResult, style: ElementTextConfig, rect: RectLike) => TextPositionCalculationResult;
interface Element$1<Props extends ElementProps = ElementProps> extends Transformable, Eventful<{ [key in ElementEventName]: (e: ElementEvent) => void | boolean } & { [key in string]: (...args: any) => void | boolean }>, ElementEventHandlerProps {}
declare class Element$1<Props extends ElementProps = ElementProps> {
  id: number;
  type: string;
  name: string;
  ignore: boolean;
  silent: boolean;
  ignoreHostSilent: boolean;
  isGroup: boolean;
  draggable: boolean | 'horizontal' | 'vertical';
  dragging: boolean;
  parent: Group;
  animators: Animator<any>[];
  ignoreClip: boolean;
  __hostTarget: Element$1;
  __zr: ZRenderType;
  __dirty: number;
  __isRendered: boolean;
  __inHover: boolean;
  __clipPaths?: Path[];
  private _clipPath?;
  private _textContent?;
  private _textGuide?;
  textConfig?: ElementTextConfig;
  textGuideLineConfig?: ElementTextGuideLineConfig;
  anid: string;
  extra: Dictionary<unknown>;
  currentStates?: string[];
  prevStates?: string[];
  states: Dictionary<ElementState>;
  stateTransition: ElementAnimateConfig;
  stateProxy?: (stateName: string, targetStates?: string[]) => ElementState;
  protected _normalState: ElementState;
  private _innerTextDefaultStyle;
  constructor(props?: Props);
  protected _init(props?: Props): void;
  drift(dx: number, dy: number, e?: ElementEvent): void;
  beforeUpdate(): void;
  afterUpdate(): void;
  update(): void;
  updateInnerText(forceUpdate?: boolean): void;
  protected canBeInsideText(): boolean;
  protected getInsideTextFill(): string | undefined;
  protected getInsideTextStroke(textFill: string): string | undefined;
  protected getOutsideFill(): string | undefined;
  protected getOutsideStroke(textFill: string): string;
  traverse<Context>(cb: (this: Context, el: Element$1<Props>) => void, context?: Context): void;
  protected attrKV(key: string, value: unknown): void;
  hide(): void;
  show(): void;
  attr(keyOrObj: Props): this;
  attr<T extends keyof Props>(keyOrObj: T, value: Props[T]): this;
  saveCurrentToNormalState(toState: ElementState): void;
  protected _innerSaveToNormal(toState: ElementState): void;
  protected _savePrimaryToNormal(toState: Dictionary<any>, normalState: Dictionary<any>, primaryKeys: readonly string[]): void;
  hasState(): boolean;
  getState(name: string): ElementState;
  ensureState(name: string): ElementState;
  clearStates(noAnimation?: boolean): void;
  useState(stateName: string, keepCurrentStates?: boolean, noAnimation?: boolean, forceUseHoverLayer?: boolean): ElementState;
  useStates(states: string[], noAnimation?: boolean, forceUseHoverLayer?: boolean): void;
  isSilent(): boolean;
  private _updateAnimationTargets;
  removeState(state: string): void;
  replaceState(oldState: string, newState: string, forceAdd: boolean): void;
  toggleState(state: string, enable: boolean): void;
  protected _mergeStates(states: ElementState[]): ElementState;
  protected _applyStateObj(stateName: string, state: ElementState, normalState: ElementState, keepCurrentStates: boolean, transition: boolean, animationCfg: ElementAnimateConfig): void;
  private _attachComponent;
  private _detachComponent;
  getClipPath(): Path<PathProps>;
  setClipPath(clipPath: Path): void;
  removeClipPath(): void;
  getTextContent(): ZRText;
  setTextContent(textEl: ZRText): void;
  setTextConfig(cfg: ElementTextConfig): void;
  removeTextConfig(): void;
  removeTextContent(): void;
  getTextGuideLine(): Polyline;
  setTextGuideLine(guideLine: Polyline): void;
  removeTextGuideLine(): void;
  markRedraw(): void;
  dirty(): void;
  private _toggleHoverLayerFlag;
  addSelfToZr(zr: ZRenderType): void;
  removeSelfFromZr(zr: ZRenderType): void;
  animate(key?: string, loop?: boolean, allowDiscreteAnimation?: boolean): Animator<any>;
  addAnimator(animator: Animator<any>, key: string): void;
  updateDuringAnimation(key: string): void;
  stopAnimation(scope?: string, forwardToLast?: boolean): this;
  animateTo(target: Props, cfg?: ElementAnimateConfig, animationProps?: MapToType<Props, boolean>): void;
  animateFrom(target: Props, cfg: ElementAnimateConfig, animationProps?: MapToType<Props, boolean>): void;
  protected _transitionState(stateName: string, target: Props, cfg?: ElementAnimateConfig, animationProps?: MapToType<Props, boolean>): void;
  getBoundingRect(): BoundingRect;
  getPaintRect(): BoundingRect;
  calculateTextPosition: ElementCalculateTextPosition;
  protected static initDefaultProps: void;
}
interface CommonStyleProps {
  shadowBlur?: number;
  shadowOffsetX?: number;
  shadowOffsetY?: number;
  shadowColor?: string;
  opacity?: number;
  blend?: string;
}
interface DisplayableProps extends ElementProps {
  style?: Dictionary<any>;
  zlevel?: number;
  z?: number;
  z2?: number;
  culling?: boolean;
  cursor?: string;
  rectHover?: boolean;
  progressive?: boolean;
  incremental?: boolean;
  ignoreCoarsePointer?: boolean;
  batch?: boolean;
  invisible?: boolean;
}
declare type DisplayableKey = keyof DisplayableProps;
declare type DisplayablePropertyType = PropType<DisplayableProps, DisplayableKey>;
declare type DisplayableStatePropNames = ElementStatePropNames | 'style' | 'z' | 'z2' | 'invisible';
declare type DisplayableState = Pick<DisplayableProps, DisplayableStatePropNames> & ElementCommonState;
interface Displayable<Props extends DisplayableProps = DisplayableProps> {
  animate(key?: '', loop?: boolean): Animator<this>;
  animate(key: 'style', loop?: boolean): Animator<this['style']>;
  getState(stateName: string): DisplayableState;
  ensureState(stateName: string): DisplayableState;
  states: Dictionary<DisplayableState>;
  stateProxy: (stateName: string) => DisplayableState;
}
declare class Displayable<Props extends DisplayableProps = DisplayableProps> extends Element$1<Props> {
  invisible: boolean;
  z: number;
  z2: number;
  zlevel: number;
  culling: boolean;
  cursor: string;
  rectHover: boolean;
  incremental: boolean;
  ignoreCoarsePointer?: boolean;
  style: Dictionary<any>;
  protected _normalState: DisplayableState;
  protected _rect: BoundingRect;
  protected _paintRect: BoundingRect;
  protected _prevPaintRect: BoundingRect;
  dirtyRectTolerance: number;
  useHoverLayer?: boolean;
  __hoverStyle?: CommonStyleProps;
  __clipPaths?: Path[];
  __canvasFillGradient: CanvasGradient;
  __canvasStrokeGradient: CanvasGradient;
  __canvasFillPattern: CanvasPattern;
  __canvasStrokePattern: CanvasPattern;
  __svgEl: SVGElement;
  constructor(props?: Props);
  protected _init(props?: Props): void;
  beforeBrush(): void;
  afterBrush(): void;
  innerBeforeBrush(): void;
  innerAfterBrush(): void;
  shouldBePainted(viewWidth: number, viewHeight: number, considerClipPath: boolean, considerAncestors: boolean): boolean;
  contain(x: number, y: number): boolean;
  traverse<Context>(cb: (this: Context, el: this) => void, context?: Context): void;
  rectContain(x: number, y: number): boolean;
  getPaintRect(): BoundingRect;
  setPrevPaintRect(paintRect: BoundingRect): void;
  getPrevPaintRect(): BoundingRect;
  animateStyle(loop: boolean): Animator<this["style"]>;
  updateDuringAnimation(targetKey: string): void;
  attrKV(key: DisplayableKey, value: DisplayablePropertyType): void;
  setStyle(obj: Props['style']): this;
  setStyle<T extends keyof Props['style']>(obj: T, value: Props['style'][T]): this;
  dirtyStyle(notRedraw?: boolean): void;
  dirty(): void;
  styleChanged(): boolean;
  styleUpdated(): void;
  createStyle(obj?: Props['style']): Props["style"];
  useStyle(obj: Props['style']): void;
  isStyleObject(obj: Props['style']): any;
  protected _innerSaveToNormal(toState: DisplayableState): void;
  protected _applyStateObj(stateName: string, state: DisplayableState, normalState: DisplayableState, keepCurrentStates: boolean, transition: boolean, animationCfg: ElementAnimateConfig): void;
  protected _mergeStates(states: DisplayableState[]): DisplayableState;
  protected _mergeStyle(targetStyle: CommonStyleProps, sourceStyle: CommonStyleProps): CommonStyleProps;
  getAnimationStyleProps(): MapToType<DisplayableProps, boolean>;
  protected static initDefaultProps: void;
}
interface PainterBase {
  type: string;
  root?: HTMLElement;
  ssrOnly?: boolean;
  resize(width?: number | string, height?: number | string): void;
  refresh(): void;
  clear(): void;
  renderToString?(): string;
  getType: () => string;
  getWidth(): number;
  getHeight(): number;
  dispose(): void;
  getViewportRoot: () => HTMLElement;
  getViewportRootOffset: () => {
    offsetLeft: number;
    offsetTop: number;
  };
  refreshHover(): void;
  configLayer(zlevel: number, config: Dictionary<any>): void;
  setBackgroundColor(backgroundColor: string | GradientObject | PatternObject): void;
}
interface HandlerProxyInterface extends Eventful {
  handler: Handler;
  dispose: () => void;
  setCursor: (cursorStyle?: string) => void;
}
declare function shapeCompareFunc(a: Displayable, b: Displayable): number;
declare class Storage {
  private _roots;
  private _displayList;
  private _displayListLen;
  traverse<T>(cb: (this: T, el: Element$1) => void, context?: T): void;
  getDisplayList(update?: boolean, includeIgnore?: boolean): Displayable[];
  updateDisplayList(includeIgnore?: boolean): void;
  private _updateAndAddDisplayable;
  addRoot(el: Element$1): void;
  delRoot(el: Element$1 | Element$1[]): void;
  delAllRoots(): void;
  getRoots(): Element$1<ElementProps>[];
  dispose(): void;
  displayableSortFunc: typeof shapeCompareFunc;
}
declare class HoveredResult {
  x: number;
  y: number;
  target: Displayable;
  topTarget: Displayable;
  constructor(x?: number, y?: number);
}
declare type HandlerName = 'click' | 'dblclick' | 'mousewheel' | 'mouseout' | 'mouseup' | 'mousedown' | 'mousemove' | 'contextmenu';
declare class Handler extends Eventful {
  storage: Storage;
  painter: PainterBase;
  painterRoot: HTMLElement;
  proxy: HandlerProxyInterface;
  private _hovered;
  private _gestureMgr;
  private _draggingMgr;
  private _pointerSize;
  _downEl: Element$1;
  _upEl: Element$1;
  _downPoint: [number, number];
  constructor(storage: Storage, painter: PainterBase, proxy: HandlerProxyInterface, painterRoot: HTMLElement, pointerSize: number);
  setHandlerProxy(proxy: HandlerProxyInterface): void;
  mousemove(event: ZRRawEvent): void;
  mouseout(event: ZRRawEvent): void;
  resize(): void;
  dispatch(eventName: HandlerName, eventArgs?: any): void;
  dispose(): void;
  setCursorStyle(cursorStyle: string): void;
  dispatchToElement(targetInfo: {
    target?: Element$1;
    topTarget?: Element$1;
  }, eventName: ElementEventName, event: ZRRawEvent): void;
  findHover(x: number, y: number, exclude?: Displayable): HoveredResult;
  processGesture(event: ZRRawEvent, stage?: 'start' | 'end' | 'change'): void;
  click: (event: ZRRawEvent) => void;
  mousedown: (event: ZRRawEvent) => void;
  mouseup: (event: ZRRawEvent) => void;
  mousewheel: (event: ZRRawEvent) => void;
  dblclick: (event: ZRRawEvent) => void;
  contextmenu: (event: ZRRawEvent) => void;
}
interface LayerConfig {
  clearColor?: string | GradientObject | ImagePatternObject;
  motionBlur?: boolean;
  lastFrameAlpha?: number;
}
/*!
* ZRender, a high performance 2d drawing library.
*
* Copyright (c) 2013, Baidu Inc.
* All rights reserved.
*
* LICENSE
* https://github.com/ecomfe/zrender/blob/master/LICENSE.txt
*/
declare class ZRender {
  dom?: HTMLElement;
  id: number;
  storage: Storage;
  painter: PainterBase;
  handler: Handler;
  animation: Animation;
  private _sleepAfterStill;
  private _stillFrameAccum;
  private _needsRefresh;
  private _needsRefreshHover;
  private _disposed;
  private _darkMode;
  private _backgroundColor;
  constructor(id: number, dom?: HTMLElement, opts?: ZRenderInitOpt);
  add(el: Element$1): void;
  remove(el: Element$1): void;
  configLayer(zLevel: number, config: LayerConfig): void;
  setBackgroundColor(backgroundColor: string | GradientObject | PatternObject): void;
  getBackgroundColor(): string | GradientObject | PatternObject;
  setDarkMode(darkMode: boolean): void;
  isDarkMode(): boolean;
  refreshImmediately(fromInside?: boolean): void;
  refresh(): void;
  flush(): void;
  private _flush;
  setSleepAfterStill(stillFramesCount: number): void;
  wakeUp(): void;
  refreshHover(): void;
  refreshHoverImmediately(): void;
  resize(opts?: {
    width?: number | string;
    height?: number | string;
  }): void;
  clearAnimation(): void;
  getWidth(): number | undefined;
  getHeight(): number | undefined;
  setCursorStyle(cursorStyle: string): void;
  findHover(x: number, y: number): {
    target: Displayable;
    topTarget: Displayable;
  } | undefined;
  on<Ctx>(eventName: ElementEventName, eventHandler: ElementEventCallback<Ctx, ZRenderType>, context?: Ctx): this;
  on<Ctx>(eventName: string, eventHandler: WithThisType<EventCallback<any[]>, unknown extends Ctx ? ZRenderType : Ctx>, context?: Ctx): this;
  off(eventName?: string, eventHandler?: EventCallback): void;
  trigger(eventName: string, event?: unknown): void;
  clear(): void;
  dispose(): void;
}
interface ZRenderInitOpt {
  renderer?: string;
  devicePixelRatio?: number;
  width?: number | string;
  height?: number | string;
  useDirtyRect?: boolean;
  useCoarsePointer?: 'auto' | boolean;
  pointerSize?: number;
  ssr?: boolean;
}
interface ZRenderType extends ZRender {}
declare const _default: {
  time: {
    month: string[];
    monthAbbr: string[];
    dayOfWeek: string[];
    dayOfWeekAbbr: string[];
  };
  legend: {
    selector: {
      all: string;
      inverse: string;
    };
  };
  toolbox: {
    brush: {
      title: {
        rect: string;
        polygon: string;
        lineX: string;
        lineY: string;
        keep: string;
        clear: string;
      };
    };
    dataView: {
      title: string;
      lang: string[];
    };
    dataZoom: {
      title: {
        zoom: string;
        back: string;
      };
    };
    magicType: {
      title: {
        line: string;
        bar: string;
        stack: string;
        tiled: string;
      };
    };
    restore: {
      title: string;
    };
    saveAsImage: {
      title: string;
      lang: string[];
    };
  };
  series: {
    typeNames: {
      pie: string;
      bar: string;
      line: string;
      scatter: string;
      effectScatter: string;
      radar: string;
      tree: string;
      treemap: string;
      boxplot: string;
      candlestick: string;
      k: string;
      heatmap: string;
      map: string;
      parallel: string;
      lines: string;
      graph: string;
      sankey: string;
      funnel: string;
      gauge: string;
      pictorialBar: string;
      themeRiver: string;
      sunburst: string;
      custom: string;
      chart: string;
    };
  };
  aria: {
    general: {
      withTitle: string;
      withoutTitle: string;
    };
    series: {
      single: {
        prefix: string;
        withName: string;
        withoutName: string;
      };
      multiple: {
        prefix: string;
        withName: string;
        withoutName: string;
        separator: {
          middle: string;
          end: string;
        };
      };
    };
    data: {
      allData: string;
      partialData: string;
      withName: string;
      withoutName: string;
      separator: {
        middle: string;
        end: string;
      };
    };
  };
};
declare type LocaleOption = typeof _default;
declare type DimensionUserOuputEncode = {
  [coordOrVisualDimName: string]: DimensionIndex[];
};
/**
 * If string, e.g., 'geo', means {geoIndex: 0}.
 * If Object, could contain some of these properties below:
 * {
 *     seriesIndex, seriesId, seriesName,
 *     geoIndex, geoId, geoName,
 *     bmapIndex, bmapId, bmapName,
 *     xAxisIndex, xAxisId, xAxisName,
 *     yAxisIndex, yAxisId, yAxisName,
 *     gridIndex, gridId, gridName,
 *     ... (can be extended)
 * }
 * Each properties can be number|string|Array.<number>|Array.<string>
 * For example, a finder could be
 * {
 *     seriesIndex: 3,
 *     geoId: ['aa', 'cc'],
 *     gridName: ['xx', 'rr']
 * }
 * xxxIndex can be set as 'all' (means all xxx) or 'none' (means not specify)
 * If nothing or null/undefined specified, return nothing.
 * If both `abcIndex`, `abcId`, `abcName` specified, only one work.
 * The priority is: index > id > name, the same with `ecModel.queryComponents`.
 */
declare type ModelFinderIndexQuery = number | number[] | 'all' | 'none' | false;
declare type ModelFinderIdQuery = OptionId | OptionId[];
declare type ModelFinderNameQuery = OptionId | OptionId[];
declare type ModelFinder = string | ModelFinderObject;
declare type ModelFinderObject = {
  seriesIndex?: ModelFinderIndexQuery;
  seriesId?: ModelFinderIdQuery;
  seriesName?: ModelFinderNameQuery;
  geoIndex?: ModelFinderIndexQuery;
  geoId?: ModelFinderIdQuery;
  geoName?: ModelFinderNameQuery;
  bmapIndex?: ModelFinderIndexQuery;
  bmapId?: ModelFinderIdQuery;
  bmapName?: ModelFinderNameQuery;
  xAxisIndex?: ModelFinderIndexQuery;
  xAxisId?: ModelFinderIdQuery;
  xAxisName?: ModelFinderNameQuery;
  yAxisIndex?: ModelFinderIndexQuery;
  yAxisId?: ModelFinderIdQuery;
  yAxisName?: ModelFinderNameQuery;
  gridIndex?: ModelFinderIndexQuery;
  gridId?: ModelFinderIdQuery;
  gridName?: ModelFinderNameQuery;
  matrixIndex?: ModelFinderIndexQuery;
  matrixId?: ModelFinderIdQuery;
  matrixName?: ModelFinderNameQuery;
  dataIndex?: number;
  dataIndexInside?: number;
};
/**
 * {
 *     seriesModels: [seriesModel1, seriesModel2],
 *     seriesModel: seriesModel1, // The first model
 *     geoModels: [geoModel1, geoModel2],
 *     geoModel: geoModel1, // The first model
 *     ...
 * }
 */
interface RichTextTooltipMarker {
  renderMode: TooltipRenderMode;
  content: string;
  style: Dictionary<unknown>;
}
declare type TooltipMarker = string | RichTextTooltipMarker;
/**
 * [Notice]:
 * Consider custom bundle on demand, chart specified
 * or component specified types and constants should
 * not put here. Only common types and constants can
 * be put in this file.
 */
declare type RendererType = 'canvas' | 'svg';
declare type NullUndefined$1 = null | undefined;
declare type HorizontalAlign = 'left' | 'center' | 'right';
declare type VerticalAlign = 'top' | 'middle' | 'bottom';
declare type ColorString = string;
declare type ZRColor = ColorString | LinearGradientObject | RadialGradientObject | PatternObject;
declare type ZRLineType = 'solid' | 'dotted' | 'dashed' | number | number[];
declare type ZRFontStyle = 'normal' | 'italic' | 'oblique';
declare type ZRFontWeight = 'normal' | 'bold' | 'bolder' | 'lighter' | number;
declare type ZRElementEventName = ElementEventName | 'globalout';
declare type ComponentMainType = keyof ECUnitOption & string;
interface PayloadItem {
  excludeSeriesId?: OptionId | OptionId[];
  animation?: PayloadAnimationPart;
  [other: string]: any;
}
interface Payload extends PayloadItem {
  type: string;
  escapeConnect?: boolean;
  batch?: PayloadItem[];
}
interface PayloadAnimationPart {
  duration?: number;
  easing?: AnimationEasing;
  delay?: number;
}
interface ECElementEvent extends ECEventData, CallbackDataParams {
  type: ZRElementEventName;
  event?: ElementEvent;
}
/**
 * The echarts event type to user.
 * Also known as packedEvent.
 */
interface ECActionEvent extends ECEventData {
  type: string;
  componentType?: string;
  componentIndex?: number;
  seriesIndex?: number;
  escapeConnect?: boolean;
  batch?: ECEventData[];
}
/**
 * TODO: not applicable in `ECEventProcessor` yet.
 */
interface ECEventData {
  [key: string]: any;
}
/**
 * 'html' is used for rendering tooltip in extra DOM form, and the result
 * string is used as DOM HTML content.
 * 'richText' is used for rendering tooltip in rich text form, for those where
 * DOM operation is not supported.
 */
declare type TooltipRenderMode = 'html' | 'richText';
declare type OrdinalRawValue = string | number;
declare type OrdinalNumber = number;
/**
 * @usage For example,
 * ```js
 * { ordinalNumbers: [2, 5, 3, 4] }
 * ```
 * means that ordinal 2 should be displayed on tick 0,
 * ordinal 5 should be displayed on tick 1, ...
 */
declare type ParsedValueNumeric = number | OrdinalNumber;
/**
 * `ScaleDataValue` represents the user input axis value in echarts API.
 * (For example, used `axis.min`/`axis.max` in echarts option, `convertToPixel`).
 * NOTICE:
 *  `ScaleDataValue` is slightly different from `OptionDataValue` for historical reason.
 *  `ScaleDataValue` should be parsed by `src/scale/Scale['parse']`.
 *  `OptionDataValue` should be parsed by `src/data/helper/dataValueHelper.parseDataValue`.
 * FIXME:
 *  Make `ScaleDataValue` `OptionDataValue` consistent? Since numeric string (like `'123'`) is accepted
 *  in `series.data` and is effectively accepted in some axis relevant option (e.g., `axis.min/max`),
 *  `type ScaleDataValue` should also include it for consistency. But it might bring some breaking in
 *  TS interface (user callback) and need comprehensive checks for all of the parsing of `ScaleDataValue`.
 */
declare type ScaleDataValue = ParsedValueNumeric | OrdinalRawValue | Date;
/**
 * - `ScaleDataValue`:
 *   e.g. geo accept that primitive input, like `convertToPixel('some_place')`;
 *   Some coord sys, such as 'cartesian2d', also supports that for only query only a single axis.
 * - `ScaleDataValue[]`:
 *   This is the most common case, each array item represent each data in
 *   every dimension required by the coord sys. e.g., `[12, 98]` represents `[xData, yData]`.
 * - `(ScaleDataValue[])[]`:
 *   represents `[data_range_x, data_range_y]`. e.g., `dataToPoint([[5, 600], [8889, 9000]])`,
 *   represents data range `[5, 600]` in x, and `[8889, 9000]` in y.
 *   Can be also `[5, [8999, 9000]]`.
 */
declare type CoordinateSystemDataCoord = (ScaleDataValue | NullUndefined$1) | (ScaleDataValue | NullUndefined$1)[] | (ScaleDataValue | ScaleDataValue[] | NullUndefined$1)[];
/**
 * Return type of API `CoordinateSystem['dataToLayout']`, expose to users.
 */
interface CoordinateSystemDataLayout {
  rect?: RectLike;
  contentRect?: RectLike;
  matrixXYLocatorRange?: number[][];
}
declare type DimensionIndex = number;
declare type DimensionIndexLoose = DimensionIndex | string;
declare type DimensionName = string;
declare type DimensionLoose = DimensionName | DimensionIndexLoose;
declare type SeriesDataType = 'main' | 'node' | 'edge';
/**
 * [ECUnitOption]:
 * An object that contains definitions of components
 * and other properties. For example:
 *
 * ```ts
 * let option: ECUnitOption = {
 *
 *     // Single `title` component:
 *     title: {...},
 *
 *     // Two `visualMap` components:
 *     visualMap: [{...}, {...}],
 *
 *     // Two `series.bar` components
 *     // and one `series.pie` component:
 *     series: [
 *         {type: 'bar', data: [...]},
 *         {type: 'bar', data: [...]},
 *         {type: 'pie', data: [...]}
 *     ],
 *
 *     // A property:
 *     backgroundColor: '#421ae4'
 *
 *     // A property object:
 *     textStyle: {
 *         color: 'red',
 *         fontSize: 20
 *     }
 * };
 * ```
 */
declare type ECUnitOption = {
  baseOption?: unknown;
  options?: unknown;
  media?: unknown;
  timeline?: ComponentOption | ComponentOption[];
  backgroundColor?: ZRColor;
  darkMode?: boolean | 'auto';
  textStyle?: GlobalTextStyleOption;
  useUTC?: boolean;
  hoverLayerThreshold?: number;
  legacyViewCoordSysCenterBase?: boolean;
  [key: string]: ComponentOption | ComponentOption[] | Dictionary<unknown> | unknown;
  stateAnimation?: AnimationOption$1;
} & AnimationOptionMixin & ColorPaletteOptionMixin;
/**
 * [ECOption]:
 * An object input to echarts.setOption(option).
 * May be an 'option: ECUnitOption',
 * or may be an object contains multi-options. For example:
 *
 * ```ts
 * let option: ECOption = {
 *     baseOption: {
 *         title: {...},
 *         legend: {...},
 *         series: [
 *             {data: [...]},
 *             {data: [...]},
 *             ...
 *         ]
 *     },
 *     timeline: {...},
 *     options: [
 *         {title: {...}, series: {data: [...]}},
 *         {title: {...}, series: {data: [...]}},
 *         ...
 *     ],
 *     media: [
 *         {
 *             query: {maxWidth: 320},
 *             option: {series: {x: 20}, visualMap: {show: false}}
 *         },
 *         {
 *             query: {minWidth: 320, maxWidth: 720},
 *             option: {series: {x: 500}, visualMap: {show: true}}
 *         },
 *         {
 *             option: {series: {x: 1200}, visualMap: {show: true}}
 *         }
 *     ]
 * };
 * ```
 */
interface ECBasicOption extends ECUnitOption {
  baseOption?: ECUnitOption;
  timeline?: ComponentOption | ComponentOption[];
  options?: ECUnitOption[];
  media?: MediaUnit[];
}
declare type OptionDataItem = OptionDataValue | Dictionary<OptionDataValue> | OptionDataValue[] | OptionDataItemObject<OptionDataValue>;
declare type OptionDataItemObject<T> = {
  id?: OptionId;
  name?: OptionName;
  groupId?: OptionId;
  childGroupId?: OptionId;
  value?: T[] | T;
  selected?: boolean;
};
declare type OptionId = string | number;
declare type OptionName = string | number;
declare type OptionDataValue = string | number | Date | null | undefined;
declare type ThemeOption = Dictionary<any>;
declare type DisplayState = 'normal' | 'emphasis' | 'blur' | 'select';
interface CallbackDataParams {
  componentType: string;
  componentSubType: string;
  componentIndex: number;
  seriesType?: string;
  seriesIndex?: number;
  seriesId?: string;
  seriesName?: string;
  name: string;
  dataIndex: number;
  data: OptionDataItem;
  dataType?: SeriesDataType;
  value: OptionDataItem | OptionDataValue;
  color?: ZRColor;
  borderColor?: string;
  dimensionNames?: DimensionName[];
  encode?: DimensionUserOuputEncode;
  marker?: TooltipMarker;
  status?: DisplayState;
  dimensionIndex?: number;
  percent?: number;
  $vars: string[];
}
interface MediaQuery {
  minWidth?: number;
  maxWidth?: number;
  minHeight?: number;
  maxHeight?: number;
  minAspectRatio?: number;
  maxAspectRatio?: number;
}
declare type MediaUnit = {
  query?: MediaQuery;
  option: ECUnitOption;
};
interface ColorPaletteOptionMixin {
  color?: ZRColor | ZRColor[];
  colorLayer?: ZRColor[][];
}
/**
 * Mixin of option set to control the box layout of each component.
 */
interface ShadowOptionMixin {
  shadowBlur?: number;
  shadowColor?: ColorString;
  shadowOffsetX?: number;
  shadowOffsetY?: number;
}
declare type AnimationDelayCallbackParam = {
  count: number;
  index: number;
};
declare type AnimationDurationCallback = (idx: number) => number;
declare type AnimationDelayCallback = (idx: number, params?: AnimationDelayCallbackParam) => number;
interface AnimationOption$1 {
  duration?: number;
  easing?: AnimationEasing;
  delay?: number;
}
/**
 * Mixin of option set to control the animation of series.
 */
interface AnimationOptionMixin {
  /**
   * If enable animation
   */
  animation?: boolean;
  /**
   * Disable animation when the number of elements exceeds the threshold
   */
  animationThreshold?: number;
  /**
   * Duration of initialize animation.
   * Can be a callback to specify duration of each element
   */
  animationDuration?: number | AnimationDurationCallback;
  /**
   * Easing of initialize animation
   */
  animationEasing?: AnimationEasing;
  /**
   * Delay of initialize animation
   * Can be a callback to specify duration of each element
   */
  animationDelay?: number | AnimationDelayCallback;
  /**
   * Delay of data update animation.
   * Can be a callback to specify duration of each element
   */
  animationDurationUpdate?: number | AnimationDurationCallback;
  /**
   * Easing of data update animation.
   */
  animationEasingUpdate?: AnimationEasing;
  /**
   * Delay of data update animation.
   * Can be a callback to specify duration of each element
   */
  animationDelayUpdate?: number | AnimationDelayCallback;
}
declare type TextCommonOptionNuanceBase = Record<string, unknown>;
declare type TextCommonOptionNuanceDefault = {};
declare type LabelStyleColorString = ColorString | 'inherit' | 'auto';
interface TextCommonOption<TNuance extends TextCommonOptionNuanceBase = TextCommonOptionNuanceDefault> extends ShadowOptionMixin {
  color?: 'color' extends keyof TNuance ? (TNuance['color'] | LabelStyleColorString) : LabelStyleColorString;
  fontStyle?: ZRFontStyle;
  fontWeight?: ZRFontWeight;
  fontFamily?: string;
  fontSize?: number | string;
  align?: HorizontalAlign;
  verticalAlign?: VerticalAlign;
  baseline?: VerticalAlign;
  opacity?: number;
  lineHeight?: number;
  backgroundColor?: ColorString | {
    image: ImageLike | string;
  };
  borderColor?: string;
  borderWidth?: number;
  borderType?: ZRLineType;
  borderDashOffset?: number;
  borderRadius?: number | number[];
  padding?: number | number[];
  /**
   * Currently margin related options are not declared here. They are not supported in rich text.
   * @see {LabelCommonOption}
   */
  width?: number | string;
  height?: number;
  textBorderColor?: string;
  textBorderWidth?: number;
  textBorderType?: ZRLineType;
  textBorderDashOffset?: number;
  textShadowBlur?: number;
  textShadowColor?: string;
  textShadowOffsetX?: number;
  textShadowOffsetY?: number;
  tag?: string;
}
declare type GlobalTextStyleOption = Pick<TextCommonOption, 'color' | 'opacity' | 'fontStyle' | 'fontWeight' | 'fontSize' | 'fontFamily' | 'textShadowColor' | 'textShadowBlur' | 'textShadowOffsetX' | 'textShadowOffsetY' | 'textBorderColor' | 'textBorderWidth' | 'textBorderType' | 'textBorderDashOffset'>;
interface ComponentOption {
  mainType?: string;
  type?: string;
  id?: OptionId;
  name?: OptionName;
  z?: number;
  zlevel?: number;
  coordinateSystem?: string;
  coordinateSystemUsage?: CoordinateSystemUsageOption;
  coord?: CoordinateSystemDataCoord;
}
/**
 * - "data": Use it as "dataCoordSys", each data item is laid out based on a coord sys.
 * - "box": Use it as "boxCoordSys", the overall bounding rect or anchor point is calculated based on a coord sys.
 *   e.g.,
 *      grid rect (cartesian rect) is calculate based on matrix/calendar coord sys;
 *      pie center is calculated based on calendar/cartesian;
 *
 * The default value (if not declared in option `coordinateSystemUsage`):
 *  For series, be "data", since this is the most case and backward compatible.
 *  For non-series components, be "box", since "data" is not applicable.
 */
declare type CoordinateSystemUsageOption = 'data' | 'box';
/**
 * Caution: If the mechanism should be changed some day, these cases
 * should be considered:
 *
 * (1) In `merge option` mode, if using the same option to call `setOption`
 * many times, the result should be the same (try our best to ensure that).
 * (2) In `merge option` mode, if a component has no id/name specified, it
 * will be merged by index, and the result sequence of the components is
 * consistent to the original sequence.
 * (3) In `replaceMerge` mode, keep the result sequence of the components is
 * consistent to the original sequence, even though there might result in "hole".
 * (4) `reset` feature (in toolbox). Find detailed info in comments about
 * `mergeOption` in module:echarts/model/OptionManager.
 */
interface GlobalModelSetOptionOpts {
  replaceMerge: ComponentMainType | ComponentMainType[];
}
interface UpdateLifecycleTransitionSeriesFinder {
  seriesIndex?: ModelFinderIndexQuery;
  seriesId?: ModelFinderIdQuery;
  dimension: DimensionLoose;
}
interface UpdateLifecycleTransitionItem {
  from?: UpdateLifecycleTransitionSeriesFinder | UpdateLifecycleTransitionSeriesFinder[];
  to: UpdateLifecycleTransitionSeriesFinder | UpdateLifecycleTransitionSeriesFinder[];
}
declare type UpdateLifecycleTransitionOpt = UpdateLifecycleTransitionItem | UpdateLifecycleTransitionItem[];
declare type ModelFinder$1 = ModelFinder;
declare const IN_MAIN_PROCESS_KEY: "__flagInMainProcess";
declare const MAIN_PROCESS_VERSION_KEY: "__mainProcessVersion";
declare const PENDING_UPDATE: "__pendingUpdate";
declare const STATUS_NEEDS_UPDATE_KEY: "__needsUpdateStatus";
declare const CONNECT_STATUS_KEY: "__connectUpdateStatus";
declare type SetOptionTransitionOpt = UpdateLifecycleTransitionOpt;
interface SetOptionOpts$1 {
  notMerge?: boolean;
  lazyUpdate?: boolean;
  silent?: boolean;
  replaceMerge?: GlobalModelSetOptionOpts['replaceMerge'];
  transition?: SetOptionTransitionOpt;
}
interface ResizeOpts {
  width?: number | 'auto';
  height?: number | 'auto';
  animation?: AnimationOption$1;
  silent?: boolean;
}
interface SetThemeOpts {
  silent?: boolean;
}
declare type RenderedEventParam = {
  elapsedTime: number;
};
declare type ECEventDefinition = { [key in ZRElementEventName]: EventCallbackSingleParam<ECElementEvent> } & {
  rendered: EventCallbackSingleParam<RenderedEventParam>;
  finished: () => void | boolean;
} & {
  [key: string]: (...args: unknown[]) => void | boolean;
};
declare type EChartsInitOpts = {
  locale?: string | LocaleOption;
  renderer?: RendererType;
  devicePixelRatio?: number;
  useDirtyRect?: boolean;
  useCoarsePointer?: boolean;
  pointerSize?: number;
  ssr?: boolean;
  width?: number | string;
  height?: number | string;
};
declare class ECharts extends Eventful<ECEventDefinition> {
  /**
   * @readonly
   */
  id: string;
  /**
   * Group id
   * @readonly
   */
  group: string;
  private _ssr;
  private _zr;
  private _dom;
  private _model;
  private _throttledZrFlush;
  private _theme;
  private _locale;
  private _chartsViews;
  private _chartsMap;
  private _componentsViews;
  private _componentsMap;
  private _coordSysMgr;
  private _api;
  private _scheduler;
  private _messageCenter;
  private _pendingActions;
  protected _$eventProcessor: never;
  private _disposed;
  private _loadingFX;
  private [PENDING_UPDATE];
  private [IN_MAIN_PROCESS_KEY];
  private [MAIN_PROCESS_VERSION_KEY];
  private [CONNECT_STATUS_KEY];
  private [STATUS_NEEDS_UPDATE_KEY];
  constructor(dom: HTMLElement, theme?: string | ThemeOption, opts?: EChartsInitOpts);
  private _onframe;
  getDom(): HTMLElement;
  getId(): string;
  getZr(): ZRenderType;
  isSSR(): boolean;
  /**
   * Usage:
   * chart.setOption(option, notMerge, lazyUpdate);
   * chart.setOption(option, {
   *     notMerge: ...,
   *     lazyUpdate: ...,
   *     silent: ...
   * });
   *
   * @param opts opts or notMerge.
   * @param opts.notMerge Default `false`.
   * @param opts.lazyUpdate Default `false`. Useful when setOption frequently.
   * @param opts.silent Default `false`.
   * @param opts.replaceMerge Default undefined.
   */
  setOption<Opt extends ECBasicOption>(option: Opt, notMerge?: boolean, lazyUpdate?: boolean): void;
  setOption<Opt extends ECBasicOption>(option: Opt, opts?: SetOptionOpts$1): void;
  /**
   * Update theme with name or theme option and repaint the chart.
   * @param theme Theme name or theme option.
   * @param opts Optional settings
   */
  setTheme(theme: string | ThemeOption, opts?: SetThemeOpts): void;
  private _updateTheme;
  private getModel;
  getOption(): ECBasicOption;
  getWidth(): number;
  getHeight(): number;
  getDevicePixelRatio(): number;
  /**
   * Get canvas which has all thing rendered
   * @deprecated Use renderToCanvas instead.
   */
  getRenderedCanvas(opts?: any): HTMLCanvasElement;
  renderToCanvas(opts?: {
    backgroundColor?: ZRColor;
    pixelRatio?: number;
  }): HTMLCanvasElement;
  renderToSVGString(opts?: {
    useViewBox?: boolean;
  }): string;
  /**
   * Get svg data url
   */
  getSvgDataURL(): string;
  getDataURL(opts?: {
    type?: 'png' | 'jpeg' | 'svg';
    pixelRatio?: number;
    backgroundColor?: ZRColor;
    excludeComponents?: ComponentMainType[];
  }): string;
  getConnectedDataURL(opts?: {
    type?: 'png' | 'jpeg' | 'svg';
    pixelRatio?: number;
    backgroundColor?: ZRColor;
    connectedBackgroundColor?: ZRColor;
    excludeComponents?: string[];
  }): string;
  /**
   * Convert from logical coordinate system to pixel coordinate system.
   * See CoordinateSystem#convertToPixel.
   *
   * TODO / PENDING:
   *  currently `convertToPixel` `convertFromPixel` `convertToLayout` may not be suitable
   *  for some extremely performance-sensitive scenarios (such as, handling massive amounts of data),
   *  since it performce "find component" every time.
   *  And it is not friendly to the nuances between different coordinate systems.
   *  @see https://github.com/apache/echarts/issues/20985 for details
   *
   * @see CoordinateSystem['dataToPoint'] for parameters and return.
   * @see CoordinateSystemDataCoord
   */
  convertToPixel(finder: ModelFinder$1, value: ScaleDataValue): number;
  convertToPixel(finder: ModelFinder$1, value: ScaleDataValue[]): number[];
  convertToPixel(finder: ModelFinder$1, value: ScaleDataValue | ScaleDataValue[]): number | number[];
  convertToPixel(finder: ModelFinder$1, value: (ScaleDataValue | ScaleDataValue[] | NullUndefined$1)[]): number | number[];
  /**
   * Convert from logical coordinate system to pixel coordinate system.
   * See CoordinateSystem#convertToPixel.
   *
   * @see CoordinateSystem['dataToLayout'] for parameters and return.
   * @see CoordinateSystemDataCoord
   */
  convertToLayout(finder: ModelFinder$1, value: (ScaleDataValue | NullUndefined$1) | (ScaleDataValue | ScaleDataValue[] | NullUndefined$1)[], opt?: unknown): CoordinateSystemDataLayout;
  /**
   * Convert from pixel coordinate system to logical coordinate system.
   * See CoordinateSystem#convertFromPixel.
   *
   * @see CoordinateSystem['pointToData'] for parameters and return.
   */
  convertFromPixel(finder: ModelFinder$1, value: number): number;
  convertFromPixel(finder: ModelFinder$1, value: number[]): number[];
  convertFromPixel(finder: ModelFinder$1, value: number | number[]): number | number[];
  /**
   * Is the specified coordinate systems or components contain the given pixel point.
   * @param {Array|number} value
   * @return {boolean} result
   */
  containPixel(finder: ModelFinder$1, value: number[]): boolean;
  /**
   * Get visual from series or data.
   * @param finder
   *        If string, e.g., 'series', means {seriesIndex: 0}.
   *        If Object, could contain some of these properties below:
   *        {
   *            seriesIndex / seriesId / seriesName,
   *            dataIndex / dataIndexInside
   *        }
   *        If dataIndex is not specified, series visual will be fetched,
   *        but not data item visual.
   *        If all of seriesIndex, seriesId, seriesName are not specified,
   *        visual will be fetched from first series.
   * @param visualType 'color', 'symbol', 'symbolSize'
   */
  getVisual(finder: ModelFinder$1, visualType: string): string | number | number[] | PatternObject | LinearGradientObject | RadialGradientObject;
  /**
   * Get view of corresponding component model
   */
  private getViewOfComponentModel;
  /**
   * Get view of corresponding series model
   */
  private getViewOfSeriesModel;
  private _initEvents;
  isDisposed(): boolean;
  clear(): void;
  dispose(): void;
  /**
   * Resize the chart
   */
  resize(opts?: ResizeOpts): void;
  /**
   * Show loading effect
   * @param name 'default' by default
   * @param cfg cfg of registered loading effect
   */
  showLoading(cfg?: object): void;
  showLoading(name?: string, cfg?: object): void;
  /**
   * Hide loading effect
   */
  hideLoading(): void;
  makeActionFromEvent(eventObj: ECActionEvent): Payload;
  /**
   * @param opt If pass boolean, means opt.silent
   * @param opt.silent Default `false`. Whether trigger events.
   * @param opt.flush Default `undefined`.
   *        true: Flush immediately, and then pixel in canvas can be fetched
   *            immediately. Caution: it might affect performance.
   *        false: Not flush.
   *        undefined: Auto decide whether perform flush.
   */
  dispatchAction(payload: Payload, opt?: boolean | {
    silent?: boolean;
    flush?: boolean | undefined;
  }): void;
  updateLabelLayout(): void;
  appendData(params: {
    seriesIndex: number;
    data: any;
  }): void;
  private static internalField;
}
/**
 * @param opts.devicePixelRatio Use window.devicePixelRatio by default
 * @param opts.renderer Can choose 'canvas' or 'svg' to render the chart.
 * @param opts.width Use clientWidth of the input `dom` by default.
 *        Can be 'auto' (the same as null/undefined)
 * @param opts.height Use clientHeight of the input `dom` by default.
 *        Can be 'auto' (the same as null/undefined)
 * @param opts.locale Specify the locale.
 * @param opts.useDirtyRect Enable dirty rectangle rendering or not.
 */
interface EChartsType extends ECharts {}
//#endregion
//#region src/types.d.ts
/** Chart event params — duck-typed to work across echarts entry points */
interface ChartEventParams {
  componentType?: string;
  seriesType?: string;
  seriesIndex?: number;
  seriesName?: string;
  name?: string;
  dataIndex?: number;
  data?: unknown;
  dataType?: string;
  value?: unknown;
  color?: string;
  event?: Event;
  [key: string]: unknown;
}
/**
 * Configuration for useChart.
 */
interface UseChartConfig {
  /** ECharts theme — 'dark', a registered theme name, or a theme object */
  theme?: string | Record<string, unknown>;
  /** Renderer — 'canvas' (default, best performance) or 'svg' */
  renderer?: 'canvas' | 'svg';
  /** ECharts locale — 'EN' (default), 'ZH', etc. */
  locale?: string;
  /** Whether to replace all options instead of merging — default: false */
  notMerge?: boolean;
  /** Whether to batch updates — default: true */
  lazyUpdate?: boolean;
  /** Device pixel ratio — default: window.devicePixelRatio */
  devicePixelRatio?: number;
  /** Width override — default: container width */
  width?: number;
  /** Height override — default: container height */
  height?: number;
  /** Called when chart instance is created */
  onInit?: (instance: EChartsType) => void;
}
/**
 * Return type of useChart.
 */
interface UseChartResult {
  /** Bind to container element via ref */
  ref: (el: Element | null) => void;
  /** The ECharts instance — null until mounted and modules loaded */
  instance: Signal<EChartsType | null>;
  /** True while ECharts modules are being dynamically imported */
  loading: Signal<boolean>;
  /** Error signal — set if chart init or setOption throws */
  error: Signal<Error | null>;
  /** Manually trigger resize */
  resize: () => void;
}
/**
 * Props for the <Chart /> component.
 * Generic parameter narrows the option type for exact autocomplete.
 */
interface ChartProps<TOption extends EChartsOption = EChartsOption> extends Props {
  /** Reactive ECharts option config — fully typed */
  options: () => TOption;
  /** ECharts theme */
  theme?: string | Record<string, unknown>;
  /** Renderer — 'canvas' (default) or 'svg' */
  renderer?: 'canvas' | 'svg';
  /** CSS style for the container div */
  style?: string;
  /** CSS class for the container div */
  class?: string;
  /** Click event handler */
  onClick?: (params: ChartEventParams) => void;
  /** Mouseover event handler */
  onMouseover?: (params: ChartEventParams) => void;
  /** Mouseout event handler */
  onMouseout?: (params: ChartEventParams) => void;
}
//#endregion
//#region src/chart-component.d.ts
/**
 * Reactive chart component. Wraps useChart in a div with automatic
 * event binding.
 *
 * @example
 * ```tsx
 * // Default — any chart type
 * <Chart
 *   options={() => ({
 *     series: [{ type: 'bar', data: revenue() }],
 *     tooltip: {},
 *   })}
 *   style="height: 400px"
 * />
 *
 * // Strict — only specific chart types
 * import type { ComposeOption, BarSeriesOption } from '@pyreon/charts'
 * <Chart<ComposeOption<BarSeriesOption>>
 *   options={() => ({
 *     series: [{ type: 'bar', data: revenue() }],
 *   })}
 *   style="height: 400px"
 * />
 * ```
 */
declare function Chart<TOption extends EChartsOption$1 = EChartsOption$1>(props: ChartProps<TOption>): VNodeChild;
//#endregion
//#region src/use-chart.d.ts
/**
 * Reactive ECharts hook. Creates a chart instance bound to a container
 * element, with automatic module lazy-loading, signal tracking, resize
 * handling, error capture, and cleanup.
 *
 * Generic parameter `TOption` narrows the option type for exact autocomplete.
 * Use `ComposeOption<SeriesUnion>` from ECharts to restrict to specific chart types.
 *
 * @example
 * ```tsx
 * // Default — accepts any ECharts option
 * const chart = useChart(() => ({
 *   series: [{ type: 'bar', data: revenue() }],
 * }))
 *
 * // Strict — only bar + line allowed, full autocomplete
 * import type { ComposeOption, BarSeriesOption, LineSeriesOption } from '@pyreon/charts'
 * type MyChartOption = ComposeOption<BarSeriesOption | LineSeriesOption>
 *
 * const chart = useChart<MyChartOption>(() => ({
 *   series: [{ type: 'bar', data: revenue() }],  // ✓
 * }))
 * ```
 */
declare function useChart<TOption extends EChartsOption$1 = EChartsOption$1>(optionsFn: () => TOption, config?: UseChartConfig): UseChartResult;
//#endregion
export { type BarSeriesOption, type BoxplotSeriesOption, type CandlestickSeriesOption, Chart, type ChartEventParams, type ChartProps, type ComposeOption, type DataZoomComponentOption, type EChartsType as ECharts, type EChartsOption, type FunnelSeriesOption, type GaugeSeriesOption, type GraphSeriesOption, type GridComponentOption, type HeatmapSeriesOption, type LegendComponentOption, type LineSeriesOption, type PieSeriesOption, type RadarSeriesOption, type SankeySeriesOption, type ScatterSeriesOption, type SetOptionOpts, type SunburstSeriesOption, type TitleComponentOption, type ToolboxComponentOption, type TooltipComponentOption, type TreeSeriesOption, type TreemapSeriesOption, type UseChartConfig, type UseChartResult, type VisualMapComponentOption, useChart };
//# sourceMappingURL=index2.d.ts.map