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

package/build/src/animation/AnimationSystem.d.ts

@@ -0,0 +1,16 @@
+import { Tween } from '@tweenjs/tween.js';
+import { DIVERenderer } from '../renderer/Renderer';
+/**
+ * Updates all animations.
+ * DIVE uses Tween.js to handle animations.
+ *
+ * @module
+ */
+export declare class DIVEAnimationSystem {
+    private _renderer;
+    private _rendererCallbackId;
+    constructor(renderer: DIVERenderer);
+    Dispose(): void;
+    Update(): void;
+    Animate<T extends object>(object: T): Tween<T>;
+}

package/build/src/ar/AR.d.ts

@@ -0,0 +1,21 @@
+import { DIVEScene } from '../scene/Scene';
+import { DIVERenderer } from '../renderer/Renderer';
+import { default as DIVEOrbitControls } from '../controls/OrbitControls';
+export type DIVEAROptions = {
+    arPlacement: 'horizontal' | 'vertical';
+    arScale: 'auto' | 'fixed';
+    /**
+     * experimental, currently deactivated
+     */
+    useWebXR: false;
+};
+export declare class DIVEAR {
+    private _renderer;
+    private _scene;
+    private _controller;
+    constructor(renderer: DIVERenderer, scene: DIVEScene, controller: DIVEOrbitControls);
+    Launch(options?: DIVEAROptions): Promise<void>;
+    private tryARQuickLook;
+    private tryWebXR;
+    private trySceneViewer;
+}

package/build/src/ar/arquicklook/ARQuickLook.d.ts

@@ -0,0 +1,8 @@
+import { DIVEScene } from '../../scene/Scene';
+import { DIVEAROptions } from '../AR';
+export declare class DIVEARQuickLook {
+    private static _usdzExporter;
+    static Launch(scene: DIVEScene, options?: DIVEAROptions): Promise<void>;
+    private static extractModels;
+    private static launchARFromNode;
+}

package/build/src/ar/sceneviewer/SceneViewer.d.ts

@@ -0,0 +1,7 @@
+import { DIVEScene } from '../../scene/Scene';
+import { DIVEAROptions } from '../AR';
+export declare class DIVESceneViewer {
+    static Launch(scene: DIVEScene, options?: DIVEAROptions): void;
+    private static launchSceneViewer;
+    private static findSceneViewerSrc;
+}

package/build/src/ar/webxr/WebXR.d.ts

@@ -0,0 +1,21 @@
+import { default as DIVEOrbitControls } from '../../controls/OrbitControls';
+import { DIVERenderer } from '../../renderer/Renderer';
+import { DIVEScene } from '../../scene/Scene';
+export declare class DIVEWebXR {
+    private static _renderer;
+    private static _scene;
+    private static _controller;
+    private static _cameraPosition;
+    private static _cameraTarget;
+    private static _renderCallbackId;
+    private static _session;
+    private static _referenceSpaceType;
+    private static _overlay;
+    private static _options;
+    private static _xrController;
+    static Launch(renderer: DIVERenderer, scene: DIVEScene, controller: DIVEOrbitControls): Promise<void>;
+    static Update(_time: DOMHighResTimeStamp, frame: XRFrame): void;
+    static End(): void;
+    private static _onSessionStarted;
+    private static _onSessionEnded;
+}

package/build/src/ar/webxr/controller/WebXRController.d.ts

