@roomle/embedding-lib 0.0.0-dev-a4754cb

package/packages/embedding-lib/src/homag-intelligence/hi-mcp/skills.d.ts

@@ -0,0 +1,23 @@
+/** A frontmatter field as YAML reads it: a scalar, or a nested field (metadata) as an object of scalars. */
+export type FrontmatterValue = string | Record<string, string>;
+/** A planning skill in the Agent Skills format: a directory with SKILL.md and supporting files. */
+export interface Skill {
+    name: string;
+    description: string;
+    frontmatter: Record<string, FrontmatterValue>;
+    /** The text of every file of the skill by its path in the skill's directory. */
+    texts: Record<string, string>;
+    files: string[];
+}
+export declare const SKILL_FILE = "SKILL.md";
+/**
+ * Reads every skill of the skills directory, given as the text of each file by
+ * its path below the directory; a broken skill fails the load and names its
+ * file.
+ */
+export declare const loadSkills: (files: Record<string, string>) => Skill[];
+/** One line per skill: its name and its description. */
+export declare const skillIndex: (skills: Skill[]) => string;
+/** A file of a skill by its path; only a file of the skill's list is read. */
+export declare const readSkillFile: (skills: Skill[], name: string, file?: string) => string;
+export declare const skills: Skill[];

package/packages/embedding-lib/src/homag-intelligence/hi-mcp/tool-executors.d.ts

@@ -0,0 +1,4 @@
+import { PlanHistory } from './plan-history';
+import { PlannerApi } from './planner-api';
+export type ToolExecutor = (roomDesignerApi: PlannerApi, args: Record<string, unknown>) => Promise<unknown>;
+export declare const createToolExecutors: (planHistory: PlanHistory) => Record<string, ToolExecutor>;

package/packages/embedding-lib/src/homag-intelligence/hi-mcp-tools.d.ts

@@ -0,0 +1,11 @@
+import { HiMcpTools } from './hi-mcp/mcp-tool';
+import { HiMcpPlannerApi } from './hi-mcp/planner-api';
+/**
+ * Creates the HI MCP tools for an AI agent that plans in the planner of this
+ * page: the tools of the HI MCP server as an AI SDK tool set, without the MCP
+ * protocol. The host passes the tool set as `tools` to its own `streamText`.
+ * The tools call the planner through `roomDesignerApi.extended` and chain its
+ * `onHistoryChange` callback; a host that sets its own handler sets it before.
+ * The tool code is loaded on the first call.
+ */
+export declare const createHiMcpTools: (roomDesignerApi: HiMcpPlannerApi) => Promise<HiMcpTools>;

package/packages/embedding-lib/src/homag-intelligence/hi-order-manager.d.ts

@@ -0,0 +1,3 @@
+import { HomagIntelligenceInitData } from '../../../web-sdk/packages';
+export declare const omPostRequest: (hiInitData: HomagIntelligenceInitData, body: any, url: string, extraHeaders?: Record<string, string>) => Promise<any>;
+export declare const omGetRequest: (hiInitData: HomagIntelligenceInitData, url: string, extraHeaders?: Record<string, string>) => Promise<any>;

package/packages/embedding-lib/src/homag-intelligence/hi-planning-assistant.d.ts

