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

package/src/common/composables/use-ui-actions.d.ts

@@ -0,0 +1,3 @@
+import { default as UiActions } from '../utils/ui-actions';
+
+export declare const useUiActions: () => UiActions;

package/src/common/config/tutorial-data.d.ts

@@ -0,0 +1,3 @@
+import { TutorialData } from '../utils/types';
+
+export declare const tutorialData: Readonly<TutorialData[]>;

package/src/common/plugins/analytics.d.ts

@@ -0,0 +1,12 @@
+import { default as GoogleAnalytics } from '../utils/google-analytics';
+
+export interface Analytics {
+    ga: GoogleAnalytics;
+}
+declare const AnalyticsPlugin: {
+    install(app: any, { configuratorId, useTracking, }: {
+        configuratorId: string;
+        useTracking: boolean;
+    }): void;
+};
+export default AnalyticsPlugin;

package/src/common/plugins/event-emitter.d.ts

@@ -0,0 +1,4 @@
+declare const EventEmitterPlugin: {
+    install(app: any): void;
+};
+export default EventEmitterPlugin;

package/src/common/plugins/local-storage.d.ts

@@ -0,0 +1,10 @@
+export interface LocalStorage {
+    getItem: (key: string) => string | null;
+    setItem: (key: string, value: string) => void;
+    removeItem: (key: string) => void;
+    clear: () => void;
+}
+declare const LocalStoragePlugin: {
+    install(app: any): void;
+};
+export default LocalStoragePlugin;

package/src/common/plugins/localize.d.ts

@@ -0,0 +1,2 @@
+declare const Localize: any;
+export default Localize;

package/src/common/plugins/ui-actions.d.ts

@@ -0,0 +1,13 @@
+import { SdkConnector } from '../../configurator/business-logic/sdk-connector';
+import { Store } from 'vuex';
+import { StoreState } from '../store';
+import { default as EventEmitter } from '../business-logic/event-emitter';
+
+declare const UiActionsPlugin: {
+    install(app: any, { sdkConnector, store, eventEmitter, }: {
+        sdkConnector: SdkConnector;
+        store: Store<StoreState>;
+        eventEmitter: EventEmitter;
+    }): void;
+};
+export default UiActionsPlugin;

package/src/common/store/collection-view-state.d.ts

@@ -0,0 +1,51 @@
+import { Module } from 'vuex';
+import { Enumify, Nullable } from '../utils/types';
+import { CollectionViewElement } from '../components/collection-view/-utils/types';
+import { StoreState } from '.';
+import { EnsurePrefix } from '../../configurator/store/ui-state';
+import { MaterialsForObjects } from '../../planner/business-logic/rooms';
+
+export type ViewTypeState = 'list' | 'small' | 'big';
+export interface GridViewUiState {
+    filter: string[];
+    search: Nullable<string>;
+    userInitiatedSearch: boolean;
+    viewType: ViewTypeState;
+    showSearchInput: boolean;
+    ignoreSearchThreshold: boolean;
+    showLabels: boolean;
+}
+export declare const COLLECTION_VIEW_TYPES: {
+    readonly PLANNER_SIDE_BAR: "planner_side_bar";
+    readonly CONFIGURATOR_SIDE_BAR: "configurator_side_bar";
+    readonly DUMMY: "dummy_side_bar";
+    readonly WALL_SIDE_BAR: "wall_side_bar";
+    readonly PRODUCT_SETTINGS: "product_settings";
+    readonly FLOOR_SIDE_BAR: "floor_side_bar";
+    readonly UNIT_TEST: "test_state";
+    readonly STATIC_COLLECTION_VIEW: "static_collection_view";
+};
+export type CollectionViewTypes = Enumify<typeof COLLECTION_VIEW_TYPES>;
+export interface CollectionViewUiState {
+    debugId: CollectionViewTypes;
+    selected: Nullable<CollectionViewElement>;
+    showsDetails: boolean;
+    gridView: GridViewUiState;
+    lastSetExteriorMaterial: Nullable<MaterialsForObjects>;
+    lastSetInteriorMaterial: Nullable<MaterialsForObjects>;
+    lastSetFloorsMaterial: Nullable<MaterialsForObjects>;
+}
+export declare const getInitialGridViewState: () => GridViewUiState;
+export declare const getInitialCollectionViewState: (debugId: CollectionViewTypes) => CollectionViewUiState;
+export declare const getInitialViewType: (initialType?: ViewTypeState) => ViewTypeState;
+type CollectionViewStateIdentifier = EnsurePrefix<'COLLECTION_VIEW_'>;
+export declare const COLLECTION_VIEW_STATE_MUTATIONS: CollectionViewStateIdentifier;
+export declare const GRID_VIEW_STATE_MUTATIONS: CollectionViewStateIdentifier;
+interface MuationPayload<T, V> {
+    state: T;
+    value: V;
+}
+export type GridViewMutationPayload<T> = MuationPayload<GridViewUiState, T>;
+export type CollectionViewMutationPayload<T> = MuationPayload<CollectionViewUiState, T>;
+export declare const collectionViewUiStateHelper: Module<CollectionViewUiState, StoreState>;
+export {};

