@roomle/embedding-lib 5.9.0-alpha.3 → 5.9.0-alpha.4

package/src/configurator/store/ui-state.d.ts

@@ -0,0 +1,80 @@
+import { Module } from 'vuex';
+import { SharedUiState, StoreState } from '../../common/store';
+import { INTERACTION_VIEW_TYPE, Nullable, Enumify } from '../../common/utils/types';
+import { ParameterGroup } from './core-data';
+import { KernelComponent, UiPossibleChild } from '@roomle/web-sdk/lib/definitions/typings/kernel';
+import { OverlaysOpenState } from '../../common/components/utils/-utils/overlays';
+import { UiInitData } from '../embedding/types';
+import { RapiTagForUi } from '@roomle/web-sdk/lib/definitions/typings/rapi-types';
+import { GridViewVariantElement } from '../components/grid-view/-utils/GridViewHelper';
+import { WallDimensionTransferable } from '@roomle/web-sdk/lib/definitions/planner-core/src/view-model/wall-plan-element-view-model';
+import { PlanObjectPosition } from '@roomle/web-sdk/lib/definitions/typings/planner';
+
+export type EnsurePrefix<T extends string> = Record<string, `${T}${string}`>;
+type UiStateIdentifier = EnsurePrefix<'UI_STATE_'>;
+export declare enum BUTTON_ACTIONS {
+    AR = 0,
+    PARTLIST = 1,
+    MULTISELECT = 2,
+    DIMENSIONS = 3,
+    FULLSCREEN = 4,
+    RESET_CAMERA = 5,
+    RENDER_IMAGE = 6,
+    ROTATE = 7,
+    SNAPPING = 8,
+    UNDO = 9,
+    REDO = 10,
+    PARTLIST_PLANNER = 11,
+    PRODUCTLIST = 12,
+    TWO_D_VIEW = 13,
+    ADD_ROOM = 14,
+    THREE_D_VIEW = 15,
+    SELECTED_PARTLIST_PLANNER = 16,
+    SWAP_PRODUCT = 17,
+    DUPLICATE_PRODUCT = 18,
+    ADD_MEASUREMENT_LINE = 19
+}
+export interface SceneSelection {
+    selectionMode: string;
+    hasChildren: boolean;
+    isRoot: boolean;
+    components: KernelComponent[];
+}
+export interface UiState extends SharedUiState {
+    selectedGroup: Nullable<ParameterGroup>;
+    overlays: OverlaysOpenState;
+    lastRegularViewMode: Nullable<boolean>;
+    onlyShowAddons: boolean;
+    activeAddon: Nullable<UiPossibleChild>;
+    currentSelection: Nullable<SceneSelection>;
+    initData: Nullable<UiInitData>;
+    isExpandedForConfigure: boolean;
+    isLoadingInProgress: boolean;
+    currentVariants: Nullable<RapiTagForUi>;
+    showVariants: boolean;
+    isViewer: boolean;
+    isConfigurator: boolean;
+    isPlanner: boolean;
+    email: Nullable<string>;
+    lastSelectedVariant: Nullable<GridViewVariantElement>;
+    undoEnabled: boolean;
+    redoEnabled: boolean;
+    undoEnabledPlanner: boolean;
+    userInitiatedSearch: boolean;
+    redoEnabledPlanner: boolean;
+    materialMultiSelect: boolean;
+    wallsDimensions: WallDimensionTransferable[];
+    objPosOnPlanner: PlanObjectPosition[];
+    initPlannerWithObjID: boolean;
+    isPlannerEditMode: boolean;
+    isShareLinkReady: boolean;
+    isInIframe: boolean;
+    firstTimeRoomView: boolean;
+    currentInteractionView: Enumify<typeof INTERACTION_VIEW_TYPE>;
+}
+export declare const UI_STATE_MUTATIONS: UiStateIdentifier;
+export declare const UI_STATE_ACTIONS: UiStateIdentifier;
+export declare const UI_STATE_GETTERS: UiStateIdentifier;
+export declare const initialState: UiState;
+export declare const uiState: Module<UiState, StoreState>;
+export {};

package/src/main.d.ts