@@ -0,0 +1,46 @@
+import { Object3D } from 'three';
+import { DIVERenderer } from '../../../renderer/Renderer';
+import { DIVEScene } from '../../../scene/Scene';
+export declare class DIVEWebXRController extends Object3D {
+    private _renderer;
+    private _scene;
+    private _session;
+    private _frameBuffer;
+    private _xrRaycaster;
+    private _origin;
+    private _crosshair;
+    private _touchscreenControls;
+    private _handNodeInitialPosition;
+    private _xrCamera;
+    private _placed;
+    private _grabbedObject;
+    private _arHitPosition;
+    private _arHitQuaternion;
+    private _arHitScale;
+    private _initialObjectPosition;
+    private _initialRaycastHit;
+    private _deltaRaycastHit;
+    private _touchQuaterion;
+    private _touchScale;
+    private _scaleThreshold;
+    constructor(session: XRSession, renderer: DIVERenderer, scene: DIVEScene);
+    Init(): Promise<this>;
+    Dispose(): void;
+    Update(frame: XRFrame): void;
+    private updateHandNode;
+    private initOrigin;
+    private placeObjects;
+    private updateObject;
+    private onTouchStart;
+    private onTouchMove;
+    private onTouchEnd;
+    private _startTouchQuaternion;
+    private onRotateStart;
+    private onRotateMove;
+    private _startTouchScale;
+    private onPinchStart;
+    private onPinchMove;
+    private prepareScene;
+    private restoreScene;
+    private initRaycaster;
+}

package/build/src/ar/webxr/crosshair/WebXRCrosshair.d.ts

@@ -0,0 +1,7 @@
+import { Mesh, Object3D } from 'three';
+export declare class DIVEWebXRCrosshair extends Object3D {
+    set mesh(mesh: Mesh | undefined);
+    constructor(mesh?: Mesh);
+    UseDefaultMesh(): void;
+    UpdateFromPose(pose: XRPose): void;
+}

package/build/src/ar/webxr/origin/WebXROrigin.d.ts

@@ -0,0 +1,31 @@
+import { Matrix4, Quaternion, Vector3 } from 'three';
+import { DIVERenderer } from '../../../renderer/Renderer';
+export declare class DIVEWebXROrigin {
+    private _renderer;
+    private _session;
+    private _requesting;
+    private _initialized;
+    private _referenceSpaceBuffer;
+    private _hitTestSource;
+    private _entityTypes;
+    private _hitTestResultBuffer;
+    private _raycastHitCounter;
+    private _originSet;
+    private _originSetResolve;
+    get originSet(): Promise<void>;
+    private _matrix;
+    get matrix(): Matrix4;
+    private set matrix(value);
+    private _position;
+    get position(): Vector3;
+    private _quaternion;
+    get quaternion(): Quaternion;
+    private _scale;
+    get scale(): Vector3;
+    constructor(session: XRSession, renderer: DIVERenderer, entityTypes?: XRHitTestTrackableType[]);
+    Init(): Promise<this>;
+    Dispose(): void;
+    Update(frame: XRFrame): void;
+    private onHitFound;
+    private onHitLost;
+}

package/build/src/ar/webxr/overlay/Overlay.d.ts

@@ -0,0 +1,8 @@
+export declare class Overlay {
+    private _element;
+    get Element(): HTMLDivElement;
+    private _closeButton;
+    get CloseButton(): SVGSVGElement;
+    constructor();
+    private createCloseButton;
+}

package/build/src/ar/webxr/raycaster/WebXRRaycaster.d.ts

@@ -0,0 +1,40 @@
+import { Matrix4, Mesh, Vector3 } from 'three';
+import { DIVERenderer } from '../../../renderer/Renderer';
+import { DIVEScene } from '../../../scene/Scene';
+import { DIVEEventExecutor } from '../../../events/EventExecutor';
+/**
+ * object is undefined when AR world is hit.
+ */
+export type DIVEHitResult = {
+    point: Vector3;
+    matrix: Matrix4;
+    object?: Mesh;
+};
+export type DIVEWebXRRaycasterEvents = {
+    AR_HIT_FOUND: {
+        hit: DIVEHitResult;
+    };
+    AR_HIT_LOST: undefined;
+    SCENE_HIT_FOUND: {
+        hit: DIVEHitResult;
+    };
+    SCENE_HIT_LOST: undefined;
+};
+export declare class DIVEWebXRRaycaster extends DIVEEventExecutor<DIVEWebXRRaycasterEvents> {
+    private _session;
+    private _initialized;
+    private _threeRaycaster;
+    private _arRaycaster;
+    private _arHitResultBuffer;
+    private _sceneHitResultBuffer;
+    private _hasHit;
+    constructor(session: XRSession, renderer: DIVERenderer, scene: DIVEScene);
+    Dispose(): void;
+    Init(): Promise<this>;
+    GetARIntersections(frame: XRFrame): DIVEHitResult[];
+    GetSceneIntersections(): DIVEHitResult[];
+    private onARHitFound;
+    private onARHitLost;
+    private onSceneHitFound;
+    private onSceneHitLost;
+}

