@qispace/vue3-player 0.4.34 → 0.4.37

package/dist/vue-components/src/components/shared/VWaypointCarousel.vue.d.ts

@@ -1,53 +1,34 @@
-declare const _default: __VLS_WithTemplateSlots<import('vue').DefineComponent<__VLS_WithDefaults<__VLS_TypePropsToRuntimeProps<{
-    thumbnails: {
+type __VLS_Props = {
+    thumbnails: Array<{
         id: string;
         thumbnailUrl: string;
-    }[];
+    }>;
     active: number;
-    cameraHasSunStudy: (cameraId: string) => boolean;
-}>, {
-    cameraHasSunStudy: (_: string) => false;
-}>, {}, unknown, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
-    previous: () => void;
-    next: () => void;
-    goto: (id: string) => void;
-}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<__VLS_WithDefaults<__VLS_TypePropsToRuntimeProps<{
-    thumbnails: {
-        id: string;
-        thumbnailUrl: string;
-    }[];
-    active: number;
-    cameraHasSunStudy: (cameraId: string) => boolean;
-}>, {
-    cameraHasSunStudy: (_: string) => false;
-}>>> & {
+    cameraHasSunStudy?: (cameraId: string) => boolean;
+};
+declare function __VLS_template(): {
+    attrs: Partial<{}>;
+    slots: {
+        before?(_: {}): any;
+        after?(_: {}): any;
+    };
+    refs: {};
+    rootEl: HTMLDivElement;
+};
+type __VLS_TemplateResult = ReturnType<typeof __VLS_template>;
+declare const __VLS_component: import('vue').DefineComponent<__VLS_Props, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+    previous: () => any;
+    next: () => any;
+    goto: (id: string) => any;
+}, string, import('vue').PublicProps, Readonly<__VLS_Props> & Readonly<{
     onPrevious?: () => any;
     onNext?: () => any;
     onGoto?: (id: string) => any;
-}, {
+}>, {
     cameraHasSunStudy: (cameraId: string) => boolean;
-}, {}>, {
-    before?(_: {}): any;
-    after?(_: {}): any;
-}>;
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, HTMLDivElement>;
+declare const _default: __VLS_WithTemplateSlots<typeof __VLS_component, __VLS_TemplateResult["slots"]>;
 export default _default;
