@shopware-ag/dive 1.19.1-beta.9 → 2.0.1-beta.1

package/build/src/modules/state/actions/action.d.ts

@@ -0,0 +1,36 @@
+import { ActionDependencies } from '../types/index.ts';
+/**
+ * Abstract base class for implementing actions in the system.
+ * Actions represent discrete units of work that can be executed with specific payloads and dependencies.
+ * To define a new action, you can call `Action.define` method.
+ *
+ * @template P - The type of the payload that the action will receive (optional)
+ * @template R - The return type of the action's execution
+ * @template D - The type of dependencies required by the action, extending ActionDependencies
+ */
+export declare abstract class Action<P = void, D extends Partial<ActionDependencies> = Partial<ActionDependencies>, R = void> {
+    protected abstract readonly _description: string;
+    protected _payload: P;
+    protected readonly _dependencies: D;
+    /**
+     * Executes the action with the provided payload and dependencies.
+     * @returns A promise that resolves to the result of the action
+     */
+    abstract execute(): R;
+    constructor(payload: P, dependencies: D);
+    /**
+     * Factory method to create a new Action class with the specified description and execution logic.
+     *
+     * @template T - The type of the payload (use void for actions without payload)
+     * @template D - The type of dependencies
+     * @template R - The return type of the action
+     * @param options - Configuration options for the action
+     * @param options.description - A description of what the action does
+     * @param options.execute - The function that implements the action's logic
+     * @returns A new Action class that can be instantiated with payload and dependencies
+     */
+    static define<T = void, D extends Partial<ActionDependencies> = Partial<ActionDependencies>, R = void>({ description, execute, }: {
+        description: string;
+        execute: (payload: T, dependencies: D) => R;
+    }): new (payload: T, dependencies: D) => Action<T, D, R>;
+}

package/build/src/modules/state/actions/ar/index.d.ts

@@ -0,0 +1 @@
+export * from './launchar.ts';

package/build/src/modules/state/actions/ar/launchar.d.ts

@@ -0,0 +1,15 @@
+import { Action } from '../action.ts';
+import { ActionDependencies } from '../../types/index.ts';
+import { ARSystemOptions } from '../../../ar/ARSystem.ts';
+export declare const LaunchARAction: new (payload: {
+    uri: string;
+    options?: ARSystemOptions;
+}, dependencies: Pick<ActionDependencies, "getARSystem">) => Action<{
+    uri: string;
+    options?: ARSystemOptions;
+}, Pick<ActionDependencies, "getARSystem">, Promise<void>>;
+declare global {
+    interface ActionTypes {
+        LAUNCH_AR: typeof LaunchARAction;
+    }
+}

package/build/src/modules/state/actions/camera/computeencompassingview.d.ts

@@ -0,0 +1,12 @@
+import { Action } from '../action.ts';
+import { Vector3Like } from 'three';
+import { ActionDependencies } from '../../types/index.ts';
+export declare const ComputeEncompassingViewAction: new (payload: void, dependencies: Pick<ActionDependencies, "engine" | "controller">) => Action<void, Pick<ActionDependencies, "engine" | "controller">, {
+    position: Vector3Like;
+    target: Vector3Like;
+}>;
+declare global {
+    interface ActionTypes {
+        COMPUTE_ENCOMPASSING_VIEW: typeof ComputeEncompassingViewAction;
+    }
+}

package/build/src/modules/state/actions/camera/getcameratransform.d.ts

@@ -0,0 +1,12 @@
+import { Action } from '../action.ts';
+import { ActionDependencies } from '../../types/index.ts';
+import { Vector3Like } from 'three';
+export declare const GetCameraTransformAction: new (payload: void, dependencies: Pick<ActionDependencies, "controller">) => Action<void, Pick<ActionDependencies, "controller">, {
+    position: Vector3Like;
+    target: Vector3Like;
+}>;
+declare global {
+    interface ActionTypes {
+        GET_CAMERA_TRANSFORM: typeof GetCameraTransformAction;
+    }
+}

package/build/src/modules/state/actions/camera/index.d.ts

