@roomle/web-sdk 2.90.0 → 2.91.0-alpha.10

package/lib/definitions/packages/configurator-core/src/services/configurator-kernel-access-callback.d.ts

@@ -0,0 +1,19 @@
+import type { KernelParameter, KernelParameterGroup, KernelPossibleChild } from '../../../typings/kernel';
+import type { PARAMETER_UPDATE_TYPE } from '../roomle-configurator';
+import type { KernelAccessCallbackI } from '../../../common-core/src/kernel-access-callback';
+import type { Context } from '../../../common-core/src/di/context';
+export interface ConfiguratorKernelAccessCallbackI extends KernelAccessCallbackI {
+    updatePossibleChildren(elementId: number, children: KernelPossibleChild[], parameterUpdateType?: PARAMETER_UPDATE_TYPE): void;
+    updateParameters(parameters: KernelParameter[], parameterGroups: KernelParameterGroup[], elementId: number | number[], parameterUpdateType: PARAMETER_UPDATE_TYPE): void;
+}
+export default class ConfiguratorKernelAccessCallback implements Context, ConfiguratorKernelAccessCallbackI {
+    _creator_: string;
+    private _callbackListener;
+    constructor(creator: string);
+    addListener(listener: ConfiguratorKernelAccessCallbackI): void;
+    removeListener(listener: ConfiguratorKernelAccessCallbackI): void;
+    isReady(): void;
+    updatePossibleChildren(elementId: number, children: KernelPossibleChild[], parameterUpdateType?: PARAMETER_UPDATE_TYPE): void;
+    updateParameters(parameters: KernelParameter[], parameterGroups: KernelParameterGroup[], elementId: number | number[], parameterUpdateType: PARAMETER_UPDATE_TYPE): void;
+    loadError(error?: any): void;
+}

package/lib/definitions/packages/configurator-core/src/services/configurator-ui-callback.d.ts