package/src/common/store/common-ui-state.d.ts

@@ -0,0 +1,35 @@
+import { Module } from 'vuex';
+import { StoreState } from '.';
+import { Enumify, Nullable, MEASUREMENT_UNIT, MEASUREMENT_SYSTEM } from '../utils/types';
+import { AdditionalInfo, RapiId } from '@roomle/web-sdk/lib/definitions/typings/rapi-types';
+import { EnsurePrefix } from '../../configurator/store/ui-state';
+
+export declare const VIEW_MODES: {
+    readonly '2D': "2d";
+    readonly '3D': "3d";
+    readonly FIRST_PERSON: "fp";
+};
+type CommonUiStateIdentifier = EnsurePrefix<'COMMON_UI_STATE_'>;
+export interface CommonUiState {
+    showFlyingMenu: boolean;
+    isInIframe: boolean;
+    isViewOnly: Nullable<boolean>;
+    lastRequestedId: Nullable<RapiId>;
+    currentViewMode: Enumify<typeof VIEW_MODES>;
+    isShadowOnStage: boolean;
+    measurementUnit: Enumify<typeof MEASUREMENT_UNIT>;
+    measurementSystem: Enumify<typeof MEASUREMENT_SYSTEM>;
+    isTextInputFocused: boolean;
+    isCameraIdle: boolean;
+    currentEmbeddedInfos: Nullable<AdditionalInfo[]>;
+    isDraggingElement: boolean;
+    loadedConfigFromIdb: boolean;
+    notificationVisible: boolean;
+    configuratorHintClosed: boolean;
+}
+export declare const initialState: CommonUiState;
+export declare const COMMON_UI_STATE_MUTATIONS: CommonUiStateIdentifier;
+export declare const COMMON_UI_STATE_GETTERS: CommonUiStateIdentifier;
+export declare const COMMON_UI_STATE_ACTIONS: CommonUiStateIdentifier;
+export declare const commonUiState: Module<CommonUiState, StoreState>;
+export {};

package/src/common/store/index.d.ts

@@ -0,0 +1,35 @@
+import { CoreState } from '../../configurator/store/core-state';
+import { CoreData } from '../../configurator/store/core-data';
+import { BUTTON_ACTIONS, UiState } from '../../configurator/store/ui-state';
+import { PlannerUiState } from '../../planner/store/planner-ui-state';
+import { CommonUiState } from './common-ui-state';
+import { CollectionViewUiState } from './collection-view-state';
+import { Nullable } from '../utils/types';
+import { PlannerCoreData } from '../../planner/store/planner-core-data';
+
+export interface SharedUiState {
+    interactionsExpanded: boolean;
+    isFullscreen: boolean;
+    isDesktop: boolean;
+    isLandscape: boolean;
+    lastRegularViewMode: Nullable<boolean>;
+    wasDesktopBefore: boolean;
+    sidebar: CollectionViewUiState;
+    topBarSelectedActions: BUTTON_ACTIONS[];
+}
+export declare const MUTATIONS: {
+    [x: string]: `PLANNER_CORE_STATE_${string}` | `PLANNER_UI_STATE_${string}` | `COMMON_UI_STATE_${string}` | `UI_STATE_${string}` | `COLLECTION_VIEW_${string}` | `CORE_DATA_${string}` | `CORE_STATE_${string}`;
+};
+export declare const ACTIONS: {
+    [x: string]: `PLANNER_CORE_STATE_${string}` | `PLANNER_UI_STATE_${string}` | `UI_STATE_${string}` | `CORE_DATA_${string}` | `CORE_STATE_${string}`;
+};
+export interface StoreState {
+    coreState: CoreState;
+    coreData: CoreData;
+    uiState: UiState;
+    plannerUiState: PlannerUiState;
+    plannerCoreData: PlannerCoreData;
+    commonUiState: CommonUiState;
+}
+declare const _default: any;
+export default _default;