@@ -0,0 +1,6 @@
+export * from './computeencompassingview.ts';
+export * from './getcameratransform.ts';
+export * from './movecamera.ts';
+export * from './setcameralayer.ts';
+export * from './setcameratransform.ts';
+export * from './zoomcamera.ts';

package/build/src/modules/state/actions/camera/lockcamera.d.ts

@@ -0,0 +1,8 @@
+import { Action } from '../action.ts';
+import { ActionDependencies } from '../../types/index.ts';
+export declare const SetCameraLockedAction: new (payload: boolean, dependencies: Pick<ActionDependencies, "controller">) => Action<boolean, Pick<ActionDependencies, "controller">, void>;
+declare global {
+    interface ActionTypes {
+        SET_CAMERA_LOCKED: typeof SetCameraLockedAction;
+    }
+}

package/build/src/modules/state/actions/camera/movecamera.d.ts

@@ -0,0 +1,29 @@
+import { Action } from '../action.ts';
+import { ActionDependencies } from '../../types/index.ts';
+import { Vector3Like } from 'three';
+export declare const MoveCameraAction: new (payload: {
+    position: Vector3Like;
+    target: Vector3Like;
+    locked: boolean;
+    duration: number;
+} | {
+    id: string;
+    locked: boolean;
+    duration: number;
+}, dependencies: Pick<ActionDependencies, "engine" | "registered" | "controller" | "getAnimationSystem">) => Action<{
+    position: Vector3Like;
+    target: Vector3Like;
+    locked: boolean;
+    duration: number;
+} | {
+    id: string;
+    locked: boolean;
+    duration: number;
+}, Pick<ActionDependencies, "engine" | "registered" | "controller" | "getAnimationSystem">, Promise<{
+    stop: () => void;
+}>>;
+declare global {
+    interface ActionTypes {
+        MOVE_CAMERA: typeof MoveCameraAction;
+    }
+}

package/build/src/modules/state/actions/camera/setcameralayer.d.ts

@@ -0,0 +1,12 @@
+import { Action } from '../action.ts';
+import { ActionDependencies } from '../../types/index.ts';
+export declare const SetCameraLayerAction: new (payload: {
+    layer: "LIVE" | "EDITOR";
+}, dependencies: Pick<ActionDependencies, "controller">) => Action<{
+    layer: "LIVE" | "EDITOR";
+}, Pick<ActionDependencies, "controller">, void>;
+declare global {
+    interface ActionTypes {
+        SET_CAMERA_LAYER: typeof SetCameraLayerAction;
+    }
+}

package/build/src/modules/state/actions/camera/setcameratransform.d.ts

@@ -0,0 +1,15 @@
+import { Action } from '../action.ts';
+import { ActionDependencies } from '../../types/index.ts';
+import { Vector3Like } from 'three';
+export declare const SetCameraTransformAction: new (payload: {
+    position: Vector3Like;
+    target: Vector3Like;
+}, dependencies: Pick<ActionDependencies, "controller">) => Action<{
+    position: Vector3Like;
+    target: Vector3Like;
+}, Pick<ActionDependencies, "controller">, void>;
+declare global {
+    interface ActionTypes {
+        SET_CAMERA_TRANSFORM: typeof SetCameraTransformAction;
+    }
+}

package/build/src/modules/state/actions/camera/zoomcamera.d.ts

@@ -0,0 +1,14 @@
+import { Action } from '../action.ts';
+import { ActionDependencies } from '../../types/index.ts';
+export declare const ZoomCameraAction: new (payload: {
+    direction: "IN" | "OUT";
+    by: number;
+}, dependencies: Pick<ActionDependencies, "controller">) => Action<{
+    direction: "IN" | "OUT";
+    by: number;
+}, Pick<ActionDependencies, "controller">, void>;
+declare global {
+    interface ActionTypes {
+        ZOOM_CAMERA: typeof ZoomCameraAction;
+    }
+}

package/build/src/modules/state/actions/index.d.ts

@@ -0,0 +1,7 @@
+export * from './ar/index.ts';
+export * from './camera/index.ts';
+export * from './media/index.ts';
+export * from './object/index.ts';
+export * from './renderer/index.ts';
+export * from './scene/index.ts';
+export * from './toolbox/index.ts';

