@roomle/embedding-lib 5.9.0-alpha.3 → 5.9.0-alpha.4

package/src/configurator/components/utils/RadioButton.vue.d.ts

@@ -0,0 +1,25 @@
+import { PropType } from 'vue';
+
+declare const _default: import('vue').DefineComponent<import('vue').ExtractPropTypes<{
+    text: StringConstructor;
+    checked: BooleanConstructor;
+    value: StringConstructor;
+    onClick: PropType<(_payload: MouseEvent) => void>;
+    name: {
+        type: StringConstructor;
+        default: string;
+    };
+}>, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<{
+    text: StringConstructor;
+    checked: BooleanConstructor;
+    value: StringConstructor;
+    onClick: PropType<(_payload: MouseEvent) => void>;
+    name: {
+        type: StringConstructor;
+        default: string;
+    };
+}>> & Readonly<{}>, {
+    name: string;
+    checked: boolean;
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;
+export default _default;

package/src/configurator/components/utils/ScrollHint.vue.d.ts

@@ -0,0 +1,13 @@
+declare const _default: import('vue').DefineComponent<{}, {}, {
+    hint: {
+        top: boolean;
+        right: boolean;
+        bottom: boolean;
+        left: boolean;
+    };
+}, {}, {
+    scrollRight(): void;
+    scrollLeft(): void;
+    toggleHints(): void;
+}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;
+export default _default;

package/src/configurator/components/utils/SearchInput.vue.d.ts

@@ -0,0 +1,41 @@
+import { PropType } from 'vue';
+import { GridViewUiState } from '../../../common/store/collection-view-state';
+
+declare const _default: import('vue').DefineComponent<import('vue').ExtractPropTypes<{
+    state: {
+        type: PropType<GridViewUiState>;
+        required: true;
+    };
+    isDesktop: BooleanConstructor;
+    onChange: {
+        type: FunctionConstructor;
+        default: () => any;
+    };
+}>, {}, {}, {}, {
+    onInput(event: Event): void;
+    onFocus(event: Event): void;
+    onCursorInInput(): void;
+    onCursorLeavesInput(): void;
+}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<{
+    state: {
+        type: PropType<GridViewUiState>;
+        required: true;
+    };
+    isDesktop: BooleanConstructor;
+    onChange: {
+        type: FunctionConstructor;
+        default: () => any;
+    };
+}>> & Readonly<{}>, {
+    isDesktop: boolean;
+    onChange: Function;
+}, {}, {
+    SvgIcon: import('vue').DefineComponent<{
+        icon: string;
+    }, {
+        svgIcon: import('vue').Ref<HTMLOrSVGElement, HTMLOrSVGElement>;
+    }, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<{
+        icon: string;
+    }> & Readonly<{}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, any>;
+}, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;
+export default _default;

package/src/configurator/components/utils/Spinner.vue.d.ts

@@ -0,0 +1,2 @@
+declare const _default: import('vue').DefineComponent<{}, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;
+export default _default;

package/src/configurator/components/utils/StartConfiguringButton.vue.d.ts

@@ -0,0 +1,31 @@
+declare const _default: import('vue').DefineComponent<{}, {}, {}, {
+    currentIcon(): any;
+}, {
+    startConfiguring(): Promise<void>;
+}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {
+    SelectionButton: {
+        new (...args: any[]): import('vue').CreateComponentPublicInstanceWithMixins<Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, import('vue').VNodeProps & import('vue').AllowedComponentProps & import('vue').ComponentCustomProps & Readonly<{}> & Readonly<{}>, {}, true, {}, {}, import('vue').GlobalComponents, import('vue').GlobalDirectives, string, {}, any, import('vue').ComponentProvideOptions, {
+            P: {};
+            B: {};
+            D: {};
+            C: {};
+            M: {};
+            Defaults: {};
+        }, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, {}>;
+        __isFragment?: never;
+        __isTeleport?: never;
+        __isSuspense?: never;
+    } & import('vue').ComponentOptionsBase<Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, {}, {}, string, {}, import('vue').GlobalComponents, import('vue').GlobalDirectives, string, import('vue').ComponentProvideOptions> & import('vue').VNodeProps & import('vue').AllowedComponentProps & import('vue').ComponentCustomProps & (new () => {
+        $slots: {
+            default?(_: {}): any;
+        };
+    });
+    SvgIcon: import('vue').DefineComponent<{
+        icon: string;
+    }, {
+        svgIcon: import('vue').Ref<HTMLOrSVGElement, HTMLOrSVGElement>;
+    }, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<{
+        icon: string;
+    }> & Readonly<{}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, any>;
+}, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;
+export default _default;

package/src/configurator/components/utils/SvgIcon.vue.d.ts

@@ -0,0 +1,8 @@
+declare const _default: import('vue').DefineComponent<{
+    icon: string;
+}, {
+    svgIcon: import('vue').Ref<HTMLOrSVGElement, HTMLOrSVGElement>;
+}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<{
+    icon: string;
+}> & Readonly<{}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, any>;
+export default _default;

package/src/configurator/components/utils/WordWrap.vue.d.ts

@@ -0,0 +1,33 @@
+declare const _default: import('vue').DefineComponent<import('vue').ExtractPropTypes<{
+    text: StringConstructor;
+    thinText: BooleanConstructor;
+    fontSmall: BooleanConstructor;
+    wrapAt: {
+        type: NumberConstructor;
+        default: number;
+    };
+    lines: {
+        type: NumberConstructor;
+        default: number;
+    };
+}>, {}, {}, {
+    wrappedLines(): string[];
+}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<{
+    text: StringConstructor;
+    thinText: BooleanConstructor;
+    fontSmall: BooleanConstructor;
+    wrapAt: {
+        type: NumberConstructor;
+        default: number;
+    };
+    lines: {
+        type: NumberConstructor;
+        default: number;
+    };
+}>> & Readonly<{}>, {
+    thinText: boolean;
+    fontSmall: boolean;
+    wrapAt: number;
+    lines: number;
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;
+export default _default;

package/src/configurator/components/utils/transitions/SlideTransitionWrapper.vue.d.ts

@@ -0,0 +1,10 @@
+declare const _default: import('vue').DefineComponent<import('vue').ExtractPropTypes<{
+    useTransition: BooleanConstructor;
+}>, {}, {}, {
+    computedTransition(): string;
+}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<{
+    useTransition: BooleanConstructor;
+}>> & Readonly<{}>, {
+    useTransition: boolean;
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;
+export default _default;

package/src/configurator/embedding/drag-ghost.d.ts

@@ -0,0 +1,11 @@
+import { Nullable } from '../../common/utils/types';
+import { DragInOptions } from '../../../packages/embedding-lib/src/plugins/types';
+
+export declare class ExposedApiDragGhost {
+    private _dragGhostAnimationFrameId;
+    private _dragGhostRemoveAnimationFrameId;
+    private _dragGhostElement;
+    constructor(dragGhostElement?: Nullable<HTMLElement>);
+    updateDragGhost(x: number, y: number, options: DragInOptions): void;
+    removeDragGhost(): void;
+}

package/src/configurator/embedding/drag-handler.d.ts

@@ -0,0 +1,11 @@
+import { SdkConnector } from '../business-logic/sdk-connector';
+import { DragInOptions } from '../../../packages/embedding-lib/src/plugins/types';
+
+export declare class ExposedApiDragHandler {
+    private _dragGhost;
+    private _sdkConnector;
+    constructor(sdkConnector: SdkConnector);
+    dragInObject(id: string, x: number, y: number, type?: string): Promise<number>;
+    updateDrag(x: number, y: number, options: DragInOptions): void;
+    dragInObjectEnd(): void;
+}

package/src/configurator/embedding/example/Embedding.vue.d.ts

@@ -0,0 +1,67 @@
+import { RoomleConfiguratorApi, default as RoomleEmbeddingApi } from '../roomle-configurator-api';
+import { ExposedApi } from '../exposed-api';
+
+declare const _default: import('vue').DefineComponent<{}, {}, {
+    showConfigurators: {
+        number01: boolean;
+        number02: boolean;
+        number03: boolean;
+        number04: boolean;
+        number05: boolean;
+        number06: boolean;
+        number07: boolean;
+        number08: boolean;
+        number09: boolean;
+        number10: boolean;
+        number11: boolean;
+        number12: boolean;
+        number13: boolean;
+        number14: boolean;
+    };
+    embeddingApi: typeof RoomleEmbeddingApi;
+    configuratorId: string;
+    defaultOptions: {
+        id: string;
+        buttons: {
+            addons: boolean;
+        };
+        useLocalRoomle: boolean;
+    };
+}, {
+    simpleLink(): string;
+    regularLink(): string;
+}, {
+    getRubensApi(iframe: HTMLIFrameElement): Promise<ExposedApi>;
+}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {
+    GlbConfSwitch: import('vue').DefineComponent<import('vue').ExtractPropTypes<{
+        defaultOptions: ObjectConstructor;
+        configuratorId: StringConstructor;
+        embeddingApi: import('vue').PropType<typeof RoomleEmbeddingApi>;
+    }>, {
+        configuratorApi: RoomleConfiguratorApi;
+        viewerApi: import('../roomle-configurator-api').RoomleViewerApi;
+    }, {
+        isConfigurator: boolean;
+        isGlbViewer: boolean;
+    }, {}, {
+        loadObject(id: string, isViewer: boolean): Promise<void>;
+    }, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<{
+        defaultOptions: ObjectConstructor;
+        configuratorId: StringConstructor;
+        embeddingApi: import('vue').PropType<typeof RoomleEmbeddingApi>;
+    }>> & Readonly<{}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;
+    GlbConfSwitchSecret: import('vue').DefineComponent<import('vue').ExtractPropTypes<{
+        defaultOptions: ObjectConstructor;
+        configuratorId: StringConstructor;
+        embeddingApi: import('vue').PropType<typeof RoomleEmbeddingApi>;
+    }>, {
+        api: RoomleConfiguratorApi | import('../roomle-configurator-api').RoomleViewerApi;
+    }, {}, {}, {
+        loadObject(id: string, isViewer: boolean): Promise<void>;
+    }, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<{
+        defaultOptions: ObjectConstructor;
+        configuratorId: StringConstructor;
+        embeddingApi: import('vue').PropType<typeof RoomleEmbeddingApi>;
+    }>> & Readonly<{}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;
+}, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;
+export default _default;

package/src/configurator/embedding/example/GlbConfSwitch.vue.d.ts

@@ -0,0 +1,21 @@
+import { PropType } from 'vue';
+import { RoomleConfiguratorApi, RoomleViewerApi, default as RoomleEmbeddingApi } from '../roomle-configurator-api';
+
+declare const _default: import('vue').DefineComponent<import('vue').ExtractPropTypes<{
+    defaultOptions: ObjectConstructor;
+    configuratorId: StringConstructor;
+    embeddingApi: PropType<typeof RoomleEmbeddingApi>;
+}>, {
+    configuratorApi: RoomleConfiguratorApi;
+    viewerApi: RoomleViewerApi;
+}, {
+    isConfigurator: boolean;
+    isGlbViewer: boolean;
+}, {}, {
+    loadObject(id: string, isViewer: boolean): Promise<void>;
+}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<{
+    defaultOptions: ObjectConstructor;
+    configuratorId: StringConstructor;
+    embeddingApi: PropType<typeof RoomleEmbeddingApi>;
+}>> & Readonly<{}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;
+export default _default;

package/src/configurator/embedding/example/GlbConfSwitchSecret.vue.d.ts

@@ -0,0 +1,17 @@
+import { PropType } from 'vue';
+import { RoomleConfiguratorApi, RoomleViewerApi, default as RoomleEmbeddingApi } from '../roomle-configurator-api';
+
+declare const _default: import('vue').DefineComponent<import('vue').ExtractPropTypes<{
+    defaultOptions: ObjectConstructor;
+    configuratorId: StringConstructor;
+    embeddingApi: PropType<typeof RoomleEmbeddingApi>;
+}>, {
+    api: RoomleConfiguratorApi | RoomleViewerApi;
+}, {}, {}, {
+    loadObject(id: string, isViewer: boolean): Promise<void>;
+}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<{
+    defaultOptions: ObjectConstructor;
+    configuratorId: StringConstructor;
+    embeddingApi: PropType<typeof RoomleEmbeddingApi>;
+}>> & Readonly<{}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;
+export default _default;

package/src/configurator/embedding/example/main.d.ts

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

package/src/configurator/embedding/exposed-analytics-callbacks.d.ts

@@ -0,0 +1,10 @@
+export declare class ExposedAnalyticsCallbacks {
+    /**
+     * Is called whenever something is sent to google analytics
+     * Possible parameters are everything which is possible in gtag.js
+     * If you need further details about gtag.js: https://developers.google.com/gtagjs
+     * Currently we use Google Analytics in combination with gtag.js so
+     * you can intercept events and send them to your own analytics tool
+     */
+    onGATracking: (..._args: any[]) => void;
+}

package/src/configurator/embedding/exposed-api.d.ts

@@ -0,0 +1,169 @@
+import { default as RoomleConfigurator } from '@roomle/web-sdk/lib/definitions/configurator-core/src/roomle-configurator';
+import { ExposedCallbacks } from './exposed-callbacks';
+import { LoadResponse, SdkConnector } from '../business-logic/sdk-connector';
+import { MessageHandler } from '../../../packages/common/src/utils/message-handler';
+import { Store } from 'vuex';
+import { StoreState } from '../../common/store';
+import { Nullable } from '../../common/utils/types';
+import { Analytics } from '../../common/plugins/analytics';
+import { default as RoomleGLBViewer } from '@roomle/web-sdk/lib/definitions/glb-viewer-core/src/roomle-glb-viewer';
+import { GlobalCallback } from '@roomle/web-sdk/lib/definitions/common-core/src/services/global-callback';
+import { Position3 } from '@roomle/web-sdk/lib/definitions/common-core/src/common-interfaces';
+import { default as RoomlePlanner } from '@roomle/web-sdk/lib/definitions/planner-core/src/roomle-planner';
+import { KernelPlanObject } from '@roomle/web-sdk/lib/definitions/typings/kernel';
+import { Translator } from '../../common/composables/use-intl';
+import { Libs } from '../plugins/libs-plugin';
+import { ExposedOverlays } from '../../common/components/utils/-utils/overlays';
+import { default as EventEmitter } from '../../common/business-logic/event-emitter';
+import { DragInOptions } from '../../../packages/embedding-lib/src/plugins/types';
+
+export declare class ExposedApi {
+    private _sdk;
+    private _exposedCallbacks;
+    private _sdkConnector;
+    private _store;
+    private _analytics;
+    private _exposedAnalyticsCallbacks;
+    private _isWebsiteReady;
+    private _libs;
+    private _intl;
+    private _configuratorSdk;
+    private _globalCallback;
+    private _messageHandlers;
+    private _eventEmitter;
+    private _dragHandler;
+    constructor(sdkConnector: SdkConnector, mainMessageHandlers: Nullable<MessageHandler>, sdk: RoomleConfigurator | RoomleGLBViewer | RoomlePlanner, exposedCallbacks: ExposedCallbacks, store: Store<StoreState>, analytics: Analytics, globalCallback: GlobalCallback, intl: Translator, libs: Libs, eventEmitter: EventEmitter);
+    private _getMethodsAndCallbacks;
+    get callbacks(): ExposedCallbacks;
+    /**
+     * call this method to load the object you want into the 3d Scene
+     * @param id database ID of the object you want to load
+     */
+    loadObject(id: string): Promise<Nullable<LoadResponse>>;
+    /**
+     * call this method to load the configuration string you want into the 3d Scene
+     * @param configurationString string of the configuration, starts with `{` and ends with `}`
+     * @returns null if configuration can not be loaded
+     */
+    loadConfigurationString(configurationString: string): Promise<Nullable<LoadResponse>>;
+    /**
+     * set the price for the UI to show
+     * most likely needed when implementing your own price service
+     *
+     * @param currencySymbol
+     * @param price
+     */
+    setPrice(currencySymbol: string, price: number): void;
+    /**
+     * This method can be used to start configuration when
+     * 3d scene is only initialized as viewer first, the
+     * configurator is automatically instantiated as viewer
+     * if the container where the configurator is placed is
+     * smaller than 1024px (this breakpoint could change in future)
+     * so do not rely on this exact pixel setting
+     */
+    startConfiguring(): void;
+    /**
+     * This method can be used to pause configuration
+     * If the configurator was called in view-only mode
+     * this method triggers the onBackToWebsite callback.
+     * To know when the view-only mode is activated see the
+     * description of the startConfiguring method
+     */
+    pauseConfiguring(): void;
+    /**
+     * call this method to trigger the onRequestProduct event from
+     * outside of the iframe. When this method is called the same
+     * process is kicked off as if the user would have clicked on
+     * request product. Therefore you can just use the same callback
+     * to react on the response
+     */
+    triggerRequestProduct(): Promise<void>;
+    /**
+     * call this method to trigger the onSaveDraft event from
+     * outside of the iframe. When this method is called the same
+     * process is kicked off as if the user would have clicked on
+     * save draft in the bottom bar. Therefore you can just use the same callback
+     * to react on the response
+     */
+    triggerSaveDraft(email?: string): Promise<void>;
+    /**
+     * call this method to trigger the onRequestPlan event from
+     * outside of the iframe. When this method is called the same
+     * process is kicked off as if the user would have clicked on
+     * request plan. Therefore you can just use the same callback
+     * to react on the response
+     */
+    triggerRequestPlan(): Promise<void>;
+    /**
+     * call this method if consent of Google Analytics is given later and not already in init-data on boot
+     */
+    giveGaConsent(): void;
+    /**
+     * Insert an object into the current MOC/planner scene
+     * If no position or rotation is set then it will be placed automatically (without overlapping other objects) with rotation 0
+     * @param id
+     * @param position as x (left/right), y (up/down) and z (front/back)
+     * @param rotation in radians
+     */
+    insertObject(id: string, position?: Position3, rotation?: number): Promise<void>;
+    /**
+     * Changes the currently selected parameter group to a parameter group containing the specified key.
+     * @param groupKey - parameterGroup key.
+     */
+    setActiveParameterGroup(groupKey: string): void;
+    /**
+     * Use this to start a drag in of an object the coordinates x and y are relative
+     * to the iframe. Meaning 0/0 is the top left corner of the iframe
+     * @param id Roomle ID of the object that should be inserted and dragged
+     * @param x coordinate of the drag event
+     * @param y coordinate of the drag event
+     * @param type type of the id, default is 'rml_id' for example: usm:frame, 'rml_serialized' for serialized configurations like {"componentId": "usm:frame"} (currently not supported), 'tc_serialized' for serialized TecConfig Object, 'tc_id' for TecConfig ID (currently not supported)
+     * @returns number runtimeId of the dragged object
+     */
+    dragInObject(id: string, x: number, y: number, type?: string): Promise<number>;
+    getBoundingClientRect(selector: string): DOMRect;
+    private _getComputedStyle;
+    getDrawerAnimation(): {
+        transition: string;
+        direction: string;
+    };
+    /**
+     * After you called dragInObject you can call this method to update the drag position
+     * the coordinates x and y are relative to the iframe. Meaning 0/0 is the top left
+     * corner of the iframe
+     * @param x coordinate of the drag event
+     * @param y coordinate of the drag event
+     * @returns void
+     */
+    updateDrag(x: number, y: number, options?: DragInOptions): void;
+    /**
+     * Call this method when the drag ends
+     */
+    dragInObjectEnd(): void;
+    getPartListPdf(planObject?: KernelPlanObject): Promise<any>;
+    /**
+     * List of overlays that can be triggered from outside the iframe.
+     * These overlays allow for controlled external triggering, ensuring
+     * that only specific, predefined overlays can be displayed from external sources.
+     *
+     * Each overlay in the set is identified by a unique number:
+     *
+     * - SAVE_DRAFT: 1
+     * - OPEN_AR: 4
+     * - EXPORT_3D: 5
+     * - TUTORIALS: 11
+     * - LOAD_PRODUCT: 12 (only available in Room Designer)
+     */
+    triggerShowOverlay(overlay: ExposedOverlays): Promise<void>;
+    getDrawerBoundingClientRect(): Promise<{
+        actual: DOMRect;
+        final: DOMRect;
+    }>;
+    disableEvents(): void;
+    enableEvents(): void;
+    toggleDrawer(): void;
+    private _websiteReady;
+    private _handleMessage;
+    private _forwardSdkCallbacks;
+}

package/src/configurator/embedding/exposed-callbacks.d.ts

@@ -0,0 +1,83 @@
+import { Base64Image } from '@roomle/web-sdk/lib/definitions/common-core/src/common-interfaces';
+import { KernelPartList, UiPlanObject } from '@roomle/web-sdk/lib/definitions/typings/kernel';
+import { RapiConfigurationEnhanced } from '@roomle/web-sdk/lib/definitions/typings/rapi-types';
+import { ButtonCallbackPayloads, CustomViewCallbackInfo } from './types';
+import { Nullable, SaveDraftPayload } from '../../common/utils/types';
+
+export interface Price {
+    currencySymbol: Nullable<string>;
+    price: Nullable<number>;
+}
+export interface Labels {
+    catalogLabel: Nullable<string>;
+    label: Nullable<string>;
+}
+export declare class ExposedCallbacks {
+    /**
+     * Returns all necessary params when 'Request Product'/'Checkout' button has pressed
+     * @param configurationId id of the current configuration
+     * @param image image of the current configuration
+     * @param partList the part list with all details, grouped, etc
+     * @param price price of the current configuration, either set via setPrice or from Roomle price service
+     * @param labels the label of the catalog and the furniture system
+     * @param configuration the data returned from the Roomle backend
+     */
+    onRequestProduct: (configurationId: string, image: Base64Image, partList: KernelPartList, price: Price, labels: Labels, configuration: RapiConfigurationEnhanced) => void;
+    /**
+     * fullList fullList (needed for price calculation) of the current configuration
+     * @param partList the part list with all details, grouped, etc
+     */
+    onPartListUpdate: (partList: KernelPartList, hash: string) => void;
+    onResize: (isDesktop: boolean) => void;
+    onUseFullPage: () => void;
+    /**
+     * Gets called when the configuring is paused and the user leaves fullscreen configurator mode
+     */
+    onBackToWebsite: () => void;
+    /**
+     * Gets called when a button in the UI is clicked
+     * @param name
+     * @param args - Optional arguments specific to the button that was clicked. This parameter is an object where each key is a UI_BUTTON and the value is the corresponding arguments for that button.
+     * @return overrideEventBehaviour true if the event has been consumed and it should not trigger default behaviour, undefined or false otherwise
+     */
+    onButtonClicked: <K extends keyof ButtonCallbackPayloads>(name: K, args?: ButtonCallbackPayloads[K]) => Promise<boolean> | boolean | void;
+    onRequestPlan: (planId: string, image: Base64Image, items: any[]) => void;
+    /**
+     * Gets called if a plan object gets added, changed or removed and returns all objects of the plan
+     * @param objects -- all objects in the plan
+     */
+    onPlanUpdate: (objects: UiPlanObject[]) => void;
+    /**
+     * Called when an element is added to the plan, not called when wall or construction element added
+     * @param addedObject
+     */
+    onPlanElementAdded: (addedObject: UiPlanObject) => void;
+    /**
+     * Called when an element is removed from the plan, not called when wall or construction element removed
+     * @param removedObject
+     */
+    onPlanElementRemoved: (removedObject: UiPlanObject) => void;
+    /**
+     * Called when an element is changed in the plan, not called when wall or construction element changed
+     * @param changedObject
+     */
+    onPlanElementChanged: (changedObject: UiPlanObject) => void;
+    /**
+     * Gets triggered if a tooltip gets closed by controls button
+     * @param tooltipName
+     */
+    onTooltipClose: (tooltipName: string) => void;
+    /**
+     * called when triggerSaveDraft called
+     * @param id configuration id or plan id
+     * @param image image of the current configuration
+     * @param url generated url from save draft
+     * @param data object contains
+     * { type: 'plan' | 'configuration', payload: configuration object or plan snapshot data}
+     */
+    onSaveDraft: (id: string, image: string, url: string, data: SaveDraftPayload) => void;
+    onShowCustomView: (...[viewName, data]: CustomViewCallbackInfo) => Promise<Nullable<boolean>> | Nullable<boolean>;
+    onHideCustomView: (...[viewName, data]: CustomViewCallbackInfo) => void;
+    onCollapseDrawer: () => void;
+    onExpandDrawer: () => void;
+}

package/src/configurator/embedding/helper.d.ts

@@ -0,0 +1,31 @@
+import { ExposedCallbacks } from './exposed-callbacks';
+import { Store } from 'vuex';
+import { StoreState } from '../../common/store';
+import { SdkConnector } from '../business-logic/sdk-connector';
+import { Analytics } from '../../common/plugins/analytics';
+import { RapiConfigurationEnhanced, RapiPlan, RapiPlanSnapshotGetData } from '@roomle/web-sdk/lib/definitions/typings/rapi-types';
+import { Nullable, SaveDraft } from '../../common/utils/types';
+import { KernelBoundsFormatted } from '../../common/utils/helper';
+import { KernelPartList, KernelPlanObject } from '@roomle/web-sdk/lib/definitions/typings/kernel';
+import { Ref } from 'vue';
+import { Libs } from '../plugins/libs-plugin';
+import { Translator } from '../../common/composables/use-intl';
+import { SelectionPayload } from '@roomle/web-sdk/lib/definitions/planner-core/src/roomle-planner-ui-callback';
+
+export declare const startConfiguring: (store: Store<StoreState>, exposedCallbacks: ExposedCallbacks) => void;
+export declare const resetCollectionViewStates: (store: Store<StoreState>) => void;
+export declare const stopConfiguring: (store: Store<StoreState>, sdkConnector: SdkConnector, embeddingCallbacks: ExposedCallbacks) => Promise<void>;
+export declare const triggerRequestProduct: (embeddingCallbacks: ExposedCallbacks, sdkConnector: SdkConnector, store: Store<StoreState>, analytics: Analytics) => Promise<void>;
+export declare const sendSaveDraft: (sdkConnector: SdkConnector, store: Store<StoreState>, currentConfiguration: RapiConfigurationEnhanced | Nullable<RapiPlanSnapshotGetData | RapiPlan>) => Promise<import('@roomle/web-sdk/lib/definitions/typings/rapi-types').RapiJson>;
+export declare function handleSave(embeddingCallbacks: ExposedCallbacks, sdkConnector: SdkConnector, store: Store<StoreState>, analytics: Analytics, email?: string): Promise<SaveDraft>;
+export declare const initializeConfiguration: (sdkConnector: SdkConnector, isPlanner: boolean, store: Store<StoreState>, email?: string, analytics?: Analytics, embeddingCallbacks?: ExposedCallbacks, skipSendCallback?: boolean) => Promise<{
+    configuration: RapiConfigurationEnhanced | RapiPlanSnapshotGetData | RapiPlan;
+    image: string;
+    url: string;
+}>;
+export declare const generateUrl: (sdkConnector: SdkConnector, store: Store<StoreState>, currentConfiguration: Nullable<RapiPlan | RapiConfigurationEnhanced | RapiPlanSnapshotGetData>, isPlanner: boolean) => Promise<string>;
+export declare const triggerRequestPlan: (embeddingCallbacks: ExposedCallbacks, sdkConnector: SdkConnector, store: Store<StoreState>, analytics: Analytics) => Promise<void>;
+export declare const getCurrentPerspectiveImage: (currentSelectedElement: Nullable<SelectionPayload>) => any;
+export declare const printPartList: (partList: KernelPartList[], price: Nullable<string>, label: string, bounds: string, catalogLabel: Nullable<string>, sdkConnector: SdkConnector, store: Store<StoreState>, embeddingCallbacks: ExposedCallbacks, libs: Libs, intl: Translator, isGenerating: Ref<boolean>) => Promise<void>;
+export declare const generatePartListPdf: (partList: KernelPartList[], price: Nullable<string>, label: string, bounds: string, catalogLabel: Nullable<string>, sdkConnector: SdkConnector, store: Store<StoreState>, libs: Libs, intl: Translator, isGenerating: Ref<boolean>, perspectiveImage?: string, planObject?: KernelPlanObject) => Promise<import('jspdf').jsPDF>;
+export declare const formatBounds: (bounds: Nullable<KernelBoundsFormatted>, intl: Translator) => string;