package/src/common/translations/local-translation-source.d.ts

@@ -0,0 +1,9 @@
+import { TranslationSource } from '../composables/use-intl';
+
+export default class LocalTranslationSource implements TranslationSource {
+    private _locale;
+    private _overrideTranslation;
+    constructor(locale: string, overrideTranslation?: any);
+    getTranslations(): Promise<any>;
+    private _getFallbackTranslations;
+}

package/src/common/utils/access-restriction.d.ts

@@ -0,0 +1,8 @@
+import { Analytics } from '../plugins/analytics';
+import { SdkConnector } from '../../configurator/business-logic/sdk-connector';
+
+export interface AccessCheckResult {
+    isCorrectDomain: boolean;
+    hasActivePackage: boolean;
+}
+export declare const isShowSceneAllowed: (configuratorId: string, sdkConnector: SdkConnector, analytics: Analytics) => Promise<AccessCheckResult>;

package/src/common/utils/ar-service.d.ts

@@ -0,0 +1,14 @@
+export default class ARService {
+    private _configuratorId;
+    constructor(configuratorId: string);
+    getArUrl(configurationId: string, isPlanSnapshot?: boolean): string | null;
+    getArUrlWithUrls(glbUrl?: string | null, usdzUrl?: string | null): string | null;
+    getMobileArUrl(id: string): string;
+    private _getAndroidSceneViewerUrl;
+    private _getBaseUrl;
+    private _getAndroidLink;
+    private _getIosLink;
+    private _encodeUrl;
+    private _getGlbUrl;
+    private _getUsdzUrl;
+}

package/src/common/utils/async-guard.d.ts

@@ -0,0 +1,12 @@
+export default class AsyncGuard<T> {
+    info: any;
+    private _promise;
+    private _resolve;
+    private _reject;
+    constructor(info?: any);
+    private _init;
+    resolve(value?: any): void;
+    reject(e: Error): void;
+    wait(): Promise<T>;
+    reset(): void;
+}

package/src/common/utils/bezier.d.ts

@@ -0,0 +1,2 @@
+export declare const createBezierCurve: (mX1: number, mY1: number, mX2: number, mY2: number) => (x: number) => number;
+export declare const easeInOutBezier: (percent: number) => number;

package/src/common/utils/color.d.ts

@@ -0,0 +1,27 @@
+import { UiInitData } from '../../configurator/embedding/types';
+import { SampleMaterial } from '../../planner/components/overlays/rooms/utils/ral-colors';
+import { KernelObject } from '@roomle/web-sdk/lib/definitions/typings/planner';
+import { RapiMaterial } from '@roomle/web-sdk/lib/definitions/typings/rapi-types';
+import { MaterialsForObjects } from '../../planner/business-logic/rooms';
+
+interface NumericRgb {
+    r: number;
+    g: number;
+    b: number;
+}
+export declare const prepareSkin: (initData: UiInitData, blackText: string, whiteText: string) => void;
+export declare const isTexturedMaterial: (material: RapiMaterial) => number;
+export declare const hasShading: (material: RapiMaterial) => import('@roomle/web-sdk/lib/definitions/typings/rapi-types').RapiBaseColor;
+export declare const isRgbMaterial: (material: RapiMaterial) => import('@roomle/web-sdk/lib/definitions/typings/rapi-types').RapiBaseColor;
+export type RgbHexValue = `#${string}`;
+export declare const numericRgbToHex: ({ r, g, b }: NumericRgb) => RgbHexValue;
+export declare const isSampleMaterial: (obj: any) => obj is SampleMaterial;
+export declare const setColorOnCoreObject: (coreObject: KernelObject, material: MaterialsForObjects) => any;
+export declare const hexIntToRgb: (hexInt: number) => {
+    r: number;
+    g: number;
+    b: number;
+};
+export declare const similarColor: (colorA: NumericRgb, colorB: NumericRgb, epsilon?: number) => boolean;
+export declare const sameHexString: (colorA: string, colorB: string) => boolean;
+export {};

