@timescope/vue 0.0.0-alpha.4 → 0.0.0-alpha.6

package/index.d.ts

@@ -1,15 +1,1790 @@
-import * as timescope0 from "timescope";
-import { Decimal, Decimal as Decimal$1, FieldDefLike, Timescope, TimescopeNumberLike, TimescopeOptionsInitial, TimescopeOptionsSelection, TimescopeOptionsSeries, TimescopeOptionsSources, TimescopeOptionsTracks, TimescopeSourceInput, TimescopeTimeLike } from "timescope";
-import * as vue0 from "vue";
+//#region ../../node_modules/.pnpm/@kikuchan+decimal@0.1.0-alpha.4/node_modules/@kikuchan/decimal/index.d.ts
+//#region src/index.d.ts
+declare const __brand: unique symbol;
+interface DecimalInstance {
+  readonly [__brand]: never;
+}
+type DecimalLike = number | string | bigint | DecimalInstance | {
+  coeff: bigint;
+  digits: bigint;
+};
+type RoundingMode = 'trunc' | 'floor' | 'ceil' | 'round';
+interface Decimal {
+  readonly [__brand]: never;
+  coeff: bigint;
+  digits: bigint;
+  clone(): Decimal;
+  round$(digits?: bigint | number, force?: boolean): this;
+  round(digits?: bigint | number, force?: boolean): Decimal;
+  floor$(digits?: bigint | number, force?: boolean): this;
+  floor(digits?: bigint | number, force?: boolean): Decimal;
+  ceil$(digits?: bigint | number, force?: boolean): this;
+  ceil(digits?: bigint | number, force?: boolean): Decimal;
+  trunc$(digits?: bigint | number, force?: boolean): this;
+  trunc(digits?: bigint | number, force?: boolean): Decimal;
+  rescale$(digits?: bigint | number, mode?: RoundingMode): this;
+  rescale(digits?: bigint | number, mode?: RoundingMode): Decimal;
+  roundBy$(step: DecimalLike, mode?: RoundingMode): this;
+  roundBy(step: DecimalLike, mode?: RoundingMode): Decimal;
+  floorBy$(step: DecimalLike): this;
+  floorBy(step: DecimalLike): Decimal;
+  ceilBy$(step: DecimalLike): this;
+  ceilBy(step: DecimalLike): Decimal;
+  truncBy$(step: DecimalLike): this;
+  truncBy(step: DecimalLike): Decimal;
+  split$(digits?: bigint | number, mode?: RoundingMode): [Decimal, Decimal];
+  split(digits?: bigint | number, mode?: RoundingMode): [Decimal, Decimal];
+  splitBy$(step: DecimalLike, mode?: RoundingMode): [Decimal, Decimal];
+  splitBy(step: DecimalLike, mode?: RoundingMode): [Decimal, Decimal];
+  neg$(flag?: boolean): this;
+  neg(flag?: boolean): Decimal;
+  abs$(): this;
+  abs(): Decimal;
+  sign$(): this;
+  sign(): Decimal;
+  isZero(): boolean;
+  isPositive(): boolean;
+  isNegative(): boolean;
+  add$(v: DecimalLike): this;
+  add(v: DecimalLike): Decimal;
+  sub$(v: DecimalLike): this;
+  sub(v: DecimalLike): Decimal;
+  mul$(v: DecimalLike, digits?: number | bigint | undefined): Decimal;
+  mul(v: DecimalLike, digits?: number | bigint | undefined): Decimal;
+  shift10$(exponent: bigint | number): this;
+  shift10(exponent: bigint | number): Decimal;
+  inverse$(digits?: bigint | number): this;
+  inverse(digits?: bigint | number): Decimal;
+  div$(v: DecimalLike, digits?: bigint | number, mode?: RoundingMode): this;
+  div(v: DecimalLike, digits?: bigint | number): Decimal;
+  mod$(v: DecimalLike): this;
+  mod(v: DecimalLike): Decimal;
+  modPositive$(v: DecimalLike): this;
+  modPositive(v: DecimalLike): Decimal;
+  clamp$(minValue: DecimalLike | undefined, maxValue: DecimalLike | undefined): this;
+  clamp(minValue: DecimalLike | undefined, maxValue: DecimalLike | undefined): Decimal;
+  cmp(v: DecimalLike): number;
+  eq(v: DecimalLike): boolean;
+  neq(v: DecimalLike): boolean;
+  lt(v: DecimalLike): boolean;
+  gt(v: DecimalLike): boolean;
+  le(v: DecimalLike): boolean;
+  ge(v: DecimalLike): boolean;
+  between(a: DecimalLike | undefined, b: DecimalLike | undefined): boolean;
+  isCloseTo(v: DecimalLike, tolerance: DecimalLike): boolean;
+  pow$(exponent: DecimalLike, digits?: bigint | number): this;
+  pow(exponent: DecimalLike, digits?: bigint | number): Decimal;
+  root$(degree: bigint | number, digits?: bigint | number): this;
+  root(degree: bigint | number, digits?: bigint | number): Decimal;
+  sqrt$(digits?: bigint | number): this;
+  sqrt(digits?: bigint | number): Decimal;
+  log$(base: DecimalLike, digits?: bigint | number): this;
+  log(base: DecimalLike, digits?: bigint | number): Decimal;
+  order(): bigint;
+  toString(): string;
+  toFixed(fractionDigits: bigint | number): string;
+  number(): number;
+  integer(): bigint;
+}
+declare function Decimal(v: null): null;
+declare function Decimal(v: undefined): undefined;
+declare function Decimal(v: DecimalLike): Decimal;
+declare function Decimal(v: DecimalLike | null): Decimal | null;
+declare function Decimal(v: DecimalLike | undefined): Decimal | undefined;
+declare function Decimal(v: DecimalLike | undefined | null): Decimal | undefined | null;
+declare namespace Decimal {
+  function isDecimal(v: unknown): v is Decimal;
+  function isDecimalLike(v: unknown): v is DecimalLike;
+  function pow10(n: bigint | number): Decimal;
+  function minmax(...values: (DecimalLike | null | undefined)[]): [Decimal | null, Decimal | null];
+  function min(...values: (DecimalLike | null | undefined)[]): Decimal | null;
+  function max(...values: (DecimalLike | null | undefined)[]): Decimal | null;
+}
+//#endregion
+//#region ../timescope/src/core/decimal.d.ts
+type NumberLike = string | bigint | number | DecimalInstance;
+//#endregion
+//#region ../timescope/src/core/range.d.ts
+type TimescopeRange<T> = [T, T];
+//#endregion
+//#region ../timescope/src/core/chunk.d.ts
+/**
+ * Minimal descriptor for a data chunk (no payload).
+ */
+type TimescopeDataChunkDesc = {
+  /** Chunk id string. */
+  id: string;
+  /** Sequence number (monotonic along time). */
+  seq: bigint;
+  /** Expiration timestamp (ms). */
+  expires?: number;
+  /** Time range covered by this chunk. */
+  range: TimescopeRange<Decimal | undefined>;
+  /** Resolution in milliseconds per sample. */
+  resolution: Decimal;
+  /** Zoom level. */
+  zoom: number;
+};
+type TimescopeDataChunkLoaderApi = {
+  expiresAt: (t: number) => void;
+  expiresIn: (t: number) => void;
+};
+/**
+ * Loader function that receives a chunk descriptor and returns its payload.
+ */
+type TimescopeDataChunkLoader<T> = (chunk: TimescopeDataChunkDesc, api: TimescopeDataChunkLoaderApi) => Promise<T | undefined>;
+//#endregion
+//#region ../timescope/src/core/animation.d.ts
+type TimescopeAnimationType = 'in-out' | 'linear' | 'out';
+type TimescopeAnimationInput = false | TimescopeAnimationType | {
+  animation: TimescopeAnimationType | false;
+  duration: number;
+  lazy?: boolean;
+};
+//#endregion
+//#region ../timescope/src/bridge/protocol.d.ts
+type TimescopeFont = {
+  family: string;
+  source: string | BufferSource;
+  desc?: FontFaceDescriptors;
+};
+//#endregion
+//#region ../timescope/src/core/style.d.ts
+type TextStyleOptions = {
+  color?: string;
+  fontWeight?: string;
+  fontSize?: string;
+  fontFamily?: string;
+};
+type TimescopeStyle = {
+  width?: string;
+  height?: string;
+  background?: string;
+};
+//#endregion
+//#region ../timescope/src/core/time.d.ts
+type TimeLike<N extends null | undefined = null> = string | Date | NumberLike | N;
+type TimeUnit = 's' | 'ms' | 'us' | 'ns';
+//#endregion
+//#region ../timescope/src/core/zoom.d.ts
+type ZoomLike = NumberLike;
+//#endregion
+//#region ../timescope/src/core/TimescopeState.d.ts
+interface TimescopeStateOptions {
+  time?: TimeLike;
+  timeRange?: TimescopeRange<TimeLike | null | undefined>;
+  zoom?: ZoomLike;
+  zoomRange?: TimescopeRange<ZoomLike | undefined>;
+}
+//#endregion
+//#region ../timescope/src/core/types.d.ts
+type MaybeFn<R$1, T> = T extends unknown[] ? ((...args: T) => R$1) | R$1 : R$1;
+type UsingElement<V$1 extends [string, string]> = `${V$1[1]}@${V$1[0]}` | V$1[1] | `@${V$1[0]}`;
+type Using1<V$1 extends [string, string]> = UsingElement<V$1> | [UsingElement<V$1>];
+type Using2<V$1 extends [string, string]> = [UsingElement<V$1>, UsingElement<V$1>];
+type StrokeStyle<T = false> = {
+  lineWidth?: MaybeFn<number, T>;
+  lineColor?: MaybeFn<string, T>;
+  lineDashArray?: MaybeFn<number[], T>;
+  lineDashOffset?: MaybeFn<number, T>;
+};
+type FillStyle<T = false> = {
+  fillColor?: MaybeFn<string, T>;
+  fillOpacity?: MaybeFn<number, T>;
+  fillPost?: boolean;
+};
+type SizeStyle<T = false> = {
+  size?: MaybeFn<number, T>;
+};
+type AngleStyle<T = false> = {
+  angle?: MaybeFn<number, T>;
+};
+type PathStyle<T = false> = {
+  path?: MaybeFn<string, T>;
+  origin?: [number, number];
+  scale?: number;
+};
+type TextStyle<T = false> = {
+  fontWeight?: MaybeFn<string, T>;
+  fontFamily?: MaybeFn<string, T>;
+  textAlign?: MaybeFn<'start' | 'center' | 'end' | 'left' | 'right', T>;
+  textBaseline?: MaybeFn<'top' | 'middle' | 'bottom' | 'hanging' | 'alphabetic' | 'ideographic', T>;
+  textColor?: MaybeFn<string, T>;
+  textOpacity?: MaybeFn<number, T>;
+  textOutline?: MaybeFn<boolean, T>;
+  textOutlineColor?: MaybeFn<string, T>;
+  textOutlineWidth?: MaybeFn<number, T>;
+  text?: MaybeFn<string, T>;
+};
+type IconStyle<T = false> = {
+  iconFontWeight?: MaybeFn<string, T>;
+  iconFontFamily?: MaybeFn<string, T>;
+  iconAlign?: MaybeFn<'start' | 'center' | 'end' | 'left' | 'right', T>;
+  iconBaseline?: MaybeFn<'top' | 'middle' | 'bottom' | 'hanging' | 'alphabetic' | 'ideographic', T>;
+  iconColor?: MaybeFn<string, T>;
+  iconOpacity?: MaybeFn<number, T>;
+  iconOutline?: MaybeFn<boolean, T>;
+  iconOutlineColor?: MaybeFn<string, T>;
+  iconOutlineWidth?: MaybeFn<number, T>;
+  icon?: MaybeFn<string, T>;
+};
+type BoxStyle<T = false> = {
+  padding?: MaybeFn<number | [number, number?, number?, number?], T>;
+  radius?: MaybeFn<number, T>;
+};
+type OffsetStyle<T = false> = {
+  offset?: MaybeFn<[number, number], T>;
+};
+type TimescopeChartStyleEntry<D$1 extends string, U$1 extends boolean, S, T extends unknown[] | false, V$1 extends [string, string]> = {
+  draw: MaybeFn<D$1, T>;
+  using?: MaybeFn<U$1 extends true ? Using2<V$1> : Using1<V$1>, T>;
+  style?: MaybeFn<S, T>;
+};
+type TimescopeChartMark<T extends unknown[] | false, V$1 extends [string, string] = [string, string]> = TimescopeChartStyleEntry<'circle', false, StrokeStyle<T> & FillStyle<T> & SizeStyle<T> & OffsetStyle<T>, T, V$1> | TimescopeChartStyleEntry<'triangle' | 'square' | 'diamond' | 'star', false, StrokeStyle<T> & FillStyle<T> & SizeStyle<T> & AngleStyle<T> & OffsetStyle<T>, T, V$1> | TimescopeChartStyleEntry<'plus' | 'cross' | 'minus', false, StrokeStyle<T> & SizeStyle<T> & AngleStyle<T> & OffsetStyle<T>, T, V$1> | TimescopeChartStyleEntry<'text', false, SizeStyle<T> & AngleStyle<T> & TextStyle<T> & OffsetStyle<T>, T, V$1> | TimescopeChartStyleEntry<'icon', false, SizeStyle<T> & AngleStyle<T> & IconStyle<T> & OffsetStyle<T>, T, V$1> | TimescopeChartStyleEntry<'path', false, SizeStyle<T> & AngleStyle<T> & PathStyle<T> & OffsetStyle<T>, T, V$1> | TimescopeChartStyleEntry<'line', true, StrokeStyle<T> & SizeStyle<T> & OffsetStyle<T>, T, V$1> | TimescopeChartStyleEntry<'section', true, StrokeStyle<T> & SizeStyle<T> & OffsetStyle<T>, T, V$1> | TimescopeChartStyleEntry<'box', true, StrokeStyle<T> & FillStyle<T> & SizeStyle<T> & BoxStyle<T> & OffsetStyle<T>, T, V$1>;
+type TimescopeChartLink<T extends unknown[] | false, V$1 extends [string, string] = [string, string]> = TimescopeChartStyleEntry<'line' | 'curve' | 'step' | 'step-start' | 'step-end', false, StrokeStyle<T>, T, V$1> | TimescopeChartStyleEntry<'area' | 'curve-area' | 'step-area' | 'step-area-start' | 'step-area-end', true, StrokeStyle<T> & FillStyle<T>, T, V$1>;
+type TimescopeChartType = 'lines' | 'lines:filled' | 'curves' | 'curves:filled' | 'steps-start' | 'steps-start:filled' | 'steps' | 'steps:filled' | 'steps-end' | 'steps-end:filled' | 'points' | 'linespoints' | 'linespoints:filled' | 'curvespoints' | 'curvespoints:filled' | 'stepspoints-start' | 'stepspoints-start:filled' | 'stepspoints' | 'stepspoints:filled' | 'stepspoints-end' | 'stepspoints-end:filled' | 'impulses' | 'impulsespoints' | 'boxes' | 'boxes:filled';
+type CalendarLevel = 'subsecond' | 'second' | 'minute' | 'hour' | 'day' | 'month' | 'year' | 'relative';
+type TimeFormatFuncOptions = {
+  time: Decimal;
+  unit: TimeUnit;
+  level: CalendarLevel;
+  digits: number;
+  stride?: bigint;
+};
+type TimeFormatFunc = (opts: TimeFormatFuncOptions) => string | undefined;
+interface TimescopeSourceCommonOptions {
+  /** Available zoom levels used to quantize resolution. */
+  zoomLevels?: number[];
+  /** Number of samples per chunk for tiled loading. */
+  chunkSize?: number;
+}
+type TimescopeSourceOptions = TimescopeSourceCommonOptions & ({
+  url: string;
+} | {
+  data: unknown;
+} | {
+  loader: TimescopeDataChunkLoader<unknown>;
+});
+type TimescopeSourceInput = string | unknown[] | object | TimescopeDataChunkLoader<unknown> | TimescopeSourceOptions;
+type InferTimeKey<T> = T extends string[] ? T[number] : T extends Record<string, unknown> ? keyof T : 'time';
+type InferValueKey<T> = T extends string[] ? T[number] : T extends Record<string, unknown> ? keyof T : 'value';
+type InferSourceType<S> = S extends unknown[] ? S : S extends TimescopeDataChunkLoader<infer X> ? X : S extends {
+  url: string;
+} ? unknown : S extends string ? unknown : S extends {
+  data: infer X;
+} ? X : S extends {
+  loader: TimescopeDataChunkLoader<infer X>;
+} ? X : S;
+type FieldDefLike<D$1> = string | string[] | Record<string, string | ((data: Record<string, any>) => D$1)>;
+type TimescopeSeriesInput<Source extends Record<string, TimescopeSourceInput>, SourceName extends keyof Source, TimeDef extends FieldDefLike<TimeLike<never>>, ValueDef extends FieldDefLike<NumberLike | null>, Track extends string> = {
+  data: {
+    source: SourceName;
+    parser?: (...args: [InferSourceType<Source[SourceName]>]) => Record<string, any>[];
+    time?: TimeDef;
+    value?: ValueDef;
+    name?: string;
+    unit?: string;
+    digits?: number;
+    color?: string;
+    scale?: 'linear' | 'log';
+    range?: NumberLike | TimescopeRange<NumberLike | undefined> | {
+      expand?: boolean;
+      shrink?: boolean;
+      default?: NumberLike | TimescopeRange<NumberLike | undefined>;
+    };
+    instantaneous?: {
+      using?: Using1<[InferTimeKey<TimeDef>, InferValueKey<ValueDef>]>;
+      zoom?: number;
+    };
+  };
+  chart?: TimescopeChartType | {
+    marks?: MaybeFn<TimescopeChartMark<[{
+      resolution: Decimal;
+      data: Record<string, any>;
+      time: Record<InferTimeKey<TimeDef>, Decimal>;
+      value: Record<InferValueKey<ValueDef>, Decimal | null>;
+    }], [InferTimeKey<TimeDef>, InferValueKey<ValueDef>]>[], [{
+      resolution: Decimal;
+      data: Record<string, any>;
+      time: Record<InferTimeKey<TimeDef>, Decimal>;
+      value: Record<InferValueKey<ValueDef>, Decimal | null>;
+    }]>;
+    links?: MaybeFn<TimescopeChartLink<[opts: {
+      resolution: Decimal;
+    }], [InferTimeKey<TimeDef>, InferValueKey<ValueDef>]>[], [opts: {
+      resolution: Decimal;
+    }]>;
+  };
+  tooltip?: boolean | {
+    label?: string;
+    format?: () => string;
+  };
+  yAxis?: boolean | 'left' | 'right' | {
+    side?: 'left' | 'right';
+    label?: string;
+  };
+  track?: Track;
+};
+type TimescopeOptionsSources<Source extends Record<string, TimescopeSourceInput>> = { [K in keyof Source]: Source[K] };
+type TimescopeOptionsSeries<Source extends Record<string, TimescopeSourceInput>, SourceName extends Record<string, keyof Source>, TimeDef extends Record<string, FieldDefLike<TimeLike<never>>>, ValueDef extends Record<string, FieldDefLike<NumberLike | null>>, Track extends string> = { [K in keyof SourceName & keyof TimeDef & keyof ValueDef]: TimescopeSeriesInput<Source, SourceName[K] & string, TimeDef[K], ValueDef[K], Track> };
+type TimeFormatLabelerOptions = {
+  year: bigint;
+  quarter: number;
+  month: number;
+  day: number;
+  hour: number;
+  minute: number;
+  second: bigint;
+  subseconds: Decimal;
+  time: Decimal;
+  week: number;
+  digits: number;
+};
+type TimeFormatLabeler = {
+  year?: (opts: TimeFormatLabelerOptions) => string;
+  month?: (opts: TimeFormatLabelerOptions) => string;
+  quarter?: (opts: TimeFormatLabelerOptions) => string;
+  date?: (opts: TimeFormatLabelerOptions) => string;
+  minutes?: (opts: TimeFormatLabelerOptions) => string;
+  seconds?: (opts: TimeFormatLabelerOptions) => string;
+};
+type TimescopeTimeAxisOptions = {
+  axis?: false | {
+    color?: string;
+  };
+  ticks?: false | {
+    color?: string;
+  };
+  labels?: false | TextStyleOptions;
+  relative?: boolean;
+  timeFormat?: TimeFormatFunc | TimeFormatLabeler;
+  timeUnit?: 's' | 'ms' | 'us' | 'ns';
+};
+type TimescopeOptionsTracks<Track extends string> = { [K in Track]: {
+  height?: number;
+  symmetric?: boolean;
+  timeAxis?: TimescopeTimeAxisOptions | boolean;
+} };
+type TimescopeOptionsSelection = boolean | {
+  resizable?: boolean;
+  color?: string;
+  invert?: boolean;
+  range?: TimescopeRange<Decimal | undefined> | null;
+};
+type TimescopeOptions<Source extends Record<string, TimescopeSourceInput> = Record<string, TimescopeSourceInput>, SourceName extends Record<string, keyof Source> = Record<string, keyof Source>, TimeDef extends Record<string, FieldDefLike<TimeLike<never>>> = Record<string, FieldDefLike<TimeLike<never>>>, ValueDef extends Record<string, FieldDefLike<NumberLike | null>> = Record<string, FieldDefLike<NumberLike | null>>, Track extends string = string> = {
+  style?: TimescopeStyle;
+  showFps?: boolean;
+  padding?: readonly number[];
+  indicator?: boolean;
+  sources?: TimescopeOptionsSources<Source>;
+  series?: TimescopeOptionsSeries<Source, SourceName, TimeDef, ValueDef, Track>;
+  tracks?: TimescopeOptionsTracks<Track>;
+  selection?: TimescopeOptionsSelection;
+};
+interface TimescopeOptionsInitial<Source extends Record<string, TimescopeSourceInput>, SourceName extends Record<string, keyof Source>, TimeDef extends Record<string, FieldDefLike<TimeLike<never>>>, ValueDef extends Record<string, FieldDefLike<NumberLike | null>>, Track extends string> extends TimescopeOptions<Source, SourceName, TimeDef, ValueDef, Track>, TimescopeStateOptions {
+  target?: HTMLElement | string;
+  fonts?: (string | TimescopeFont)[];
+  wheelSensitivity?: number;
+}
+//#endregion
+//#region ../timescope/src/main/Timescope.d.ts
+type TimescopeFitOptions = {
+  animation?: boolean;
+  padding?: number | [l: number, r: number];
+};
+//#endregion
+//#region ../../node_modules/.pnpm/@vue+shared@3.5.26/node_modules/@vue/shared/dist/shared.d.ts
+type Prettify<T> = { [K in keyof T]: T[K] } & {};
+type UnionToIntersection<U$1> = (U$1 extends any ? (k: U$1) => void : never) extends ((k: infer I) => void) ? I : never;
+type LooseRequired<T> = { [P in keyof (T & Required<T>)]: T[P] };
+type IfAny<T, Y, N> = 0 extends 1 & T ? Y : N;
+//#endregion
+//#region ../../node_modules/.pnpm/@vue+reactivity@3.5.26/node_modules/@vue/reactivity/dist/reactivity.d.ts
+declare enum TrackOpTypes {
+  GET = "get",
+  HAS = "has",
+  ITERATE = "iterate",
+}
+declare enum TriggerOpTypes {
+  SET = "set",
+  ADD = "add",
+  DELETE = "delete",
+  CLEAR = "clear",
+}
+type UnwrapNestedRefs<T> = T extends Ref ? T : UnwrapRefSimple<T>;
+declare const ShallowReactiveMarker: unique symbol;
+type Primitive = string | number | boolean | bigint | symbol | undefined | null;
+type Builtin = Primitive | Function | Date | Error | RegExp;
+type EffectScheduler = (...args: any[]) => any;
+type DebuggerEvent = {
+  effect: Subscriber;
+} & DebuggerEventExtraInfo;
+type DebuggerEventExtraInfo = {
+  target: object;
+  type: TrackOpTypes | TriggerOpTypes;
+  key: any;
+  newValue?: any;
+  oldValue?: any;
+  oldTarget?: Map<any, any> | Set<any>;
+};
+interface DebuggerOptions {
+  onTrack?: (event: DebuggerEvent) => void;
+  onTrigger?: (event: DebuggerEvent) => void;
+}
+interface ReactiveEffectOptions extends DebuggerOptions {
+  scheduler?: EffectScheduler;
+  allowRecurse?: boolean;
+  onStop?: () => void;
+}
+/**
+ * Subscriber is a type that tracks (or subscribes to) a list of deps.
+ */
+interface Subscriber extends DebuggerOptions {}
+declare class ReactiveEffect<T = any> implements Subscriber, ReactiveEffectOptions {
+  fn: () => T;
+  scheduler?: EffectScheduler;
+  onStop?: () => void;
+  onTrack?: (event: DebuggerEvent) => void;
+  onTrigger?: (event: DebuggerEvent) => void;
+  constructor(fn: () => T);
+  pause(): void;
+  resume(): void;
+  run(): T;
+  stop(): void;
+  trigger(): void;
+  get dirty(): boolean;
+}
+type ComputedGetter<T> = (oldValue?: T) => T;
+type ComputedSetter<T> = (newValue: T) => void;
+interface WritableComputedOptions<T, S = T> {
+  get: ComputedGetter<T>;
+  set: ComputedSetter<S>;
+}
+declare const RefSymbol: unique symbol;
+declare const RawSymbol: unique symbol;
+interface Ref<T = any, S = T> {
+  get value(): T;
+  set value(_: S);
+  /**
+   * Type differentiator only.
+   * We need this to be in public d.ts but don't want it to show up in IDE
+   * autocomplete, so we use a private Symbol instead.
+   */
+  [RefSymbol]: true;
+}
+declare const ShallowRefMarker: unique symbol;
+type ShallowRef<T = any, S = T> = Ref<T, S> & {
+  [ShallowRefMarker]?: true;
+};
+/**
+ * This is a special exported interface for other packages to declare
+ * additional types that should bail out for ref unwrapping. For example
+ * \@vue/runtime-dom can declare it like so in its d.ts:
+ *
+ * ``` ts
+ * declare module '@vue/reactivity' {
+ *   export interface RefUnwrapBailTypes {
+ *     runtimeDOMBailTypes: Node | Window
+ *   }
+ * }
+ * ```
+ */
+interface RefUnwrapBailTypes {}
+type ShallowUnwrapRef<T> = { [K in keyof T]: DistributeRef<T[K]> };
+type DistributeRef<T> = T extends Ref<infer V, unknown> ? V : T;
+type UnwrapRef<T> = T extends ShallowRef<infer V, unknown> ? V : T extends Ref<infer V, unknown> ? UnwrapRefSimple<V> : UnwrapRefSimple<T>;
+type UnwrapRefSimple<T> = T extends Builtin | Ref | RefUnwrapBailTypes[keyof RefUnwrapBailTypes] | {
+  [RawSymbol]?: true;
+} ? T : T extends Map<infer K, infer V> ? Map<K, UnwrapRefSimple<V>> & UnwrapRef<Omit<T, keyof Map<any, any>>> : T extends WeakMap<infer K, infer V> ? WeakMap<K, UnwrapRefSimple<V>> & UnwrapRef<Omit<T, keyof WeakMap<any, any>>> : T extends Set<infer V> ? Set<UnwrapRefSimple<V>> & UnwrapRef<Omit<T, keyof Set<any>>> : T extends WeakSet<infer V> ? WeakSet<UnwrapRefSimple<V>> & UnwrapRef<Omit<T, keyof WeakSet<any>>> : T extends ReadonlyArray<any> ? { [K in keyof T]: UnwrapRefSimple<T[K]> } : T extends object & {
+  [ShallowReactiveMarker]?: never;
+} ? { [P in keyof T]: P extends symbol ? T[P] : UnwrapRef<T[P]> } : T;
+type WatchCallback<V$1 = any, OV = any> = (value: V$1, oldValue: OV, onCleanup: OnCleanup) => any;
+type OnCleanup = (cleanupFn: () => void) => void;
+type WatchStopHandle = () => void;
+//#endregion
+//#region ../../node_modules/.pnpm/@vue+runtime-core@3.5.26/node_modules/@vue/runtime-core/dist/runtime-core.d.ts
+type Slot<T extends any = any> = (...args: IfAny<T, any[], [T] | (T extends undefined ? [] : never)>) => VNode[];
+type InternalSlots = {
+  [name: string]: Slot | undefined;
+};
+type Slots = Readonly<InternalSlots>;
+declare const SlotSymbol: unique symbol;
+type SlotsType<T extends Record<string, any> = Record<string, any>> = {
+  [SlotSymbol]?: T;
+};
+type StrictUnwrapSlotsType<S extends SlotsType, T = NonNullable<S[typeof SlotSymbol]>> = [keyof S] extends [never] ? Slots : Readonly<T> & T;
+type UnwrapSlotsType<S extends SlotsType, T = NonNullable<S[typeof SlotSymbol]>> = [keyof S] extends [never] ? Slots : Readonly<Prettify<{ [K in keyof T]: NonNullable<T[K]> extends ((...args: any[]) => any) ? T[K] : Slot<T[K]> }>>;
+type RawSlots = {
+  [name: string]: unknown;
+  $stable?: boolean;
+};
+declare enum SchedulerJobFlags {
+  QUEUED = 1,
+  PRE = 2,
+  /**
+   * Indicates whether the effect is allowed to recursively trigger itself
+   * when managed by the scheduler.
+   *
+   * By default, a job cannot trigger itself because some built-in method calls,
+   * e.g. Array.prototype.push actually performs reads as well (#1740) which
+   * can lead to confusing infinite loops.
+   * The allowed cases are component update functions and watch callbacks.
+   * Component update functions may update child component props, which in turn
+   * trigger flush: "pre" watch callbacks that mutates state that the parent
+   * relies on (#1801). Watch callbacks doesn't track its dependencies so if it
+   * triggers itself again, it's likely intentional and it is the user's
+   * responsibility to perform recursive state mutation that eventually
+   * stabilizes (#1727).
+   */
+  ALLOW_RECURSE = 4,
+  DISPOSED = 8,
+}
+interface SchedulerJob extends Function {
+  id?: number;
+  /**
+   * flags can technically be undefined, but it can still be used in bitwise
+   * operations just like 0.
+   */
+  flags?: SchedulerJobFlags;
+  /**
+   * Attached by renderer.ts when setting up a component's render effect
+   * Used to obtain component information when reporting max recursive updates.
+   */
+  i?: ComponentInternalInstance;
+}
+declare function nextTick(): Promise<void>;
+declare function nextTick<T, R$1>(this: T, fn: (this: T) => R$1 | Promise<R$1>): Promise<R$1>;
+type ComponentPropsOptions<P$1 = Data> = ComponentObjectPropsOptions<P$1> | string[];
+type ComponentObjectPropsOptions<P$1 = Data> = { [K in keyof P$1]: Prop<P$1[K]> | null };
+type Prop<T, D$1 = T> = PropOptions<T, D$1> | PropType<T>;
+type DefaultFactory<T> = (props: Data) => T | null | undefined;
+interface PropOptions<T = any, D$1 = T> {
+  type?: PropType<T> | true | null;
+  required?: boolean;
+  default?: D$1 | DefaultFactory<D$1> | null | undefined | object;
+  validator?(value: unknown, props: Data): boolean;
+}
+type PropType<T> = PropConstructor<T> | (PropConstructor<T> | null)[];
+type PropConstructor<T = any> = {
+  new (...args: any[]): T & {};
+} | {
+  (): T;
+} | PropMethod<T>;
+type PropMethod<T, TConstructor = any> = [T] extends [((...args: any) => any) | undefined] ? {
+  new (): TConstructor;
+  (): T;
+  readonly prototype: TConstructor;
+} : never;
+type RequiredKeys<T> = { [K in keyof T]: T[K] extends {
+  required: true;
+} | {
+  default: any;
+} | BooleanConstructor | {
+  type: BooleanConstructor;
+} ? T[K] extends {
+  default: undefined | (() => undefined);
+} ? never : K : never }[keyof T];
+type OptionalKeys<T> = Exclude<keyof T, RequiredKeys<T>>;
+type DefaultKeys<T> = { [K in keyof T]: T[K] extends {
+  default: any;
+} | BooleanConstructor | {
+  type: BooleanConstructor;
+} ? T[K] extends {
+  type: BooleanConstructor;
+  required: true;
+} ? never : K : never }[keyof T];
+type InferPropType<T, NullAsAny = true> = [T] extends [null] ? NullAsAny extends true ? any : null : [T] extends [{
+  type: null | true;
+}] ? any : [T] extends [ObjectConstructor | {
+  type: ObjectConstructor;
+}] ? Record<string, any> : [T] extends [BooleanConstructor | {
+  type: BooleanConstructor;
+}] ? boolean : [T] extends [DateConstructor | {
+  type: DateConstructor;
+}] ? Date : [T] extends [(infer U)[] | {
+  type: (infer U)[];
+}] ? U extends DateConstructor ? Date | InferPropType<U, false> : InferPropType<U, false> : [T] extends [Prop<infer V, infer D>] ? unknown extends V ? keyof V extends never ? IfAny<V, V, D> : V : V : T;
+/**
+ * Extract prop types from a runtime props options object.
+ * The extracted types are **internal** - i.e. the resolved props received by
+ * the component.
+ * - Boolean props are always present
+ * - Props with default values are always present
+ *
+ * To extract accepted props from the parent, use {@link ExtractPublicPropTypes}.
+ */
+type ExtractPropTypes<O> = { [K in keyof Pick<O, RequiredKeys<O>>]: O[K] extends {
+  default: any;
+} ? Exclude<InferPropType<O[K]>, undefined> : InferPropType<O[K]> } & { [K in keyof Pick<O, OptionalKeys<O>>]?: InferPropType<O[K]> };
+type ExtractDefaultPropTypes<O> = O extends object ? { [K in keyof Pick<O, DefaultKeys<O>>]: InferPropType<O[K]> } : {};
+/**
+ * Vue `<script setup>` compiler macro for declaring component props. The
+ * expected argument is the same as the component `props` option.
+ *
+ * Example runtime declaration:
+ * ```js
+ * // using Array syntax
+ * const props = defineProps(['foo', 'bar'])
+ * // using Object syntax
+ * const props = defineProps({
+ *   foo: String,
+ *   bar: {
+ *     type: Number,
+ *     required: true
+ *   }
+ * })
+ * ```
+ *
+ * Equivalent type-based declaration:
+ * ```ts
+ * // will be compiled into equivalent runtime declarations
+ * const props = defineProps<{
+ *   foo?: string
+ *   bar: number
+ * }>()
+ * ```
+ *
+ * @see {@link https://vuejs.org/api/sfc-script-setup.html#defineprops-defineemits}
+ *
+ * This is only usable inside `<script setup>`, is compiled away in the
+ * output and should **not** be actually called at runtime.
+ */
+declare function defineProps<PropNames extends string = string>(props: PropNames[]): Prettify<Readonly<{ [key in PropNames]?: any }>>;
+declare function defineProps<PP extends ComponentObjectPropsOptions = ComponentObjectPropsOptions>(props: PP): Prettify<Readonly<ExtractPropTypes<PP>>>;
+declare function defineProps<TypeProps>(): DefineProps<LooseRequired<TypeProps>, BooleanKey<TypeProps>>;
+type DefineProps<T, BKeys extends keyof T> = Readonly<T> & { readonly [K in BKeys]-?: boolean };
+type BooleanKey<T, K$1 extends keyof T = keyof T> = K$1 extends any ? T[K$1] extends boolean | undefined ? T[K$1] extends never | undefined ? never : K$1 : never : never;
+/**
+ * Vue `<script setup>` compiler macro for declaring a component's emitted
+ * events. The expected argument is the same as the component `emits` option.
+ *
+ * Example runtime declaration:
+ * ```js
+ * const emit = defineEmits(['change', 'update'])
+ * ```
+ *
+ * Example type-based declaration:
+ * ```ts
+ * const emit = defineEmits<{
+ *   // <eventName>: <expected arguments>
+ *   change: []
+ *   update: [value: number] // named tuple syntax
+ * }>()
+ *
+ * emit('change')
+ * emit('update', 1)
+ * ```
+ *
+ * This is only usable inside `<script setup>`, is compiled away in the
+ * output and should **not** be actually called at runtime.
+ *
+ * @see {@link https://vuejs.org/api/sfc-script-setup.html#defineprops-defineemits}
+ */
+declare function defineEmits<EE extends string = string>(emitOptions: EE[]): EmitFn<EE[]>;
+declare function defineEmits<E extends EmitsOptions = EmitsOptions>(emitOptions: E): EmitFn<E>;
+declare function defineEmits<T extends ComponentTypeEmits>(): T extends ((...args: any[]) => any) ? T : ShortEmits<T>;
+type ComponentTypeEmits = ((...args: any[]) => any) | Record<string, any>;
+type RecordToUnion<T extends Record<string, any>> = T[keyof T];
+type ShortEmits<T extends Record<string, any>> = UnionToIntersection<RecordToUnion<{ [K in keyof T]: (evt: K, ...args: T[K]) => void }>>;
+/**
+ * Vue `<script setup>` compiler macro for declaring a component's exposed
+ * instance properties when it is accessed by a parent component via template
+ * refs.
+ *
+ * `<script setup>` components are closed by default - i.e. variables inside
+ * the `<script setup>` scope is not exposed to parent unless explicitly exposed
+ * via `defineExpose`.
+ *
+ * This is only usable inside `<script setup>`, is compiled away in the
+ * output and should **not** be actually called at runtime.
+ *
+ * @see {@link https://vuejs.org/api/sfc-script-setup.html#defineexpose}
+ */
+declare function defineExpose<Exposed extends Record<string, any> = Record<string, any>>(exposed?: Exposed): void;
+/**
+ * Vue `<script setup>` compiler macro for declaring a component's additional
+ * options. This should be used only for options that cannot be expressed via
+ * Composition API - e.g. `inheritAttrs`.
+ *
+ * @see {@link https://vuejs.org/api/sfc-script-setup.html#defineoptions}
+ */
+declare function defineOptions<RawBindings = {}, D$1 = {}, C$1 extends ComputedOptions = {}, M$1 extends MethodOptions = {}, Mixin$1 extends ComponentOptionsMixin = ComponentOptionsMixin, Extends$1 extends ComponentOptionsMixin = ComponentOptionsMixin>(options?: ComponentOptionsBase<{}, RawBindings, D$1, C$1, M$1, Mixin$1, Extends$1, {}> & {
+  /**
+   * props should be defined via defineProps().
+   */
+  props?: never;
+  /**
+   * emits should be defined via defineEmits().
+   */
+  emits?: never;
+  /**
+   * expose should be defined via defineExpose().
+   */
+  expose?: never;
+  /**
+   * slots should be defined via defineSlots().
+   */
+  slots?: never;
+}): void;
+declare function defineSlots<S extends Record<string, any> = Record<string, any>>(): StrictUnwrapSlotsType<SlotsType<S>>;
+type ModelRef<T, M$1 extends PropertyKey = string, G = T, S = T> = Ref<G, S> & [ModelRef<T, M$1, G, S>, Record<M$1, true | undefined>];
+type DefineModelOptions<T = any, G = T, S = T> = {
+  get?: (v: T) => G;
+  set?: (v: S) => any;
+};
+/**
+ * Vue `<script setup>` compiler macro for declaring a
+ * two-way binding prop that can be consumed via `v-model` from the parent
+ * component. This will declare a prop with the same name and a corresponding
+ * `update:propName` event.
+ *
+ * If the first argument is a string, it will be used as the prop name;
+ * Otherwise the prop name will default to "modelValue". In both cases, you
+ * can also pass an additional object which will be used as the prop's options.
+ *
+ * The returned ref behaves differently depending on whether the parent
+ * provided the corresponding v-model props or not:
+ * - If yes, the returned ref's value will always be in sync with the parent
+ *   prop.
+ * - If not, the returned ref will behave like a normal local ref.
+ *
+ * @example
+ * ```ts
+ * // default model (consumed via `v-model`)
+ * const modelValue = defineModel<string>()
+ * modelValue.value = "hello"
+ *
+ * // default model with options
+ * const modelValue = defineModel<string>({ required: true })
+ *
+ * // with specified name (consumed via `v-model:count`)
+ * const count = defineModel<number>('count')
+ * count.value++
+ *
+ * // with specified name and default value
+ * const count = defineModel<number>('count', { default: 0 })
+ * ```
+ */
+declare function defineModel<T, M$1 extends PropertyKey = string, G = T, S = T>(options: ({
+  default: any;
+} | {
+  required: true;
+}) & PropOptions<T> & DefineModelOptions<T, G, S>): ModelRef<T, M$1, G, S>;
+declare function defineModel<T, M$1 extends PropertyKey = string, G = T, S = T>(options?: PropOptions<T> & DefineModelOptions<T, G, S>): ModelRef<T | undefined, M$1, G | undefined, S | undefined>;
+declare function defineModel<T, M$1 extends PropertyKey = string, G = T, S = T>(name: string, options: ({
+  default: any;
+} | {
+  required: true;
+}) & PropOptions<T> & DefineModelOptions<T, G, S>): ModelRef<T, M$1, G, S>;
+declare function defineModel<T, M$1 extends PropertyKey = string, G = T, S = T>(name: string, options?: PropOptions<T> & DefineModelOptions<T, G, S>): ModelRef<T | undefined, M$1, G | undefined, S | undefined>;
+type NotUndefined<T> = T extends undefined ? never : T;
+type MappedOmit<T, K$1 extends keyof any> = { [P in keyof T as P extends K$1 ? never : P]: T[P] };
+type InferDefaults<T> = { [K in keyof T]?: InferDefault<T, T[K]> };
+type NativeType = null | undefined | number | string | boolean | symbol | Function;
+type InferDefault<P$1, T> = ((props: P$1) => T & {}) | (T extends NativeType ? T : never);
+type PropsWithDefaults<T, Defaults$1 extends InferDefaults<T>, BKeys extends keyof T> = T extends unknown ? Readonly<MappedOmit<T, keyof Defaults$1>> & { readonly [K in keyof Defaults$1 as K extends keyof T ? K : never]-?: K extends keyof T ? Defaults$1[K] extends undefined ? IfAny<Defaults$1[K], NotUndefined<T[K]>, T[K]> : NotUndefined<T[K]> : never } & { readonly [K in BKeys]-?: K extends keyof Defaults$1 ? Defaults$1[K] extends undefined ? boolean | undefined : boolean : boolean } : never;
+/**
+ * Vue `<script setup>` compiler macro for providing props default values when
+ * using type-based `defineProps` declaration.
+ *
+ * Example usage:
+ * ```ts
+ * withDefaults(defineProps<{
+ *   size?: number
+ *   labels?: string[]
+ * }>(), {
+ *   size: 3,
+ *   labels: () => ['default label']
+ * })
+ * ```
+ *
+ * This is only usable inside `<script setup>`, is compiled away in the output
+ * and should **not** be actually called at runtime.
+ *
+ * @see {@link https://vuejs.org/guide/typescript/composition-api.html#typing-component-props}
+ */
+declare function withDefaults<T, BKeys extends keyof T, Defaults$1 extends InferDefaults<T>>(props: DefineProps<T, BKeys>, defaults: Defaults$1): PropsWithDefaults<T, Defaults$1, BKeys>;
+type ObjectEmitsOptions = Record<string, ((...args: any[]) => any) | null>;
+type EmitsOptions = ObjectEmitsOptions | string[];
+type EmitsToProps<T extends EmitsOptions | ComponentTypeEmits> = T extends string[] ? { [K in `on${Capitalize<T[number]>}`]?: (...args: any[]) => any } : T extends ObjectEmitsOptions ? { [K in string & keyof T as `on${Capitalize<K>}`]?: (...args: T[K] extends ((...args: infer P) => any) ? P : T[K] extends null ? any[] : never) => any } : {};
+type ShortEmitsToObject<E> = E extends Record<string, any[]> ? { [K in keyof E]: (...args: E[K]) => any } : E;
+type EmitFn<Options = ObjectEmitsOptions, Event$1 extends keyof Options = keyof Options> = Options extends Array<infer V> ? (event: V, ...args: any[]) => void : {} extends Options ? (event: string, ...args: any[]) => void : UnionToIntersection<{ [key in Event$1]: Options[key] extends ((...args: infer Args) => any) ? (event: key, ...args: Args) => void : Options[key] extends any[] ? (event: key, ...args: Options[key]) => void : (event: key, ...args: any[]) => void }[Event$1]>;
+/**
+Runtime helper for applying directives to a vnode. Example usage:
+
+const comp = resolveComponent('comp')
+const foo = resolveDirective('foo')
+const bar = resolveDirective('bar')
+
+return withDirectives(h(comp), [
+  [foo, this.x],
+  [bar, this.y]
+])
+*/
+
+interface DirectiveBinding<Value = any, Modifiers extends string = string, Arg = any> {
+  instance: ComponentPublicInstance | Record<string, any> | null;
+  value: Value;
+  oldValue: Value | null;
+  arg?: Arg;
+  modifiers: DirectiveModifiers<Modifiers>;
+  dir: ObjectDirective<any, Value, Modifiers, Arg>;
+}
+type DirectiveHook<HostElement = any, Prev = VNode<any, HostElement> | null, Value = any, Modifiers extends string = string, Arg = any> = (el: HostElement, binding: DirectiveBinding<Value, Modifiers, Arg>, vnode: VNode<any, HostElement>, prevVNode: Prev) => void;
+type SSRDirectiveHook<Value = any, Modifiers extends string = string, Arg = any> = (binding: DirectiveBinding<Value, Modifiers, Arg>, vnode: VNode) => Data | undefined;
+interface ObjectDirective<HostElement = any, Value = any, Modifiers extends string = string, Arg = any> {
+  created?: DirectiveHook<HostElement, null, Value, Modifiers, Arg>;
+  beforeMount?: DirectiveHook<HostElement, null, Value, Modifiers, Arg>;
+  mounted?: DirectiveHook<HostElement, null, Value, Modifiers, Arg>;
+  beforeUpdate?: DirectiveHook<HostElement, VNode<any, HostElement>, Value, Modifiers, Arg>;
+  updated?: DirectiveHook<HostElement, VNode<any, HostElement>, Value, Modifiers, Arg>;
+  beforeUnmount?: DirectiveHook<HostElement, null, Value, Modifiers, Arg>;
+  unmounted?: DirectiveHook<HostElement, null, Value, Modifiers, Arg>;
+  getSSRProps?: SSRDirectiveHook<Value, Modifiers, Arg>;
+  deep?: boolean;
+}
+type FunctionDirective<HostElement = any, V$1 = any, Modifiers extends string = string, Arg = any> = DirectiveHook<HostElement, any, V$1, Modifiers, Arg>;
+type Directive<HostElement = any, Value = any, Modifiers extends string = string, Arg = any> = ObjectDirective<HostElement, Value, Modifiers, Arg> | FunctionDirective<HostElement, Value, Modifiers, Arg>;
+type DirectiveModifiers<K$1 extends string = string> = Partial<Record<K$1, boolean>>;
+/**
+ * Custom properties added to component instances in any way and can be accessed through `this`
+ *
+ * @example
+ * Here is an example of adding a property `$router` to every component instance:
+ * ```ts
+ * import { createApp } from 'vue'
+ * import { Router, createRouter } from 'vue-router'
+ *
+ * declare module 'vue' {
+ *   interface ComponentCustomProperties {
+ *     $router: Router
+ *   }
+ * }
+ *
+ * // effectively adding the router to every component instance
+ * const app = createApp({})
+ * const router = createRouter()
+ * app.config.globalProperties.$router = router
+ *
+ * const vm = app.mount('#app')
+ * // we can access the router from the instance
+ * vm.$router.push('/')
+ * ```
+ */
+interface ComponentCustomProperties {}
+type IsDefaultMixinComponent<T> = T extends ComponentOptionsMixin ? ComponentOptionsMixin extends T ? true : false : false;
+type MixinToOptionTypes<T> = T extends ComponentOptionsBase<infer P, infer B, infer D, infer C, infer M, infer Mixin, infer Extends, any, any, infer Defaults, any, any, any, any, any, any, any> ? OptionTypesType<P & {}, B & {}, D & {}, C & {}, M & {}, Defaults & {}> & IntersectionMixin<Mixin> & IntersectionMixin<Extends> : never;
+type ExtractMixin<T> = {
+  Mixin: MixinToOptionTypes<T>;
+}[T extends ComponentOptionsMixin ? 'Mixin' : never];
+type IntersectionMixin<T> = IsDefaultMixinComponent<T> extends true ? OptionTypesType : UnionToIntersection<ExtractMixin<T>>;
+type UnwrapMixinsType<T, Type extends OptionTypesKeys> = T extends OptionTypesType ? T[Type] : never;
+type EnsureNonVoid<T> = T extends void ? {} : T;
+type ComponentPublicInstanceConstructor<T extends ComponentPublicInstance<Props$1, RawBindings, D$1, C$1, M$1> = ComponentPublicInstance<any>, Props$1 = any, RawBindings = any, D$1 = any, C$1 extends ComputedOptions = ComputedOptions, M$1 extends MethodOptions = MethodOptions> = {
+  __isFragment?: never;
+  __isTeleport?: never;
+  __isSuspense?: never;
+  new (...args: any[]): T;
+};
+/**
+ * @deprecated This is no longer used internally, but exported and relied on by
+ * existing library types generated by vue-tsc.
+ */
+
+/**
+ * This is the same as `CreateComponentPublicInstance` but adds local components,
+ * global directives, exposed, and provide inference.
+ * It changes the arguments order so that we don't need to repeat mixin
+ * inference everywhere internally, but it has to be a new type to avoid
+ * breaking types that relies on previous arguments order (#10842)
+ */
+type CreateComponentPublicInstanceWithMixins<P$1 = {}, B$1 = {}, D$1 = {}, C$1 extends ComputedOptions = {}, M$1 extends MethodOptions = {}, Mixin$1 extends ComponentOptionsMixin = ComponentOptionsMixin, Extends$1 extends ComponentOptionsMixin = ComponentOptionsMixin, E extends EmitsOptions = {}, PublicProps$1 = P$1, Defaults$1 = {}, MakeDefaultsOptional extends boolean = false, I extends ComponentInjectOptions = {}, S extends SlotsType = {}, LC extends Record<string, Component> = {}, Directives extends Record<string, Directive> = {}, Exposed extends string = string, TypeRefs extends Data = {}, TypeEl extends Element = any, Provide extends ComponentProvideOptions = ComponentProvideOptions, PublicMixin = IntersectionMixin<Mixin$1> & IntersectionMixin<Extends$1>, PublicP = UnwrapMixinsType<PublicMixin, 'P'> & EnsureNonVoid<P$1>, PublicB = UnwrapMixinsType<PublicMixin, 'B'> & EnsureNonVoid<B$1>, PublicD = UnwrapMixinsType<PublicMixin, 'D'> & EnsureNonVoid<D$1>, PublicC extends ComputedOptions = UnwrapMixinsType<PublicMixin, 'C'> & EnsureNonVoid<C$1>, PublicM extends MethodOptions = UnwrapMixinsType<PublicMixin, 'M'> & EnsureNonVoid<M$1>, PublicDefaults = UnwrapMixinsType<PublicMixin, 'Defaults'> & EnsureNonVoid<Defaults$1>> = ComponentPublicInstance<PublicP, PublicB, PublicD, PublicC, PublicM, E, PublicProps$1, PublicDefaults, MakeDefaultsOptional, ComponentOptionsBase<P$1, B$1, D$1, C$1, M$1, Mixin$1, Extends$1, E, string, Defaults$1, {}, string, S, LC, Directives, Exposed, Provide>, I, S, Exposed, TypeRefs, TypeEl>;
+type ExposedKeys<T, Exposed extends string & keyof T> = '' extends Exposed ? T : Pick<T, Exposed>;
+type ComponentPublicInstance<P$1 = {},
+// props type extracted from props option
+B$1 = {},
+// raw bindings returned from setup()
+D$1 = {},
+// return from data()
+C$1 extends ComputedOptions = {}, M$1 extends MethodOptions = {}, E extends EmitsOptions = {}, PublicProps$1 = {}, Defaults$1 = {}, MakeDefaultsOptional extends boolean = false, Options = ComponentOptionsBase<any, any, any, any, any, any, any, any, any>, I extends ComponentInjectOptions = {}, S extends SlotsType = {}, Exposed extends string = '', TypeRefs extends Data = {}, TypeEl extends Element = any> = {
+  $: ComponentInternalInstance;
+  $data: D$1;
+  $props: MakeDefaultsOptional extends true ? Partial<Defaults$1> & Omit<Prettify<P$1> & PublicProps$1, keyof Defaults$1> : Prettify<P$1> & PublicProps$1;
+  $attrs: Data;
+  $refs: Data & TypeRefs;
+  $slots: UnwrapSlotsType<S>;
+  $root: ComponentPublicInstance | null;
+  $parent: ComponentPublicInstance | null;
+  $host: Element | null;
+  $emit: EmitFn<E>;
+  $el: TypeEl;
+  $options: Options & MergedComponentOptionsOverride;
+  $forceUpdate: () => void;
+  $nextTick: typeof nextTick;
+  $watch<T extends string | ((...args: any) => any)>(source: T, cb: T extends ((...args: any) => infer R) ? (...args: [R, R, OnCleanup]) => any : (...args: [any, any, OnCleanup]) => any, options?: WatchOptions): WatchStopHandle;
+} & ExposedKeys<IfAny<P$1, P$1, Readonly<Defaults$1> & Omit<P$1, keyof ShallowUnwrapRef<B$1> | keyof Defaults$1>> & ShallowUnwrapRef<B$1> & UnwrapNestedRefs<D$1> & ExtractComputedReturns<C$1> & M$1 & ComponentCustomProperties & InjectToObject<I>, Exposed>;
+interface SuspenseProps {
+  onResolve?: () => void;
+  onPending?: () => void;
+  onFallback?: () => void;
+  timeout?: string | number;
+  /**
+   * Allow suspense to be captured by parent suspense
+   *
+   * @default false
+   */
+  suspensible?: boolean;
+}
+declare const SuspenseImpl: {
+  name: string;
+  __isSuspense: boolean;
+  process(n1: VNode | null, n2: VNode, container: RendererElement, anchor: RendererNode | null, parentComponent: ComponentInternalInstance | null, parentSuspense: SuspenseBoundary | null, namespace: ElementNamespace, slotScopeIds: string[] | null, optimized: boolean, rendererInternals: RendererInternals): void;
+  hydrate: typeof hydrateSuspense;
+  normalize: typeof normalizeSuspenseChildren;
+};
+declare const Suspense: {
+  __isSuspense: true;
+  new (): {
+    $props: VNodeProps & SuspenseProps;
+    $slots: {
+      default(): VNode[];
+      fallback(): VNode[];
+    };
+  };
+};
+interface SuspenseBoundary {
+  vnode: VNode<RendererNode, RendererElement, SuspenseProps>;
+  parent: SuspenseBoundary | null;
+  parentComponent: ComponentInternalInstance | null;
+  namespace: ElementNamespace;
+  container: RendererElement;
+  hiddenContainer: RendererElement;
+  activeBranch: VNode | null;
+  pendingBranch: VNode | null;
+  deps: number;
+  pendingId: number;
+  timeout: number;
+  isInFallback: boolean;
+  isHydrating: boolean;
+  isUnmounted: boolean;
+  effects: Function[];
+  resolve(force?: boolean, sync?: boolean): void;
+  fallback(fallbackVNode: VNode): void;
+  move(container: RendererElement, anchor: RendererNode | null, type: MoveType): void;
+  next(): RendererNode | null;
+  registerDep(instance: ComponentInternalInstance, setupRenderEffect: SetupRenderEffectFn, optimized: boolean): void;
+  unmount(parentSuspense: SuspenseBoundary | null, doRemove?: boolean): void;
+}
+declare function hydrateSuspense(node: Node, vnode: VNode, parentComponent: ComponentInternalInstance | null, parentSuspense: SuspenseBoundary | null, namespace: ElementNamespace, slotScopeIds: string[] | null, optimized: boolean, rendererInternals: RendererInternals, hydrateNode: (node: Node, vnode: VNode, parentComponent: ComponentInternalInstance | null, parentSuspense: SuspenseBoundary | null, slotScopeIds: string[] | null, optimized: boolean) => Node | null): Node | null;
+declare function normalizeSuspenseChildren(vnode: VNode): void;
+type Hook<T = () => void> = T | T[];
+interface BaseTransitionProps<HostElement = RendererElement> {
+  mode?: 'in-out' | 'out-in' | 'default';
+  appear?: boolean;
+  persisted?: boolean;
+  onBeforeEnter?: Hook<(el: HostElement) => void>;
+  onEnter?: Hook<(el: HostElement, done: () => void) => void>;
+  onAfterEnter?: Hook<(el: HostElement) => void>;
+  onEnterCancelled?: Hook<(el: HostElement) => void>;
+  onBeforeLeave?: Hook<(el: HostElement) => void>;
+  onLeave?: Hook<(el: HostElement, done: () => void) => void>;
+  onAfterLeave?: Hook<(el: HostElement) => void>;
+  onLeaveCancelled?: Hook<(el: HostElement) => void>;
+  onBeforeAppear?: Hook<(el: HostElement) => void>;
+  onAppear?: Hook<(el: HostElement, done: () => void) => void>;
+  onAfterAppear?: Hook<(el: HostElement) => void>;
+  onAppearCancelled?: Hook<(el: HostElement) => void>;
+}
+interface TransitionHooks<HostElement = RendererElement> {
+  mode: BaseTransitionProps['mode'];
+  persisted: boolean;
+  beforeEnter(el: HostElement): void;
+  enter(el: HostElement): void;
+  leave(el: HostElement, remove: () => void): void;
+  clone(vnode: VNode): TransitionHooks<HostElement>;
+  afterLeave?(): void;
+  delayLeave?(el: HostElement, earlyRemove: () => void, delayedLeave: () => void): void;
+  delayedLeave?(): void;
+}
+type ElementNamespace = 'svg' | 'mathml' | undefined;
+interface RendererOptions<HostNode = RendererNode, HostElement = RendererElement> {
+  patchProp(el: HostElement, key: string, prevValue: any, nextValue: any, namespace?: ElementNamespace, parentComponent?: ComponentInternalInstance | null): void;
+  insert(el: HostNode, parent: HostElement, anchor?: HostNode | null): void;
+  remove(el: HostNode): void;
+  createElement(type: string, namespace?: ElementNamespace, isCustomizedBuiltIn?: string, vnodeProps?: (VNodeProps & {
+    [key: string]: any;
+  }) | null): HostElement;
+  createText(text: string): HostNode;
+  createComment(text: string): HostNode;
+  setText(node: HostNode, text: string): void;
+  setElementText(node: HostElement, text: string): void;
+  parentNode(node: HostNode): HostElement | null;
+  nextSibling(node: HostNode): HostNode | null;
+  querySelector?(selector: string): HostElement | null;
+  setScopeId?(el: HostElement, id: string): void;
+  cloneNode?(node: HostNode): HostNode;
+  insertStaticContent?(content: string, parent: HostElement, anchor: HostNode | null, namespace: ElementNamespace, start?: HostNode | null, end?: HostNode | null): [HostNode, HostNode];
+}
+interface RendererNode {
+  [key: string | symbol]: any;
+}
+interface RendererElement extends RendererNode {}
+interface RendererInternals<HostNode = RendererNode, HostElement = RendererElement> {
+  p: PatchFn;
+  um: UnmountFn;
+  r: RemoveFn;
+  m: MoveFn;
+  mt: MountComponentFn;
+  mc: MountChildrenFn;
+  pc: PatchChildrenFn;
+  pbc: PatchBlockChildrenFn;
+  n: NextFn;
+  o: RendererOptions<HostNode, HostElement>;
+}
+type PatchFn = (n1: VNode | null,
+// null means this is a mount
+n2: VNode, container: RendererElement, anchor?: RendererNode | null, parentComponent?: ComponentInternalInstance | null, parentSuspense?: SuspenseBoundary | null, namespace?: ElementNamespace, slotScopeIds?: string[] | null, optimized?: boolean) => void;
+type MountChildrenFn = (children: VNodeArrayChildren, container: RendererElement, anchor: RendererNode | null, parentComponent: ComponentInternalInstance | null, parentSuspense: SuspenseBoundary | null, namespace: ElementNamespace, slotScopeIds: string[] | null, optimized: boolean, start?: number) => void;
+type PatchChildrenFn = (n1: VNode | null, n2: VNode, container: RendererElement, anchor: RendererNode | null, parentComponent: ComponentInternalInstance | null, parentSuspense: SuspenseBoundary | null, namespace: ElementNamespace, slotScopeIds: string[] | null, optimized: boolean) => void;
+type PatchBlockChildrenFn = (oldChildren: VNode[], newChildren: VNode[], fallbackContainer: RendererElement, parentComponent: ComponentInternalInstance | null, parentSuspense: SuspenseBoundary | null, namespace: ElementNamespace, slotScopeIds: string[] | null) => void;
+type MoveFn = (vnode: VNode, container: RendererElement, anchor: RendererNode | null, type: MoveType, parentSuspense?: SuspenseBoundary | null) => void;
+type NextFn = (vnode: VNode) => RendererNode | null;
+type UnmountFn = (vnode: VNode, parentComponent: ComponentInternalInstance | null, parentSuspense: SuspenseBoundary | null, doRemove?: boolean, optimized?: boolean) => void;
+type RemoveFn = (vnode: VNode) => void;
+type MountComponentFn = (initialVNode: VNode, container: RendererElement, anchor: RendererNode | null, parentComponent: ComponentInternalInstance | null, parentSuspense: SuspenseBoundary | null, namespace: ElementNamespace, optimized: boolean) => void;
+type SetupRenderEffectFn = (instance: ComponentInternalInstance, initialVNode: VNode, container: RendererElement, anchor: RendererNode | null, parentSuspense: SuspenseBoundary | null, namespace: ElementNamespace, optimized: boolean) => void;
+declare enum MoveType {
+  ENTER = 0,
+  LEAVE = 1,
+  REORDER = 2,
+}
+/**
+ * The createRenderer function accepts two generic arguments:
+ * HostNode and HostElement, corresponding to Node and Element types in the
+ * host environment. For example, for runtime-dom, HostNode would be the DOM
+ * `Node` interface and HostElement would be the DOM `Element` interface.
+ *
+ * Custom renderers can pass in the platform specific types like this:
+ *
+ * ``` js
+ * const { render, createApp } = createRenderer<Node, Element>({
+ *   patchProp,
+ *   ...nodeOps
+ * })
+ * ```
+ */
+
+type MatchPattern = string | RegExp | (string | RegExp)[];
+interface KeepAliveProps {
+  include?: MatchPattern;
+  exclude?: MatchPattern;
+  max?: number | string;
+}
+type DebuggerHook = (e: DebuggerEvent) => void;
+type ErrorCapturedHook<TError = unknown> = (err: TError, instance: ComponentPublicInstance | null, info: string) => boolean | void;
+declare enum DeprecationTypes$1 {
+  GLOBAL_MOUNT = "GLOBAL_MOUNT",
+  GLOBAL_MOUNT_CONTAINER = "GLOBAL_MOUNT_CONTAINER",
+  GLOBAL_EXTEND = "GLOBAL_EXTEND",
+  GLOBAL_PROTOTYPE = "GLOBAL_PROTOTYPE",
+  GLOBAL_SET = "GLOBAL_SET",
+  GLOBAL_DELETE = "GLOBAL_DELETE",
+  GLOBAL_OBSERVABLE = "GLOBAL_OBSERVABLE",
+  GLOBAL_PRIVATE_UTIL = "GLOBAL_PRIVATE_UTIL",
+  CONFIG_SILENT = "CONFIG_SILENT",
+  CONFIG_DEVTOOLS = "CONFIG_DEVTOOLS",
+  CONFIG_KEY_CODES = "CONFIG_KEY_CODES",
+  CONFIG_PRODUCTION_TIP = "CONFIG_PRODUCTION_TIP",
+  CONFIG_IGNORED_ELEMENTS = "CONFIG_IGNORED_ELEMENTS",
+  CONFIG_WHITESPACE = "CONFIG_WHITESPACE",
+  CONFIG_OPTION_MERGE_STRATS = "CONFIG_OPTION_MERGE_STRATS",
+  INSTANCE_SET = "INSTANCE_SET",
+  INSTANCE_DELETE = "INSTANCE_DELETE",
+  INSTANCE_DESTROY = "INSTANCE_DESTROY",
+  INSTANCE_EVENT_EMITTER = "INSTANCE_EVENT_EMITTER",
+  INSTANCE_EVENT_HOOKS = "INSTANCE_EVENT_HOOKS",
+  INSTANCE_CHILDREN = "INSTANCE_CHILDREN",
+  INSTANCE_LISTENERS = "INSTANCE_LISTENERS",
+  INSTANCE_SCOPED_SLOTS = "INSTANCE_SCOPED_SLOTS",
+  INSTANCE_ATTRS_CLASS_STYLE = "INSTANCE_ATTRS_CLASS_STYLE",
+  OPTIONS_DATA_FN = "OPTIONS_DATA_FN",
+  OPTIONS_DATA_MERGE = "OPTIONS_DATA_MERGE",
+  OPTIONS_BEFORE_DESTROY = "OPTIONS_BEFORE_DESTROY",
+  OPTIONS_DESTROYED = "OPTIONS_DESTROYED",
+  WATCH_ARRAY = "WATCH_ARRAY",
+  PROPS_DEFAULT_THIS = "PROPS_DEFAULT_THIS",
+  V_ON_KEYCODE_MODIFIER = "V_ON_KEYCODE_MODIFIER",
+  CUSTOM_DIR = "CUSTOM_DIR",
+  ATTR_FALSE_VALUE = "ATTR_FALSE_VALUE",
+  ATTR_ENUMERATED_COERCION = "ATTR_ENUMERATED_COERCION",
+  TRANSITION_CLASSES = "TRANSITION_CLASSES",
+  TRANSITION_GROUP_ROOT = "TRANSITION_GROUP_ROOT",
+  COMPONENT_ASYNC = "COMPONENT_ASYNC",
+  COMPONENT_FUNCTIONAL = "COMPONENT_FUNCTIONAL",
+  COMPONENT_V_MODEL = "COMPONENT_V_MODEL",
+  RENDER_FUNCTION = "RENDER_FUNCTION",
+  FILTERS = "FILTERS",
+  PRIVATE_APIS = "PRIVATE_APIS",
+}
+type CompatConfig = Partial<Record<DeprecationTypes$1, boolean | 'suppress-warning'>> & {
+  MODE?: 2 | 3 | ((comp: Component | null) => 2 | 3);
+};
+/**
+ * Interface for declaring custom options.
+ *
+ * @example
+ * ```ts
+ * declare module 'vue' {
+ *   interface ComponentCustomOptions {
+ *     beforeRouteUpdate?(
+ *       to: Route,
+ *       from: Route,
+ *       next: () => void
+ *     ): void
+ *   }
+ * }
+ * ```
+ */
+interface ComponentCustomOptions {}
+type RenderFunction = () => VNodeChild;
+interface ComponentOptionsBase<Props$1, RawBindings, D$1, C$1 extends ComputedOptions, M$1 extends MethodOptions, Mixin$1 extends ComponentOptionsMixin, Extends$1 extends ComponentOptionsMixin, E extends EmitsOptions, EE extends string = string, Defaults$1 = {}, I extends ComponentInjectOptions = {}, II extends string = string, S extends SlotsType = {}, LC extends Record<string, Component> = {}, Directives extends Record<string, Directive> = {}, Exposed extends string = string, Provide extends ComponentProvideOptions = ComponentProvideOptions> extends LegacyOptions<Props$1, D$1, C$1, M$1, Mixin$1, Extends$1, I, II, Provide>, ComponentInternalOptions, ComponentCustomOptions {
+  setup?: (this: void, props: LooseRequired<Props$1 & Prettify<UnwrapMixinsType<IntersectionMixin<Mixin$1> & IntersectionMixin<Extends$1>, 'P'>>>, ctx: SetupContext<E, S>) => Promise<RawBindings> | RawBindings | RenderFunction | void;
+  name?: string;
+  template?: string | object;
+  render?: Function;
+  components?: LC & Record<string, Component>;
+  directives?: Directives & Record<string, Directive>;
+  inheritAttrs?: boolean;
+  emits?: (E | EE[]) & ThisType<void>;
+  slots?: S;
+  expose?: Exposed[];
+  serverPrefetch?(): void | Promise<any>;
+  compilerOptions?: RuntimeCompilerOptions;
+  call?: (this: unknown, ...args: unknown[]) => never;
+  __isFragment?: never;
+  __isTeleport?: never;
+  __isSuspense?: never;
+  __defaults?: Defaults$1;
+}
+/**
+ * Subset of compiler options that makes sense for the runtime.
+ */
+interface RuntimeCompilerOptions {
+  isCustomElement?: (tag: string) => boolean;
+  whitespace?: 'preserve' | 'condense';
+  comments?: boolean;
+  delimiters?: [string, string];
+}
+type ComponentOptions<Props$1 = {}, RawBindings = any, D$1 = any, C$1 extends ComputedOptions = any, M$1 extends MethodOptions = any, Mixin$1 extends ComponentOptionsMixin = any, Extends$1 extends ComponentOptionsMixin = any, E extends EmitsOptions = any, EE extends string = string, Defaults$1 = {}, I extends ComponentInjectOptions = {}, II extends string = string, S extends SlotsType = {}, LC extends Record<string, Component> = {}, Directives extends Record<string, Directive> = {}, Exposed extends string = string, Provide extends ComponentProvideOptions = ComponentProvideOptions> = ComponentOptionsBase<Props$1, RawBindings, D$1, C$1, M$1, Mixin$1, Extends$1, E, EE, Defaults$1, I, II, S, LC, Directives, Exposed, Provide> & ThisType<CreateComponentPublicInstanceWithMixins<{}, RawBindings, D$1, C$1, M$1, Mixin$1, Extends$1, E, Readonly<Props$1>, Defaults$1, false, I, S, LC, Directives>>;
+type ComponentOptionsMixin = ComponentOptionsBase<any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any>;
+type ComputedOptions = Record<string, ComputedGetter<any> | WritableComputedOptions<any>>;
+interface MethodOptions {
+  [key: string]: Function;
+}
+type ExtractComputedReturns<T extends any> = { [key in keyof T]: T[key] extends {
+  get: (...args: any[]) => infer TReturn;
+} ? TReturn : T[key] extends ((...args: any[]) => infer TReturn) ? TReturn : never };
+type ObjectWatchOptionItem = {
+  handler: WatchCallback | string;
+} & WatchOptions;
+type WatchOptionItem = string | WatchCallback | ObjectWatchOptionItem;
+type ComponentWatchOptionItem = WatchOptionItem | WatchOptionItem[];
+type ComponentWatchOptions = Record<string, ComponentWatchOptionItem>;
+type ComponentProvideOptions = ObjectProvideOptions | Function;
+type ObjectProvideOptions = Record<string | symbol, unknown>;
+type ComponentInjectOptions = string[] | ObjectInjectOptions;
+type ObjectInjectOptions = Record<string | symbol, string | symbol | {
+  from?: string | symbol;
+  default?: unknown;
+}>;
+type InjectToObject<T extends ComponentInjectOptions> = T extends string[] ? { [K in T[number]]?: unknown } : T extends ObjectInjectOptions ? { [K in keyof T]?: unknown } : never;
+interface LegacyOptions<Props$1, D$1, C$1 extends ComputedOptions, M$1 extends MethodOptions, Mixin$1 extends ComponentOptionsMixin, Extends$1 extends ComponentOptionsMixin, I extends ComponentInjectOptions, II extends string, Provide extends ComponentProvideOptions = ComponentProvideOptions> {
+  compatConfig?: CompatConfig;
+  [key: string]: any;
+  data?: (this: CreateComponentPublicInstanceWithMixins<Props$1, {}, {}, {}, MethodOptions, Mixin$1, Extends$1>, vm: CreateComponentPublicInstanceWithMixins<Props$1, {}, {}, {}, MethodOptions, Mixin$1, Extends$1>) => D$1;
+  computed?: C$1;
+  methods?: M$1;
+  watch?: ComponentWatchOptions;
+  provide?: Provide;
+  inject?: I | II[];
+  filters?: Record<string, Function>;
+  mixins?: Mixin$1[];
+  extends?: Extends$1;
+  beforeCreate?(): any;
+  created?(): any;
+  beforeMount?(): any;
+  mounted?(): any;
+  beforeUpdate?(): any;
+  updated?(): any;
+  activated?(): any;
+  deactivated?(): any;
+  /** @deprecated use `beforeUnmount` instead */
+  beforeDestroy?(): any;
+  beforeUnmount?(): any;
+  /** @deprecated use `unmounted` instead */
+  destroyed?(): any;
+  unmounted?(): any;
+  renderTracked?: DebuggerHook;
+  renderTriggered?: DebuggerHook;
+  errorCaptured?: ErrorCapturedHook;
+  /**
+   * runtime compile only
+   * @deprecated use `compilerOptions.delimiters` instead.
+   */
+  delimiters?: [string, string];
+  /**
+   * #3468
+   *
+   * type-only, used to assist Mixin's type inference,
+   * TypeScript will try to simplify the inferred `Mixin` type,
+   * with the `__differentiator`, TypeScript won't be able to combine different mixins,
+   * because the `__differentiator` will be different
+   */
+  __differentiator?: keyof D$1 | keyof C$1 | keyof M$1;
+}
+type MergedHook<T = () => void> = T | T[];
+type MergedComponentOptionsOverride = {
+  beforeCreate?: MergedHook;
+  created?: MergedHook;
+  beforeMount?: MergedHook;
+  mounted?: MergedHook;
+  beforeUpdate?: MergedHook;
+  updated?: MergedHook;
+  activated?: MergedHook;
+  deactivated?: MergedHook;
+  /** @deprecated use `beforeUnmount` instead */
+  beforeDestroy?: MergedHook;
+  beforeUnmount?: MergedHook;
+  /** @deprecated use `unmounted` instead */
+  destroyed?: MergedHook;
+  unmounted?: MergedHook;
+  renderTracked?: MergedHook<DebuggerHook>;
+  renderTriggered?: MergedHook<DebuggerHook>;
+  errorCaptured?: MergedHook<ErrorCapturedHook>;
+};
+type OptionTypesKeys = 'P' | 'B' | 'D' | 'C' | 'M' | 'Defaults';
+type OptionTypesType<P$1 = {}, B$1 = {}, D$1 = {}, C$1 extends ComputedOptions = {}, M$1 extends MethodOptions = {}, Defaults$1 = {}> = {
+  P: P$1;
+  B: B$1;
+  D: D$1;
+  C: C$1;
+  M: M$1;
+  Defaults: Defaults$1;
+};
+/**
+ * @deprecated
+ */
+
+interface InjectionConstraint<T> {}
+type InjectionKey<T> = symbol & InjectionConstraint<T>;
+type PublicProps = VNodeProps & AllowedComponentProps & ComponentCustomProps;
+type ResolveProps<PropsOrPropOptions, E extends EmitsOptions> = Readonly<PropsOrPropOptions extends ComponentPropsOptions ? ExtractPropTypes<PropsOrPropOptions> : PropsOrPropOptions> & ({} extends E ? {} : EmitsToProps<E>);
+type DefineComponent<PropsOrPropOptions = {}, RawBindings = {}, D$1 = {}, C$1 extends ComputedOptions = ComputedOptions, M$1 extends MethodOptions = MethodOptions, Mixin$1 extends ComponentOptionsMixin = ComponentOptionsMixin, Extends$1 extends ComponentOptionsMixin = ComponentOptionsMixin, E extends EmitsOptions = {}, EE extends string = string, PP = PublicProps, Props$1 = ResolveProps<PropsOrPropOptions, E>, Defaults$1 = ExtractDefaultPropTypes<PropsOrPropOptions>, S extends SlotsType = {}, LC extends Record<string, Component> = {}, Directives extends Record<string, Directive> = {}, Exposed extends string = string, Provide extends ComponentProvideOptions = ComponentProvideOptions, MakeDefaultsOptional extends boolean = true, TypeRefs extends Record<string, unknown> = {}, TypeEl extends Element = any> = ComponentPublicInstanceConstructor<CreateComponentPublicInstanceWithMixins<Props$1, RawBindings, D$1, C$1, M$1, Mixin$1, Extends$1, E, PP, Defaults$1, MakeDefaultsOptional, {}, S, LC & GlobalComponents, Directives & GlobalDirectives, Exposed, TypeRefs, TypeEl>> & ComponentOptionsBase<Props$1, RawBindings, D$1, C$1, M$1, Mixin$1, Extends$1, E, EE, Defaults$1, {}, string, S, LC & GlobalComponents, Directives & GlobalDirectives, Exposed, Provide> & PP;
+interface App<HostElement = any> {
+  version: string;
+  config: AppConfig;
+  use<Options extends unknown[]>(plugin: Plugin<Options>, ...options: NoInfer<Options>): this;
+  use<Options>(plugin: Plugin<Options>, options: NoInfer<Options>): this;
+  mixin(mixin: ComponentOptions): this;
+  component(name: string): Component | undefined;
+  component<T extends Component | DefineComponent>(name: string, component: T): this;
+  directive<HostElement = any, Value = any, Modifiers extends string = string, Arg = any>(name: string): Directive<HostElement, Value, Modifiers, Arg> | undefined;
+  directive<HostElement = any, Value = any, Modifiers extends string = string, Arg = any>(name: string, directive: Directive<HostElement, Value, Modifiers, Arg>): this;
+  mount(rootContainer: HostElement | string,
+  /**
+   * @internal
+   */
+  isHydrate?: boolean,
+  /**
+   * @internal
+   */
+  namespace?: boolean | ElementNamespace,
+  /**
+   * @internal
+   */
+  vnode?: VNode): ComponentPublicInstance;
+  unmount(): void;
+  onUnmount(cb: () => void): void;
+  provide<T, K$1 = InjectionKey<T> | string | number>(key: K$1, value: K$1 extends InjectionKey<infer V> ? V : T): this;
+  /**
+   * Runs a function with the app as active instance. This allows using of `inject()` within the function to get access
+   * to variables provided via `app.provide()`.
+   *
+   * @param fn - function to run with the app as active instance
+   */
+  runWithContext<T>(fn: () => T): T;
+  _uid: number;
+  _component: ConcreteComponent;
+  _props: Data | null;
+  _container: HostElement | null;
+  _context: AppContext;
+  _instance: ComponentInternalInstance | null;
+  /**
+   * v2 compat only
+   */
+  filter?(name: string): Function | undefined;
+  filter?(name: string, filter: Function): this;
+}
+type OptionMergeFunction = (to: unknown, from: unknown) => any;
+interface AppConfig {
+  readonly isNativeTag: (tag: string) => boolean;
+  performance: boolean;
+  optionMergeStrategies: Record<string, OptionMergeFunction>;
+  globalProperties: ComponentCustomProperties & Record<string, any>;
+  errorHandler?: (err: unknown, instance: ComponentPublicInstance | null, info: string) => void;
+  warnHandler?: (msg: string, instance: ComponentPublicInstance | null, trace: string) => void;
+  /**
+   * Options to pass to `@vue/compiler-dom`.
+   * Only supported in runtime compiler build.
+   */
+  compilerOptions: RuntimeCompilerOptions;
+  /**
+   * @deprecated use config.compilerOptions.isCustomElement
+   */
+  isCustomElement?: (tag: string) => boolean;
+  /**
+   * TODO document for 3.5
+   * Enable warnings for computed getters that recursively trigger itself.
+   */
+  warnRecursiveComputed?: boolean;
+  /**
+   * Whether to throw unhandled errors in production.
+   * Default is `false` to avoid crashing on any error (and only logs it)
+   * But in some cases, e.g. SSR, throwing might be more desirable.
+   */
+  throwUnhandledErrorInProduction?: boolean;
+  /**
+   * Prefix for all useId() calls within this app
+   */
+  idPrefix?: string;
+}
+interface AppContext {
+  app: App;
+  config: AppConfig;
+  mixins: ComponentOptions[];
+  components: Record<string, Component>;
+  directives: Record<string, Directive>;
+  provides: Record<string | symbol, any>;
+}
+type PluginInstallFunction<Options = any[]> = Options extends unknown[] ? (app: App, ...options: Options) => any : (app: App, options: Options) => any;
+type ObjectPlugin<Options = any[]> = {
+  install: PluginInstallFunction<Options>;
+};
+type FunctionPlugin<Options = any[]> = PluginInstallFunction<Options> & Partial<ObjectPlugin<Options>>;
+type Plugin<Options = any[], P$1 extends unknown[] = (Options extends unknown[] ? Options : [Options])> = FunctionPlugin<P$1> | ObjectPlugin<P$1>;
+type TeleportVNode = VNode<RendererNode, RendererElement, TeleportProps>;
+interface TeleportProps {
+  to: string | RendererElement | null | undefined;
+  disabled?: boolean;
+  defer?: boolean;
+}
+declare const TeleportImpl: {
+  name: string;
+  __isTeleport: boolean;
+  process(n1: TeleportVNode | null, n2: TeleportVNode, container: RendererElement, anchor: RendererNode | null, parentComponent: ComponentInternalInstance | null, parentSuspense: SuspenseBoundary | null, namespace: ElementNamespace, slotScopeIds: string[] | null, optimized: boolean, internals: RendererInternals): void;
+  remove(vnode: VNode, parentComponent: ComponentInternalInstance | null, parentSuspense: SuspenseBoundary | null, {
+    um: unmount,
+    o: {
+      remove: hostRemove
+    }
+  }: RendererInternals, doRemove: boolean): void;
+  move: typeof moveTeleport;
+  hydrate: typeof hydrateTeleport;
+};
+declare enum TeleportMoveTypes {
+  TARGET_CHANGE = 0,
+  TOGGLE = 1,
+  // enable / disable
+  REORDER = 2,
+}
+declare function moveTeleport(vnode: VNode, container: RendererElement, parentAnchor: RendererNode | null, {
+  o: {
+    insert
+  },
+  m: move
+}: RendererInternals, moveType?: TeleportMoveTypes): void;
+declare function hydrateTeleport(node: Node, vnode: TeleportVNode, parentComponent: ComponentInternalInstance | null, parentSuspense: SuspenseBoundary | null, slotScopeIds: string[] | null, optimized: boolean, {
+  o: {
+    nextSibling,
+    parentNode,
+    querySelector,
+    insert,
+    createText
+  }
+}: RendererInternals<Node, Element>, hydrateChildren: (node: Node | null, vnode: VNode, container: Element, parentComponent: ComponentInternalInstance | null, parentSuspense: SuspenseBoundary | null, slotScopeIds: string[] | null, optimized: boolean) => Node | null): Node | null;
+declare const Teleport: {
+  __isTeleport: true;
+  new (): {
+    $props: VNodeProps & TeleportProps;
+    $slots: {
+      default(): VNode[];
+    };
+  };
+};
+declare const Fragment: {
+  __isFragment: true;
+  new (): {
+    $props: VNodeProps;
+  };
+};
+declare const Text: unique symbol;
+declare const Comment: unique symbol;
+declare const Static: unique symbol;
+type VNodeTypes = string | VNode | Component | typeof Text | typeof Static | typeof Comment | typeof Fragment | typeof Teleport | typeof TeleportImpl | typeof Suspense | typeof SuspenseImpl;
+type VNodeRef = string | Ref | ((ref: Element | ComponentPublicInstance | null, refs: Record<string, any>) => void);
+type VNodeNormalizedRefAtom = {
+  /**
+   * component instance
+   */
+  i: ComponentInternalInstance;
+  /**
+   * Actual ref
+   */
+  r: VNodeRef;
+  /**
+   * setup ref key
+   */
+  k?: string;
+  /**
+   * refInFor marker
+   */
+  f?: boolean;
+};
+type VNodeNormalizedRef = VNodeNormalizedRefAtom | VNodeNormalizedRefAtom[];
+type VNodeMountHook = (vnode: VNode) => void;
+type VNodeUpdateHook = (vnode: VNode, oldVNode: VNode) => void;
+type VNodeProps = {
+  key?: PropertyKey;
+  ref?: VNodeRef;
+  ref_for?: boolean;
+  ref_key?: string;
+  onVnodeBeforeMount?: VNodeMountHook | VNodeMountHook[];
+  onVnodeMounted?: VNodeMountHook | VNodeMountHook[];
+  onVnodeBeforeUpdate?: VNodeUpdateHook | VNodeUpdateHook[];
+  onVnodeUpdated?: VNodeUpdateHook | VNodeUpdateHook[];
+  onVnodeBeforeUnmount?: VNodeMountHook | VNodeMountHook[];
+  onVnodeUnmounted?: VNodeMountHook | VNodeMountHook[];
+};
+type VNodeChildAtom = VNode | string | number | boolean | null | undefined | void;
+type VNodeArrayChildren = Array<VNodeArrayChildren | VNodeChildAtom>;
+type VNodeChild = VNodeChildAtom | VNodeArrayChildren;
+type VNodeNormalizedChildren = string | VNodeArrayChildren | RawSlots | null;
+interface VNode<HostNode = RendererNode, HostElement = RendererElement, ExtraProps = {
+  [key: string]: any;
+}> {
+  type: VNodeTypes;
+  props: (VNodeProps & ExtraProps) | null;
+  key: PropertyKey | null;
+  ref: VNodeNormalizedRef | null;
+  /**
+   * SFC only. This is assigned on vnode creation using currentScopeId
+   * which is set alongside currentRenderingInstance.
+   */
+  scopeId: string | null;
+  children: VNodeNormalizedChildren;
+  component: ComponentInternalInstance | null;
+  dirs: DirectiveBinding[] | null;
+  transition: TransitionHooks<HostElement> | null;
+  el: HostNode | null;
+  placeholder: HostNode | null;
+  anchor: HostNode | null;
+  target: HostElement | null;
+  targetStart: HostNode | null;
+  targetAnchor: HostNode | null;
+  suspense: SuspenseBoundary | null;
+  shapeFlag: number;
+  patchFlag: number;
+  appContext: AppContext | null;
+}
+type Data = Record<string, unknown>;
+/**
+ * Public utility type for extracting the instance type of a component.
+ * Works with all valid component definition types. This is intended to replace
+ * the usage of `InstanceType<typeof Comp>` which only works for
+ * constructor-based component definition types.
+ *
+ * @example
+ * ```ts
+ * const MyComp = { ... }
+ * declare const instance: ComponentInstance<typeof MyComp>
+ * ```
+ */
+
+/**
+ * For extending allowed non-declared props on components in TSX
+ */
+interface ComponentCustomProps {}
+/**
+ * For globally defined Directives
+ * Here is an example of adding a directive `VTooltip` as global directive:
+ *
+ * @example
+ * ```ts
+ * import VTooltip from 'v-tooltip'
+ *
+ * declare module '@vue/runtime-core' {
+ *   interface GlobalDirectives {
+ *     VTooltip
+ *   }
+ * }
+ * ```
+ */
+interface GlobalDirectives {}
+/**
+ * For globally defined Components
+ * Here is an example of adding a component `RouterView` as global component:
+ *
+ * @example
+ * ```ts
+ * import { RouterView } from 'vue-router'
+ *
+ * declare module '@vue/runtime-core' {
+ *   interface GlobalComponents {
+ *     RouterView
+ *   }
+ * }
+ * ```
+ */
+interface GlobalComponents {
+  Teleport: DefineComponent<TeleportProps>;
+  Suspense: DefineComponent<SuspenseProps>;
+  KeepAlive: DefineComponent<KeepAliveProps>;
+  BaseTransition: DefineComponent<BaseTransitionProps>;
+}
+/**
+ * Default allowed non-declared props on component in TSX
+ */
+interface AllowedComponentProps {
+  class?: unknown;
+  style?: unknown;
+}
+interface ComponentInternalOptions {
+  /**
+   * Compat build only, for bailing out of certain compatibility behavior
+   */
+  __isBuiltIn?: boolean;
+  /**
+   * This one should be exposed so that devtools can make use of it
+   */
+  __file?: string;
+  /**
+   * name inferred from filename
+   */
+  __name?: string;
+}
+interface FunctionalComponent<P$1 = {}, E extends EmitsOptions | Record<string, any[]> = {}, S extends Record<string, any> = any, EE extends EmitsOptions = ShortEmitsToObject<E>> extends ComponentInternalOptions {
+  (props: P$1 & EmitsToProps<EE>, ctx: Omit<SetupContext<EE, IfAny<S, {}, SlotsType<S>>>, 'expose'>): any;
+  props?: ComponentPropsOptions<P$1>;
+  emits?: EE | (keyof EE)[];
+  slots?: IfAny<S, Slots, SlotsType<S>>;
+  inheritAttrs?: boolean;
+  displayName?: string;
+  compatConfig?: CompatConfig;
+}
+/**
+ * Concrete component type matches its actual value: it's either an options
+ * object, or a function. Use this where the code expects to work with actual
+ * values, e.g. checking if its a function or not. This is mostly for internal
+ * implementation code.
+ */
+type ConcreteComponent<Props$1 = {}, RawBindings = any, D$1 = any, C$1 extends ComputedOptions = ComputedOptions, M$1 extends MethodOptions = MethodOptions, E extends EmitsOptions | Record<string, any[]> = {}, S extends Record<string, any> = any> = ComponentOptions<Props$1, RawBindings, D$1, C$1, M$1> | FunctionalComponent<Props$1, E, S>;
+/**
+ * A type used in public APIs where a component type is expected.
+ * The constructor type is an artificial type returned by defineComponent().
+ */
+type Component<PropsOrInstance = any, RawBindings = any, D$1 = any, C$1 extends ComputedOptions = ComputedOptions, M$1 extends MethodOptions = MethodOptions, E extends EmitsOptions | Record<string, any[]> = {}, S extends Record<string, any> = any> = ConcreteComponent<PropsOrInstance, RawBindings, D$1, C$1, M$1, E, S> | ComponentPublicInstanceConstructor<PropsOrInstance>;
+type SetupContext<E = EmitsOptions, S extends SlotsType = {}> = E extends any ? {
+  attrs: Data;
+  slots: UnwrapSlotsType<S>;
+  emit: EmitFn<E>;
+  expose: <Exposed extends Record<string, any> = Record<string, any>>(exposed?: Exposed) => void;
+} : never;
+/**
+ * We expose a subset of properties on the internal instance as they are
+ * useful for advanced external libraries and tools.
+ */
+interface ComponentInternalInstance {
+  uid: number;
+  type: ConcreteComponent;
+  parent: ComponentInternalInstance | null;
+  root: ComponentInternalInstance;
+  appContext: AppContext;
+  /**
+   * Vnode representing this component in its parent's vdom tree
+   */
+  vnode: VNode;
+  /**
+   * Root vnode of this component's own vdom tree
+   */
+  subTree: VNode;
+  /**
+   * Render effect instance
+   */
+  effect: ReactiveEffect;
+  /**
+   * Force update render effect
+   */
+  update: () => void;
+  /**
+   * Render effect job to be passed to scheduler (checks if dirty)
+   */
+  job: SchedulerJob;
+  proxy: ComponentPublicInstance | null;
+  exposed: Record<string, any> | null;
+  exposeProxy: Record<string, any> | null;
+  data: Data;
+  props: Data;
+  attrs: Data;
+  slots: InternalSlots;
+  refs: Data;
+  emit: EmitFn;
+  isMounted: boolean;
+  isUnmounted: boolean;
+  isDeactivated: boolean;
+}
+interface WatchEffectOptions extends DebuggerOptions {
+  flush?: 'pre' | 'post' | 'sync';
+}
+interface WatchOptions<Immediate = boolean> extends WatchEffectOptions {
+  immediate?: Immediate;
+  deep?: boolean | number;
+  once?: boolean;
+}
+declare module '@vue/reactivity' {
+  interface RefUnwrapBailTypes {
+    runtimeCoreBailTypes: VNode | {
+      $: ComponentInternalInstance;
+    };
+  }
+}
+// Note: this file is auto concatenated to the end of the bundled d.ts during
+// build.
+
+declare module '@vue/runtime-core' {
+  export interface GlobalComponents {
+    Teleport: DefineComponent<TeleportProps>;
+    Suspense: DefineComponent<SuspenseProps>;
+    KeepAlive: DefineComponent<KeepAliveProps>;
+    BaseTransition: DefineComponent<BaseTransitionProps>;
+  }
+}
 
