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

package/lib/definitions/packages/common-core/src/lightsetting/dynamic-light-setting.d.ts

@@ -0,0 +1,26 @@
+import LightSetting from './light-setting';
+import type { SceneSettings } from '../scene-settings-loader';
+import type { Box3, PerspectiveCamera, Scene } from 'three';
+import { Vector3 } from 'three';
+export default class DynamicLightSetting extends LightSetting {
+    private _lights;
+    private _cameraLight;
+    private _boundingSize;
+    private _dynamicLightSettingLoader;
+    constructor(scene: Scene, oldLightSetting?: LightSetting);
+    needsBounds(): boolean;
+    updateBounds(bounds: Box3): void;
+    loadFromJSON(json: string): Promise<void>;
+    loadFromObject(sceneSettings: SceneSettings): Promise<void>;
+    loadFromURL(url: string): Promise<void>;
+    addToScene(): void;
+    update(camera: PerspectiveCamera, target: Vector3): void;
+    removeFromScene(): void;
+    reload(): void;
+    showGUI(): void;
+    private _addToGUI;
+    private _addRectAreaLightToGUI;
+    private _addSpotLightToGUI;
+    private _addAmbientLightToGUI;
+    private _addDirectionalLightToGUI;
+}

package/lib/definitions/packages/common-core/src/lightsetting/light-setting.d.ts

@@ -0,0 +1,14 @@
+import type { Box3, Scene } from 'three';
+import { Object3D } from 'three';
+export default abstract class LightSetting {
+    protected _scene: Scene;
+    private _cameraContainer;
+    constructor(scene: Scene, oldLightSetting?: LightSetting);
+    needsBounds(): boolean;
+    updateBounds(_bounds: Box3): void;
+    abstract addToScene(): void;
+    abstract removeFromScene(): void;
+    abstract reload(): void;
+    abstract showGUI(): void;
+    getCameraContainer(): Object3D;
+}

package/lib/definitions/packages/common-core/src/logger.d.ts

@@ -0,0 +1,6 @@
+export default class Logger {
+    info(...args: any[]): void;
+    log(...args: any[]): void;
+    warn(...args: any[]): void;
+    error(...args: any[]): void;
+}

package/lib/definitions/packages/common-core/src/main.d.ts

