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

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/__tests__/roomle-material-viewer.d.ts

@@ -0,0 +1 @@
+export {};

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

@@ -0,0 +1 @@
+export {};

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

@@ -0,0 +1,13 @@
+import { default as Main } from '../../common-core/src/main';
+import { default as RoomleMaterialViewer } from './roomle-material-viewer';
+
+export declare class MaterialViewer extends Main {
+    private _viewer;
+    protected setupGlobals(): void;
+    protected setupDependencies(): void;
+    protected cleanUpGlobals(): void;
+    protected cleanUpDependencies(): void;
+    protected bootFinished(): Promise<void>;
+    getApi(): RoomleMaterialViewer;
+    protected getContextName(): string;
+}

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

@@ -0,0 +1,11 @@
+import { UiCallback } from '../../common-core/src/utils/ui-callback';
+import { RapiMaterialShading } from '../../typings/rapi-types';
+
+export default class RoomleMaterialViewerUiCallback extends UiCallback {
+    constructor(creator: string);
+    /**
+     * Gets called when a material parameter has been changed using the graphical user interface
+     * @param materialShading
+     */
+    onMaterialShadingChanged: (materialShading: RapiMaterialShading) => void;
+}

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

@@ -0,0 +1,126 @@
+import { ExternalEmbeddable, GlobalAPI, default as Main } from '../../common-core/src/main';
+import { Context } from '../../common-core/src/di/context';
+import { SceneSettings } from '../../common-core/src/scene-settings-loader';
+import { GEOMETRY } from './webgl/material-viewer-scene-manager';
+import { RapiId, RapiMaterial, RapiMaterialShading, RapiTexture } from '../../typings/rapi-types';
+import { default as RoomleMaterialViewerUiCallback } from './roomle-material-viewer-ui-callback';
+import { InitDataDefinition } from '../../common-core/src/utils/shims';
+import { CanvasOffset } from '../../common-core/src/common-interfaces';
+import { default as UnitFormatter } from '../../configurator-core/src/services/unit-formatter';
+import { Scene } from 'three';
+import { default as IdbManager } from '../../common-core/src/services/idb-manager';
+import { GlobalCallback } from '../../common-core/src/services/global-callback';
+
+export default class RoomleMaterialViewer implements GlobalAPI, Context, ExternalEmbeddable<RoomleMaterialViewerUiCallback> {
+    _creator_: string;
+    private _domHelper;
+    private _scriptLoader;
+    private _lifeCycleManager;
+    private _roomleMaterialViewerUiCallback;
+    private _initData;
+    private _globalCallback;
+    private _rapiAccess;
+    private _unitFormatter;
+    protected _idbManager: IdbManager;
+    private _sceneManager;
+    constructor(creator: string);
+    setCameraOffset(offset: CanvasOffset): void;
+    getCameraOffset(): CanvasOffset;
+    init(element: HTMLElement): Promise<void>;
+    private _initPromiseCallback;
+    get callbacks(): RoomleMaterialViewerUiCallback;
+    set callbacks(callback: RoomleMaterialViewerUiCallback);
+    loadMaterialShading(materialShading: RapiMaterialShading): Promise<void>;
+    resetMaterial(): void;
+    loadMaterial(material: RapiMaterial, options?: {
+        flushCache?: boolean;
+    }): Promise<void>;
+    loadMaterialId(materialId: RapiId, options?: {
+        flushCache?: boolean;
+    }): Promise<void>;
+    getMaterialShading(version?: number): RapiMaterialShading;
+    /**
+     * 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>;
+    setOverrides(initData: InitDataDefinition): void;
+    updateSize(): void;
+    /**
+     * 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;
+    resumeTest(element: HTMLElement): void;
+    pauseTest(): void;
+    showGUI(): 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>;
+    /**
+     * Set the geometry of the demo material mesh
+     *
+     * Possible parameter:
+     * 'cube',
+     * 'sphere',
+     * 'plane_vertical',
+     * 'plane_horizontal'
+     *
+     * @param type
+     */
+    setGeometry(type: GEOMETRY): void;
+    /**
+     * Set a texture on the demo material, if no base64Image is set, the image field of rapiTexture is used
+     * @param rapiTexture
+     * @param base64Image for example "data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAYAAAAfFcSJAAAADUlEQVR42mNkYPj/HwADBwIAMCbHYQAAAABJRU5ErkJggg=="
+     */
+    addTexture(rapiTexture: RapiTexture, base64Image?: string): Promise<void>;
+    /**
+     * Remove texture from the demo material
+     * @param rapiTexture
+     */
+    removeTexture(rapiTexture: RapiTexture): void;
+    private _clearCaches;
+    getScene(): Scene;
+    updateScene(): void;
+    /**
+     * returns unit formatter for formatting input und output values in scene
+     */
+    getUnitFormatter(): UnitFormatter;
+    /**
+     * returns manager class to interface with indexedDB storage
+     */
+    getStorage(): IdbManager;
+    setEnvironmentMap(params: {
+        url?: string;
+        intensity?: number;
+        rotation?: number;
+        maxLightSources?: number;
+    }): void;
+    /**
+     * @internal
+     * Use this callbacks to hook in your functionality
+     */
+    get globalCallbacks(): GlobalCallback;
+}

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

@@ -0,0 +1,7 @@
+import { default as RoomleMaterialViewer } from '../roomle-material-viewer';
+
+declare global {
+    interface Window {
+        RoomleMaterialViewer: RoomleMaterialViewer;
+    }
+}

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

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