package/build/src/ar/webxr/raycaster/ar/WebXRRaycasterAR.d.ts

@@ -0,0 +1,15 @@
+import { DIVERenderer } from '../../../../renderer/Renderer';
+import { DIVEHitResult } from '../WebXRRaycaster';
+export declare class DIVEWebXRRaycasterAR {
+    private _session;
+    private _renderer;
+    private _transientHitTestSource;
+    private _referenceSpaceBuffer;
+    private _requesting;
+    private _initialized;
+    private _hitMatrixBuffer;
+    constructor(session: XRSession, renderer: DIVERenderer);
+    Dispose(): void;
+    Init(): Promise<this>;
+    GetIntersections(frame: XRFrame): DIVEHitResult[];
+}

package/build/src/ar/webxr/raycaster/three/WebXRRaycasterTHREE.d.ts

@@ -0,0 +1,12 @@
+import { DIVERenderer } from '../../../../renderer/Renderer';
+import { DIVEScene } from '../../../../scene/Scene';
+import { DIVEHitResult } from '../WebXRRaycaster';
+export declare class DIVEWebXRRaycasterTHREE {
+    private _renderer;
+    private _scene;
+    private _controller;
+    private _raycaster;
+    constructor(renderer: DIVERenderer, scene: DIVEScene);
+    Init(): Promise<this>;
+    GetIntersections(): DIVEHitResult[];
+}

package/build/src/ar/webxr/touchscreencontrols/WebXRTouchscreenControls.d.ts

@@ -0,0 +1,73 @@
+import { Vector2 } from 'three';
+import { DIVEEventExecutor } from '../../../events/EventExecutor';
+export type DIVETouchscreenEvents = {
+    TOUCH_START: {
+        touches: {
+            current: Vector2;
+        }[];
+        touchCount: number;
+    };
+    TOUCH_MOVE: {
+        touches: {
+            current: Vector2;
+            delta: Vector2;
+        }[];
+        touchCount: number;
+    };
+    TOUCH_END: {
+        touches: {
+            current: Vector2;
+        }[];
+        touchCount: number;
+    };
+    ROTATE_START: {
+        current: number;
+    };
+    ROTATE_MOVE: {
+        current: number;
+        delta: number;
+    };
+    ROTATE_END: {
+        current: number;
+    };
+    PINCH_START: {
+        current: number;
+    };
+    PINCH_MOVE: {
+        current: number;
+        delta: number;
+    };
+    PINCH_END: {
+        current: number;
+    };
+};
+export declare class DIVEWebXRTouchscreenControls extends DIVEEventExecutor<DIVETouchscreenEvents> {
+    private _session;
+    private _touchCount;
+    private _touches;
+    private _handleRotateStarted;
+    private _handleRotateMoved;
+    private _handleRotateEnded;
+    private _startAngle;
+    private _lastAngle;
+    private _angleDelta;
+    private _handlePinchStarted;
+    private _handlePinchMoved;
+    private _handlePinchEnded;
+    private _scaleDistanceStart;
+    private _currentDistance;
+    private _deltaDistance;
+    constructor(session: XRSession);
+    Dispose(): void;
+    private onTouchStart;
+    private onTouchMove;
+    private onTouchEnd;
+    private onSessionSelectStart;
+    private onSessionSelectEnd;
+    private handleRotateStart;
+    private handleRotateMoved;
+    private handleRotateEnded;
+    private handlePinchStart;
+    private handlePinchMoved;
+    private handlePinchEnded;
+}

