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

package/src/configurator/components/parameters/types/ThumbnailsParameter.vue.d.ts

@@ -0,0 +1,369 @@
+import { PropType } from 'vue';
+import { UiKernelParameter } from '@roomle/web-sdk/lib/definitions/typings/kernel';
+import { GridViewElement, GridViewGroup } from '../../grid-view/-utils/GridViewHelper';
+import { CollectionViewUiState } from '../../../../common/store/collection-view-state';
+
+declare const _default: import('vue').DefineComponent<import('vue').ExtractPropTypes<{
+    parameter: PropType<UiKernelParameter>;
+    isExpanded: BooleanConstructor;
+    onExpand: {
+        type: FunctionConstructor;
+        required: true;
+    };
+    onCollapse: {
+        type: PropType<(_payload: MouseEvent) => void>;
+    };
+    state: {
+        type: PropType<CollectionViewUiState>;
+        required: true;
+    };
+    isDesktop: BooleanConstructor;
+}>, {}, {}, {
+    allElements(): GridViewElement[];
+    selectedElement(): GridViewElement;
+    normalizedGroups(): GridViewGroup[];
+}, {
+    onSelect({ key }: {
+        key: string;
+    }): Promise<void>;
+}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<{
+    parameter: PropType<UiKernelParameter>;
+    isExpanded: BooleanConstructor;
+    onExpand: {
+        type: FunctionConstructor;
+        required: true;
+    };
+    onCollapse: {
+        type: PropType<(_payload: MouseEvent) => void>;
+    };
+    state: {
+        type: PropType<CollectionViewUiState>;
+        required: true;
+    };
+    isDesktop: BooleanConstructor;
+}>> & Readonly<{}>, {
+    isDesktop: boolean;
+    isExpanded: boolean;
+}, {}, {
+    GridView: import('vue').DefineComponent<import('vue').ExtractPropTypes<{
+        isExpanded: BooleanConstructor;
+        onExpand: {
+            type: FunctionConstructor;
+            required: true;
+        };
+        onSelect: {
+            type: PropType<((..._args: any[]) => void) | ((..._args: any[]) => void)[]>;
+            required: true;
+        };
+        onDragStart: FunctionConstructor;
+        onDragEnd: FunctionConstructor;
+        elements: PropType<GridViewElement<import('../../grid-view/-utils/GridViewHelper').GridViewElementPossiblePayload>[]>;
+        selectedElement: {
+            type: PropType<import('@roomle/web-sdk/lib/definitions/typings/kernel').UiPossibleChild | import('../../grid-view/-utils/GridViewHelper').GridViewVariantElement | GridViewElement<import('../../grid-view/-utils/GridViewHelper').GridViewElementPossiblePayload>>;
+            default: any;
+        };
+        groups: {
+            type: PropType<GridViewGroup<import('../../grid-view/-utils/GridViewHelper').GridViewElementPossiblePayload>[]>;
+            required: true;
+        };
+        onCollapse: {
+            type: PropType<(_payload: MouseEvent) => void>;
+        };
+        state: {
+            type: PropType<import('../../../../common/store/collection-view-state').GridViewUiState>;
+        };
+        isDesktop: BooleanConstructor;
+    }>, {
+        onSelectWrapped: (...args: any) => void;
+    }, {
+        currentTouch: import('../../../../../packages/common/src/utils/touch-drag').TouchDrag<GridViewElement<import('../../grid-view/-utils/GridViewHelper').GridViewElementPossiblePayload>>;
+    }, {
+        selectedElementWrapped(): GridViewElement<import('../../grid-view/-utils/GridViewHelper').GridViewElementPossiblePayload>;
+        isDraggable(): boolean;
+        stateWrapped(): import('../../../../common/store/collection-view-state').GridViewUiState;
+    }, {
+        dragStart(gridViewElement: GridViewElement<import('../../grid-view/-utils/GridViewHelper').GridViewElementPossiblePayload>, event: DragEvent | TouchEvent): Promise<void>;
+        dragEnd(gridViewElement: GridViewElement<import('../../grid-view/-utils/GridViewHelper').GridViewElementPossiblePayload>, event: DragEvent | TouchEvent): void;
+        touchStart(gridViewElement: GridViewElement<import('../../grid-view/-utils/GridViewHelper').GridViewElementPossiblePayload>, event: TouchEvent): void;
+        touchMove(_gridViewElement: GridViewElement<import('../../grid-view/-utils/GridViewHelper').GridViewElementPossiblePayload>, event: TouchEvent): void;
+        touchEnd(gridViewElement: GridViewElement<import('../../grid-view/-utils/GridViewHelper').GridViewElementPossiblePayload>, event: TouchEvent): void;
+    }, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<{
+        isExpanded: BooleanConstructor;
+        onExpand: {
+            type: FunctionConstructor;
+            required: true;
+        };
+        onSelect: {
+            type: PropType<((..._args: any[]) => void) | ((..._args: any[]) => void)[]>;
+            required: true;
+        };
+        onDragStart: FunctionConstructor;
+        onDragEnd: FunctionConstructor;
+        elements: PropType<GridViewElement<import('../../grid-view/-utils/GridViewHelper').GridViewElementPossiblePayload>[]>;
+        selectedElement: {
+            type: PropType<import('@roomle/web-sdk/lib/definitions/typings/kernel').UiPossibleChild | import('../../grid-view/-utils/GridViewHelper').GridViewVariantElement | GridViewElement<import('../../grid-view/-utils/GridViewHelper').GridViewElementPossiblePayload>>;
+            default: any;
+        };
+        groups: {
+            type: PropType<GridViewGroup<import('../../grid-view/-utils/GridViewHelper').GridViewElementPossiblePayload>[]>;
+            required: true;
+        };
+        onCollapse: {
+            type: PropType<(_payload: MouseEvent) => void>;
+        };
+        state: {
+            type: PropType<import('../../../../common/store/collection-view-state').GridViewUiState>;
+        };
+        isDesktop: BooleanConstructor;
+    }>> & Readonly<{}>, {
+        isDesktop: boolean;
+        isExpanded: boolean;
+        selectedElement: import('@roomle/web-sdk/lib/definitions/typings/kernel').UiPossibleChild | import('../../grid-view/-utils/GridViewHelper').GridViewVariantElement | GridViewElement<import('../../grid-view/-utils/GridViewHelper').GridViewElementPossiblePayload>;
+    }, {}, {
+        ExpandedView: import('vue').DefineComponent<{
+            groups: GridViewGroup<import('../../grid-view/-utils/GridViewHelper').GridViewElementPossiblePayload>[];
+            selectedElement: GridViewElement<import('../../grid-view/-utils/GridViewHelper').GridViewElementPossiblePayload>;
+            onSelect: (element: GridViewElement<import('../../grid-view/-utils/GridViewHelper').GridViewElementPossiblePayload>) => void;
+            onDragStart: (element: GridViewElement<import('../../grid-view/-utils/GridViewHelper').GridViewElementPossiblePayload>, event: DragEvent) => void;
+            onDragEnd: (element: GridViewElement<import('../../grid-view/-utils/GridViewHelper').GridViewElementPossiblePayload>, event: DragEvent) => void;
+            onTouchStart: (element: GridViewElement<import('../../grid-view/-utils/GridViewHelper').GridViewElementPossiblePayload>, event: TouchEvent) => void;
+            onTouchEnd: (element: GridViewElement<import('../../grid-view/-utils/GridViewHelper').GridViewElementPossiblePayload>, event: TouchEvent) => void;
+            onTouchMove: (element: GridViewElement<import('../../grid-view/-utils/GridViewHelper').GridViewElementPossiblePayload>, event: TouchEvent) => void;
+            onCollapse?: (_payload: MouseEvent) => void;
+            state: import('../../../../common/store/collection-view-state').GridViewUiState;
+            isDesktop?: boolean;
+            isDraggable?: boolean;
+        }, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<{
+            groups: GridViewGroup<import('../../grid-view/-utils/GridViewHelper').GridViewElementPossiblePayload>[];
+            selectedElement: GridViewElement<import('../../grid-view/-utils/GridViewHelper').GridViewElementPossiblePayload>;
+            onSelect: (element: GridViewElement<import('../../grid-view/-utils/GridViewHelper').GridViewElementPossiblePayload>) => void;
+            onDragStart: (element: GridViewElement<import('../../grid-view/-utils/GridViewHelper').GridViewElementPossiblePayload>, event: DragEvent) => void;
+            onDragEnd: (element: GridViewElement<import('../../grid-view/-utils/GridViewHelper').GridViewElementPossiblePayload>, event: DragEvent) => void;
+            onTouchStart: (element: GridViewElement<import('../../grid-view/-utils/GridViewHelper').GridViewElementPossiblePayload>, event: TouchEvent) => void;
+            onTouchEnd: (element: GridViewElement<import('../../grid-view/-utils/GridViewHelper').GridViewElementPossiblePayload>, event: TouchEvent) => void;
+            onTouchMove: (element: GridViewElement<import('../../grid-view/-utils/GridViewHelper').GridViewElementPossiblePayload>, event: TouchEvent) => void;
+            onCollapse?: (_payload: MouseEvent) => void;
+            state: import('../../../../common/store/collection-view-state').GridViewUiState;
+            isDesktop?: boolean;
+            isDraggable?: boolean;
+        }> & Readonly<{}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, any>;
+        CollapsedView: {
+            new (...args: any[]): import('vue').CreateComponentPublicInstanceWithMixins<Readonly<import('vue').ExtractPropTypes<{
+                elements: PropType<GridViewElement<import('../../grid-view/-utils/GridViewHelper').GridViewElementPossiblePayload>[]>;
+                selectedElement: PropType<GridViewElement<import('../../grid-view/-utils/GridViewHelper').GridViewElementPossiblePayload>>;
+                onExpand: FunctionConstructor;
+                onSelect: {
+                    type: FunctionConstructor;
+                    default: () => any;
+                };
+                onDragStart: {
+                    type: FunctionConstructor;
+                    default: () => any;
+                };
+                onDragEnd: {
+                    type: FunctionConstructor;
+                    default: () => any;
+                };
+                onTouchStart: {
+                    type: FunctionConstructor;
+                    default: () => any;
+                };
+                onTouchEnd: {
+                    type: FunctionConstructor;
+                    default: () => any;
+                };
+                onTouchMove: {
+                    type: FunctionConstructor;
+                    default: () => any;
+                };
+                showAllElements: BooleanConstructor;
+                isDesktop: BooleanConstructor;
+                isDraggable: BooleanConstructor;
+                isScrolling: BooleanConstructor;
+                state: {
+                    type: PropType<import('../../../../common/store/collection-view-state').GridViewUiState>;
+                    default: () => {
+                        filter: any[];
+                        search: any;
+                        userInitiatedSearch: boolean;
+                        viewType: import('../../../../common/store/collection-view-state').ViewTypeState;
+                    };
+                };
+            }>> & Readonly<{}>, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, import('vue').VNodeProps & import('vue').AllowedComponentProps & import('vue').ComponentCustomProps & Readonly<import('vue').ExtractPropTypes<{
+                elements: PropType<GridViewElement<import('../../grid-view/-utils/GridViewHelper').GridViewElementPossiblePayload>[]>;
+                selectedElement: PropType<GridViewElement<import('../../grid-view/-utils/GridViewHelper').GridViewElementPossiblePayload>>;
+                onExpand: FunctionConstructor;
+                onSelect: {
+                    type: FunctionConstructor;
+                    default: () => any;
+                };
+                onDragStart: {
+                    type: FunctionConstructor;
+                    default: () => any;
+                };
+                onDragEnd: {
+                    type: FunctionConstructor;
+                    default: () => any;
+                };
+                onTouchStart: {
+                    type: FunctionConstructor;
+                    default: () => any;
+                };
+                onTouchEnd: {
+                    type: FunctionConstructor;
+                    default: () => any;
+                };
+                onTouchMove: {
+                    type: FunctionConstructor;
+                    default: () => any;
+                };
+                showAllElements: BooleanConstructor;
+                isDesktop: BooleanConstructor;
+                isDraggable: BooleanConstructor;
+                isScrolling: BooleanConstructor;
+                state: {
+                    type: PropType<import('../../../../common/store/collection-view-state').GridViewUiState>;
+                    default: () => {
+                        filter: any[];
+                        search: any;
+                        userInitiatedSearch: boolean;
+                        viewType: import('../../../../common/store/collection-view-state').ViewTypeState;
+                    };
+                };
+            }>> & Readonly<{}>, {
+                state: import('../../../../common/store/collection-view-state').GridViewUiState;
+                isDesktop: boolean;
+                onSelect: Function;
+                onDragStart: Function;
+                onDragEnd: Function;
+                onTouchStart: Function;
+                onTouchEnd: Function;
+                onTouchMove: Function;
+                isDraggable: boolean;
+                showAllElements: boolean;
+                isScrolling: boolean;
+            }, true, {}, {}, import('vue').GlobalComponents, import('vue').GlobalDirectives, string, {}, any, import('vue').ComponentProvideOptions, {
+                P: {};
+                B: {};
+                D: {};
+                C: {};
+                M: {};
+                Defaults: {};
+            }, Readonly<import('vue').ExtractPropTypes<{
+                elements: PropType<GridViewElement<import('../../grid-view/-utils/GridViewHelper').GridViewElementPossiblePayload>[]>;
+                selectedElement: PropType<GridViewElement<import('../../grid-view/-utils/GridViewHelper').GridViewElementPossiblePayload>>;
+                onExpand: FunctionConstructor;
+                onSelect: {
+                    type: FunctionConstructor;
+                    default: () => any;
+                };
+                onDragStart: {
+                    type: FunctionConstructor;
+                    default: () => any;
+                };
+                onDragEnd: {
+                    type: FunctionConstructor;
+                    default: () => any;
+                };
+                onTouchStart: {
+                    type: FunctionConstructor;
+                    default: () => any;
+                };
+                onTouchEnd: {
+                    type: FunctionConstructor;
+                    default: () => any;
+                };
+                onTouchMove: {
+                    type: FunctionConstructor;
+                    default: () => any;
+                };
+                showAllElements: BooleanConstructor;
+                isDesktop: BooleanConstructor;
+                isDraggable: BooleanConstructor;
+                isScrolling: BooleanConstructor;
+                state: {
+                    type: PropType<import('../../../../common/store/collection-view-state').GridViewUiState>;
+                    default: () => {
+                        filter: any[];
+                        search: any;
+                        userInitiatedSearch: boolean;
+                        viewType: import('../../../../common/store/collection-view-state').ViewTypeState;
+                    };
+                };
+            }>> & Readonly<{}>, {}, {}, {}, {}, {
+                state: import('../../../../common/store/collection-view-state').GridViewUiState;
+                isDesktop: boolean;
+                onSelect: Function;
+                onDragStart: Function;
+                onDragEnd: Function;
+                onTouchStart: Function;
+                onTouchEnd: Function;
+                onTouchMove: Function;
+                isDraggable: boolean;
+                showAllElements: boolean;
+                isScrolling: boolean;
+            }>;
+            __isFragment?: never;
+            __isTeleport?: never;
+            __isSuspense?: never;
+        } & import('vue').ComponentOptionsBase<Readonly<import('vue').ExtractPropTypes<{
+            elements: PropType<GridViewElement<import('../../grid-view/-utils/GridViewHelper').GridViewElementPossiblePayload>[]>;
+            selectedElement: PropType<GridViewElement<import('../../grid-view/-utils/GridViewHelper').GridViewElementPossiblePayload>>;
+            onExpand: FunctionConstructor;
+            onSelect: {
+                type: FunctionConstructor;
+                default: () => any;
+            };
+            onDragStart: {
+                type: FunctionConstructor;
+                default: () => any;
+            };
+            onDragEnd: {
+                type: FunctionConstructor;
+                default: () => any;
+            };
+            onTouchStart: {
+                type: FunctionConstructor;
+                default: () => any;
+            };
+            onTouchEnd: {
+                type: FunctionConstructor;
+                default: () => any;
+            };
+            onTouchMove: {
+                type: FunctionConstructor;
+                default: () => any;
+            };
+            showAllElements: BooleanConstructor;
+            isDesktop: BooleanConstructor;
+            isDraggable: BooleanConstructor;
+            isScrolling: BooleanConstructor;
+            state: {
+                type: PropType<import('../../../../common/store/collection-view-state').GridViewUiState>;
+                default: () => {
+                    filter: any[];
+                    search: any;
+                    userInitiatedSearch: boolean;
+                    viewType: import('../../../../common/store/collection-view-state').ViewTypeState;
+                };
+            };
+        }>> & Readonly<{}>, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, {
+            state: import('../../../../common/store/collection-view-state').GridViewUiState;
+            isDesktop: boolean;
+            onSelect: Function;
+            onDragStart: Function;
+            onDragEnd: Function;
+            onTouchStart: Function;
+            onTouchEnd: Function;
+            onTouchMove: Function;
+            isDraggable: boolean;
+            showAllElements: boolean;
+            isScrolling: boolean;
+        }, {}, string, {}, import('vue').GlobalComponents, import('vue').GlobalDirectives, string, import('vue').ComponentProvideOptions> & import('vue').VNodeProps & import('vue').AllowedComponentProps & import('vue').ComponentCustomProps & (new () => {
+            $slots: {
+                aux?(_: {}): any;
+            };
+        });
+    }, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;
+}, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;
+export default _default;

