@shopware-ag/dive 1.18.4 → 1.18.5-beta.1

package/build/src/info/Info.d.ts

@@ -0,0 +1,39 @@
+export declare enum WebXRUnsupportedReason {
+    'UNKNWON_ERROR' = 0,
+    'NO_HTTPS' = 1,
+    'IMMERSIVE_AR_NOT_SUPPORTED_BY_DEVICE' = 2,
+    'AR_SESSION_NOT_ALLOWED' = 3
+}
+export declare class DIVEInfo {
+    private static _supportsWebXR;
+    private static _webXRUnsupportedReason;
+    /**
+     *
+     * @returns The system the user is using. Possible values are "Android", "iOS", "Windows", "MacOS", "Linux" or "Unknown".
+     */
+    static GetSystem(): string;
+    /**
+     * @returns A promise that resolves to a boolean indicating whether the user's device supports WebXR.
+     */
+    static GetSupportsWebXR(): Promise<boolean>;
+    /**
+     * @returns The reason why WebXR is not supported on the user's device. Returns null if WebXR is supported nor not has been checked yet.
+     */
+    static GetWebXRUnsupportedReason(): WebXRUnsupportedReason | null;
+    /**
+     * @returns A boolean indicating whether the user's device supports AR Quick Look.
+     */
+    static GetSupportsARQuickLook(): boolean;
+    /**
+     * @returns A boolean indicating whether the user's device is a mobile device.
+     */
+    static get isMobile(): boolean;
+    /**
+     * @returns A boolean indicating whether the user's device is a desktop device.
+     */
+    static get isDesktop(): boolean;
+    /**
+     * @returns A promise that resolves to a boolean indicating whether the user's device is capable of AR.
+     */
+    static GetIsARCapable(): Promise<boolean>;
+}

package/build/src/interface/Draggable.d.ts

@@ -0,0 +1,7 @@
+import { DraggableEvent } from '../toolbox/BaseTool';
+export interface DIVEDraggable {
+    isDraggable: true;
+    onDragStart?: (e: DraggableEvent) => void;
+    onDrag?: (e: DraggableEvent) => void;
+    onDragEnd?: (e: DraggableEvent) => void;
+}

package/build/src/interface/Hoverable.d.ts

@@ -0,0 +1,7 @@
+import { Intersection } from 'three';
+export interface DIVEHoverable {
+    isHoverable: true;
+    onPointerEnter?: (i: Intersection) => void;
+    onPointerOver?: (i: Intersection) => void;
+    onPointerLeave?: () => void;
+}

package/build/src/interface/Movable.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Interface for objects that can be moved in the scene.
+ *
+ * @module
+ */
+export interface DIVEMovable {
+    isMovable: true;
+    onMoveStart?: () => void;
+    onMove?: () => void;
+    onMoveEnd?: () => void;
+}

package/build/src/interface/Rotatable.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Interface for objects that can be rotated in the scene.
+ *
+ * @module
+ */
+export interface DIVERotatable {
+    isRotatable: true;
+    onRotate?: () => void;
+}

package/build/src/interface/Scalable.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Interface for objects that can be scaled in the scene.
+ *
+ * @module
+ */
+export interface DIVEScalable {
+    isScalable: true;
+    onScale?: () => void;
+}

package/build/src/interface/Selectable.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Interface for objects that can be selected in the scene.
+ *
+ * @module
+ */
+export interface DIVESelectable {
+    isSelectable: true;
+    onSelect?: () => void;
+    onDeselect?: () => void;
+}

package/build/src/io/IO.d.ts

@@ -0,0 +1,10 @@
+import { DIVESceneFileType } from '../types';
+import { DIVEScene } from '../scene/Scene';
+export declare class DIVEIO {
+    private _scene;
+    private _gltfIO;
+    constructor(scene: DIVEScene);
+    Import<FileType extends keyof DIVESceneFileType>(type: FileType, url: string): Promise<DIVESceneFileType[FileType] | null>;
+    Export<FileType extends keyof DIVESceneFileType>(type: FileType): Promise<string | null>;
+    private _createBlobURL;
+}

package/build/src/io/gltf/GLTFIO.d.ts