package/build/src/axiscamera/AxisCamera.d.ts

@@ -0,0 +1,18 @@
+import { Matrix4, OrthographicCamera } from 'three';
+import { DIVERenderer } from '../renderer/Renderer.ts';
+import { DIVEScene } from '../scene/Scene.ts';
+import { default as DIVEOrbitControls } from '../controls/OrbitControls.ts';
+/**
+ * Shows the scene axes in the bottom left corner of the screen.
+ *
+ * @module
+ */
+export default class DIVEAxisCamera extends OrthographicCamera {
+    private axesHelper;
+    private _renderer;
+    private _scene;
+    private _renderCallbackId;
+    constructor(renderer: DIVERenderer, scene: DIVEScene, controls: DIVEOrbitControls);
+    Dispose(): void;
+    SetFromCameraMatrix(matrix: Matrix4): void;
+}

package/build/src/camera/PerspectiveCamera.d.ts

@@ -0,0 +1,20 @@
+import { PerspectiveCamera } from 'three';
+export type DIVEPerspectiveCameraSettings = {
+    fov: number;
+    near: number;
+    far: number;
+};
+export declare const DIVEPerspectiveCameraDefaultSettings: DIVEPerspectiveCameraSettings;
+/**
+ * A Perspective camera. Can change the layer mask to show different objects.
+ *
+ * @module
+ */
+export default class DIVEPerspectiveCamera extends PerspectiveCamera {
+    static readonly EDITOR_VIEW_LAYER_MASK: number;
+    static readonly LIVE_VIEW_LAYER_MASK = 16;
+    onSetCameraLayer: (mask: number) => void;
+    constructor(settings?: Partial<DIVEPerspectiveCameraSettings>);
+    OnResize(width: number, height: number): void;
+    SetCameraLayer(layer: 'LIVE' | 'EDITOR'): void;
+}

package/build/src/com/Communication.d.ts

@@ -0,0 +1,77 @@
+import { Actions } from './actions/index.ts';
+import { DIVEScene } from '../scene/Scene.ts';
+import { default as DIVEToolbox } from '../toolbox/Toolbox.ts';
+import { default as DIVEOrbitControls } from '../controls/OrbitControls.ts';
+import { DIVERenderer } from '../renderer/Renderer.ts';
+type EventListener<Action extends keyof Actions> = (payload: Actions[Action]['PAYLOAD']) => void;
+type Unsubscribe = () => boolean;
+/**
+ * Main class for communicating with DIVE.
+ *
+ * You can subscribe to actions and perform them from outside and inside DIVE.
+ *
+ * ```ts
+ * import { DIVE } from "@shopware-ag/dive";
+ *
+ * const dive = new DIVE();
+ *
+ * dive.Communication.Subscribe('GET_ALL_SCENE_DATA', () => {
+ *  // do something
+ * }));
+ *
+ * dive.Communication.PerformAction('GET_ALL_SCENE_DATA', {});
+ * ```
+ *
+ * @module
+ */
+export declare class DIVECommunication {
+    private static __instances;
+    static get(id: string): DIVECommunication | undefined;
+    private _id;
+    get id(): string;
+    private renderer;
+    private scene;
+    private controller;
+    private toolbox;
+    private _mediaGenerator;
+    private get mediaGenerator();
+    private _io;
+    private get io();
+    private _ar;
+    private get ar();
+    private registered;
+    private listeners;
+    constructor(renderer: DIVERenderer, scene: DIVEScene, controls: DIVEOrbitControls, toolbox: DIVEToolbox);
+    DestroyInstance(): boolean;
+    PerformAction<Action extends keyof Actions>(action: Action, payload: Actions[Action]['PAYLOAD']): Actions[Action]['RETURN'];
+    Subscribe<Action extends keyof Actions>(type: Action, listener: EventListener<Action>): Unsubscribe;
+    private dispatch;
+    private getAllSceneData;
+    private getAllObjects;
+    private getObjects;
+    private addObject;
+    private updateObject;
+    private deleteObject;
+    private selectObject;
+    private deselectObject;
+    private setBackground;
+    private dropIt;
+    private placeOnFloor;
+    private setCameraTransform;
+    private getCameraTransform;
+    private moveCamera;
+    private setCameraLayer;
+    private resetCamera;
+    private computeEncompassingView;
+    private zoomCamera;
+    private setGizmoMode;
+    private setGizmoVisibility;
+    private setGizmoScaleLinked;
+    private useTool;
+    private modelLoaded;
+    private updateScene;
+    private generateMedia;
+    private setParent;
+    private exportScene;
+}
+export type { Actions } from './actions/index.ts';