package/src/common/utils/compatibility.d.ts

@@ -0,0 +1,4 @@
+import { Analytics } from '../plugins/analytics';
+import { UiInitData } from '../../configurator/embedding/types';
+
+export declare const checkDeprecations: (inIframe: boolean, uiInitData: UiInitData, analytics: Analytics) => void;

package/src/common/utils/composable-helpers.d.ts

@@ -0,0 +1,10 @@
+import { Ref, UnwrapRef } from 'vue';
+import { Nullable } from './types';
+
+export declare class UseAsyncData<T> {
+    data: Ref<Nullable<T>>;
+    error: Ref<Nullable<string>>;
+    isLoaded: Ref<boolean>;
+    constructor(data: Ref<Nullable<T>>, error: Ref<Nullable<string>>, isLoaded: Ref<boolean>);
+    safeData<T>(defaultValue: T): Ref<UnwrapRef<T>>;
+}

package/src/common/utils/dom.d.ts

@@ -0,0 +1,20 @@
+import { Nullable } from './types';
+
+export declare const isScrolledToRightEnd: (element: Nullable<HTMLElement>, threshold?: number) => boolean;
+export declare const hasVerticalOverflow: (element: HTMLElement) => boolean;
+export declare const hasHorizontalOverflow: (element: HTMLElement) => boolean;
+export declare const cssVariableToNumber: (cssVariable: string) => number;
+export declare const remToPixel: (remValue: string, remBase: number) => number;
+export declare const percentInStringToFloat: (percentInString: string) => number;
+export declare const animationDurationInMsToFloat: (animationDuration: string) => number;
+export declare const calcIsDesktop: (width?: number) => boolean;
+export declare const cssClassNameToSelector: (cssClassName: string) => string;
+export declare const removeLoadingScreen: (e2e: boolean | undefined) => Promise<void>;
+export declare const hasLoadingScreen: () => boolean;
+export declare const hasLoadingScreenIntend: () => boolean;
+export declare const showLoadingScreen: (e2e: boolean | undefined, delay?: number) => Promise<void>;
+export declare const copyToClipboard: (text: string) => void;
+export declare const setLoadingProgress: (percent: number) => void;
+export declare const hideLoadingCircle: () => void;
+export declare const scrollElement: (selectedElement: Element) => void;
+export declare const getInteractionTiming: () => string;

package/src/common/utils/font-size-detector.d.ts

@@ -0,0 +1 @@
+export declare const getCurrentFontSize: () => number;

package/src/common/utils/fonts.d.ts

@@ -0,0 +1,3 @@
+import { UiInitData } from '../../configurator/embedding/types';
+
+export declare const prepareFonts: (initData: UiInitData) => Promise<void>;

package/src/common/utils/google-analytics.d.ts