@@ -0,0 +1,107 @@
+import type { AppState } from './utils/app-context';
+import type { LifeCycleCallbacks } from './life-cycle-manager';
+import type RapiAccess from './rapi-access';
+import type { CanvasOffset } from './common-interfaces';
+import type UnitFormatter from '../../configurator-core/src/services/unit-formatter';
+import type { Scene } from 'three';
+import type IdbManager from './services/idb-manager';
+import type { GlobalCallback } from './services/global-callback';
+export interface EnvMapParams {
+    /**
+     * url of the env map (exr or hdr)
+     */
+    url?: string;
+    /**
+     * intensity of the env map (brightness of the scene). recommended value between 0.5 and 2
+     */
+    intensity?: number;
+    /**
+     * rotation of the environment map, influences also shadow direction
+     */
+    rotation?: number;
+    /**
+     * maximum number of light sources (and thus shadows) extracted form the env map
+     */
+    maxLightSources?: number;
+}
+export interface GlobalAPI {
+    updateSize(): void;
+    getMain(): Main;
+    /**
+     * Returns the three.js scene (https://threejs.org/docs/#api/en/scenes/Scene)
+     * WARNING: This is the actual scene (reference) and not a copy!
+     */
+    getScene(): Scene;
+    /**
+     * Updates the scene (recalculating bounds) and restart rendering
+     */
+    updateScene(): void;
+    /**
+     * Sets the available screen space for our item
+     * Example 1: right 0.9 means 10% padding on the right side
+     * Example 2: bottom 0.2 means 20% padding on the bottom side
+     * default: 'left: 0, top: 1, right: 1, bottom: 0'
+     * @param offset
+     */
+    setCameraOffset(offset: CanvasOffset): void;
+    /**
+     * Gets the available screen space for our item
+     * default: 'left: 0, top: 1, right: 1, bottom: 0'
+     */
+    getCameraOffset(): CanvasOffset;
+    getUnitFormatter(): UnitFormatter;
+    getStorage(): IdbManager;
+    setEnvironmentMap(params: EnvMapParams): void;
+    get globalCallbacks(): GlobalCallback;
+}
+/**
+ * Shared API between configurator and planner
+ */
+export interface RubensAPI {
+    resetCameraPosition(): void;
+    exportImageFromCamera(): Promise<void>;
+    exportCanvasScreenshot(quality?: number): Promise<string>;
+    enableMultiselect(): void;
+    getStorage(): IdbManager;
+}
+export interface ExternalEmbeddable<T = any> {
+    callbacks: T;
+}
+export interface KernelUtilityForUi {
+    getRuntimeComponentIdOfRootComponent(planObjectId?: number): number;
+}
+export declare const enum BASE_CONTEXT {
+    CONFIGURATOR = "configurator",
+    PLANNER = "planner",
+    GLB_VIEWER = "glb-viewer",
+    MATERIAL_VIEWER = "material-viewer",
+    TOOLS_CORE = "tools-core"
+}
+export default abstract class Main implements LifeCycleCallbacks {
+    protected _context: string;
+    protected abstract setupGlobals(settings?: AppState): void;
+    protected abstract setupDependencies(): void;
+    protected abstract cleanUpGlobals(): void;
+    protected abstract cleanUpDependencies(): void;
+    protected abstract bootFinished(): void;
+    protected abstract getContextName(): string;
+    abstract getApi(): ExternalEmbeddable;
+    constructor(creator?: string);
+    private _setupCommonGlobals;
+    private _setupCommonDependencies;
+    private _cleanUpCommonGlobals;
+    private _cleanUpCommonDependencies;
+    boot(settings?: object): void;
+    protected lookup<T>(specifier: string, context?: string): T;
+    teardown(): void;
+    pause(): void;
+    resume(element?: HTMLElement): void;
+    destroy(): void;
+    /**
+     * returns the instance of the rapi access so that
+     * the user of the SDK can fetch data from the Roomle backend
+     * @params none
+     * @return RapiAccess
+     */
+    getRapiAccess(): RapiAccess;
+}

package/lib/definitions/packages/common-core/src/network-layer.d.ts

@@ -0,0 +1,15 @@
+import type { AssetUrl } from '../../typings/rapi-types';
+type NetworkResponseValidator = (response: Response) => Promise<boolean>;
+export interface NetworkRequestValidations {
+    checkResponse?: NetworkResponseValidator;
+}
+export default class NetworkLayer {
+    private _queue;
+    private _pendingRequests;
+    private _nextSlot;
+    private _fetch;
+    fetch(request: Request | AssetUrl, options?: {
+        [key: string]: string;
+    }, checks?: NetworkRequestValidations): Promise<any>;
+}
+export {};

package/lib/definitions/packages/common-core/src/rapi-access.d.ts

