@roomle/embedding-lib 5.24.0 → 5.25.0-alpha.10

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

@@ -0,0 +1,711 @@
+import { RAPI_PATHS } from '../../common-core/src/rapi-access';
+import { default as UnitFormatter } from './services/unit-formatter';
+import { Base64Image, CanvasOffset } from '../../common-core/src/common-interfaces';
+import { KernelParameter, KernelParameterGroup, KernelPartList, KernelPartListPrice, KernelPossibleChild, UiKernelParameter, UiPossibleChild, UiPossibleChildTag, ExportType } from '../../typings/kernel';
+import { DynamicLightSettingSource } from '../../common-core/src/lightsetting/dynamic-light-setting-loader';
+import { ExternalEmbeddable, GlobalAPI, KernelUtilityForUi, RubensAPI, default as Main } from '../../common-core/src/main';
+import { SceneSettings } from '../../common-core/src/scene-settings-loader';
+import { default as ConfiguratorUiCallbacks } from './services/configurator-ui-callback';
+import { AssetUrl, ConfigurationHash, ConfigurationString, RapiAdditionalContent, RapiConfiguration, RapiConfiguratorSettings, RapiId, RapiItem, RapiMaterial, RapiTagForUi } from '../../typings/rapi-types';
+import { Context } from '../../common-core/src/di/context';
+import { default as ConfiguratorSceneManager } from './webgl/configurator-scene-manager';
+import { default as ConfiguratorContext } from '../../common-core/src/webgl/configurator-context';
+import { ConfiguratorKernelAccessCallbackI } from './services/configurator-kernel-access-callback';
+import { default as InitData } from '../../common-core/src/utils/init-data';
+import { GlobalInitDataDefinition, InitDataDefinition } from '../../common-core/src/utils/shims';
+import { CameraParameter } from '../../common-core/src/cameracontrol/camera-control';
+import { PrepareImageOptions, RenderOptions } from '../../common-core/src/webgl/image-renderer';
+import { GlobalCallback } from '../../common-core/src/services/global-callback';
+import { default as RoomleToolsCore } from '../../tools-core/src/roomle-tools-core';
+import { Scene } from 'three';
+import { default as IdbManager } from '../../common-core/src/services/idb-manager';
+import { HomagIxArticleParams, HomagIxHeaderParams, HomagIxOrderParams } from './utils/imos-ix-poc-export-helper';
+import { ConfiguratorDebugAPI } from './configurator-debug-api';
+import { CancelSelectionReasons } from '../../typings/planner';
+import { PluginName, SaveCurrentConfigurationReturnType } from './utils/plugin-types';
+
+interface ConfigurationLoadedResponse {
+    partList: KernelPartList;
+    errors: string[];
+    hash: string;
+    rootComponentLabel: string;
+}
+interface CleanupOptions {
+    resetCoreCache?: boolean;
+    resetMeshCache?: boolean;
+    resetApiCache?: boolean;
+}
+export declare const enum PARAMETER_UPDATE_TYPE {
+    PLAN_OBJECT = 0,
+    PLAN_COMPONENT = 1,
+    COMMON_COMPONENTS = 2
+}
+export default class RoomleConfigurator<P extends readonly PluginName[] = readonly []> implements GlobalAPI, Context, KernelUtilityForUi, ConfiguratorKernelAccessCallbackI, ExternalEmbeddable<ConfiguratorUiCallbacks>, RubensAPI, ConfiguratorDebugAPI {
+    _creator_: string;
+    private _activePlugins;
+    private _rapiAccess;
+    private _dataSyncer;
+    private _errorHandler;
+    private _unitFormatter;
+    protected _idbManager: IdbManager;
+    private _domHelper;
+    private _configuratorUiCallbacks;
+    private _configuratorKernelAccessCallback;
+    private _lifeCycleManager;
+    private _plannerKernelAccess;
+    private _scriptLoader;
+    private _configuratorContext;
+    private _initData;
+    private _globalInitData;
+    private _globalCallback;
+    private _kernelIo;
+    private _sceneManager;
+    private _onInitDoneCollection;
+    private _isKernelReady;
+    private _isWebGlReady;
+    private _isPreloadReady;
+    private _isLoadError;
+    private _rejectOnLoadError;
+    private _isReloading;
+    private _needsSync;
+    private _isInitDone;
+    private _checkInitDone;
+    private _onInitDone;
+    constructor(creator: string, activePlugins?: P);
+    exportCanvasScreenshot(quality?: number): Promise<string>;
+    initSceneManager(sceneManager?: ConfiguratorSceneManager): void;
+    getScene(): Scene;
+    updateScene(): void;
+    private _loadWebGlLib;
+    private _loadingWebGlSuccess;
+    private _webGlIsReady;
+    private _initPromiseCallback;
+    private _notifyOnConfigurationReady;
+    private _notifyOnConfigurationLoadingError;
+    private _loadItemOrConfigById;
+    private _shouldBroadcastToUi;
+    private _isCorrectResponse;
+    private _onLoadConfiguration;
+    private _clearScene;
+    private _notifyUiAboutNewItem;
+    private _notifyUiAboutNewConfiguration;
+    notifyUiAboutNewLabel(id: RapiId): void;
+    private _getMaterialGroups;
+    private _loadConfiguration;
+    private _preLoadItemOrConfig;
+    private _preloadPackage;
+    private _reloadConfiguration;
+    private _performLoadConfiguration;
+    private _changeHDGeometry;
+    /**
+     * Set general configuration parameter
+     * @param initData
+     */
+    setOverrides(initData: Partial<InitDataDefinition & GlobalInitDataDefinition> | InitData): void;
+    /**
+     * This method has to be called before configurator is ready to use
+     *
+     * @param element which should contain the configurator
+     * @param initData
+     * @return Promise which is resolved when configurator is initialized
+     */
+    init(element: HTMLElement, initData?: InitDataDefinition): Promise<void>;
+    /**
+     * Cancels the selection of all currently selected components
+     */
+    cancelSelection({ reason, resetCamera, }?: {
+        reason?: CancelSelectionReasons;
+        resetCamera?: boolean;
+    }): void;
+    /**
+     * Enable the use of HD geometry. Also reloads the object with HD geometry enabled
+     */
+    enableHDGeometry(): Promise<void | ConfigurationLoadedResponse>;
+    /**
+     * Disable the use of HD Geometry
+     */
+    disableHDGeometry(): Promise<void | ConfigurationLoadedResponse>;
+    /**
+     * Change the camera offset
+     * @param offset
+     */
+    changeOffset(offset: CanvasOffset): void;
+    /**
+     * Shows dockings/ghosts for the selected possible child
+     *
+     * @param possibleChild
+     * @param dragEvent
+     * @param dragIn
+     */
+    previewDockings(possibleChild: UiPossibleChild, dragEvent?: DragEvent, dragIn?: boolean): void;
+    /**
+     * Remove/cancel all dockings/ghosts
+     */
+    cancelDockings(): void;
+    /**
+     * Deletes the currently selected component if possible
+     */
+    requestDeleteComponent(): void;
+    /**
+     * Renders the current item in high quality, it also uses the current lightsetting
+     * @param renderOptions
+     */
+    renderImage(renderOptions: RenderOptions): Promise<Base64Image>;
+    /**
+     * Generates a perspective image (slightly from the side) and returns it as base 64
+     */
+    preparePerspectiveImage(options?: PrepareImageOptions): Promise<Base64Image>;
+    /**
+     * Generates an image of one part (slightly from the side) and returns it as base 64
+     * WARNING: It's only possible to render one sub part at a time
+     * * @param partId id of the sub part, received from part list
+     * * @param options size of the rendered image in pixel (default is 256), will render faster when size is smaller
+     */
+    preparePartImage(partId: number, options?: PrepareImageOptions | number): Promise<Base64Image>;
+    /**
+     * Saves the current configuration (parameters etc)
+     * and returns a new configuration object including the configuration hash
+     */
+    saveCurrentConfiguration(): Promise<SaveCurrentConfigurationReturnType<P>>;
+    /**
+     * Generates images of the current configuration
+     *
+     * @return Promise containing the `topImage`, `perspectgetAdditionalContentsOfiveImage` and a boolean `isLocally` which indicates if the images were generated while being offline
+     */
+    generateImagesOfCurrentConfiguration(): Promise<object>;
+    /**
+     * Generates a top image (birds perspective) and returns it as base 64
+     * @param options should object dimensions be visible
+     */
+    prepareTopImage(options?: PrepareImageOptions | boolean): Promise<Base64Image>;
+    /**
+     * Resets the camera back to the start position
+     */
+    resetCameraPosition(): void;
+    /**
+     * For testing purpose only
+     * @hidden
+     * @param filter
+     */
+    showBenchmarks(filter?: string): void;
+    /**
+     * Shows current scene graph, used for debug purposes only
+     * @hidden
+     * @param id
+     */
+    debugSceneGraph(id?: number): void;
+    /**
+     * Loads an item based on a configuration string
+     *
+     * For example: `{'componentId":"muuto:Muuto-Stacked'}`
+     * @param configuration
+     * @param initData
+     */
+    loadConfiguration(configuration: ConfigurationString, initData?: InitDataDefinition): Promise<ConfigurationLoadedResponse>;
+    /**
+     * Loads an item based on a configuration hash
+     *
+     * For example: `koinor:FORMIA_LeftGroup:79FBF0D6C79A2598B5FF943111EA29DC0C6884AA97F4383582B47F69C14DDB2C`
+     * @param configurationId
+     * @param initData
+     */
+    loadConfigurationById(configurationId: RapiId, initData?: InitDataDefinition): Promise<ConfigurationLoadedResponse>;
+    /**
+     * Loads a configuration based on the item id
+     * @param itemId
+     * @param initData
+     */
+    loadConfigurableItemById(itemId: RapiId, initData?: InitDataDefinition): Promise<ConfigurationLoadedResponse>;
+    /**
+     * Downloads and caches the selected configuration id for faster use
+     * @param configurationId
+     */
+    preLoadConfigurationById(configurationId: RapiId): Promise<RapiConfiguration>;
+    /**
+     * Downloads and caches the selected item id for faster use
+     * @param itemId
+     */
+    preLoadConfigurableItemById(itemId: RapiId): Promise<RapiItem>;
+    private _getTag;
+    private _dispatchSetParameter;
+    /**
+     * Sets the parameter of the selected component. If nothing is selected the parameters of the
+     * parameters of the plan object are set
+     * @param parameter an instance of the kernel parameter we want to set, use 'key: "your-key"' if
+     *                  you do not have a kernel instance and do not need validation of the input
+     * @param value the value we want to set on the parameter as string
+     * @param isRaw turn this to true if you dont want the kernel to parse the value string, e.g. convert 100cm to 1000
+     */
+    setParameter(parameter: KernelParameter, value: string, isRaw?: boolean): Promise<void>;
+    /**
+     * Method to set a parameter on the plan object. This is used by embedding as well
+     * @param parameter an instance of the kernel parameter we want to set, use 'key: "your-key"' if
+     *                  you do not have a kernel instance and do not need validation of the input
+     * @param value the value we want to set on the parameter as string
+     */
+    setParameterOfPlanObject(parameter: KernelParameter, value: string): Promise<void>;
+    /**
+     * Sets an animation value of the selected component. If nothing is selected the values of the
+     * animations of the plan object are set
+     * @param key key of the animation as string
+     * @param value the value we want to set on the animation as string
+     */
+    setAnimationValue(key: string, value: string): Promise<void>;
+    /**
+     * Method to set an animation value on the plan object.
+     * @param key key of the animation as string
+     * @param value the value we want to set on the animation as string
+     */
+    setAnimationValueOfPlanObject(key: string, value: string): Promise<void>;
+    /**
+     * Returns all parameters which correspond to the plan object. This is also exposed for embedding
+     */
+    getParametersOfPlanObject(): Promise<KernelParameter[]>;
+    /**
+     * Method to set a parameter on the root component. This is used by embedding as well
+     * @param parameter an instance of the kernel parameter we want to set, use 'key: "your-key"' if
+     *                  you do not have a kernel instance and do not need validation of the input
+     * @param value the value we want to set on the parameter as string
+     */
+    setParameterOfRootComponent(parameter: KernelParameter, value: string): Promise<void>;
+    /**
+     * Returns all parameters which correspond to the root component. This is also exposed for embedding
+     */
+    getParametersOfRootComponent(): Promise<KernelParameter[]>;
+    /**
+     * Enable the selection of multiple components.
+     * Common parameters shared between those components can then be changed at once
+     */
+    enableMultiselect(): void;
+    /**
+     * Disable selection of multiple components. By default only one component can be selected at a time
+     */
+    disableMultiselect(): void;
+    /**
+     * @return Promise with the current configuration string/hash
+     */
+    getCurrentConfiguration(): Promise<ConfigurationString>;
+    /**
+     * Loads the component (defined as string) into the kernel
+     *
+     * @param componentString
+     * @return Promise which gets resolved when the component has been loaded
+     */
+    loadComponentIntoKernel(componentString: string): Promise<void>;
+    /**
+     * @return Promise containing the short url for the current configuration
+     */
+    getShortUrlOfCurrentConfiguration(): Promise<string>;
+    /**
+     * Returns the formatted value based on the parameter.unitType
+     *
+     * @param value
+     * @param parameter
+     */
+    formatValueToUnitString(value: number, parameter: KernelParameter): string | number;
+    /**
+     * Get tag for a given tag id
+     *
+     * @param tagId
+     * @param options `{ include: RAPI_PATHS[] }`
+     * @return Promise containing the tag including items and materials for that tag
+     */
+    getTagById(tagId: RapiId, options?: {
+        include: RAPI_PATHS[];
+    }): Promise<RapiTagForUi>;
+    /**
+     * Returns same url when online or caches url when offline
+     * @param url
+     */
+    requestAsset(url: string): AssetUrl;
+    /**
+     * Sets the material of the floor to the given RapiMaterial.
+     * If the current environment is not floor environment it will be changed
+     *
+     * @param material
+     * @return promise that resolves when material has been changed
+     */
+    changeFloorMaterial(material: RapiMaterial): Promise<void>;
+    /**
+     * Sets the material of the floor to the given material id.
+     * If the current environment is not floor environment it will be changed
+     *
+     * Example material ids are:
+     * roomle_floor:DresdenEiche
+     * roomle_floor:Ibiza
+     * roomle_floor:Palma
+     * roomle_floor:Elba
+     * roomle_floor:Manacor
+     * roomle_floor:KernEiche
+     * roomle_floor:KieferScandic
+     * roomle_floor:EicheHabsburg
+     * roomle_floor:FuldaKiefer
+     * roomle_floor:Ashton
+     * roomle_floor:EicheLondon
+     *
+     * @param materialId
+     * @return promise that resolves when material has been changed
+     */
+    changeFloorMaterialById(materialId: string): Promise<void>;
+    /**
+     * In embedding scenario the core dispatches the onOpenFloorMaterials event
+     * if someone outside of the iframe wants to open the floor materials popup
+     * @hidden
+     */
+    openFloorMaterials(): void;
+    /**
+     * In embedding scenario the core dispatches the onOpenPartList event
+     * if someone outside of the iframe wants to open the part list popup
+     * @hidden
+     */
+    openPartList(): void;
+    /**
+     * It is possible to add additional content to a configurable-item in our backend
+     * for example, product images, product videos etc. To fetch them you can use this method
+     * @param rapiItems
+     */
+    getAdditionalContentsOf(rapiItems: RapiItem[]): Promise<RapiAdditionalContent[]>;
+    /**
+     * @hidden
+     *
+     * @param rapiId
+     */
+    changeTypeChangeTag(rapiId: RapiId): void;
+    /**
+     * After calling this method the UiCallback removeTypeChangeTag is triggered (see: {@link @roomle/web-sdk/configurator-core/src/services/configurator-ui-callback#ConfiguratorUiCallbacks.onRemoveTypeChangeTag})
+     * @param rapiId
+     */
+    removeTypeChangeTag(rapiId: RapiId): void;
+    showGUI(): void;
+    /**
+     * Show overlay with statistic data for:
+     * fps
+     * memory in MB
+     * number of draw calls
+     * number of poly/triangle count
+     * number of geometries
+     * number of textures
+     */
+    showStats(): void;
+    /**
+     * Show dimensions (width, height, depth) of object
+     *
+     * See {@link @roomle/web-sdk/configurator-core/src/services/configurator-ui-callback#ConfiguratorUiCallbacks.onDimensionsVisibilityChange} to get notified when dimension visibility changes
+     */
+    showDimensions(): void;
+    /**
+     * Hides dimensions when they are shown (see {@link showDimensions}).
+     * Calling hideDimensions does not force dimensions to be always hidden.
+     *
+     * See {@link @roomle/web-sdk/configurator-core/src/services/configurator-ui-callback#ConfiguratorUiCallbacks.onDimensionsVisibilityChange} to get notified when dimension visibility changes
+     */
+    hideDimensions(): void;
+    /**
+     * Start sync of catalog to make it offline available
+     * @param catalogId
+     */
+    syncCatalog(catalogId: RapiId): Promise<void>;
+    /**
+     * Start sync of floor tag to make it offline available
+     * @param tagId
+     */
+    syncFloorTag(tagId: RapiId): Promise<void>;
+    /**
+     * Start sync of type change tag to make it offline available
+     * @param tagId
+     */
+    syncTypeChangeTag(tagId: RapiId): Promise<void>;
+    /**
+       * Loads a dynamic light settings into the scene. The dynamic light setting source can be an
+       * object (js), json, or an url (url to json). See {@link @roomle/web-sdk/configurator-core/src/scene-settings-loader#SceneSettings} how to define it.
+       *
+       * Exampe:
+       * ```
+       {
+        "lights": [
+          {
+            "type": "rectarea",
+            "name": "main",
+            "intensity": 240,
+            "color": "#ffffff",
+            "position": {
+              "x": -0.5,
+              "y": 6,
+              "z": 3
+            },
+            "target": {
+              "x": 0,
+              "y": 0,
+              "z": 0
+            },
+            "castShadow": true,
+            "width": 0.8,
+            "height": 0.8
+          },
+          {
+            "type": "spot",
+            "name": "side",
+            "intensity": 0.3,
+            "color": "#ffffff",
+            "position": {
+              "x": 2,
+              "y": 3,
+              "z": 1.5
+            },
+            "target": {
+              "x": 0,
+              "y": 0.1,
+              "z": 0
+            },
+            "castShadow": false,
+            "angle": 50,
+            "penumbra": 0.5
+          },
+          {
+            "type": "ambient",
+            "name": "ambient",
+            "intensity": 0.3,
+            "color": "#ffffff",
+            "position": {
+              "x": 0,
+              "y": 0,
+              "z": 0
+            }
+          }
+        ]
+      }
+       ```
+       * @param source
+       */
+    loadDynamicLightSetting(source: DynamicLightSettingSource): Promise<void>;
+    /**
+     * Used for test puprose only
+     * @hidden
+     * @param hex
+     */
+    setBackgroundColor(hex: string): void;
+    /**
+     * Used for test puprose only
+     * @hidden
+     * @param url
+     */
+    setBackgroundImage(url: string): void;
+    /**
+     * Loads a SceneSettings object, currently it can can contain a light setting definition
+     * (see {@link @roomle/web-sdk/configurator-core/src/roomle-configurator#RoomleConfigurator.loadDynamicLightSetting}) and an environment definition (see {@link @roomle/web-sdk/configurator-core/src/environment/dynamic-environment-setting-loader#EnvironmentSetting}).
+     * @param sceneSettings
+     */
+    loadSceneSetting(sceneSettings: SceneSettings): Promise<void>;
+    /**
+     * By default the outline pass uses the bounding box mesh of each component to highlight the object.
+     * When mesh selection is enabled, the meshes of the object are used directly.
+     * This is the recommended setting for non square/rectangular (shelf) components like sofas.
+     *
+     * @param enabled
+     */
+    enableMeshSelection(enabled: boolean): void;
+    /**
+     * This function has to be called when the size of the container
+     * (the html element which has been used in the init method) changes
+     * It is VERY important to call this method because the SDK can not
+     * detect if the DOM element which embeds the canvas of the 3D scene
+     * changes in size
+     */
+    updateSize(): void;
+    setCameraOffset(offset: CanvasOffset): void;
+    getCameraOffset(): CanvasOffset;
+    /**
+     * Return the main class which has access to lifecycle events and RapiAccess.
+     * Hidden because it's only useful for embedding API.
+     * Has to be overridden by main class.
+     * @hidden
+     */
+    getMain(): Main;
+    /**
+     * Clears the scene and all components/meshes.
+     * Also unregisters configurator callbacks in kernel.
+     * @param options CleanupOptions
+     */
+    cleanup(options?: CleanupOptions): void;
+    /**
+     * This method is used for lifecycle tests only
+     * @hidden
+     */
+    resumeTest(element?: HTMLElement): void;
+    /**
+     * This method is used for lifecycle tests only
+     * @hidden
+     */
+    pauseTest(): void;
+    /**
+     * Moves the camera closer to the object. Default value (when no value given) is 4, higher value moves a bigger distance.
+     * @param value
+     */
+    zoomIn(value?: number): void;
+    /**
+     * Moves the camera away from the object. Default value (when no value given) is 4, higher value moves a bigger distance.
+     * @param value
+     */
+    zoomOut(value?: number): void;
+    /**
+     * Use this callbacks to hook in your functionality
+     */
+    get callbacks(): ConfiguratorUiCallbacks;
+    /**
+     * @internal
+     * Use this callbacks to hook in your functionality
+     */
+    get globalCallbacks(): GlobalCallback;
+    /**
+     * Returns the runtime component id of root component of the current plan object
+     * @return number the number of the runtime id of the root component
+     */
+    getRuntimeComponentIdOfRootComponent(): number;
+    /**
+     * returns the current configuration hash, this can be used for analytics or other stuff like caching etc
+     * @return string current configuration hash
+     */
+    getCurrentConfigurationHash(): Promise<ConfigurationHash>;
+    getCurrentSelection(): string[];
+    isReady(): void;
+    updatePossibleChildren(elementId: number, children: KernelPossibleChild[], parameterUpdateType?: PARAMETER_UPDATE_TYPE): Promise<void>;
+    updateParameters(parameters: KernelParameter[], parameterGroups: KernelParameterGroup[], elementId: number | number[], parameterUpdateType: PARAMETER_UPDATE_TYPE): void;
+    loadError(error?: any): void;
+    resumeKernelCallbacks(): void;
+    pauseKernelCallbacks(): void;
+    /**
+     * Set the name of the parameter group which is selected at the moment
+     * @param group
+     */
+    setActiveGroupInView(group: string): void;
+    /**
+     * Set the name of the parameter group which is selected at the moment
+     * @param group
+     * @param runtimeId
+     */
+    setActiveGroupInViewForPlanObject(group: string, runtimeId?: number): void;
+    /**
+     * Get all parameter groups defined on the component, even if it has no parameters assigned
+     */
+    getParameterGroups(): KernelParameterGroup[];
+    /**
+     * Get the data which is assigned to the configurator object, especially things like allowed hosts
+     */
+    getConfiguratorSettings(): Promise<RapiConfiguratorSettings>;
+    moveCamera(cameraParameter: CameraParameter): Promise<void>;
+    /**
+     * Select a component by runtime id. You can retrieve this ID from partlist etc
+     * If it's already selected it will be deselected to mimic the behavior of click/touch
+     * @param runtimeId number, the runtime id of the component. You can retrieve this ID from partlist etc
+     */
+    selectComponent(runtimeId: number): Promise<void>;
+    /**
+     * Sets the parameter of the component by it's runtime id
+     * parameters of the plan object are set
+     * @param runtimeId number, the runtime id of the component. You can retrieve this ID from partlist etc
+     * @param parameter an instance of the kernel parameter we want to set, use 'key: "your-key"' if
+     *                  you do not have a kernel instance and do not need validation of the input
+     * @param value the value we want to set on the parameter as string
+     */
+    setComponentParameter(runtimeId: number, parameter: KernelParameter, value: string): Promise<void>;
+    /**
+     * Highlight parts in the scene with the given ids
+     * Use empty array to remove highlights
+     * @param ids
+     */
+    highlightParts(ids: number[]): void;
+    /**
+     * Undo last action
+     * calls configuratorHistory.undo where array of last configuration are stored
+     */
+    undo(): Promise<void>;
+    /**
+     * Redo last action
+     * calls configuratorHistory.redo where array of last configuration are stored
+     * only possible if undo was called before
+     */
+    redo(): Promise<void>;
+    /**
+     * clears current configurator history
+     */
+    clearHistory(): void;
+    /**
+     * Returns the hash of the given serialized configuration
+     * @param serializedConfiguration
+     */
+    getHashOfSerializedConfiguration(serializedConfiguration: string): ConfigurationHash;
+    /**
+     * Returns parameters of the component including groups
+     * @param componentRuntimeId
+     */
+    getParametersOfComponent(componentRuntimeId: number): UiKernelParameter[];
+    private _mapComponentTooltipsToParamKeys;
+    private _setParameterTooltip;
+    private _addGroupsToParameters;
+    private _getChildrenOf;
+    /**
+     * Returns all possible children and the default child for a given component
+     * @param componentRuntimeId
+     * @param onlyPossible: boolean true if you only want possibleChildren
+     * @param onlyVisible: boolean true if you only want visible children
+     */
+    getChildrenOfPlanComponent(componentRuntimeId: number, onlyPossible?: boolean, onlyVisible?: boolean): Promise<{
+        tags: UiPossibleChildTag[];
+        defaultChild: UiPossibleChild;
+    }>;
+    /**
+     * Returns all possible children and the default child for the plan object
+     * @param onlyPossible: boolean true if you only want possibleChildren
+     * @param onlyVisible: boolean true if you only want visible children
+     */
+    getChildrenOfPlanObject(onlyPossible?: boolean, onlyVisible?: boolean): Promise<{
+        tags: UiPossibleChildTag[];
+        defaultChild: UiPossibleChild;
+    }>;
+    private _addAdditionalInfoToPossibleChildren;
+    private _getPossibleChildrenForKernelPossibleChildren;
+    /**
+     * returns unit formatter for formatting input und output values in scene
+     */
+    getUnitFormatter(): UnitFormatter;
+    /**
+     * returns manager class to interface with indexedDB storage
+     */
+    getStorage(): IdbManager;
+    /**
+     * returns class containing configurator specific data properties
+     */
+    getConfiguratorContext(): ConfiguratorContext;
+    /**
+     * Returns the KernelComponent object for the given componentRuntimeId
+     * @param componentRuntimeId
+     */
+    getComponent(componentRuntimeId: number): import('../../typings/kernel').KernelComponent;
+    getTools(): Promise<RoomleToolsCore>;
+    exportImageFromCamera(filename?: string, shouldWaitForAssets?: boolean): Promise<void>;
+    calcPartsPriceSum(partList: KernelPartList): Promise<KernelPartListPrice>;
+    generateProductionServiceExport(defaultExportDefinition?: string): Promise<any>;
+    generateTCExport(defaultExportDefinition?: string): Promise<any>;
+    generateIMOSiXExport(defaultExportDefinition?: string): Promise<any>;
+    generateHOMAGiXExport(defaultExportDefinition?: string, homagIxOrderData?: HomagIxOrderParams, homagIxHeaderParams?: HomagIxHeaderParams, homagIxArticleParams?: HomagIxArticleParams): Promise<string>;
+    downloadHomagIxExportPoC(): Promise<any>;
+    generateHomagIxExport(exportType: ExportType, defaultExportDefinition?: string): Promise<any>;
+    setEnvironmentMap(params: {
+        url?: string;
+        intensity?: number;
+        rotation?: number;
+        maxLightSources?: number;
+    }): void;
+    enableEvents(): void;
+    disableEvents(): void;
+    enableDebugging(): void;
+    /**
+     * Temporarily stops all input event listeners on the canvas.
+     */
+    pauseInputListeners(): void;
+    /**
+     * Resumes all input event listeners on the canvas.
+     */
+    resumeInputListeners(): void;
+}
+export {};