@@ -0,0 +1,68 @@
+import { Nullable } from './types';
+
+export declare const GA_DIMENSIONS: {
+    [key: string]: string;
+};
+export declare const GA_METRICS: {
+    RESPONSE_END_TIME: string;
+    DOM_LOAD_TIME: string;
+    WINDOW_LOAD_TIME: string;
+    TIME_TO_FIRST_BTYE: string;
+    KERNEL_IS_READY: string;
+    INIT_LOADING_SCREEN_CLOSE: string;
+};
+declare enum GA_ACTION_TYPE {
+    EXCEPTION = "exception",
+    TIMING = "timing_complete"
+}
+declare enum CUSTOM_ACTION_TYPE {
+    TRACK_TIMING = "track_timing"
+}
+export declare const GA_NULL_VALUE = "(not set)";
+export declare enum GA_CATEGORY {
+    ERROR = "Error",
+    NAVIGATION_TIMING = "Navigation Timing",
+    TIMING = "Timing",
+    INTERACTION = "Interaction",
+    TRACKING = "Tracking",
+    DEPRECATION = "Deprecation"
+}
+export type GoogleAnalyticsCallback = (...args: any[]) => void;
+export declare const MAX_QUEUE_LENGTH = 1500;
+export default class GoogleAnalytics {
+    history: IArguments[];
+    private _settings;
+    private _queue;
+    private _trackingId;
+    private _useTracking;
+    private _callbacks;
+    private _gaReady;
+    private get _gtag();
+    constructor(configuratorId: string, useTracking?: boolean);
+    giveConsent(): void;
+    trackEvent(action: CUSTOM_ACTION_TYPE | GA_ACTION_TYPE | string, category: GA_CATEGORY, label: string, value?: Nullable<number>, fieldsObject?: object): void;
+    trackTiming(category: GA_CATEGORY, label: any, value: number, fieldsObject?: object): void;
+    setDimension(dimension: string, value: any): void;
+    setDimensions(dimensions: {
+        [key: string]: any;
+    }): void;
+    trackError(message: string, specialErrorName?: Nullable<string>): void;
+    trackContentError(message: string): void;
+    addCallback(listener: GoogleAnalyticsCallback): void;
+    removeUiCallback(listener: GoogleAnalyticsCallback): void;
+    cleanUpHistory(): void;
+    trackWrongDomain(): void;
+    trackNoActivePackage(): void;
+    private _execCommand;
+    private _loadLibScript;
+    private _send;
+    private _flushQueue;
+    private _setObjectProperties;
+    private _trackException;
+    private _trackErrors;
+    private _trackErrorEvent;
+    private _setSettings;
+    private _findDimension;
+    private _sendNavigationTimingMetrics;
+}
+export {};

package/src/common/utils/helper.d.ts