@@ -0,0 +1,294 @@
+import type { ConfiguratorKernelClass, DebugValueMapChange, KernelComponent, KernelCube, KernelPartList, KernelVector3, UiKernelParameter, UiPossibleChild, UiPossibleChildTag } from '../../../typings/kernel';
+import type { UIIntersection } from '../utils/ui-intersection-helper';
+import type { RAPI_PATHS } from '../../../common-core/src/rapi-access';
+import type { ConfigurationHash, RapiId, RapiTagForUi } from '../../../typings/rapi-types';
+import { UiCallback } from '../../../common-core/src/utils/ui-callback';
+import type { ConfiguratorKernelContainer } from '../../../typings/configurator-kernel-container';
+import type { PlannerKernelContainer } from '../../../typings/planner-kernel-container';
+import type { RoomleComponent } from '../../../common-core/src/webgl/roomle-component-factory';
+import type { ConfiguratorDebugCallbacks } from '../configurator-debug-api';
+export type ComponentAction = 'edit' | 'add';
+export type ComponentType = 'preview' | 'component';
+export interface UIComponentInfo {
+    id: number;
+    position: {
+        x: number;
+        y: number;
+        z: number;
+    };
+    type: ComponentType;
+    actions: ComponentAction[];
+}
+export default class ConfiguratorUiCallbacks extends UiCallback implements ConfiguratorDebugCallbacks {
+    /**
+     * When kernel initialization is complete
+     */
+    onKernelIsReady: () => void;
+    /**
+     * gets called when the screen position of components/previews changes
+     * @param positions
+     */
+    onComponentPositionsUpdated: (positions: UIComponentInfo[]) => void;
+    /**
+     * When component parameters are changed/updated, this event is triggered
+     * on start up and when a configuration changes
+     * @param parameters
+     */
+    onUpdateParameters: (parameters: UiKernelParameter[]) => void;
+    /**
+     * When children of a component change, this event is triggered
+     * on start up and when a configuration changes
+     * @param tags
+     * @param defaultChild
+     */
+    onUpdatePossibleChildren: (tags: UiPossibleChildTag[], defaultChild: UiPossibleChild) => void;
+    /**
+     * When the price of a configuration/item changes, this event is triggered
+     * on start up and when a configuration changes
+     * @param currencySymbol
+     * @param price
+     */
+    onUpdatePrice: (currencySymbol: string, price: number) => void;
+    /**
+     * When a/another (different) component has been selected
+     * @param selectionMode
+     * @param isRoot
+     * @param hasChildren
+     * @param components
+     */
+    onSelectionChange: (selectionMode: string, isRoot: boolean, hasChildren: boolean, components: KernelComponent[]) => void;
+    /**
+     * When a component or item selection has been canceled
+     */
+    onSelectionCancel: () => void;
+    /**
+     * When part list has been changed/updated, this event is triggered
+     * on start up and when a configuration changes
+     * @param partList
+     * @param hash
+     */
+    onPartListUpdate: (partList: KernelPartList, hash: ConfigurationHash) => void;
+    /**
+     * When the bounds of the object are changed/updated, this event is triggered
+     * on start up and when a configuration changes
+     * @param bounds
+     */
+    onBoundsUpdate: (bounds: {
+        width: string;
+        height: string;
+        depth: string;
+        kernelBounds: KernelCube;
+    }) => void;
+    /**
+     * When a new item or configuration is loading, this can be useful to display loading screens etc
+     */
+    onLoadConfiguration: () => void;
+    /**
+     * When configuration has been loaded completely, this can be useful to hide loading indicators
+     * @param partList
+     * @param hash
+     * @param rootComponentLabel
+     */
+    onConfigurationReady: (partList: KernelPartList, hash: ConfigurationHash, rootComponentLabel: string) => void;
+    /**
+     * When UI should show the overlay based on the selected tag. Gets triggered when {@link @roomle/web-sdk/configurator-core/src/utils/shims#CommonInitData.startTag} is set
+     * @param tag
+     */
+    onOpenTag: (tag: RapiTagForUi) => void;
+    /**
+     * When UI should show add ons
+     */
+    onOpenAddOns: () => void;
+    /**
+     * When the user clicks on no UI element, can be used to deselect
+     */
+    onClickOutside: () => void;
+    /**
+     * Is triggered when {@link @roomle/web-sdk/configurator-core/src/roomle-configurator#RoomleConfigurator.previewDockings} has no available dockings
+     */
+    onNoDockingsAvailable: () => void;
+    /**
+     * When the configuration overlaps the UI (defined by {@link @roomle/web-sdk/configurator-core/src/configurator-interfaces#CanvasOffset})
+     * @param intersections
+     */
+    onUiIntersectionChange: (intersections: UIIntersection[]) => void;
+    /**
+     * When the zoom level has been changed by the user
+     * @param minZoom true when zoomed out as far as possible
+     * @param maxZoom true when zoomed in as much as possible
+     */
+    onZoomChange: (minZoom: boolean, maxZoom: boolean) => void;
+    /**
+     * When the use clicks on a configurable element twice to zoom the camera onto said element.
+     * Doesn't matter if triggered by the user or via SDK
+     */
+    onZoomToComponent: () => void;
+    /**
+     * When the visibility of the dimensions changes from visible to gone or vice versa.
+     * Doesn't matter if triggered by the user or via SDK
+     * @param visible
+     */
+    onDimensionsVisibilityChange: (visible: boolean) => void;
+    /**
+     * When not connected to the internet
+     * @param error
+     */
+    onErrorDueToOffline: (error: Error) => void;
+    /**
+     * When any generic error is thrown while requesting data
+     * @param error
+     */
+    onError: (error: Error) => void;
+    /**
+     * Fires after an element has been docked
+     * @param component the child component that was docked to the parent component
+     * @param id the runtime id of the child component
+     */
+    onElementDocked: (component: KernelComponent, id: number) => void;
+    /**
+     * When dockings/ghosts are no longer visible
+     */
+    onDockingsPreviewRemoved: () => void;
+    /**
+     * Updates when the current configuration changes
+     * @param hasChildren
+     */
+    onConfigurationHasChildren: (hasChildren: boolean) => void;
+    /**
+     * This method is used to track timings, this can be helpful to identify performance bottel necks
+     * @hidden
+     * @param category
+     * @param label
+     * @param time
+     * @param meta
+     */
+    onTrackTiming: (category: string, label: string, time: number, meta: object) => void;
+    /**
+     * When a dock component call has been completed
+     * @param childDbId the database id of the component which is docked
+     * @param childDockId the number of the dock position
+     * @param parentDbId the database id of the component to which is docked
+     * @param parentDockId the number of the dock position to which is docked
+     * @param position vector where the dock is done can be null
+     */
+    onUserInitiatedDockDone: (childDbId: RapiId, childDockId: number, parentDbId: RapiId, parentDockId: number, position: KernelVector3) => void;
+    /**
+     * When user hovers over an addon plus symbol
+     */
+    onAddonPlusHover: () => void;
+    /**
+     * When user hovers over an addon plus symbol
+     */
+    onAddonPlusHoverOff: () => void;
+    /**
+     * When all addon plus symbols are shown in the user interface
+     */
+    onAddonPlusShown: () => void;
+    /**
+     * When all addon plus symbols are hidden in the user interface
+     */
+    onAddonPlusHidden: () => void;
+    /**
+     * When an asset could not be loaded (for example an image or texture). See paths or ids to identify the problem.
+     * @param data
+     */
+    onContentProblem: (data: {
+        rapiPath: RAPI_PATHS;
+        ids: RapiId[];
+        message: string;
+    }) => void;
+    /**
+     * When a sync has been started
+     */
+    onSyncStarted: () => void;
+    /**
+     * When a previously requested sync has been completed
+     */
+    onSyncDone: () => void;
+    /**
+     * When UI should show floor material selection
+     */
+    onOpenFloorMaterials: () => void;
+    /**
+     * When UI should show part list
+     */
+    onOpenPartList: () => void;
+    /**
+     * When a requested component could not be loaded from RAPI
+     * @param error
+     * @param id
+     */
+    onComponentLoadError: (error: Error, id: RapiId) => void;
+    /**
+     * Gets called when configuration/configurable-item could not be loaded
+     */
+    onConfigurationLoadError: () => void;
+    /**
+     * When {@link @roomle/web-sdk/configurator-core/src/roomle-configurator#RoomleConfigurator.changeTypeChangeTag} as been called and the sync has been started
+     * @param rapiId
+     */
+    onChangeTypeChangeTag: (rapiId: RapiId) => void;
+    /**
+     * When {@link @roomle/web-sdk/configurator-core/src/roomle-configurator#RoomleConfigurator.removeTypeChangeTag} as been called
+     * @param rapiId
+     */
+    onRemoveTypeChangeTag: (rapiId: RapiId) => void;
+    /**
+     * Gets called when a new item/configuration has been loaded
+     * @param catalogName
+     * @param rapiItemLabel
+     * @param rootComponentLabel
+     */
+    onConfigurationLabelChange: (catalogName: string, rapiItemLabel: string, rootComponentLabel: string) => void;
+    /**
+     * When kernel failed to load a mesh
+     */
+    onMemoryCorruption: () => void;
+    /**
+     * is called when the configurator kernel is ready. It returns the container and the instance
+     * @param kernelContainer
+     * @param kernelInstance
+     */
+    onConfiguratorKernelIsReady: (kernelContainer: ConfiguratorKernelContainer | PlannerKernelContainer, kernelInstance: ConfiguratorKernelClass) => void;
+    /**
+     * is called when the configuration is saved to our backend
+     */
+    onConfigurationSaved: (configurationHash: ConfigurationHash) => void;
+    /**
+     * called when camera position starts to change or is changing at the moment
+     */
+    onCameraPositionChanges: () => void;
+    /**
+     * gets called if history changes
+     * @param undo true if undo is possible
+     * @param redo true if redo is possible
+     */
+    onHistoryChange: (undo: boolean, redo: boolean) => void;
+    /**
+     * This function gets called when a selectable component on a configurable element has been clicked on.
+     * An equivalent function for component clicks is onClickElement in the roomle-planner-ui-callback.ts
+     * @param component RoomleComponent instance of the clicked component
+     */
+    onClickComponent: (component: RoomleComponent) => void;
+    /**
+     * This function gets called when an external mesh is requested
+     * @param meshId meshId
+     * @param quality number between 0 and 100
+     * @returns void
+     */
+    onRequestExternalMesh: (meshId: string, quality: number) => void;
+    /**
+     * This function gets called when a geometry is ready
+     * @param runtimeId number
+     * @returns void
+     */
+    onGeometryReady: (runtimeId: number) => void;
+    /**
+     * This function gets called when a geometry is not ready
+     * @param runtimeId
+     * @returns
+     */
+    onGeometryNotReady: (runtimeId: number) => void;
+    onValueMapChanged: (changes: DebugValueMapChange) => void;
+    constructor(creator: string);
+}