@@ -0,0 +1,55 @@
+import { PlanningAssistantOutput, PlanningAssistantPrompt } from '../../../web-sdk/packages';
+import { HiMcpPlannerApi } from './hi-mcp/planner-api';
+/**
+ * The model of the AI Planning Assistant as a JSON object: everything
+ * `loadChatModel` and `startPlanningAssistant` need to reach it.
+ */
+export interface PlanningAssistantConfig {
+    /** `azure` for a deployment on an Azure AI Foundry resource, else the provider of the model. */
+    provider: 'azure' | 'mistral' | 'anthropic' | 'google';
+    /** The model id at the provider; for `azure` the name of the deployment. */
+    model: string;
+    /** The API key of the provider; for `azure` the key of the Foundry resource. */
+    apiKey: string;
+    /** `azure` only: the OpenAI v1 endpoint of the Foundry resource, e.g. `https://<resource>.services.ai.azure.com/openai/v1`. */
+    baseUrl?: string;
+    /** `azure` only: call the deployment through the Chat Completions API instead of the Responses API. */
+    chatCompletions?: boolean;
+    /** `azure` only: the reasoning effort of the deployment; its default when unset. */
+    reasoningEffort?: string;
+    /** Whether the model reads images: the window offers the image drop only then. */
+    readsImages: boolean;
+}
+/** The planner the planning assistant runs in: the HI MCP tools' planner API, the agent prompts and the window. */
+export type PlanningAssistantPlannerApi = HiMcpPlannerApi & {
+    extended: {
+        getExternalObjectAgentPrompts(): Promise<{
+            systemPrompt: string;
+            imagePrompt: string;
+        }>;
+        planningAssistantOutput(part: PlanningAssistantOutput): unknown;
+        callbacks: {
+            onPlanningAssistantPrompt?: (prompt: PlanningAssistantPrompt) => Promise<void>;
+        };
+    };
+};
+/** The AI SDK language model of the config and the provider options `streamText` takes with it. */
+export declare const loadChatModel: ({ provider, model, apiKey, baseUrl, chatCompletions, reasoningEffort, }: PlanningAssistantConfig) => Promise<{
+    languageModel: any;
+    providerOptions: {
+        azure: {
+            reasoningEffort: string;
+        };
+    };
+} | {
+    languageModel: any;
+    providerOptions?: undefined;
+}>;
+/**
+ * Runs the planning agent of the AI Planning Assistant window
+ * (featureFlags.planningAssistant) in this page: the window hands every
+ * message to "onPlanningAssistantPrompt", the agent calls the HI MCP tools,
+ * the tools call the planner of this page, and the agent's output goes to
+ * "planningAssistantOutput". Aborting the signal ends a running turn.
+ */
+export declare const startPlanningAssistant: (roomDesignerApi: PlanningAssistantPlannerApi, config: PlanningAssistantConfig, signal: AbortSignal) => Promise<void>;

package/packages/embedding-lib/src/homag-intelligence/hi-requests.d.ts

@@ -0,0 +1,35 @@
+import { HomagIntelligenceInitData } from '../../../web-sdk/packages';
+/**
+ * Register a subscription/library combination that requires the legacy
+ * TecConfig URL format.
+ *
+ * Call this **before** `setupHi` so that subsequent data fetches
+ * (`libLoadArticleCatalog`, `libLoadMasterData`, `libLoadCalcScript`)
+ * use the correct URL scheme.
+ *
+ * @example
+ * ```typescript
+ * import { registerLegacyUrlFormat, setupHi } from '@roomle/embedding-lib/hi';
+ *
+ * registerLegacyUrlFormat('5bf5fac8-58af-4a95-a5e0-41a4dc52d5f5', 'Furniture_Smith');
+ * await setupHi(hiOptions, callbacks);
+ * ```
+ */
+export declare const registerLegacyUrlFormat: (subscriptionId: string, libraryId: string) => void;
+/**
+ * Unregister a subscription/library combination so it no longer uses the
+ * legacy TecConfig URL format.
+ *
+ * Useful when HOMAG migrates a subscription to the newer URL scheme.
+ *
+ * @example
+ * ```typescript
+ * import { unregisterLegacyUrlFormat } from '@roomle/embedding-lib/hi';
+ *
+ * unregisterLegacyUrlFormat('e2fe8b3d-da31-4a20-92ab-ab6e3839300e', 'Furniture_Smith');
+ * ```
+ */
+export declare const unregisterLegacyUrlFormat: (subscriptionId: string, libraryId: string) => void;
+export declare const libLoadArticleCatalog: (hiInitData: HomagIntelligenceInitData) => Promise<any>;
+export declare const libLoadMasterData: (hiInitData: HomagIntelligenceInitData) => Promise<any>;
+export declare const libLoadCalcScript: (hiInitData: HomagIntelligenceInitData) => Promise<string>;

package/packages/embedding-lib/src/homag-intelligence/hi-setup.d.ts