@@ -0,0 +1,184 @@
+import type { Base64Image } from './common-interfaces';
+import type { RoomleError } from './error-handler';
+import type { SHORT_TYPES } from './utils/url-shortener';
+import type { Base64String, MAIL_TYPE, PriceId, RapiAdditionalContent, RapiAuth, RapiCatalog, RapiComponent, RapiConfiguration, RapiConfiguratorSettings, RapiId, RapiItem, RapiJson, RapiMaterial, RapiMaterialGroup, RapiMesh, RapiMeshData, RapiPackage, RapiPlan, RapiPlanSnapshotGetData, RapiPlanSnapshotId, RapiPlanSnapshotPostData, RapiPrice, RapiShortId, RapiSkin, RapiTag, RapiTenant, RapiTexture, UserAction } from '../../typings/rapi-types';
+import type { Context } from './di/context';
+export declare const MAX_URL_LENGTH = 1500;
+export declare const MESH_DEFAULT_FORMAT = "crt";
+export declare const MESH_DEFAULT_QUALITY = 50;
+type HttpVerbGet = 'GET';
+type HttpVerbPost = 'POST';
+type HttpVerbPut = 'PUT';
+export type ImageKeysOnObject = 'perspectiveImage' | 'topImage';
+export interface FetchOptions {
+    id?: RapiId;
+    method?: HttpVerbGet | HttpVerbPost | HttpVerbPut;
+    data?: RapiJson | Base64String;
+    resolve?: (data: RapiJson) => void;
+    reject?: (error: RoomleError) => void;
+    accept?: string;
+    contentType?: string;
+    additionalHeaders?: {
+        [key: string]: string | number;
+    };
+    filterKey?: string;
+    cacheKey?: string;
+    pathSuffix?: string;
+    embed?: RAPI_PATHS[];
+}
+export type ExternalResponseValidator = (type: 'rapi-access', response: Response) => Promise<boolean>;
+export declare const isPlanSnapshotId: (id: string | RapiId) => id is `ps_${string}`;
+export declare const LEGACY_GROUP_INDICATOR: string;
+export declare const RAPI_PATH_KEY = "__rapi_path__";
+export declare const enum RAPI_PATHS {
+    COMPONENTS = "components",
+    TEXTURES = "textures",
+    MESHES = "meshes",
+    MATERIALS = "materials",
+    CONFIGURATIONS = "configurations",
+    ITEMS = "items",
+    TAG = "tags",
+    PACKAGE = "package",
+    PRELOAD = "preloads/components",
+    SHORT_IDS = "shortIds",
+    CATALOGS = "catalogs",
+    PLANS = "plans",
+    ITEM_ADDITIONAL_CONTENTS = "itemAdditionalContents",
+    TENANT_ME = "tenants/me",
+    TENANT = "tenants",
+    SKIN = "skins",
+    PRICE = "prices",
+    CATALOG_MESHES = "catalogMeshes",
+    CONFIGURATORS = "configurators",
+    USER_ACTIONS = "userActions",
+    AUTH = "auth",
+    PLAN_SNAPSHOTS = "planSnapshots"
+}
+export declare const validateParams: (params?: Record<string, string | string[]>) => Record<string, string | string[]> | boolean;
+export default class RapiAccess implements Context {
+    _creator_: string;
+    private _formDataUtil;
+    private _errorHandler;
+    private _dataSyncer;
+    private _networkLayer;
+    private _localStorage;
+    private _globalInitData;
+    private _globalCallback;
+    private _itemLoaded;
+    private _currentToken;
+    constructor(creator: string);
+    getPreloadForItem(id: RapiId): Promise<void>;
+    getPreloadForConfiguration(id: RapiId): Promise<void>;
+    private _getPreload;
+    changeUseOfHDGeometry(): void;
+    getHSCPackage(id: RapiId): Promise<RapiPackage | void>;
+    getComponent(id: RapiId): Promise<RapiComponent>;
+    getConfiguration(id: RapiId): Promise<RapiConfiguration>;
+    getConfigurations(ids: RapiId[]): Promise<RapiConfiguration[]>;
+    getItem(id: RapiId): Promise<RapiItem>;
+    getComponents(ids: RapiId[]): Promise<RapiComponent[]>;
+    getItems(ids: RapiId[]): Promise<RapiItem[]>;
+    getTag(id: RapiId): Promise<RapiTag>;
+    getTags(ids: RapiId[]): Promise<RapiTag[]>;
+    getTexture(id: RapiId): Promise<RapiTexture>;
+    getCatalog(id: RapiId): Promise<RapiCatalog>;
+    getMesh(id: RapiId, format?: string, quality?: number): Promise<RapiMeshData>;
+    getMeshesOfCatalog(catalogId: RapiId): Promise<RapiMesh[]>;
+    getTexturesOf(rapiJson: RapiJson): Promise<RapiTexture[]>;
+    getItemsOf(rapiJson: RapiJson): Promise<RapiItem[]>;
+    getMaterialsOf(rapiJson: RapiJson): Promise<RapiMaterial[]>;
+    getComponentsOf(rapiJson: RapiJson): Promise<RapiComponent[]>;
+    getAdditionalContentsOfItems(rapiItems: RapiItem[]): Promise<RapiAdditionalContent[]>;
+    getMaterial(id: RapiId): Promise<RapiMaterial>;
+    peekMaterial(id: RapiId): RapiMaterial;
+    peekComponent(id: RapiId): RapiComponent;
+    peekItem(id: RapiId): RapiItem;
+    peekConfiguration(id: RapiId): RapiConfiguration;
+    getMaterials(ids: RapiId[]): Promise<RapiMaterial[]>;
+    getPlan(id: RapiId): Promise<RapiPlan>;
+    getPlanSnapshot(id: RapiPlanSnapshotId): Promise<RapiPlanSnapshotGetData>;
+    static clearCaches(): void;
+    cleanUp(): void;
+    getMaterialsByGroup(groupIdsToCheck: RapiId[]): Promise<RapiMaterialGroup[]>;
+    private _flushOfflineQueue;
+    private _setQueuedConfiguration;
+    saveConfiguration(configuration: RapiConfiguration): Promise<RapiConfiguration>;
+    getShortUrl(referencedId: RapiId, type: SHORT_TYPES): Promise<RapiShortId>;
+    resolveShortUrl(id: string): Promise<RapiShortId>;
+    private _peekData;
+    private _createAssetsFormData;
+    saveConfigurationImage(configuration: RapiConfiguration, image1: Base64Image | null, type1: ImageKeysOnObject | null, image2: Base64Image | null, type2: ImageKeysOnObject | null): Promise<RapiConfiguration>;
+    savePlanSnapshotImage(planSnapshot: RapiPlanSnapshotPostData, image1: Base64Image, type1: ImageKeysOnObject, image2: Base64Image, type2: ImageKeysOnObject): Promise<RapiPlanSnapshotGetData>;
+    private _markConfigurationAsLocally;
+    private _save;
+    combineMaterialsToGroups(materials: RapiMaterial[]): Promise<RapiMaterialGroup[]>;
+    private _getByIds;
+    private _getByIdsPackets;
+    private _getByIdsSingle;
+    private _getById;
+    private _get;
+    private _fetchJson;
+    private _fetch;
+    private _createHeaders;
+    private _handleJson;
+    private _prepareEmbeddedData;
+    private _getCache;
+    private _getErrorCache;
+    private _getCacheFrom;
+    private _setCache;
+    private _prepareData;
+    private _getRelationsCacheFor;
+    private _prepareGroups;
+    private _handleError;
+    private _getRelationData;
+    private _prepareRelationalData;
+    private _notifyWaiters;
+    private _tenantMe;
+    /**
+     * Returns info about the tenant with the provided ID. If the ID is not set it tries to use the current tenant.
+     * @param tenantId
+     */
+    getTenant(tenantId?: number): Promise<RapiTenant>;
+    getCurrentSkin(): Promise<RapiSkin>;
+    getPrices(pricesIds: PriceId[]): Promise<RapiPrice[]>;
+    getConfiguratorSettings(id: RapiId): Promise<RapiConfiguratorSettings>;
+    sendUserAction(userAction: UserAction): Promise<RapiJson>;
+    private _share;
+    /**
+     * Export a configuration or plansnapshot id into a given file format and send it via email
+     * Shares a configuration id using email
+     * @param id
+     * @param email
+     * @param type the email template to use
+     * @param urlParams - URL parameters to include in the request (key-value pairs) of the current configuration settings.
+     */
+    shareConfiguration(id: RapiId, email: string, type: MAIL_TYPE, urlParams?: Record<string, string | string[]>): Promise<unknown>;
+    /**
+     * Shares a sharePlanSnapshot id using email
+     * @param id
+     * @param email
+     * @param type the email template to use
+     * @param urlParams - URL parameters to include in the request (key-value pairs) of the current planner settings.
+  
+     */
+    sharePlanSnapshot(id: RapiId, email: string, type: MAIL_TYPE, urlParams?: Record<string, string | string[]>): Promise<unknown>;
+    /**
+     * Export a configuration id into a given file format and send it via email
+     * @param id
+     * @param email
+     * @param fileFormat check API documentation for valid formats
+     */
+    export3D(id: RapiId, email: string, fileFormat: string, options?: object): Promise<unknown>;
+    trackView(id: string): Promise<void>;
+    signinUser(email: string, password: string): Promise<RapiAuth>;
+    signoutUser(token: string): Promise<void>;
+    savePlan(plan: RapiPlan): Promise<RapiPlan>;
+    savePlanSnapshot(planSnapshot: RapiPlanSnapshotPostData): Promise<RapiPlanSnapshotGetData>;
+    setCurrentToken(token: string): void;
+    removeCurrentToken(): void;
+    createNewPlan(): RapiPlan;
+    updateCache(rapiPath: RAPI_PATHS, data: RapiJson & {
+        id: RapiId;
+    }): void;
+}
+export {};

