@roomle/embedding-lib 5.23.0-alpha.1 → 5.24.0-alpha.1

package/src/configurator/components/utils/PopUp.vue.d.ts

@@ -9,15 +9,7 @@ interface Props {
     size?: PopUpSize;
     alignTo?: PopUpAlignment;
 }
-declare const _default: __VLS_WithTemplateSlots<import('vue').DefineComponent<import('vue').ExtractPropTypes<__VLS_WithDefaults<__VLS_TypePropsToOption<Props>, {
-    displayCloseButton: boolean;
-    isDesktop: boolean;
-    isLightTheme: boolean;
-}>>, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<__VLS_WithDefaults<__VLS_TypePropsToOption<Props>, {
-    displayCloseButton: boolean;
-    isDesktop: boolean;
-    isLightTheme: boolean;
-}>>> & Readonly<{}>, {
+declare const _default: __VLS_WithTemplateSlots<import('vue').DefineComponent<Props, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<Props> & Readonly<{}>, {
     isDesktop: boolean;
     displayCloseButton: boolean;
     isLightTheme: boolean;
@@ -27,25 +19,8 @@ declare const _default: __VLS_WithTemplateSlots<import('vue').DefineComponent<im
     }): any;
 }>;
 export default _default;
-type __VLS_WithDefaults<P, D> = {
-    [K in keyof Pick<P, keyof P>]: K extends keyof D ? __VLS_Prettify<P[K] & {
-        default: D[K];
-    }> : P[K];
-};
-type __VLS_Prettify<T> = {
-    [K in keyof T]: T[K];
-} & {};
 type __VLS_WithTemplateSlots<T, S> = T & {
     new (): {
         $slots: S;
     };
 };
-type __VLS_NonUndefinedable<T> = T extends undefined ? never : T;
-type __VLS_TypePropsToOption<T> = {
-    [K in keyof T]-?: {} extends Pick<T, K> ? {
-        type: import('vue').PropType<__VLS_NonUndefinedable<T[K]>>;
-    } : {
-        type: import('vue').PropType<T[K]>;
-        required: true;
-    };
-};

package/src/configurator/components/utils/PrimaryButton.vue.d.ts

@@ -31,6 +31,10 @@ declare const _default: import('vue').DefineComponent<import('vue').ExtractPropT
     disabled: boolean;
     red: boolean;
 }, {}, {
-    Spinner: import('vue').DefineComponent<{}, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;
+    Spinner: import('vue').DefineComponent<{
+        size?: string;
+    }, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<{
+        size?: string;
+    }> & Readonly<{}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;
 }, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;
 export default _default;

package/src/configurator/components/utils/SearchInput.vue.d.ts