package/lib/definitions/packages/configurator-core/src/services/unit-formatter.d.ts

@@ -0,0 +1,46 @@
+import type { KernelParameter, KernelPartListParameter, UiKernelParameter } from '../../../typings/kernel';
+import type { Context } from '../../../common-core/src/di/context';
+export declare const MEASUREMENT_SYSTEM_STRING: {
+    IMPERIAL: string;
+    METRIC: string;
+};
+export default class UnitFormatter implements Context {
+    _creator_: string;
+    _actualUnitString: string;
+    private _actualMeasurementString;
+    private _initData;
+    private _plannerKernelAccess;
+    private _formatter;
+    private _actualUnit;
+    private _actualUnitStringType;
+    private _precision;
+    constructor(creator?: string);
+    init(kernelContainer: any): void;
+    private _initMeasurementSystemType;
+    private _initActualUnit;
+    private _getKernelUnitEnum;
+    private _initActualUnitStringType;
+    private _isFormatterReady;
+    formatAngleValueToUnitString(value: number, parameter: KernelParameter): string;
+    parseAngleValueFromUnitString(rotation: string): string;
+    parseValue(value: string, parameter: KernelParameter): string | number;
+    formatValueToUnitString(value: number, parameter: KernelParameter): string | number;
+    isParseableNumber(aString: string): boolean;
+    isParseableUnitString(aString: string, parameter: KernelParameter): boolean;
+    parseMMValueFromUnitString(aString: string, unitType: string): number;
+    parseNumber(aString: string): number;
+    formatNumber(aValue: number, digit?: number): string;
+    formatSquareMMValueToUnitString(aValue: number): string;
+    formatMMValueToUnitString(aValue: number, unitType?: string): string;
+    formatMMValueWithReqMaxLength(aValue: number, reqMaxSize: number): string;
+    private _formatParameterValue;
+    formatPartListParameter(parameter: KernelPartListParameter): void;
+    formatParameter(parameter: UiKernelParameter): void;
+    isInch(): boolean;
+    getActualUnitString(): string;
+    getActualMeasurementString(): string;
+    getUnitStringType(): string;
+    getPrecision(): number;
+    getAllowedDelta(): number;
+    setUnitInitData(unit: string, measurementSystem?: string): void;
+}