package/lib/definitions/packages/common-core/src/roomle-sdk.d.ts

@@ -0,0 +1,45 @@
+import type { Configurator } from '../../configurator-core/src/configurator';
+import type { Planner } from '../../planner-core/src/planner';
+import type { GlbViewer } from '../../glb-viewer-core/src/glb-viewer';
+import type { MaterialViewer } from '../../material-viewer/src/material-viewer';
+import RapiAccess from './rapi-access';
+import type { GlobalInitDataDefinition, InitDataDefinition } from './utils/shims';
+import { GlobalCallback } from './services/global-callback';
+import type { ToolsCore } from '../../tools-core/src/tools-core';
+export default class RoomleSdk {
+    static getConfigurator(initData?: InitDataDefinition, context?: string): Promise<Configurator>;
+    static getPlanner(initData?: InitDataDefinition, context?: string): Promise<Planner>;
+    static getGlbViewer(initData?: InitDataDefinition, context?: string): Promise<GlbViewer>;
+    static getMaterialViewer(initData?: InitDataDefinition, context?: string): Promise<MaterialViewer>;
+    static getCoreTools(initData?: InitDataDefinition, context?: string): Promise<ToolsCore>;
+    /**
+     * Get a rapi access instance
+     * If you want to set used locale or tenant you have to call setGlobalInitData first
+     */
+    static getRapiAccess(): Promise<RapiAccess>;
+    /**
+     * Get the global callback instance
+     * this is helpful if you want to listen to callbacks which are triggered
+     * globally, e.g.: onNetworkRequest
+     */
+    static get callbacks(): Promise<GlobalCallback>;
+    /**
+     * Set global init data params like locale or tenant
+     * @param initData
+     */
+    static setGlobalInitData(globalInitData: GlobalInitDataDefinition): void;
+    /**
+     * Pass in the desired context name and you'll get back a unique context name which does not exist yet.
+     * @param contextName
+     */
+    static getContext(contextName: string): string;
+    /**
+     * Sets up dependency injection and adds init data. if init data is not set it will return undefined.
+     * This means the context will be set in the instantiated classes.
+     * @param contextName
+     * @param initData
+     * @param context
+     * @private
+     */
+    private static _setupDI;
+}