@@ -0,0 +1,12 @@
+import { GLTF } from 'three/examples/jsm/loaders/GLTFLoader';
+import { Object3D } from 'three';
+export declare class DIVEGLTFIO {
+    private _importer;
+    private _exporter;
+    constructor();
+    Import(url: string, onProgress?: (progress: number) => void): Promise<GLTF>;
+    Export(object: Object3D, binary: true, onlyVisible: boolean): Promise<ArrayBuffer>;
+    Export(object: Object3D, binary: false, onlyVisible: boolean): Promise<{
+        [key: string]: unknown;
+    }>;
+}

package/build/src/light/AmbientLight.d.ts

@@ -0,0 +1,17 @@
+import { Color, Object3D } from 'three';
+/**
+ * A basic ambient light.
+ *
+ * Can change the color, intensity, and visibility of the light.
+ *
+ * @module
+ */
+export default class DIVEAmbientLight extends Object3D {
+    readonly isDIVELight: true;
+    readonly isDIVEAmbientLight: true;
+    private _light;
+    constructor();
+    SetColor(color: Color): void;
+    SetIntensity(intensity: number): void;
+    SetEnabled(enabled: boolean): void;
+}

package/build/src/light/PointLight.d.ts

@@ -0,0 +1,29 @@
+import { Color, Object3D } from 'three';
+import { DIVEMovable } from '../interface/Movable';
+import { DIVESelectable } from '../interface/Selectable';
+import { TransformControls } from 'three/examples/jsm/controls/TransformControls';
+/**
+ * A basic point light.
+ *
+ * Can change the color, intensity, and visibility of the light.
+ *
+ * Can be moved and selected.
+ *
+ * @module
+ */
+export default class DIVEPointLight extends Object3D implements DIVESelectable, DIVEMovable {
+    readonly isDIVELight: true;
+    readonly isDIVEPointLight: true;
+    readonly isMovable: true;
+    readonly isSelectable: true;
+    gizmo: TransformControls | null;
+    private light;
+    private mesh;
+    constructor();
+    SetColor(color: Color): void;
+    SetIntensity(intensity: number): void;
+    SetEnabled(enabled: boolean): void;
+    onMove(): void;
+    onSelect(): void;
+    onDeselect(): void;
+}

package/build/src/light/SceneLight.d.ts

@@ -0,0 +1,18 @@
+import { Color, Object3D } from 'three';
+/**
+ * A complex scene light.
+ *
+ * Can change the color, intensity, and visibility of the light.
+ *
+ * @module
+ */
+export default class DIVESceneLight extends Object3D {
+    readonly isDIVELight: true;
+    readonly isDIVESceneLight: true;
+    private _hemiLight;
+    private _dirLight;
+    constructor();
+    SetColor(color: Color): void;
+    SetIntensity(intensity: number): void;
+    SetEnabled(enabled: boolean): void;
+}

package/build/src/loadingmanager/LoadingManager.d.ts

@@ -0,0 +1,14 @@
+import { GLTF } from 'three/examples/jsm/loaders/GLTFLoader';
+/**
+ * A basic loading manager.
+ *
+ * @module
+ */
+export declare class DIVELoadingManager {
+    private gltfloader;
+    private dracoloader;
+    constructor();
+    private progress;
+    LoadGLTF(uri: string): Promise<GLTF>;
+    PollProgress(): number;
+}

package/build/src/math/ceil/ceilExp.d.ts

@@ -0,0 +1 @@
+export default function ceilExp(number: number, decimals?: number): number;

package/build/src/math/degToRad/degToRad.d.ts

@@ -0,0 +1 @@
+export default function degToRad(degrees: number): number;

package/build/src/math/floor/floorExp.d.ts

@@ -0,0 +1 @@
+export default function floorExp(number: number, decimals?: number): number;

package/build/src/math/helper/shift.d.ts

@@ -0,0 +1 @@
+export default function shift(value: number, exponent: number): number;

package/build/src/math/index.d.ts