package/build/src/com/actions/camera/computeencompassingview.d.ts

@@ -0,0 +1,9 @@
+import { Vector3Like } from 'three';
+export default interface COMPUTE_ENCOMPASSING_VIEW {
+    DESCRIPTION: 'Calculates the camera position and target to view the whole scene. (experimental)';
+    PAYLOAD: object;
+    RETURN: {
+        position: Vector3Like;
+        target: Vector3Like;
+    };
+}

package/build/src/com/actions/camera/getcameratransform.d.ts

@@ -0,0 +1,9 @@
+import { Vector3Like } from 'three';
+export default interface GET_CAMERA_TRANSFORM {
+    DESCRIPTION: 'Returns the current camera position and target.';
+    PAYLOAD: object;
+    RETURN: {
+        position: Vector3Like;
+        target: Vector3Like;
+    };
+}

package/build/src/com/actions/camera/movecamera.d.ts

@@ -0,0 +1,15 @@
+import { Vector3Like } from 'three';
+export default interface MOVE_CAMERA {
+    DESCRIPTION: 'Moves the camera to a new position and target.';
+    PAYLOAD: {
+        position: Vector3Like;
+        target: Vector3Like;
+        locked: boolean;
+        duration: number;
+    } | {
+        id: string;
+        locked: boolean;
+        duration: number;
+    };
+    RETURN: boolean;
+}

package/build/src/com/actions/camera/resetcamera.d.ts

@@ -0,0 +1,7 @@
+export default interface RESET_CAMERA {
+    DESCRIPTION: 'Reset the camera to its initial position and rotation.';
+    PAYLOAD: {
+        duration: number;
+    };
+    RETURN: boolean;
+}

package/build/src/com/actions/camera/setcameralayer.d.ts

@@ -0,0 +1,7 @@
+export default interface SET_CAMERA_LAYER {
+    DESCRIPTION: 'Sets the camera layer to a certain layer.';
+    PAYLOAD: {
+        layer: 'LIVE' | 'EDITOR';
+    };
+    RETURN: boolean;
+}

package/build/src/com/actions/camera/setcameratransform.d.ts

@@ -0,0 +1,9 @@
+import { Vector3Like } from 'three';
+export default interface SET_CAMERA_TRANSFORM {
+    DESCRIPTION: 'Sets the camera position and target.';
+    PAYLOAD: {
+        position: Vector3Like;
+        target: Vector3Like;
+    };
+    RETURN: boolean;
+}

package/build/src/com/actions/camera/zoomcamera.d.ts

@@ -0,0 +1,8 @@
+export default interface ZOOM_CAMERA {
+    DESCRIPTION: 'Zooms the camera in or out by a certain amount.';
+    PAYLOAD: {
+        direction: 'IN' | 'OUT';
+        by: number;
+    };
+    RETURN: boolean;
+}