package/lib/definitions/packages/common-core/src/scene-settings-loader.d.ts

@@ -0,0 +1,8 @@
+import type { EnvironmentSetting } from './environment/dynamic-environment-setting-loader';
+import type { DynamicLight } from './lightsetting/dynamic-light-setting-loader';
+export interface SceneSettings {
+    environment: EnvironmentSetting;
+    lights: DynamicLight[];
+}
+export default class SceneSettingsLoader {
+}

package/lib/definitions/packages/common-core/src/script-loader.d.ts

@@ -0,0 +1,15 @@
+import type { Context } from './di/context';
+export interface ScriptData {
+    name: string;
+    id: string;
+}
+export default class ScriptLoader implements Context {
+    _creator_: string;
+    private _singlePromiseFactory;
+    constructor(creator: string);
+    fetch(url: string, options: {
+        id: string;
+    }): Promise<unknown>;
+    loadScripts(scripts: ScriptData[]): Promise<any[]>;
+    cleanUp(): void;
+}

package/lib/definitions/packages/common-core/src/services/cache-holder.d.ts

@@ -0,0 +1,11 @@
+import type { RoomleComponent } from '../webgl/roomle-component-factory';
+import type { BufferGeometry, Material } from 'three';
+export default class CacheHolder {
+    private _componentCache;
+    private _geometryCache;
+    private _materialCache;
+    get componentCache(): Map<string, RoomleComponent>;
+    get geometryCache(): Map<string, BufferGeometry>;
+    get materialCache(): Map<string, Material>;
+    clear(): void;
+}

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