@@ -0,0 +1,83 @@
+import { Enumify, CATALOG_INFOS_TYPES, ExtendedKernelVector3, GroupedCollection, Nullable } from './types';
+import { RapiConfiguration, RapiItem, RapiTenant, AdditionalInfo, RapiMaterial, RapiComponent, RapiPlanSnapshotGetData } from '@roomle/web-sdk/lib/definitions/typings/rapi-types';
+import { StoreState } from '../store';
+import { UiInitData } from '../../configurator/embedding/types';
+import { BUTTON_ACTIONS } from '../../configurator/store/ui-state';
+import { default as RoomlePlanner } from '@roomle/web-sdk/lib/definitions/planner-core/src/roomle-planner';
+import { default as RoomleConfigurator } from '@roomle/web-sdk/lib/definitions/configurator-core/src/roomle-configurator';
+import { KernelVector3 } from '@roomle/web-sdk/lib/definitions/typings/kernel';
+import { PlannerUiState } from '../../planner/store/planner-ui-state';
+
+export declare const throttle: <T extends (...args: any[]) => any>(func: T, delay?: number) => (...funcArgs: Parameters<T>) => void;
+export declare const round: (float: number, precision: number) => number;
+export declare const playwrightRemoveQueryParams: (url: string | URL, keyOfParamToDelete: string) => string;
+/**
+ * Get cloudinary (cdn) url for given parameters
+ * @param url
+ * @param format
+ * @param size
+ * @param step
+ */
+export declare const getImageURL: (url: string, size?: number, step?: number) => string;
+export interface KeyValuePair {
+    key: string;
+    value: string;
+}
+export declare const addMetaHeaderTag: (id: string, attributes: KeyValuePair[]) => void;
+export declare const uuid: (a?: Nullable<string>) => string;
+export declare const snakeCase: (str: string) => string;
+export interface KernelBoundsFormatted {
+    width: string;
+    height: string;
+    depth: string;
+}
+export declare const deepCopy: <T>(o: T) => T;
+export declare const toBoolean: (value: boolean | undefined, defaultValue?: boolean) => boolean;
+export declare const scriptInfo: (...args: any[]) => void;
+export declare const getGlbAssetUrl: (obj: RapiItem | RapiConfiguration | RapiPlanSnapshotGetData) => Nullable<string>;
+export declare const getUsdzAssetUrl: (obj: RapiItem | RapiConfiguration | RapiPlanSnapshotGetData) => Nullable<string>;
+export declare const hasArAssets: (item: RapiItem) => boolean;
+export declare const formatPrice: (currencySymbol: Nullable<string>, price: Nullable<number>) => Nullable<string>;
+export declare const normalizeFloatingNumber: (num: number, decimals?: number) => number;
+export declare const checkForActivePackage: (tenant: RapiTenant) => boolean;
+export declare const oneTimeInterval: (callback: () => void, delay: number) => number;
+export declare const runOnIdle: any;
+export declare const isLocationJestTest: () => boolean;
+export declare const parseColorToHex: (color: string) => string;
+export declare const parseColorToHexDecimal: (color: string) => number;
+export declare const parseColorToHexDecimalString: (color: string) => string;
+export declare const groupArrayBy: <T>(collection: T[], key: keyof T) => GroupedCollection<T>;
+export declare const setupStoreWithInitData: (initData: UiInitData, store: Store<StoreState>) => void;
+export declare const isActionActive: (state: PlannerUiState, action: BUTTON_ACTIONS) => boolean;
+export declare const setMeasurementUnit: (sdkConnector: RoomlePlanner | RoomleConfigurator, store: Store<StoreState>) => void;
+export declare const getStartConfiguringOrViewingIcon: (store: Store<StoreState>) => string;
+export interface Tooltip {
+    [key: string]: string;
+}
+export declare const hasTooltip: (element: any) => element is {
+    tooltip: Tooltip;
+};
+export declare const getParameterTooltip: (tooltip: Tooltip, currentLanguage: string) => string;
+export declare const getElementEmbeddedUrl: (additionalInfos: AdditionalInfo[] | undefined, currentLanguage: string, type: Enumify<typeof CATALOG_INFOS_TYPES>) => Nullable<string>;
+export declare const getFilteredAdditionalInfos: (payload: RapiMaterial, isParameter: boolean, parameterAdditionalInfos: AdditionalInfo[]) => AdditionalInfo[];
+export declare const hasAdditionalInfos: (payload: RapiMaterial | RapiComponent, type: Enumify<typeof CATALOG_INFOS_TYPES>, locale: string) => boolean;
+export declare const getElementTooltipText: (additionalInfos: AdditionalInfo[] | undefined, currentLanguage: string) => Nullable<string>;
+export type WithRequired<T, K extends keyof T> = T & {
+    [P in K]-?: T[P];
+};
+export declare const radToDeg: (rad: number) => number;
+export declare const isValidPlanID: (planId: string) => boolean;
+export declare const convertToUIValuesHelper: (valuesMM: KernelVector3, api: Nullable<RoomlePlanner>) => {
+    x: string;
+    y: string;
+    z: string;
+};
+export declare const convertToKernel: (vector: {
+    x: number;
+    y: number;
+    z: number;
+}) => ExtendedKernelVector3;
+export declare const sortObjects: (a: any, b: any) => number;
+export declare const parseFloatString: (value: string, fractionDigits?: number) => number;
+export declare const noop: () => void;
+export declare const playwrightRemoveQueryParamsFromJSON: (json: any, queryParams: string[], onlyHttpUrls?: boolean) => any;

package/src/common/utils/init-data-helper.d.ts

@@ -0,0 +1,3 @@
+import { UiInitData } from '../../configurator/embedding/types';
+
+export declare const initDataToQueryParams: (initData: UiInitData, prefix?: string) => string;

package/src/common/utils/log-canvas-coords.d.ts

@@ -0,0 +1,3 @@
+import { LogLevelCanvasCoords } from '../../configurator/embedding/types';
+
+export declare const activate: (logLevelCanvasCoords: LogLevelCanvasCoords) => void;

package/src/common/utils/parameters.d.ts