package/build/src/com/actions/index.d.ts

@@ -0,0 +1,58 @@
+import { default as SET_BACKGROUND } from './scene/setbackground.ts';
+import { default as RESET_CAMERA } from './camera/resetcamera.ts';
+import { default as SET_CAMERA_LAYER } from './camera/setcameralayer.ts';
+import { default as ZOOM_CAMERA } from './camera/zoomcamera.ts';
+import { default as SET_GIZMO_MODE } from './toolbox/select/setgizmomode.ts';
+import { default as SET_CAMERA_TRANSFORM } from './camera/setcameratransform.ts';
+import { default as MOVE_CAMERA } from './camera/movecamera.ts';
+import { default as PLACE_ON_FLOOR } from './object/model/placeonfloor.ts';
+import { default as GET_ALL_OBJECTS } from './object/getallobjects.ts';
+import { default as GET_OBJECTS } from './object/getobjects.ts';
+import { default as ADD_OBJECT } from './object/addobject.ts';
+import { default as DELETE_OBJECT } from './object/deleteobject.ts';
+import { default as UPDATE_OBJECT } from './object/updateobject.ts';
+import { default as MODEL_LOADED } from './object/model/modelloaded.ts';
+import { default as UPDATE_SCENE } from './scene/updatescene.ts';
+import { default as GENERATE_MEDIA } from './media/generatemedia.ts';
+import { default as GET_ALL_SCENE_DATA } from './scene/getallscenedata.ts';
+import { default as SELECT_OBJECT } from './object/selectobject.ts';
+import { default as DESELECT_OBJECT } from './object/deselectobject.ts';
+import { default as GET_CAMERA_TRANSFORM } from './camera/getcameratransform.ts';
+import { default as DROP_IT } from './object/model/dropit.ts';
+import { default as SET_GIZMO_VISIBILITY } from './toolbox/transform/setgizmovisible.js';
+import { default as SET_GIZMO_SCALE_LINKED } from './toolbox/transform/setgizmoscalelinked.ts';
+import { default as COMPUTE_ENCOMPASSING_VIEW } from './camera/computeencompassingview.ts';
+import { default as USE_TOOL } from './toolbox/usetool.ts';
+import { default as SET_PARENT } from './object/setparent.ts';
+import { default as EXPORT_SCENE } from './scene/exportscene.ts';
+import { default as LAUNCH_AR } from './scene/launchar.ts';
+export interface Actions {
+    GET_ALL_SCENE_DATA: GET_ALL_SCENE_DATA;
+    GET_ALL_OBJECTS: GET_ALL_OBJECTS;
+    GET_OBJECTS: GET_OBJECTS;
+    ADD_OBJECT: ADD_OBJECT;
+    UPDATE_OBJECT: UPDATE_OBJECT;
+    DELETE_OBJECT: DELETE_OBJECT;
+    SELECT_OBJECT: SELECT_OBJECT;
+    DESELECT_OBJECT: DESELECT_OBJECT;
+    SET_BACKGROUND: SET_BACKGROUND;
+    DROP_IT: DROP_IT;
+    PLACE_ON_FLOOR: PLACE_ON_FLOOR;
+    SET_CAMERA_TRANSFORM: SET_CAMERA_TRANSFORM;
+    GET_CAMERA_TRANSFORM: GET_CAMERA_TRANSFORM;
+    MOVE_CAMERA: MOVE_CAMERA;
+    RESET_CAMERA: RESET_CAMERA;
+    COMPUTE_ENCOMPASSING_VIEW: COMPUTE_ENCOMPASSING_VIEW;
+    SET_CAMERA_LAYER: SET_CAMERA_LAYER;
+    ZOOM_CAMERA: ZOOM_CAMERA;
+    SET_GIZMO_MODE: SET_GIZMO_MODE;
+    SET_GIZMO_VISIBILITY: SET_GIZMO_VISIBILITY;
+    SET_GIZMO_SCALE_LINKED: SET_GIZMO_SCALE_LINKED;
+    USE_TOOL: USE_TOOL;
+    MODEL_LOADED: MODEL_LOADED;
+    UPDATE_SCENE: UPDATE_SCENE;
+    GENERATE_MEDIA: GENERATE_MEDIA;
+    SET_PARENT: SET_PARENT;
+    EXPORT_SCENE: EXPORT_SCENE;
+    LAUNCH_AR: LAUNCH_AR;
+}

