@bluepic/embed 0.1.0

package/lib/components/BluepicLiveTemplate.vue.d.ts

@@ -0,0 +1,1895 @@
+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: import("vue").Ref<{
+        [k: string]: unknown;
+    } | undefined, {
+        [k: string]: unknown;
+    } | undefined>;
+    bluepicEmbeddedRef: import("vue").Ref<import("vue").CreateComponentPublicInstanceWithMixins<Readonly<import("vue").ExtractPropTypes<{
+        templateId: {
+            type: StringConstructor;
+            required: true;
+        };
+        studioResourcesBaseUrl: {
+            type: StringConstructor;
+            required: true;
+        };
+        cloudflarePagesHostname: {
+            type: StringConstructor;
+            required: true;
+        };
+        publishedVersionSlug: {
+            type: StringConstructor;
+            required: false;
+            default: string;
+        };
+        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;
+        asyncSerialIsEnabled: import("vue").ComputedRef<any>;
+        maxTries: number;
+        serialPromise: Promise<Template.Serial> | undefined;
+        frameURL: import("vue").ComputedRef<string>;
+        ready: import("vue").Ref<boolean, boolean>;
+        serial: import("vue").Ref<Template.Serial | undefined, Template.Serial | undefined>;
+        frameRef: import("vue").Ref<HTMLIFrameElement | undefined, HTMLIFrameElement | undefined>;
+        controller: import("vue").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>;
+        publishedVersionSlug: string;
+        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;
+        };
+        studioResourcesBaseUrl: {
+            type: StringConstructor;
+            required: true;
+        };
+        cloudflarePagesHostname: {
+            type: StringConstructor;
+            required: true;
+        };
+        publishedVersionSlug: {
+            type: StringConstructor;
+            required: false;
+            default: string;
+        };
+        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;
+        asyncSerialIsEnabled: import("vue").ComputedRef<any>;
+        maxTries: number;
+        serialPromise: Promise<Template.Serial> | undefined;
+        frameURL: import("vue").ComputedRef<string>;
+        ready: import("vue").Ref<boolean, boolean>;
+        serial: import("vue").Ref<Template.Serial | undefined, Template.Serial | undefined>;
+        frameRef: import("vue").Ref<HTMLIFrameElement | undefined, HTMLIFrameElement | undefined>;
+        controller: import("vue").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>;
+        publishedVersionSlug: string;
+        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;
+        };
+        studioResourcesBaseUrl: {
+            type: StringConstructor;
+            required: true;
+        };
+        cloudflarePagesHostname: {
+            type: StringConstructor;
+            required: true;
+        };
+        publishedVersionSlug: {
+            type: StringConstructor;
+            required: false;
+            default: string;
+        };
+        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;
+        asyncSerialIsEnabled: import("vue").ComputedRef<any>;
+        maxTries: number;
+        serialPromise: Promise<Template.Serial> | undefined;
+        frameURL: import("vue").ComputedRef<string>;
+        ready: import("vue").Ref<boolean, boolean>;
+        serial: import("vue").Ref<Template.Serial | undefined, Template.Serial | undefined>;
+        frameRef: import("vue").Ref<HTMLIFrameElement | undefined, HTMLIFrameElement | undefined>;
+        controller: import("vue").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>;
+        publishedVersionSlug: string;
+        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;
+        };
+        studioResourcesBaseUrl: {
+            type: StringConstructor;
+            required: true;
+        };
+        cloudflarePagesHostname: {
+            type: StringConstructor;
+            required: true;
+        };
+        publishedVersionSlug: {
+            type: StringConstructor;
+            required: false;
+            default: string;
+        };
+        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;
+        asyncSerialIsEnabled: import("vue").ComputedRef<any>;
+        maxTries: number;
+        serialPromise: Promise<Template.Serial> | undefined;
+        frameURL: import("vue").ComputedRef<string>;
+        ready: import("vue").Ref<boolean, boolean>;
+        serial: import("vue").Ref<Template.Serial | undefined, Template.Serial | undefined>;
+        frameRef: import("vue").Ref<HTMLIFrameElement | undefined, HTMLIFrameElement | undefined>;
+        controller: import("vue").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>;
+        publishedVersionSlug: string;
+        bxCoreVersion: string;
+        authorization: string;
+        fonts: unknown[];
+        webgl: boolean;
+        resolution: number;
+        asyncSerial: boolean;
+    }> | undefined>;
+    zoompinchRef: import("vue").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: import("vue").Ref<HTMLElement | undefined, HTMLElement | undefined>;
+        canvasRef: import("vue").Ref<HTMLElement | undefined, HTMLElement | undefined>;
+        matrixRef: import("vue").Ref<HTMLElement | undefined, HTMLElement | undefined>;
+        canvasNaturalWidth: import("vue").Ref<any, any>;
+        canvasNaturalHeight: import("vue").Ref<any, any>;
+        offset: import("vue").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: import("vue").Ref<boolean, boolean>;
+        transitionDuration: import("vue").Ref<number, number>;
+        wrapperX: import("vue").Ref<number, number>;
+        wrapperY: import("vue").Ref<number, number>;
+        wrapperWidth: import("vue").Ref<number, number>;
+        wrapperHeight: import("vue").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: import("vue").Ref<HTMLElement | undefined, HTMLElement | undefined>;
+        canvasRef: import("vue").Ref<HTMLElement | undefined, HTMLElement | undefined>;
+        matrixRef: import("vue").Ref<HTMLElement | undefined, HTMLElement | undefined>;
+        canvasNaturalWidth: import("vue").Ref<any, any>;
+        canvasNaturalHeight: import("vue").Ref<any, any>;
+        offset: import("vue").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: import("vue").Ref<boolean, boolean>;
+        transitionDuration: import("vue").Ref<number, number>;
+        wrapperX: import("vue").Ref<number, number>;
+        wrapperY: import("vue").Ref<number, number>;
+        wrapperWidth: import("vue").Ref<number, number>;
+        wrapperHeight: import("vue").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: import("vue").Ref<HTMLElement | undefined, HTMLElement | undefined>;
+        canvasRef: import("vue").Ref<HTMLElement | undefined, HTMLElement | undefined>;
+        matrixRef: import("vue").Ref<HTMLElement | undefined, HTMLElement | undefined>;
+        canvasNaturalWidth: import("vue").Ref<any, any>;
+        canvasNaturalHeight: import("vue").Ref<any, any>;
+        offset: import("vue").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: import("vue").Ref<boolean, boolean>;
+        transitionDuration: import("vue").Ref<number, number>;
+        wrapperX: import("vue").Ref<number, number>;
+        wrapperY: import("vue").Ref<number, number>;
+        wrapperWidth: import("vue").Ref<number, number>;
+        wrapperHeight: import("vue").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: import("vue").Ref<HTMLElement | undefined, HTMLElement | undefined>;
+        canvasRef: import("vue").Ref<HTMLElement | undefined, HTMLElement | undefined>;
+        matrixRef: import("vue").Ref<HTMLElement | undefined, HTMLElement | undefined>;
+        canvasNaturalWidth: import("vue").Ref<any, any>;
+        canvasNaturalHeight: import("vue").Ref<any, any>;
+        offset: import("vue").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: import("vue").Ref<boolean, boolean>;
+        transitionDuration: import("vue").Ref<number, number>;
+        wrapperX: import("vue").Ref<number, number>;
+        wrapperY: import("vue").Ref<number, number>;
+        wrapperWidth: import("vue").Ref<number, number>;
+        wrapperHeight: import("vue").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: import("vue").Ref<HTMLDivElement | undefined, HTMLDivElement | undefined>;
+    bluepicLiveTemplateRootWidth: import("vue").Ref<number, number>;
+    bluepicLiveTemplateRootHeight: import("vue").Ref<number, number>;
+    wrapperAspectRatio: import("vue").ComputedRef<number>;
+    aspectRatio: import("vue").ComputedRef<number | undefined>;
+    aspectRatioSizingSide: import("vue").ComputedRef<"width" | "height" | undefined>;
+    transform: import("vue").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: import("vue").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: import("vue").Ref<number | undefined, number | undefined>;
+    handleError: (code: number) => void;
+    retryTemplateLoad: () => void;
+    lastTouch: import("vue").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;
+        };
+        studioResourcesBaseUrl: {
+            type: StringConstructor;
+            required: true;
+        };
+        cloudflarePagesHostname: {
+            type: StringConstructor;
+            required: true;
+        };
+        publishedVersionSlug: {
+            type: StringConstructor;
+            required: false;
+            default: string;
+        };
+        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;
+        asyncSerialIsEnabled: import("vue").ComputedRef<any>;
+        maxTries: number;
+        serialPromise: Promise<Template.Serial> | undefined;
+        frameURL: import("vue").ComputedRef<string>;
+        ready: import("vue").Ref<boolean, boolean>;
+        serial: import("vue").Ref<Template.Serial | undefined, Template.Serial | undefined>;
+        frameRef: import("vue").Ref<HTMLIFrameElement | undefined, HTMLIFrameElement | undefined>;
+        controller: import("vue").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;
+        };
+        studioResourcesBaseUrl: {
+            type: StringConstructor;
+            required: true;
+        };
+        cloudflarePagesHostname: {
+            type: StringConstructor;
+            required: true;
+        };
+        publishedVersionSlug: {
+            type: StringConstructor;
+            required: false;
+            default: string;
+        };
+        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>;
+        publishedVersionSlug: string;
+        bxCoreVersion: string;
+        authorization: string;
+        fonts: unknown[];
+        webgl: boolean;
+        resolution: number;
+        asyncSerial: boolean;
+    }, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+    BluepicSpinner: import("vue").DefineComponent<{}, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, 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: import("vue").Ref<HTMLElement | undefined, HTMLElement | undefined>;
+        canvasRef: import("vue").Ref<HTMLElement | undefined, HTMLElement | undefined>;
+        matrixRef: import("vue").Ref<HTMLElement | undefined, HTMLElement | undefined>;
+        canvasNaturalWidth: import("vue").Ref<any, any>;
+        canvasNaturalHeight: import("vue").Ref<any, any>;
+        offset: import("vue").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: import("vue").Ref<boolean, boolean>;
+        transitionDuration: import("vue").Ref<number, number>;
+        wrapperX: import("vue").Ref<number, number>;
+        wrapperY: import("vue").Ref<number, number>;
+        wrapperWidth: import("vue").Ref<number, number>;
+        wrapperHeight: import("vue").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;
+        darkmode: import("vue").ComputedRef<boolean>;
+        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;
+        darkmode: import("vue").ComputedRef<boolean>;
+        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