@@ -0,0 +1,6 @@
+import { HiCallbacks } from '../../../common/src/hi/hi-types';
+import { HomagIntelligenceInitData, GlobalInitDataDefinition } from '../../../web-sdk/packages';
+/** @internal Exported for testing purposes */
+export declare const setFallbackLanguage: (hiInitData: HomagIntelligenceInitData, globalInitData: GlobalInitDataDefinition) => void;
+export declare const setupHi: (libraryIdOrOptions: HomagIntelligenceInitData | string, callbacks?: Partial<HiCallbacks>) => Promise<void>;
+export declare const cleanupHi: () => void;

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

@@ -0,0 +1,8 @@
+import { HomagIntelligenceInitData } from '../../../web-sdk/packages';
+export declare const HOMAG_INTELLIGENCE_ENDPOINT = "https://europe-west3-rml-showcases.cloudfunctions.net/proxy_request?url=";
+/**
+ * Returns `hiInitData` unchanged when its `libraryId` already matches the
+ * requested one (avoiding an unnecessary allocation), otherwise returns a
+ * shallow copy with the `libraryId` overridden.
+ */
+export declare const withLibraryId: (hiInitData: HomagIntelligenceInitData, libraryId: string) => HomagIntelligenceInitData;

package/packages/embedding-lib/src/plugins/constants.d.ts

@@ -0,0 +1,19 @@
+export declare const RML_DRAG_IN_STYLES_ID = "rml-drag-in-styles";
+export declare const RML_DRAG_IN_DRAG_ELEMENT_ID = "rml-drag-in-drag-element";
+export declare const RML_DRAG_IN_OVERLAY_CSS_CLASS = "rml-drag-in-overlay";
+export declare const RML_DRAG_IN_DRAG_GHOST_CSS_CLASS = "rml-drag-in-drag-ghost";
+export declare const RML_DRAG_IN_FADE_IN_ANIMATION = "rml-drag-in-fade-in";
+export declare const RML_DRAG_IN_FADE_OUT_ANIMATION = "rml-drag-in-fade-out";
+export declare const RML_CSS_CLASSES: {
+    readonly DISPLAY_NONE: "rml-display-none";
+};
+export declare const TARGET_OPACITY = 0.5;
+export declare const ANIMATION_DURATION = "250ms";
+export declare const ANIMATION_DIRECTION = "forwards";
+export declare const RML_DRAG_GHOST_FADE_IN_ANIMATION_CSS = "@keyframes rml-drag-in-fade-in {from{opacity: 0;}to {opacity: 0.5;}}";
+export declare const RML_DRAG_GHOST_FADE_OUT_ANIMATION_CSS = "@keyframes rml-drag-in-fade-out {from{opacity: 0.5;}to {opacity: 0;}}";
+export declare const RML_DRAG_GHOST_FADE_IN = "rml-drag-in-fade-in 250ms forwards";
+export declare const RML_DRAG_GHOST_FADE_OUT = "rml-drag-in-fade-out 250ms forwards";
+export declare const RML_DRAG_IN_FALLBACK_GHOST_URL = "https://res.cloudinary.com/roomle/image/upload/v1729679975/fallback_afpyqr.jpg";
+export declare const RML_DRAG_IN_FALLBACK_GHOST_WIDTH = 112;
+export declare const RML_DRAG_IN_FALLBACK_GHOST_HEIGHT = 112;

package/packages/embedding-lib/src/plugins/drag-in.d.ts