package/lib/definitions/packages/configurator-core/src/static-files/fonts.d.ts

@@ -0,0 +1,2 @@
+export { default as LATO_SUB_FILE_NAME } from '../../public/fonts/lato_regular_sub.json';
+export { default as LATO_FILE_NAME } from '../../public/fonts/lato_regular.json';

package/lib/definitions/packages/configurator-core/src/static-files/geometries.d.ts

@@ -0,0 +1 @@
+export { default as BANANA_FILE_NAME } from '../../public/geometry/banana.glb?url';

package/lib/definitions/packages/configurator-core/src/static-files/settings.d.ts

@@ -0,0 +1 @@
+export { default as DEFAULT_EXTERNAL_OBJECT_API_CONFIGURATION } from '../../public/settings/default-external-object-api-configuration.json';

package/lib/definitions/packages/configurator-core/src/static-files/textures.d.ts

@@ -0,0 +1 @@
+export { default as WHITE_WALL_TEXTURE_FILE_NAME } from '../../public/textures/white_wall_texture.jpg';

package/lib/definitions/packages/configurator-core/src/utils/async-dependency-loader.d.ts

@@ -0,0 +1,5 @@
+import type { Font } from 'three/examples/jsm/loaders/FontLoader.js';
+export default class AsyncDependencyLoader {
+    static loadFont(path: string): Promise<Font>;
+    private static _resolveAll;
+}

