@roomle/embedding-lib 5.25.0-alpha.6 → 5.25.0-alpha.8

package/docs/md/web/embedding/CHANGELOG.md

@@ -1,6 +1,6 @@
-## [5.25.0-alpha.6](https://github.com/roomle-dev/roomle-ui/compare/embedding-lib-v5.25.0-alpha.5...embedding-lib-v5.25.0-alpha.6) (2025-08-06)
+## [5.25.0-alpha.8](https://github.com/roomle-dev/roomle-ui/compare/embedding-lib-v5.25.0-alpha.7...embedding-lib-v5.25.0-alpha.8) (2025-08-07)
 
 
 ### Bug Fixes
 
-* more tests passing under vite ([705ade6](https://github.com/roomle-dev/roomle-ui/commit/705ade69485bc15410345109f2b265c39bd4ab97))
+* make material transition async again ([533feff](https://github.com/roomle-dev/roomle-ui/commit/533feff2f59ba75533c9be9b4a548e78940cb226))

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@roomle/embedding-lib",
-  "version": "5.25.0-alpha.6",
+  "version": "5.25.0-alpha.8",
   "description": "This is a small library which can be used to communicate with the Roomle Configurator",
   "type": "module",
   "main": "./roomle-embedding-lib.umd.js",

package/packages/embedding-lib/src/examples/homag-intelligence-example.d.ts

@@ -0,0 +1,9 @@
+import { Example } from '../example';
+
+export default class DragInExample implements Example {
+    private _abortController;
+    setupHtml(parent: HTMLElement): Promise<void>;
+    closeExample(): Promise<void>;
+    private start;
+    runExample(): Promise<void>;
+}

package/packages/embedding-lib/src/examples/utils/homag-intelligence/create-catalog.d.ts

@@ -0,0 +1 @@
+export declare const createCatalog: (articleCatalog: HTMLElement, draggable?: boolean) => Promise<void>;

package/packages/embedding-lib/src/examples/utils/homag-intelligence/default-api-options.d.ts

@@ -0,0 +1,43 @@
+declare const _default: {
+    enableArrangementCorrection: boolean;
+    uiConfiguration: {
+        userRight: string;
+        materialAttributes: string[];
+        attributesVisibleInPlanner: string[];
+        attributeGroupsVisibleInPlanner: any[];
+        showPossibleSubModules: boolean;
+        animatedOpenClose: boolean;
+        showThumbnails: boolean;
+    };
+    materialConfiguration: {
+        defaultMaterial: string;
+        replaceUnmappedMaterialsWithDefault: boolean;
+        materialMapping: {
+            materialName: string;
+            materialId: string;
+        }[];
+    };
+    debugConfiguration: {
+        createDebugGeometry: boolean;
+    };
+    tecConfigInfo: {
+        baseUrlDebug: string;
+        /**
+         * If you do not want to use the proxy provided by Roomle
+         * uncomment the next three lines and comment the line
+         * which has the Roomle proxy URL in it.
+         * BE AWARE: That the example url dfteccdeveu01-app.azurewebsites.net
+         * only works if you requesting from localhost:3100 otherwise you
+         * will have CORS issues
+         */
+        /** comment this line if you do not want to use the Roomle proxy  */
+        baseUrl: string;
+        om: {
+            subscriptionId: string;
+            key: string;
+            importBaseUrl: string;
+        };
+        libraryId: string;
+    };
+};
+export default _default;

package/packages/embedding-lib/src/examples/utils/homag-intelligence/dom-helper.d.ts

@@ -0,0 +1,13 @@
+import { RoomDesignerApiType } from './overlay';
+
+export declare const GROUP_SELECTION_STR = "Group selection";
+export declare const getOverlayDomElement: () => HTMLElement;
+export declare const positionOverlay: (roomDesignerApi: RoomDesignerApiType) => Promise<void>;
+export declare const showOverlay: () => void;
+export declare const hideOverlay: () => void;
+export declare const addShadow: (roomDesignerApi: RoomDesignerApiType) => Promise<void>;
+export declare const removeShadow: () => void;
+export declare const currentSelectionType: (selectionPayload: any) => "Group selection" | "Unknown selection type" | "Root module selection" | "Sub module selection";
+export declare const showItemSelectionWarning: (roomDesignerApi: RoomDesignerApiType) => Promise<void>;
+export declare const showCustomItemSelectionView: (state: any, roomDesignerApi: RoomDesignerApiType) => Promise<void>;
+export declare const showCustomCatalogView: (roomDesignerApi: RoomDesignerApiType) => Promise<void>;

package/packages/embedding-lib/src/examples/utils/homag-intelligence/drag-in.d.ts

@@ -0,0 +1,3 @@
+import { RoomDesignerApiType } from './overlay';
+
+export declare const addDragEventListeners: (roomDesignerApi: RoomDesignerApiType, catalogElements: NodeListOf<Element> | Element[], signal: AbortSignal, element?: HTMLElement | null) => void;

package/packages/embedding-lib/src/examples/utils/homag-intelligence/overlay.d.ts

@@ -0,0 +1,2 @@
+export type RoomDesignerApiType = any;
+export declare const initOverlayLogic: (roomDesignerApi: RoomDesignerApiType, posMode: boolean) => Promise<void>;

package/packages/embedding-lib/src/examples/utils/homag-intelligence/state.d.ts

@@ -0,0 +1,14 @@
+export declare const state: {
+    selection: {
+        type: any;
+        payload: any;
+        parameters: any[];
+    };
+    currentContext: string;
+    currentCustomView: any;
+    currentSidebar: any;
+    abortController: AbortController;
+    isBuildingCatalog: any;
+    waitForCatalog: () => Promise<void>;
+};
+export declare const resetSelectionState: () => void;

package/packages/embedding-lib/src/examples/utils/homag-intelligence/util.d.ts

@@ -0,0 +1,19 @@
+export declare const fetchJSONData: (url: string) => Promise<any>;
+export declare const fetchDataWithAuthorization: (url: string, type: string, property: string) => Promise<Response>;
+export declare const logMessage: (message: string, ...args: (string | null)[]) => void;
+export declare const logApiCall: (message: string) => void;
+export declare const logApiCallback: (message: string, ...args: (string | null)[]) => void;
+export declare const logLink: (message: string, linkUrl: string) => void;
+export declare class RenderQueue {
+    reRenders: number;
+    queue: Array<{
+        renderFn: any;
+        resolve: any;
+        reject: any;
+    }>;
+    isProcessing: boolean;
+    constructor();
+    enqueue(renderFn: any): Promise<unknown>;
+    processQueue(): Promise<void>;
+}
+export declare const getQueryParam: (key: string, url?: string) => string;

package/packages/web-sdk/packages/common-core/src/main.d.ts

@@ -86,7 +86,7 @@ export default abstract class Main implements LifeCycleCallbacks {
     protected abstract setupDependencies(): void;
     protected abstract cleanUpGlobals(): void;
     protected abstract cleanUpDependencies(): void;
-    protected abstract bootFinished(): void;
+    protected abstract bootFinished(): Promise<void>;
     protected abstract getContextName(): string;
     abstract getApi(): ExternalEmbeddable;
     constructor(creator?: string);
@@ -94,7 +94,7 @@ export default abstract class Main implements LifeCycleCallbacks {
     private _setupCommonDependencies;
     private _cleanUpCommonGlobals;
     private _cleanUpCommonDependencies;
-    boot(settings?: object): void;
+    boot(settings?: object): Promise<void>;
     protected lookup<T>(specifier: string, context?: string): T;
     teardown(): void;
     pause(): void;

package/packages/web-sdk/packages/common-core/src/utils/init-data.d.ts

@@ -9,6 +9,7 @@ import { CustomShadingParameters, SceneShadingType } from '../webgl/renderer/sha
 import { RapiId } from '../../../typings/rapi-types';
 import { CanvasOffset } from '../common-interfaces';
 import { ExternalObjectApiConfiguration } from '../../../planner-core/src/external-object-api';
+import { HomagIntelligenceInitData } from '../../../homag-intelligence/src/loader';
 
 export declare const DEFAULT_ENV_MAP_INTENSITY = 1.5;
 export declare const DEFAULT_ENV_MAP_ROTATION = 0;
@@ -49,6 +50,7 @@ export default class InitData implements Context, Omit<InitDataDefinition, 'colo
     customShading?: CustomShadingParameters;
     customShadingMoc?: CustomShadingParameters;
     restrictionLevel?: number;
+    hi?: HomagIntelligenceInitData;
     offlineSync?: string;
     highlighting?: Enumify<typeof ROOMLE_HIGHLIGHTNG>;
     initialFloorMaterial?: string;

package/packages/web-sdk/packages/common-core/src/utils/shims.d.ts

@@ -6,6 +6,7 @@ import { Enumify } from '../types';
 import { DefaultEnvironmentSceneType } from '../webgl/renderer/environment-scene';
 import { CustomShadingParameters, SceneShadingType } from '../webgl/renderer/shading-settings';
 import { Color } from 'three';
+import { HomagIntelligenceInitData } from '../../../homag-intelligence/src/loader';
 
 export declare const enum WINDOW_EVENT {
     RESIZE = "resize",
@@ -315,6 +316,11 @@ export interface CommonInitData {
      * @description restrictionLevel defines visibility of parameters and possible children
      */
     restrictionLevel?: number;
+    /**
+     * @description Settings for Homag Intelligence
+     * @internal
+     */
+    hi?: HomagIntelligenceInitData;
 }
 export interface ConfiguratorInitData {
     /**

package/packages/web-sdk/packages/configurator-core/src/configurator.d.ts

@@ -9,6 +9,6 @@ export declare class Configurator extends Main {
     protected cleanUpDependencies(): void;
     protected setupGlobals(appState?: AppState): void;
     getApi(): RoomleConfigurator;
-    protected bootFinished(): void;
+    protected bootFinished(): Promise<void>;
     protected getContextName(): string;
 }

package/packages/web-sdk/packages/configurator-core/src/utils/component-raycast-helper.d.ts

@@ -12,7 +12,7 @@ export default class ComponentRaycastHelper {
     init(object: Object3D, camera: PerspectiveCamera): void;
     setCamera(camera: PerspectiveCamera): void;
     setObject(object: Object3D): void;
-    changeMaterialsOnSelect(object: Object3D, component: RoomleComponent, selected?: boolean, callback?: () => void): Promise<void>;
+    changeMaterialsOnSelect(object: Object3D, component: RoomleComponent, selected?: boolean, callback?: () => void): void;
     private _changeMaterialsOnSelect;
     isComponentVisible(component: RoomleComponent): boolean;
     checkComponentAndPreviewVisibility(sceneEventHandler: ConfiguratorSceneEventHandler, configuratorViewModel: ConfiguratorViewModel): void;

package/packages/web-sdk/packages/glb-viewer-core/src/glb-viewer.d.ts

@@ -7,7 +7,7 @@ export declare class GlbViewer extends Main {
     protected setupDependencies(): void;
     protected cleanUpGlobals(): void;
     protected cleanUpDependencies(): void;
-    protected bootFinished(): void;
+    protected bootFinished(): Promise<void>;
     getApi(): RoomleGLBViewer;
     protected getContextName(): string;
 }

package/packages/web-sdk/packages/homag-intelligence/src/api.d.ts

@@ -0,0 +1,22 @@
+import { RoomDesignerRequests } from './emulator';
+import { MasterData, PosGroup } from './model/oc-scripts-domain.model';
+import { RoomlePlannerType } from '../../typings/external-objects';
+
+export declare class RoomDesignerApi implements RoomDesignerRequests {
+    private _roomlePlanner;
+    constructor(roomlePlanner: RoomlePlannerType);
+    loadMasterData(masterData: MasterData): void;
+    loadPosGroups(posDataJson: PosGroup | PosGroup[], findFreeSpaceInPlan: boolean, verifyArrangement: boolean, mergedGroups?: string[]): Promise<void>;
+    selectGroup(groupId: string): Promise<void>;
+    selectRoot(rootModuleId: string): Promise<void>;
+    selectModule(rootModuleId: string, subModuleId: string): Promise<void>;
+    openCloseGroup(groupOrRootModuleId: string, subModuleId: string | null, open: boolean, animate: boolean): Promise<void>;
+    deleteGroup(groupId: string, wasMerged?: boolean): Promise<void>;
+    deleteRootModule(rootModuleId: string): Promise<void>;
+    getPosDataOfAllGroups(): Promise<PosGroup[]>;
+    generatePlanSnapshot(): Promise<void>;
+    saveExternalObjectSnapshot(): Promise<import('../../typings/rapi-types').RapiPlanSnapshotGetDataWith3dUrls>;
+    saveCurrentPlanSnapshot(): Promise<import('../../typings/rapi-types').RapiPlanSnapshotGetData>;
+    renderPosDataImage(posDataJson: object): Promise<void>;
+    downloadGlb(): Promise<void>;
+}

package/packages/web-sdk/packages/homag-intelligence/src/callbacks.d.ts

@@ -0,0 +1,37 @@
+import { GlueLogic } from './emulator';
+import { default as RoomlePlanner } from '../../planner-core/src/roomle-planner';
+
+export interface ExternalObjectSegment {
+    cmd: string;
+    x: number;
+    y: number;
+    type?: string;
+    angle?: number;
+}
+export interface ExternalObjectContour {
+    level: number;
+    segments: ExternalObjectSegment[];
+}
+export interface ExternalObjectGroupPosition {
+    pos: number[];
+    rotationY?: number;
+    contours?: ExternalObjectContour[];
+}
+export interface ExternalObjectRootModule {
+    moduleId: string;
+    pos: number[];
+    rotationY?: number;
+}
+export interface ExternalObjectGroup {
+    groupId: string;
+    pos: number[];
+    rotationY?: number;
+    rootModules: ExternalObjectRootModule[];
+    contours?: ExternalObjectContour[];
+}
+export interface ExternalModuleInformation {
+    groupId: string;
+    rootModuleId: string;
+    subModuleId: string | null;
+}
+export declare const initCallbacks: (roomlePlanner: RoomlePlanner, gluLogic: GlueLogic) => void;

package/packages/web-sdk/packages/homag-intelligence/src/emulator.d.ts

@@ -0,0 +1,101 @@
+import { ExternalModuleInformation, ExternalObjectGroup, ExternalObjectGroupPosition } from './callbacks';
+import { MasterData, PosModuleAttribute, PosGroup, PosModuleData, PosModuleRootData } from './model/oc-scripts-domain.model';
+
+export interface LibraryData {
+    get masterData(): MasterData | null;
+    get posGroupVersion(): number;
+    calculateGroup(posGroup: PosGroup): PosGroup;
+    getOrderData(posGroup: PosGroup[], roomlePlannerId?: string): PosGroup;
+    getAttributesDropDownValues(module: PosModuleRootData): Promise<any>;
+    solveModuleAttributeConflict(module: PosModuleData, attributeName: string, value: string | number | boolean): PosModuleAttribute[] | undefined;
+}
+export interface RoomDesignerRequests {
+    loadMasterData(masterData: MasterData): void;
+    loadPosGroups(posDataJson: PosGroup | PosGroup[], findFreeSpaceInPlan: boolean, verifyArrangement: boolean, mergedGroups?: string[]): Promise<void>;
+    selectGroup(groupId: string): Promise<void>;
+    selectRoot(rootModuleId: string): Promise<void>;
+    selectModule(rootModuleId: string, subModuleId: string): Promise<void>;
+    openCloseGroup(groupOrRootModuleId: string, subModuleId: string | null, open: boolean, animate: boolean): Promise<void>;
+    deleteGroup(groupId: string, wasMerged?: boolean): Promise<void>;
+    deleteRootModule(rootModuleId: string): Promise<void>;
+    getPosDataOfAllGroups(): Promise<PosGroup[]>;
+    generatePlanSnapshot(): Promise<void>;
+    saveExternalObjectSnapshot(): Promise<any>;
+    saveCurrentPlanSnapshot(): Promise<any>;
+}
+export interface GlueLogic {
+    mergeGroups(targetGroup: ExternalObjectGroup, idsOfGroupsMerged: string | string[], idOfTargetRootModule: string): void;
+    deleteRootModule(remainingGroup: ExternalObjectGroup, rootModuleIdToDelete: string, splitOffGroups: ExternalObjectGroup[]): void;
+    splitRootModuleFromGroup(splitGroup: ExternalObjectGroup, newGroupedRootModules: ExternalObjectGroup[]): void;
+    duplicateGroup(sourceGroupId: string, newGroupPosition: ExternalObjectGroupPosition): void;
+    modifyAttribute(groupId: string, moduleIdObjects: ExternalModuleInformation[], attributeName: string, value: string): void;
+    arrangeRootModulesOfGroup(changedGroup: ExternalObjectGroup): void;
+    changedGroupPlanningSituation(changedGroup: ExternalObjectGroup): void;
+    deleteGroup(groupId: string): Promise<void>;
+    changedGroup(posDataJson: PosGroup): void;
+    loadedGroup(posDataJson: PosGroup): void;
+    removedGroup(groupId: string): void;
+    openCloseGroup(groupId: string): void;
+    getGroupDataForOrder(roomlePlannerId?: string): Promise<any>;
+    savePlanSnapshot(): Promise<PlanSnapshot>;
+}
+interface PlanSnapshot {
+    id: string;
+    perspectiveImageLink: string;
+    topImageLink: string;
+    room3dLink: string;
+    room3dFullLink: string;
+}
+interface GroupItem {
+    posDataJson: PosGroup;
+    opened: boolean;
+}
+export declare class Emulator implements GlueLogic {
+    _designerRequests: RoomDesignerRequests;
+    _libraryData: LibraryData;
+    _posDataJsonMap: Map<string, any>;
+    _groupMap: Map<string, GroupItem>;
+    _nextPosDataId: number;
+    constructor(designerRequests: RoomDesignerRequests, libraryData: LibraryData);
+    loadPosData(articleCatalogJson: any, libraryId: string): void;
+    newPosDataFromId(id: string): any;
+    deleteGroup(groupId: string): Promise<void>;
+    selectGroup(groupId: string): Promise<void>;
+    selectCheckAttributes(root: PosModuleRootData): Promise<void>;
+    selectRoot(_groupId: any, rootId: string): Promise<void>;
+    deleteRoot(groupId: any, rootId: string): Promise<void>;
+    selectSubModule(groupId: any, rootId: string, moduleId: string): Promise<void>;
+    openCloseGroup(groupId: string): Promise<void>;
+    deleteRootModule(remainingGroup: ExternalObjectGroup, rootModuleIdToDelete: string, splitOffGroups: ExternalObjectGroup[]): void;
+    duplicateGroup(sourceGroupId: string, newGroupPosition: ExternalObjectGroupPosition): Promise<void>;
+    mergeGroups(targetGroup: ExternalObjectGroup, idsOfGroupsMerged: string | string[], idOfTargetRootModule: string): void;
+    private _applyImplicitRelevantAttributes;
+    splitRootModuleFromGroup(splitGroup: ExternalObjectGroup, newGroupedRootModules: ExternalObjectGroup[]): void;
+    arrangeRootModulesOfGroup(changedGroup: ExternalObjectGroup): void;
+    removedGroup(groupId: string): void;
+    changedGroup(posDataJson: PosGroup): void;
+    changedGroupPlanningSituation(changedGroup: ExternalObjectGroup): void;
+    loadedGroup(posDataJson: PosGroup): void;
+    getGroupDataForOrder(roomlePlannerId?: string): Promise<PosGroup>;
+    private _setGroupContour;
+    private _setGroupPosition;
+    private _setRootModulesPosition;
+    private _loadPosData;
+    private _splitOffGroupsFromGroups;
+    private _splitOffRootModulesFromGroup;
+    private _calculateNewGroup;
+    private _calculate;
+    private _calculateAndUpdateGroupMap;
+    private _addNewGroup;
+    private _addGroupToMap;
+    updateAttribute(rootModuleId: string | undefined, moduleId: string, attributeId: string, attributeValue: string | boolean): Promise<void>;
+    modifyAttribute(groupId: string, moduleIdObjects: ExternalModuleInformation[], attributeName: string, value: string): void;
+    _modifyAttributeOfModules(emulatorGroupItem: GroupItem, moduleIds: string[] | string, attributeName: string, value: string | boolean): PosGroup;
+    private _setAttribute;
+    savePlanSnapshot(): Promise<PlanSnapshot>;
+    private _findModule;
+    private _replacesIDs;
+    private _replacesModuleIDs;
+    private _getNextID;
+}
+export {};

package/packages/web-sdk/packages/homag-intelligence/src/homag-intelligence.d.ts

@@ -0,0 +1,28 @@
+import { RmlPlugin } from './rml-plugin';
+import { Emulator } from './emulator';
+import { ApiOptions } from './loader';
+import { MasterData } from './model/oc-scripts-domain.model';
+import { default as RoomlePlanner } from '../../planner-core/src/roomle-planner';
+
+export declare const HOMAG_INTELLIGENCE_ENDPOINT = "https://europe-west3-rml-showcases.cloudfunctions.net/proxy_request?url=";
+export declare class HomagIntelligence extends RmlPlugin {
+    private _roomlePlanner;
+    private _api;
+    private _masterData;
+    private _emulator;
+    private _articles;
+    private _scriptLoaded;
+    private _hiLibraryLoaded;
+    private _orders;
+    constructor();
+    loadHiLibrary(libraryId: string, apiOptions: ApiOptions): Promise<{
+        articles: any;
+        masterData: MasterData;
+        calcScriptLoaded: boolean;
+    }>;
+    init(roomlePlanner: RoomlePlanner, libraryId: string, apiOptions: ApiOptions): Promise<this>;
+    private _loadMasterData;
+    getEmulator(): Emulator;
+    sendToOM(withPrice?: boolean): Promise<void>;
+    fetchPrice(planId?: string): Promise<any>;
+}

package/packages/web-sdk/packages/homag-intelligence/src/loader.d.ts

@@ -0,0 +1,24 @@
+import { MasterData } from './model/oc-scripts-domain.model';
+
+export interface HomagIntelligenceInitData {
+    libraryId: string;
+    serverOptions: ApiOptions;
+}
+export interface OrderManagerOptions {
+    key?: string;
+    importBaseUrl?: string;
+}
+export interface ApiOptions {
+    subscriptionId: string;
+    om?: OrderManagerOptions;
+    endpointUrl?: string;
+    localUrl?: string;
+}
+export declare const fetchDataWithAuthorization: (url: string, type: 'json' | 'text', apiOptions: ApiOptions, debug?: {
+    property: string;
+}) => Promise<Response>;
+export declare const loadHiLibrary: (libraryId: string, apiOptions: ApiOptions) => Promise<{
+    articles: any;
+    masterData: MasterData;
+    calcScriptLoaded: boolean;
+}>;

package/packages/web-sdk/packages/homag-intelligence/src/model/oc-scripts-domain.model.d.ts

@@ -0,0 +1,312 @@
+export declare const enum PosUserRight {
+    Simple = "Simple",
+    Advanced = "Advanced",
+    Master = "Master"
+}
+export declare const enum UserRightLevel {
+    Simple = 0,
+    Advanced = 1,
+    Master = 2
+}
+export declare const getUserRightLevel: (right?: PosUserRight | null) => UserRightLevel;
+export interface PosArticleInfo {
+    /**
+     * Defined the library that is used / must match the MasterData
+     */
+    libraryId: string;
+    /**
+     * Defined the library that is used / must match the MasterData
+     */
+    catalog: string;
+    /**
+     * The id of the initial article
+     */
+    articleId: string;
+    /**
+     * The name of the initial article
+     */
+    articleName?: string;
+    desc?: string;
+    imageUrl?: string;
+    category?: string;
+}
+export interface PosPartData {
+    id: string;
+    hidden?: boolean;
+    relPos: number[];
+    dim: number[];
+    fullMatrix: number[];
+    openfullMatrix?: number[];
+    name: string;
+    material?: PosFaceMaterial[] | string;
+    extrude?: PosPartExtrudeInfo;
+    model?: PosPartModelInfo;
+    hideModelWhenOpen?: boolean;
+    modelOpen?: PosPartModelInfo;
+}
+export interface PosPartExtrudeInfo {
+    svg: string;
+    direction: string;
+}
+export interface PosFaceMaterial {
+    materialId: string;
+    faceKey?: PosFaceKey;
+    uvRotation?: number;
+    uvOffset?: number[];
+    uvScale?: number[];
+}
+export declare enum PosFaceKey {
+    Default = "default",
+    Bottom = "bottom",
+    Top = "top",
+    Left = "left",
+    Right = "right",
+    Front = "front",
+    Back = "back",
+    Side = "side"
+}
+export interface PosPartModelInfo {
+    url: string;
+    params?: string;
+}
+export interface PosModuleAttribute {
+    id: string;
+    value?: number | string | boolean;
+    isInput?: boolean;
+}
+export interface PosModuleData {
+    id: string;
+    name: string;
+    modules?: PosModuleData[];
+    parts?: PosPartData[];
+    imageUrl?: string;
+    attributes?: PosModuleAttribute[];
+    canBeDeleted?: boolean;
+    isGenerated?: boolean;
+    checkAttributes?: Map<string, string | number | boolean | undefined>;
+}
+export interface PosModuleRootData extends PosModuleData, PosArticleInfo {
+    /**
+     * Additional text for this root module
+     */
+    additionalText?: string;
+    /**
+     * Position of this article; if not set it is always 0,0,0 (x/y/z)
+     */
+    articlePos?: number[];
+    /**
+     * Rotation on the vertical axis in degree (0-359)
+     */
+    rotationY?: number;
+    logMessages: PosErrorMsg[];
+    dockInfos: PosDockInfo[];
+    insertLevelInfos?: PosInsertLevelInfo[];
+    insertLevelFixed?: boolean;
+}
+export interface PosInsertLevelInfo {
+    height: number;
+    isDefault?: boolean;
+}
+export interface PosDockInfo {
+    id: PosDock;
+    start: number[];
+    end: number[];
+}
+export declare const enum PosDock {
+    RightTop = "RightTop",
+    BackTop = "BackTop",
+    LeftTop = "LeftTop",
+    RightBottom = "RightBottom",
+    BackBottom = "BackBottom",
+    LeftBottom = "LeftBottom",
+    LeftBackTop = "LeftBackTop",
+    RightBackTop = "RightBackTop",
+    LeftBackBottom = "LeftBackBottom",
+    RightBackBottom = "RightBackBottom"
+}
+export interface PosErrorMsg {
+    category: LogMessageCategoryType;
+    msg: string;
+    seqNo: number;
+    timestamp: string;
+    scope?: LogMessageScope;
+}
+export interface LogMessageScope {
+    moduleUniqueId?: string;
+    attrId?: string;
+}
+export declare const enum LogMessageCategoryType {
+    Fatal = "Fatal",
+    Error = "Error",
+    Warning = "Warning",
+    Info = "Info",
+    Debug = "Debug"
+}
+export interface PosContourSegment {
+    cmd: string;
+    x: number;
+    y: number;
+    angle: number;
+    type?: string;
+}
+export interface PosContour {
+    level: number;
+    segments: PosContourSegment[];
+}
+export interface PosGroup {
+    /**
+     * The unique id of the Group
+     */
+    id: string;
+    /**
+     * One or multiple roots for this article group
+     */
+    roots: PosModuleRootData[];
+    /**
+     * Global (error) messages
+     */
+    logMessages: PosErrorMsg[];
+    /**
+     * Position/Orientation inside the room
+     */
+    /**
+     * Optional a position of this group
+     */
+    pos?: number[];
+    /**
+     * The rotation on the vertical axis in degree (0-360)
+     */
+    rotationY?: number;
+    /**
+     * Optional a contour list of the surrounding elements
+     */
+    contours?: PosContour[];
+    /**
+     * The version used for this data structure
+     */
+    ver?: number;
+}
+export interface PosArticle extends PosArticleInfo {
+    roots: PosModuleRootData[];
+}
+export interface PosSaveData {
+    groups: PosGroup[];
+    roomlePlannerId?: string;
+    perspectiveImageLink?: string;
+    topImageLink?: string;
+    room3dLink?: string;
+    room3dFullLink?: string;
+}
+export interface PosPriceData {
+    Groups: PosPriceGroup[];
+    LogMessages: PosErrorMsg[];
+}
+export interface PosPriceGroup {
+    Id: string;
+    Roots: PosRootPrice[];
+}
+export interface PosRootPrice {
+    Id: string;
+    TotalPrice?: number;
+    Currency?: string;
+}
+export interface PosArticleCalculation {
+    /**
+     * Calculates the article group
+     * @param article
+     * @returns calc
+     */
+    calc(article: PosGroup): PosGroup;
+}
+export type MDAttributeSelection = MDBoolAttributeSelection | MDTextAttributeSelection | MDIntegerAttributeSelection | MDRealAttributeSelection | MDDimAttributeSelection;
+interface BaseAttributeSelection {
+    imageUrl?: string;
+    desc?: string;
+    name?: string;
+}
+export interface MDBoolAttributeSelection extends BaseAttributeSelection {
+    value?: boolean;
+}
+export interface MDTextAttributeSelection extends BaseAttributeSelection {
+    value?: string;
+}
+export interface MDIntegerAttributeSelection extends BaseAttributeSelection {
+    value?: number;
+}
+export interface MDRealAttributeSelection extends BaseAttributeSelection {
+    value?: number;
+}
+export interface MDDimAttributeSelection extends BaseAttributeSelection {
+    value?: number;
+}
+export interface MDNumberMinMaxAttributeSelection {
+    min?: number;
+    max?: string;
+    desc?: string;
+}
+export declare const enum MDType {
+    Dim = "Dim",
+    Integer = "Integer",
+    Real = "Real",
+    Bool = "Bool",
+    Text = "Text"
+}
+export type MDAttributeInfo = MDBoolAttributeInfo | MDTextAttributeInfo | MDIntegerAttributeInfo | MDRealAttributeInfo | MDDimAttributeInfo;
+interface BaseMDAttributeInfo {
+    id: string;
+    name: string;
+    isMain?: boolean;
+    desc?: string;
+    group?: string;
+    imageUrl?: string;
+    type: MDType;
+    userRight?: PosUserRight | null;
+    userView?: string | null;
+    implicitRelevant?: boolean;
+    sorting?: number;
+}
+export interface MDBoolAttributeInfo extends BaseMDAttributeInfo {
+    selections?: MDBoolAttributeSelection[];
+    type: MDType.Bool;
+}
+export interface MDTextAttributeInfo extends BaseMDAttributeInfo {
+    selections?: MDTextAttributeSelection[];
+    type: MDType.Text;
+}
+export interface MDIntegerAttributeInfo extends BaseMDAttributeInfo {
+    selections?: (MDIntegerAttributeSelection | MDNumberMinMaxAttributeSelection)[];
+    type: MDType.Integer;
+}
+export interface MDRealAttributeInfo extends BaseMDAttributeInfo {
+    selections?: (MDRealAttributeSelection | MDNumberMinMaxAttributeSelection)[];
+    type: MDType.Real;
+}
+export interface MDDimAttributeInfo extends BaseMDAttributeInfo {
+    selections?: (MDDimAttributeSelection | MDNumberMinMaxAttributeSelection)[];
+    type: MDType.Dim;
+}
+export interface MDModuleInfo {
+    id: string;
+    name: string;
+    desc?: string;
+    group?: string;
+    imageUrl?: string;
+    assignedAttributes: string[];
+}
+export interface MasterData {
+    libraryId: string;
+    modules: MDModuleInfo[];
+    attributes: MDAttributeInfo[];
+}
+export interface CheckResult {
+    calcResult: CheckDropDownEntry[];
+}
+export interface CheckDropDownEntry {
+    value: string | number | boolean;
+    kind: CheckDropDownEntryKind;
+}
+export declare enum CheckDropDownEntryKind {
+    Normal = 0,
+    Conflicting = 1
+}
+export {};

package/packages/web-sdk/packages/homag-intelligence/src/orders.d.ts

@@ -0,0 +1,39 @@
+import { default as RoomlePlanner } from '../../planner-core/src/roomle-planner';
+import { GlueLogic } from './emulator';
+import { ApiOptions } from './loader';
+
+export declare const createEmptyOrder: () => {
+    id: any;
+    state: string;
+    orderNumber: string;
+    orderName: string;
+    orderDescription: string;
+    project: string;
+    personInCharge: string;
+    orderDate: string;
+    deliveryDatePlanned: string;
+    addresses: {
+        type: string;
+        street: string;
+        houseNumber: string;
+        postalCode: string;
+        city: string;
+        country: string;
+    }[];
+    customerName: string;
+    customerNumber: string;
+    createdAt: string;
+    changedAt: string;
+    changedBy: string;
+    items: any[];
+};
+export declare const sendToOM: (apiOptions: ApiOptions, roomlePlanner: RoomlePlanner, gluLogic: GlueLogic, withPrice?: boolean) => Promise<void>;
+export declare const fetchPrice: (apiOptions: ApiOptions, gluLogic: GlueLogic, planId?: string) => Promise<any>;
+export default class Orders {
+    private _roomlePlanner;
+    private _gluLogic;
+    private _apiOptions;
+    constructor(roomlePlanner: RoomlePlanner, gluLogic: GlueLogic, apiOptions: ApiOptions);
+    sendToOM(withPrice?: boolean): Promise<void>;
+    fetchPrice(planId?: string): Promise<any>;
+}

package/packages/web-sdk/packages/homag-intelligence/src/rml-plugin.d.ts

@@ -0,0 +1,3 @@
+export declare abstract class RmlPlugin {
+    abstract init(...args: any[]): Promise<this>;
+}

package/packages/web-sdk/packages/homag-intelligence/src/util.d.ts

@@ -0,0 +1,5 @@
+type Logable = string | number | boolean | object | null | undefined;
+export declare const logApiCallback: (...args: Logable[]) => void;
+export declare const logMessage: (...args: Logable[]) => void;
+export declare const logApiCall: (...args: Logable[]) => void;
+export {};

package/packages/web-sdk/packages/material-viewer/src/material-viewer.d.ts

@@ -7,7 +7,7 @@ export declare class MaterialViewer extends Main {
     protected setupDependencies(): void;
     protected cleanUpGlobals(): void;
     protected cleanUpDependencies(): void;
-    protected bootFinished(): void;
+    protected bootFinished(): Promise<void>;
     getApi(): RoomleMaterialViewer;
     protected getContextName(): string;
 }

package/packages/web-sdk/packages/planner-core/src/planner.d.ts

@@ -10,7 +10,7 @@ export declare class Planner<P extends readonly PluginName[] = readonly []> exte
     protected setupDependencies(): void;
     protected cleanUpGlobals(): void;
     protected cleanUpDependencies(): void;
-    protected bootFinished(): void;
+    protected bootFinished(): Promise<void>;
     getApi(): RoomlePlanner<P>;
     protected getContextName(): string;
 }

package/packages/web-sdk/packages/planner-core/src/roomle-planner.d.ts

@@ -1,3 +1,4 @@
+import { default as RapiAccess } from '../../common-core/src/rapi-access';
 import { default as RoomlePlannerUiCallback } from './roomle-planner-ui-callback';
 import { GlbViewer } from '../../glb-viewer-core/src/glb-viewer';
 import { ExternalEmbeddable, GlobalAPI, KernelUtilityForUi, RubensAPI, default as Main } from '../../common-core/src/main';
@@ -26,6 +27,7 @@ import { ExternalGroupData, ExternalObject, ExtObjId } from '../../typings/exter
 import { PluginName } from '../../configurator-core/src/utils/plugin-types';
 import { Nullable } from '../../typings/helper';
 import { MaybePromise } from '../../common-core/src/utils/common-utils';
+import { HomagIntelligence } from '../../homag-intelligence/src/homag-intelligence';
 
 export type ID_TYPE = 'rml_id' | 'tc_id' | 'rml_serialized' | 'tc_serialized';
 export declare const EXT_OBJ_EXCEPTION = "Could not retrieve configuration for external object! Did you implement onGetConfigurationForExternalObject?";
@@ -75,9 +77,9 @@ export interface InsertItemResult {
 export default class RoomlePlanner<P extends readonly PluginName[] = readonly []> implements KernelAccessCallbackI, RoomlePlannerCallback, GlobalAPI, Context, KernelUtilityForUi, ExternalEmbeddable<RoomlePlannerUiCallback>, RubensAPI, ExternalObjectAPI {
     _creator_: string;
     private _activePlugins;
+    private _homagIntelligence;
     private _configuratorContext;
     private _domHelper;
-    private _scriptLoader;
     private _kernelAccessCallback;
     private _plannerKernelAccess;
     private _rapiAccess;
@@ -518,4 +520,9 @@ export default class RoomlePlanner<P extends readonly PluginName[] = readonly []
      * only possible if undo was called before
      */
     redo(): Promise<void>;
+    setHomagIntelligence(homagIntelligence: HomagIntelligence): void;
+    newPosDataFromId(id: string): any;
+    sendToOM(withPrice?: boolean): Promise<void>;
+    fetchPrice(planId?: string): Promise<any>;
+    getRapiAccess(): RapiAccess;
 }

package/packages/web-sdk/packages/tools-core/src/tools-core.d.ts

@@ -7,7 +7,7 @@ export declare class ToolsCore extends Main {
     protected setupDependencies(): void;
     protected cleanUpGlobals(): void;
     protected cleanUpDependencies(): void;
-    protected bootFinished(): void;
+    protected bootFinished(): Promise<void>;
     getApi(): RoomleToolsCore;
     protected getContextName(): string;
 }

package/packages/web-sdk/packages/typings/external-objects.d.ts

@@ -1,4 +1,6 @@
 import { RapiItem, RapiConfigurationEnhanced, Element, RapiTag } from './rapi-types';
+import { default as RoomlePlanner } from '../planner-core/src/roomle-planner';
+import { default as RoomleConfigurator } from '../configurator-core/src/roomle-configurator';
 
 export declare const EXTERNAL_ID_PREFIX = "__ext__obj__#";
 export type ExtObjId = `${typeof EXTERNAL_ID_PREFIX}${string}`;
@@ -17,4 +19,10 @@ export type ExternalTag = Partial<RapiTag> & Pick<RapiTag, 'label'> & {
     id: ExtObjId;
 };
 export type ExternalGroupData = object | string | string[];
+export type RoomlePlannerWithExtObjs = RoomlePlanner<['external-objects']>;
+export type RoomlePlannerType = RoomlePlanner | RoomlePlannerWithExtObjs;
+export type RoomleConfiguratorWithExtObjs = RoomleConfigurator<[
+    'external-objects'
+]>;
+export type RoomleConfiguratorType = RoomleConfigurator | RoomleConfiguratorWithExtObjs;
 export {};

package/packages/web-sdk/packages/typings/planner.d.ts

@@ -284,7 +284,7 @@ export interface KernelObjectConfiguration {
     serializedDefinition: string;
     uniqueId: string;
 }
-declare class KernelObjectConfigurationArray extends EmsArray<KernelObjectConfiguration> {
+export declare class KernelObjectConfigurationArray extends EmsArray<KernelObjectConfiguration> {
 }
 export interface LightSourceConfiguration {
     lightSourceAreaInSquareMeters: number;

package/src/common/components/collection-view/-utils/collection-view-dynamic-components.d.ts

@@ -2666,7 +2666,7 @@ declare const dynamicComponents: {
             required: true;
         };
     }>, {
-        api: import('vue').ShallowRef<RoomlePlanner<["external-objects"]>>;
+        api: import('vue').ShallowRef<RoomlePlannerWithExtObjs>;
     }, {
         scalingDirection: number;
     }, {}, {

package/src/common/composables/use-configurator-api.d.ts

@@ -1,5 +1,5 @@
 import { ShallowRef } from 'vue';
 
 export declare const useConfiguratorApi: () => {
-    configuratorApi: ShallowRef<any>;
+    configuratorApi: ShallowRef<RoomleConfiguratorType>;
 };

package/src/common/composables/use-core-instances.d.ts

@@ -1,6 +1,6 @@
 import { ShallowRef } from 'vue';
 
 export declare const useCoreInstances: () => {
-    api: ShallowRef<RoomlePlanner<["external-objects"]>>;
+    api: ShallowRef<RoomlePlannerWithExtObjs>;
     planInteractionHandler: ShallowRef<PlanInteractionHandler>;
 };

package/src/common/composables/use-static-item-parameters.d.ts

@@ -1,7 +1,7 @@
 import { GridViewElement } from '../../configurator/components/grid-view/-utils/GridViewHelper';
 import { MaterialsForObjects } from '../../planner/business-logic/rooms';
 
-export declare const useStaticItemParameters: (api: RoomlePlanner<["external-objects"]>, materialRootTag?: string[] | string) => {
+export declare const useStaticItemParameters: (api: RoomlePlannerWithExtObjs, materialRootTag?: string[] | string) => {
     show: {
         sizeControls: any;
         colorControls: any;

package/src/common/utils/helper.d.ts

@@ -65,7 +65,7 @@ export type WithRequired<T, K extends keyof T> = T & {
 };
 export declare const radToDeg: (rad: number) => number;
 export declare const isValidPlanID: (planId: string) => boolean;
-export declare const convertToUIValuesHelper: (valuesMM: KernelVector3, api: RoomlePlanner<["external-objects"]>) => {
+export declare const convertToUIValuesHelper: (valuesMM: KernelVector3, api: RoomlePlannerWithExtObjs) => {
     x: any;
     y: any;
     z: any;

package/src/common/utils/parameters.d.ts

@@ -2,7 +2,6 @@ import { RapiMaterial, RapiMaterialGroup, RapiTagForUi, RapiTexture } from '@roo
 import { KernelPartListParameter, UiPossibleChildTag } from '@roomle/web-sdk/typings/kernel';
 import { CollectionViewElement, TabCategory } from '../components/collection-view/-utils/types';
 import { VariantsMap } from '../../configurator/embedding/types';
-import { RoomleConfiguratorType } from './types';
 import { Translator } from '../composables/use-intl';
 
 export declare const DISABLED_PARAMETERS_ELEM_KEY = "disabled-parameters";

package/src/common/utils/types.d.ts

@@ -1,5 +1,3 @@
-import { default as RoomleConfigurator } from '@roomle/web-sdk/configurator-core/src/roomle-configurator';
-import { default as RoomlePlanner } from '@roomle/web-sdk/planner-core/src/roomle-planner';
 import { ExternalConfiguration } from '@roomle/web-sdk/typings/external-objects';
 import { KernelVector3 } from '@roomle/web-sdk/typings/kernel';
 import { RapiConfigurationEnhanced, RapiPlanSnapshotGetData, RapiPlan } from '@roomle/web-sdk/typings/rapi-types';
@@ -147,9 +145,4 @@ export type TutorialData = {
     [key: string]: CustomTutorialTranslation | CustomTutorialPlatform | CustomTutorialScope;
 };
 export type TooltipTarget<T> = ComponentPublicInstance<T>;
-export type RoomlePlannerWithExtObjs = RoomlePlanner<['external-objects']>;
-export type RoomleConfiguratorWithExtObjs = RoomleConfigurator<[
-    'external-objects'
-]>;
-export type RoomleConfiguratorType = RoomleConfigurator | RoomleConfiguratorWithExtObjs;
 export type RapiCallbacks = Record<any, any>;

package/src/configurator/business-logic/roomle-sdk-wrapper.d.ts

@@ -1,12 +1,13 @@
 import { default as RapiAccess } from '@roomle/web-sdk/common-core/src/rapi-access';
 import { GlbViewer } from '@roomle/web-sdk/glb-viewer-core/src/glb-viewer';
 import { Configurator } from '@roomle/web-sdk/configurator-core/src/configurator';
-import { Nullable, RoomleConfiguratorType } from '../../common/utils/types';
+import { Nullable } from '../../common/utils/types';
 import { UiInitData } from '../embedding/types';
 import { GlobalInitDataDefinition } from '@roomle/web-sdk/common-core/src/utils/shims';
 import { Planner } from '@roomle/web-sdk/planner-core/src/planner';
 import { GlobalCallback } from '@roomle/web-sdk/common-core/src/services/global-callback';
 import { default as IdbManager } from '@roomle/web-sdk/common-core/src/services/idb-manager';
+import { RoomleConfiguratorType } from '@roomle/web-sdk/typings/external-objects';
 
 /**
  * We use this class in a plugin so we

package/src/configurator/embedding/exposed-api.d.ts

@@ -3,7 +3,8 @@ import { LoadResponse, SdkConnector } from '../business-logic/sdk-connector';
 import { MessageHandler } from '../../../packages/common/src/utils/message-handler';
 import { Store } from 'vuex';
 import { StoreState } from '../../common/store';
-import { Nullable, RoomleConfiguratorType, RoomlePlannerWithExtObjs } from '../../common/utils/types';
+import { Nullable } from '../../common/utils/types';
+import { RoomlePlannerWithExtObjs, RoomleConfiguratorType } from '@roomle/web-sdk/typings/external-objects';
 import { Analytics } from '../../common/plugins/analytics';
 import { default as RoomleGLBViewer } from '@roomle/web-sdk/glb-viewer-core/src/roomle-glb-viewer';
 import { GlobalCallback } from '@roomle/web-sdk/common-core/src/services/global-callback';

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

@@ -4,10 +4,10 @@ import { CloseReason, ToggleCallback } from '../../../common/utils/types';
 declare const _default: import('vue').DefineComponent<{
     onClose: (_action: BUTTON_ACTIONS, _reason: CloseReason) => void;
     onToggleExpand?: ToggleCallback;
-    api: RoomlePlanner<["external-objects"]>;
+    api: RoomlePlannerWithExtObjs;
 }, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<{
     onClose: (_action: BUTTON_ACTIONS, _reason: CloseReason) => void;
     onToggleExpand?: ToggleCallback;
-    api: RoomlePlanner<["external-objects"]>;
+    api: RoomlePlannerWithExtObjs;
 }> & Readonly<{}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, any>;
 export default _default;

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

@@ -1,8 +1,8 @@
 declare const _default: import('vue').DefineComponent<{
-    api: RoomlePlanner<["external-objects"]>;
+    api: RoomlePlannerWithExtObjs;
     isConstructionElement?: boolean;
 }, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<{
-    api: RoomlePlanner<["external-objects"]>;
+    api: RoomlePlannerWithExtObjs;
     isConstructionElement?: boolean;
 }> & Readonly<{}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, any>;
 export default _default;

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

@@ -1,6 +1,6 @@
 declare const _default: import('vue').DefineComponent<{
-    api: RoomlePlanner<["external-objects"]>;
+    api: RoomlePlannerWithExtObjs;
 }, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<{
-    api: RoomlePlanner<["external-objects"]>;
+    api: RoomlePlannerWithExtObjs;
 }> & Readonly<{}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, any>;
 export default _default;

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

@@ -1,10 +1,10 @@
 declare const _default: import('vue').DefineComponent<{
     selectionElement: PlanElementViewModel;
-    api: RoomlePlanner<["external-objects"]>;
+    api: RoomlePlannerWithExtObjs;
     productName: string;
 }, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<{
     selectionElement: PlanElementViewModel;
-    api: RoomlePlanner<["external-objects"]>;
+    api: RoomlePlannerWithExtObjs;
     productName: string;
 }> & Readonly<{}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, any>;
 export default _default;

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

@@ -1,6 +1,6 @@
 declare const _default: import('vue').DefineComponent<{
-    api: RoomlePlanner<["external-objects"]>;
+    api: RoomlePlannerWithExtObjs;
 }, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<{
-    api: RoomlePlanner<["external-objects"]>;
+    api: RoomlePlannerWithExtObjs;
 }> & Readonly<{}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, any>;
 export default _default;

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

@@ -1,5 +1,5 @@
 declare const _default: import('vue').DefineComponent<{
-    api: RoomlePlanner<["external-objects"]>;
+    api: RoomlePlannerWithExtObjs;
     setValues: (values: KernelVector3) => Promise<void>;
     getValues: () => KernelVector3;
     labels: {
@@ -13,7 +13,7 @@ declare const _default: import('vue').DefineComponent<{
         z: boolean;
     };
 }, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<{
-    api: RoomlePlanner<["external-objects"]>;
+    api: RoomlePlannerWithExtObjs;
     setValues: (values: KernelVector3) => Promise<void>;
     getValues: () => KernelVector3;
     labels: {

package/src/planner/components/overlays/rooms/ConstructionVariants.vue.d.ts

@@ -4,14 +4,14 @@ declare const _default: import('vue').DefineComponent<{
     onExpand: (event: MouseEvent) => void;
     onCollapse?: (_payload: MouseEvent) => void;
     isDesktop?: boolean;
-    api: RoomlePlanner<["external-objects"]>;
+    api: RoomlePlannerWithExtObjs;
 }, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<{
     groups: RapiTag[];
     isExpanded?: boolean;
     onExpand: (event: MouseEvent) => void;
     onCollapse?: (_payload: MouseEvent) => void;
     isDesktop?: boolean;
-    api: RoomlePlanner<["external-objects"]>;
+    api: RoomlePlannerWithExtObjs;
 }> & Readonly<{}>, {
     isDesktop: boolean;
     isExpanded: boolean;

package/src/planner/components/overlays/rooms/DoorParametersSetting.vue.d.ts

@@ -7,7 +7,7 @@ declare const _default: import('vue').DefineComponent<import('vue').ExtractPropT
         required: true;
     };
     api: {
-        type: PropType<RoomlePlanner<["external-objects"]>>;
+        type: PropType<RoomlePlannerWithExtObjs>;
         required: true;
     };
     interactionHandler: {
@@ -2260,7 +2260,7 @@ declare const _default: import('vue').DefineComponent<import('vue').ExtractPropT
         required: true;
     };
     api: {
-        type: PropType<RoomlePlanner<["external-objects"]>>;
+        type: PropType<RoomlePlannerWithExtObjs>;
         required: true;
     };
     interactionHandler: {
@@ -2497,7 +2497,7 @@ declare const _default: import('vue').DefineComponent<import('vue').ExtractPropT
             required: true;
         };
     }>, {
-        api: import('vue').ShallowRef<RoomlePlanner<["external-objects"]>>;
+        api: import('vue').ShallowRef<RoomlePlannerWithExtObjs>;
     }, {
         scalingDirection: number;
     }, {}, {
@@ -4851,24 +4851,24 @@ declare const _default: import('vue').DefineComponent<import('vue').ExtractPropT
         onExpand: (event: MouseEvent) => void;
         onCollapse?: (_payload: MouseEvent) => void;
         isDesktop?: boolean;
-        api: RoomlePlanner<["external-objects"]>;
+        api: RoomlePlannerWithExtObjs;
     }, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<{
         groups: RapiTag[];
         isExpanded?: boolean;
         onExpand: (event: MouseEvent) => void;
         onCollapse?: (_payload: MouseEvent) => void;
         isDesktop?: boolean;
-        api: RoomlePlanner<["external-objects"]>;
+        api: RoomlePlannerWithExtObjs;
     }> & Readonly<{}>, {
         isDesktop: boolean;
         isExpanded: boolean;
     }, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, any>;
     LoadingSpinner: import('vue').DefineComponent<{}, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;
     ProductPositions: import('vue').DefineComponent<{
-        api: RoomlePlanner<["external-objects"]>;
+        api: RoomlePlannerWithExtObjs;
         isConstructionElement?: boolean;
     }, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<{
-        api: RoomlePlanner<["external-objects"]>;
+        api: RoomlePlannerWithExtObjs;
         isConstructionElement?: boolean;
     }> & Readonly<{}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, any>;
 }, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;

package/src/planner/components/overlays/rooms/ElementLengthScaling.vue.d.ts

@@ -19,7 +19,7 @@ declare const _default: import('vue').DefineComponent<import('vue').ExtractPropT
         required: true;
     };
 }>, {
-    api: ShallowRef<RoomlePlanner<["external-objects"]>>;
+    api: ShallowRef<RoomlePlannerWithExtObjs>;
 }, {
     scalingDirection: number;
 }, {}, {

package/src/planner/components/overlays/rooms/WindowParametersSetting.vue.d.ts

@@ -5,11 +5,11 @@ declare const _default: import('vue').DefineComponent<{
     onClose: (_buttonAction: BUTTON_ACTIONS, _reason: CloseReason) => Promise<void>;
     onToggleExpand?: () => void;
     interactionHandler: PlanInteractionHandler;
-    api: RoomlePlanner<["external-objects"]>;
+    api: RoomlePlannerWithExtObjs;
 }, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<{
     onClose: (_buttonAction: BUTTON_ACTIONS, _reason: CloseReason) => Promise<void>;
     onToggleExpand?: () => void;
     interactionHandler: PlanInteractionHandler;
-    api: RoomlePlanner<["external-objects"]>;
+    api: RoomlePlannerWithExtObjs;
 }> & Readonly<{}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, any>;
 export default _default;

package/src/planner/components/utils/AssureConfiguratorHandlers.vue.d.ts

@@ -1,5 +1,5 @@
 declare const _default: import('vue').DefineComponent<{}, {
-    configuratorApi: import('vue').ShallowRef<any>;
+    configuratorApi: import('vue').ShallowRef<RoomleConfiguratorType>;
 }, {}, {
     isLoaded(): boolean;
 }, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;

package/src/planner/components/utils/AssureSdkHandlers.vue.d.ts

@@ -1,5 +1,5 @@
 declare const _default: import('vue').DefineComponent<{}, {
-    api: import('vue').ShallowRef<RoomlePlanner<["external-objects"]>>;
+    api: import('vue').ShallowRef<RoomlePlannerWithExtObjs>;
     planInteractionHandler: import('vue').ShallowRef<PlanInteractionHandler>;
 }, {}, {
     isLoaded(): boolean;

package/src/planner/utils/planner-sidebar.d.ts

@@ -25,4 +25,4 @@ export declare const CONFIGURATOR_SIDEBAR_STATE_KEYS: {
     readonly SHOULD_SHOW_COLLECTION_VIEW_ELEMENT: "configurator_sidebar_show_collection_view_element";
 };
 export declare const matchProductListAndQuantity: (productList: UiPlanObject[]) => ProductListItem[];
-export declare const fillPartList: (data: RapiItem | RapiConfiguration, partList: KernelPartList, hash: string, plannerApi: RoomlePlanner<["external-objects"]>, store: Store<StoreState>) => Promise<void>;
+export declare const fillPartList: (data: RapiItem | RapiConfiguration, partList: KernelPartList, hash: string, plannerApi: RoomlePlannerWithExtObjs, store: Store<StoreState>) => Promise<void>;