package/src/configurator/components/parameters/types/UnknownParameter.vue.d.ts

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

package/src/configurator/components/top-bar/ARButton.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/-utils/SceneOffsetResizer.d.ts

@@ -0,0 +1,25 @@
+import { CanvasOffset } from '@roomle/web-sdk/lib/definitions/common-core/src/common-interfaces';
+import { GlobalAPI } from '@roomle/web-sdk/lib/definitions/common-core/src/main';
+
+export interface SceneOffsetResizerCallback {
+    onStart: () => void;
+    onProgress: (remaining: CanvasOffset) => void;
+    onFinished: () => void;
+}
+export declare class SceneOffsetResizer {
+    static getCameraOffset(parentWidth: number, width: number, parentHeight: number, height: number, isFullscreenOrMobileLandscape: boolean, isExpanded: boolean, isDesktop: boolean, hasGroups: boolean): CanvasOffset;
+    private _api;
+    private _targetOffset;
+    private _startOffset;
+    private _distance;
+    private _startTime;
+    private _duration;
+    constructor(api: GlobalAPI);
+    animateOffset(target: CanvasOffset, duration: number, callback?: SceneOffsetResizerCallback): void;
+    private _animate;
+    private _resize;
+    private _addOffsets;
+    private _multiplyScalar;
+    private _easeInOutBezier;
+    private _getRemainingDistance;
+}