@@ -0,0 +1,24 @@
+import { StoreState } from './common/store';
+import { Translator } from './common/composables/use-intl';
+import { Analytics } from './common/plugins/analytics';
+import { SdkConnector } from './configurator/business-logic/sdk-connector';
+import { ExposedCallbacks } from './configurator/embedding/exposed-callbacks';
+import { Libs } from './configurator/plugins/libs-plugin';
+import { default as UiActions } from './common/utils/ui-actions';
+import { Store } from 'vuex';
+import { default as ARService } from './common/utils/ar-service';
+import { LocalStorage } from './common/plugins/local-storage';
+
+declare module '@vue/runtime-core' {
+    interface ComponentCustomProperties {
+        $sdkConnector: SdkConnector;
+        $embeddingCallbacks: ExposedCallbacks;
+        $arService: ARService;
+        $store: Store<StoreState>;
+        $analytics: Analytics;
+        $libs: Libs;
+        intl: Translator;
+        $uiActions: UiActions;
+        $localStorage: LocalStorage;
+    }
+}

package/src/planner/business-logic/general-room-parameters.d.ts

@@ -0,0 +1,32 @@
+import { PlanInteractionHandler } from '@roomle/web-sdk/lib/definitions/typings/planner';
+
+export interface RangeValues {
+    ceilingHeight: number;
+    parapetHeight: number;
+    thickness: number;
+}
+export interface RangeValuesFormatted {
+    ceilingHeight: string;
+    parapetHeight: string;
+    thickness: string;
+}
+export declare const DEFAULT_MAX_RANGE: {
+    readonly ceilingHeight: 5000;
+    readonly parapetHeight: 2000;
+    readonly thickness: 600;
+};
+export declare const DEFAULT_MIN_RANGE: {
+    readonly ceilingHeight: 10;
+    readonly parapetHeight: 10;
+    readonly thickness: 10;
+};
+export declare const TABBED_NAV_MENU_CONSTRUCTION: {
+    key: "tabbed-nav-menu-construction";
+    label: string;
+};
+export declare const setDefaultWallHeight: (value: string, interactionHandler: PlanInteractionHandler) => void;
+export declare const setDefaultParapetHeight: (value: string, interactionHandler: PlanInteractionHandler) => void;
+export declare const setDefaultWallThickness: (value: string, interactionHandler: PlanInteractionHandler) => void;
+export declare const getDefaultWallHeight: (interactionHandler: PlanInteractionHandler) => number;
+export declare const getDefaultParapetHeight: (interactionHandler: PlanInteractionHandler) => number;
+export declare const getDefaultWallThickness: (interactionHandler: PlanInteractionHandler) => number;

package/src/planner/business-logic/pre-defined-rooms.d.ts

@@ -0,0 +1,4 @@
+import { GridViewElement } from '../../configurator/components/grid-view/-utils/GridViewHelper';
+import { SampleRoom } from './rooms';
+
+export declare const getPreDefinedRooms: (translate: (key: string) => string) => GridViewElement<SampleRoom>[];

package/src/planner/business-logic/rooms.d.ts

@@ -0,0 +1,62 @@
+import { CollectionViewElement, CollectionViewElementPossibleTypes } from '../../common/components/collection-view/-utils/types';
+import { default as PlanElementViewModel } from '@roomle/web-sdk/lib/definitions/common-core/src/view-model/plan-element-view-model';
+import { WallDefinition } from '@roomle/web-sdk/lib/definitions/planner-core/src/roomle-planner';
+import { PlanInteractionHandler, PlanOverview } from '@roomle/web-sdk/lib/definitions/typings/planner';
+import { PlannerUiState } from '../store/planner-ui-state';
+import { GridViewElement } from '../../configurator/components/grid-view/-utils/GridViewHelper';
+import { RapiMaterial } from '@roomle/web-sdk/lib/definitions/typings/rapi-types';
+import { SampleMaterial } from '../components/overlays/rooms/utils/ral-colors';
+
+export type RoomType = 'empty' | 'floor' | 'wall' | 'corner' | 'square' | 'L';
+export interface SampleRoom {
+    id: string;
+    roomSketch: string;
+    label: string;
+    type: RoomType;
+}
+export interface DrawControlTab {
+    id: string;
+    label: string;
+    desc: string;
+}
+export interface RoomRangeParametersTab {
+    id: string;
+    uiType: string;
+    heading: string;
+    minRange: string;
+    maxRange: string;
+    setValue: (value: string, interactionHandler: PlanInteractionHandler) => void;
+    getValue: (interactionHandler: PlanInteractionHandler) => string;
+}
+export interface WallRangeParametersTab {
+    id: string;
+    uiType: string;
+    heading: string;
+    minRange: string;
+    maxRange: string;
+    setValue: (value: string, interactionHandler: PlanInteractionHandler, state: PlannerUiState) => void;
+    getValue: (interactionHandler: PlanInteractionHandler, wall: PlanElementViewModel) => string;
+}
+export interface WallLengthScalingTab extends WallRangeParametersTab {
+    switchScalingDirection: (activeSwitch: number) => void;
+}
+export interface UnitSwitchTab {
+    id: string;
+    label: string;
+    switchUnit: (activeSwitch: number) => void;
+    firstOption: string;
+    secondOption: string;
+}
+export type MaterialsForObjects = RapiMaterial | SampleMaterial;
+export interface WallColorGroup {
+    id: string;
+    label: string;
+    materials: MaterialsForObjects[];
+    sort?: number;
+}
+export type SampleRoomsCollectionView = [
+    CollectionViewElement<GridViewElement<SampleRoom>[]>,
+    CollectionViewElement<DrawControlTab>
+];
+export type GeneralRoomParameterView = Array<CollectionViewElement<CollectionViewElementPossibleTypes>>;
+export declare const getRoomDefinition: (type: RoomType, planOverview: PlanOverview) => WallDefinition[];

