import { type Ref } from 'vue';
import { Template } from '@bluepic/types';
export type Transform = {
    x: number;
    y: number;
    scale: number;
    rotate: number;
};
declare const _sfc_main: import("vue").DefineComponent<{}, {
    props: any;
    emit: ((event: unknown, ...args: any[]) => void) | ((event: string, ...args: any[]) => void);
    data: import("vue").ModelRef<Record<string, any>[keyof T], {
        [k: string]: unknown;
    }, T[K], T[K]>;
    serial: import("vue").ModelRef<Record<string, any>[keyof T], Template.Serial, T[K], T[K]>;
    ready: import("vue").ModelRef<Record<string, any>[keyof T], boolean, T[K], T[K]>;
    globalScope: Ref<{
        [k: string]: unknown;
    } | undefined, {
        [k: string]: unknown;
    } | undefined>;
    bluepicEmbeddedRef: Ref<import("vue").CreateComponentPublicInstanceWithMixins<Readonly<import("vue").ExtractPropTypes<{
        templateId: {
            type: StringConstructor;
            required: true;
        };
        embedApiBaseUrl: {
            type: StringConstructor;
            required: true;
        };
        env: {
            type: StringConstructor;
            required: true;
        };
        cloudflarePagesHostname: {
            type: StringConstructor;
            required: true;
        };
        bxCoreVersion: {
            type: StringConstructor;
            required: false;
            default: string;
        };
        authorization: {
            type: StringConstructor;
            required: false;
            default: undefined;
        };
        data: {
            type: ObjectConstructor;
            required: false;
            default: () => {};
        };
        fonts: {
            type: ArrayConstructor;
            required: false;
            default: () => never[];
        };
        webgl: {
            type: BooleanConstructor;
            required: false;
            default: boolean;
        };
        resolution: {
            type: NumberConstructor;
            required: false;
            default: number;
        };
        asyncSerial: {
            type: BooleanConstructor;
            required: false;
            default: boolean;
        };
        baseSerial: {
            type: null;
            required: false;
        };
    }>> & Readonly<{
        "onUpdate:data"?: ((...args: any[]) => any) | undefined;
        "onUpdate:serial"?: ((...args: any[]) => any) | undefined;
        "onUpdate:ready"?: ((...args: any[]) => any) | undefined;
        onError?: ((...args: any[]) => any) | undefined;
        "onUpdate:globalScope"?: ((...args: any[]) => any) | undefined;
    }>, {
        props: any;
        emit: (event: "update:data" | "update:serial" | "update:ready" | "error" | "update:globalScope", ...args: any[]) => void;
        knownBxCoreVersion: import("vue").ComputedRef<any>;
        asyncSerialIsFinallyEnabled: import("vue").ComputedRef<any>;
        maxTries: number;
        serialPromise: Promise<Template.Serial> | undefined;
        frameURL: import("vue").ComputedRef<string>;
        ready: Ref<boolean, boolean>;
        serial: Ref<Template.Serial | undefined, Template.Serial | undefined>;
        frameRef: Ref<HTMLIFrameElement | undefined, HTMLIFrameElement | undefined>;
        controller: Ref<import("../util/bluepicEmbed").default | undefined, import("../util/bluepicEmbed").default | undefined>;
        busy: boolean;
        waiting: boolean;
        update: () => void;
        resolveData: () => Promise<{
            [k: string]: any;
        } | undefined>;
        webglSupported: () => Promise<boolean>;
        renderWebGL: (options: {
            type: "image/png" | "image/jpeg" | "image/webp" | "image/jpge";
            resolution?: number | undefined;
            quality?: number | undefined;
            area?: {
                x: number;
                y: number;
                width: number;
                height: number;
            } | undefined;
        }) => Promise<Blob>;
        renderSVG: () => Promise<Document>;
    }, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, ("update:data" | "update:serial" | "update:ready" | "error" | "update:globalScope")[], import("vue").PublicProps, {
        data: Record<string, any>;
        bxCoreVersion: string;
        authorization: string;
        fonts: unknown[];
        webgl: boolean;
        resolution: number;
        asyncSerial: boolean;
    }, true, {}, {}, import("vue").GlobalComponents, import("vue").GlobalDirectives, string, {}, any, import("vue").ComponentProvideOptions, {
        P: {};
        B: {};
        D: {};
        C: {};
        M: {};
        Defaults: {};
    }, Readonly<import("vue").ExtractPropTypes<{
        templateId: {
            type: StringConstructor;
            required: true;
        };
        embedApiBaseUrl: {
            type: StringConstructor;
            required: true;
        };
        env: {
            type: StringConstructor;
            required: true;
        };
        cloudflarePagesHostname: {
            type: StringConstructor;
            required: true;
        };
        bxCoreVersion: {
            type: StringConstructor;
            required: false;
            default: string;
        };
        authorization: {
            type: StringConstructor;
            required: false;
            default: undefined;
        };
        data: {
            type: ObjectConstructor;
            required: false;
            default: () => {};
        };
        fonts: {
            type: ArrayConstructor;
            required: false;
            default: () => never[];
        };
        webgl: {
            type: BooleanConstructor;
            required: false;
            default: boolean;
        };
        resolution: {
            type: NumberConstructor;
            required: false;
            default: number;
        };
        asyncSerial: {
            type: BooleanConstructor;
            required: false;
            default: boolean;
        };
        baseSerial: {
            type: null;
            required: false;
        };
    }>> & Readonly<{
        "onUpdate:data"?: ((...args: any[]) => any) | undefined;
        "onUpdate:serial"?: ((...args: any[]) => any) | undefined;
        "onUpdate:ready"?: ((...args: any[]) => any) | undefined;
        onError?: ((...args: any[]) => any) | undefined;
        "onUpdate:globalScope"?: ((...args: any[]) => any) | undefined;
    }>, {
        props: any;
        emit: (event: "update:data" | "update:serial" | "update:ready" | "error" | "update:globalScope", ...args: any[]) => void;
        knownBxCoreVersion: import("vue").ComputedRef<any>;
        asyncSerialIsFinallyEnabled: import("vue").ComputedRef<any>;
        maxTries: number;
        serialPromise: Promise<Template.Serial> | undefined;
        frameURL: import("vue").ComputedRef<string>;
        ready: Ref<boolean, boolean>;
        serial: Ref<Template.Serial | undefined, Template.Serial | undefined>;
        frameRef: Ref<HTMLIFrameElement | undefined, HTMLIFrameElement | undefined>;
        controller: Ref<import("../util/bluepicEmbed").default | undefined, import("../util/bluepicEmbed").default | undefined>;
        busy: boolean;
        waiting: boolean;
        update: () => void;
        resolveData: () => Promise<{
            [k: string]: any;
        } | undefined>;
        webglSupported: () => Promise<boolean>;
        renderWebGL: (options: {
            type: "image/png" | "image/jpeg" | "image/webp" | "image/jpge";
            resolution?: number | undefined;
            quality?: number | undefined;
            area?: {
                x: number;
                y: number;
                width: number;
                height: number;
            } | undefined;
        }) => Promise<Blob>;
        renderSVG: () => Promise<Document>;
    }, {}, {}, {}, {
        data: Record<string, any>;
        bxCoreVersion: string;
        authorization: string;
        fonts: unknown[];
        webgl: boolean;
        resolution: number;
        asyncSerial: boolean;
    }> | undefined, import("vue").CreateComponentPublicInstanceWithMixins<Readonly<import("vue").ExtractPropTypes<{
        templateId: {
            type: StringConstructor;
            required: true;
        };
        embedApiBaseUrl: {
            type: StringConstructor;
            required: true;
        };
        env: {
            type: StringConstructor;
            required: true;
        };
        cloudflarePagesHostname: {
            type: StringConstructor;
            required: true;
        };
        bxCoreVersion: {
            type: StringConstructor;
            required: false;
            default: string;
        };
        authorization: {
            type: StringConstructor;
            required: false;
            default: undefined;
        };
        data: {
            type: ObjectConstructor;
            required: false;
            default: () => {};
        };
        fonts: {
            type: ArrayConstructor;
            required: false;
            default: () => never[];
        };
        webgl: {
            type: BooleanConstructor;
            required: false;
            default: boolean;
        };
        resolution: {
            type: NumberConstructor;
            required: false;
            default: number;
        };
        asyncSerial: {
            type: BooleanConstructor;
            required: false;
            default: boolean;
        };
        baseSerial: {
            type: null;
            required: false;
        };
    }>> & Readonly<{
        "onUpdate:data"?: ((...args: any[]) => any) | undefined;
        "onUpdate:serial"?: ((...args: any[]) => any) | undefined;
        "onUpdate:ready"?: ((...args: any[]) => any) | undefined;
        onError?: ((...args: any[]) => any) | undefined;
        "onUpdate:globalScope"?: ((...args: any[]) => any) | undefined;
    }>, {
        props: any;
        emit: (event: "update:data" | "update:serial" | "update:ready" | "error" | "update:globalScope", ...args: any[]) => void;
        knownBxCoreVersion: import("vue").ComputedRef<any>;
        asyncSerialIsFinallyEnabled: import("vue").ComputedRef<any>;
        maxTries: number;
        serialPromise: Promise<Template.Serial> | undefined;
        frameURL: import("vue").ComputedRef<string>;
        ready: Ref<boolean, boolean>;
        serial: Ref<Template.Serial | undefined, Template.Serial | undefined>;
        frameRef: Ref<HTMLIFrameElement | undefined, HTMLIFrameElement | undefined>;
        controller: Ref<import("../util/bluepicEmbed").default | undefined, import("../util/bluepicEmbed").default | undefined>;
        busy: boolean;
        waiting: boolean;
        update: () => void;
        resolveData: () => Promise<{
            [k: string]: any;
        } | undefined>;
        webglSupported: () => Promise<boolean>;
        renderWebGL: (options: {
            type: "image/png" | "image/jpeg" | "image/webp" | "image/jpge";
            resolution?: number | undefined;
            quality?: number | undefined;
            area?: {
                x: number;
                y: number;
                width: number;
                height: number;
            } | undefined;
        }) => Promise<Blob>;
        renderSVG: () => Promise<Document>;
    }, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, ("update:data" | "update:serial" | "update:ready" | "error" | "update:globalScope")[], import("vue").PublicProps, {
        data: Record<string, any>;
        bxCoreVersion: string;
        authorization: string;
        fonts: unknown[];
        webgl: boolean;
        resolution: number;
        asyncSerial: boolean;
    }, true, {}, {}, import("vue").GlobalComponents, import("vue").GlobalDirectives, string, {}, any, import("vue").ComponentProvideOptions, {
        P: {};
        B: {};
        D: {};
        C: {};
        M: {};
        Defaults: {};
    }, Readonly<import("vue").ExtractPropTypes<{
        templateId: {
            type: StringConstructor;
            required: true;
        };
        embedApiBaseUrl: {
            type: StringConstructor;
            required: true;
        };
        env: {
            type: StringConstructor;
            required: true;
        };
        cloudflarePagesHostname: {
            type: StringConstructor;
            required: true;
        };
        bxCoreVersion: {
            type: StringConstructor;
            required: false;
            default: string;
        };
        authorization: {
            type: StringConstructor;
            required: false;
            default: undefined;
        };
        data: {
            type: ObjectConstructor;
            required: false;
            default: () => {};
        };
        fonts: {
            type: ArrayConstructor;
            required: false;
            default: () => never[];
        };
        webgl: {
            type: BooleanConstructor;
            required: false;
            default: boolean;
        };
        resolution: {
            type: NumberConstructor;
            required: false;
            default: number;
        };
        asyncSerial: {
            type: BooleanConstructor;
            required: false;
            default: boolean;
        };
        baseSerial: {
            type: null;
            required: false;
        };
    }>> & Readonly<{
        "onUpdate:data"?: ((...args: any[]) => any) | undefined;
        "onUpdate:serial"?: ((...args: any[]) => any) | undefined;
        "onUpdate:ready"?: ((...args: any[]) => any) | undefined;
        onError?: ((...args: any[]) => any) | undefined;
        "onUpdate:globalScope"?: ((...args: any[]) => any) | undefined;
    }>, {
        props: any;
        emit: (event: "update:data" | "update:serial" | "update:ready" | "error" | "update:globalScope", ...args: any[]) => void;
        knownBxCoreVersion: import("vue").ComputedRef<any>;
        asyncSerialIsFinallyEnabled: import("vue").ComputedRef<any>;
        maxTries: number;
        serialPromise: Promise<Template.Serial> | undefined;
        frameURL: import("vue").ComputedRef<string>;
        ready: Ref<boolean, boolean>;
        serial: Ref<Template.Serial | undefined, Template.Serial | undefined>;
        frameRef: Ref<HTMLIFrameElement | undefined, HTMLIFrameElement | undefined>;
        controller: Ref<import("../util/bluepicEmbed").default | undefined, import("../util/bluepicEmbed").default | undefined>;
        busy: boolean;
        waiting: boolean;
        update: () => void;
        resolveData: () => Promise<{
            [k: string]: any;
        } | undefined>;
        webglSupported: () => Promise<boolean>;
        renderWebGL: (options: {
            type: "image/png" | "image/jpeg" | "image/webp" | "image/jpge";
            resolution?: number | undefined;
            quality?: number | undefined;
            area?: {
                x: number;
                y: number;
                width: number;
                height: number;
            } | undefined;
        }) => Promise<Blob>;
        renderSVG: () => Promise<Document>;
    }, {}, {}, {}, {
        data: Record<string, any>;
        bxCoreVersion: string;
        authorization: string;
        fonts: unknown[];
        webgl: boolean;
        resolution: number;
        asyncSerial: boolean;
    }> | undefined>;
    zoompinchRef: Ref<import("vue").CreateComponentPublicInstanceWithMixins<Readonly<import("vue").ExtractPropTypes<{
        transform: {
            type: ObjectConstructor;
            required: false;
            default: () => {
                x: number;
                y: number;
                scale: number;
                rotate: number;
            };
        };
        width: {
            type: NumberConstructor;
            required: true;
        };
        height: {
            type: NumberConstructor;
            required: true;
        };
        offset: {
            type: ObjectConstructor;
            required: false;
            default: () => {
                left: number;
                top: number;
                right: number;
                bottom: number;
            };
        };
        maxScale: {
            type: NumberConstructor;
            required: false;
            default: number;
        };
        minScale: {
            type: NumberConstructor;
            required: false;
            default: number;
        };
        bounds: {
            type: BooleanConstructor;
            required: false;
            default: boolean;
        };
        rotation: {
            type: BooleanConstructor;
            required: false;
            default: boolean;
        };
        mouse: {
            type: BooleanConstructor;
            required: false;
            default: boolean;
        };
        wheel: {
            type: BooleanConstructor;
            required: false;
            default: boolean;
        };
        touch: {
            type: BooleanConstructor;
            required: false;
            default: boolean;
        };
        gesture: {
            type: BooleanConstructor;
            required: false;
            default: boolean;
        };
    }>> & {
        "onUpdate:transform"?: ((...args: any[]) => any) | undefined;
        onDragGestureStart?: ((...args: any[]) => any) | undefined;
        onDragGestureEnd?: ((...args: any[]) => any) | undefined;
    }, {
        props: any;
        emit: (event: "update:transform" | "dragGestureStart" | "dragGestureEnd", ...args: any[]) => void;
        zoompinchRef: Ref<HTMLElement | undefined, HTMLElement | undefined>;
        canvasRef: Ref<HTMLElement | undefined, HTMLElement | undefined>;
        matrixRef: Ref<HTMLElement | undefined, HTMLElement | undefined>;
        canvasNaturalWidth: Ref<any, any>;
        canvasNaturalHeight: Ref<any, any>;
        offset: Ref<any, any>;
        rotationEnabled: import("vue").ComputedRef<any>;
        renderingTranslate: import("vue").ComputedRef<number[]>;
        renderingRotate: import("vue").ComputedRef<number>;
        renderingScale: import("vue").ComputedRef<number>;
        composePoint: (x: number, y: number, currScale?: number | undefined, currTranslate?: [number, number] | undefined, currRotate?: number | undefined) => [number, number];
        handleWheel: (event: WheelEvent) => void;
        handleMousedown: (event: MouseEvent) => void;
        handleMousemove: (event: MouseEvent) => void;
        handleMouseup: (event: MouseEvent) => void;
        handleTouchstart: (event: TouchEvent) => void;
        handleTouchmove: (event: TouchEvent) => void;
        handleTouchend: (event: TouchEvent) => void;
        handleGesturestart: (event: UIEvent) => void;
        handleGesturechange: (event: any) => void;
        handleGestureend: (event: any) => void;
        applyTransform: (newScale: number, wrapperInnerCoords: [number, number], canvasAnchorCoords: [number, number], animate?: boolean | undefined) => void;
        rotateCanvas: (x: number, y: number, radians: number) => void;
        compose: (x: number, y: number) => [number, number];
        exposedTransform: import("vue").WritableComputedRef<{
            x: number;
            y: number;
            scale: number;
            rotate: number;
        }, {
            x: number;
            y: number;
            scale: number;
            rotate: number;
        }>;
        calcProjectionTranslate: (newScale: number, wrapperPosition: [number, number], canvasPosition: [number, number], virtualRotate?: number | undefined) => [number, number];
        clientCoordinatesToCanvasCoordinates: (clientX: number, clientY: number) => [number, number];
        normalizeMatrixCoordinates: (clientX: number, clientY: number) => [number, number];
        transitionEnabled: Ref<boolean, boolean>;
        transitionDuration: Ref<number, number>;
        wrapperX: Ref<number, number>;
        wrapperY: Ref<number, number>;
        wrapperWidth: Ref<number, number>;
        wrapperHeight: Ref<number, number>;
        wheelGestures: Readonly<{
            on: <EK extends "wheel">(type: EK, listener: import("zoompinch/lib/controllers/wheel-gestures/events/EventBus").EventListener<import("zoompinch/lib/controllers/wheel-gestures").WheelGesturesEventMap[EK]>) => import("zoompinch/lib/controllers/wheel-gestures/events/EventBus").Off;
            off: <EK_1 extends "wheel">(type: EK_1, listener: import("zoompinch/lib/controllers/wheel-gestures/events/EventBus").EventListener<import("zoompinch/lib/controllers/wheel-gestures").WheelGesturesEventMap[EK_1]>) => void;
            observe: (target: EventTarget) => () => void;
            unobserve: (target: EventTarget) => void;
            disconnect: () => void;
            feedWheel: (wheelEvents: import("zoompinch/lib/controllers/wheel-gestures").WheelEventData | import("zoompinch/lib/controllers/wheel-gestures").WheelEventData[]) => void;
            updateOptions: (newOptions?: Partial<import("zoompinch/lib/controllers/wheel-gestures").WheelGesturesConfig> | undefined) => import("zoompinch/lib/controllers/wheel-gestures").WheelGesturesConfig;
        }>;
        touchmoveSinceTouchstart: boolean;
        touchstartPoint: {
            x: number;
            y: number;
        } | null;
        touchmoveMinDistance: number;
        touchstartProxy: (event: TouchEvent) => void;
        touchmoveProxy: (event: TouchEvent) => void;
        touchendProxy: (event: TouchEvent) => void;
        mousemoveSinceMousedown: boolean;
        mousestartPoint: {
            x: number;
            y: number;
        } | null;
        mousemoveMinDistance: number;
        mousedownProxy: (event: MouseEvent) => void;
        mousemoveProxy: (event: MouseEvent) => void;
        mouseupProxy: (event: MouseEvent) => void;
        isTouchDevice: () => boolean;
        gestureEnabled: import("vue").ComputedRef<any>;
        gesturestartProxy: (event: any) => void;
        gesturechangeProxy: (event: any) => void;
        gestureendProxy: (event: any) => void;
        wrapperBounds: import("vue").ComputedRef<{
            x: number;
            y: number;
            width: number;
            height: number;
        }>;
        readonly radiansToDegrees: typeof import("zoompinch/lib/controllers/helpers").radiansToDegrees;
    }, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, ("update:transform" | "dragGestureStart" | "dragGestureEnd")[], import("vue").PublicProps, {
        transform: Record<string, any>;
        offset: Record<string, any>;
        maxScale: number;
        minScale: number;
        bounds: boolean;
        rotation: boolean;
        mouse: boolean;
        wheel: boolean;
        touch: boolean;
        gesture: boolean;
    }, true, {}, {}, import("vue").GlobalComponents, import("vue").GlobalDirectives, string, {}, any, import("vue").ComponentProvideOptions, {
        P: {};
        B: {};
        D: {};
        C: {};
        M: {};
        Defaults: {};
    }, Readonly<import("vue").ExtractPropTypes<{
        transform: {
            type: ObjectConstructor;
            required: false;
            default: () => {
                x: number;
                y: number;
                scale: number;
                rotate: number;
            };
        };
        width: {
            type: NumberConstructor;
            required: true;
        };
        height: {
            type: NumberConstructor;
            required: true;
        };
        offset: {
            type: ObjectConstructor;
            required: false;
            default: () => {
                left: number;
                top: number;
                right: number;
                bottom: number;
            };
        };
        maxScale: {
            type: NumberConstructor;
            required: false;
            default: number;
        };
        minScale: {
            type: NumberConstructor;
            required: false;
            default: number;
        };
        bounds: {
            type: BooleanConstructor;
            required: false;
            default: boolean;
        };
        rotation: {
            type: BooleanConstructor;
            required: false;
            default: boolean;
        };
        mouse: {
            type: BooleanConstructor;
            required: false;
            default: boolean;
        };
        wheel: {
            type: BooleanConstructor;
            required: false;
            default: boolean;
        };
        touch: {
            type: BooleanConstructor;
            required: false;
            default: boolean;
        };
        gesture: {
            type: BooleanConstructor;
            required: false;
            default: boolean;
        };
    }>> & {
        "onUpdate:transform"?: ((...args: any[]) => any) | undefined;
        onDragGestureStart?: ((...args: any[]) => any) | undefined;
        onDragGestureEnd?: ((...args: any[]) => any) | undefined;
    }, {
        props: any;
        emit: (event: "update:transform" | "dragGestureStart" | "dragGestureEnd", ...args: any[]) => void;
        zoompinchRef: Ref<HTMLElement | undefined, HTMLElement | undefined>;
        canvasRef: Ref<HTMLElement | undefined, HTMLElement | undefined>;
        matrixRef: Ref<HTMLElement | undefined, HTMLElement | undefined>;
        canvasNaturalWidth: Ref<any, any>;
        canvasNaturalHeight: Ref<any, any>;
        offset: Ref<any, any>;
        rotationEnabled: import("vue").ComputedRef<any>;
        renderingTranslate: import("vue").ComputedRef<number[]>;
        renderingRotate: import("vue").ComputedRef<number>;
        renderingScale: import("vue").ComputedRef<number>;
        composePoint: (x: number, y: number, currScale?: number | undefined, currTranslate?: [number, number] | undefined, currRotate?: number | undefined) => [number, number];
        handleWheel: (event: WheelEvent) => void;
        handleMousedown: (event: MouseEvent) => void;
        handleMousemove: (event: MouseEvent) => void;
        handleMouseup: (event: MouseEvent) => void;
        handleTouchstart: (event: TouchEvent) => void;
        handleTouchmove: (event: TouchEvent) => void;
        handleTouchend: (event: TouchEvent) => void;
        handleGesturestart: (event: UIEvent) => void;
        handleGesturechange: (event: any) => void;
        handleGestureend: (event: any) => void;
        applyTransform: (newScale: number, wrapperInnerCoords: [number, number], canvasAnchorCoords: [number, number], animate?: boolean | undefined) => void;
        rotateCanvas: (x: number, y: number, radians: number) => void;
        compose: (x: number, y: number) => [number, number];
        exposedTransform: import("vue").WritableComputedRef<{
            x: number;
            y: number;
            scale: number;
            rotate: number;
        }, {
            x: number;
            y: number;
            scale: number;
            rotate: number;
        }>;
        calcProjectionTranslate: (newScale: number, wrapperPosition: [number, number], canvasPosition: [number, number], virtualRotate?: number | undefined) => [number, number];
        clientCoordinatesToCanvasCoordinates: (clientX: number, clientY: number) => [number, number];
        normalizeMatrixCoordinates: (clientX: number, clientY: number) => [number, number];
        transitionEnabled: Ref<boolean, boolean>;
        transitionDuration: Ref<number, number>;
        wrapperX: Ref<number, number>;
        wrapperY: Ref<number, number>;
        wrapperWidth: Ref<number, number>;
        wrapperHeight: Ref<number, number>;
        wheelGestures: Readonly<{
            on: <EK extends "wheel">(type: EK, listener: import("zoompinch/lib/controllers/wheel-gestures/events/EventBus").EventListener<import("zoompinch/lib/controllers/wheel-gestures").WheelGesturesEventMap[EK]>) => import("zoompinch/lib/controllers/wheel-gestures/events/EventBus").Off;
            off: <EK_1 extends "wheel">(type: EK_1, listener: import("zoompinch/lib/controllers/wheel-gestures/events/EventBus").EventListener<import("zoompinch/lib/controllers/wheel-gestures").WheelGesturesEventMap[EK_1]>) => void;
            observe: (target: EventTarget) => () => void;
            unobserve: (target: EventTarget) => void;
            disconnect: () => void;
            feedWheel: (wheelEvents: import("zoompinch/lib/controllers/wheel-gestures").WheelEventData | import("zoompinch/lib/controllers/wheel-gestures").WheelEventData[]) => void;
            updateOptions: (newOptions?: Partial<import("zoompinch/lib/controllers/wheel-gestures").WheelGesturesConfig> | undefined) => import("zoompinch/lib/controllers/wheel-gestures").WheelGesturesConfig;
        }>;
        touchmoveSinceTouchstart: boolean;
        touchstartPoint: {
            x: number;
            y: number;
        } | null;
        touchmoveMinDistance: number;
        touchstartProxy: (event: TouchEvent) => void;
        touchmoveProxy: (event: TouchEvent) => void;
        touchendProxy: (event: TouchEvent) => void;
        mousemoveSinceMousedown: boolean;
        mousestartPoint: {
            x: number;
            y: number;
        } | null;
        mousemoveMinDistance: number;
        mousedownProxy: (event: MouseEvent) => void;
        mousemoveProxy: (event: MouseEvent) => void;
        mouseupProxy: (event: MouseEvent) => void;
        isTouchDevice: () => boolean;
        gestureEnabled: import("vue").ComputedRef<any>;
        gesturestartProxy: (event: any) => void;
        gesturechangeProxy: (event: any) => void;
        gestureendProxy: (event: any) => void;
        wrapperBounds: import("vue").ComputedRef<{
            x: number;
            y: number;
            width: number;
            height: number;
        }>;
        readonly radiansToDegrees: typeof import("zoompinch/lib/controllers/helpers").radiansToDegrees;
    }, {}, {}, {}, {
        transform: Record<string, any>;
        offset: Record<string, any>;
        maxScale: number;
        minScale: number;
        bounds: boolean;
        rotation: boolean;
        mouse: boolean;
        wheel: boolean;
        touch: boolean;
        gesture: boolean;
    }> | undefined, import("vue").CreateComponentPublicInstanceWithMixins<Readonly<import("vue").ExtractPropTypes<{
        transform: {
            type: ObjectConstructor;
            required: false;
            default: () => {
                x: number;
                y: number;
                scale: number;
                rotate: number;
            };
        };
        width: {
            type: NumberConstructor;
            required: true;
        };
        height: {
            type: NumberConstructor;
            required: true;
        };
        offset: {
            type: ObjectConstructor;
            required: false;
            default: () => {
                left: number;
                top: number;
                right: number;
                bottom: number;
            };
        };
        maxScale: {
            type: NumberConstructor;
            required: false;
            default: number;
        };
        minScale: {
            type: NumberConstructor;
            required: false;
            default: number;
        };
        bounds: {
            type: BooleanConstructor;
            required: false;
            default: boolean;
        };
        rotation: {
            type: BooleanConstructor;
            required: false;
            default: boolean;
        };
        mouse: {
            type: BooleanConstructor;
            required: false;
            default: boolean;
        };
        wheel: {
            type: BooleanConstructor;
            required: false;
            default: boolean;
        };
        touch: {
            type: BooleanConstructor;
            required: false;
            default: boolean;
        };
        gesture: {
            type: BooleanConstructor;
            required: false;
            default: boolean;
        };
    }>> & {
        "onUpdate:transform"?: ((...args: any[]) => any) | undefined;
        onDragGestureStart?: ((...args: any[]) => any) | undefined;
        onDragGestureEnd?: ((...args: any[]) => any) | undefined;
    }, {
        props: any;
        emit: (event: "update:transform" | "dragGestureStart" | "dragGestureEnd", ...args: any[]) => void;
        zoompinchRef: Ref<HTMLElement | undefined, HTMLElement | undefined>;
        canvasRef: Ref<HTMLElement | undefined, HTMLElement | undefined>;
        matrixRef: Ref<HTMLElement | undefined, HTMLElement | undefined>;
        canvasNaturalWidth: Ref<any, any>;
        canvasNaturalHeight: Ref<any, any>;
        offset: Ref<any, any>;
        rotationEnabled: import("vue").ComputedRef<any>;
        renderingTranslate: import("vue").ComputedRef<number[]>;
        renderingRotate: import("vue").ComputedRef<number>;
        renderingScale: import("vue").ComputedRef<number>;
        composePoint: (x: number, y: number, currScale?: number | undefined, currTranslate?: [number, number] | undefined, currRotate?: number | undefined) => [number, number];
        handleWheel: (event: WheelEvent) => void;
        handleMousedown: (event: MouseEvent) => void;
        handleMousemove: (event: MouseEvent) => void;
        handleMouseup: (event: MouseEvent) => void;
        handleTouchstart: (event: TouchEvent) => void;
        handleTouchmove: (event: TouchEvent) => void;
        handleTouchend: (event: TouchEvent) => void;
        handleGesturestart: (event: UIEvent) => void;
        handleGesturechange: (event: any) => void;
        handleGestureend: (event: any) => void;
        applyTransform: (newScale: number, wrapperInnerCoords: [number, number], canvasAnchorCoords: [number, number], animate?: boolean | undefined) => void;
        rotateCanvas: (x: number, y: number, radians: number) => void;
        compose: (x: number, y: number) => [number, number];
        exposedTransform: import("vue").WritableComputedRef<{
            x: number;
            y: number;
            scale: number;
            rotate: number;
        }, {
            x: number;
            y: number;
            scale: number;
            rotate: number;
        }>;
        calcProjectionTranslate: (newScale: number, wrapperPosition: [number, number], canvasPosition: [number, number], virtualRotate?: number | undefined) => [number, number];
        clientCoordinatesToCanvasCoordinates: (clientX: number, clientY: number) => [number, number];
        normalizeMatrixCoordinates: (clientX: number, clientY: number) => [number, number];
        transitionEnabled: Ref<boolean, boolean>;
        transitionDuration: Ref<number, number>;
        wrapperX: Ref<number, number>;
        wrapperY: Ref<number, number>;
        wrapperWidth: Ref<number, number>;
        wrapperHeight: Ref<number, number>;
        wheelGestures: Readonly<{
            on: <EK extends "wheel">(type: EK, listener: import("zoompinch/lib/controllers/wheel-gestures/events/EventBus").EventListener<import("zoompinch/lib/controllers/wheel-gestures").WheelGesturesEventMap[EK]>) => import("zoompinch/lib/controllers/wheel-gestures/events/EventBus").Off;
            off: <EK_1 extends "wheel">(type: EK_1, listener: import("zoompinch/lib/controllers/wheel-gestures/events/EventBus").EventListener<import("zoompinch/lib/controllers/wheel-gestures").WheelGesturesEventMap[EK_1]>) => void;
            observe: (target: EventTarget) => () => void;
            unobserve: (target: EventTarget) => void;
            disconnect: () => void;
            feedWheel: (wheelEvents: import("zoompinch/lib/controllers/wheel-gestures").WheelEventData | import("zoompinch/lib/controllers/wheel-gestures").WheelEventData[]) => void;
            updateOptions: (newOptions?: Partial<import("zoompinch/lib/controllers/wheel-gestures").WheelGesturesConfig> | undefined) => import("zoompinch/lib/controllers/wheel-gestures").WheelGesturesConfig;
        }>;
        touchmoveSinceTouchstart: boolean;
        touchstartPoint: {
            x: number;
            y: number;
        } | null;
        touchmoveMinDistance: number;
        touchstartProxy: (event: TouchEvent) => void;
        touchmoveProxy: (event: TouchEvent) => void;
        touchendProxy: (event: TouchEvent) => void;
        mousemoveSinceMousedown: boolean;
        mousestartPoint: {
            x: number;
            y: number;
        } | null;
        mousemoveMinDistance: number;
        mousedownProxy: (event: MouseEvent) => void;
        mousemoveProxy: (event: MouseEvent) => void;
        mouseupProxy: (event: MouseEvent) => void;
        isTouchDevice: () => boolean;
        gestureEnabled: import("vue").ComputedRef<any>;
        gesturestartProxy: (event: any) => void;
        gesturechangeProxy: (event: any) => void;
        gestureendProxy: (event: any) => void;
        wrapperBounds: import("vue").ComputedRef<{
            x: number;
            y: number;
            width: number;
            height: number;
        }>;
        readonly radiansToDegrees: typeof import("zoompinch/lib/controllers/helpers").radiansToDegrees;
    }, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, ("update:transform" | "dragGestureStart" | "dragGestureEnd")[], import("vue").PublicProps, {
        transform: Record<string, any>;
        offset: Record<string, any>;
        maxScale: number;
        minScale: number;
        bounds: boolean;
        rotation: boolean;
        mouse: boolean;
        wheel: boolean;
        touch: boolean;
        gesture: boolean;
    }, true, {}, {}, import("vue").GlobalComponents, import("vue").GlobalDirectives, string, {}, any, import("vue").ComponentProvideOptions, {
        P: {};
        B: {};
        D: {};
        C: {};
        M: {};
        Defaults: {};
    }, Readonly<import("vue").ExtractPropTypes<{
        transform: {
            type: ObjectConstructor;
            required: false;
            default: () => {
                x: number;
                y: number;
                scale: number;
                rotate: number;
            };
        };
        width: {
            type: NumberConstructor;
            required: true;
        };
        height: {
            type: NumberConstructor;
            required: true;
        };
        offset: {
            type: ObjectConstructor;
            required: false;
            default: () => {
                left: number;
                top: number;
                right: number;
                bottom: number;
            };
        };
        maxScale: {
            type: NumberConstructor;
            required: false;
            default: number;
        };
        minScale: {
            type: NumberConstructor;
            required: false;
            default: number;
        };
        bounds: {
            type: BooleanConstructor;
            required: false;
            default: boolean;
        };
        rotation: {
            type: BooleanConstructor;
            required: false;
            default: boolean;
        };
        mouse: {
            type: BooleanConstructor;
            required: false;
            default: boolean;
        };
        wheel: {
            type: BooleanConstructor;
            required: false;
            default: boolean;
        };
        touch: {
            type: BooleanConstructor;
            required: false;
            default: boolean;
        };
        gesture: {
            type: BooleanConstructor;
            required: false;
            default: boolean;
        };
    }>> & {
        "onUpdate:transform"?: ((...args: any[]) => any) | undefined;
        onDragGestureStart?: ((...args: any[]) => any) | undefined;
        onDragGestureEnd?: ((...args: any[]) => any) | undefined;
    }, {
        props: any;
        emit: (event: "update:transform" | "dragGestureStart" | "dragGestureEnd", ...args: any[]) => void;
        zoompinchRef: Ref<HTMLElement | undefined, HTMLElement | undefined>;
        canvasRef: Ref<HTMLElement | undefined, HTMLElement | undefined>;
        matrixRef: Ref<HTMLElement | undefined, HTMLElement | undefined>;
        canvasNaturalWidth: Ref<any, any>;
        canvasNaturalHeight: Ref<any, any>;
        offset: Ref<any, any>;
        rotationEnabled: import("vue").ComputedRef<any>;
        renderingTranslate: import("vue").ComputedRef<number[]>;
        renderingRotate: import("vue").ComputedRef<number>;
        renderingScale: import("vue").ComputedRef<number>;
        composePoint: (x: number, y: number, currScale?: number | undefined, currTranslate?: [number, number] | undefined, currRotate?: number | undefined) => [number, number];
        handleWheel: (event: WheelEvent) => void;
        handleMousedown: (event: MouseEvent) => void;
        handleMousemove: (event: MouseEvent) => void;
        handleMouseup: (event: MouseEvent) => void;
        handleTouchstart: (event: TouchEvent) => void;
        handleTouchmove: (event: TouchEvent) => void;
        handleTouchend: (event: TouchEvent) => void;
        handleGesturestart: (event: UIEvent) => void;
        handleGesturechange: (event: any) => void;
        handleGestureend: (event: any) => void;
        applyTransform: (newScale: number, wrapperInnerCoords: [number, number], canvasAnchorCoords: [number, number], animate?: boolean | undefined) => void;
        rotateCanvas: (x: number, y: number, radians: number) => void;
        compose: (x: number, y: number) => [number, number];
        exposedTransform: import("vue").WritableComputedRef<{
            x: number;
            y: number;
            scale: number;
            rotate: number;
        }, {
            x: number;
            y: number;
            scale: number;
            rotate: number;
        }>;
        calcProjectionTranslate: (newScale: number, wrapperPosition: [number, number], canvasPosition: [number, number], virtualRotate?: number | undefined) => [number, number];
        clientCoordinatesToCanvasCoordinates: (clientX: number, clientY: number) => [number, number];
        normalizeMatrixCoordinates: (clientX: number, clientY: number) => [number, number];
        transitionEnabled: Ref<boolean, boolean>;
        transitionDuration: Ref<number, number>;
        wrapperX: Ref<number, number>;
        wrapperY: Ref<number, number>;
        wrapperWidth: Ref<number, number>;
        wrapperHeight: Ref<number, number>;
        wheelGestures: Readonly<{
            on: <EK extends "wheel">(type: EK, listener: import("zoompinch/lib/controllers/wheel-gestures/events/EventBus").EventListener<import("zoompinch/lib/controllers/wheel-gestures").WheelGesturesEventMap[EK]>) => import("zoompinch/lib/controllers/wheel-gestures/events/EventBus").Off;
            off: <EK_1 extends "wheel">(type: EK_1, listener: import("zoompinch/lib/controllers/wheel-gestures/events/EventBus").EventListener<import("zoompinch/lib/controllers/wheel-gestures").WheelGesturesEventMap[EK_1]>) => void;
            observe: (target: EventTarget) => () => void;
            unobserve: (target: EventTarget) => void;
            disconnect: () => void;
            feedWheel: (wheelEvents: import("zoompinch/lib/controllers/wheel-gestures").WheelEventData | import("zoompinch/lib/controllers/wheel-gestures").WheelEventData[]) => void;
            updateOptions: (newOptions?: Partial<import("zoompinch/lib/controllers/wheel-gestures").WheelGesturesConfig> | undefined) => import("zoompinch/lib/controllers/wheel-gestures").WheelGesturesConfig;
        }>;
        touchmoveSinceTouchstart: boolean;
        touchstartPoint: {
            x: number;
            y: number;
        } | null;
        touchmoveMinDistance: number;
        touchstartProxy: (event: TouchEvent) => void;
        touchmoveProxy: (event: TouchEvent) => void;
        touchendProxy: (event: TouchEvent) => void;
        mousemoveSinceMousedown: boolean;
        mousestartPoint: {
            x: number;
            y: number;
        } | null;
        mousemoveMinDistance: number;
        mousedownProxy: (event: MouseEvent) => void;
        mousemoveProxy: (event: MouseEvent) => void;
        mouseupProxy: (event: MouseEvent) => void;
        isTouchDevice: () => boolean;
        gestureEnabled: import("vue").ComputedRef<any>;
        gesturestartProxy: (event: any) => void;
        gesturechangeProxy: (event: any) => void;
        gestureendProxy: (event: any) => void;
        wrapperBounds: import("vue").ComputedRef<{
            x: number;
            y: number;
            width: number;
            height: number;
        }>;
        readonly radiansToDegrees: typeof import("zoompinch/lib/controllers/helpers").radiansToDegrees;
    }, {}, {}, {}, {
        transform: Record<string, any>;
        offset: Record<string, any>;
        maxScale: number;
        minScale: number;
        bounds: boolean;
        rotation: boolean;
        mouse: boolean;
        wheel: boolean;
        touch: boolean;
        gesture: boolean;
    }> | undefined>;
    bluepicLiveTemplateRootRef: Ref<HTMLDivElement | undefined, HTMLDivElement | undefined>;
    bluepicLiveTemplateRootWidth: Ref<number, number>;
    bluepicLiveTemplateRootHeight: Ref<number, number>;
    wrapperAspectRatio: import("vue").ComputedRef<number>;
    aspectRatio: import("vue").ComputedRef<number | undefined>;
    aspectRatioSizingSide: import("vue").ComputedRef<"width" | "height" | undefined>;
    transform: Ref<{
        x: number;
        y: number;
        scale: number;
        rotate: number;
    }, Transform | {
        x: number;
        y: number;
        scale: number;
        rotate: number;
    }>;
    handleMatrixClick: (event: MouseEvent) => void;
    frames: import("vue").ComputedRef<any>;
    focusedFrame: Ref<[number, number] | undefined, [number, number] | undefined>;
    wrapperBounds: import("vue").ComputedRef<{
        x: number;
        y: number;
        width: number;
        height: number;
    } | undefined>;
    canvasRatio: import("vue").ComputedRef<number | undefined>;
    wrapperRatio: import("vue").ComputedRef<number | undefined>;
    naturalSizingSide: import("vue").ComputedRef<"width" | "height" | undefined>;
    coverBaseScaling: import("vue").ComputedRef<number | undefined>;
    frameRatio: import("vue").ComputedRef<number | undefined>;
    frameInFocusSizingSide: import("vue").ComputedRef<"width" | "height" | undefined>;
    focusFrameScale: import("vue").ComputedRef<any>;
    getTransformToFocusFrame: (frameX: number, frameY: number) => {
        rotate: number;
        scale: any;
        x: number;
        y: number;
    } | undefined;
    isMultiFrame: import("vue").ComputedRef<boolean>;
    calcCurrFocusedFrame: () => number[] | undefined;
    translateBounds: import("vue").ComputedRef<{
        top: number;
        right: number;
        bottom: number;
        left: number;
    } | undefined>;
    innerScroll: import("vue").ComputedRef<[number, number] | undefined>;
    closestFrameScaleDiff: import("vue").ComputedRef<number | undefined>;
    closestFrameDescriptor: import("vue").ComputedRef<{
        x: {
            index: number;
            distance: number;
        };
        y: {
            index: number;
            distance: number;
        };
    } | undefined>;
    closestFrame: import("vue").ComputedRef<{
        x: number;
        y: number;
    } | undefined>;
    coverScaleY: import("vue").ComputedRef<number | undefined>;
    coverScaleX: import("vue").ComputedRef<number | undefined>;
    needsToFit: import("vue").ComputedRef<boolean | undefined>;
    fit: () => void;
    applyTranformBasedOnFrame: (frameX: number, frameY: number) => void;
    focusFrameX: (frameX: number, event: MouseEvent) => void;
    focusFrameY: (frameY: number, event: MouseEvent) => void;
    handleDoubleTap: ({ clientX, clientY }: {
        clientX: number;
        clientY: number;
    }) => void;
    error: Ref<number | undefined, number | undefined>;
    handleError: (code: number) => void;
    retryTemplateLoad: () => void;
    lastTouch: Ref<number | undefined, number | undefined>;
    handleTouchend: (event: TouchEvent) => void;
    lastFrameX: number;
    lastFrameY: number;
    handleDragGestureStart: () => void;
    handleDragGestureEnd: (event: Event) => void;
    BluepicEmbedded: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
        templateId: {
            type: StringConstructor;
            required: true;
        };
        embedApiBaseUrl: {
            type: StringConstructor;
            required: true;
        };
        env: {
            type: StringConstructor;
            required: true;
        };
        cloudflarePagesHostname: {
            type: StringConstructor;
            required: true;
        };
        bxCoreVersion: {
            type: StringConstructor;
            required: false;
            default: string;
        };
        authorization: {
            type: StringConstructor;
            required: false;
            default: undefined;
        };
        data: {
            type: ObjectConstructor;
            required: false;
            default: () => {};
        };
        fonts: {
            type: ArrayConstructor;
            required: false;
            default: () => never[];
        };
        webgl: {
            type: BooleanConstructor;
            required: false;
            default: boolean;
        };
        resolution: {
            type: NumberConstructor;
            required: false;
            default: number;
        };
        asyncSerial: {
            type: BooleanConstructor;
            required: false;
            default: boolean;
        };
        baseSerial: {
            type: null;
            required: false;
        };
    }>, {
        props: any;
        emit: (event: "update:data" | "update:serial" | "update:ready" | "error" | "update:globalScope", ...args: any[]) => void;
        knownBxCoreVersion: import("vue").ComputedRef<any>;
        asyncSerialIsFinallyEnabled: import("vue").ComputedRef<any>;
        maxTries: number;
        serialPromise: Promise<Template.Serial> | undefined;
        frameURL: import("vue").ComputedRef<string>;
        ready: Ref<boolean, boolean>;
        serial: Ref<Template.Serial | undefined, Template.Serial | undefined>;
        frameRef: Ref<HTMLIFrameElement | undefined, HTMLIFrameElement | undefined>;
        controller: Ref<import("../util/bluepicEmbed").default | undefined, import("../util/bluepicEmbed").default | undefined>;
        busy: boolean;
        waiting: boolean;
        update: () => void;
        resolveData: () => Promise<{
            [k: string]: any;
        } | undefined>;
        webglSupported: () => Promise<boolean>;
        renderWebGL: (options: {
            type: "image/png" | "image/jpeg" | "image/webp" | "image/jpge";
            resolution?: number | undefined;
            quality?: number | undefined;
            area?: {
                x: number;
                y: number;
                width: number;
                height: number;
            } | undefined;
        }) => Promise<Blob>;
        renderSVG: () => Promise<Document>;
    }, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, ("update:data" | "update:serial" | "update:ready" | "error" | "update:globalScope")[], "update:data" | "update:serial" | "update:ready" | "error" | "update:globalScope", import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
        templateId: {
            type: StringConstructor;
            required: true;
        };
        embedApiBaseUrl: {
            type: StringConstructor;
            required: true;
        };
        env: {
            type: StringConstructor;
            required: true;
        };
        cloudflarePagesHostname: {
            type: StringConstructor;
            required: true;
        };
        bxCoreVersion: {
            type: StringConstructor;
            required: false;
            default: string;
        };
        authorization: {
            type: StringConstructor;
            required: false;
            default: undefined;
        };
        data: {
            type: ObjectConstructor;
            required: false;
            default: () => {};
        };
        fonts: {
            type: ArrayConstructor;
            required: false;
            default: () => never[];
        };
        webgl: {
            type: BooleanConstructor;
            required: false;
            default: boolean;
        };
        resolution: {
            type: NumberConstructor;
            required: false;
            default: number;
        };
        asyncSerial: {
            type: BooleanConstructor;
            required: false;
            default: boolean;
        };
        baseSerial: {
            type: null;
            required: false;
        };
    }>> & Readonly<{
        "onUpdate:data"?: ((...args: any[]) => any) | undefined;
        "onUpdate:serial"?: ((...args: any[]) => any) | undefined;
        "onUpdate:ready"?: ((...args: any[]) => any) | undefined;
        onError?: ((...args: any[]) => any) | undefined;
        "onUpdate:globalScope"?: ((...args: any[]) => any) | undefined;
    }>, {
        data: Record<string, any>;
        bxCoreVersion: string;
        authorization: string;
        fonts: unknown[];
        webgl: boolean;
        resolution: number;
        asyncSerial: boolean;
    }, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
    readonly Zoompinch: import("vue").DefineComponent<{
        transform: {
            type: ObjectConstructor;
            required: false;
            default: () => {
                x: number;
                y: number;
                scale: number;
                rotate: number;
            };
        };
        width: {
            type: NumberConstructor;
            required: true;
        };
        height: {
            type: NumberConstructor;
            required: true;
        };
        offset: {
            type: ObjectConstructor;
            required: false;
            default: () => {
                left: number;
                top: number;
                right: number;
                bottom: number;
            };
        };
        maxScale: {
            type: NumberConstructor;
            required: false;
            default: number;
        };
        minScale: {
            type: NumberConstructor;
            required: false;
            default: number;
        };
        bounds: {
            type: BooleanConstructor;
            required: false;
            default: boolean;
        };
        rotation: {
            type: BooleanConstructor;
            required: false;
            default: boolean;
        };
        mouse: {
            type: BooleanConstructor;
            required: false;
            default: boolean;
        };
        wheel: {
            type: BooleanConstructor;
            required: false;
            default: boolean;
        };
        touch: {
            type: BooleanConstructor;
            required: false;
            default: boolean;
        };
        gesture: {
            type: BooleanConstructor;
            required: false;
            default: boolean;
        };
    }, {
        props: any;
        emit: (event: "update:transform" | "dragGestureStart" | "dragGestureEnd", ...args: any[]) => void;
        zoompinchRef: Ref<HTMLElement | undefined, HTMLElement | undefined>;
        canvasRef: Ref<HTMLElement | undefined, HTMLElement | undefined>;
        matrixRef: Ref<HTMLElement | undefined, HTMLElement | undefined>;
        canvasNaturalWidth: Ref<any, any>;
        canvasNaturalHeight: Ref<any, any>;
        offset: Ref<any, any>;
        rotationEnabled: import("vue").ComputedRef<any>;
        renderingTranslate: import("vue").ComputedRef<number[]>;
        renderingRotate: import("vue").ComputedRef<number>;
        renderingScale: import("vue").ComputedRef<number>;
        composePoint: (x: number, y: number, currScale?: number | undefined, currTranslate?: [number, number] | undefined, currRotate?: number | undefined) => [number, number];
        handleWheel: (event: WheelEvent) => void;
        handleMousedown: (event: MouseEvent) => void;
        handleMousemove: (event: MouseEvent) => void;
        handleMouseup: (event: MouseEvent) => void;
        handleTouchstart: (event: TouchEvent) => void;
        handleTouchmove: (event: TouchEvent) => void;
        handleTouchend: (event: TouchEvent) => void;
        handleGesturestart: (event: UIEvent) => void;
        handleGesturechange: (event: any) => void;
        handleGestureend: (event: any) => void;
        applyTransform: (newScale: number, wrapperInnerCoords: [number, number], canvasAnchorCoords: [number, number], animate?: boolean | undefined) => void;
        rotateCanvas: (x: number, y: number, radians: number) => void;
        compose: (x: number, y: number) => [number, number];
        exposedTransform: import("vue").WritableComputedRef<{
            x: number;
            y: number;
            scale: number;
            rotate: number;
        }, {
            x: number;
            y: number;
            scale: number;
            rotate: number;
        }>;
        calcProjectionTranslate: (newScale: number, wrapperPosition: [number, number], canvasPosition: [number, number], virtualRotate?: number | undefined) => [number, number];
        clientCoordinatesToCanvasCoordinates: (clientX: number, clientY: number) => [number, number];
        normalizeMatrixCoordinates: (clientX: number, clientY: number) => [number, number];
        transitionEnabled: Ref<boolean, boolean>;
        transitionDuration: Ref<number, number>;
        wrapperX: Ref<number, number>;
        wrapperY: Ref<number, number>;
        wrapperWidth: Ref<number, number>;
        wrapperHeight: Ref<number, number>;
        wheelGestures: Readonly<{
            on: <EK extends "wheel">(type: EK, listener: import("zoompinch/lib/controllers/wheel-gestures/events/EventBus").EventListener<import("zoompinch/lib/controllers/wheel-gestures").WheelGesturesEventMap[EK]>) => import("zoompinch/lib/controllers/wheel-gestures/events/EventBus").Off;
            off: <EK_1 extends "wheel">(type: EK_1, listener: import("zoompinch/lib/controllers/wheel-gestures/events/EventBus").EventListener<import("zoompinch/lib/controllers/wheel-gestures").WheelGesturesEventMap[EK_1]>) => void;
            observe: (target: EventTarget) => () => void;
            unobserve: (target: EventTarget) => void;
            disconnect: () => void;
            feedWheel: (wheelEvents: import("zoompinch/lib/controllers/wheel-gestures").WheelEventData | import("zoompinch/lib/controllers/wheel-gestures").WheelEventData[]) => void;
            updateOptions: (newOptions?: Partial<import("zoompinch/lib/controllers/wheel-gestures").WheelGesturesConfig> | undefined) => import("zoompinch/lib/controllers/wheel-gestures").WheelGesturesConfig;
        }>;
        touchmoveSinceTouchstart: boolean;
        touchstartPoint: {
            x: number;
            y: number;
        } | null;
        touchmoveMinDistance: number;
        touchstartProxy: (event: TouchEvent) => void;
        touchmoveProxy: (event: TouchEvent) => void;
        touchendProxy: (event: TouchEvent) => void;
        mousemoveSinceMousedown: boolean;
        mousestartPoint: {
            x: number;
            y: number;
        } | null;
        mousemoveMinDistance: number;
        mousedownProxy: (event: MouseEvent) => void;
        mousemoveProxy: (event: MouseEvent) => void;
        mouseupProxy: (event: MouseEvent) => void;
        isTouchDevice: () => boolean;
        gestureEnabled: import("vue").ComputedRef<any>;
        gesturestartProxy: (event: any) => void;
        gesturechangeProxy: (event: any) => void;
        gestureendProxy: (event: any) => void;
        wrapperBounds: import("vue").ComputedRef<{
            x: number;
            y: number;
            width: number;
            height: number;
        }>;
        readonly radiansToDegrees: typeof import("zoompinch/lib/controllers/helpers").radiansToDegrees;
    }, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, ("update:transform" | "dragGestureStart" | "dragGestureEnd")[], "update:transform" | "dragGestureStart" | "dragGestureEnd", import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
        transform: {
            type: ObjectConstructor;
            required: false;
            default: () => {
                x: number;
                y: number;
                scale: number;
                rotate: number;
            };
        };
        width: {
            type: NumberConstructor;
            required: true;
        };
        height: {
            type: NumberConstructor;
            required: true;
        };
        offset: {
            type: ObjectConstructor;
            required: false;
            default: () => {
                left: number;
                top: number;
                right: number;
                bottom: number;
            };
        };
        maxScale: {
            type: NumberConstructor;
            required: false;
            default: number;
        };
        minScale: {
            type: NumberConstructor;
            required: false;
            default: number;
        };
        bounds: {
            type: BooleanConstructor;
            required: false;
            default: boolean;
        };
        rotation: {
            type: BooleanConstructor;
            required: false;
            default: boolean;
        };
        mouse: {
            type: BooleanConstructor;
            required: false;
            default: boolean;
        };
        wheel: {
            type: BooleanConstructor;
            required: false;
            default: boolean;
        };
        touch: {
            type: BooleanConstructor;
            required: false;
            default: boolean;
        };
        gesture: {
            type: BooleanConstructor;
            required: false;
            default: boolean;
        };
    }>> & {
        "onUpdate:transform"?: ((...args: any[]) => any) | undefined;
        onDragGestureStart?: ((...args: any[]) => any) | undefined;
        onDragGestureEnd?: ((...args: any[]) => any) | undefined;
    }, {
        transform: Record<string, any>;
        offset: Record<string, any>;
        maxScale: number;
        minScale: number;
        bounds: boolean;
        rotation: boolean;
        mouse: boolean;
        wheel: boolean;
        touch: boolean;
        gesture: boolean;
    }, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
    readonly BxButton: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
        size: {
            type: StringConstructor;
            required: false;
            default: string;
        };
        round: {
            type: BooleanConstructor;
            required: false;
            default: boolean;
        };
        circle: {
            type: BooleanConstructor;
            required: false;
            default: boolean;
        };
        secondary: {
            type: BooleanConstructor;
            required: false;
            default: boolean;
        };
        primary: {
            type: BooleanConstructor;
            required: false;
            default: boolean;
        };
        tertiary: {
            type: BooleanConstructor;
            required: false;
        };
        quarternary: {
            type: BooleanConstructor;
            required: false;
            default: boolean;
        };
        disabled: {
            type: BooleanConstructor;
            required: false;
            default: boolean;
        };
        state: {
            type: StringConstructor;
            required: false;
            default: string;
        };
        centered: {
            type: BooleanConstructor;
            required: false;
        };
        tag: {
            type: StringConstructor;
            required: false;
            default: string;
        };
        loading: {
            type: BooleanConstructor;
            required: false;
            default: boolean;
        };
    }>, {
        props: any;
        slots: Readonly<{
            [name: string]: import("vue").Slot<any> | undefined;
        }>;
        BxSpin: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
            size: {
                type: StringConstructor;
                required: false;
                default: string;
            };
        }>, {
            props: any;
        }, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
            size: {
                type: StringConstructor;
                required: false;
                default: string;
            };
        }>> & Readonly<{}>, {
            size: string;
        }, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
    }, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
        size: {
            type: StringConstructor;
            required: false;
            default: string;
        };
        round: {
            type: BooleanConstructor;
            required: false;
            default: boolean;
        };
        circle: {
            type: BooleanConstructor;
            required: false;
            default: boolean;
        };
        secondary: {
            type: BooleanConstructor;
            required: false;
            default: boolean;
        };
        primary: {
            type: BooleanConstructor;
            required: false;
            default: boolean;
        };
        tertiary: {
            type: BooleanConstructor;
            required: false;
        };
        quarternary: {
            type: BooleanConstructor;
            required: false;
            default: boolean;
        };
        disabled: {
            type: BooleanConstructor;
            required: false;
            default: boolean;
        };
        state: {
            type: StringConstructor;
            required: false;
            default: string;
        };
        centered: {
            type: BooleanConstructor;
            required: false;
        };
        tag: {
            type: StringConstructor;
            required: false;
            default: string;
        };
        loading: {
            type: BooleanConstructor;
            required: false;
            default: boolean;
        };
    }>> & Readonly<{}>, {
        size: string;
        round: boolean;
        circle: boolean;
        secondary: boolean;
        primary: boolean;
        tertiary: boolean;
        quarternary: boolean;
        disabled: boolean;
        state: string;
        centered: boolean;
        tag: string;
        loading: boolean;
    }, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
    readonly BxIcon: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
        size: {
            type: (StringConstructor | NumberConstructor)[];
            required: false;
        };
    }>, {
        props: any;
    }, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
        size: {
            type: (StringConstructor | NumberConstructor)[];
            required: false;
        };
    }>> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
    readonly ExpandOutline: import("vue").DefineComponent<{}, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, import("vue").EmitsOptions, string, import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<import("vue").ExtractPropTypes<{}>>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
    readonly BandageOutline: import("vue").DefineComponent<{}, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, import("vue").EmitsOptions, string, import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<import("vue").ExtractPropTypes<{}>>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
    readonly RefreshOutline: import("vue").DefineComponent<{}, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, import("vue").EmitsOptions, string, import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<import("vue").ExtractPropTypes<{}>>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
    BxCard: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
        title: {
            type: StringConstructor;
            required: false;
        };
        description: {
            type: StringConstructor;
            required: false;
        };
        cover: {
            type: StringConstructor;
            required: false;
        };
        size: {
            type: StringConstructor;
            required: false;
            default: string;
        };
        bordered: {
            type: BooleanConstructor;
            required: false;
            default: boolean;
        };
        transculent: {
            type: BooleanConstructor;
            required: false;
            default: boolean;
        };
        coverWidth: {
            type: StringConstructor;
            required: false;
        };
        hoverable: {
            type: BooleanConstructor;
            required: false;
            default: boolean;
        };
        dividers: {
            type: BooleanConstructor;
            required: false;
            default: boolean;
        };
    }>, {
        props: any;
        slots: Readonly<{
            [name: string]: import("vue").Slot<any> | undefined;
        }>;
    }, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
        title: {
            type: StringConstructor;
            required: false;
        };
        description: {
            type: StringConstructor;
            required: false;
        };
        cover: {
            type: StringConstructor;
            required: false;
        };
        size: {
            type: StringConstructor;
            required: false;
            default: string;
        };
        bordered: {
            type: BooleanConstructor;
            required: false;
            default: boolean;
        };
        transculent: {
            type: BooleanConstructor;
            required: false;
            default: boolean;
        };
        coverWidth: {
            type: StringConstructor;
            required: false;
        };
        hoverable: {
            type: BooleanConstructor;
            required: false;
            default: boolean;
        };
        dividers: {
            type: BooleanConstructor;
            required: false;
            default: boolean;
        };
    }>> & Readonly<{}>, {
        transculent: boolean;
        size: string;
        bordered: boolean;
        hoverable: boolean;
        dividers: boolean;
    }, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<{}> & Readonly<{}>, {} | {
    [x: string]: any;
}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
export default _sfc_main;
//# sourceMappingURL=BluepicLiveTemplate.vue.d.ts.map