vccs 0.0.1 → 0.2.0

package/dist/cartesian/axis/YAxis.d.ts

@@ -0,0 +1,192 @@
+import { PropType } from 'vue';
+import { DataKey } from '../../types';
+import { AxisDomain, AxisInterval } from '../../types/axis';
+export declare const YAxis: import('vue').DefineComponent<import('vue').ExtractPropTypes<{
+    allowDataOverflow: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    allowDecimals: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    allowDuplicatedCategory: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    width: {
+        type: NumberConstructor;
+        default: number;
+    };
+    hide: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    mirror: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    orientation: {
+        type: StringConstructor;
+        default: import('../../state/cartesianAxisSlice').YAxisOrientation;
+    };
+    padding: {
+        type: ObjectConstructor;
+        default: import('../../state/cartesianAxisSlice').YAxisPadding;
+    };
+    reversed: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    scale: {
+        type: (StringConstructor | FunctionConstructor)[];
+        default: import('../../types/scale').ScaleType | import('../../types/scale').RechartsScale;
+    };
+    tickCount: {
+        type: NumberConstructor;
+        default: number;
+    };
+    type: {
+        type: StringConstructor;
+        default: import('../../types/axis').AxisDomainType;
+    };
+    yAxisId: {
+        type: (NumberConstructor | StringConstructor)[];
+    };
+    dataKey: {
+        type: PropType<DataKey<any>>;
+        default: any;
+    };
+    tickFormatter: {
+        type: FunctionConstructor;
+        default: any;
+    };
+    unit: {
+        type: StringConstructor;
+        default: any;
+    };
+    interval: {
+        type: PropType<AxisInterval>;
+    };
+    domain: {
+        type: PropType<AxisDomain>;
+        default: any;
+    };
+    axisLine: {
+        type: (ObjectConstructor | BooleanConstructor)[];
+        default: boolean;
+    };
+    tickLine: {
+        type: (ObjectConstructor | BooleanConstructor)[];
+        default: boolean;
+    };
+    tickMargin: NumberConstructor;
+    minTickGap: {
+        type: NumberConstructor;
+        default: number;
+    };
+}>, () => import("vue/jsx-runtime").JSX.Element, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<{
+    allowDataOverflow: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    allowDecimals: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    allowDuplicatedCategory: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    width: {
+        type: NumberConstructor;
+        default: number;
+    };
+    hide: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    mirror: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    orientation: {
+        type: StringConstructor;
+        default: import('../../state/cartesianAxisSlice').YAxisOrientation;
+    };
+    padding: {
+        type: ObjectConstructor;
+        default: import('../../state/cartesianAxisSlice').YAxisPadding;
+    };
+    reversed: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    scale: {
+        type: (StringConstructor | FunctionConstructor)[];
+        default: import('../../types/scale').ScaleType | import('../../types/scale').RechartsScale;
+    };
+    tickCount: {
+        type: NumberConstructor;
+        default: number;
+    };
+    type: {
+        type: StringConstructor;
+        default: import('../../types/axis').AxisDomainType;
+    };
+    yAxisId: {
+        type: (NumberConstructor | StringConstructor)[];
+    };
+    dataKey: {
+        type: PropType<DataKey<any>>;
+        default: any;
+    };
+    tickFormatter: {
+        type: FunctionConstructor;
+        default: any;
+    };
+    unit: {
+        type: StringConstructor;
+        default: any;
+    };
+    interval: {
+        type: PropType<AxisInterval>;
+    };
+    domain: {
+        type: PropType<AxisDomain>;
+        default: any;
+    };
+    axisLine: {
+        type: (ObjectConstructor | BooleanConstructor)[];
+        default: boolean;
+    };
+    tickLine: {
+        type: (ObjectConstructor | BooleanConstructor)[];
+        default: boolean;
+    };
+    tickMargin: NumberConstructor;
+    minTickGap: {
+        type: NumberConstructor;
+        default: number;
+    };
+}>> & Readonly<{}>, {
+    tickFormatter: Function;
+    unit: string;
+    width: number;
+    scale: string | Function;
+    padding: Record<string, any>;
+    type: string;
+    dataKey: DataKey<any>;
+    orientation: string;
+    tickCount: number;
+    hide: boolean;
+    allowDuplicatedCategory: boolean;
+    allowDataOverflow: boolean;
+    reversed: boolean;
+    domain: AxisDomain;
+    allowDecimals: boolean;
+    mirror: boolean;
+    minTickGap: number;
+    axisLine: boolean | Record<string, any>;
+    tickLine: boolean | Record<string, any>;
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;

package/dist/cartesian/axis/index.d.ts

@@ -0,0 +1,2 @@
+export { XAxis } from './XAxis';
+export { YAxis } from './YAxis';

package/dist/cartesian/axis/type.d.ts

@@ -0,0 +1,57 @@
+import { DataKey } from '../../types';
+import { AxisDomain, AxisDomainType, AxisRange } from '../../types/axis';
+import { RechartsScale, ScaleType } from '../../types/scale';
+import { SVGAttributes } from 'vue';
+export interface BaseAxisProps {
+    /** The type of axis */
+    type?: AxisDomainType;
+    /** The key of data displayed in the axis */
+    dataKey?: DataKey<any>;
+    /** Whether display the axis */
+    hide?: boolean;
+    /** The scale type as a string, or scale function */
+    scale?: ScaleType | RechartsScale;
+    /** The option for tick */
+    tick?: object;
+    /** The count of ticks */
+    tickCount?: number;
+    /** The option for axisLine */
+    axisLine?: boolean | SVGAttributes;
+    /** The option for tickLine */
+    tickLine?: boolean | SVGAttributes;
+    /** The size of tick line */
+    tickSize?: number;
+    /** The formatter function of tick */
+    tickFormatter?: (value: any, index: number) => string;
+    /**
+     * When domain of the axis is specified and the type of the axis is 'number',
+     * if allowDataOverflow is set to be false,
+     * the domain will be adjusted when the minimum value of data is smaller than domain[0] or
+     * the maximum value of data is greater than domain[1] so that the axis displays all data values.
+     * If set to true, graphic elements (line, area, bars) will be clipped to conform to the specified domain.
+     */
+    allowDataOverflow?: boolean;
+    /**
+     * Allow the axis has duplicated categories or not when the type of axis is "category".
+     */
+    allowDuplicatedCategory?: boolean;
+    /**
+     * Allow the ticks of axis to be decimals or not.
+     */
+    allowDecimals?: boolean;
+    /** The domain of scale in this axis */
+    domain?: AxisDomain;
+    /** Consider hidden elements when computing the domain (defaults to false) */
+    includeHidden?: boolean;
+    /** The name of data displayed in the axis */
+    name?: string;
+    /** The unit of data displayed in the axis */
+    unit?: string;
+    range?: AxisRange;
+    /** axis vue component  ?as? */
+    AxisComp?: any;
+    /** Needed to allow usage of the label prop on the X and Y axis */
+    label?: string | number | object;
+    /** The HTML element's class name */
+    className?: string;
+}

package/dist/cartesian/bar/Bar.d.ts

@@ -0,0 +1,2 @@
+import { BarPropsWithSVG } from './type';
+export declare const Bar: import('vue').DefineComponent<BarPropsWithSVG, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<BarPropsWithSVG> & Readonly<{}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, any>;

package/dist/cartesian/bar/components/BarBackground.d.ts

@@ -0,0 +1 @@
+export declare const BarBackground: import('vue').DefineComponent<{}, () => import("vue/jsx-runtime").JSX.Element, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;

package/dist/cartesian/bar/components/BarRectangles.d.ts

@@ -0,0 +1 @@
+export declare const BarRectangles: import('vue').DefineComponent<{}, () => import("vue/jsx-runtime").JSX.Element, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;

package/dist/cartesian/bar/hooks/useBar.d.ts

@@ -0,0 +1,23 @@
+import { Ref, SVGAttributes, ShallowRef } from 'vue';
+import { BarProps } from '../type';
+import { BarRectangleItem } from '../../../types/bar';
+export interface BarContext {
+    clipPathId: string;
+    layout: Ref<'horizontal' | 'vertical' | 'centric' | 'radial'>;
+    props: BarProps;
+    attrs: SVGAttributes;
+    data: Readonly<ShallowRef<readonly BarRectangleItem[]>>;
+    isAnimating: Ref<boolean>;
+    shapeSlot?: (props: any) => any;
+    activeBarSlot?: (props: any) => any;
+    cellProps: ShallowRef<Record<string, any>[]>;
+}
+export declare const useBarContext: <T extends BarContext = BarContext>(fallback?: T) => T extends null ? BarContext : BarContext, provideBarContext: (contextValue: BarContext) => BarContext;
+export declare function useBar(props: BarProps, shapeSlot?: (props: any) => any, activeBarSlot?: (props: any) => any): {
+    shouldRender: import('vue').ComputedRef<boolean>;
+    needClip: import('vue').ComputedRef<boolean>;
+    clipPathId: string;
+    barData: Readonly<ShallowRef<readonly BarRectangleItem[]>>;
+    isAnimating: Ref<boolean, boolean>;
+    cellProps: ShallowRef<Record<string, any>[], Record<string, any>[]>;
+};

package/dist/cartesian/bar/index.d.ts

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

package/dist/cartesian/bar/type.d.ts

@@ -0,0 +1,166 @@
+import { ChartData } from '../../state/chartDataSlice';
+import { Coordinate, DataKey, TooltipType, VuePropsToType, WithSVGProps } from '../../types';
+import { AnimationOptions } from 'motion-v';
+import { AxisId } from '../../types/axis';
+import { PropType } from 'vue';
+import { LegendType } from '../../types/legend';
+import { MinPointSize } from '../../shape';
+export type Rectangle = {
+    x: number | null;
+    y: number | null;
+    width: number;
+    height: number;
+};
+export type BarRectangleItem = {
+    value?: number | [number, number];
+    background?: Rectangle;
+    tooltipPosition: Coordinate;
+    readonly payload?: any;
+    x: number | null;
+    y: number | null;
+    width: number;
+    height: number;
+};
+export declare const BarVueProps: {
+    class: {
+        type: StringConstructor;
+        default: any;
+    };
+    barSize: {
+        type: PropType<string | number>;
+    };
+    data: {
+        type: PropType<ChartData>;
+        default: any;
+    };
+    dataKey: {
+        type: PropType<DataKey<any>>;
+        required: boolean;
+    };
+    fill: {
+        type: StringConstructor;
+        default: any;
+    };
+    stroke: {
+        type: StringConstructor;
+        default: any;
+    };
+    strokeWidth: {
+        type: NumberConstructor;
+        default: number;
+    };
+    unit: {
+        type: PropType<string | number>;
+        default: any;
+    };
+    name: {
+        type: PropType<string | number>;
+    };
+    tooltipType: {
+        type: PropType<TooltipType>;
+        default: any;
+    };
+    legendType: {
+        type: PropType<LegendType>;
+        default: string;
+    };
+    minPointSize: {
+        type: PropType<MinPointSize>;
+        default: number;
+    };
+    maxBarSize: {
+        type: NumberConstructor;
+    };
+    hide: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    background: {
+        type: PropType<boolean | Record<string, any>>;
+        default: boolean;
+    };
+    radius: {
+        type: PropType<number | [number, number, number, number]>;
+        default: any;
+    };
+    onAnimationStart: {
+        type: PropType<() => void>;
+        default: any;
+    };
+    onAnimationEnd: {
+        type: PropType<() => void>;
+        default: any;
+    };
+    isAnimationActive: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    activeBar: {
+        type: PropType<Record<string, any> | boolean>;
+        default: boolean;
+    };
+    activeIndex: {
+        type: NumberConstructor;
+        default: any;
+    };
+    id: {
+        type: StringConstructor;
+        default: any;
+    };
+    stackId: {
+        type: PropType<string | number>;
+        default: any;
+    };
+    xAxisId: {
+        type: PropType<AxisId>;
+        default: number;
+    };
+    yAxisId: {
+        type: PropType<AxisId>;
+        default: number;
+    };
+    animationBegin: {
+        type: NumberConstructor;
+        default: number;
+    };
+    animationDuration: {
+        type: NumberConstructor;
+        default: number;
+    };
+    animationEasing: {
+        type: StringConstructor;
+        default: string;
+    };
+    transition: {
+        type: PropType<AnimationOptions>;
+        default: {
+            duration: number;
+            ease: string;
+        };
+    };
+    needClip: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    label: {
+        type: PropType<boolean | Record<string, any>>;
+        default: boolean;
+    };
+};
+export type BarProps = VuePropsToType<typeof BarVueProps>;
+export type BarPropsWithSVG = WithSVGProps<typeof BarVueProps>;
+export type BarSettings = {
+    barSize?: string | number;
+    data?: ChartData;
+    dataKey: DataKey<any>;
+    maxBarSize?: number;
+    minPointSize: MinPointSize;
+    stackId?: string | number;
+};
+export type BarMouseEvent = (data: BarRectangleItem, index: number, event: MouseEvent) => void;
+export interface BarEvents {
+    onClick: BarMouseEvent;
+    onMouseEnter: BarMouseEvent;
+    onMouseLeave: BarMouseEvent;
+    onMouseMove: BarMouseEvent;
+}

package/dist/cartesian/bar/utils.d.ts

@@ -0,0 +1,31 @@
+import { TooltipPayloadConfiguration } from '../../state/tooltipSlice';
+import { BarProps, BarSettings } from './type';
+import { BarPositionPosition, BarRectangleItem } from '../../types/bar';
+import { BaseAxisWithScale } from '../../state/selectors/axisSelectors';
+import { DataKey, TickItem } from '../../types';
+import { Series } from 'victory-vendor/d3-shape';
+import { ChartOffsetInternal } from '../../utils/types';
+import { MinPointSize } from '../../shape';
+import { LegendPayload } from '../../components/DefaultLegendContent';
+export declare function computeLegendPayloadFromBarData(props: BarProps): ReadonlyArray<LegendPayload>;
+export declare function getTooltipEntrySettings(props: BarProps): TooltipPayloadConfiguration;
+/**
+ * Safely gets minPointSize from the minPointSize prop if it is a function
+ * @param minPointSize minPointSize as passed to the Bar component
+ * @param defaultValue default minPointSize
+ * @returns minPointSize
+ */
+export declare function minPointSizeCallback(minPointSize: MinPointSize, defaultValue?: number): (value: unknown, index: number) => number;
+export declare function computeBarRectangles({ layout, barSettings: { dataKey, minPointSize: minPointSizeProp }, pos, bandSize, xAxis, yAxis, xAxisTicks, yAxisTicks, stackedData, displayedData, offset, }: {
+    layout: 'horizontal' | 'vertical';
+    barSettings: BarSettings;
+    pos: BarPositionPosition;
+    bandSize: number;
+    xAxis?: BaseAxisWithScale;
+    yAxis?: BaseAxisWithScale;
+    xAxisTicks: TickItem[];
+    yAxisTicks: TickItem[];
+    stackedData: Series<Record<number, number>, DataKey<any>> | undefined;
+    offset: ChartOffsetInternal;
+    displayedData: any[];
+}): ReadonlyArray<BarRectangleItem> | undefined;

package/dist/cartesian/brush/Brush.d.ts

@@ -0,0 +1,2 @@
+import { BrushPropsWithSVG } from './type';
+export declare const Brush: import('vue').DefineComponent<BrushPropsWithSVG, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<BrushPropsWithSVG> & Readonly<{}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;

package/dist/cartesian/brush/components/Background.d.ts

@@ -0,0 +1,15 @@
+export declare const Background: import('vue').DefineComponent<import('vue').ExtractPropTypes<{
+    x: NumberConstructor;
+    y: NumberConstructor;
+    width: NumberConstructor;
+    height: NumberConstructor;
+    fill: StringConstructor;
+    stroke: StringConstructor;
+}>, () => import("vue/jsx-runtime").JSX.Element, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<{
+    x: NumberConstructor;
+    y: NumberConstructor;
+    width: NumberConstructor;
+    height: NumberConstructor;
+    fill: StringConstructor;
+    stroke: StringConstructor;
+}>> & Readonly<{}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;

package/dist/cartesian/brush/components/BrushText.d.ts

@@ -0,0 +1,27 @@
+import { PropType } from 'vue';
+import { DataKey } from '../../../types/common';
+export declare const BrushText: import('vue').DefineComponent<import('vue').ExtractPropTypes<{
+    startIndex: NumberConstructor;
+    endIndex: NumberConstructor;
+    y: NumberConstructor;
+    height: NumberConstructor;
+    travellerWidth: NumberConstructor;
+    stroke: StringConstructor;
+    tickFormatter: PropType<(value: any, index: number) => number | string>;
+    dataKey: PropType<DataKey<any>>;
+    data: PropType<any[]>;
+    startX: NumberConstructor;
+    endX: NumberConstructor;
+}>, () => import("vue/jsx-runtime").JSX.Element, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<{
+    startIndex: NumberConstructor;
+    endIndex: NumberConstructor;
+    y: NumberConstructor;
+    height: NumberConstructor;
+    travellerWidth: NumberConstructor;
+    stroke: StringConstructor;
+    tickFormatter: PropType<(value: any, index: number) => number | string>;
+    dataKey: PropType<DataKey<any>>;
+    data: PropType<any[]>;
+    startX: NumberConstructor;
+    endX: NumberConstructor;
+}>> & Readonly<{}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;

package/dist/cartesian/brush/components/Panorama.d.ts

@@ -0,0 +1,65 @@
+import { PropType } from 'vue';
+import { Padding } from '../../../types/common';
+export declare const Panorama: import('vue').DefineComponent<import('vue').ExtractPropTypes<{
+    x: {
+        type: NumberConstructor;
+        required: true;
+    };
+    y: {
+        type: NumberConstructor;
+        required: true;
+    };
+    width: {
+        type: NumberConstructor;
+        required: true;
+    };
+    height: {
+        type: NumberConstructor;
+        required: true;
+    };
+    data: {
+        type: PropType<any[]>;
+        required: true;
+    };
+    padding: {
+        type: PropType<Padding>;
+        default: () => {
+            top: number;
+            right: number;
+            bottom: number;
+            left: number;
+        };
+    };
+}>, () => import("vue/jsx-runtime").JSX.Element, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<{
+    x: {
+        type: NumberConstructor;
+        required: true;
+    };
+    y: {
+        type: NumberConstructor;
+        required: true;
+    };
+    width: {
+        type: NumberConstructor;
+        required: true;
+    };
+    height: {
+        type: NumberConstructor;
+        required: true;
+    };
+    data: {
+        type: PropType<any[]>;
+        required: true;
+    };
+    padding: {
+        type: PropType<Padding>;
+        default: () => {
+            top: number;
+            right: number;
+            bottom: number;
+            left: number;
+        };
+    };
+}>> & Readonly<{}>, {
+    padding: Padding;
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;

package/dist/cartesian/brush/components/Slide.d.ts

@@ -0,0 +1,20 @@
+export declare const Slide: import('vue').DefineComponent<import('vue').ExtractPropTypes<{
+    y: NumberConstructor;
+    height: NumberConstructor;
+    stroke: StringConstructor;
+    travellerWidth: NumberConstructor;
+    startX: NumberConstructor;
+    endX: NumberConstructor;
+}>, () => import("vue/jsx-runtime").JSX.Element, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, ("mousedown" | "mouseenter" | "mouseleave" | "touchstart")[], "mousedown" | "mouseenter" | "mouseleave" | "touchstart", import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<{
+    y: NumberConstructor;
+    height: NumberConstructor;
+    stroke: StringConstructor;
+    travellerWidth: NumberConstructor;
+    startX: NumberConstructor;
+    endX: NumberConstructor;
+}>> & Readonly<{
+    onMousedown?: (...args: any[]) => any;
+    onMouseenter?: (...args: any[]) => any;
+    onMouseleave?: (...args: any[]) => any;
+    onTouchstart?: (...args: any[]) => any;
+}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;

package/dist/cartesian/brush/components/Traveller.d.ts

@@ -0,0 +1,13 @@
+export declare const Traveller: import('vue').DefineComponent<import('vue').ExtractPropTypes<{
+    x: NumberConstructor;
+    y: NumberConstructor;
+    width: NumberConstructor;
+    height: NumberConstructor;
+    stroke: StringConstructor;
+}>, () => import("vue/jsx-runtime").JSX.Element, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<{
+    x: NumberConstructor;
+    y: NumberConstructor;
+    width: NumberConstructor;
+    height: NumberConstructor;
+    stroke: StringConstructor;
+}>> & Readonly<{}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;

package/dist/cartesian/brush/components/TravellerLayer.d.ts

@@ -0,0 +1,22 @@
+import { BrushProps } from '../type';
+export declare const TravellerLayer: import('vue').DefineComponent<import('vue').ExtractPropTypes<{
+    id: StringConstructor;
+    travellerX: NumberConstructor;
+    otherProps: () => BrushProps & {
+        y: number;
+    };
+}>, () => import("vue/jsx-runtime").JSX.Element, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, ("focus" | "blur" | "mousedown" | "mouseenter" | "mouseleave" | "touchstart" | "traveller-move-keyboard")[], "focus" | "blur" | "mousedown" | "mouseenter" | "mouseleave" | "touchstart" | "traveller-move-keyboard", import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<{
+    id: StringConstructor;
+    travellerX: NumberConstructor;
+    otherProps: () => BrushProps & {
+        y: number;
+    };
+}>> & Readonly<{
+    onFocus?: (...args: any[]) => any;
+    onBlur?: (...args: any[]) => any;
+    onMousedown?: (...args: any[]) => any;
+    onMouseenter?: (...args: any[]) => any;
+    onMouseleave?: (...args: any[]) => any;
+    onTouchstart?: (...args: any[]) => any;
+    "onTraveller-move-keyboard"?: (...args: any[]) => any;
+}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;