package/src/configurator/components/utils/-utils/popup-types.d.ts

@@ -0,0 +1 @@
+export type PopUpAlignment = 'scene' | 'window';

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

@@ -0,0 +1,8 @@
+declare const _default: import('vue').DefineComponent<{
+    onClick: (_payload: MouseEvent) => void;
+    direction?: string;
+}, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<{
+    onClick: (_payload: MouseEvent) => void;
+    direction?: string;
+}> & Readonly<{}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, any>;
+export default _default;

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

@@ -0,0 +1,9 @@
+declare const _default: __VLS_WithTemplateSlots<import('vue').DefineComponent<{}, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, any>, {
+    default?(_: {}): any;
+}>;
+export default _default;
+type __VLS_WithTemplateSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

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

@@ -0,0 +1,10 @@
+import { PropType } from 'vue';
+
+declare const _default: import('vue').DefineComponent<import('vue').ExtractPropTypes<{
+    name: StringConstructor;
+    onChange: PropType<(_payload: Event) => void>;
+}>, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<{
+    name: StringConstructor;
+    onChange: PropType<(_payload: Event) => void>;
+}>> & Readonly<{}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;
+export default _default;

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

@@ -0,0 +1,15 @@
+declare const _default: import('vue').DefineComponent<{}, {}, {}, {
+    shouldShowCloseButton(): boolean;
+    showHint(): boolean;
+}, {
+    closeFullscreen(): void;
+}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {
+    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/GdprEmailInput.vue.d.ts

@@ -0,0 +1,12 @@
+declare const _default: import('vue').DefineComponent<{
+    inputID: string;
+    onChange: (_isValid: boolean, _email: string, _gdprChecked: boolean) => void;
+    placeholder?: string;
+    noGdpr?: boolean;
+}, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<{
+    inputID: string;
+    onChange: (_isValid: boolean, _email: string, _gdprChecked: boolean) => void;
+    placeholder?: string;
+    noGdpr?: boolean;
+}> & Readonly<{}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, any>;
+export default _default;

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

@@ -0,0 +1,12 @@
+declare const _default: __VLS_WithTemplateSlots<import('vue').DefineComponent<{}, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, any>, {
+    header?(_: {}): any;
+    header?(_: {}): any;
+    content?(_: {}): any;
+    content?(_: {}): any;
+}>;
+export default _default;
+type __VLS_WithTemplateSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

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

@@ -0,0 +1,23 @@
+declare const _default: import('vue').DefineComponent<import('vue').ExtractPropTypes<{
+    src: StringConstructor;
+    alt: StringConstructor;
+}>, {}, {
+    loadingError: boolean;
+}, {
+    image(): HTMLImageElement;
+    hasImage(): boolean;
+}, {
+    _setupErrorHandler(): void;
+}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<{
+    src: StringConstructor;
+    alt: StringConstructor;
+}>> & Readonly<{}>, {}, {}, {
+    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/InteractionsContainer.vue.d.ts

@@ -0,0 +1,18 @@
+import { EventBus } from '../../../common/business-logic/event-bus';
+import { ToggleCallback } from '../../../common/utils/types';
+
+declare const _default: __VLS_WithTemplateSlots<import('vue').DefineComponent<{}, {
+    toggle: () => void;
+}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, any>, {
+    default?(_: {
+        toggle: () => void;
+        toggleEvent: EventBus<ToggleCallback>;
+        isExpanded: boolean;
+    }): any;
+}>;
+export default _default;
+type __VLS_WithTemplateSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

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

@@ -0,0 +1,79 @@
+import { PropType } from 'vue';
+import { PopUpAlignment } from './-utils/popup-types';
+
+type PopUpSize = 'auto' | 'big' | 'medium' | 'small';
+declare const _default: import('vue').DefineComponent<import('vue').ExtractPropTypes<{
+    onClose: FunctionConstructor;
+    displayCloseButton: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    isDesktop: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    isLightTheme: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    size: {
+        type: PropType<PopUpSize>;
+        validator(value: any): boolean;
+    };
+    alignTo: {
+        type: PropType<PopUpAlignment>;
+        validator(value: any): boolean;
+    };
+}>, {}, {}, {
+    isAuto(): boolean;
+    isBig(): boolean;
+    isMedium(): boolean;
+    isSmall(): boolean;
+    isAlignToScene(): boolean;
+}, {
+    close(): void;
+}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<{
+    onClose: FunctionConstructor;
+    displayCloseButton: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    isDesktop: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    isLightTheme: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    size: {
+        type: PropType<PopUpSize>;
+        validator(value: any): boolean;
+    };
+    alignTo: {
+        type: PropType<PopUpAlignment>;
+        validator(value: any): boolean;
+    };
+}>> & Readonly<{}>, {
+    isDesktop: boolean;
+    displayCloseButton: boolean;
+    isLightTheme: boolean;
+}, {}, {
+    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>;
+    SlideTransitionWrapper: 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>;
+}, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;
+export default _default;

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

@@ -0,0 +1,36 @@
+declare const _default: import('vue').DefineComponent<import('vue').ExtractPropTypes<{
+    disabled: BooleanConstructor;
+    onClick: FunctionConstructor;
+    light: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    red: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+}>, {}, {
+    isRunning: boolean;
+}, {
+    isDisabled(): boolean;
+}, {
+    clicked(event: Event): Promise<void>;
+}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<{
+    disabled: BooleanConstructor;
+    onClick: FunctionConstructor;
+    light: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    red: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+}>> & Readonly<{}>, {
+    light: boolean;
+    disabled: boolean;
+    red: boolean;
+}, {}, {
+    Spinner: import('vue').DefineComponent<{}, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;
+}, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;
+export default _default;