@@ -0,0 +1,18 @@
+import { default as ceilExp } from './ceil/ceilExp.ts';
+import { default as floorExp } from './floor/floorExp.ts';
+import { default as roundExp } from './round/roundExp.ts';
+import { default as signedAngleTo } from './signedAngleTo/signedAngleTo.ts';
+import { default as toFixedExp } from './toFixed/toFixedExp.ts';
+import { default as truncateExp } from './truncate/truncateExp.ts';
+import { default as radToDeg } from './radToDeg/radToDeg.ts';
+import { default as degToRad } from './degToRad/degToRad.ts';
+export declare const DIVEMath: {
+    ceilExp: typeof ceilExp;
+    floorExp: typeof floorExp;
+    roundExp: typeof roundExp;
+    toFixedExp: typeof toFixedExp;
+    truncateExp: typeof truncateExp;
+    signedAngleTo: typeof signedAngleTo;
+    radToDeg: typeof radToDeg;
+    degToRad: typeof degToRad;
+};

package/build/src/math/radToDeg/radToDeg.d.ts

@@ -0,0 +1 @@
+export default function radToDeg(radians: number): number;

package/build/src/math/round/roundExp.d.ts

@@ -0,0 +1 @@
+export default function roundExponential(number: number, decimals?: number): number;

package/build/src/math/signedAngleTo/signedAngleTo.d.ts

@@ -0,0 +1,9 @@
+import { Vector3 } from 'three';
+/**
+ * Calculate the signed angle between two vectors. Only works when the vectors are on the same plane.
+ * @param vecB Start Vector
+ * @param vecA Target Vector
+ * @param planeNormal The vector's plane normal
+ * @returns Signed angle in radians
+ */
+export default function signedAngleTo(vecA: Vector3, vecB: Vector3, planeNormal: Vector3): number;

package/build/src/math/toFixed/toFixedExp.d.ts

@@ -0,0 +1 @@
+export default function toFixedExp(number: number, decimals?: number): string;

package/build/src/math/truncate/truncateExp.d.ts

@@ -0,0 +1 @@
+export default function truncateExp(number: number, decimals?: number): number;

package/build/src/mediacreator/MediaCreator.d.ts

@@ -0,0 +1,17 @@
+import { DIVEScene } from '../scene/Scene.ts';
+import { DIVERenderer } from '../renderer/Renderer.ts';
+import { default as DIVEOrbitControls } from '../controls/OrbitControls.ts';
+import { Vector3Like } from 'three';
+/**
+ * Creates renderings of the current scene
+ *
+ * @module
+ */
+export declare class DIVEMediaCreator {
+    private renderer;
+    private scene;
+    private controller;
+    constructor(renderer: DIVERenderer, scene: DIVEScene, controller: DIVEOrbitControls);
+    GenerateMedia(position: Vector3Like, target: Vector3Like, width: number, height: number): string;
+    DrawCanvas(canvasElement?: HTMLCanvasElement): HTMLCanvasElement;
+}

package/build/src/model/Model.d.ts

@@ -0,0 +1,21 @@
+import { GLTF } from 'three/examples/jsm/loaders/GLTFLoader';
+import { COMMaterial } from '../com/types';
+import { DIVENode } from '../node/Node';
+/**
+ * A basic model class.
+ *
+ * It does calculate it's own bounding box which is used for positioning on the floor.
+ *
+ * Can be moved and selected.
+ *
+ * @module
+ */
+export declare class DIVEModel extends DIVENode {
+    readonly isDIVEModel: true;
+    private _mesh;
+    private _material;
+    SetModel(gltf: GLTF): void;
+    SetMaterial(material: Partial<COMMaterial>): void;
+    PlaceOnFloor(): void;
+    DropIt(): void;
+}

package/build/src/node/Node.d.ts

@@ -0,0 +1,24 @@
+import { Box3, Object3D, Vector3, Vector3Like } from 'three';
+import { DIVEMovable } from '../interface/Movable';
+import { DIVESelectable } from '../interface/Selectable';
+import { TransformControls } from 'three/examples/jsm/controls/TransformControls';
+export declare class DIVENode extends Object3D implements DIVESelectable, DIVEMovable {
+    readonly isDIVENode: true;
+    readonly isSelectable: true;
+    readonly isMovable: true;
+    gizmo: TransformControls | null;
+    protected _positionWorldBuffer: Vector3;
+    protected _boundingBox: Box3;
+    constructor();
+    SetPosition(position: Vector3Like): void;
+    SetRotation(rotation: Vector3Like): void;
+    SetScale(scale: Vector3Like): void;
+    SetVisibility(visible: boolean): void;
+    SetToWorldOrigin(): void;
+    /**
+     * Can be called when the object is moved from a foreign object (gizmo, parent, etc.) to update the object's position.
+     */
+    onMove(): void;
+    onSelect(): void;
+    onDeselect(): void;
+}