-type __VLS_NonUndefinedable<T> = T extends undefined ? never : T;
-type __VLS_TypePropsToRuntimeProps<T> = {
-    [K in keyof T]-?: {} extends Pick<T, K> ? {
-        type: import('vue').PropType<__VLS_NonUndefinedable<T[K]>>;
-    } : {
-        type: import('vue').PropType<T[K]>;
-        required: true;
-    };
-};
-type __VLS_WithDefaults<P, D> = {
-    [K in keyof Pick<P, keyof P>]: K extends keyof D ? __VLS_Prettify<P[K] & {
-        default: D[K];
-    }> : P[K];
-};
-type __VLS_Prettify<T> = {
-    [K in keyof T]: T[K];
-} & {};
 type __VLS_WithTemplateSlots<T, S> = T & {
     new (): {
         $slots: S;

package/dist/vue-components/src/components/shared/VZoomBox.vue.d.ts

@@ -1,21 +1,28 @@
-declare function adjustZoom(delta: number, x?: number, y?: number): void;
-declare const _default: __VLS_WithTemplateSlots<import('vue').DefineComponent<__VLS_WithDefaults<__VLS_TypePropsToRuntimeProps<{
+type __VLS_Props = {
     desktop?: boolean;
     mobile?: boolean;
     maxScale?: number;
     consumeMouseClickWhenMoved?: boolean;
     consumeMouseUpWhenMoved?: boolean;
-    position?: "absolute" | "relative";
-}>, {
-    desktop: boolean;
-    mobile: boolean;
-    maxScale: number;
-    consumeMouseClickWhenMoved: boolean;
-    consumeMouseUpWhenMoved: boolean;
-    position: string;
-}>, {
+    position?: 'absolute' | 'relative';
+};
+declare function adjustZoom(delta: number, x?: number, y?: number): void;
+declare function __VLS_template(): {
+    attrs: Partial<{}>;
+    slots: Readonly<{
+        default: [];
+    }> & {
+        default: [];
+    };
+    refs: {
+        box: HTMLDivElement;
+    };
+    rootEl: HTMLDivElement;
+};
+type __VLS_TemplateResult = ReturnType<typeof __VLS_template>;
+declare const __VLS_component: import('vue').DefineComponent<__VLS_Props, {
     adjustZoom: typeof adjustZoom;
-}, unknown, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
     update: (event: {
         scale: number;
         x: number;
@@ -24,22 +31,8 @@ declare const _default: __VLS_WithTemplateSlots<import('vue').DefineComponent<__
         min: number;
         max: number;
         resolve: (projectedX: number, projectedY: number) => void;
-    }) => void;
-}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<__VLS_WithDefaults<__VLS_TypePropsToRuntimeProps<{
-    desktop?: boolean;
-    mobile?: boolean;
-    maxScale?: number;
-    consumeMouseClickWhenMoved?: boolean;
-    consumeMouseUpWhenMoved?: boolean;
-    position?: "absolute" | "relative";
-}>, {
-    desktop: boolean;
-    mobile: boolean;
-    maxScale: number;
-    consumeMouseClickWhenMoved: boolean;
-    consumeMouseUpWhenMoved: boolean;
-    position: string;
-}>>> & {
+    }) => any;
+}, string, import('vue').PublicProps, Readonly<__VLS_Props> & Readonly<{
     onUpdate?: (event: {
         scale: number;
         x: number;
@@ -49,36 +42,18 @@ declare const _default: __VLS_WithTemplateSlots<import('vue').DefineComponent<__
         max: number;
         resolve: (projectedX: number, projectedY: number) => void;
     }) => any;
-}, {
-    mobile: boolean;
-    position: "absolute" | "relative";
+}>, {
     desktop: boolean;
+    mobile: boolean;
     maxScale: number;
     consumeMouseClickWhenMoved: boolean;
     consumeMouseUpWhenMoved: boolean;
-}, {}>, Readonly<{
-    default: [];
-}> & {
-    default: [];
-}>;
+    position: "absolute" | "relative";
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {
+    box: HTMLDivElement;
+}, HTMLDivElement>;
+declare const _default: __VLS_WithTemplateSlots<typeof __VLS_component, __VLS_TemplateResult["slots"]>;
 export default _default;