@@ -0,0 +1,32 @@
+import { RapiId } from '../../../web-sdk/packages';
+import { ExposedApi } from '../../../../src/configurator/embedding/exposed-api';
+import { DragInSettings, EmbeddingPlugin, EmbeddingPluginMode } from './types';
+import { PossibleCustomViewsAndMain } from '../../../../src/configurator/embedding/custom-views';
+import { DragInStrategy } from './strategy/types';
+import { OnBeforeUpdateDragGhost } from '../embedding-plugins';
+export declare class DragIn extends EmbeddingPlugin implements DragInStrategy {
+    options: DragInSettings;
+    private _strategy;
+    private _customDragSignal;
+    private _injectStyles;
+    private _initializeDragGhost;
+    constructor(instance: ExposedApi, mainDomElement: HTMLIFrameElement | HTMLBodyElement, mode: EmbeddingPluginMode, viewName: PossibleCustomViewsAndMain);
+    init(): Promise<void>;
+    get isDragging(): boolean;
+    dragStart(id: RapiId, event: DragEvent | TouchEvent | MouseEvent, type?: string): void;
+    dragUpdate(event: DragEvent | TouchEvent | MouseEvent): void;
+    dragEnd(): void;
+    touchStart(id: RapiId, event: TouchEvent, type?: string): void;
+    touchMove(event: TouchEvent): void;
+    touchEnd(): void;
+    dispose(): void;
+    beforeUpdateGhost(handler: OnBeforeUpdateDragGhost): void;
+    registerCustomDrag({ customDragStart, customDragEnd, customDragUpdate, beforeUpdateGhost, }: {
+        customDragStart: (event: MouseEvent | TouchEvent) => void;
+        customDragEnd: (event: MouseEvent | TouchEvent) => void;
+        customDragUpdate: (event: MouseEvent | TouchEvent) => void;
+        beforeUpdateGhost?: OnBeforeUpdateDragGhost;
+    }): void;
+    unregisterCustomDrag(): void;
+    releaseInput(event: DragEvent | TouchEvent | MouseEvent): void;
+}

package/packages/embedding-lib/src/plugins/strategy/drag-phase.d.ts

@@ -0,0 +1,25 @@
+/**
+ * How far a drag-in strategy's `dragStart` has got.
+ *
+ * Both strategies ask Rubens for bounding rects over `MessageHandler` — an
+ * `await` — while `dragUpdate` keeps firing synchronously. In that window a drag
+ * is running but the strategy cannot yet tell whether the pointer is over the
+ * canvas, so changing the scene there is what caused RML-17511. The rects live
+ * inside `ready` rather than in nullable fields, so "not loaded yet" cannot be
+ * mistaken for "that element does not exist".
+ *
+ * `failed` is terminal: `dragUpdate` should keep ignoring events instead of
+ * looking like it is still loading. Details in
+ * `.agents/findings/homag-drag-in-inserts-object-twice.md`.
+ */
+export type DragPhase<TBounds> = {
+    kind: 'idle';
+} | {
+    kind: 'starting';
+} | {
+    kind: 'ready';
+    bounds: TBounds;
+} | {
+    kind: 'failed';
+    reason: string;
+};

package/packages/embedding-lib/src/plugins/strategy/from-custom-view.d.ts

@@ -0,0 +1,39 @@
+import { DragInStrategy } from './types';
+import { ID_TYPE, RapiId } from '../../../../web-sdk/packages';
+import { ExposedApi } from '../../../../../src/configurator/embedding/exposed-api';
+import { DragInSettings } from '../types';
+import { PossibleCustomViewsAndMain } from '../../../../../src/configurator/embedding/custom-views';
+import { OnBeforeUpdateDragGhost } from '../../embedding-plugins';
+export declare class DragInFromCustomViewStrategy implements DragInStrategy {
+    private _options;
+    private _instance;
+    private _mainDomElement;
+    private _viewName;
+    private _currentCustomDrag;
+    private _startTarget;
+    private _dragGhost;
+    private _onBeforeUpdateDrag;
+    isDragging: boolean;
+    private _hasEnteredIframe;
+    private _pendingDragIn;
+    private _phase;
+    private _dragGeneration;
+    /** Kept so `dispose()` can remove the listener again. */
+    private _parentWithDragLeave;
+    /** Same listener and same reasoning as `_parentDragLeave` in `from-website.ts`. */
+    private _parentDragLeave;
+    constructor(instance: ExposedApi, mainDomElement: HTMLIFrameElement, options: DragInSettings, viewName: PossibleCustomViewsAndMain);
+    beforeUpdateGhost(handler: OnBeforeUpdateDragGhost): void;
+    _dragStart(id: RapiId, _event: MouseEvent | TouchEvent, type?: ID_TYPE): Promise<void>;
+    _dragUpdate(event: MouseEvent | TouchEvent): void;
+    _dragEnd(): void;
+    dragStart(id: RapiId, event: MouseEvent | TouchEvent, type: ID_TYPE): void;
+    dragEnd(): void;
+    dragUpdate(event: MouseEvent | TouchEvent): void;
+    touchStart(id: RapiId, event: TouchEvent, type?: ID_TYPE): void;
+    touchMove(event: TouchEvent): void;
+    touchEnd(): void;
+    dispose(): void;
+    private _resetStartTarget;
+    releaseInput(_event: TouchEvent | MouseEvent): void;
+}

