import { Transform } from '@zoompinch/vue';
import { Ref } from 'vue';
import { Template } from '@bluepic/types';
type __VLS_Props = {
    bxCoreVersion?: string;
    /** Override the sandbox host (defaults to sandbox.bluepic.io). e.g. sandbox.bluepic.eu */
    cloudflarePagesHostname?: string;
    /** Optional asset proxy template, e.g. "https://assets.bluepic.eu/proxy?url=$TARGET". */
    assetProxy?: string;
    serial?: Template.Serial;
    serialWidth?: number;
    serialHeight?: number;
    preview?: string;
    offset: {
        top: number;
        right: number;
        bottom: number;
        left: number;
    };
    zoomAndPan: boolean;
    watermark: boolean;
    /**
     * Author-provided accessible description for the live graphic. May contain
     * `{{expression}}` placeholders (an AI-authoring convention) that are resolved
     * at runtime against the live binding scope so the text alternative always
     * reflects the currently rendered graphic.
     */
    accessibilityDescription?: string;
};
declare const _default: import("vue").DefineComponent<__VLS_Props, {
    currentlyFocusedFrame: import("vue").ComputedRef<{
        x: number;
        y: number;
    } | undefined>;
    focusFrame: (frameX: number, frameY: number) => void;
    globalScope: Ref<{
        [k: string]: unknown;
    }, {
        [k: string]: unknown;
    }>;
    bxLiveTemplateRef: Ref<import("vue").CreateComponentPublicInstanceWithMixins<Readonly<{
        bxCoreVersion?: string;
        cloudflarePagesHostname?: string;
        assetProxy?: string;
        serial?: Template.Serial;
        serialWidth?: number;
        serialHeight?: number;
        preview?: string;
        data?: {
            [k: string]: unknown;
        };
    }> & Readonly<{
        onError?: ((args_0: string) => any) | undefined;
        "onUpdate:data"?: ((args_0: {
            [k: string]: unknown;
        }) => any) | undefined;
        "onUpdate:globalScope"?: ((args_0: {
            [k: string]: unknown;
        }) => any) | undefined;
    }>, {
        render: {
            (options: {
                type: "image/png" | "image/jpeg" | "image/jpge" | "image/webp" | "image/svg+xml" | "application/vnd.adobe.indesign-idml-package";
                resolution: number;
                quality: number;
                vectorExportOptions?: {
                    mode: "optimized" | "raw";
                    keepGroupTransforms: boolean;
                    rasterizeAllMasks: boolean;
                    vectorizeAllTexts: boolean;
                };
                watermark: boolean;
                resultType: "blob";
                externalCanvas: HTMLCanvasElement | null;
            }): Promise<Blob>;
            (options: {
                type: "image/png" | "image/jpeg" | "image/jpge" | "image/webp";
                resolution: number;
                quality: number;
                vectorExportOptions?: {
                    mode: "optimized" | "raw";
                    keepGroupTransforms: boolean;
                    rasterizeAllMasks: boolean;
                    vectorizeAllTexts: boolean;
                };
                watermark: boolean;
                resultType: "canvas";
                externalCanvas: HTMLCanvasElement | null;
            }): Promise<HTMLCanvasElement>;
        };
        aspectRatio: import("vue").ComputedRef<number>;
        ready: Ref<boolean, boolean>;
        controller: Ref<import("../../util/bxEmbed.js").EmbeddedController | undefined, import("../../util/bxEmbed.js").EmbeddedController | undefined>;
        evaluate(func: Function, ...args: string[]): Promise<unknown>;
    }, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
        error: (args_0: string) => any;
        "update:data": (args_0: {
            [k: string]: unknown;
        }) => any;
        "update:globalScope": (args_0: {
            [k: string]: unknown;
        }) => any;
    }, import("vue").PublicProps, {}, false, {}, {}, import("vue").GlobalComponents, import("vue").GlobalDirectives, string, {}, any, import("vue").ComponentProvideOptions, {
        P: {};
        B: {};
        D: {};
        C: {};
        M: {};
        Defaults: {};
    }, Readonly<{
        bxCoreVersion?: string;
        cloudflarePagesHostname?: string;
        assetProxy?: string;
        serial?: Template.Serial;
        serialWidth?: number;
        serialHeight?: number;
        preview?: string;
        data?: {
            [k: string]: unknown;
        };
    }> & Readonly<{
        onError?: ((args_0: string) => any) | undefined;
        "onUpdate:data"?: ((args_0: {
            [k: string]: unknown;
        }) => any) | undefined;
        "onUpdate:globalScope"?: ((args_0: {
            [k: string]: unknown;
        }) => any) | undefined;
    }>, {
        render: {
            (options: {
                type: "image/png" | "image/jpeg" | "image/jpge" | "image/webp" | "image/svg+xml" | "application/vnd.adobe.indesign-idml-package";
                resolution: number;
                quality: number;
                vectorExportOptions?: {
                    mode: "optimized" | "raw";
                    keepGroupTransforms: boolean;
                    rasterizeAllMasks: boolean;
                    vectorizeAllTexts: boolean;
                };
                watermark: boolean;
                resultType: "blob";
                externalCanvas: HTMLCanvasElement | null;
            }): Promise<Blob>;
            (options: {
                type: "image/png" | "image/jpeg" | "image/jpge" | "image/webp";
                resolution: number;
                quality: number;
                vectorExportOptions?: {
                    mode: "optimized" | "raw";
                    keepGroupTransforms: boolean;
                    rasterizeAllMasks: boolean;
                    vectorizeAllTexts: boolean;
                };
                watermark: boolean;
                resultType: "canvas";
                externalCanvas: HTMLCanvasElement | null;
            }): Promise<HTMLCanvasElement>;
        };
        aspectRatio: import("vue").ComputedRef<number>;
        ready: Ref<boolean, boolean>;
        controller: Ref<import("../../util/bxEmbed.js").EmbeddedController | undefined, import("../../util/bxEmbed.js").EmbeddedController | undefined>;
        evaluate(func: Function, ...args: string[]): Promise<unknown>;
    }, {}, {}, {}, {}> | undefined, import("vue").CreateComponentPublicInstanceWithMixins<Readonly<{
        bxCoreVersion?: string;
        cloudflarePagesHostname?: string;
        assetProxy?: string;
        serial?: Template.Serial;
        serialWidth?: number;
        serialHeight?: number;
        preview?: string;
        data?: {
            [k: string]: unknown;
        };
    }> & Readonly<{
        onError?: ((args_0: string) => any) | undefined;
        "onUpdate:data"?: ((args_0: {
            [k: string]: unknown;
        }) => any) | undefined;
        "onUpdate:globalScope"?: ((args_0: {
            [k: string]: unknown;
        }) => any) | undefined;
    }>, {
        render: {
            (options: {
                type: "image/png" | "image/jpeg" | "image/jpge" | "image/webp" | "image/svg+xml" | "application/vnd.adobe.indesign-idml-package";
                resolution: number;
                quality: number;
                vectorExportOptions?: {
                    mode: "optimized" | "raw";
                    keepGroupTransforms: boolean;
                    rasterizeAllMasks: boolean;
                    vectorizeAllTexts: boolean;
                };
                watermark: boolean;
                resultType: "blob";
                externalCanvas: HTMLCanvasElement | null;
            }): Promise<Blob>;
            (options: {
                type: "image/png" | "image/jpeg" | "image/jpge" | "image/webp";
                resolution: number;
                quality: number;
                vectorExportOptions?: {
                    mode: "optimized" | "raw";
                    keepGroupTransforms: boolean;
                    rasterizeAllMasks: boolean;
                    vectorizeAllTexts: boolean;
                };
                watermark: boolean;
                resultType: "canvas";
                externalCanvas: HTMLCanvasElement | null;
            }): Promise<HTMLCanvasElement>;
        };
        aspectRatio: import("vue").ComputedRef<number>;
        ready: Ref<boolean, boolean>;
        controller: Ref<import("../../util/bxEmbed.js").EmbeddedController | undefined, import("../../util/bxEmbed.js").EmbeddedController | undefined>;
        evaluate(func: Function, ...args: string[]): Promise<unknown>;
    }, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
        error: (args_0: string) => any;
        "update:data": (args_0: {
            [k: string]: unknown;
        }) => any;
        "update:globalScope": (args_0: {
            [k: string]: unknown;
        }) => any;
    }, import("vue").PublicProps, {}, false, {}, {}, import("vue").GlobalComponents, import("vue").GlobalDirectives, string, {}, any, import("vue").ComponentProvideOptions, {
        P: {};
        B: {};
        D: {};
        C: {};
        M: {};
        Defaults: {};
    }, Readonly<{
        bxCoreVersion?: string;
        cloudflarePagesHostname?: string;
        assetProxy?: string;
        serial?: Template.Serial;
        serialWidth?: number;
        serialHeight?: number;
        preview?: string;
        data?: {
            [k: string]: unknown;
        };
    }> & Readonly<{
        onError?: ((args_0: string) => any) | undefined;
        "onUpdate:data"?: ((args_0: {
            [k: string]: unknown;
        }) => any) | undefined;
        "onUpdate:globalScope"?: ((args_0: {
            [k: string]: unknown;
        }) => any) | undefined;
    }>, {
        render: {
            (options: {
                type: "image/png" | "image/jpeg" | "image/jpge" | "image/webp" | "image/svg+xml" | "application/vnd.adobe.indesign-idml-package";
                resolution: number;
                quality: number;
                vectorExportOptions?: {
                    mode: "optimized" | "raw";
                    keepGroupTransforms: boolean;
                    rasterizeAllMasks: boolean;
                    vectorizeAllTexts: boolean;
                };
                watermark: boolean;
                resultType: "blob";
                externalCanvas: HTMLCanvasElement | null;
            }): Promise<Blob>;
            (options: {
                type: "image/png" | "image/jpeg" | "image/jpge" | "image/webp";
                resolution: number;
                quality: number;
                vectorExportOptions?: {
                    mode: "optimized" | "raw";
                    keepGroupTransforms: boolean;
                    rasterizeAllMasks: boolean;
                    vectorizeAllTexts: boolean;
                };
                watermark: boolean;
                resultType: "canvas";
                externalCanvas: HTMLCanvasElement | null;
            }): Promise<HTMLCanvasElement>;
        };
        aspectRatio: import("vue").ComputedRef<number>;
        ready: Ref<boolean, boolean>;
        controller: Ref<import("../../util/bxEmbed.js").EmbeddedController | undefined, import("../../util/bxEmbed.js").EmbeddedController | undefined>;
        evaluate(func: Function, ...args: string[]): Promise<unknown>;
    }, {}, {}, {}, {}> | undefined>;
    ready: import("vue").ComputedRef<boolean>;
    templateViewRootWidth: import("vue").ShallowRef<number>;
    templateViewRootHeight: import("vue").ShallowRef<number>;
    fit: () => void;
    needsToFit: import("vue").ComputedRef<boolean | undefined>;
    transform: Ref<{
        translateX: number;
        translateY: number;
        scale: number;
        rotate: number;
    }, Transform | {
        translateX: number;
        translateY: number;
        scale: number;
        rotate: number;
    }>;
    zoompinchRef: Ref<({
        $: import("vue").ComponentInternalInstance;
        $data: {};
        $props: {
            readonly transform?: Transform | undefined;
            readonly offset?: {
                top: number;
                right: number;
                bottom: number;
                left: number;
            } | undefined;
            readonly maxScale?: number | undefined;
            readonly minScale?: number | undefined;
            readonly clampBounds?: boolean | undefined;
            readonly rotation?: boolean | undefined;
            readonly mouse?: boolean | undefined;
            readonly wheel?: boolean | undefined;
            readonly touch?: boolean | undefined;
            readonly gesture?: boolean | undefined;
            readonly zoomSpeed?: number | undefined;
            readonly translateSpeed?: number | undefined;
            readonly zoomSpeedAppleTrackpad?: number | undefined;
            readonly translateSpeedAppleTrackpad?: number | undefined;
            readonly "onUpdate:transform"?: ((transform: Transform) => any) | undefined | undefined;
            readonly onInit?: (() => any) | undefined | undefined;
            readonly onDragGestureStart?: ((event: MouseEvent | TouchEvent | WheelEvent) => any) | undefined | undefined;
            readonly onDragGestureEnd?: ((event: MouseEvent | TouchEvent | WheelEvent) => any) | undefined | undefined;
        } & import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps;
        $attrs: import("vue").Attrs;
        $refs: {
            [x: string]: unknown;
        } & {
            zoompinchRef: HTMLDivElement;
        };
        $slots: Readonly<{
            [name: string]: import("vue").Slot<any> | undefined;
        }>;
        $root: import("vue").ComponentPublicInstance | null;
        $parent: import("vue").ComponentPublicInstance | null;
        $host: Element | null;
        $emit: ((event: "init") => void) & ((event: "update:transform", transform: Transform) => void) & ((event: "dragGestureStart", event: MouseEvent | TouchEvent | WheelEvent) => void) & ((event: "dragGestureEnd", event: MouseEvent | TouchEvent | WheelEvent) => void);
        $el: HTMLDivElement;
        $options: import("vue").ComponentOptionsBase<Readonly<{
            transform?: Transform;
            offset?: {
                top: number;
                right: number;
                bottom: number;
                left: number;
            };
            maxScale?: number;
            minScale?: number;
            clampBounds?: boolean;
            rotation?: boolean;
            mouse?: boolean;
            wheel?: boolean;
            touch?: boolean;
            gesture?: boolean;
            zoomSpeed?: number;
            translateSpeed?: number;
            zoomSpeedAppleTrackpad?: number;
            translateSpeedAppleTrackpad?: number;
        }> & Readonly<{
            "onUpdate:transform"?: ((transform: Transform) => any) | undefined;
            onInit?: (() => any) | undefined;
            onDragGestureStart?: ((event: MouseEvent | TouchEvent | WheelEvent) => any) | undefined;
            onDragGestureEnd?: ((event: MouseEvent | TouchEvent | WheelEvent) => any) | undefined;
        }>, {
            applyTransform: (scale: number, wrapperInnerCoords: [number, number], canvasCoords: [number, number], rotate?: number) => void;
            composePoint: import("vue").Ref<(x: number, y: number) => [number, number], (x: number, y: number) => [number, number]>;
            normalizeClientCoords: (clientX: number, clientY: number) => [number, number];
            zoompinchEngine: import("vue").Ref<import("@zoompinch/core").Zoompinch | undefined, import("@zoompinch/core").Zoompinch | undefined>;
            canvasWidth: import("vue").Ref<number, number>;
            canvasHeight: import("vue").Ref<number, number>;
            rotateCanvas: (x: number, y: number, radians: number) => void;
        }, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
            "update:transform": (transform: Transform) => any;
            init: () => any;
            dragGestureStart: (event: MouseEvent | TouchEvent | WheelEvent) => any;
            dragGestureEnd: (event: MouseEvent | TouchEvent | WheelEvent) => any;
        }, string, {
            transform: Transform;
            offset: {
                top: number;
                right: number;
                bottom: number;
                left: number;
            };
            maxScale: number;
            minScale: number;
            clampBounds: boolean;
            rotation: boolean;
            mouse: boolean;
            wheel: boolean;
            touch: boolean;
            gesture: boolean;
        }, {}, 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 import("vue").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<{
        transform: Transform;
        offset: {
            top: number;
            right: number;
            bottom: number;
            left: number;
        };
        maxScale: number;
        minScale: number;
        clampBounds: boolean;
        rotation: boolean;
        mouse: boolean;
        wheel: boolean;
        touch: boolean;
        gesture: boolean;
    }> & Omit<Readonly<{
        transform?: Transform;
        offset?: {
            top: number;
            right: number;
            bottom: number;
            left: number;
        };
        maxScale?: number;
        minScale?: number;
        clampBounds?: boolean;
        rotation?: boolean;
        mouse?: boolean;
        wheel?: boolean;
        touch?: boolean;
        gesture?: boolean;
        zoomSpeed?: number;
        translateSpeed?: number;
        zoomSpeedAppleTrackpad?: number;
        translateSpeedAppleTrackpad?: number;
    }> & Readonly<{
        "onUpdate:transform"?: ((transform: Transform) => any) | undefined;
        onInit?: (() => any) | undefined;
        onDragGestureStart?: ((event: MouseEvent | TouchEvent | WheelEvent) => any) | undefined;
        onDragGestureEnd?: ((event: MouseEvent | TouchEvent | WheelEvent) => any) | undefined;
    }>, "minScale" | "maxScale" | "transform" | "wheel" | "offset" | "clampBounds" | "rotation" | "mouse" | "touch" | "gesture" | "applyTransform" | "composePoint" | "normalizeClientCoords" | "zoompinchEngine" | "canvasWidth" | "canvasHeight" | "rotateCanvas"> & {
        applyTransform: (scale: number, wrapperInnerCoords: [number, number], canvasCoords: [number, number], rotate?: number) => void;
        composePoint: (x: number, y: number) => [number, number];
        normalizeClientCoords: (clientX: number, clientY: number) => [number, number];
        zoompinchEngine: import("@zoompinch/core").Zoompinch | undefined;
        canvasWidth: number;
        canvasHeight: number;
        rotateCanvas: (x: number, y: number, radians: number) => void;
    } & {} & import("vue").ComponentCustomProperties & {} & {
        $slots: Readonly<{
            default: () => import("vue").VNode | import("vue").VNode[];
            matrix: (args: {
                composePoint: (x: number, y: number) => [number, number];
                normalizeClientCoords: (clientX: number, clientY: number) => [number, number];
                canvasWidth: number;
                canvasHeight: number;
            }) => import("vue").VNode | import("vue").VNode[];
        }> & {
            default: () => import("vue").VNode | import("vue").VNode[];
            matrix: (args: {
                composePoint: (x: number, y: number) => [number, number];
                normalizeClientCoords: (clientX: number, clientY: number) => [number, number];
                canvasWidth: number;
                canvasHeight: number;
            }) => import("vue").VNode | import("vue").VNode[];
        };
    }) | undefined, ({
        $: import("vue").ComponentInternalInstance;
        $data: {};
        $props: {
            readonly transform?: Transform | undefined;
            readonly offset?: {
                top: number;
                right: number;
                bottom: number;
                left: number;
            } | undefined;
            readonly maxScale?: number | undefined;
            readonly minScale?: number | undefined;
            readonly clampBounds?: boolean | undefined;
            readonly rotation?: boolean | undefined;
            readonly mouse?: boolean | undefined;
            readonly wheel?: boolean | undefined;
            readonly touch?: boolean | undefined;
            readonly gesture?: boolean | undefined;
            readonly zoomSpeed?: number | undefined;
            readonly translateSpeed?: number | undefined;
            readonly zoomSpeedAppleTrackpad?: number | undefined;
            readonly translateSpeedAppleTrackpad?: number | undefined;
            readonly "onUpdate:transform"?: ((transform: Transform) => any) | undefined | undefined;
            readonly onInit?: (() => any) | undefined | undefined;
            readonly onDragGestureStart?: ((event: MouseEvent | TouchEvent | WheelEvent) => any) | undefined | undefined;
            readonly onDragGestureEnd?: ((event: MouseEvent | TouchEvent | WheelEvent) => any) | undefined | undefined;
        } & import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps;
        $attrs: import("vue").Attrs;
        $refs: {
            [x: string]: unknown;
        } & {
            zoompinchRef: HTMLDivElement;
        };
        $slots: Readonly<{
            [name: string]: import("vue").Slot<any> | undefined;
        }>;
        $root: import("vue").ComponentPublicInstance | null;
        $parent: import("vue").ComponentPublicInstance | null;
        $host: Element | null;
        $emit: ((event: "init") => void) & ((event: "update:transform", transform: Transform) => void) & ((event: "dragGestureStart", event: MouseEvent | TouchEvent | WheelEvent) => void) & ((event: "dragGestureEnd", event: MouseEvent | TouchEvent | WheelEvent) => void);
        $el: HTMLDivElement;
        $options: import("vue").ComponentOptionsBase<Readonly<{
            transform?: Transform;
            offset?: {
                top: number;
                right: number;
                bottom: number;
                left: number;
            };
            maxScale?: number;
            minScale?: number;
            clampBounds?: boolean;
            rotation?: boolean;
            mouse?: boolean;
            wheel?: boolean;
            touch?: boolean;
            gesture?: boolean;
            zoomSpeed?: number;
            translateSpeed?: number;
            zoomSpeedAppleTrackpad?: number;
            translateSpeedAppleTrackpad?: number;
        }> & Readonly<{
            "onUpdate:transform"?: ((transform: Transform) => any) | undefined;
            onInit?: (() => any) | undefined;
            onDragGestureStart?: ((event: MouseEvent | TouchEvent | WheelEvent) => any) | undefined;
            onDragGestureEnd?: ((event: MouseEvent | TouchEvent | WheelEvent) => any) | undefined;
        }>, {
            applyTransform: (scale: number, wrapperInnerCoords: [number, number], canvasCoords: [number, number], rotate?: number) => void;
            composePoint: import("vue").Ref<(x: number, y: number) => [number, number], (x: number, y: number) => [number, number]>;
            normalizeClientCoords: (clientX: number, clientY: number) => [number, number];
            zoompinchEngine: import("vue").Ref<import("@zoompinch/core").Zoompinch | undefined, import("@zoompinch/core").Zoompinch | undefined>;
            canvasWidth: import("vue").Ref<number, number>;
            canvasHeight: import("vue").Ref<number, number>;
            rotateCanvas: (x: number, y: number, radians: number) => void;
        }, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
            "update:transform": (transform: Transform) => any;
            init: () => any;
            dragGestureStart: (event: MouseEvent | TouchEvent | WheelEvent) => any;
            dragGestureEnd: (event: MouseEvent | TouchEvent | WheelEvent) => any;
        }, string, {
            transform: Transform;
            offset: {
                top: number;
                right: number;
                bottom: number;
                left: number;
            };
            maxScale: number;
            minScale: number;
            clampBounds: boolean;
            rotation: boolean;
            mouse: boolean;
            wheel: boolean;
            touch: boolean;
            gesture: boolean;
        }, {}, 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 import("vue").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<{
        transform: Transform;
        offset: {
            top: number;
            right: number;
            bottom: number;
            left: number;
        };
        maxScale: number;
        minScale: number;
        clampBounds: boolean;
        rotation: boolean;
        mouse: boolean;
        wheel: boolean;
        touch: boolean;
        gesture: boolean;
    }> & Omit<Readonly<{
        transform?: Transform;
        offset?: {
            top: number;
            right: number;
            bottom: number;
            left: number;
        };
        maxScale?: number;
        minScale?: number;
        clampBounds?: boolean;
        rotation?: boolean;
        mouse?: boolean;
        wheel?: boolean;
        touch?: boolean;
        gesture?: boolean;
        zoomSpeed?: number;
        translateSpeed?: number;
        zoomSpeedAppleTrackpad?: number;
        translateSpeedAppleTrackpad?: number;
    }> & Readonly<{
        "onUpdate:transform"?: ((transform: Transform) => any) | undefined;
        onInit?: (() => any) | undefined;
        onDragGestureStart?: ((event: MouseEvent | TouchEvent | WheelEvent) => any) | undefined;
        onDragGestureEnd?: ((event: MouseEvent | TouchEvent | WheelEvent) => any) | undefined;
    }>, "minScale" | "maxScale" | "transform" | "wheel" | "offset" | "clampBounds" | "rotation" | "mouse" | "touch" | "gesture" | "applyTransform" | "composePoint" | "normalizeClientCoords" | "zoompinchEngine" | "canvasWidth" | "canvasHeight" | "rotateCanvas"> & {
        applyTransform: (scale: number, wrapperInnerCoords: [number, number], canvasCoords: [number, number], rotate?: number) => void;
        composePoint: (x: number, y: number) => [number, number];
        normalizeClientCoords: (clientX: number, clientY: number) => [number, number];
        zoompinchEngine: import("@zoompinch/core").Zoompinch | undefined;
        canvasWidth: number;
        canvasHeight: number;
        rotateCanvas: (x: number, y: number, radians: number) => void;
    } & {} & import("vue").ComponentCustomProperties & {} & {
        $slots: Readonly<{
            default: () => import("vue").VNode | import("vue").VNode[];
            matrix: (args: {
                composePoint: (x: number, y: number) => [number, number];
                normalizeClientCoords: (clientX: number, clientY: number) => [number, number];
                canvasWidth: number;
                canvasHeight: number;
            }) => import("vue").VNode | import("vue").VNode[];
        }> & {
            default: () => import("vue").VNode | import("vue").VNode[];
            matrix: (args: {
                composePoint: (x: number, y: number) => [number, number];
                normalizeClientCoords: (clientX: number, clientY: number) => [number, number];
                canvasWidth: number;
                canvasHeight: number;
            }) => import("vue").VNode | import("vue").VNode[];
        };
    }) | undefined>;
    isMultiFrame: import("vue").ComputedRef<boolean>;
}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<__VLS_Props> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
export default _default;