package/lib/definitions/packages/configurator-core/src/utils/async-helper.d.ts

@@ -0,0 +1,12 @@
+export declare const enum ASYNC_OPERATIONS {
+    COMPONENT_DEFINITION_LOADED = 0,
+    KERNEL_SERIALIZED_CONFIGURATION = 1,
+    KERNEL_PLAN_OBJECT_CONSTRUCTION_DONE = 2,
+    UI_RELOAD_CONFIGURATION = 3,
+    CONFIGURATION_LOADED = 4
+}
+export default class AsyncHelper {
+    static finishOperation(operationType: ASYNC_OPERATIONS, data?: any): void;
+    static failOperation(operationType: ASYNC_OPERATIONS, data: Error): void;
+    static waitFor(operationType: ASYNC_OPERATIONS, startCommand?: () => void): Promise<any>;
+}

package/lib/definitions/packages/configurator-core/src/utils/component-dimensioning-helper.d.ts

@@ -0,0 +1,17 @@
+import type { RoomleComponent } from '../../../common-core/src/webgl/roomle-component-factory';
+import type { Context } from '../../../common-core/src/di/context';
+import type { PerspectiveCamera } from 'three';
+export default class ComponentDimensioningHelper implements Context {
+    _creator_: string;
+    private _plannerKernelAccess;
+    private _camera;
+    private _activeComponents;
+    private _componentDimensioningsExist;
+    constructor(creator: string);
+    setCamera(camera: PerspectiveCamera): void;
+    add(component: RoomleComponent): boolean;
+    remove(component: RoomleComponent, remove?: boolean): Promise<void>;
+    hasComponentDimensions(): boolean;
+    reset(): Promise<void>;
+    invalidateDimensioningsCache(componentRuntimeId?: number): void;
+}

package/lib/definitions/packages/configurator-core/src/utils/component-dimensioning.d.ts

@@ -0,0 +1,35 @@
+import type { Dimensioning } from '../../../typings/kernel';
+import type { Position2 } from '../../../common-core/src/common-interfaces';
+import type { Box3 } from 'three';
+import { Object3D } from 'three';
+import type { Font } from 'three/examples/jsm/loaders/FontLoader';
+export default class ComponentDimensioning extends Object3D {
+    private _cacheHolder;
+    private _unitFormatter;
+    private _dimensioning;
+    private _center;
+    private _size;
+    private _origin;
+    private _font;
+    private _level;
+    private _line;
+    private _text;
+    private _plane;
+    private _lineMaterial;
+    private _planeMaterial;
+    private _textMaterial;
+    private _cameraPosition;
+    constructor(dimensioning: Dimensioning, boundingBox: Box3, font: Font, cameraPosition: Position2);
+    clone(): any;
+    private _initMaterials;
+    private _init;
+    private _getXEdge;
+    private _addXEdgeSideLines;
+    private _getZEdge;
+    private _addZEdgeSideLines;
+    private _getYEdge;
+    private _addYEdgeSideLines;
+    private _addLine;
+    private _addText;
+    private _getXSign;
+}

package/lib/definitions/packages/configurator-core/src/utils/component-raycast-helper.d.ts