package/packages/embedding-lib/src/plugins/strategy/from-website.d.ts

@@ -0,0 +1,45 @@
+import { DragInStrategy } from './types';
+import { ID_TYPE, RapiId } from '../../../../web-sdk/packages';
+import { ExposedApi } from '../../../../../src/configurator/embedding/exposed-api';
+import { DragInOptions } from '../types';
+import { OnBeforeUpdateDragGhost } from '../../embedding-plugins';
+export declare class DragInFromWebsiteStrategy implements DragInStrategy {
+    private _options;
+    private _instance;
+    private _mainDomElement;
+    private _currentDrag;
+    private _firefoxDragPosition;
+    private _onBeforeUpdateDrag;
+    isDragging: boolean;
+    private _hasEnteredIframe;
+    private _dragInObjectCalled;
+    private _pendingDragIn;
+    private _phase;
+    /**
+     * Bumped by `dragStart` and `dragEnd`, so a `dragStart` still awaiting its rect
+     * cannot arm the *next* drag with this drag's rects.
+     */
+    private _dragGeneration;
+    private _currentTouch;
+    /** Kept so `dispose()` can remove the listener again. */
+    private _parentWithDragLeave;
+    private _firefoxFallback;
+    /**
+     * Fires for every `dragleave` bubbling up through the iframe's parent, ours or
+     * not, so it needs the same guard `dragUpdate` has. Kept because `dragUpdate`
+     * bails once `getXY` reports 0,0, leaving this the only cancel for a drag that
+     * ends outside the iframe. Trade-off of the reset in
+     * `.agents/plans/drag-in-host-page-hardening.md`.
+     */
+    private _parentDragLeave;
+    constructor(instance: ExposedApi, mainDomElement: HTMLIFrameElement, options: DragInOptions);
+    beforeUpdateGhost(handler: OnBeforeUpdateDragGhost): void;
+    dragStart(id: RapiId, event: DragEvent | TouchEvent, type?: ID_TYPE): Promise<void>;
+    dragUpdate(event: DragEvent | TouchEvent): void;
+    dragEnd(): void;
+    touchStart(id: RapiId, event: TouchEvent, type?: ID_TYPE): void;
+    touchMove(event: TouchEvent): void;
+    touchEnd(): void;
+    dispose(): void;
+    releaseInput(_event: DragEvent | TouchEvent | MouseEvent): void;
+}

package/packages/embedding-lib/src/plugins/strategy/types.d.ts

@@ -0,0 +1,14 @@
+import { RapiId } from '../../../../web-sdk/packages';
+import { OnBeforeUpdateDragGhost } from '../../embedding-plugins';
+export interface DragInStrategy {
+    isDragging: boolean;
+    dragStart(id: RapiId, event: DragEvent | TouchEvent | MouseEvent, type?: string): void | Promise<void>;
+    dragUpdate(event: DragEvent | TouchEvent | MouseEvent): void;
+    dragEnd(): void;
+    touchStart(id: RapiId, event: TouchEvent, type?: string): void;
+    touchMove(event: TouchEvent): void;
+    touchEnd(): void;
+    beforeUpdateGhost(handler: OnBeforeUpdateDragGhost): void;
+    releaseInput(event: DragEvent | TouchEvent | MouseEvent): void;
+    dispose(): void;
+}

package/packages/embedding-lib/src/plugins/types.d.ts