@@ -1,34 +1,11 @@
-declare const _default: import('vue').DefineComponent<import('vue').ExtractPropTypes<__VLS_WithDefaults<__VLS_TypePropsToOption<{
+declare const _default: import('vue').DefineComponent<{
     isDesktop?: boolean;
     onChange?: (event: Event) => void;
-}>, {
-    isDesktop: boolean;
-    onChange: () => any;
-}>>, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<__VLS_WithDefaults<__VLS_TypePropsToOption<{
+}, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<{
     isDesktop?: boolean;
     onChange?: (event: Event) => void;
-}>, {
-    isDesktop: boolean;
-    onChange: () => any;
-}>>> & Readonly<{}>, {
+}> & Readonly<{}>, {
     isDesktop: boolean;
     onChange: (event: Event) => void;
 }, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;
 export default _default;
-type __VLS_WithDefaults<P, D> = {
-    [K in keyof Pick<P, keyof P>]: K extends keyof D ? __VLS_Prettify<P[K] & {
-        default: D[K];
-    }> : P[K];
-};
-type __VLS_Prettify<T> = {
-    [K in keyof T]: T[K];
-} & {};
-type __VLS_NonUndefinedable<T> = T extends undefined ? never : T;
-type __VLS_TypePropsToOption<T> = {
-    [K in keyof T]-?: {} extends Pick<T, K> ? {
-        type: import('vue').PropType<__VLS_NonUndefinedable<T[K]>>;
-    } : {
-        type: import('vue').PropType<T[K]>;
-        required: true;
-    };
-};

package/src/configurator/components/utils/Spinner.vue.d.ts

@@ -1,2 +1,6 @@
-declare const _default: import('vue').DefineComponent<{}, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;
+declare const _default: import('vue').DefineComponent<{
+    size?: string;
+}, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<{
+    size?: string;
+}> & Readonly<{}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;
 export default _default;

package/src/configurator/components/utils/StartConfiguringButton.vue.d.ts

@@ -4,18 +4,36 @@ declare const _default: import('vue').DefineComponent<{}, {}, {}, {
     startConfiguring(): Promise<void>;
 }, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {
     SelectionButton: {
-        new (...args: any[]): import('vue').CreateComponentPublicInstanceWithMixins<Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, import('vue').VNodeProps & import('vue').AllowedComponentProps & import('vue').ComponentCustomProps & Readonly<{}> & Readonly<{}>, {}, true, {}, {}, import('vue').GlobalComponents, import('vue').GlobalDirectives, string, {}, any, import('vue').ComponentProvideOptions, {
+        new (...args: any[]): import('vue').CreateComponentPublicInstanceWithMixins<Readonly<{
+            onClick?: () => void;
+            dark?: boolean;
+            red?: boolean;
+            svgBigger?: boolean;
+            active?: boolean;
+        }> & Readonly<{}>, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, import('vue').PublicProps, {}, true, {}, {}, import('vue').GlobalComponents, import('vue').GlobalDirectives, string, {}, any, import('vue').ComponentProvideOptions, {
             P: {};
             B: {};
             D: {};
             C: {};
             M: {};
             Defaults: {};
-        }, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, {}>;
+        }, Readonly<{
+            onClick?: () => void;
+            dark?: boolean;
+            red?: boolean;
+            svgBigger?: boolean;
+            active?: boolean;
+        }> & Readonly<{}>, {}, {}, {}, {}, {}>;
         __isFragment?: never;
         __isTeleport?: never;
         __isSuspense?: never;
-    } & import('vue').ComponentOptionsBase<Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, {}, {}, string, {}, import('vue').GlobalComponents, import('vue').GlobalDirectives, string, import('vue').ComponentProvideOptions> & import('vue').VNodeProps & import('vue').AllowedComponentProps & import('vue').ComponentCustomProps & (new () => {
+    } & import('vue').ComponentOptionsBase<Readonly<{
+        onClick?: () => void;
+        dark?: boolean;
+        red?: boolean;
+        svgBigger?: boolean;
+        active?: boolean;
+    }> & Readonly<{}>, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, {}, {}, string, {}, import('vue').GlobalComponents, import('vue').GlobalDirectives, string, import('vue').ComponentProvideOptions> & import('vue').VNodeProps & import('vue').AllowedComponentProps & import('vue').ComponentCustomProps & (new () => {
         $slots: {
             default?(_: {}): any;
         };

package/src/planner/components/DraggableButton.vue.d.ts

@@ -15,7 +15,10 @@ declare const _default: __VLS_WithTemplateSlots<import('vue').DefineComponent<{
     initPosition: PointCoords;
 }, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, any>, {
     default?(_: {
-        currentBtnPosition: PointCoords;
+        currentBtnPosition: {
+            x: number;
+            y: number;
+        };
         isDragging: boolean;
     }): any;
 }>;

package/src/planner/components/RotationIndicator.vue.d.ts

@@ -1,40 +1,20 @@
 import { PointCoords } from '../utils/rotation-calculation';
 
-declare const _default: __VLS_WithTemplateSlots<import('vue').DefineComponent<import('vue').ExtractPropTypes<__VLS_WithDefaults<__VLS_TypePropsToOption<{
+declare const _default: __VLS_WithTemplateSlots<import('vue').DefineComponent<{
     selectedObjCenter?: PointCoords;
     progress?: number;
     radius?: number;
     stroke?: number;
     snapDegrees?: number;
     rotationDegrees?: number;
-}>, {
-    selectedObjCenter: () => {
-        x: number;
-        y: number;
-    };
-    progress: number;
-    radius: number;
-    stroke: number;
-    snapDegrees: number;
-    rotationDegrees: number;
-}>>, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<__VLS_WithDefaults<__VLS_TypePropsToOption<{
+}, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<{
     selectedObjCenter?: PointCoords;
     progress?: number;
     radius?: number;
     stroke?: number;
     snapDegrees?: number;
     rotationDegrees?: number;
-}>, {
-    selectedObjCenter: () => {
-        x: number;
-        y: number;
-    };
-    progress: number;
-    radius: number;
-    stroke: number;
-    snapDegrees: number;
-    rotationDegrees: number;
-}>>> & Readonly<{}>, {
+}> & Readonly<{}>, {
     progress: number;
     stroke: number;
     selectedObjCenter: PointCoords;
@@ -45,25 +25,8 @@ declare const _default: __VLS_WithTemplateSlots<import('vue').DefineComponent<im
     default?(_: {}): any;
 }>;
 export default _default;
-type __VLS_WithDefaults<P, D> = {
-    [K in keyof Pick<P, keyof P>]: K extends keyof D ? __VLS_Prettify<P[K] & {
-        default: D[K];
-    }> : P[K];
-};
-type __VLS_Prettify<T> = {
-    [K in keyof T]: T[K];
-} & {};
 type __VLS_WithTemplateSlots<T, S> = T & {
     new (): {
         $slots: S;
     };
 };
-type __VLS_NonUndefinedable<T> = T extends undefined ? never : T;
-type __VLS_TypePropsToOption<T> = {
-    [K in keyof T]-?: {} extends Pick<T, K> ? {
-        type: import('vue').PropType<__VLS_NonUndefinedable<T[K]>>;
-    } : {
-        type: import('vue').PropType<T[K]>;
-        required: true;
-    };
-};

package/src/planner/components/overlays/ProductListButton.vue.d.ts

@@ -1,2 +1,6 @@
-declare const _default: import('vue').DefineComponent<{}, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;
+declare const _default: import('vue').DefineComponent<{
+    onClick?: () => void;
+}, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<{
+    onClick?: () => void;
+}> & Readonly<{}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;
 export default _default;

package/src/planner/components/overlays/product-settings/ProductRangeControl.vue.d.ts

@@ -1,4 +1,5 @@
 import { PropType } from 'vue';
+import { StoreState } from '../../../../common/store';
 
 declare const _default: import('vue').DefineComponent<import('vue').ExtractPropTypes<{
     onClick: FunctionConstructor;
@@ -14,6 +15,328 @@ declare const _default: import('vue').DefineComponent<import('vue').ExtractPropT
     disabled: BooleanConstructor;
 }>, {
     store: any;
+    commonUiStore: import('pinia').Store<"commonUiStore", Pick<{
+        showFlyingMenu: import('vue').Ref<boolean, boolean>;
+        flyingMenuTriggeredByClick: import('vue').Ref<boolean, boolean>;
+        isInIframe: import('vue').Ref<boolean, boolean>;
+        isViewOnly: import('vue').Ref<boolean, boolean>;
+        lastRequestedId: import('vue').Ref<string, string>;
+        currentViewMode: import('vue').Ref<import('../../../../common/utils/types').Enumify<{
+            readonly '2D': "2d";
+            readonly '3D': "3d";
+            readonly FIRST_PERSON: "fp";
+        }>, import('../../../../common/utils/types').Enumify<{
+            readonly '2D': "2d";
+            readonly '3D': "3d";
+            readonly FIRST_PERSON: "fp";
+        }>>;
+        isShadowOnStage: import('vue').Ref<boolean, boolean>;
+        measurementUnit: import('vue').Ref<import('../../../../common/utils/types').Enumify<{
+            readonly FEET: "feet";
+            readonly INCH_FEET: "inchfeet";
+            readonly INCH: "inch";
+            readonly CM: "cm";
+            readonly MM: "mm";
+        }>, import('../../../../common/utils/types').Enumify<{
+            readonly FEET: "feet";
+            readonly INCH_FEET: "inchfeet";
+            readonly INCH: "inch";
+            readonly CM: "cm";
+            readonly MM: "mm";
+        }>>;
+        measurementSystem: import('vue').Ref<import('../../../../common/utils/types').Enumify<{
+            readonly IMPERIAL: "imperial";
+            readonly METRIC: "metric";
+        }>, import('../../../../common/utils/types').Enumify<{
+            readonly IMPERIAL: "imperial";
+            readonly METRIC: "metric";
+        }>>;
+        isTextInputFocused: import('vue').Ref<boolean, boolean>;
+        isCameraIdle: import('vue').Ref<boolean, boolean>;
+        currentEmbeddedInfos: import('vue').Ref<{
+            type: import('@roomle/web-sdk/lib/definitions/common-core/src/types').Enumify<{
+                readonly PARAMETER: "parameter";
+                readonly PARAMETER_VALUE: "paramValue";
+                readonly MATERIAL: "material";
+                readonly COMPONENT: "component";
+                readonly ITEM: "item";
+            }>;
+            key: string;
+            parentIdFilter: string;
+            catalog: string;
+            tooltip: {
+                [key: string]: string;
+            };
+            fullInfo: {
+                type: string;
+                url: {
+                    [key: string]: string;
+                };
+            };
+        }[], import('@roomle/web-sdk/lib/definitions/typings/rapi-types').AdditionalInfo[] | {
+            type: import('@roomle/web-sdk/lib/definitions/common-core/src/types').Enumify<{
+                readonly PARAMETER: "parameter";
+                readonly PARAMETER_VALUE: "paramValue";
+                readonly MATERIAL: "material";
+                readonly COMPONENT: "component";
+                readonly ITEM: "item";
+            }>;
+            key: string;
+            parentIdFilter: string;
+            catalog: string;
+            tooltip: {
+                [key: string]: string;
+            };
+            fullInfo: {
+                type: string;
+                url: {
+                    [key: string]: string;
+                };
+            };
+        }[]>;
+        isDraggingElement: import('vue').Ref<boolean, boolean>;
+        loadedConfigFromIdb: import('vue').Ref<boolean, boolean>;
+        notificationVisible: import('vue').Ref<boolean, boolean>;
+        configuratorHintClosed: import('vue').Ref<boolean, boolean>;
+        is2d: import('vue').ComputedRef<boolean>;
+        is3d: import('vue').ComputedRef<boolean>;
+        isFp: import('vue').ComputedRef<boolean>;
+        setPiniaVuexReference: (store: Store<StoreState>) => void;
+        setViewMode: ({ isDesktop, isLandscape, }: {
+            isDesktop: boolean;
+            isLandscape: boolean;
+        }) => void;
+        setFlyingMenuVisibility: (payload: {
+            show: boolean;
+            flyingMenuTriggeredByClick: boolean;
+        }) => void;
+        setDraggingElementStatus: (isDragging: boolean) => void;
+        setMeasurementUnit: (unit: import('../../../../common/utils/types').Enumify<{
+            readonly FEET: "feet";
+            readonly INCH_FEET: "inchfeet";
+            readonly INCH: "inch";
+            readonly CM: "cm";
+            readonly MM: "mm";
+        }>) => void;
+        setMeasurementSystem: (system: import('../../../../common/utils/types').Enumify<{
+            readonly IMPERIAL: "imperial";
+            readonly METRIC: "metric";
+        }>) => void;
+    }, "showFlyingMenu" | "flyingMenuTriggeredByClick" | "isInIframe" | "isViewOnly" | "lastRequestedId" | "currentViewMode" | "isShadowOnStage" | "measurementUnit" | "measurementSystem" | "isTextInputFocused" | "isCameraIdle" | "currentEmbeddedInfos" | "isDraggingElement" | "loadedConfigFromIdb" | "notificationVisible" | "configuratorHintClosed">, Pick<{
+        showFlyingMenu: import('vue').Ref<boolean, boolean>;
+        flyingMenuTriggeredByClick: import('vue').Ref<boolean, boolean>;
+        isInIframe: import('vue').Ref<boolean, boolean>;
+        isViewOnly: import('vue').Ref<boolean, boolean>;
+        lastRequestedId: import('vue').Ref<string, string>;
+        currentViewMode: import('vue').Ref<import('../../../../common/utils/types').Enumify<{
+            readonly '2D': "2d";
+            readonly '3D': "3d";
+            readonly FIRST_PERSON: "fp";
+        }>, import('../../../../common/utils/types').Enumify<{
+            readonly '2D': "2d";
+            readonly '3D': "3d";
+            readonly FIRST_PERSON: "fp";
+        }>>;
+        isShadowOnStage: import('vue').Ref<boolean, boolean>;
+        measurementUnit: import('vue').Ref<import('../../../../common/utils/types').Enumify<{
+            readonly FEET: "feet";
+            readonly INCH_FEET: "inchfeet";
+            readonly INCH: "inch";
+            readonly CM: "cm";
+            readonly MM: "mm";
+        }>, import('../../../../common/utils/types').Enumify<{
+            readonly FEET: "feet";
+            readonly INCH_FEET: "inchfeet";
+            readonly INCH: "inch";
+            readonly CM: "cm";
+            readonly MM: "mm";
+        }>>;
+        measurementSystem: import('vue').Ref<import('../../../../common/utils/types').Enumify<{
+            readonly IMPERIAL: "imperial";
+            readonly METRIC: "metric";
+        }>, import('../../../../common/utils/types').Enumify<{
+            readonly IMPERIAL: "imperial";
+            readonly METRIC: "metric";
+        }>>;
+        isTextInputFocused: import('vue').Ref<boolean, boolean>;
+        isCameraIdle: import('vue').Ref<boolean, boolean>;
+        currentEmbeddedInfos: import('vue').Ref<{
+            type: import('@roomle/web-sdk/lib/definitions/common-core/src/types').Enumify<{
+                readonly PARAMETER: "parameter";
+                readonly PARAMETER_VALUE: "paramValue";
+                readonly MATERIAL: "material";
+                readonly COMPONENT: "component";
+                readonly ITEM: "item";
+            }>;
+            key: string;
+            parentIdFilter: string;
+            catalog: string;
+            tooltip: {
+                [key: string]: string;
+            };
+            fullInfo: {
+                type: string;
+                url: {
+                    [key: string]: string;
+                };
+            };
+        }[], import('@roomle/web-sdk/lib/definitions/typings/rapi-types').AdditionalInfo[] | {
+            type: import('@roomle/web-sdk/lib/definitions/common-core/src/types').Enumify<{
+                readonly PARAMETER: "parameter";
+                readonly PARAMETER_VALUE: "paramValue";
+                readonly MATERIAL: "material";
+                readonly COMPONENT: "component";
+                readonly ITEM: "item";
+            }>;
+            key: string;
+            parentIdFilter: string;
+            catalog: string;
+            tooltip: {
+                [key: string]: string;
+            };
+            fullInfo: {
+                type: string;
+                url: {
+                    [key: string]: string;
+                };
+            };
+        }[]>;
+        isDraggingElement: import('vue').Ref<boolean, boolean>;
+        loadedConfigFromIdb: import('vue').Ref<boolean, boolean>;
+        notificationVisible: import('vue').Ref<boolean, boolean>;
+        configuratorHintClosed: import('vue').Ref<boolean, boolean>;
+        is2d: import('vue').ComputedRef<boolean>;
+        is3d: import('vue').ComputedRef<boolean>;
+        isFp: import('vue').ComputedRef<boolean>;
+        setPiniaVuexReference: (store: Store<StoreState>) => void;
+        setViewMode: ({ isDesktop, isLandscape, }: {
+            isDesktop: boolean;
+            isLandscape: boolean;
+        }) => void;
+        setFlyingMenuVisibility: (payload: {
+            show: boolean;
+            flyingMenuTriggeredByClick: boolean;
+        }) => void;
+        setDraggingElementStatus: (isDragging: boolean) => void;
+        setMeasurementUnit: (unit: import('../../../../common/utils/types').Enumify<{
+            readonly FEET: "feet";
+            readonly INCH_FEET: "inchfeet";
+            readonly INCH: "inch";
+            readonly CM: "cm";
+            readonly MM: "mm";
+        }>) => void;
+        setMeasurementSystem: (system: import('../../../../common/utils/types').Enumify<{
+            readonly IMPERIAL: "imperial";
+            readonly METRIC: "metric";
+        }>) => void;
+    }, "is2d" | "is3d" | "isFp">, Pick<{
+        showFlyingMenu: import('vue').Ref<boolean, boolean>;
+        flyingMenuTriggeredByClick: import('vue').Ref<boolean, boolean>;
+        isInIframe: import('vue').Ref<boolean, boolean>;
+        isViewOnly: import('vue').Ref<boolean, boolean>;
+        lastRequestedId: import('vue').Ref<string, string>;
+        currentViewMode: import('vue').Ref<import('../../../../common/utils/types').Enumify<{
+            readonly '2D': "2d";
+            readonly '3D': "3d";
+            readonly FIRST_PERSON: "fp";
+        }>, import('../../../../common/utils/types').Enumify<{
+            readonly '2D': "2d";
+            readonly '3D': "3d";
+            readonly FIRST_PERSON: "fp";
+        }>>;
+        isShadowOnStage: import('vue').Ref<boolean, boolean>;
+        measurementUnit: import('vue').Ref<import('../../../../common/utils/types').Enumify<{
+            readonly FEET: "feet";
+            readonly INCH_FEET: "inchfeet";
+            readonly INCH: "inch";
+            readonly CM: "cm";
+            readonly MM: "mm";
+        }>, import('../../../../common/utils/types').Enumify<{
+            readonly FEET: "feet";
+            readonly INCH_FEET: "inchfeet";
+            readonly INCH: "inch";
+            readonly CM: "cm";
+            readonly MM: "mm";
+        }>>;
+        measurementSystem: import('vue').Ref<import('../../../../common/utils/types').Enumify<{
+            readonly IMPERIAL: "imperial";
+            readonly METRIC: "metric";
+        }>, import('../../../../common/utils/types').Enumify<{
+            readonly IMPERIAL: "imperial";
+            readonly METRIC: "metric";
+        }>>;
+        isTextInputFocused: import('vue').Ref<boolean, boolean>;
+        isCameraIdle: import('vue').Ref<boolean, boolean>;
+        currentEmbeddedInfos: import('vue').Ref<{
+            type: import('@roomle/web-sdk/lib/definitions/common-core/src/types').Enumify<{
+                readonly PARAMETER: "parameter";
+                readonly PARAMETER_VALUE: "paramValue";
+                readonly MATERIAL: "material";
+                readonly COMPONENT: "component";
+                readonly ITEM: "item";
+            }>;
+            key: string;
+            parentIdFilter: string;
+            catalog: string;
+            tooltip: {
+                [key: string]: string;
+            };
+            fullInfo: {
+                type: string;
+                url: {
+                    [key: string]: string;
+                };
+            };
+        }[], import('@roomle/web-sdk/lib/definitions/typings/rapi-types').AdditionalInfo[] | {
+            type: import('@roomle/web-sdk/lib/definitions/common-core/src/types').Enumify<{
+                readonly PARAMETER: "parameter";
+                readonly PARAMETER_VALUE: "paramValue";
+                readonly MATERIAL: "material";
+                readonly COMPONENT: "component";
+                readonly ITEM: "item";
+            }>;
+            key: string;
+            parentIdFilter: string;
+            catalog: string;
+            tooltip: {
+                [key: string]: string;
+            };
+            fullInfo: {
+                type: string;
+                url: {
+                    [key: string]: string;
+                };
+            };
+        }[]>;
+        isDraggingElement: import('vue').Ref<boolean, boolean>;
+        loadedConfigFromIdb: import('vue').Ref<boolean, boolean>;
+        notificationVisible: import('vue').Ref<boolean, boolean>;
+        configuratorHintClosed: import('vue').Ref<boolean, boolean>;
+        is2d: import('vue').ComputedRef<boolean>;
+        is3d: import('vue').ComputedRef<boolean>;
+        isFp: import('vue').ComputedRef<boolean>;
+        setPiniaVuexReference: (store: Store<StoreState>) => void;
+        setViewMode: ({ isDesktop, isLandscape, }: {
+            isDesktop: boolean;
+            isLandscape: boolean;
+        }) => void;
+        setFlyingMenuVisibility: (payload: {
+            show: boolean;
+            flyingMenuTriggeredByClick: boolean;
+        }) => void;
+        setDraggingElementStatus: (isDragging: boolean) => void;
+        setMeasurementUnit: (unit: import('../../../../common/utils/types').Enumify<{
+            readonly FEET: "feet";
+            readonly INCH_FEET: "inchfeet";
+            readonly INCH: "inch";
+            readonly CM: "cm";
+            readonly MM: "mm";
+        }>) => void;
+        setMeasurementSystem: (system: import('../../../../common/utils/types').Enumify<{
+            readonly IMPERIAL: "imperial";
+            readonly METRIC: "metric";
+        }>) => void;
+    }, "setPiniaVuexReference" | "setViewMode" | "setFlyingMenuVisibility" | "setDraggingElementStatus" | "setMeasurementUnit" | "setMeasurementSystem">>;
     valueFormatted: import('vue').ComputedRef<{
         label: string;
     }>;