package/build/src/com/actions/media/generatemedia.d.ts

@@ -0,0 +1,15 @@
+import { Vector3Like } from 'three';
+export default interface GENERATE_MEDIA {
+    DESCRIPTION: 'Generates a screenshot, stores it in a Blob and writes the URL into the payload.';
+    PAYLOAD: ({
+        position: Vector3Like;
+        target: Vector3Like;
+    } | {
+        id: string;
+    }) & {
+        width: number;
+        height: number;
+        dataUri: string;
+    };
+    RETURN: boolean;
+}

package/build/src/com/actions/object/addobject.d.ts

@@ -0,0 +1,6 @@
+import { COMEntity } from '../../types';
+export default interface ADD_OBJECT {
+    DESCRIPTION: 'Adds an object to the scene.';
+    PAYLOAD: COMEntity;
+    RETURN: boolean;
+}

package/build/src/com/actions/object/deleteobject.d.ts

@@ -0,0 +1,8 @@
+import { COMEntity } from '../../types';
+export default interface DELETE_OBJECT {
+    DESCRIPTION: 'Deletes an object from the scene.';
+    PAYLOAD: Partial<COMEntity> & {
+        id: string;
+    };
+    RETURN: boolean;
+}

package/build/src/com/actions/object/deselectobject.d.ts

@@ -0,0 +1,8 @@
+import { COMEntity } from '../../types';
+export default interface DESELECT_OBJECT {
+    DESCRIPTION: 'Deselects an existing object.';
+    PAYLOAD: Partial<COMEntity> & {
+        id: string;
+    };
+    RETURN: boolean;
+}

package/build/src/com/actions/object/getallobjects.d.ts

@@ -0,0 +1,6 @@
+import { COMEntity } from '../../types';
+export default interface GET_ALL_OBJECTS {
+    readonly DESCRIPTION: 'Retrieves all objects in the scene.';
+    PAYLOAD: Map<string, COMEntity>;
+    RETURN: Map<string, COMEntity>;
+}

package/build/src/com/actions/object/getobjects.d.ts

@@ -0,0 +1,8 @@
+import { COMEntity } from '../../types';
+export default interface GET_OBJECTS {
+    DESCRIPTION: 'Returns a list of objects of given IDs.';
+    PAYLOAD: {
+        ids: string[];
+    };
+    RETURN: COMEntity[];
+}

package/build/src/com/actions/object/model/dropit.d.ts

@@ -0,0 +1,7 @@
+export default interface DROP_IT {
+    DESCRIPTION: 'Places an object on top of an underlying object or the floor.';
+    PAYLOAD: {
+        id: string;
+    };
+    RETURN: boolean;
+}

package/build/src/com/actions/object/model/modelloaded.d.ts

@@ -0,0 +1,7 @@
+export default interface MODEL_LOADED {
+    DESCRIPTION: 'Is triggered when a model is loaded.';
+    PAYLOAD: {
+        id: string;
+    };
+    RETURN: boolean;
+}

package/build/src/com/actions/object/model/placeonfloor.d.ts

@@ -0,0 +1,7 @@
+export default interface PLACE_ON_FLOOR {
+    DESCRIPTION: 'Places an object on the floor.';
+    PAYLOAD: {
+        id: string;
+    };
+    RETURN: boolean;
+}