@@ -0,0 +1,22 @@
+import { type RoomleComponent } from '../../../common-core/src/webgl/roomle-component-factory';
+import type ConfiguratorSceneEventHandler from '../webgl/configurator-scene-event-handler';
+import type ConfiguratorViewModel from '../../../common-core/src/view-model/configurator-view-model';
+import type { Object3D, PerspectiveCamera } from 'three';
+export default class ComponentRaycastHelper {
+    private _object;
+    private _camera;
+    private _raycaster;
+    private _nonTransparentComponent;
+    constructor();
+    init(object: Object3D, camera: PerspectiveCamera): void;
+    setCamera(camera: PerspectiveCamera): void;
+    setObject(object: Object3D): void;
+    changeMaterialsOnSelect(object: Object3D, component: RoomleComponent, selected?: boolean, callback?: () => void): void;
+    private _changeMaterialsOnSelect;
+    isComponentVisible(component: RoomleComponent): boolean;
+    checkComponentAndPreviewVisibility(sceneEventHandler: ConfiguratorSceneEventHandler, configuratorViewModel: ConfiguratorViewModel): void;
+    checkComponentVisibility(sceneEventHandler: ConfiguratorSceneEventHandler, configuratorViewModel: ConfiguratorViewModel): void;
+    areAllPreviewsVisible(configuratorViewModel: ConfiguratorViewModel): boolean;
+    areAllComponentsInFrustum(previews: RoomleComponent[]): boolean;
+    checkPreviewVisibility(configuratorViewModel: ConfiguratorViewModel): void;
+}

package/lib/definitions/packages/configurator-core/src/utils/configurator-history.d.ts

@@ -0,0 +1,47 @@
+import type { Context } from '../../../common-core/src/di/context';
+import type { ConfigurationString } from '../../../typings/rapi-types';
+export default class ConfiguratorHistory implements Context {
+    _creator_: string;
+    private _history;
+    private _index;
+    private _configuratorUiCallbacks;
+    constructor(creator: string);
+    /**
+     * loads the configurationString of the configuration which was set before
+     * only possible if there are some changes on the current item
+     * @returns configurationString of lastAction or null if canUndo returns false
+     */
+    undo(): ConfigurationString | null;
+    /**
+     * loads the configurationString of the configuration which was set before undo function was called
+     * only possible if undo function was called before
+     * @returns configurationString of configuration before undo was called or null if canRedo returns false
+     */
+    redo(): ConfigurationString | null;
+    /**
+     * pushes new configurationString to history Array
+     * is called when changes on the item happened
+     * @param configurationString
+     * @returns
+     */
+    push(configurationString: ConfigurationString): void;
+    /**
+     * checks if there are any changes on the item already happened
+     * @returns true if the current configuration is not the default configuration
+     */
+    canUndo(): boolean;
+    /**
+     * checks if there are newer configurations
+     * @returns true if current configuration is not the latest configuration
+     */
+    canRedo(): boolean;
+    /**
+     * @returns array of all configuration strings
+     */
+    getHistory(): string[];
+    /**
+     * clears history and make new empty history array
+     * sets index on 0 that no undo and redo is possible
+     */
+    clearHistory(): void;
+}

package/lib/definitions/packages/configurator-core/src/utils/dimensioning-helper.d.ts

@@ -0,0 +1,61 @@
+import { Object3D, type Scene } from 'three';
+import { Box3, Vector3 } from 'three';
+import { type KernelCube } from '../../../typings/kernel';
+export default class DimensioningHelper {
+    _creator_: string;
+    private _unitFormatter;
+    private _uiScene;
+    private _object;
+    private _objectRotation;
+    private _cameraPosition;
+    private _font;
+    private _onChange;
+    private _topDimensions;
+    private _initialized;
+    private _origin;
+    private _dimensions;
+    private _lineMaterial;
+    private _planeMaterial;
+    private _widthLine;
+    private _heightLine;
+    private _depthLine;
+    private _widthText;
+    private _heightText;
+    private _depthText;
+    private _enabled;
+    private _dimensionsVisible;
+    private _dimensionLineGroup;
+    private _dimensionTextGroup;
+    constructor(creator: string);
+    private _loaded;
+    private _performUpdate;
+    private _updateWidth;
+    private _updateHeight;
+    private _updateDepth;
+    updateSize(boxForMeasurement: KernelCube): void;
+    update(force?: boolean): void;
+    addToObject(object: Object3D): void;
+    removeFromObject(object: Object3D): void;
+    addToUiScene(uiScene: Scene): void;
+    removeFromUiScene(uiScene: Scene): void;
+    private _getWidthEdge;
+    private _getDepthEdge;
+    private _getHeightEdge;
+    onDimensionsVisibilityChanged(handler: (visible: boolean) => void): void;
+    enableTopDimensions(): void;
+    disableTopDimensions(): void;
+    enableDimensions(): void;
+    disableDimensions(): void;
+    private _visibilityChangedCallback;
+    _clear(): void;
+    getBoundingBox(): Box3;
+    private setVisibility;
+    moveCameraStart(position: Vector3): void;
+    moveCameraEnd(position: Vector3): void;
+    clearScene(_scene: Scene): void;
+    setObject(object: Object3D, rotation?: number): void;
+    setUiScene(uiScene: Scene): void;
+    isInitialized(): Promise<void>;
+    areDimensionsEnabled(): boolean;
+    private _getRotation;
+}