package/src/planner/business-logic/sdk-connector-planner.d.ts

@@ -0,0 +1,67 @@
+import { Enumify, Nullable, PLAN_OBJECT_TYPES } from '../../common/utils/types';
+import { Store } from 'vuex';
+import { StoreState } from '../../common/store';
+import { Analytics } from '../../common/plugins/analytics';
+import { RoomleSdkWrapper } from '../../configurator/business-logic/roomle-sdk-wrapper';
+import { UiInitData } from '../../configurator/embedding/types';
+import { default as RoomlePlanner } from '@roomle/web-sdk/lib/definitions/planner-core/src/roomle-planner';
+import { PLAN_ELEMENT_CHANGE_TYPES, SelectionPayload } from '@roomle/web-sdk/lib/definitions/planner-core/src/roomle-planner-ui-callback';
+import { RapiId, RapiPlan, RapiPlanSnapshotGetData } from '@roomle/web-sdk/lib/definitions/typings/rapi-types';
+import { CancelSelectionReasons } from '@roomle/web-sdk/lib/definitions/typings/planner';
+import { Connector } from '../../common/business-logic/connector';
+import { default as PlanElementViewModel } from '@roomle/web-sdk/lib/definitions/common-core/src/view-model/plan-element-view-model';
+import { RuntimeId } from '@roomle/web-sdk/lib/definitions/typings/kernel';
+import { default as EventEmitter } from '../../common/business-logic/event-emitter';
+
+export declare const getConstructionWallAngle: (selectionElement: Nullable<PlanElementViewModel>) => Nullable<number>;
+export declare class SdkConnectorPlanner extends Connector {
+    private _planner;
+    private _initWaiters;
+    private _store;
+    private _sdkWrapper;
+    private _analytics;
+    private _eventEmitter;
+    private _lastPlanId;
+    private _currentPlan;
+    private _loadedLocalPlan;
+    private _initData;
+    constructor(store: Store<StoreState>, analytics?: Nullable<Analytics>, eventEmitter?: Nullable<EventEmitter>);
+    get api(): Promise<RoomlePlanner>;
+    init(sdkWrapper: RoomleSdkWrapper, element: HTMLElement, initData: UiInitData): Promise<void>;
+    initPlanner(planner: RoomlePlanner): Promise<void>;
+    loadPlan(id: RapiId): Promise<void>;
+    loadPlanBasedOnObjectId(id: RapiId): Promise<RuntimeId>;
+    getObjects(): Promise<import('@roomle/web-sdk/lib/definitions/typings/kernel').UiPlanObject[]>;
+    updateProductList(): Promise<void>;
+    onSelectionCancel(reason: CancelSelectionReasons): Promise<void>;
+    private _checkForVisibleDrawer;
+    saveCurrentPlan(): Promise<Nullable<RapiPlanSnapshotGetData | RapiPlan>>;
+    private _disableWallDrawingState;
+    private _enableWallDrawingState;
+    switch2D(): Promise<void>;
+    switch3D(): Promise<void>;
+    switchFp(): Promise<void>;
+    confirmRoom(switchTo2D: boolean): Promise<void>;
+    cancelSelection(): Promise<void>;
+    private _toggleFirstPersonControlsNotification;
+    private popSidebar;
+    onSelectionChange(_mode: string, objectType: Enumify<typeof PLAN_OBJECT_TYPES>, payload: SelectionPayload, payloadPromise: Promise<SelectionPayload>, planElementViewModel: PlanElementViewModel): void;
+    private _handleSelectedActions;
+    private _handleOpenFlyingMenu;
+    private _handleCloseFlyingMenu;
+    private _checkForLocallySavedPlan;
+    savePlanToIdb(): Promise<void>;
+    private _getKeyForIdb;
+    private _pruneLocallySavedPlans;
+    private _setViewNameState;
+    private _handleWallObjectType;
+    private _setSelectionParameters;
+    private _handleSelectionOnMobileMode;
+    private _handleSelectionOnDesktopMode;
+    private _updateInteractionOnPlanObjectChange;
+    private _setSidebarViewNameState;
+    preparePartListData(selectedItemPayload: SelectionPayload): Promise<void>;
+    private _getCurrentPlanXML;
+    onPlanElementChanged(changeType: Enumify<typeof PLAN_ELEMENT_CHANGE_TYPES>): Promise<void>;
+    private _emitConstructionAttachedWallAngle;
+}