@@ -0,0 +1,131 @@
+import type RapiAccess from '../rapi-access';
+import type ScriptLoader from '../script-loader';
+import type KernelIo from '../kernel-io';
+import type DataSyncer from './data-syncer';
+import type { ArticleNumber, ConfigurationHash, RapiConfiguration, RapiId, RapiPrice } from '../../../typings/rapi-types';
+import type { LifeCycleCallbacks } from '../life-cycle-manager';
+import type { Context } from '../di/context';
+import type { AssetRequest, AssetType, ConfigurationExporter, ConfiguratorKernelClass, KernelComponent, KernelMeshAttributes, KernelMeshBuffer, KernelPart, KernelPartList, KernelPartListPrice, KernelVector3 } from '../../../typings/kernel';
+import type ConfiguratorUiCallbacks from '../../../configurator-core/src/services/configurator-ui-callback';
+import type { GlobalCallback } from './global-callback';
+import type InitData from '../utils/init-data';
+import type UnitFormatter from '../../../configurator-core/src/services/unit-formatter';
+import type ConfiguratorContext from '../webgl/configurator-context';
+import type GlobalInitData from '../utils/global-init-data';
+import type { ConfiguratorKernelCallbackI } from '../configurator-kernel-access';
+export declare const enum KERNEL_TYPE {
+    PLANNER = 0,
+    CONFIGURATOR = 1
+}
+interface SubComponentWaiter {
+    parentId: number;
+    partId: number;
+}
+export declare const USE_DELTA_COMPONENT_UPDATES = true;
+export default abstract class CommonKernelAccess implements LifeCycleCallbacks, Context {
+    _creator_: string;
+    protected _rapiAccess: RapiAccess;
+    protected _scriptLoader: ScriptLoader;
+    protected _kernelIo: KernelIo;
+    protected _dataSyncer: DataSyncer;
+    private _lifeCycleManager;
+    private _requestedItemIds;
+    private _requestedMaterialIds;
+    protected _configuratorUiCallbacks: ConfiguratorUiCallbacks;
+    protected _globalCallback: GlobalCallback;
+    protected _initData: InitData;
+    protected _unitFormatter: UnitFormatter;
+    protected _configuratorContext: ConfiguratorContext;
+    protected _globalInitData: GlobalInitData;
+    protected _lastPartListHash: string;
+    protected _configuratorKernelCallbackListener: Set<ConfiguratorKernelCallbackI>;
+    protected _cachedGroupIds: string[];
+    protected _waitingForGroups: boolean;
+    /**
+     *
+     * !!!WARNING!!!
+     *
+     * @todo check if this can become a problem if we tell
+     *       the minifier to mangle properties stargin with _
+     *       see the discussion at https://gitlab.com/roomle/roomle-threejs/merge_requests/401#note_143575143
+     *
+     * not sure if we can prefix protected methods with _
+     * the leading _ was done for minification purpose, because
+     * JS minifier do not know the visibility of TypeScript
+     * therefore they do not mangle class properties because they
+     * do not know if a property is public or private, but you can
+     * tell the minifier that everything with a certain prefix is
+     * private and then they mangle these class properties. I'm not
+     * sure if minification breaks the app if property names of the
+     * abstract class are mangled! We have to check this! Currently
+     * we us the minifier called terser
+     *
+     * !!!WARNING!!!
+     *
+     */
+    protected _kernelType: KERNEL_TYPE;
+    protected _kernelInstance: ConfiguratorKernelClass;
+    protected _configurationExporter: ConfigurationExporter;
+    protected _kernelContainer: any;
+    protected _subComponentsWaiters: Map<RapiId, SubComponentWaiter[]>;
+    protected _shouldWait: boolean;
+    protected _kernelPath: string;
+    protected _useWASM: boolean;
+    protected _utilityToLongArray(longArray: number[]): any;
+    protected abstract onLoadComponentError(error: Error, id: RapiId): void;
+    constructor(creator: string);
+    protected init(kernelType: KERNEL_TYPE): void;
+    protected _initKernel(): void;
+    get kernelContainer(): any;
+    get kernelInstance(): ConfiguratorKernelClass;
+    get configurationExporter(): ConfigurationExporter;
+    private _setupKernelPaths;
+    private _setupEmsModule;
+    private _passSubComponentsToKernel;
+    private _fetchSubComponents;
+    private _flushSubComponentsWaiters;
+    protected isReady(): void;
+    protected addDebugInfo(): void;
+    getConfigurationData(planObjectId: number): Promise<RapiConfiguration>;
+    requestAssets(requestedAssets: AssetRequest[]): void;
+    loadComponent(componentIds: string[]): void;
+    loadItemConfigurations(itemIds: string[]): Promise<void>;
+    requestDeleteComponent(componentId: number): void;
+    dockComponentWithPosition(parentId: number, parentDockId: number, childId: number, childDockId: number, position: KernelVector3): void;
+    Editor3dAddMesh(runtimeComponentId: number, meshId: number, geometryName: string, environmentGeometry: boolean, meshAttributes: KernelMeshAttributes, meshBuffer: KernelMeshBuffer): void;
+    Editor3ChangedMesh(runtimeComponentId: number, meshId: number, geometryName: string, meshAttributes: KernelMeshAttributes): void;
+    Editor3dRemoveMesh(runtimeComponentId: number, meshId: number): void;
+    Editor3dBeginConstruction(id: number, isDeltaUpdate: boolean): void;
+    Editor3dEndConstruction(id: number): void;
+    Editor3dComponentCreated(id: number, position: KernelVector3, eulerAngles: KernelVector3, isRootComponent: boolean, parentObjectRuntimeId: number): void;
+    Editor3dComponentDocked(componentId: number, isRootComponent: boolean, parentId: number, componentPosition: KernelVector3, componentRotation: KernelVector3): void;
+    Editor3dGeometryReady(id: number): void;
+    Editor3dGeometryNotReady(id: number): void;
+    componentDeleted(componentId: number): void;
+    componentMetaUpdated(componentId: number): void;
+    sceneCleared(): void;
+    requestMaterialsInGroup(groupIds: string[]): void;
+    requestPlanComponentConstruction(id: number, useDeltaUpdates?: boolean): void;
+    addConfiguratorListener(listener: ConfiguratorKernelCallbackI): void;
+    removeConfiguratorListener(listener: ConfiguratorKernelCallbackI): void;
+    cleanUpCallbacks(): void;
+    requestMaterialProperties(materialIds: RapiId[]): Promise<void>;
+    protected registerCallbacks(): void;
+    pause(): void;
+    resume(): void;
+    destroy(): void;
+    protected _handleCortoMesh(buffer: ArrayBuffer, meshId: string, quality: number): void;
+    private _requestAssetByExternalUrl;
+    protected _handleInvalidAsset(assetType: AssetType, idOrUrl: string, quality: number): void;
+    calcPartsPriceSum(partList: KernelPartList): Promise<KernelPartListPrice>;
+    protected _calcPrice(partList?: KernelPartList): Promise<KernelPartListPrice>;
+    addUiDataAndPriceToPartList(partList: KernelPartList, hash: string): Promise<KernelPartList>;
+    addLabelToKernelComponent(kernelComponent: KernelComponent): void;
+    addUiDataToPartList(partList: KernelPart[], hash: string): KernelPart[];
+    requestExternalMesh(_requestedMeshes: Array<{
+        meshId: string;
+        quality: number;
+    }>): void;
+    requestPartListAndUpdatePricesOfParts(hash?: ConfigurationHash, _prices?: Map<ArticleNumber, RapiPrice>): Promise<void>;
+}
+export {};