package/build/src/primitive/Primitive.d.ts

@@ -0,0 +1,28 @@
+import { DIVENode } from '../node/Node';
+import { COMGeometry, COMMaterial } from '../com/types';
+/**
+ * A basic model class.
+ *
+ * It does calculate it's own bounding box which is used for positioning on the floor.
+ *
+ * Can be moved and selected.
+ *
+ * @module
+ */
+export declare class DIVEPrimitive extends DIVENode {
+    readonly isDIVEPrimitive: true;
+    private _mesh;
+    constructor();
+    SetGeometry(geometry: COMGeometry): void;
+    SetMaterial(material: Partial<COMMaterial>): void;
+    PlaceOnFloor(): void;
+    DropIt(): void;
+    private assembleGeometry;
+    private createCylinderGeometry;
+    private createSphereGeometry;
+    private createPyramidGeometry;
+    private createBoxGeometry;
+    private createConeGeometry;
+    private createWallGeometry;
+    private createPlaneGeometry;
+}

package/build/src/primitive/floor/Floor.d.ts

@@ -0,0 +1,14 @@
+import { ColorRepresentation, Mesh } from 'three';
+/**
+ * A basic floor geometry.
+ *
+ * Can change the color and visibility of the floor.
+ *
+ * @module
+ */
+export declare class DIVEFloor extends Mesh {
+    isFloor: true;
+    constructor();
+    SetVisibility(visible: boolean): void;
+    SetColor(color: ColorRepresentation): void;
+}

package/build/src/renderer/Renderer.d.ts

@@ -0,0 +1,69 @@
+import { Camera, Scene, ShadowMapType, ToneMapping, WebGLRenderer } from 'three';
+export type DIVERendererSettings = {
+    antialias: boolean;
+    alpha: boolean;
+    stencil: boolean;
+    shadowMapEnabled: boolean;
+    shadowMapType: ShadowMapType;
+    toneMapping: ToneMapping;
+    canvas?: HTMLCanvasElement;
+};
+export declare const DIVERendererDefaultSettings: DIVERendererSettings;
+export type DIVERenderCallback = (time: DOMHighResTimeStamp, frame: XRFrame) => void;
+/**
+ * A changed version of the WebGLRenderer.
+ *
+ * Has to be started manually by calling StartRenderer().
+ *
+ * @module
+ */
+export declare class DIVERenderer extends WebGLRenderer {
+    private paused;
+    private running;
+    private force;
+    private preRenderCallbacks;
+    private postRenderCallbacks;
+    constructor(rendererSettings?: Partial<DIVERendererSettings>);
+    Dispose(): void;
+    StartRenderer(scene: Scene, cam: Camera): void;
+    PauseRenderer(): void;
+    ResumeRenderer(): void;
+    StopRenderer(): void;
+    OnResize(width: number, height: number): void;
+    /**
+     * Adds a callback to the render loop before actual render call.
+     * @param callback Executed before rendering.
+     * @returns uuid to remove the callback.
+     */
+    AddPreRenderCallback(callback: DIVERenderCallback): string;
+    /**
+     * Removes a callback from the render loop before actual render call.
+     * @param uuid of callback to remove.
+     * @returns if removing was successful.
+     */
+    RemovePreRenderCallback(uuid: string): boolean;
+    /**
+     * Adds a callback to the render loop after actual render call.
+     * @param callback Executed after rendering.
+     * @returns uuid to remove the callback.
+     */
+    AddPostRenderCallback(callback: DIVERenderCallback): string;
+    /**
+     * Removes a callback from the render loop after actual render call.
+     * @param uuid of callback to remove.
+     * @returns if removing was successful.
+     */
+    RemovePostRenderCallback(uuid: string): boolean;
+    /**
+     * Forces the renderer to render the next frame.
+     */
+    ForceRendering(): void;
+    /**
+     * Internal render loop.
+     *
+     * To control renderloop you can add callbacks via AddPreRenderCallback() and AddPostRenderCallback().
+     * @param scene Scene to render.
+     * @param cam Camera to render with.
+     */
+    private internal_render;
+}