package/build/src/modules/state/actions/media/generatemedia.d.ts

@@ -0,0 +1,25 @@
+import { Action } from '../action.ts';
+import { ActionDependencies } from '../../types/index.ts';
+import { Vector3Like } from 'three';
+export declare const GenerateMediaAction: new (payload: ({
+    position: Vector3Like;
+    target: Vector3Like;
+} | {
+    id: string;
+}) & {
+    width: number;
+    height: number;
+}, dependencies: Pick<ActionDependencies, "registered" | "getMediaCreator">) => Action<({
+    position: Vector3Like;
+    target: Vector3Like;
+} | {
+    id: string;
+}) & {
+    width: number;
+    height: number;
+}, Pick<ActionDependencies, "registered" | "getMediaCreator">, Promise<string>>;
+declare global {
+    interface ActionTypes {
+        GENERATE_MEDIA: typeof GenerateMediaAction;
+    }
+}

package/build/src/modules/state/actions/media/index.d.ts

@@ -0,0 +1 @@
+export * from './generatemedia.ts';

package/build/src/modules/state/actions/object/addobject.d.ts

@@ -0,0 +1,8 @@
+import { Action } from '../action.ts';
+import { ActionDependencies, COMEntity } from '../../types/index.ts';
+export declare const AddObjectAction: new (payload: COMEntity, dependencies: Pick<ActionDependencies, "engine" | "registered">) => Action<COMEntity, Pick<ActionDependencies, "engine" | "registered">, void>;
+declare global {
+    interface ActionTypes {
+        ADD_OBJECT: typeof AddObjectAction;
+    }
+}

package/build/src/modules/state/actions/object/deleteobject.d.ts

@@ -0,0 +1,12 @@
+import { Action } from '../action.ts';
+import { ActionDependencies, COMEntity } from '../../types/index.ts';
+export declare const DeleteObjectAction: new (payload: Partial<COMEntity> & {
+    id: string;
+}, dependencies: Pick<ActionDependencies, "engine" | "registered">) => Action<Partial<COMEntity> & {
+    id: string;
+}, Pick<ActionDependencies, "engine" | "registered">, void>;
+declare global {
+    interface ActionTypes {
+        DELETE_OBJECT: typeof DeleteObjectAction;
+    }
+}

package/build/src/modules/state/actions/object/deselectobject.d.ts

@@ -0,0 +1,12 @@
+import { Action } from '../action.ts';
+import { ActionDependencies, COMEntity } from '../../types/index.ts';
+export declare const DeselectObjectAction: new (payload: Partial<COMEntity> & {
+    id: string;
+}, dependencies: Pick<ActionDependencies, "engine" | "registered" | "getToolbox">) => Action<Partial<COMEntity> & {
+    id: string;
+}, Pick<ActionDependencies, "engine" | "registered" | "getToolbox">, Promise<void>>;
+declare global {
+    interface ActionTypes {
+        DESELECT_OBJECT: typeof DeselectObjectAction;
+    }
+}

package/build/src/modules/state/actions/object/dropit.d.ts

@@ -0,0 +1,12 @@
+import { Action } from '../action.ts';
+import { ActionDependencies } from '../../types/index.ts';
+export declare const DropItAction: new (payload: {
+    id: string;
+}, dependencies: Pick<ActionDependencies, "engine" | "registered">) => Action<{
+    id: string;
+}, Pick<ActionDependencies, "engine" | "registered">, void>;
+declare global {
+    interface ActionTypes {
+        DROP_IT: typeof DropItAction;
+    }
+}

package/build/src/modules/state/actions/object/getallobjects.d.ts

@@ -0,0 +1,8 @@
+import { Action } from '../action.ts';
+import { ActionDependencies, COMEntity } from '../../types/index.ts';
+export declare const GetAllObjectsAction: new (payload: void, dependencies: Pick<ActionDependencies, "registered">) => Action<void, Pick<ActionDependencies, "registered">, Map<string, COMEntity>>;
+declare global {
+    interface ActionTypes {
+        GET_ALL_OBJECTS: typeof GetAllObjectsAction;
+    }
+}

package/build/src/modules/state/actions/object/getobjects.d.ts