package/lib/definitions/packages/common-core/src/services/data-syncer.d.ts

@@ -0,0 +1,41 @@
+import type { CommunicationInterfaceCallback } from '../../../workers/src/communication-interface';
+import { WORKER_MESSAGE } from '../../../workers/src/communication-interface';
+import type { RapiId, AssetUrl } from '../../../typings/rapi-types';
+import type { Context } from '../di/context';
+export default class DataSyncer implements Context, CommunicationInterfaceCallback {
+    _creator_: string;
+    private _rapiAccess;
+    private _singlePromiseFactory;
+    private _errorHandler;
+    private _configuratorUiCallbacks;
+    private _initData;
+    private _worker;
+    private _mainThreadToWorker;
+    private _bootCallbacks;
+    private _isStarted;
+    private _isStarting;
+    private _alwaysUseCache;
+    constructor(creator: string);
+    start(catalogId: RapiId): Promise<void>;
+    syncCatalog(catalogId: RapiId): Promise<void>;
+    syncFloorTag(tagId: RapiId): Promise<any>;
+    syncTypeChangeTag(tagId: RapiId): Promise<any>;
+    private _syncFloorTag;
+    _syncTypeChangeTag(tagId: RapiId): Promise<any>;
+    getIsCatalogSynced(catalogId: RapiId): boolean;
+    private _startWorker;
+    onCommand(command: WORKER_MESSAGE, conversationId: number, data: any): void;
+    private _handleCatalog;
+    private _handleTags;
+    private _handleExternalMeshes;
+    private _handleItemsAndAdditionalContents;
+    private _handleMaterialsAndTextures;
+    private _handleContentWithAssets;
+    private _fetchAssets;
+    private _preCacheAsset;
+    private _assetUrlToBase64;
+    private _softReject;
+    requestAsset(url: string, urlAsFallback?: boolean): AssetUrl;
+    setAlwaysUseCache(alwaysUseCache: boolean): void;
+    preFillAssetCache(key: string, url: string): void;
+}