-type __VLS_NonUndefinedable<T> = T extends undefined ? never : T;
-type __VLS_TypePropsToRuntimeProps<T> = {
-    [K in keyof T]-?: {} extends Pick<T, K> ? {
-        type: import('vue').PropType<__VLS_NonUndefinedable<T[K]>>;
-    } : {
-        type: import('vue').PropType<T[K]>;
-        required: true;
-    };
-};
-type __VLS_WithDefaults<P, D> = {
-    [K in keyof Pick<P, keyof P>]: K extends keyof D ? __VLS_Prettify<P[K] & {
-        default: D[K];
-    }> : P[K];
-};
-type __VLS_Prettify<T> = {
-    [K in keyof T]: T[K];
-} & {};
 type __VLS_WithTemplateSlots<T, S> = T & {
     new (): {
         $slots: S;

package/dist/vue-components/src/components/structureChooser/VStructureChooser.vue.d.ts

@@ -1,7 +1,7 @@
+import { nextTick } from 'vue';
 import { StructureChooserData } from './types';
 import { ColorCallback, CdnFileResolverCallback, I18NConfig, Pos } from '../types';
-
-declare const _default: __VLS_WithTemplateSlots<import('vue').DefineComponent<__VLS_WithDefaults<__VLS_TypePropsToRuntimeProps<{
+type __VLS_Props = {
     structureChooserData: StructureChooserData;
     cdnFileResolver: CdnFileResolverCallback;
     colorCallback?: ColorCallback;
@@ -15,19 +15,184 @@ declare const _default: __VLS_WithTemplateSlots<import('vue').DefineComponent<__
     version?: string;
     showVersion?: boolean;
     showUi?: boolean;
-    activeStructureIds?: string[];
-}>, {
-    colorCallback: () => {
-        r: number;
-        g: number;
-        b: number;
-        a: number;
-        s: number;
+    activeStructureIds?: Array<string>;
+};
+declare function __VLS_template(): {
+    attrs: Partial<{}>;
+    slots: Readonly<{
+        default(): any;
+        popup(props: {
+            hoverId: string;
+            hoverable: boolean;
+        }): any;
+    }> & {
+        default(): any;
+        popup(props: {
+            hoverId: string;
+            hoverable: boolean;
+        }): any;
     };
-    mobileBreakpoint: number;
-    showVersion: boolean;
-    showUi: boolean;
-}>, {
+    refs: {
+        container: HTMLDivElement;
+        zoomBox: {
+            $: import('vue').ComponentInternalInstance;
+            $data: {};
+            $props: Partial<{
+                desktop: boolean;
+                mobile: boolean;
+                maxScale: number;
+                consumeMouseClickWhenMoved: boolean;
+                consumeMouseUpWhenMoved: boolean;
+                position: "absolute" | "relative";
+            }> & Omit<{
+                readonly desktop?: boolean;
+                readonly mobile?: boolean;
+                readonly maxScale?: number;
+                readonly consumeMouseClickWhenMoved?: boolean;
+                readonly consumeMouseUpWhenMoved?: boolean;
+                readonly position?: "absolute" | "relative";
+                readonly onUpdate?: (event: {
+                    scale: number;
+                    x: number;
+                    y: number;
+                    current: number;
+                    min: number;
+                    max: number;
+                    resolve: (projectedX: number, projectedY: number) => void;
+                }) => any;
+            } & import('vue').VNodeProps & import('vue').AllowedComponentProps & import('vue').ComponentCustomProps, "desktop" | "mobile" | "maxScale" | "consumeMouseClickWhenMoved" | "consumeMouseUpWhenMoved" | "position">;
+            $attrs: {
+                [x: string]: unknown;
+            };
+            $refs: {
+                [x: string]: unknown;
+            } & {
+                box: HTMLDivElement;
+            };
+            $slots: Readonly<{
+                [name: string]: import('vue').Slot<any>;
+            }>;
+            $root: import('vue').ComponentPublicInstance | null;
+            $parent: import('vue').ComponentPublicInstance | null;
+            $host: Element | null;
+            $emit: (event: "update", event: {
+                scale: number;
+                x: number;
+                y: number;
+                current: number;
+                min: number;
+                max: number;
+                resolve: (projectedX: number, projectedY: number) => void;
+            }) => void;
+            $el: HTMLDivElement;
+            $options: import('vue').ComponentOptionsBase<Readonly<{
+                desktop?: boolean;
+                mobile?: boolean;
+                maxScale?: number;
+                consumeMouseClickWhenMoved?: boolean;
+                consumeMouseUpWhenMoved?: boolean;
+                position?: "absolute" | "relative";
+            }> & Readonly<{
+                onUpdate?: (event: {
+                    scale: number;
+                    x: number;
+                    y: number;
+                    current: number;
+                    min: number;
+                    max: number;
+                    resolve: (projectedX: number, projectedY: number) => void;
+                }) => any;
+            }>, {
+                adjustZoom: (delta: number, x?: number, y?: number) => void;
+            }, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+                update: (event: {
+                    scale: number;
+                    x: number;
+                    y: number;
+                    current: number;
+                    min: number;
+                    max: number;
+                    resolve: (projectedX: number, projectedY: number) => void;
+                }) => any;
+            }, string, {
+                desktop: boolean;
+                mobile: boolean;
+                maxScale: number;
+                consumeMouseClickWhenMoved: boolean;
+                consumeMouseUpWhenMoved: boolean;
+                position: "absolute" | "relative";
+            }, {}, string, {}, import('vue').GlobalComponents, import('vue').GlobalDirectives, string, import('vue').ComponentProvideOptions> & {
+                beforeCreate?: (() => void) | (() => void)[];
+                created?: (() => void) | (() => void)[];
+                beforeMount?: (() => void) | (() => void)[];
+                mounted?: (() => void) | (() => void)[];
+                beforeUpdate?: (() => void) | (() => void)[];
+                updated?: (() => void) | (() => void)[];
+                activated?: (() => void) | (() => void)[];
+                deactivated?: (() => void) | (() => void)[];
+                beforeDestroy?: (() => void) | (() => void)[];
+                beforeUnmount?: (() => void) | (() => void)[];
+                destroyed?: (() => void) | (() => void)[];
+                unmounted?: (() => void) | (() => void)[];
+                renderTracked?: ((e: import('vue').DebuggerEvent) => void) | ((e: import('vue').DebuggerEvent) => void)[];
+                renderTriggered?: ((e: import('vue').DebuggerEvent) => void) | ((e: import('vue').DebuggerEvent) => void)[];
+                errorCaptured?: ((err: unknown, instance: import('vue').ComponentPublicInstance | null, info: string) => boolean | void) | ((err: unknown, instance: import('vue').ComponentPublicInstance | null, info: string) => boolean | void)[];
+            };
+            $forceUpdate: () => void;
+            $nextTick: typeof nextTick;
+            $watch<T extends string | ((...args: any) => any)>(source: T, cb: T extends (...args: any) => infer R ? (...args: [R, R, import('@vue/reactivity').OnCleanup]) => any : (...args: [any, any, import('@vue/reactivity').OnCleanup]) => any, options?: import('vue').WatchOptions): import('vue').WatchStopHandle;
+        } & Readonly<{
+            desktop: boolean;
+            mobile: boolean;
+            maxScale: number;
+            consumeMouseClickWhenMoved: boolean;
+            consumeMouseUpWhenMoved: boolean;
+            position: "absolute" | "relative";
+        }> & Omit<Readonly<{
+            desktop?: boolean;
+            mobile?: boolean;
+            maxScale?: number;
+            consumeMouseClickWhenMoved?: boolean;
+            consumeMouseUpWhenMoved?: boolean;
+            position?: "absolute" | "relative";
+        }> & Readonly<{
+            onUpdate?: (event: {
+                scale: number;
+                x: number;
+                y: number;
+                current: number;
+                min: number;
+                max: number;
+                resolve: (projectedX: number, projectedY: number) => void;
+            }) => any;
+        }>, "adjustZoom" | ("desktop" | "mobile" | "maxScale" | "consumeMouseClickWhenMoved" | "consumeMouseUpWhenMoved" | "position")> & import('vue').ShallowUnwrapRef<{
+            adjustZoom: (delta: number, x?: number, y?: number) => void;
+        }> & {} & import('vue').ComponentCustomProperties & {} & {
+            $slots: Readonly<{
+                default: [];
+            }> & {
+                default: [];
+            };
+        };
+        hoverProbe: import('vue').CreateComponentPublicInstanceWithMixins<Readonly<{}> & Readonly<{}>, {
+            isHoverEnabled: import('vue').ComputedRef<boolean>;
+        }, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, import('vue').PublicProps, {}, true, {}, {}, import('vue').GlobalComponents, import('vue').GlobalDirectives, string, {
+            hoverCheck: HTMLDivElement;
+        }, HTMLDivElement, import('vue').ComponentProvideOptions, {
+            P: {};
+            B: {};
+            D: {};
+            C: {};
+            M: {};
+            Defaults: {};
+        }, Readonly<{}> & Readonly<{}>, {
+            isHoverEnabled: import('vue').ComputedRef<boolean>;
+        }, {}, {}, {}, {}>;
+    };
+    rootEl: any;
+};
+type __VLS_TemplateResult = ReturnType<typeof __VLS_template>;
+declare const __VLS_component: import('vue').DefineComponent<__VLS_Props, {
     getState: () => {
         currentCameraIndex: number;
         currentDayIndex: number;
@@ -46,90 +211,192 @@ declare const _default: __VLS_WithTemplateSlots<import('vue').DefineComponent<__
         x: number;
         y: number;
     };
-}, unknown, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
-    onError: (error: Error) => void;
-    onClick: (structureId: string, goToScene: () => void) => void;
-    onHoverOver: (structureId: string) => void;
-    onHoverOut: (structureId: string) => void;
+}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+    onError: (error: Error) => any;
+    onClick: (structureId: string, goToScene: () => void) => any;
+    onMouseMove: (mouseEvent: MouseEvent, pos?: Pos) => any;
+    onHoverOver: (structureId: string) => any;
+    onHoverOut: (structureId: string) => any;
     onBoundingBoxesUpdate: (boundingBoxes: {
         id: string;
-        boundingBox: any;
-    }[]) => void;
-    onMouseMove: (mouseEvent: MouseEvent, pos?: Pos) => void;
-    onInitialize: () => void;
-}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<__VLS_WithDefaults<__VLS_TypePropsToRuntimeProps<{
-    structureChooserData: StructureChooserData;
-    cdnFileResolver: CdnFileResolverCallback;
-    colorCallback?: ColorCallback;
-    i18nConfig?: I18NConfig;
-    customOverlayContent?: string;
-    selectedId?: string;
-    defaultCamera?: string;
-    defaultDay?: number;
-    defaultTime?: number;
-    mobileBreakpoint?: number;
-    version?: string;
-    showVersion?: boolean;
-    showUi?: boolean;
-    activeStructureIds?: string[];
-}>, {
-    colorCallback: () => {
-        r: number;
-        g: number;
-        b: number;
-        a: number;
-        s: number;
-    };
-    mobileBreakpoint: number;
-    showVersion: boolean;
-    showUi: boolean;
-}>>> & {
+        boundingBox: ReturnType<DOMRect["toJSON"]>;
+    }[]) => any;
+    onInitialize: () => any;
+}, string, import('vue').PublicProps, Readonly<__VLS_Props> & Readonly<{
     onOnError?: (error: Error) => any;
     onOnClick?: (structureId: string, goToScene: () => void) => any;
+    onOnMouseMove?: (mouseEvent: MouseEvent, pos?: Pos) => any;
     onOnHoverOver?: (structureId: string) => any;
     onOnHoverOut?: (structureId: string) => any;
     onOnBoundingBoxesUpdate?: (boundingBoxes: {
         id: string;
-        boundingBox: any;
+        boundingBox: ReturnType<DOMRect["toJSON"]>;
     }[]) => any;
-    onOnMouseMove?: (mouseEvent: MouseEvent, pos?: Pos) => any;
     onOnInitialize?: () => any;
-}, {
-    colorCallback: ColorCallback;
-    mobileBreakpoint: number;
+}>, {
     showVersion: boolean;
     showUi: boolean;
-}, {}>, Readonly<{
-    default(): any;
-    popup(props: {
-        hoverId: string;
-        hoverable: boolean;
-    }): any;
-}> & {
-    default(): any;
-    popup(props: {
-        hoverId: string;
-        hoverable: boolean;
-    }): any;
-}>;
-export default _default;
-type __VLS_NonUndefinedable<T> = T extends undefined ? never : T;
-type __VLS_TypePropsToRuntimeProps<T> = {
-    [K in keyof T]-?: {} extends Pick<T, K> ? {
-        type: import('vue').PropType<__VLS_NonUndefinedable<T[K]>>;
-    } : {
-        type: import('vue').PropType<T[K]>;
-        required: true;
+    colorCallback: ColorCallback;
+    mobileBreakpoint: number;
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {
+    container: HTMLDivElement;
+    zoomBox: {
+        $: import('vue').ComponentInternalInstance;
+        $data: {};
+        $props: Partial<{
+            desktop: boolean;
+            mobile: boolean;
+            maxScale: number;
+            consumeMouseClickWhenMoved: boolean;
+            consumeMouseUpWhenMoved: boolean;
+            position: "absolute" | "relative";
+        }> & Omit<{
+            readonly desktop?: boolean;
+            readonly mobile?: boolean;
+            readonly maxScale?: number;
+            readonly consumeMouseClickWhenMoved?: boolean;
+            readonly consumeMouseUpWhenMoved?: boolean;
+            readonly position?: "absolute" | "relative";
+            readonly onUpdate?: (event: {
+                scale: number;
+                x: number;
+                y: number;
+                current: number;
+                min: number;
+                max: number;
+                resolve: (projectedX: number, projectedY: number) => void;
+            }) => any;
+        } & import('vue').VNodeProps & import('vue').AllowedComponentProps & import('vue').ComponentCustomProps, "desktop" | "mobile" | "maxScale" | "consumeMouseClickWhenMoved" | "consumeMouseUpWhenMoved" | "position">;
+        $attrs: {
+            [x: string]: unknown;
+        };
+        $refs: {
+            [x: string]: unknown;
+        } & {
+            box: HTMLDivElement;
+        };
+        $slots: Readonly<{
+            [name: string]: import('vue').Slot<any>;
+        }>;
+        $root: import('vue').ComponentPublicInstance | null;
+        $parent: import('vue').ComponentPublicInstance | null;
+        $host: Element | null;
+        $emit: (event: "update", event: {
+            scale: number;
+            x: number;
+            y: number;
+            current: number;
+            min: number;
+            max: number;
+            resolve: (projectedX: number, projectedY: number) => void;
+        }) => void;
+        $el: HTMLDivElement;
+        $options: import('vue').ComponentOptionsBase<Readonly<{
+            desktop?: boolean;
+            mobile?: boolean;
+            maxScale?: number;
+            consumeMouseClickWhenMoved?: boolean;
+            consumeMouseUpWhenMoved?: boolean;
+            position?: "absolute" | "relative";
+        }> & Readonly<{
+            onUpdate?: (event: {
+                scale: number;
+                x: number;
+                y: number;
+                current: number;
+                min: number;
+                max: number;
+                resolve: (projectedX: number, projectedY: number) => void;
+            }) => any;
+        }>, {
+            adjustZoom: (delta: number, x?: number, y?: number) => void;
+        }, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+            update: (event: {
+                scale: number;
+                x: number;
+                y: number;
+                current: number;
+                min: number;
+                max: number;
+                resolve: (projectedX: number, projectedY: number) => void;
+            }) => any;
+        }, string, {
+            desktop: boolean;
+            mobile: boolean;
+            maxScale: number;
+            consumeMouseClickWhenMoved: boolean;
+            consumeMouseUpWhenMoved: boolean;
+            position: "absolute" | "relative";
+        }, {}, string, {}, import('vue').GlobalComponents, import('vue').GlobalDirectives, string, import('vue').ComponentProvideOptions> & {
+            beforeCreate?: (() => void) | (() => void)[];
+            created?: (() => void) | (() => void)[];
+            beforeMount?: (() => void) | (() => void)[];
+            mounted?: (() => void) | (() => void)[];
+            beforeUpdate?: (() => void) | (() => void)[];
+            updated?: (() => void) | (() => void)[];
+            activated?: (() => void) | (() => void)[];
+            deactivated?: (() => void) | (() => void)[];
+            beforeDestroy?: (() => void) | (() => void)[];
+            beforeUnmount?: (() => void) | (() => void)[];
+            destroyed?: (() => void) | (() => void)[];
+            unmounted?: (() => void) | (() => void)[];
+            renderTracked?: ((e: import('vue').DebuggerEvent) => void) | ((e: import('vue').DebuggerEvent) => void)[];
+            renderTriggered?: ((e: import('vue').DebuggerEvent) => void) | ((e: import('vue').DebuggerEvent) => void)[];
+            errorCaptured?: ((err: unknown, instance: import('vue').ComponentPublicInstance | null, info: string) => boolean | void) | ((err: unknown, instance: import('vue').ComponentPublicInstance | null, info: string) => boolean | void)[];
+        };
+        $forceUpdate: () => void;
+        $nextTick: typeof nextTick;
+        $watch<T extends string | ((...args: any) => any)>(source: T, cb: T extends (...args: any) => infer R ? (...args: [R, R, import('@vue/reactivity').OnCleanup]) => any : (...args: [any, any, import('@vue/reactivity').OnCleanup]) => any, options?: import('vue').WatchOptions): import('vue').WatchStopHandle;
+    } & Readonly<{
+        desktop: boolean;
+        mobile: boolean;
+        maxScale: number;
+        consumeMouseClickWhenMoved: boolean;
+        consumeMouseUpWhenMoved: boolean;
+        position: "absolute" | "relative";
+    }> & Omit<Readonly<{
+        desktop?: boolean;
+        mobile?: boolean;
+        maxScale?: number;
+        consumeMouseClickWhenMoved?: boolean;
+        consumeMouseUpWhenMoved?: boolean;
+        position?: "absolute" | "relative";
+    }> & Readonly<{
+        onUpdate?: (event: {
+            scale: number;
+            x: number;
+            y: number;
+            current: number;
+            min: number;
+            max: number;
+            resolve: (projectedX: number, projectedY: number) => void;
+        }) => any;
+    }>, "adjustZoom" | ("desktop" | "mobile" | "maxScale" | "consumeMouseClickWhenMoved" | "consumeMouseUpWhenMoved" | "position")> & import('vue').ShallowUnwrapRef<{
+        adjustZoom: (delta: number, x?: number, y?: number) => void;
+    }> & {} & import('vue').ComponentCustomProperties & {} & {
+        $slots: Readonly<{
+            default: [];
+        }> & {
+            default: [];
+        };
     };
-};
-type __VLS_WithDefaults<P, D> = {
-    [K in keyof Pick<P, keyof P>]: K extends keyof D ? __VLS_Prettify<P[K] & {
-        default: D[K];
-    }> : P[K];
-};
-type __VLS_Prettify<T> = {
-    [K in keyof T]: T[K];
-} & {};
+    hoverProbe: import('vue').CreateComponentPublicInstanceWithMixins<Readonly<{}> & Readonly<{}>, {
+        isHoverEnabled: import('vue').ComputedRef<boolean>;
+    }, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, import('vue').PublicProps, {}, true, {}, {}, import('vue').GlobalComponents, import('vue').GlobalDirectives, string, {
+        hoverCheck: HTMLDivElement;
+    }, HTMLDivElement, import('vue').ComponentProvideOptions, {
+        P: {};
+        B: {};
+        D: {};
+        C: {};
+        M: {};
+        Defaults: {};
+    }, Readonly<{}> & Readonly<{}>, {
+        isHoverEnabled: import('vue').ComputedRef<boolean>;
+    }, {}, {}, {}, {}>;
+}, any>;
+declare const _default: __VLS_WithTemplateSlots<typeof __VLS_component, __VLS_TemplateResult["slots"]>;
+export default _default;
 type __VLS_WithTemplateSlots<T, S> = T & {
     new (): {
         $slots: S;