@@ -0,0 +1,12 @@
+import { Action } from '../action.ts';
+import { ActionDependencies, COMEntity } from '../../types/index.ts';
+export declare const GetObjectsAction: new (payload: {
+    ids: string[];
+}, dependencies: Pick<ActionDependencies, "engine" | "registered">) => Action<{
+    ids: string[];
+}, Pick<ActionDependencies, "engine" | "registered">, COMEntity[]>;
+declare global {
+    interface ActionTypes {
+        GET_OBJECTS: typeof GetObjectsAction;
+    }
+}

package/build/src/modules/state/actions/object/index.d.ts

@@ -0,0 +1,11 @@
+export * from './addobject.ts';
+export * from './deleteobject.ts';
+export * from './deselectobject.ts';
+export * from './dropit.ts';
+export * from './getallobjects.ts';
+export * from './getobjects.ts';
+export * from './modelloaded.ts';
+export * from './placeonfloor.ts';
+export * from './selectobject.ts';
+export * from './setparent.ts';
+export * from './updateobject.ts';

package/build/src/modules/state/actions/object/modelloaded.d.ts

@@ -0,0 +1,12 @@
+import { Action } from '../action.ts';
+import { ActionDependencies } from '../../types/index.ts';
+export declare const ModelLoadedAction: new (payload: {
+    id: string;
+}, dependencies: Pick<ActionDependencies, "registered">) => Action<{
+    id: string;
+}, Pick<ActionDependencies, "registered">, void>;
+declare global {
+    interface ActionTypes {
+        MODEL_LOADED: typeof ModelLoadedAction;
+    }
+}

package/build/src/modules/state/actions/object/placeonfloor.d.ts

@@ -0,0 +1,12 @@
+import { Action } from '../action.ts';
+import { ActionDependencies } from '../../types/index.ts';
+export declare const PlaceOnFloorAction: new (payload: {
+    id: string;
+}, dependencies: Pick<ActionDependencies, "engine" | "registered">) => Action<{
+    id: string;
+}, Pick<ActionDependencies, "engine" | "registered">, void>;
+declare global {
+    interface ActionTypes {
+        PLACE_ON_FLOOR: typeof PlaceOnFloorAction;
+    }
+}

package/build/src/modules/state/actions/object/selectobject.d.ts

@@ -0,0 +1,12 @@
+import { Action } from '../action.ts';
+import { ActionDependencies, COMEntity } from '../../types/index.ts';
+export declare const SelectObjectAction: new (payload: Partial<COMEntity> & {
+    id: string;
+}, dependencies: Pick<ActionDependencies, "engine" | "registered" | "getToolbox">) => Action<Partial<COMEntity> & {
+    id: string;
+}, Pick<ActionDependencies, "engine" | "registered" | "getToolbox">, Promise<void>>;
+declare global {
+    interface ActionTypes {
+        SELECT_OBJECT: typeof SelectObjectAction;
+    }
+}

package/build/src/modules/state/actions/object/setparent.d.ts

@@ -0,0 +1,22 @@
+import { Action } from '../action.ts';
+import { ActionDependencies, COMEntity } from '../../types/index.ts';
+export declare const SetParentAction: new (payload: {
+    object: Partial<COMEntity> & {
+        id: string;
+    };
+    parent: (Partial<COMEntity> & {
+        id: string;
+    }) | null;
+}, dependencies: Pick<ActionDependencies, "engine" | "registered">) => Action<{
+    object: Partial<COMEntity> & {
+        id: string;
+    };
+    parent: (Partial<COMEntity> & {
+        id: string;
+    }) | null;
+}, Pick<ActionDependencies, "engine" | "registered">, void>;
+declare global {
+    interface ActionTypes {
+        SET_PARENT: typeof SetParentAction;
+    }
+}

package/build/src/modules/state/actions/object/updateobject.d.ts

@@ -0,0 +1,12 @@
+import { Action } from '../action.ts';
+import { ActionDependencies, COMEntity } from '../../types/index.ts';
+export declare const UpdateObjectAction: new (payload: Partial<COMEntity> & {
+    id: string;
+}, dependencies: Pick<ActionDependencies, "engine" | "registered">) => Action<Partial<COMEntity> & {
+    id: string;
+}, Pick<ActionDependencies, "engine" | "registered">, void>;
+declare global {
+    interface ActionTypes {
+        UPDATE_OBJECT: typeof UpdateObjectAction;
+    }
+}