@@ -0,0 +1,35 @@
+import { ExposedApi } from '../../../../src/configurator/embedding/exposed-api';
+import { PossibleCustomViewsAndMain } from '../../../../src/configurator/embedding/custom-views';
+import { PointRect } from '../../../common/src/utils/drag';
+export type EmbeddingPluginMode = 'website' | 'custom-view';
+export declare class EmbeddingPlugin {
+    protected _mainDomElement: HTMLIFrameElement | HTMLBodyElement;
+    protected _instance: ExposedApi;
+    protected _mode: EmbeddingPluginMode;
+    protected _viewName: PossibleCustomViewsAndMain;
+    constructor(instance: ExposedApi, iframe: HTMLIFrameElement | HTMLBodyElement, mode: EmbeddingPluginMode, viewName: PossibleCustomViewsAndMain);
+    init(): Promise<void>;
+}
+export interface DragInSettings {
+    dragInOverlapX?: number;
+    dragInOverlapY?: number;
+    fingerSize?: number;
+    touchDragDelay?: number;
+    touchDragEpsilon?: number;
+    customDragDelay?: number;
+    customDragEpsilon?: number;
+}
+export interface DragGhostOptions {
+    external?: boolean;
+    visibleIn?: PointRect;
+    hiddenIn?: PointRect;
+    url?: string;
+    width?: number;
+    height?: number;
+    element?: HTMLElement;
+}
+export interface DragInOptions {
+    settings?: DragInSettings;
+    ghost?: DragGhostOptions;
+    mode?: EmbeddingPluginMode;
+}

package/packages/embedding-lib/src/roomle-embedding-lib.d.ts

@@ -0,0 +1,82 @@
+import { ConfiguratorSettings, UiInitData } from '../../../src/configurator/embedding/types';
+import { PossibleCustomViews } from '../../../src/configurator/embedding/custom-views';
+import { ConfiguratorUiCallbacks, RoomleConfigurator, RoomleGLBViewer, RoomlePlanner } from '../../web-sdk/packages';
+import { DragIn } from './plugins/drag-in';
+import { Connector, RoomleEmbeddingApiKeys } from './connector';
+export declare const NAMESPACE: {
+    [key: string]: keyof RoomleEmbeddingApiKeys | 'callbacks';
+};
+export declare const NAMESPACE_SEPARATOR = ".";
+export declare const SDK_CALLBACK: string;
+export declare const HANDSHAKE_MESSAGES: {
+    REQUEST_BOOT: string;
+    SETUP: string;
+    WEBSITE_READY: string;
+};
+export declare const WELL_KNOWN_MESSAGES: {
+    GET_METHODS: string;
+    RETURN_METHODS: string;
+    REGISTER_CUSTOM_VIEW: string;
+    REGISTER_CUSTOM_VIEW_DONE: string;
+};
+export declare const isExposable: (name: string) => boolean;
+export declare const getMethodNames: (proto: any, namespace: string, isCallback?: boolean) => string[];
+export declare const getConfiguratorSettings: (configuratorId: string, initData: UiInitData) => Promise<ConfiguratorSettings>;
+export declare const INTERACTION_CONTAINER_SELECTOR = "data-rml-interaction-container";
+export type { ConfiguratorSettings, UiInitData, } from '../../../src/configurator/embedding/types';
+interface PluginMap {
+    dragIn: typeof DragIn;
+}
+export type AvailablePlugins = {
+    [K in keyof PluginMap]?: InstanceType<PluginMap[K]>;
+};
+export type PluginConstructors = {
+    [K in keyof PluginMap]: PluginMap[K];
+};
+export type PluginDefinitions = Array<keyof AvailablePlugins | {
+    name: keyof AvailablePlugins;
+    loader: () => Promise<PluginConstructors[keyof PluginConstructors]>;
+}>;
+export type RoomleConfiguratorApi = RoomleEmbeddingApi<RoomleConfigurator, ConfiguratorUiCallbacks>;
+export type RoomleViewerApi = RoomleEmbeddingApi<RoomleGLBViewer, ConfiguratorUiCallbacks>;
+export type RoomlePlannerApi = RoomleEmbeddingApi<RoomlePlanner, ConfiguratorUiCallbacks>;
+export default class RoomleEmbeddingApi<SdkType, SdkCallbacks> extends Connector<SdkType, SdkCallbacks> {
+    static createPlanner(configuratorId: string, container: HTMLElement, initData: UiInitData, plugins?: PluginDefinitions): Promise<RoomlePlannerApi>;
+    static connect(customView: PossibleCustomViews, plugins?: PluginDefinitions): Promise<Connector<RoomleConfigurator<readonly []>, ConfiguratorUiCallbacks>>;
+    /**
+     * Method to create a new instance of a Roomle Configurator
+     * @param configuratorId the id which identifies your configurator, you will get this ID from your Roomle Contact Person
+     * @param container DOM container in which the configurator should be placed
+     * @param initData settings with which the configurator should be started
+     */
+    static createConfigurator(configuratorId: string, container: HTMLElement, initData: UiInitData, plugins?: PluginDefinitions): Promise<RoomleConfiguratorApi>;
+    /**
+     * Method to create a new instance of a Roomle Configurator
+     * @deprecated please use "createConfigurator"
+     * @param configuratorId the id which identifies your configurator, you will get this ID from your Roomle Contact Person
+     * @param container DOM container in which the configurator should be placed
+     * @param initData settings with which the configurator should be started
+     */
+    static create(configuratorId: string, container: HTMLElement, initData: UiInitData, plugins: PluginDefinitions): Promise<RoomleConfiguratorApi>;
+    /**
+     * Method to create a new instance of a Roomle Viewer
+     * @param configuratorId the id which identifies your configurator, you will get this ID from your Roomle Contact Person
+     * @param container DOM container in which the configurator should be placed
+     * @param initData settings with which the configurator should be started
+     */
+    static createViewer(configuratorId: string, container: HTMLElement, initData: UiInitData, plugins?: PluginDefinitions): Promise<RoomleViewerApi>;
+    private static _create;
+    private _waitForIframe;
+    private _container;
+    private _configuratorSettings;
+    private _initData;
+    private _iframe;
+    private constructor();
+    teardown(): void;
+    private _createIframe;
+    private _onResize;
+    private _onUseFullPage;
+    private _onBackToWebsite;
+    private _executeMessage;
+}
+export { type Connector } from './connector';