package/lib/definitions/packages/common-core/src/services/global-callback.d.ts

@@ -0,0 +1,35 @@
+import type { Nullable } from '../../../typings/helper';
+import type { RapiJsonBox } from '../../../typings/rapi-types';
+import type { KernelMessageMetaInfo, KernelMessageType } from '../kernel-io';
+import type { ExternalResponseValidator, FetchOptions, RAPI_PATHS } from '../rapi-access';
+import { UiCallback } from '../utils/ui-callback';
+export declare class GlobalCallback extends UiCallback {
+    /**
+     * is called when a network request is made
+     * @param url string the fetched url
+     * @param data RequestInit what is used to init the request
+     * @param options object what additional options do we use
+     */
+    onNetworkRequest: (_url: string, _data: RequestInit, _options: FetchOptions) => void;
+    /**
+     * is called when the Kernel sends us some message
+     * @param _type KernelMessageType can either be exception, error or warning
+     * @param _message string the message from the Kernel
+     * @param _meta KernelMessageMetaInfo optional, adds more information for debugging
+     */
+    onKernelMsg: (_type: KernelMessageType, _message: string, _meta?: KernelMessageMetaInfo) => void;
+    onCheckExternalCache: (_url: string, _requestData: RequestInit) => Promise<any>;
+    onValidateNetworkResponse: ExternalResponseValidator;
+    /**
+     *
+     * @param _url URL of the request
+     * @param _rapiPath the RAPI_PATHS enum
+     * @param _json the JSON response
+     * @returns void
+     */
+    onApiJsonReceived: (_url: string, _rapiPath: RAPI_PATHS, _json: any) => Promise<Nullable<RapiJsonBox> | undefined>;
+    /**
+     * is called the scene is ready for rendering it as an image
+     */
+    onReadyForRender: () => void;
+}

package/lib/definitions/packages/common-core/src/services/hdr-environment-loader.d.ts

@@ -0,0 +1,18 @@
+import type { Context } from '../di/context';
+import type { Texture, WebGLRenderer } from 'three';
+export interface EnvironmentMapResult {
+    url: string;
+    environmentMap: Texture;
+}
+export default class HdrEnvironmentLoader implements Context {
+    _creator_: string;
+    private _environmentMap;
+    private _envChangedCallback;
+    private _exrLoader;
+    private _rgbeLoader;
+    constructor(creator: string);
+    loadUrl(renderer: WebGLRenderer, url: string): Promise<EnvironmentMapResult>;
+    private _loadExr;
+    private _loadRgbe;
+    registerEnvironmentChangedCallback(callBack: (maps: EnvironmentMapResult) => void): void;
+}