package/lib/definitions/packages/configurator-core/src/utils/error-messages.d.ts

@@ -0,0 +1,4 @@
+declare const _default: {
+    NO_MATERIAL_ID: string;
+};
+export default _default;

package/lib/definitions/packages/configurator-core/src/utils/event-dispatcher.d.ts

@@ -0,0 +1,16 @@
+type ListenerFunction<T> = (arg: T) => void;
+export interface Listener<T> {
+    key: number;
+    fun: ListenerFunction<T>;
+}
+export default class EventDispatcher<T> {
+    private _listeners;
+    private _disabled;
+    private _addEventListener;
+    addEventListener(eventName: number, callback: ListenerFunction<T>, scope: any): void;
+    dispatchEvent(eventName: number, arg?: T): void;
+    removeEventListener(eventName: number, fun: ListenerFunction<T>): void;
+    enableEvents(): void;
+    disableEvents(): void;
+}
+export {};

package/lib/definitions/packages/configurator-core/src/utils/global-definitions.d.ts

@@ -0,0 +1,8 @@
+import '../../../typings/global-definitions';
+import type RoomleConfigurator from '../roomle-configurator';
+declare global {
+    interface Window {
+        ConfiguratorKernel: any;
+        RoomleConfigurator: RoomleConfigurator;
+    }
+}

package/lib/definitions/packages/configurator-core/src/utils/indexeddb-adapter.d.ts

@@ -0,0 +1,9 @@
+import type { WasmDbEntry } from '../../../typings/kernel';
+export declare const NOT_FOUND_ERROR = "404";
+export default class IndexedDbAdapter {
+    static openDb(dbName: string, dbVersion: number, upgradeDbCallback: (this: IDBOpenDBRequest, ev: IDBVersionChangeEvent) => any): Promise<IDBDatabase>;
+    static getObjectStore(dbConnection: IDBDatabase, storeName: string, transactionMode: IDBTransactionMode): IDBObjectStore;
+    static getRecordFromObjectStore(dbConnection: IDBDatabase, storeName: string, recordId: string): Promise<WasmDbEntry>;
+    static deleteRecordFromObjectStore(dbConnection: IDBDatabase, storeName: string, recordId: string): Promise<void>;
+    static saveRecordToObjectStore(dbConnection: IDBDatabase, storeName: string, objRecord: WasmDbEntry): Promise<void>;
+}

package/lib/definitions/packages/configurator-core/src/utils/injectables.d.ts

@@ -0,0 +1,2 @@
+import { DependencyInjectionAssignment } from '../../../common-core/src/di/container';
+export declare const INJECTABLES: DependencyInjectionAssignment[];

package/lib/definitions/packages/configurator-core/src/utils/parameter-helper.d.ts

@@ -0,0 +1,14 @@
+import type { KernelParameter, KernelPartListParameter } from '../../../typings/kernel';
+export declare const enum PARAMETER_UI_TYPES {
+    RANGE = "Range",
+    BOOLEAN = "Boolean",
+    MATERIAL = "Material",
+    OPTIONS = "Options",
+    THUMBNAILS = "Thumbnails"
+}
+export declare const isRange: (parameter: KernelParameter) => boolean;
+export declare const isOptions: (parameter: KernelParameter) => boolean;
+export declare const hasUnits: (parameter: KernelParameter | KernelPartListParameter) => boolean;
+export declare const isThumbnail: (parameter: KernelParameter) => boolean;
+export declare const isBoolean: (parameter: KernelParameter) => boolean;
+export declare const isMaterial: (parameter: KernelParameter | KernelPartListParameter) => boolean;