package/build/src/scene/Scene.d.ts

@@ -0,0 +1,46 @@
+import { Scene, Box3, ColorRepresentation } from 'three';
+import { COMModel, COMEntity } from '../com/types';
+import { DIVERoot } from './root/Root';
+import { DIVEGrid } from '../grid/Grid';
+import { DIVEFloor } from '../primitive/floor/Floor';
+import { DIVESceneObject } from '../types';
+import { DIVEXRRoot } from './xrroot/XRRoot';
+import { DIVERenderer } from '../renderer/Renderer';
+/**
+ * A basic scene class.
+ *
+ * Comes with a root object that contains all the scene objects.
+ *
+ * @module
+ */
+export declare class DIVEScene extends Scene {
+    private _root;
+    private _floor;
+    private _grid;
+    get Root(): DIVERoot;
+    private _xrRoot;
+    get XRRoot(): DIVEXRRoot;
+    get Floor(): DIVEFloor;
+    get Grid(): DIVEGrid;
+    constructor();
+    InitXR(renderer: DIVERenderer): void;
+    DisposeXR(): void;
+    SetBackground(color: ColorRepresentation): void;
+    ComputeSceneBB(): Box3;
+    GetSceneObject<T extends DIVESceneObject>(object: Partial<COMEntity> & {
+        id: string;
+    }): T | undefined;
+    AddSceneObject(object: COMEntity): void;
+    UpdateSceneObject(object: Partial<COMEntity> & {
+        id: string;
+        entityType: string;
+    }): void;
+    DeleteSceneObject(object: Partial<COMEntity> & {
+        id: string;
+        entityType: string;
+    }): void;
+    PlaceOnFloor(object: Partial<COMModel> & {
+        id: string;
+        entityType: string;
+    }): void;
+}

package/build/src/scene/root/Root.d.ts

@@ -0,0 +1,42 @@
+import { Box3, Object3D } from 'three';
+import { COMEntity } from '../../com/types';
+import { DIVESceneObject } from '../../types';
+/**
+ * A basic scene node to hold grid, floor and all lower level roots.
+ *
+ * @module
+ */
+export declare class DIVERoot extends Object3D {
+    readonly isDIVERoot: true;
+    private loadingManager;
+    constructor();
+    ComputeSceneBB(): Box3;
+    GetSceneObject<T extends DIVESceneObject>(object: Partial<COMEntity> & {
+        id: string;
+    }): T | undefined;
+    AddSceneObject(object: COMEntity): void;
+    UpdateSceneObject(object: Partial<COMEntity> & {
+        id: string;
+        entityType: string;
+    }): void;
+    DeleteSceneObject(object: Partial<COMEntity> & {
+        id: string;
+        entityType: string;
+    }): void;
+    PlaceOnFloor(object: Partial<COMEntity> & {
+        id: string;
+        entityType: string;
+    }): void;
+    private updateLight;
+    private updateModel;
+    private updatePrimitive;
+    private updateGroup;
+    private deleteLight;
+    private deleteModel;
+    private deletePrimitive;
+    private deleteGroup;
+    private placeOnFloor;
+    private setParent;
+    private detachTransformControls;
+    private findScene;
+}

package/build/src/scene/xrroot/XRRoot.d.ts

@@ -0,0 +1,17 @@
+import { Object3D } from 'three';
+import { DIVERoot } from '../root/Root';
+import { DIVERenderer } from '../../renderer/Renderer';
+import { DIVEXRLightRoot } from './xrlightroot/XRLightRoot';
+import { DIVEScene } from '../Scene';
+export declare class DIVEXRRoot extends Object3D {
+    private _xrLightRoot;
+    private _xrModelRoot;
+    private _xrHandNode;
+    get XRModelRoot(): DIVERoot;
+    get XRLightRoot(): DIVEXRLightRoot;
+    get XRHandNode(): Object3D;
+    private _xrShadowPlane;
+    constructor(scene: DIVEScene);
+    InitLightEstimation(renderer: DIVERenderer): void;
+    DisposeLightEstimation(): void;
+}

package/build/src/scene/xrroot/xrlightroot/XRLightRoot.d.ts