package/packages/embedding-lib/src/utils.d.ts

@@ -0,0 +1,35 @@
+import { Nullable } from '../../common/src/utils/types';
+export declare const getComputedStyleCached: (element: HTMLElement) => CSSStyleDeclaration;
+export declare const convertToPixels: (value: string, unit: string, element: HTMLElement) => number;
+export declare const getXY: (element: HTMLElement, event: DragEvent | TouchEvent, fallback?: {
+    x: number;
+    y: number;
+}) => {
+    x: number;
+    y: number;
+};
+export declare const extractClientXY: (event: MouseEvent | DragEvent | TouchEvent, fallback?: Nullable<{
+    x: number;
+    y: number;
+}>) => {
+    clientX: number;
+    clientY: number;
+};
+export declare const createGracefulProxy: <T extends object>(target: Partial<T>) => T;
+export declare const isPointInBounds: (clientX: number, clientY: number, bounds: {
+    left: number;
+    right: number;
+    top: number;
+    bottom: number;
+}) => boolean;
+export declare const isOverVisibleCanvasFromCustomView: (clientX: number, clientY: number, canvasBb: Nullable<DOMRect>, overlayBb: Nullable<DOMRect>, interactionContainerBb: Nullable<DOMRect>, iframeBounds?: DOMRect) => boolean;
+/**
+ * Is the point over Rubens' visible 3D canvas? The host-page vantage point of
+ * `isOverVisibleCanvasFromCustomView` above: all it has is the iframe rect,
+ * standing in for the canvas, minus the interaction container.
+ *
+ * `interactionContainer` arrives in iframe-local coordinates and is offset here.
+ * `null` means there is none, so the whole iframe is canvas — pass it only once
+ * that is known, never while the rect is still loading (RML-17511).
+ */
+export declare const isOverVisibleCanvasFromHostPage: (clientX: number, clientY: number, iframeBounds: DOMRect, interactionContainer: Nullable<DOMRect>) => boolean;

package/roomle-embedding-lib.d.ts

@@ -0,0 +1,6 @@
+export * from './packages/embedding-lib/src/roomle-embedding-lib'
+export {}
+import _default from './packages/embedding-lib/src/roomle-embedding-lib'
+export default _default
+export * from './packages/embedding-lib/src/roomle-embedding-lib'
+export {}