package/build/src/modules/state/actions/renderer/index.d.ts

@@ -0,0 +1 @@
+export * from './startrender.ts';

package/build/src/modules/state/actions/renderer/startrender.d.ts

@@ -0,0 +1,8 @@
+import { Action } from '../action.ts';
+import { ActionDependencies } from '../../types/index.ts';
+export declare const StartRenderAction: new (payload: void, dependencies: Pick<ActionDependencies, "engine">) => Action<void, Pick<ActionDependencies, "engine">, void>;
+declare global {
+    interface ActionTypes {
+        START_RENDER: typeof StartRenderAction;
+    }
+}

package/build/src/modules/state/actions/scene/exportscene.d.ts

@@ -0,0 +1,13 @@
+import { Action } from '../action.ts';
+import { ActionDependencies } from '../../types/index.ts';
+import { DIVESceneFileType } from '../../../../types/index.ts';
+export declare const ExportSceneAction: new (payload: {
+    type: keyof DIVESceneFileType;
+}, dependencies: Pick<ActionDependencies, "engine" | "getAssetExporter">) => Action<{
+    type: keyof DIVESceneFileType;
+}, Pick<ActionDependencies, "engine" | "getAssetExporter">, Promise<ArrayBuffer | null>>;
+declare global {
+    interface ActionTypes {
+        EXPORT_SCENE: typeof ExportSceneAction;
+    }
+}

package/build/src/modules/state/actions/scene/getallscenedata.d.ts

@@ -0,0 +1,9 @@
+import { Action } from '../action.ts';
+import { ActionDependencies } from '../../types/index.ts';
+import { DIVESceneData } from '../../../../types/index.ts';
+export declare const GetAllSceneDataAction: new (payload: object, dependencies: Pick<ActionDependencies, "engine" | "registered" | "controller">) => Action<object, Pick<ActionDependencies, "engine" | "registered" | "controller">, DIVESceneData>;
+declare global {
+    interface ActionTypes {
+        GET_ALL_SCENE_DATA: typeof GetAllSceneDataAction;
+    }
+}

package/build/src/modules/state/actions/scene/index.d.ts

@@ -0,0 +1,4 @@
+export * from './exportscene.ts';
+export * from './getallscenedata.ts';
+export * from './setbackground.ts';
+export * from './updatescene.ts';

package/build/src/modules/state/actions/scene/setbackground.d.ts

@@ -0,0 +1,12 @@
+import { Action } from '../action.ts';
+import { ActionDependencies } from '../../types/index.ts';
+export declare const SetBackgroundAction: new (payload: {
+    color: string | number;
+}, dependencies: Pick<ActionDependencies, "engine">) => Action<{
+    color: string | number;
+}, Pick<ActionDependencies, "engine">, void>;
+declare global {
+    interface ActionTypes {
+        SET_BACKGROUND: typeof SetBackgroundAction;
+    }
+}

package/build/src/modules/state/actions/scene/updatescene.d.ts

@@ -0,0 +1,20 @@
+import { Action } from '../action.ts';
+import { ActionDependencies } from '../../types/index.ts';
+export declare const UpdateSceneAction: new (payload: Partial<{
+    name: string;
+    backgroundColor: string | number;
+    gridEnabled: boolean;
+    floorEnabled: boolean;
+    floorColor: string | number;
+}>, dependencies: Pick<ActionDependencies, "engine">) => Action<Partial<{
+    name: string;
+    backgroundColor: string | number;
+    gridEnabled: boolean;
+    floorEnabled: boolean;
+    floorColor: string | number;
+}>, Pick<ActionDependencies, "engine">, void>;
+declare global {
+    interface ActionTypes {
+        UPDATE_SCENE: typeof UpdateSceneAction;
+    }
+}

package/build/src/modules/state/actions/toolbox/index.d.ts

@@ -0,0 +1,4 @@
+export * from './setgizmomode.ts';
+export * from './setgizmoscalelinked.ts';
+export * from './setgizmovisible.ts';
+export * from './usetool.ts';