@@ -0,0 +1,13 @@
+import { DIVERenderer } from '../../../renderer/Renderer';
+import { Object3D } from 'three';
+import { DIVEScene } from '../../Scene';
+export declare class DIVEXRLightRoot extends Object3D {
+    private _scene;
+    private _xrLight;
+    private _lightRoot;
+    constructor(scene: DIVEScene);
+    InitLightEstimation(renderer: DIVERenderer): void;
+    DisposeLightEstimation(): void;
+    private onEstimationStart;
+    private onEstimationEnd;
+}

package/build/src/toolbox/BaseTool.d.ts

@@ -0,0 +1,48 @@
+import { Intersection, Object3D, Raycaster, Vector2, Vector3 } from 'three';
+import { DIVEScene } from '../scene/Scene';
+import { default as DIVEOrbitControls } from '../controls/OrbitControls';
+import { DIVEDraggable } from '../interface/Draggable';
+import { DIVEHoverable } from '../interface/Hoverable';
+export type DraggableEvent = {
+    dragStart: Vector3;
+    dragCurrent: Vector3;
+    dragEnd: Vector3;
+    dragDelta: Vector3;
+};
+export declare abstract class DIVEBaseTool {
+    readonly POINTER_DRAG_THRESHOLD: number;
+    name: string;
+    protected _canvas: HTMLElement;
+    protected _scene: DIVEScene;
+    protected _controller: DIVEOrbitControls;
+    protected _pointer: Vector2;
+    protected get _pointerAnyDown(): boolean;
+    protected _pointerPrimaryDown: boolean;
+    protected _pointerMiddleDown: boolean;
+    protected _pointerSecondaryDown: boolean;
+    protected _lastPointerDown: Vector2;
+    protected _lastPointerUp: Vector2;
+    protected _raycaster: Raycaster;
+    protected _intersects: Intersection[];
+    protected _hovered: (Object3D & DIVEHoverable) | null;
+    protected _dragging: boolean;
+    protected _dragStart: Vector3;
+    protected _dragCurrent: Vector3;
+    protected _dragEnd: Vector3;
+    protected _dragDelta: Vector3;
+    protected _draggable: DIVEDraggable | null;
+    protected _dragRaycastOnObjects: Object3D[] | null;
+    protected constructor(scene: DIVEScene, controller: DIVEOrbitControls);
+    Activate(): void;
+    Deactivate(): void;
+    onPointerDown(e: PointerEvent): void;
+    onDragStart(e: PointerEvent): void;
+    onPointerMove(e: PointerEvent): void;
+    onDrag(e: PointerEvent): void;
+    onPointerUp(e: PointerEvent): void;
+    onClick(e: PointerEvent): void;
+    onDragEnd(e: PointerEvent): void;
+    onWheel(e: WheelEvent): void;
+    protected raycast(objects?: Object3D[]): Intersection[];
+    private pointerWasDragged;
+}

package/build/src/toolbox/Toolbox.d.ts

@@ -0,0 +1,31 @@
+import { default as DIVEOrbitControls } from '../controls/OrbitControls.ts';
+import { DIVEScene } from '../scene/Scene.ts';
+import { DIVEBaseTool } from './BaseTool.ts';
+import { DIVESelectTool } from './select/SelectTool.ts';
+export type ToolType = 'select' | 'none';
+/**
+ * A Toolbox to activate and deactivate tools to use with the pointer.
+ *
+ * @module
+ */
+export default class DIVEToolbox {
+    static readonly DefaultTool = "select";
+    private _scene;
+    private _controller;
+    private _activeTool;
+    private _selectTool;
+    get selectTool(): DIVESelectTool;
+    constructor(scene: DIVEScene, controller: DIVEOrbitControls);
+    Dispose(): void;
+    GetActiveTool(): DIVEBaseTool | null;
+    UseTool(tool: ToolType): void;
+    SetGizmoMode(mode: 'translate' | 'rotate' | 'scale'): void;
+    SetGizmoVisibility(active: boolean): void;
+    SetGizmoScaleLinked(linked: boolean): void;
+    onPointerMove(e: PointerEvent): void;
+    onPointerDown(e: PointerEvent): void;
+    onPointerUp(e: PointerEvent): void;
+    onWheel(e: WheelEvent): void;
+    private addEventListeners;
+    private removeEventListeners;
+}