@@ -0,0 +1,19 @@
+import { RapiMaterial, RapiMaterialGroup, RapiTagForUi, RapiTexture } from '@roomle/web-sdk/lib/definitions/typings/rapi-types';
+import { KernelPartListParameter, UiPossibleChildTag } from '@roomle/web-sdk/lib/definitions/typings/kernel';
+import { CollectionViewElement, TabCategory } from '../components/collection-view/-utils/types';
+import { VariantsMap } from '../../configurator/embedding/types';
+import { default as RoomleConfigurator } from '@roomle/web-sdk/lib/definitions/configurator-core/src/roomle-configurator';
+
+export interface RapiMaterialEmbeddedTextures extends RapiMaterial {
+    embeddedTextures?: RapiTexture[];
+    [key: string]: any;
+}
+export declare const getAllMaterials: (groups?: RapiMaterialGroup[]) => RapiMaterialEmbeddedTextures[];
+export declare const mapAddons: (addons: UiPossibleChildTag[]) => CollectionViewElement[];
+export declare const mapVariants: (tag: RapiTagForUi) => CollectionViewElement[];
+export declare const mapRootTagToCollectionViewArray: (tags: RapiTagForUi[], tabCategory?: TabCategory) => CollectionViewElement[];
+export declare const filterAndMapAddons: (addons: UiPossibleChildTag[], selectedGroup: string | undefined) => CollectionViewElement[];
+export declare const addonsHaveGroups: (addons: UiPossibleChildTag[]) => boolean;
+export declare const extractRootComponentId: (id: string) => string;
+export declare const getCurrentVariants: (api: RoomleConfigurator, id: string, variantChangeMap?: VariantsMap) => Promise<RapiTagForUi>;
+export declare const prepareParametersForUi: (parameters: KernelPartListParameter[]) => KernelPartListParameter[];

package/src/common/utils/performance.d.ts

@@ -0,0 +1,2 @@
+export declare const addLoadMark: () => void;
+export declare const calcTiming: () => void;

package/src/common/utils/plan.d.ts

@@ -0,0 +1 @@
+export declare const EMPTY_PLAN = "<plan version=\"2\"><walls><nodes/><edges/></walls><planobjects/><texters/><measures/><floors/><transparency><layers/></transparency></plan>";

package/src/common/utils/playwright-handler.d.ts

@@ -0,0 +1,5 @@
+import { RoomleSdkWrapper } from '../../configurator/business-logic/roomle-sdk-wrapper';
+
+export declare const isRunningInPlaywright: () => boolean;
+export declare const patchForPlaywright: (sdkWrapper: RoomleSdkWrapper) => Promise<void>;
+export declare const attachPlaywrightHints: () => Promise<void>;

package/src/common/utils/playwright-response-checker.d.ts

@@ -0,0 +1,3 @@
+import { RoomleSdkWrapper } from '../../configurator/business-logic/roomle-sdk-wrapper';
+
+export declare const addResponseForPlaywrightValidator: (sdkWrapper: RoomleSdkWrapper) => Promise<void>;

package/src/common/utils/root-tags.d.ts

@@ -0,0 +1,5 @@
+import { default as RapiAccess } from '@roomle/web-sdk/lib/definitions/common-core/src/rapi-access';
+import { RapiId, RapiTag } from '@roomle/web-sdk/lib/definitions/typings/rapi-types';
+
+export declare const getAllRootTags: (possibleRootTagId: RapiId | RapiId[], rapiAccess: RapiAccess) => Promise<RapiTag[]>;
+export declare const generateRootTagCacheId: (tagId: RapiId | RapiId[]) => string;

package/src/common/utils/script-loader.d.ts

@@ -0,0 +1,6 @@
+export default class ScriptLoader {
+    static fetch(url: string, options: {
+        id: string;
+        style?: boolean;
+    }): Promise<void>;
+}

package/src/common/utils/share.d.ts

@@ -0,0 +1 @@
+export declare const createShareLinkFromUrl: (url: string) => string;

package/src/common/utils/tutorials.d.ts

@@ -0,0 +1,6 @@
+import { DEMO_TYPES, Enumify } from './types';
+
+export declare const checkTutorialLink: (link: string) => Enumify<typeof DEMO_TYPES>;
+export declare const isSupaDemoLink: (link: string) => boolean;
+export declare const isYouTubeLink: (link: string) => boolean;
+export declare const isUnknownLink: (link: string) => boolean;