package/build/src/modules/state/actions/toolbox/setgizmomode.d.ts

@@ -0,0 +1,12 @@
+import { Action } from '../action.ts';
+import { ActionDependencies } from '../../types/index.ts';
+export declare const SetGizmoModeAction: new (payload: {
+    mode: "translate" | "rotate" | "scale";
+}, dependencies: Pick<ActionDependencies, "getToolbox">) => Action<{
+    mode: "translate" | "rotate" | "scale";
+}, Pick<ActionDependencies, "getToolbox">, Promise<void>>;
+declare global {
+    interface ActionTypes {
+        SET_GIZMO_MODE: typeof SetGizmoModeAction;
+    }
+}

package/build/src/modules/state/actions/toolbox/setgizmoscalelinked.d.ts

@@ -0,0 +1,8 @@
+import { Action } from '../action.ts';
+import { ActionDependencies } from '../../types/index.ts';
+export declare const SetGizmoScaleLinkedAction: new (payload: boolean, dependencies: Pick<ActionDependencies, "getToolbox">) => Action<boolean, Pick<ActionDependencies, "getToolbox">, Promise<void>>;
+declare global {
+    interface ActionTypes {
+        SET_GIZMO_SCALE_LINKED: typeof SetGizmoScaleLinkedAction;
+    }
+}

package/build/src/modules/state/actions/toolbox/setgizmovisible.d.ts

@@ -0,0 +1,8 @@
+import { Action } from '../action.ts';
+import { ActionDependencies } from '../../types/index.ts';
+export declare const SetGizmoVisibilityAction: new (payload: boolean, dependencies: Pick<ActionDependencies, "getToolbox">) => Action<boolean, Pick<ActionDependencies, "getToolbox">, Promise<void>>;
+declare global {
+    interface ActionTypes {
+        SET_GIZMO_VISIBILITY: typeof SetGizmoVisibilityAction;
+    }
+}

package/build/src/modules/state/actions/toolbox/usetool.d.ts

@@ -0,0 +1,13 @@
+import { Action } from '../action.ts';
+import { ActionDependencies } from '../../types/index.ts';
+import { ToolType } from '../../../toolbox/Toolbox.ts';
+export declare const UseToolAction: new (payload: {
+    tool: ToolType;
+}, dependencies: Pick<ActionDependencies, "getToolbox">) => Action<{
+    tool: ToolType;
+}, Pick<ActionDependencies, "getToolbox">, Promise<void>>;
+declare global {
+    interface ActionTypes {
+        USE_TOOL: typeof UseToolAction;
+    }
+}

package/build/src/modules/state/types/ActionTypes.d.ts

@@ -0,0 +1,18 @@
+import { DIVEEngine } from '../../../engine/Engine.ts';
+import { OrbitController } from '../../controller/orbit/OrbitController.ts';
+import { COMEntity } from '../types/index.ts';
+export type ActionPayload<T> = T extends new (payload: infer P, dependencies: infer D) => unknown ? P : never;
+export type ActionReturn<T> = T extends new (payload: infer P, dependencies: infer D) => infer ClassInstance ? ClassInstance extends {
+    execute(): infer E;
+} ? E : never : never;
+export type ActionDeps<T> = T extends new (payload: unknown, dependencies: infer D) => unknown ? D extends Partial<ActionDependencies> ? D : never : never;
+export interface ActionDependencies {
+    registered: Map<string, COMEntity>;
+    engine: DIVEEngine;
+    controller: OrbitController;
+    getAnimationSystem: () => Promise<import('../../animation/AnimationSystem.ts').AnimationSystem>;
+    getARSystem: () => Promise<import('../../ar/ARSystem.ts').ARSystem>;
+    getAssetExporter: () => Promise<import('../../asset/exporter/AssetExporter.ts').AssetExporter>;
+    getMediaCreator: () => Promise<import('../../mediacreator/MediaCreator.ts').MediaCreator>;
+    getToolbox: () => Promise<import('../../toolbox/Toolbox.ts').Toolbox>;
+}

package/build/src/modules/{com → state}/types/COMBaseEntity.d.ts