package/src/planner/business-logic/selected-door-parameters.d.ts

@@ -0,0 +1,10 @@
+export declare const SELECTED_DOOR_MAX_RANGE: {
+    readonly doorHeight: 3000;
+    readonly doorLength: 5000;
+    readonly parapetHeight: 3000;
+};
+export declare const SELECTED_DOOR_MIN_RANGE: {
+    readonly doorHeight: 10;
+    readonly doorLength: 10;
+    readonly parapetHeight: 10;
+};

package/src/planner/business-logic/selected-wall-parameters.d.ts

@@ -0,0 +1,11 @@
+export declare const SELECTED_WALL_MAX_RANGE: {
+    wallHeight: number;
+    wallLength: number;
+    wallThickness: number;
+};
+export declare const SELECTED_WALL_MIN_RANGE: {
+    wallHeight: number;
+    wallLength: number;
+    wallThickness: number;
+};
+export type WallSide = 'left' | 'right';

package/src/planner/business-logic/selected-window-parameters.d.ts

@@ -0,0 +1,10 @@
+export declare const SELECTED_WINDOW_MAX_RANGE: {
+    readonly windowHeight: 3000;
+    readonly windowLength: 5000;
+    readonly parapetHeight: 3000;
+};
+export declare const SELECTED_WINDOW_MIN_RANGE: {
+    readonly windowHeight: 10;
+    readonly windowLength: 10;
+    readonly parapetHeight: 10;
+};

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