+// Note: this file is auto concatenated to the end of the bundled d.ts during
+// build.
+type _defineProps = typeof defineProps;
+type _defineEmits = typeof defineEmits;
+type _defineExpose = typeof defineExpose;
+type _defineOptions = typeof defineOptions;
+type _defineSlots = typeof defineSlots;
+type _defineModel = typeof defineModel;
+type _withDefaults = typeof withDefaults;
+declare global {
+  const defineProps: _defineProps;
+  const defineEmits: _defineEmits;
+  const defineExpose: _defineExpose;
+  const defineOptions: _defineOptions;
+  const defineSlots: _defineSlots;
+  const defineModel: _defineModel;
+  const withDefaults: _withDefaults;
+}
+//#endregion
+//#region ../../node_modules/.pnpm/@vue+runtime-dom@3.5.26/node_modules/@vue/runtime-dom/dist/runtime-dom.d.ts
+declare const TRANSITION = "transition";
+declare const ANIMATION = "animation";
+type AnimationTypes = typeof TRANSITION | typeof ANIMATION;
+interface TransitionProps extends BaseTransitionProps<Element> {
+  name?: string;
+  type?: AnimationTypes;
+  css?: boolean;
+  duration?: number | {
+    enter: number;
+    leave: number;
+  };
+  enterFromClass?: string;
+  enterActiveClass?: string;
+  enterToClass?: string;
+  appearFromClass?: string;
+  appearActiveClass?: string;
+  appearToClass?: string;
+  leaveFromClass?: string;
+  leaveActiveClass?: string;
+  leaveToClass?: string;
+}
+type TransitionGroupProps = Omit<TransitionProps, 'mode'> & {
+  tag?: string;
+  moveClass?: string;
+};
+declare const vShowOriginalDisplay: unique symbol;
+declare const vShowHidden: unique symbol;
+interface VShowElement extends HTMLElement {
+  [vShowOriginalDisplay]: string;
+  [vShowHidden]: boolean;
+}
+declare const vShow: ObjectDirective<VShowElement> & {
+  name: 'show';
+};
+declare const systemModifiers: readonly ["ctrl", "shift", "alt", "meta"];
+type SystemModifiers = (typeof systemModifiers)[number];
+type CompatModifiers = keyof typeof keyNames;
+type VOnModifiers = SystemModifiers | ModifierGuards | CompatModifiers;
+type ModifierGuards = 'shift' | 'ctrl' | 'alt' | 'meta' | 'left' | 'right' | 'stop' | 'prevent' | 'self' | 'middle' | 'exact';
+/**
+ * @private
+ */
+
+declare const keyNames: Record<'esc' | 'space' | 'up' | 'left' | 'right' | 'down' | 'delete', string>;
+/**
+ * @private
+ */
+
+type VOnDirective = Directive<any, any, VOnModifiers>;
+type AssignerFn = (value: any) => void;
+declare const assignKey: unique symbol;
+type ModelDirective<T, Modifiers extends string = string> = ObjectDirective<T & {
+  [assignKey]: AssignerFn;
+  _assigning?: boolean;
+}, any, Modifiers>;
+declare const vModelText: ModelDirective<HTMLInputElement | HTMLTextAreaElement, 'trim' | 'number' | 'lazy'>;
+declare const vModelCheckbox: ModelDirective<HTMLInputElement>;
+declare const vModelRadio: ModelDirective<HTMLInputElement>;
+declare const vModelSelect: ModelDirective<HTMLSelectElement, 'number'>;
+declare const vModelDynamic: ObjectDirective<HTMLInputElement | HTMLSelectElement | HTMLTextAreaElement>;
+type VModelDirective = typeof vModelText | typeof vModelCheckbox | typeof vModelSelect | typeof vModelRadio | typeof vModelDynamic;
+/**
+ * This is a stub implementation to prevent the need to use dom types.
+ *
+ * To enable proper types, add `"dom"` to `"lib"` in your `tsconfig.json`.
+ */
+type DomType<T> = typeof globalThis extends {
+  window: unknown;
+} ? T : never;
+declare module '@vue/reactivity' {
+  interface RefUnwrapBailTypes {
+    runtimeDOMBailTypes: DomType<Node | Window>;
+  }
+}
+declare module '@vue/runtime-core' {
+  interface GlobalComponents {
+    Transition: DefineComponent<TransitionProps>;
+    TransitionGroup: DefineComponent<TransitionGroupProps>;
+  }
+  interface GlobalDirectives {
+    vShow: typeof vShow;
+    vOn: VOnDirective;
+    vBind: VModelDirective;
+    vIf: Directive<any, boolean>;
+    vOnce: Directive;
+    vSlot: Directive;
+  }
+}
+//#endregion
 //#region src/Timescope.vue.d.ts