@@ -1,4 +1,4 @@
-import { COMEntityType } from './COMEntityType';
+import { COMEntityType } from './COMEntityType.ts';
 export type COMBaseEntity = {
     id: string;
     name: string;

package/build/src/modules/state/types/COMEntity.d.ts

@@ -0,0 +1,11 @@
+import { COMPov } from './COMPov.ts';
+import { COMLight } from './COMLight.ts';
+import { COMModel } from './COMModel.ts';
+import { COMPrimitive } from './COMPrimitive.ts';
+import { COMGroup } from './COMGroup.ts';
+export type COMMinimal<T extends COMEntity> = T extends COMEntity ? {
+    id: string;
+    entityType: T['entityType'];
+} : never;
+export type COMPartial<T extends COMEntity | void = void> = T extends COMEntity ? COMMinimal<T> & Partial<T> : COMMinimal<COMEntity> & Partial<COMEntity>;
+export type COMEntity = COMPov | COMLight | COMModel | COMPrimitive | COMGroup;

package/build/src/modules/{com → state}/types/COMGeometry.d.ts

@@ -1,4 +1,4 @@
-import { COMGeometryType } from './COMGeometryType';
+import { COMGeometryType } from './COMGeometryType.ts';
 export type COMGeometry = {
     name: COMGeometryType;
     width: number;

package/build/src/modules/state/types/COMGroup.d.ts

@@ -0,0 +1,11 @@
+import { Vector3Like } from 'three';
+import { COMBaseEntity } from './COMBaseEntity.ts';
+import { COMEntity } from './COMEntity.ts';
+export declare function isCOMGroup(entity: COMEntity): entity is COMGroup;
+export type COMGroup = COMBaseEntity & {
+    entityType: 'group';
+    position: Vector3Like;
+    rotation: Vector3Like;
+    scale: Vector3Like;
+    bbVisible?: boolean;
+};

package/build/src/modules/state/types/COMLight.d.ts

@@ -0,0 +1,28 @@
+import { Vector3Like } from 'three';
+import { COMBaseEntity } from './COMBaseEntity.ts';
+import { COMEntity } from './COMEntity.ts';
+export declare function isCOMLight(entity: COMEntity): entity is COMLight;
+export type COMBaseLight = COMBaseEntity & {
+    type: LightType;
+    intensity: number;
+    color: string | number;
+    enabled: boolean;
+    position?: Vector3Like;
+    rotation?: Vector3Like;
+};
+export type COMAmbientLight = COMBaseLight & {
+    entityType: 'light';
+    type: 'ambient';
+};
+export type COMPointLight = COMBaseLight & {
+    entityType: 'light';
+    type: 'point';
+    position: Vector3Like;
+};
+export type COMSceneLight = COMBaseLight & {
+    entityType: 'light';
+    type: 'scene';
+};
+type LightType = 'ambient' | 'point' | 'scene';
+export type COMLight = COMAmbientLight | COMPointLight | COMSceneLight;
+export {};

package/build/src/modules/state/types/COMModel.d.ts

@@ -0,0 +1,14 @@
+import { Vector3Like } from 'three';
+import { COMMaterial } from './COMMaterial.ts';
+import { COMBaseEntity } from './COMBaseEntity.ts';
+import { COMEntity } from './COMEntity.ts';
+export declare function isCOMModel(entity: COMEntity): entity is COMModel;
+export type COMModel = COMBaseEntity & {
+    entityType: 'model';
+    uri: string;
+    position: Vector3Like;
+    rotation: Vector3Like;
+    scale: Vector3Like;
+    loaded: boolean;
+    material?: Partial<COMMaterial>;
+};

package/build/src/modules/state/types/COMPov.d.ts

@@ -0,0 +1,10 @@
+import { Vector3Like } from 'three';
+import { COMBaseEntity } from './COMBaseEntity.ts';
+import { COMEntity } from './COMEntity.ts';
+export declare function isCOMPov(entity: COMEntity): entity is COMPov;
+export type COMPov = COMBaseEntity & {
+    entityType: 'pov';
+    position: Vector3Like;
+    target: Vector3Like;
+    locked?: boolean;
+};