@@ -0,0 +1,27 @@
+import { PointCoords } from '../utils/rotation-calculation';
+
+declare const _default: __VLS_WithTemplateSlots<import('vue').DefineComponent<{
+    actionButton: number;
+    initPosition?: PointCoords;
+    selectedObjCenter?: PointCoords;
+    onInteraction: (_dragging: boolean) => void;
+}, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<{
+    actionButton: number;
+    initPosition?: PointCoords;
+    selectedObjCenter?: PointCoords;
+    onInteraction: (_dragging: boolean) => void;
+}> & Readonly<{}>, {
+    selectedObjCenter: PointCoords;
+    initPosition: PointCoords;
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, any>, {
+    default?(_: {
+        currentBtnPosition: PointCoords;
+        isDragging: boolean;
+    }): any;
+}>;
+export default _default;
+type __VLS_WithTemplateSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

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

@@ -0,0 +1,19 @@
+import { RapiTagForUi } from '@roomle/web-sdk/lib/definitions/typings/rapi-types';
+import { CollectionViewUiState } from '../../common/store/collection-view-state';
+
+declare const _default: import('vue').DefineComponent<{
+    objects: RapiTagForUi;
+    isExpanded?: boolean;
+    onExpand?: () => void;
+    onCollapse?: (_payload: MouseEvent) => void;
+    state: CollectionViewUiState;
+    isDesktop: boolean;
+}, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<{
+    objects: RapiTagForUi;
+    isExpanded?: boolean;
+    onExpand?: () => void;
+    onCollapse?: (_payload: MouseEvent) => void;
+    state: CollectionViewUiState;
+    isDesktop: boolean;
+}> & Readonly<{}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, any>;
+export default _default;

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

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

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

@@ -0,0 +1,15 @@
+import { ToggleCallback } from '../../common/utils/types';
+import { EventBus } from '../../common/business-logic/event-bus';
+
+declare const _default: import('vue').DefineComponent<{
+    onToggleExpand?: () => void;
+    isLoading?: boolean;
+    resetScroll: () => void;
+    icToggleEvent: EventBus<ToggleCallback>;
+}, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<{
+    onToggleExpand?: () => void;
+    isLoading?: boolean;
+    resetScroll: () => void;
+    icToggleEvent: EventBus<ToggleCallback>;
+}> & Readonly<{}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, any>;
+export default _default;

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

@@ -0,0 +1,14 @@
+import { PointCoords } from '../utils/rotation-calculation';
+
+declare const _default: import('vue').DefineComponent<{
+    selectedObjCenter: PointCoords;
+    currentBtnPosition: PointCoords;
+    isDragging: boolean;
+    onCalculateRotation: (_newValue: PointCoords, _currentBtnPosition: PointCoords, _isDragging: boolean) => void;
+}, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<{
+    selectedObjCenter: PointCoords;
+    currentBtnPosition: PointCoords;
+    isDragging: boolean;
+    onCalculateRotation: (_newValue: PointCoords, _currentBtnPosition: PointCoords, _isDragging: boolean) => void;
+}> & Readonly<{}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, any>;
+export default _default;

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

@@ -0,0 +1,6 @@
+declare const _default: import('vue').DefineComponent<{
+    showInteractions: boolean;
+}, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<{
+    showInteractions: boolean;
+}> & Readonly<{}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, any>;
+export default _default;

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

@@ -0,0 +1,69 @@
+import { PointCoords } from '../utils/rotation-calculation';
+
+declare const _default: __VLS_WithTemplateSlots<import('vue').DefineComponent<import('vue').ExtractPropTypes<__VLS_WithDefaults<__VLS_TypePropsToOption<{
+    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<{
+    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<{}>, {
+    progress: number;
+    stroke: number;
+    selectedObjCenter: PointCoords;
+    radius: number;
+    snapDegrees: number;
+    rotationDegrees: number;
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, any>, {
+    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/StartPlannerButton.vue.d.ts

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

package/src/planner/components/catalog/CatalogTrigger.vue.d.ts

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

package/src/planner/components/measurements/MeasurementDisplayComponent.vue.d.ts

@@ -0,0 +1,48 @@
+import { ObjectToWallDimensionTransferable, ObjectWallDimension } from '@roomle/web-sdk/lib/definitions/common-core/src/view-model/plan-object-view-model';
+import { ConstructionMeasurementsTransferable } from '@roomle/web-sdk/lib/definitions/planner-core/src/utils/measurements';
+import { MeasurementLineDimensionTransferable } from '@roomle/web-sdk/lib/definitions/planner-core/src/view-model/measurement-line-plan-element-view-model';
+import { WallDimensionTransferable } from '@roomle/web-sdk/lib/definitions/planner-core/src/view-model/wall-plan-element-view-model';
+import { Nullable } from '@roomle/web-sdk/lib/definitions/typings/helper';
+
+type MeasurementType = Nullable<ConstructionMeasurementsTransferable> | Nullable<MeasurementLineDimensionTransferable[]> | Nullable<WallDimensionTransferable[]> | Nullable<ObjectToWallDimensionTransferable[]> | ObjectWallDimension;
+declare const _default: __VLS_WithTemplateSlots<import('vue').DefineComponent<{
+    measurements: MeasurementType;
+    styleFactor: number;
+    isBold?: boolean;
+    boldFactor?: number;
+    hasLine?: boolean;
+    hasBubble?: boolean;
+    opaqueBubble?: boolean;
+    isLineBoundBox?: boolean;
+}, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<{
+    measurements: MeasurementType;
+    styleFactor: number;
+    isBold?: boolean;
+    boldFactor?: number;
+    hasLine?: boolean;
+    hasBubble?: boolean;
+    opaqueBubble?: boolean;
+    isLineBoundBox?: boolean;
+}> & Readonly<{}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, any>, Readonly<{
+    default(_props: {
+        measurement: WallDimensionTransferable;
+        isVisible: boolean;
+    }): void;
+    measurementIcons(_props: {
+        measurement: WallDimensionTransferable;
+    }): void;
+}> & {
+    default(_props: {
+        measurement: WallDimensionTransferable;
+        isVisible: boolean;
+    }): void;
+    measurementIcons(_props: {
+        measurement: WallDimensionTransferable;
+    }): void;
+}>;
+export default _default;
+type __VLS_WithTemplateSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/src/planner/components/measurements/ShowConstructionMeasurements.vue.d.ts

@@ -0,0 +1,8 @@
+import { ConstructionMeasurementsTransferable } from '@roomle/web-sdk/lib/definitions/planner-core/src/utils/measurements';
+
+declare const _default: import('vue').DefineComponent<{
+    constructionElementMeasurements: ConstructionMeasurementsTransferable;
+}, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<{
+    constructionElementMeasurements: ConstructionMeasurementsTransferable;
+}> & Readonly<{}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, any>;
+export default _default;

package/src/planner/components/measurements/ShowFloorsAreasData.vue.d.ts

@@ -0,0 +1,8 @@
+import { FloorAreaDataTransferable } from '@roomle/web-sdk/lib/definitions/planner-core/src/view-model/floor-plan-element-view-model';
+
+declare const _default: import('vue').DefineComponent<{
+    floorsAreas: FloorAreaDataTransferable[];
+}, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<{
+    floorsAreas: FloorAreaDataTransferable[];
+}> & Readonly<{}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, any>;
+export default _default;

package/src/planner/components/measurements/ShowMeasurementLineDimension.vue.d.ts

@@ -0,0 +1,8 @@
+import { MeasurementLineDimensionTransferable } from '@roomle/web-sdk/lib/definitions/planner-core/src/view-model/measurement-line-plan-element-view-model';
+
+declare const _default: import('vue').DefineComponent<{
+    measurementLineDimensions: MeasurementLineDimensionTransferable[];
+}, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<{
+    measurementLineDimensions: MeasurementLineDimensionTransferable[];
+}> & Readonly<{}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, any>;
+export default _default;

package/src/planner/components/measurements/ShowObjectMeasurements.vue.d.ts

@@ -0,0 +1,10 @@
+import { ObjectMeasurementsTransferable } from '@roomle/web-sdk/lib/definitions/common-core/src/view-model/plan-object-view-model';
+
+declare const _default: import('vue').DefineComponent<{
+    elementMeasurements: ObjectMeasurementsTransferable;
+    selectedPlanElementId: number;
+}, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<{
+    elementMeasurements: ObjectMeasurementsTransferable;
+    selectedPlanElementId: number;
+}> & Readonly<{}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, any>;
+export default _default;

package/src/planner/components/measurements/ShowWallMeasurements.vue.d.ts

@@ -0,0 +1,8 @@
+import { WallDimensionTransferable } from '@roomle/web-sdk/lib/definitions/planner-core/src/view-model/wall-plan-element-view-model';
+
+declare const _default: import('vue').DefineComponent<{
+    getWallsMeasurements: WallDimensionTransferable[];
+}, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<{
+    getWallsMeasurements: WallDimensionTransferable[];
+}> & Readonly<{}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, any>;
+export default _default;

package/src/planner/components/measurements/utils/IndicatorArrow.vue.d.ts

@@ -0,0 +1,14 @@
+declare const _default: import('vue').DefineComponent<import('vue').ExtractPropTypes<{
+    direction: {
+        type: StringConstructor;
+        required: true;
+        validator: (value: string) => boolean;
+    };
+}>, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<{
+    direction: {
+        type: StringConstructor;
+        required: true;
+        validator: (value: string) => boolean;
+    };
+}>> & Readonly<{}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;
+export default _default;

package/src/planner/components/measurements/utils/IndicatorLine.vue.d.ts

@@ -0,0 +1,21 @@
+declare const _default: import('vue').DefineComponent<import('vue').ExtractPropTypes<{
+    side: {
+        type: StringConstructor;
+        required: true;
+        validator: (value: string) => boolean;
+    };
+    hasLine: BooleanConstructor;
+    isBold: BooleanConstructor;
+}>, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<{
+    side: {
+        type: StringConstructor;
+        required: true;
+        validator: (value: string) => boolean;
+    };
+    hasLine: BooleanConstructor;
+    isBold: BooleanConstructor;
+}>> & Readonly<{}>, {
+    hasLine: boolean;
+    isBold: boolean;
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;
+export default _default;

package/src/planner/components/measurements/utils/MeasurementText.vue.d.ts

@@ -0,0 +1,19 @@
+declare const _default: __VLS_WithTemplateSlots<import('vue').DefineComponent<import('vue').ExtractPropTypes<{
+    measurement: ObjectConstructor;
+    opaque: BooleanConstructor;
+    textStyle: ObjectConstructor;
+}>, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<{
+    measurement: ObjectConstructor;
+    opaque: BooleanConstructor;
+    textStyle: ObjectConstructor;
+}>> & Readonly<{}>, {
+    opaque: boolean;
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, any>, {
+    default?(_: {}): any;
+}>;
+export default _default;
+type __VLS_WithTemplateSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};