-declare const __VLS_export: <Source extends Record<string, TimescopeSourceInput>, SourceName extends Record<string, keyof Source>, TimeDef extends Record<string, FieldDefLike<TimescopeTimeLike<never>>>, ValueDef extends Record<string, FieldDefLike<TimescopeNumberLike | null>>, Track extends string>(__VLS_props: NonNullable<Awaited<typeof __VLS_setup>>["props"], __VLS_ctx?: __VLS_PrettifyLocal<Pick<NonNullable<Awaited<typeof __VLS_setup>>, "attrs" | "emit" | "slots">>, __VLS_expose?: NonNullable<Awaited<typeof __VLS_setup>>["expose"], __VLS_setup?: Promise<{
+declare const __VLS_export: <Source extends Record<string, TimescopeSourceInput>, SourceName extends Record<string, keyof Source>, TimeDef extends Record<string, FieldDefLike<TimeLike<never>>>, ValueDef extends Record<string, FieldDefLike<NumberLike | null>>, Track extends string>(__VLS_props: NonNullable<Awaited<typeof __VLS_setup>>["props"], __VLS_ctx?: __VLS_PrettifyLocal<Pick<NonNullable<Awaited<typeof __VLS_setup>>, "attrs" | "emit" | "slots">>, __VLS_exposed?: NonNullable<Awaited<typeof __VLS_setup>>["expose"], __VLS_setup?: Promise<{
   props: __VLS_PrettifyLocal<{
     width?: string;
     height?: string;
-    stack?: "vertical" | "horizontal";
-    time?: Decimal$1 | number | null | string | Date;
-    timeRange?: [Decimal$1 | number | null | string | Date | undefined, Decimal$1 | number | null | string | Date | undefined];
+    time?: Decimal | number | null | string | Date;
+    timeRange?: [Decimal | number | null | string | Date | undefined, Decimal | number | null | string | Date | undefined];
     zoom?: number;
     zoomRange?: [number | undefined, number | undefined];
     sources?: TimescopeOptionsSources<Source>;
@@ -20,33 +1795,49 @@ declare const __VLS_export: <Source extends Record<string, TimescopeSourceInput>
     showFps?: boolean;
     fonts?: TimescopeOptionsInitial<any, any, any, any, any>["fonts"];
   } & {
-    onTimechanged?: ((args_0: Decimal$1 | null) => any) | undefined;
-    onTimechanging?: ((args_0: Decimal$1 | null) => any) | undefined;
+    onTimechanged?: ((args_0: Decimal | null) => any) | undefined;
+    onTimechanging?: ((args_0: Decimal | null) => any) | undefined;
+    onTimeanimating?: ((args_0: Decimal | null) => any) | undefined;
     onZoomchanged?: ((args_0: number) => any) | undefined;
     onZoomchanging?: ((args_0: number) => any) | undefined;
-    onRangechanging?: ((args_0: [Decimal$1, Decimal$1]) => any) | undefined;
-    onRangechanged?: ((args_0: [Decimal$1, Decimal$1] | null) => any) | undefined;
-    "onUpdate:time"?: ((args_0: Decimal$1 | null) => any) | undefined;
+    onZoomanimating?: ((args_0: number) => any) | undefined;
+    onRangechanging?: ((args_0: [Decimal, Decimal]) => any) | undefined;
+    onRangechanged?: ((args_0: [Decimal, Decimal] | null) => any) | undefined;
+    "onUpdate:time"?: ((args_0: Decimal | null) => any) | undefined;
     "onUpdate:zoom"?: ((args_0: number) => any) | undefined;
-  }> & vue0.PublicProps & (typeof globalThis extends {
+    "onUpdate:timechanging"?: ((args_0: Decimal | null) => any) | undefined;
+    "onUpdate:zoomchanging"?: ((args_0: number) => any) | undefined;
+    "onUpdate:timeanimating"?: ((args_0: Decimal | null) => any) | undefined;
+    "onUpdate:zoomanimating"?: ((args_0: number) => any) | undefined;
+  }> & PublicProps & (typeof globalThis extends {
     __VLS_PROPS_FALLBACK: infer P;
   } ? P : {});
-  expose: (exposed: vue0.ShallowUnwrapRef<{
-    api: vue0.Raw<Timescope<Record<string, TimescopeSourceInput>, Record<string, string>, Record<string, FieldDefLike<TimescopeTimeLike<never>>>, Record<string, FieldDefLike<TimescopeNumberLike | null>>, string>>;
+  expose: (exposed: ShallowUnwrapRef<{
+    time: Ref<number | boolean | Decimal | null, number | boolean | Decimal | null>;
+    timeChanging: Ref<number | boolean | Decimal | null, number | boolean | Decimal | null>;
+    timeAnimating: Ref<number | boolean | Decimal | null, number | boolean | Decimal | null>;
+    zoom: Ref<number | boolean | Decimal | null, number | boolean | Decimal | null>;
+    zoomChanging: Ref<number | boolean | Decimal | null, number | boolean | Decimal | null>;
+    zoomAnimating: Ref<number | boolean | Decimal | null, number | boolean | Decimal | null>;
+    animating: Ref<number | boolean | Decimal | null, number | boolean | Decimal | null>;
+    editing: Ref<number | boolean | Decimal | null, number | boolean | Decimal | null>;
+    setTime: (v: TimeLike | null, animation?: TimescopeAnimationInput) => boolean;
+    setZoom: (v: NumberLike, animation?: TimescopeAnimationInput) => boolean;
+    fitTo: (range: TimescopeRange<TimeLike<never>>, opts?: TimescopeFitOptions) => boolean;
   }>) => void;
   attrs: any;
   slots: {};
-  emit: ((evt: "timechanged", args_0: Decimal$1 | null) => void) & ((evt: "timechanging", args_0: Decimal$1 | null) => void) & ((evt: "zoomchanged", args_0: number) => void) & ((evt: "zoomchanging", args_0: number) => void) & ((evt: "rangechanging", args_0: [Decimal$1, Decimal$1]) => void) & ((evt: "rangechanged", args_0: [Decimal$1, Decimal$1] | null) => void) & ((evt: "update:time", args_0: Decimal$1 | null) => void) & ((evt: "update:zoom", args_0: number) => void);
-}>) => vue0.VNode & {
+  emit: ((evt: "timechanged", args_0: Decimal | null) => void) & ((evt: "timechanging", args_0: Decimal | null) => void) & ((evt: "timeanimating", args_0: Decimal | null) => void) & ((evt: "zoomchanged", args_0: number) => void) & ((evt: "zoomchanging", args_0: number) => void) & ((evt: "zoomanimating", args_0: number) => void) & ((evt: "rangechanging", args_0: [Decimal, Decimal]) => void) & ((evt: "rangechanged", args_0: [Decimal, Decimal] | null) => void) & ((evt: "update:time", args_0: Decimal | null) => void) & ((evt: "update:zoom", args_0: number) => void) & ((evt: "update:timechanging", args_0: Decimal | null) => void) & ((evt: "update:zoomchanging", args_0: number) => void) & ((evt: "update:timeanimating", args_0: Decimal | null) => void) & ((evt: "update:zoomanimating", args_0: number) => void);
+}>) => VNode & {
   __ctx?: Awaited<typeof __VLS_setup>;
 };
 declare const _default: typeof __VLS_export;
-type __VLS_PrettifyLocal<T> = { [K in keyof T as K]: T[K] } & {};
+type __VLS_PrettifyLocal<T> = (T extends any ? { [K in keyof T]: T[K] } : { [K in keyof T as K]: T[K] }) & {};
 //#endregion
 //#region src/index.d.ts
-declare const defineTimescopeOptions: <Source extends Record<string, timescope0.TimescopeSourceInput>, SourceName extends Record<string, keyof Source>, TimeDef extends Record<string, timescope0.FieldDefLike<timescope0.TimescopeTimeLike<never>>>, ValueDef extends Record<string, timescope0.FieldDefLike<timescope0.TimescopeNumberLike | null>>, Track extends string>(opts: timescope0.TimescopeOptions<Source, SourceName, TimeDef, ValueDef, Track>) => typeof opts;
-declare const defineTimescopeSources: <Source extends Record<string, timescope0.TimescopeSourceInput>>(opts: timescope0.TimescopeOptionsSources<Source>) => typeof opts;
-declare const defineTimescopeTracks: <Track extends string>(opts: timescope0.TimescopeOptionsTracks<Track>) => typeof opts;
-declare const defineTimescopeSeries: <Source extends Record<string, timescope0.TimescopeSourceInput>, SourceName extends Record<string, keyof Source>, TimeDef extends Record<string, timescope0.FieldDefLike<timescope0.TimescopeTimeLike<never>>>, ValueDef extends Record<string, timescope0.FieldDefLike<timescope0.TimescopeNumberLike | null>>, Track extends string = "default">(opts: timescope0.TimescopeOptionsSeries<Source, SourceName, TimeDef, ValueDef, Track>, sources?: timescope0.TimescopeOptionsSources<Source>, tracks?: timescope0.TimescopeOptionsTracks<Track>) => typeof opts;
+declare const defineTimescopeOptions: <Source extends Record<string, TimescopeSourceInput>, SourceName extends Record<string, keyof Source>, TimeDef extends Record<string, FieldDefLike<TimeLike<never>>>, ValueDef extends Record<string, FieldDefLike<NumberLike | null>>, Track extends string>(opts: TimescopeOptions<Source, SourceName, TimeDef, ValueDef, Track>) => typeof opts;
+declare const defineTimescopeSources: <Source extends Record<string, TimescopeSourceInput>>(opts: TimescopeOptionsSources<Source>) => typeof opts;
+declare const defineTimescopeTracks: <Track extends string>(opts: TimescopeOptionsTracks<Track>) => typeof opts;
+declare const defineTimescopeSeries: <Source extends Record<string, TimescopeSourceInput>, SourceName extends Record<string, keyof Source>, TimeDef extends Record<string, FieldDefLike<TimeLike<never>>>, ValueDef extends Record<string, FieldDefLike<NumberLike | null>>, Track extends string = "default">(opts: TimescopeOptionsSeries<Source, SourceName, TimeDef, ValueDef, Track>, sources?: TimescopeOptionsSources<Source>, tracks?: TimescopeOptionsTracks<Track>) => typeof opts;
 //#endregion
 export { Decimal, _default as Timescope, defineTimescopeOptions, defineTimescopeSeries, defineTimescopeSources, defineTimescopeTracks };