@3dverse/api 0.10.1 → 0.10.2

package/dist/_prebuild/wrapper.d.ts

@@ -124,7 +124,7 @@ export type UploadTask = {
      * This is only available if the source file is being downloaded.
      */
     download_progress?: ConversionProgress;
-    status: ('waiting' | 'downloading' | 'pending' | 'converting' | 'error' | 'success' | 'rejected') & string;
+    status: ('waiting' | 'downloading' | 'extracting' | 'pending' | 'converting' | 'error' | 'success' | 'rejected') & string;
     conversion_tasks: Array<ConversionTask>;
 };
 /**
@@ -343,9 +343,18 @@ export type Cubemap = {
 export type SessionId = string;
 /** Client unique identifier */
 export type ClientId = string;
+/**
+ * What an application attaches to a session it creates, or to a client it joins one with, which the service keeps
+ * and answers as is, never reading it: up to 32 keys, each a string of up to 512 characters, set once
+ */
+export type Metadata = {
+    [_additionalproperties_: string]: string;
+};
 export type Client = {
     client_id?: ClientId;
     client_type?: 'user' | 'guest';
+    /** What the application which joined with this client attached to it, empty for none */
+    metadata?: Metadata;
     user_id: UserId;
     /** Used only for debug purposes */
     username: string;
@@ -379,6 +388,8 @@ export type Session = {
     is_transient_session: boolean;
     /** Current clients in session */
     clients: Array<Client>;
+    /** What the application which created the session attached to it, empty for none */
+    metadata: Metadata;
 };
 /**
  * - `draft`: the plan is being reviewed, and expires unless confirmed.
@@ -526,9 +537,9 @@ export type SupportedSourceFileFormats = {
         associated_file_extensions?: {
             [_additionalproperties_: string]: Array<string>;
         };
-        /** Per sub-pipeline breakdown, keyed by converter name. */
+        /** Per converter breakdown, keyed by converter name. */
         converters: {
-            /** One sub-pipeline of a conversion type. */
+            /** One converter of a conversion type. */
             [_additionalproperties_: string]: {
                 associated_file_extensions?: {
                     [_additionalproperties_: string]: Array<string>;
@@ -548,9 +559,9 @@ export type SupportedSourceFileFormats = {
         associated_file_extensions?: {
             [_additionalproperties_: string]: Array<string>;
         };
-        /** Per sub-pipeline breakdown, keyed by converter name. */
+        /** Per converter breakdown, keyed by converter name. */
         converters: {
-            /** One sub-pipeline of a conversion type. */
+            /** One converter of a conversion type. */
             [_additionalproperties_: string]: {
                 associated_file_extensions?: {
                     [_additionalproperties_: string]: Array<string>;
@@ -570,9 +581,9 @@ export type SupportedSourceFileFormats = {
         associated_file_extensions?: {
             [_additionalproperties_: string]: Array<string>;
         };
-        /** Per sub-pipeline breakdown, keyed by converter name. */
+        /** Per converter breakdown, keyed by converter name. */
         converters: {
-            /** One sub-pipeline of a conversion type. */
+            /** One converter of a conversion type. */
             [_additionalproperties_: string]: {
                 associated_file_extensions?: {
                     [_additionalproperties_: string]: Array<string>;
@@ -592,9 +603,9 @@ export type SupportedSourceFileFormats = {
         associated_file_extensions?: {
             [_additionalproperties_: string]: Array<string>;
         };
-        /** Per sub-pipeline breakdown, keyed by converter name. */
+        /** Per converter breakdown, keyed by converter name. */
         converters: {
-            /** One sub-pipeline of a conversion type. */
+            /** One converter of a conversion type. */
             [_additionalproperties_: string]: {
                 associated_file_extensions?: {
                     [_additionalproperties_: string]: Array<string>;
@@ -614,9 +625,9 @@ export type SupportedSourceFileFormats = {
         associated_file_extensions?: {
             [_additionalproperties_: string]: Array<string>;
         };
-        /** Per sub-pipeline breakdown, keyed by converter name. */
+        /** Per converter breakdown, keyed by converter name. */
         converters: {
-            /** One sub-pipeline of a conversion type. */
+            /** One converter of a conversion type. */
             [_additionalproperties_: string]: {
                 associated_file_extensions?: {
                     [_additionalproperties_: string]: Array<string>;
@@ -636,9 +647,9 @@ export type SupportedSourceFileFormats = {
         associated_file_extensions?: {
             [_additionalproperties_: string]: Array<string>;
         };
-        /** Per sub-pipeline breakdown, keyed by converter name. */
+        /** Per converter breakdown, keyed by converter name. */
         converters: {
-            /** One sub-pipeline of a conversion type. */
+            /** One converter of a conversion type. */
             [_additionalproperties_: string]: {
                 associated_file_extensions?: {
                     [_additionalproperties_: string]: Array<string>;
@@ -655,78 +666,10 @@ export type SupportedSourceFileFormats = {
 };
 /** Conversion task unique identifier */
 export type ConversionTaskId = string;
-/** Data Pipeline unique identifier. */
-export type DataPipelineId = string;
 /** Pipeline unique identifier. A pipeline is an instance of a Data Pipeline. */
-export type PipelineId = string;
-/** Instance of a Data Pipeline. */
-export type Pipeline = {
-    /** Data Pipeline unique identifier. */
-    data_pipeline_id: string;
-    /** Unique identifier of an environment */
-    environment_id: string;
-    /** Reason why the pipeline failed or was rejected, if applicable. */
-    error?: string;
-    /** Stable, machine-readable category for why a pipeline/job/step failed or was rejected. Meant for programmatic handling (e.g. displaying a localized, user-facing message) — the accompanying `error` field carries the technical detail. `processing_failed` is a catch-all used whenever the failure doesn't fall into one of the other, more specific categories. */
-    error_code?: 'quota_exceeded' | 'unsupported_file_format' | 'nothing_to_process' | 'enqueue_failed' | 'download_failed' | 'extraction_failed' | 'processing_failed';
-    /** Date and time when the pipeline was completed, either successfully or with errors. */
-    finished_at?: string;
-    /** Folder unique identifier */
-    folder_id: string;
-    jobs: Array<{
-        /** Reason why the job failed, if applicable. */
-        error?: string;
-        /** Stable, machine-readable category for why a pipeline/job/step failed or was rejected. Meant for programmatic handling (e.g. displaying a localized, user-facing message) — the accompanying `error` field carries the technical detail. `processing_failed` is a catch-all used whenever the failure doesn't fall into one of the other, more specific categories. */
-        error_code?: 'quota_exceeded' | 'unsupported_file_format' | 'nothing_to_process' | 'enqueue_failed' | 'download_failed' | 'extraction_failed' | 'processing_failed';
-        /** Date and time when the job was completed, either successfully or with errors. */
-        finished_at?: string;
-        /** Data Pipeline job unique identifier. */
-        job_id: string;
-        /** Name of the job. */
-        name: string;
-        /** Pipeline unique identifier. A pipeline is an instance of a Data Pipeline. */
-        pipeline_id: string;
-        progress: number;
-        /** Date and time when the job was queued for processing. */
-        queued_at?: string;
-        /** Date and time when the job was started. */
-        started_at?: string;
-        /** Possible status of a job. */
-        status: 'created' | 'queued' | 'running' | 'timed-out' | 'failed' | 'succeeded';
-        steps: Array<{
-            /** Reason why the step failed, if applicable. */
-            error?: string;
-            /** Stable, machine-readable category for why a pipeline/job/step failed or was rejected. Meant for programmatic handling (e.g. displaying a localized, user-facing message) — the accompanying `error` field carries the technical detail. `processing_failed` is a catch-all used whenever the failure doesn't fall into one of the other, more specific categories. */
-            error_code?: 'quota_exceeded' | 'unsupported_file_format' | 'nothing_to_process' | 'enqueue_failed' | 'download_failed' | 'extraction_failed' | 'processing_failed';
-            /** Date and time when the step was completed, either successfully or with errors. */
-            finished_at?: string;
-            /** Data Pipeline job unique identifier. */
-            job_id: string;
-            /** Name of the step. */
-            name: string;
-            progress: number;
-            /** Date and time when the step was started. */
-            started_at?: string;
-            /** Possible status of a step. */
-            status: 'created' | 'skipped' | 'queued' | 'running' | 'timed-out' | 'failed' | 'succeeded';
-            /** Data Pipeline job step unique identifier. */
-            step_id: string;
-        }>;
-    }>;
-    /** Name of the pipeline. */
-    name: string;
-    /** Pipeline unique identifier. A pipeline is an instance of a Data Pipeline. */
-    pipeline_id: string;
-    progress: number;
-    /** Date and time when the pipeline was accepted by the system and queued for processing. */
-    queued_at?: string;
-    /** Possible status of a pipeline. */
-    status: 'created' | 'downloading' | 'extracting' | 'pending-approval' | 'queued' | 'running' | 'passed-with-errors' | 'failed' | 'rejected' | 'succeeded';
-    /** Date and time when the pipeline was triggered. */
-    triggered_at: string;
-    /** User unique identifier */
-    user_id: string;
-};
+export type DataPipelineId = string;
+/** Import unique identifier, which this service mints: the id of the pipeline running it. */
+export type ImportId = string;
 export type AssetContainer = 'action_maps' | 'animations' | 'animation_graphs' | 'animation_sequences' | 'animation_sets' | 'collision_geometries' | 'cubemaps' | 'event_maps' | 'materials' | 'meshes' | 'modules' | 'point_clouds' | 'render_graphs' | 'scenes' | 'scripts' | 'shaders' | 'shader_contexts' | 'skeletons' | 'sounds' | 'textures' | 'textures_3d' | 'volume_materials';
 /** An error the gateway raised, or one of the services it calls answered */
 export type ServiceError = {
@@ -1161,6 +1104,8 @@ export type AssetDescription = {
             [_additionalproperties_: string]: any;
         };
     };
+    /** Other modules this module uses */
+    moduleDependencies?: Array<string>;
     /** Name of the asset */
     name: string;
     /** Unique identifier for the asset */
@@ -2367,6 +2312,8 @@ export type EditableAssetDescription = {
             [_additionalproperties_: string]: any;
         };
     };
+    /** Other modules this module uses */
+    moduleDependencies?: Array<string>;
     /** Name of the asset */
     name: string;
     /** Unique identifier for the asset */
@@ -2948,200 +2895,766 @@ export type EditableAssetDescription = {
             /** How this buffer is going to be used */
             usage: number;
         };
-        /** Categories */
-        categories?: Array<string>;
-        /** Parameter default value */
-        default?: number | boolean | Array<number>;
-        /** Description of the parameter, shown by tools. Not read by the engine */
-        description?: string;
-        /** Identifier of the parameter, kept while its name is, and never given to another: tools follow a parameter across the versions of its shader by it. Not read by the engine */
-        id?: number;
-        /** Whether this parameter (a render target or buffer) is the resource used to compute the number of dispatched workgroups for a compute shader, i.e. DispatchedGroups = referenceResource.size / workgroupSize (see compute_shader_size_reference's reference_resource) */
-        isReferenceResource?: boolean;
-        /** For a parameter holding one of a set of values: each value, named and described for tools. Not read by the engine */
-        list?: Array<{
-            description?: string;
-            name: string;
-            value: number;
-        }>;
-        /** Parameter name */
-        name: string;
-        /** Parameter native type */
-        nativeType: 'vec4' | 'vec3' | 'vec2' | 'float' | 'int32_t' | 'texture2d_ref' | 'render_target_index' | 'buffer_reference';
-        /** Parameter offset in bytes */
-        offset: number;
-        /** Additional properties gating this parameter's relevance and/or driving how it's interpreted by tooling (e.g. the material editor) */
-        properties?: {
-            /** For a parameter of type "texture" or "render_target_index": the underlying pixel type's exact format */
-            format?: 'int32' | 'uint32' | 'int64' | 'uint64' | 'float32' | 'float64' | 'vec2' | 'ivec2' | 'vec3' | 'ivec3' | 'vec4' | 'ivec4' | 'color3' | 'color4';
-            /** For a parameter of type "buffer" or "render_target_index": how the underlying resource is accessed */
-            openMode?: 'read' | 'write' | 'readwrite';
-            /** Specialization constants gating this parameter's relevance: the key is a constant name, the value is what it must hold for the parameter to be relevant (e.g. shown in the material editor) */
-            spec?: {
-                [_additionalproperties_: string]: number | boolean;
-            };
+        /** Categories */
+        categories?: Array<string>;
+        /** Parameter default value */
+        default?: number | boolean | Array<number>;
+        /** Description of the parameter, shown by tools. Not read by the engine */
+        description?: string;
+        /** Identifier of the parameter, kept while its name is, and never given to another: tools follow a parameter across the versions of its shader by it. Not read by the engine */
+        id?: number;
+        /** Whether this parameter (a render target or buffer) is the resource used to compute the number of dispatched workgroups for a compute shader, i.e. DispatchedGroups = referenceResource.size / workgroupSize (see compute_shader_size_reference's reference_resource) */
+        isReferenceResource?: boolean;
+        /** For a parameter holding one of a set of values: each value, named and described for tools. Not read by the engine */
+        list?: Array<{
+            description?: string;
+            name: string;
+            value: number;
+        }>;
+        /** Parameter name */
+        name: string;
+        /** Parameter native type */
+        nativeType: 'vec4' | 'vec3' | 'vec2' | 'float' | 'int32_t' | 'texture2d_ref' | 'render_target_index' | 'buffer_reference';
+        /** Parameter offset in bytes */
+        offset: number;
+        /** Additional properties gating this parameter's relevance and/or driving how it's interpreted by tooling (e.g. the material editor) */
+        properties?: {
+            /** For a parameter of type "texture" or "render_target_index": the underlying pixel type's exact format */
+            format?: 'int32' | 'uint32' | 'int64' | 'uint64' | 'float32' | 'float64' | 'vec2' | 'ivec2' | 'vec3' | 'ivec3' | 'vec4' | 'ivec4' | 'color3' | 'color4';
+            /** For a parameter of type "buffer" or "render_target_index": how the underlying resource is accessed */
+            openMode?: 'read' | 'write' | 'readwrite';
+            /** Specialization constants gating this parameter's relevance: the key is a constant name, the value is what it must hold for the parameter to be relevant (e.g. shown in the material editor) */
+            spec?: {
+                [_additionalproperties_: string]: number | boolean;
+            };
+        };
+        /** Parameter type */
+        type: 'vec4' | 'ivec4' | 'quat' | 'color_alpha' | 'vec3' | 'ivec3' | 'color' | 'vec2' | 'ivec2' | 'float' | 'int' | 'uint' | 'bool' | 'texture' | 'render_target_index' | 'buffer';
+    }>;
+    /** Descriptions of all modules that compose this shader */
+    moduleDescriptions?: Array<{
+        /** Names of the bindings used by this module */
+        bindings?: Array<string>;
+        /** Constants used by this module */
+        constants?: {
+            [_additionalproperties_: string]: Array<number>;
+        };
+        /** Entry point of the shader module */
+        entryPoint?: string;
+        /** Outputs of this shader module (e.g. a fragment shader's color attachments, or the last stage's varying outputs), used to validate the module's compatibility with a render pipeline */
+        outputs?: Array<{
+            /** Output location */
+            location: number;
+            /** Output variable name */
+            name: string;
+            /** Output variable type */
+            type: 'bool' | 'int8' | 'int16' | 'int32' | 'int64' | 'uint8' | 'uint16' | 'uint32' | 'uint64' | 'float16' | 'float32' | 'float64' | 'vec2' | 'ivec2' | 'vec3' | 'ivec3' | 'vec4' | 'ivec4' | 'pointer';
+        }>;
+        /** Offset in byte in the shader payload buffer */
+        payloadOffset: number;
+        /** Size in byte of the compiled module */
+        payloadSize: number;
+        /** Push constant members used by this module, used to validate push constant layout compatibility across the pipeline's stages */
+        pushConstants?: Array<{
+            /** Push constant member name */
+            name: string;
+            /** Offset in byte within the push constant block */
+            offset: number;
+            /** Size in byte of the push constant member */
+            size: number;
+            /** Push constant member type */
+            type: 'bool' | 'int8' | 'int16' | 'int32' | 'int64' | 'uint8' | 'uint16' | 'uint32' | 'uint64' | 'float16' | 'float32' | 'float64' | 'vec2' | 'ivec2' | 'vec3' | 'ivec3' | 'vec4' | 'ivec4' | 'pointer';
+        }>;
+        /** The shader stage */
+        shaderStage: number;
+        /** Bit mask of the descriptor bindings used by this module, bit N for binding N */
+        usedBindings: number;
+    }>;
+    /** Name of the asset */
+    name: string;
+    /** Data descriptor for render graph node shaders */
+    nodeDataDescriptor?: Array<{
+        /** Additional properties for a parameter of type "buffer": how many elements it holds, the size of each element, and how the buffer is used. Absent for every other parameter type */
+        bufferProperties?: {
+            /** Number of elements in the buffer, or a [x, y] pair of factors applied to the viewport width and height (each rounded up and clamped to a minimum of 1, then multiplied) to compute the element count */
+            elementCount: number | Array<number>;
+            /** Size in bytes of a single element in the buffer. If the buffer is declared as `T *buffer`, this is sizeof(T) */
+            elementSize: number;
+            /** How this buffer is going to be used */
+            usage: number;
+        };
+        /** Categories */
+        categories?: Array<string>;
+        /** Parameter default value */
+        default?: number | boolean | Array<number>;
+        /** Description of the parameter, shown by tools. Not read by the engine */
+        description?: string;
+        /** Identifier of the parameter, kept while its name is, and never given to another: tools follow a parameter across the versions of its shader by it. Not read by the engine */
+        id?: number;
+        /** Whether this parameter (a render target or buffer) is the resource used to compute the number of dispatched workgroups for a compute shader, i.e. DispatchedGroups = referenceResource.size / workgroupSize (see compute_shader_size_reference's reference_resource) */
+        isReferenceResource?: boolean;
+        /** For a parameter holding one of a set of values: each value, named and described for tools. Not read by the engine */
+        list?: Array<{
+            description?: string;
+            name: string;
+            value: number;
+        }>;
+        /** Parameter name */
+        name: string;
+        /** Parameter native type */
+        nativeType: 'vec4' | 'vec3' | 'vec2' | 'float' | 'int32_t' | 'texture2d_ref' | 'render_target_index' | 'buffer_reference';
+        /** Parameter offset in bytes */
+        offset: number;
+        /** Additional properties gating this parameter's relevance and/or driving how it's interpreted by tooling (e.g. the material editor) */
+        properties?: {
+            /** For a parameter of type "texture" or "render_target_index": the underlying pixel type's exact format */
+            format?: 'int32' | 'uint32' | 'int64' | 'uint64' | 'float32' | 'float64' | 'vec2' | 'ivec2' | 'vec3' | 'ivec3' | 'vec4' | 'ivec4' | 'color3' | 'color4';
+            /** For a parameter of type "buffer" or "render_target_index": how the underlying resource is accessed */
+            openMode?: 'read' | 'write' | 'readwrite';
+            /** Specialization constants gating this parameter's relevance: the key is a constant name, the value is what it must hold for the parameter to be relevant (e.g. shown in the material editor) */
+            spec?: {
+                [_additionalproperties_: string]: number | boolean;
+            };
+        };
+        /** Parameter type */
+        type: 'vec4' | 'ivec4' | 'quat' | 'color_alpha' | 'vec3' | 'ivec3' | 'color' | 'vec2' | 'ivec2' | 'float' | 'int' | 'uint' | 'bool' | 'texture' | 'render_target_index' | 'buffer';
+    }>;
+    /** Hash of the node data descriptor, used to detect changes in the descriptor */
+    nodeDataDescriptorHash?: number;
+    /** The size in byte of the compiled shader code (accumulated size of all modules) */
+    payloadSize?: number;
+    /** Reference to the shader context associated with this shader. Only present for shaders that use one. */
+    shaderContextRef?: string;
+    /** Vulkan bit mask of all shader stages present in this shader */
+    shaderStages?: number;
+    /** Unique identifier for the asset */
+    uuid: string;
+    /** Vertex description. Only valid when a vertex shader module is present */
+    vertexDescriptor?: Array<{
+        /** Binding number */
+        binding: number;
+        /** Format */
+        format: number;
+        /** Location */
+        location: number;
+        /** Offset */
+        offset: number;
+        /** Semantic */
+        semantic: (1 | 2 | 4 | 8 | 16 | 32) & number;
+        /** Stride between consecutive elements within the buffer */
+        stride: number;
+    }>;
+} | {
+    /** The albedo look up table */
+    albedoLUT?: Array<{
+        /** The normalized key for this entry */
+        key?: number;
+        /** The value associated to the key */
+        value?: Array<number> | number;
+    }>;
+    /** The metallic look up table */
+    metallicLUT?: Array<{
+        /** The normalized key for this entry */
+        key?: number;
+        /** The value associated to the key */
+        value?: Array<number> | number;
+    }>;
+    /** Name of the asset */
+    name: string;
+    /** The opacity look up table */
+    opacityLUT?: Array<{
+        /** The normalized key for this entry */
+        key?: number;
+        /** The value associated to the key */
+        value?: Array<number> | number;
+    }>;
+    /** The maximum voxel value handled by the material */
+    rangeMax: number;
+    /** The minimum voxel value handled material */
+    rangeMin: number;
+    /** The roughness look up table */
+    roughnessLUT?: Array<{
+        /** The normalized key for this entry */
+        key?: number;
+        /** The value associated to the key */
+        value?: Array<number> | number;
+    }>;
+    /** Unique identifier for the asset */
+    uuid: string;
+};
+export type AssetContainerWithPayload = 'animations' | 'animation_graphs' | 'animation_sequences' | 'collision_geometries' | 'meshes' | 'point_clouds' | 'scripts' | 'shaders' | 'skeletons' | 'sounds' | 'textures' | 'textures_3d';
+export type AssetContainerWithGraph = 'animation_graphs' | 'render_graphs' | 'scripts' | 'shaders';
+export type AssetContainerWithCode = 'animation_sequences' | 'modules' | 'scripts' | 'shaders';
+export type AssetContainerExportable = 'meshes' | 'sounds';
+export type Vector3 = Array<number>;
+/** An entity of a scene: its components, by class. */
+export type Entity = {
+    /** Drives skeletal animation using an Animation Graph and Animation Set; animates descendant skinned meshes whose skeletons are compatible with the set. */
+    animation_controller?: {
+        /** Referenced Animation Graph (UUID). */
+        animationGraphRef?: string;
+        /** Referenced Animation Set (UUID). */
+        animationSetRef?: string;
+        /** Autoplay when the session starts. */
+        autoPlay?: boolean;
+        /** Animation Graph input parameters in JSON format. */
+        dataJSON?: {
+            [_additionalproperties_: string]: any;
+        };
+        /** Entity containing the Bone component for the skeleton's root bone. */
+        rootBoneEntityRef?: {
+            linkage: Array<string>;
+            /** A unique identifier, such as an entity's, or the nil uuid for none. */
+            originalEUID: string;
+        };
+        /** Enable root motion extraction and application to the entity transform. */
+        rootMotionEnabled?: boolean;
+    };
+    /** Controls playback of an Animation Sequence; assigns tracks to entities. */
+    animation_sequence_controller?: {
+        /** Referenced Animation Sequence (UUID). */
+        animationSequenceRef?: string;
+        /** Map from track UUID to assigned entity. */
+        entities?: {
+            /** A reference to an entity: the uuid it was created with, and the uuids of the linkers it was instanced through. */
+            [_additionalproperties_: string]: {
+                linkage: Array<string>;
+                /** A unique identifier, such as an entity's, or the nil uuid for none. */
+                originalEUID: string;
+            };
+        };
+        /** Loop playback when reaching the stop offset. */
+        loop?: boolean;
+        /** Playback speed multiplier. Negative values play in reverse. */
+        playbackSpeed?: number;
+        /** Normalized start offset [0, 1]. */
+        startOffset?: number;
+        /** Normalized stop offset [0, 1]. When looping, playback wraps to startOffset at this point. */
+        stopOffset?: number;
+    };
+    /** Associates this entity with a bone in a skeleton (for attachments and transforms). */
+    bone?: {
+        /** Zero-based index of this bone within the bound skeleton. */
+        boneIndex?: number;
+    };
+    /** Box geometry. */
+    box_geometry?: {
+        /** Box dimensions (width, height, depth) in meters. */
+        dimension?: Array<number>;
+        /** Local offset of the geometry origin (meters). */
+        offset?: Array<number>;
+    };
+    /** Virtual camera. */
+    camera?: {
+        /** Render Graph input parameters in JSON; schema defined by renderGraphRef. */
+        dataJSON?: {
+            [_additionalproperties_: string]: any;
+        };
+        /** Referenced render graph to use for rendering from this camera. */
+        renderGraphRef?: string;
+        /** Index of the render target to blit/output to. -1 indicates the default target. */
+        renderTargetIndex?: number;
+    };
+    /** Capsule geometry. */
+    capsule_geometry?: {
+        /** Alignment axis of the capsule: 0=X, 1=Y, 2=Z. */
+        axis?: (0 | 1 | 2) & number;
+        /** Height of the cylindrical mid-section (meters). */
+        height?: number;
+        /** Local offset of the geometry origin (meters). */
+        offset?: Array<number>;
+        /** Radius of the hemispherical ends (meters). */
+        radius?: number;
+    };
+    /** Kinematic character controller for collision-constrained movement without a rigid body. Uses tuned collision handling for responsive control. */
+    character_controller?: {
+        /** Collision skin width (meters). */
+        skinWidth?: number;
+        /** Maximum walkable slope (degrees). Slopes steeper than this are not walkable. */
+        slopeLimit?: number;
+        /** Maximum climbable step height. Steps higher than this cannot be climbed automatically. */
+        stepOffset?: number;
+    };
+    /** Reference to a collision geometry asset used by physics. */
+    collision_geometry_ref?: {
+        /** Referenced collision geometry (UUID). */
+        collisionGeometryRef?: string;
+    };
+    /** 6-DoF constraint built on a Joint. Defaults to fixed; selectively unlock translation and rotation on X/Y/Z and configure limits and springs. */
+    constraint?: {
+        /** Linear limit spring damping per axis (N·s/m). */
+        motionLimitSpringDamping?: Array<number>;
+        /** Linear limit spring stiffness per axis (N/m). >0 makes the limit soft (spring-like). */
+        motionLimitSpringStiffness?: Array<number>;
+        /** Lower linear limit per axis (meters). */
+        motionLowerLimit?: Array<number>;
+        /** Upper linear limit per axis (meters). */
+        motionUpperLimit?: Array<number>;
+        /** Swing cone half-angles about Y and Z of the constraint frame (degrees). 0 does not restrict rotation; max 180. Used if either swing axis is limited. */
+        swingLimitAngle?: Array<number>;
+        /** Swing limit spring damping (N·m·s/rad). */
+        swingSpringDamping?: number;
+        /** Swing limit spring stiffness (N·m/rad). >0 makes the limit soft. */
+        swingSpringStiffness?: number;
+        /** Twist angle limits (min,max) around the twist axis (degrees). Range (−360, 360). */
+        twistLimitAngle?: Array<number>;
+        /** Twist limit spring damping (N·m·s/rad). */
+        twistSpringDamping?: number;
+        /** Twist limit spring stiffness (N·m/rad). >0 makes the limit soft. */
+        twistSpringStiffness?: number;
+        /** Unlock motion along/around the specified axes. */
+        unlockedMotion?: number;
+    };
+    /** Drives a Constraint toward target position/orientation and velocities using configurable stiffness, damping, and force limits. */
+    constraint_actuator?: {
+        /** Angular drive damping per axis (N·m·s/rad). */
+        angularDamping?: Array<number>;
+        /** Max angular drive torque/impulse per axis (N·m). −1 = unlimited. */
+        angularForceLimit?: Array<number>;
+        /** Angular drive stiffness per axis (N·m/rad). >0 applies spring torque toward the goal. */
+        angularStiffness?: Array<number>;
+        /** Target angular velocity (rad/s). */
+        angularVelocity?: Array<number>;
+        /** Target angular orientation. */
+        goalOrientation?: Array<number>;
+        /** Target linear position offset (meters). */
+        goalPosition?: Array<number>;
+        /** Linear drive damping per axis (N·s/m). */
+        linearDamping?: Array<number>;
+        /** Max linear drive force/impulse per axis (N). −1 = unlimited. */
+        linearForceLimit?: Array<number>;
+        /** Linear drive stiffness per axis (N/m). >0 applies spring force toward the goal. */
+        linearStiffness?: Array<number>;
+        /** Target linear velocity (m/s). */
+        linearVelocity?: Array<number>;
+        /** Drive type: apply as force or as acceleration. */
+        type?: (0 | 1) & number;
+    };
+    /** Enables culling using a simple analytic shape. Add alongside a geometry component (box, cylinder, plane, sphere). */
+    culling_geometry?: {
+        /** Additive: show elements inside the geometry. Subtractive: show elements outside the geometry. */
+        isAdditive?: boolean;
+    };
+    /** Custom projection lens using an explicit projection matrix. */
+    custom_lens?: {
+        /** Projection matrix mapping view-space to clip-space (cs_from_vs). */
+        cs_from_vs?: Array<number>;
+    };
+    /** Cylinder geometry. */
+    cylinder_geometry?: {
+        /** Alignment axis of the cylinder: 0=X, 1=Y, 2=Z. */
+        axis?: (0 | 1 | 2) & number;
+        /** Height of the cylinder (meters). */
+        height?: number;
+        /** Local offset of the geometry origin (meters). */
+        offset?: Array<number>;
+        /** Radius of the cylinder (meters). */
+        radius?: number;
+    };
+    /** Human-readable name of the entity. */
+    debug_name?: {
+        /** Entity name. */
+        value?: string;
+    };
+    /** Projects a material onto scene surfaces within the projector's box volume. */
+    decal_projector?: {
+        /** Z-index ordering for decal rendering; higher values render on top of lower ones. */
+        zIndex?: number;
+    };
+    /** Scene environment settings, including skybox background and precomputed image-based lighting (IBL). This component is only applied in the scene where this entity lives, it is discarded for subscenes. */
+    environment?: {
+        /** Diffuse irradiance cubemap used for ambient PBR lighting. */
+        irradianceUUID?: string;
+        /** Specular radiance cubemap (prefiltered) used for PBR reflections. */
+        radianceUUID?: string;
+        /** Skybox cubemap used as the scene background (no lighting effect). */
+        skyboxUUID?: string;
+    };
+    /** Unique identifier for the entity. */
+    euid: {
+        /** Unique identifier value. */
+        value: string;
+    };
+    /** Base joint connecting two bodies. By default locks relative position and orientation between constrainer and constrainee. */
+    joint?: {
+        /** Break force threshold (Newtons). */
+        breakForce?: number;
+        /** Break torque threshold (N·m). */
+        breakTorque?: number;
+        /** Entity with a Rigid Body to be constrained. */
+        constrainee?: {
+            linkage: Array<string>;
+            /** A unique identifier, such as an entity's, or the nil uuid for none. */
+            originalEUID: string;
+        };
+        /** Entity acting as constrainer (rigid/static) or null to constrain to world origin. */
+        constrainer?: {
+            linkage: Array<string>;
+            /** A unique identifier, such as an entity's, or the nil uuid for none. */
+            originalEUID: string;
+        };
+        /** Enable collision between constrainer and constrainee bodies. */
+        enableCollision?: boolean;
+    };
+    /** Displays an editor-only label in the 3D view. */
+    label?: {
+        /** Camera framing parameters for navigating to the label. */
+        camera?: Array<number>;
+        /** Label description text. */
+        description?: string;
+        /** Camera travel speed (meters/second). */
+        speed?: number;
+        /** Label title text. */
+        title?: string;
+    };
+    /** Records the entity's lineage through linkers and parentage. */
+    lineage?: {
+        /** Ordinal index among siblings (editor-only). */
+        ordinal?: number;
+        /** UUID of this entity's parent (default is root). */
+        parentUUID?: string;
+    };
+    /** Local-space axis-aligned bounding box. */
+    local_aabb?: {
+        /** Local AABB maximum corner (x,y,z). */
+        max?: Array<number>;
+        /** Local AABB minimum corner (x,y,z). */
+        min?: Array<number>;
+    };
+    /** Local transform of the entity (position, orientation, scale). */
+    local_transform?: {
+        /** Local orientation as Euler angles (editor-only). */
+        eulerOrientation?: Array<number>;
+        /** Last global orientation entered by a user as Euler angles (may be invalid; editor-only). */
+        globalEulerOrientation?: Array<number>;
+        /** Local orientation as a quaternion. */
+        orientation?: Array<number>;
+        /** Local position (x, y, z) in meters. */
+        position?: Array<number>;
+        /** Local non-uniform scale (x, y, z). */
+        scale?: Array<number>;
+    };
+    /** Assigns a shader to the entity's mesh and provides its input values and specialization constants. */
+    material?: {
+        /** Specialization constants (JSON); schema defined by shaderRef. */
+        constantsJSON?: {
+            [_additionalproperties_: string]: any;
+        };
+        /** Shader input values (JSON); schema defined by shaderRef. */
+        dataJSON?: {
+            [_additionalproperties_: string]: any;
+        };
+        /** Render both front and back faces (double-sided). */
+        isDoubleSided?: boolean;
+        /** Referenced shader (UUID). */
+        shaderRef?: string;
+    };
+    /** Reference to a material to use for rendering. */
+    material_ref?: {
+        /** Face culling override: 0 = inherit from material, 1 = single-sided, 2 = double-sided. */
+        faceCulling?: (0 | 1 | 2) & number;
+        /** Referenced material (UUID). */
+        value?: string;
+    };
+    /** Displays editor-only measurement annotations in the 3D view. */
+    measure?: {
+        /** Display color for the measurement. */
+        color?: Array<number>;
+        /** Measurement type to display. */
+        type?: (0 | 1 | 2 | 3) & number;
+    };
+    /** Reference to a mesh to render (with submesh selection). */
+    mesh_ref?: {
+        /** Shadow casting mode for this mesh. */
+        shadowCastingMode?: (0 | 1) & number;
+        /** Index of the submesh within the mesh's submesh array. */
+        submeshIndex?: number;
+        /** Referenced mesh (UUID). */
+        value?: string;
+    };
+    /** Contains weights assigned to morph targets of the mesh referred to by the entity's mesh_ref. */
+    morph_targets?: {
+        /** Map from morph target name to weight (commonly 0..1). */
+        weights?: {
+            [_additionalproperties_: string]: number;
+        };
+    };
+    /** Orthographic projection lens with configurable zoom and depth range. */
+    orthographic_lens?: {
+        /** Far clipping plane distance (meters). */
+        zFar?: number;
+        /** Near clipping plane distance (meters). */
+        zNear?: number;
+        /** Zoom factor applied to the orthographic extents (X,Y). 1 = no zoom. */
+        zoomFactor?: Array<number>;
+    };
+    /** Overrides an entity from a subscene: mark for deletion, replace components, or detach specific components. */
+    overrider?: {
+        /** Hashes of components to detach from the overridden entity. */
+        componentsToDetach?: Array<number>;
+        /** Mark the overridden entity as deleted in the composed scene. */
+        deleter?: boolean;
+        /** Target entity to override. */
+        entityRef?: {
+            linkage: Array<string>;
+            /** A unique identifier, such as an entity's, or the nil uuid for none. */
+            originalEUID: string;
+        };
+    };
+    /** Perspective projection lens with vertical field of view and near/far clipping planes. */
+    perspective_lens?: {
+        /** Far clipping plane distance (meters). Set to 0 for an infinite far plane. */
+        farPlane?: number;
+        /** Vertical field of view angle in degrees. */
+        fovy?: number;
+        /** Near clipping plane distance (meters). */
+        nearPlane?: number;
+        /** Projection center offset for stereoscopic rendering (meters). */
+        offset?: Array<number>;
+    };
+    /** Physical surface properties used for contact: friction, restitution, optional contact modification, and trigger mode. */
+    physics_material?: {
+        /** Applied contact velocity offset when colliding (m/s). Only used if modifyContact is true. */
+        contactVelocity?: Array<number>;
+        /** Dynamic (kinetic) friction coefficient (typically 0..1). If greater than staticFriction, staticFriction is clamped up to match. Effective value is averaged with the other surface. */
+        dynamicFriction?: number;
+        /** Treat associated geometry as a trigger (generates events but no physical response). */
+        isTrigger?: boolean;
+        /** Enable contact modification (applies contactVelocity on collisions). */
+        modifyContact?: boolean;
+        /** Restitution (bounciness) in [0,1]. 0 = no bounce; 1 = perfectly elastic. Effective value is averaged with the other surface. */
+        restitution?: number;
+        /** Static friction coefficient (typically 0..1). 0 feels like ice; higher resists start of motion. Effective value is averaged with the other surface. */
+        staticFriction?: number;
+    };
+    /** Infinite plane geometry. */
+    plane_geometry?: {
+        /** Signed distance from the origin along the plane normal (meters). */
+        distance?: number;
+        /** Unit normal vector of the plane (in local space). */
+        normal?: Array<number>;
+    };
+    /** Reference to a point cloud. */
+    point_cloud_ref?: {
+        /** Referenced point cloud (UUID). */
+        value?: string;
+    };
+    /** Omnidirectional light source with physically based intensity and falloff. Acts as a point light by default; enable isDirectional to emit parallel rays. Attach a Spot Light component to add a cone cutoff. Can optionally drive the atmosphere sun direction. */
+    point_light?: {
+        /** RGB light color in linear space [0-1]. Multiplies intensity. */
+        color?: Array<number>;
+        /** Luminous intensity in candela (cd) for point and spot lights. Illuminance in lux (lx) when isDirectional, above the atmosphere when isSun. */
+        intensity?: number;
+        /** Treat this as a directional light using the entity's orientation; position is ignored. */
+        isDirectional?: boolean;
+        /** Use this light's direction to control the atmosphere sun direction. */
+        isSun?: boolean;
+        /** Distance in meters at which the inverse-square falloff is windowed to zero. 0 for no cutoff. */
+        range?: number;
+    };
+    /** Omnidirectional reflection probe that captures the local environment into a cubemap for specular reflections (IBL). */
+    reflection_probe?: {
+        /** Capture far clip distance (meters). */
+        farDist?: number;
+        /** Capture near clip distance (meters). */
+        nearDist?: number;
+        /** Offset of the probe capture origin relative to the entity position (meters). */
+        offset?: Array<number>;
+        /** Reflection cubemap resolution (pixels per face). Higher values increase detail and cost. */
+        quality?: number;
+    };
+    /** Rigid body parameters for dynamic simulation (mass, damping, limits, CCD, and kinematic/gravity behavior). */
+    rigid_body?: {
+        /** Angular damping coefficient (s^-1). 0 = no damping; must be non-negative. */
+        angularDamping?: number;
+        /** Center of mass relative to the entity's local transform (meters). */
+        centerOfMass?: Array<number>;
+        /** Collision detection mode (CCD). Kinematic bodies do not support Linear/Continuous CCD. */
+        collisionDetection?: (0 | 1 | 2 | 3) & number;
+        /** Treat the rigid body as kinematic (unaffected by forces; driven by animation/app logic). */
+        isKinematic?: boolean;
+        /** Linear damping coefficient (s^-1). 0 = no damping; must be non-negative. */
+        linearDamping?: number;
+        /** Lock motion along/around the specified axes. */
+        lockedAxis?: number;
+        /** Mass (kg). A value of 0 is treated as infinite mass (static). */
+        mass?: number;
+        /** Maximum angular velocity (rad/s). Must be non-negative. */
+        maxAngularVelocity?: number;
+        /** Maximum linear velocity (m/s). Must be non-negative. */
+        maxLinearVelocity?: number;
+        /** Whether the rigid body is affected by gravity. */
+        useGravity?: boolean;
+    };
+    /** Reference to a subscene (linker); used to compose scenes. */
+    scene_ref?: {
+        /** Maximum recursion depth when a scene references itself. */
+        maxRecursionCount?: number;
+        /** Referenced scene (UUID). */
+        value?: string;
+    };
+    /** References a script and supplies its input values. */
+    script_element?: {
+        /** Script input values in JSON; schema defined by scriptRef. */
+        dataJSON?: {
+            [_additionalproperties_: string]: any;
+        };
+        /** Referenced script (UUID). */
+        scriptRef?: string;
+    };
+    /** Holds a set of script elements keyed by UUID. */
+    script_map?: {
+        /** Map of script UUID to script element. */
+        elements?: {
+            /** References a script and supplies its input values. */
+            [_additionalproperties_: string]: {
+                /** Script input values in JSON; schema defined by scriptRef. */
+                dataJSON?: {
+                    [_additionalproperties_: string]: any;
+                };
+                /** Referenced script (UUID). */
+                scriptRef?: string;
+            };
+        };
+    };
+    /** Enables a light to cast real-time shadows with configurable map resolution, depth range, and (for directional lights) cascades. */
+    shadow_caster?: {
+        /** Directional lights only: blend/accumulate all cascades to reduce visible transitions between splits. */
+        accumulateShadowCascades?: boolean;
+        /** Depth bias applied during shadow tests to reduce self-shadowing (acne). Increase to mitigate artifacts; too high causes peter-panning. */
+        bias?: number;
+        /** Directional lights only: number of cascades for CSM. 0 = static shadow map, 1–4 = increasing cascade count. */
+        cascadeCount?: (0 | 1 | 2 | 3 | 4) & number;
+        /** Directional lights only: cascade split distribution for CSM. 0 = uniform (linear) splits; 1 = logarithmic (more resolution near the camera). Values in [0,1] blend between the two. */
+        cascadeSplitLambda?: number;
+        /** Shadow camera far clip distance (meters). Use the smallest range that contains casters/receivers. */
+        farDist?: number;
+        /** Shadow camera near clip distance (meters). Tighten to improve depth precision. */
+        nearDist?: number;
+        /** Shadow map resolution (pixels per side). Higher values increase detail at the cost of memory and performance. */
+        quality?: (256 | 512 | 1024 | 2048 | 3072 | 4096 | 6144 | 8192) & number;
+    };
+    /** Reference to a skeleton asset for skinning and animation. */
+    skeleton_ref?: {
+        /** Referenced skeleton (UUID). */
+        value?: string;
+    };
+    /** Reference to a sound asset with playback and spatialization controls. */
+    sound_ref?: {
+        /** Distance attenuation model. */
+        attenuationModel?: (0 | 1 | 2 | 3) & number;
+        /** Rolloff factor for distance attenuation. */
+        attenuationRolloffFactor?: number;
+        /** Autoplay when the simulation starts. */
+        autoPlayOnStart?: boolean;
+        /** Scale factor for the Doppler effect. */
+        dopplerFactor?: number;
+        /** Behavior when the sound becomes inaudible. */
+        inaudibleBehavior?: (0 | 1 | 2) & number;
+        /** Whether the sound loops. */
+        looping?: boolean;
+        /** Distance beyond which the sound is inaudible (meters). */
+        maxDistance?: number;
+        /** Distance at which the sound stays at max volume (meters). */
+        minDistance?: number;
+        /** Stereo pan. −1 = left, 1 = right. */
+        pan?: number;
+        /** Playback speed multiplier (1.0 = normal). */
+        playSpeed?: number;
+        /** Referenced sound (UUID). */
+        value?: string;
+        /** Playback volume [0..1]. */
+        volume?: number;
+    };
+    /** Sphere geometry. */
+    sphere_geometry?: {
+        /** Local offset of the geometry origin (meters). */
+        offset?: Array<number>;
+        /** Radius of the sphere (meters). */
+        radius?: number;
+    };
+    /** Displays an editor-only spline in the 3D view. */
+    spline?: {
+        /** Display color of the curve. */
+        color?: Array<number>;
+        /** Catmull-Rom tension (only when type is Catmull-Rom). */
+        tension?: number;
+        /** Spline interpolation type. */
+        type?: (0 | 1 | 2) & number;
+    };
+    /** Adds a cone cutoff to a light, producing a spotlight. Requires a Point Light component for color/intensity and falloff. */
+    spot_light?: {
+        /** Optional IES photometric profile (2D texture). Modulates emitted intensity by direction; leave empty for uniform distribution. */
+        IESProfile?: string;
+        /** Cone half-angle in degrees, from the axis to the edge. Light falls to zero at the cone edge. */
+        cutoff?: number;
+    };
+    /** Free-form tags used to group and filter entities. */
+    tags?: {
+        /** List of tags applied to this entity. */
+        value?: Array<string>;
+    };
+    /** Vehicle Controller parameters. */
+    vehicle_controller?: {
+        /** The chassis. */
+        chassis?: {
+            linkage: Array<string>;
+            /** A unique identifier, such as an entity's, or the nil uuid for none. */
+            originalEUID: string;
+        };
+        /** The front left wheel. */
+        frontLeftWheel?: {
+            linkage: Array<string>;
+            /** A unique identifier, such as an entity's, or the nil uuid for none. */
+            originalEUID: string;
         };
-        /** Parameter type */
-        type: 'vec4' | 'ivec4' | 'quat' | 'color_alpha' | 'vec3' | 'ivec3' | 'color' | 'vec2' | 'ivec2' | 'float' | 'int' | 'uint' | 'bool' | 'texture' | 'render_target_index' | 'buffer';
-    }>;
-    /** Descriptions of all modules that compose this shader */
-    moduleDescriptions?: Array<{
-        /** Names of the bindings used by this module */
-        bindings?: Array<string>;
-        /** Constants used by this module */
-        constants?: {
-            [_additionalproperties_: string]: Array<number>;
+        /** The front right wheel. */
+        frontRightWheel?: {
+            linkage: Array<string>;
+            /** A unique identifier, such as an entity's, or the nil uuid for none. */
+            originalEUID: string;
         };
-        /** Entry point of the shader module */
-        entryPoint?: string;
-        /** Outputs of this shader module (e.g. a fragment shader's color attachments, or the last stage's varying outputs), used to validate the module's compatibility with a render pipeline */
-        outputs?: Array<{
-            /** Output location */
-            location: number;
-            /** Output variable name */
-            name: string;
-            /** Output variable type */
-            type: 'bool' | 'int8' | 'int16' | 'int32' | 'int64' | 'uint8' | 'uint16' | 'uint32' | 'uint64' | 'float16' | 'float32' | 'float64' | 'vec2' | 'ivec2' | 'vec3' | 'ivec3' | 'vec4' | 'ivec4' | 'pointer';
-        }>;
-        /** Offset in byte in the shader payload buffer */
-        payloadOffset: number;
-        /** Size in byte of the compiled module */
-        payloadSize: number;
-        /** Push constant members used by this module, used to validate push constant layout compatibility across the pipeline's stages */
-        pushConstants?: Array<{
-            /** Push constant member name */
-            name: string;
-            /** Offset in byte within the push constant block */
-            offset: number;
-            /** Size in byte of the push constant member */
-            size: number;
-            /** Push constant member type */
-            type: 'bool' | 'int8' | 'int16' | 'int32' | 'int64' | 'uint8' | 'uint16' | 'uint32' | 'uint64' | 'float16' | 'float32' | 'float64' | 'vec2' | 'ivec2' | 'vec3' | 'ivec3' | 'vec4' | 'ivec4' | 'pointer';
-        }>;
-        /** The shader stage */
-        shaderStage: number;
-        /** Bit mask of the descriptor bindings used by this module, bit N for binding N */
-        usedBindings: number;
-    }>;
-    /** Name of the asset */
-    name: string;
-    /** Data descriptor for render graph node shaders */
-    nodeDataDescriptor?: Array<{
-        /** Additional properties for a parameter of type "buffer": how many elements it holds, the size of each element, and how the buffer is used. Absent for every other parameter type */
-        bufferProperties?: {
-            /** Number of elements in the buffer, or a [x, y] pair of factors applied to the viewport width and height (each rounded up and clamped to a minimum of 1, then multiplied) to compute the element count */
-            elementCount: number | Array<number>;
-            /** Size in bytes of a single element in the buffer. If the buffer is declared as `T *buffer`, this is sizeof(T) */
-            elementSize: number;
-            /** How this buffer is going to be used */
-            usage: number;
+        /** The rear left wheel. */
+        rearLeftWheel?: {
+            linkage: Array<string>;
+            /** A unique identifier, such as an entity's, or the nil uuid for none. */
+            originalEUID: string;
         };
-        /** Categories */
-        categories?: Array<string>;
-        /** Parameter default value */
-        default?: number | boolean | Array<number>;
-        /** Description of the parameter, shown by tools. Not read by the engine */
-        description?: string;
-        /** Identifier of the parameter, kept while its name is, and never given to another: tools follow a parameter across the versions of its shader by it. Not read by the engine */
-        id?: number;
-        /** Whether this parameter (a render target or buffer) is the resource used to compute the number of dispatched workgroups for a compute shader, i.e. DispatchedGroups = referenceResource.size / workgroupSize (see compute_shader_size_reference's reference_resource) */
-        isReferenceResource?: boolean;
-        /** For a parameter holding one of a set of values: each value, named and described for tools. Not read by the engine */
-        list?: Array<{
-            description?: string;
-            name: string;
-            value: number;
-        }>;
-        /** Parameter name */
-        name: string;
-        /** Parameter native type */
-        nativeType: 'vec4' | 'vec3' | 'vec2' | 'float' | 'int32_t' | 'texture2d_ref' | 'render_target_index' | 'buffer_reference';
-        /** Parameter offset in bytes */
-        offset: number;
-        /** Additional properties gating this parameter's relevance and/or driving how it's interpreted by tooling (e.g. the material editor) */
-        properties?: {
-            /** For a parameter of type "texture" or "render_target_index": the underlying pixel type's exact format */
-            format?: 'int32' | 'uint32' | 'int64' | 'uint64' | 'float32' | 'float64' | 'vec2' | 'ivec2' | 'vec3' | 'ivec3' | 'vec4' | 'ivec4' | 'color3' | 'color4';
-            /** For a parameter of type "buffer" or "render_target_index": how the underlying resource is accessed */
-            openMode?: 'read' | 'write' | 'readwrite';
-            /** Specialization constants gating this parameter's relevance: the key is a constant name, the value is what it must hold for the parameter to be relevant (e.g. shown in the material editor) */
-            spec?: {
-                [_additionalproperties_: string]: number | boolean;
-            };
+        /** The rear right wheel. */
+        rearRightWheel?: {
+            linkage: Array<string>;
+            /** A unique identifier, such as an entity's, or the nil uuid for none. */
+            originalEUID: string;
         };
-        /** Parameter type */
-        type: 'vec4' | 'ivec4' | 'quat' | 'color_alpha' | 'vec3' | 'ivec3' | 'color' | 'vec2' | 'ivec2' | 'float' | 'int' | 'uint' | 'bool' | 'texture' | 'render_target_index' | 'buffer';
-    }>;
-    /** Hash of the node data descriptor, used to detect changes in the descriptor */
-    nodeDataDescriptorHash?: number;
-    /** The size in byte of the compiled shader code (accumulated size of all modules) */
-    payloadSize?: number;
-    /** Reference to the shader context associated with this shader. Only present for shaders that use one. */
-    shaderContextRef?: string;
-    /** Vulkan bit mask of all shader stages present in this shader */
-    shaderStages?: number;
-    /** Unique identifier for the asset */
-    uuid: string;
-    /** Vertex description. Only valid when a vertex shader module is present */
-    vertexDescriptor?: Array<{
-        /** Binding number */
-        binding: number;
-        /** Format */
-        format: number;
-        /** Location */
-        location: number;
-        /** Offset */
-        offset: number;
-        /** Semantic */
-        semantic: (1 | 2 | 4 | 8 | 16 | 32) & number;
-        /** Stride between consecutive elements within the buffer */
-        stride: number;
-    }>;
-} | {
-    /** The albedo look up table */
-    albedoLUT?: Array<{
-        /** The normalized key for this entry */
-        key?: number;
-        /** The value associated to the key */
-        value?: Array<number> | number;
-    }>;
-    /** The metallic look up table */
-    metallicLUT?: Array<{
-        /** The normalized key for this entry */
-        key?: number;
-        /** The value associated to the key */
-        value?: Array<number> | number;
-    }>;
-    /** Name of the asset */
-    name: string;
-    /** The opacity look up table */
-    opacityLUT?: Array<{
-        /** The normalized key for this entry */
-        key?: number;
-        /** The value associated to the key */
-        value?: Array<number> | number;
-    }>;
-    /** The maximum voxel value handled by the material */
-    rangeMax: number;
-    /** The minimum voxel value handled material */
-    rangeMin: number;
-    /** The roughness look up table */
-    roughnessLUT?: Array<{
-        /** The normalized key for this entry */
-        key?: number;
-        /** The value associated to the key */
-        value?: Array<number> | number;
-    }>;
-    /** Unique identifier for the asset */
-    uuid: string;
+    };
+    /** View filtering and display controls applied to the referenced volume. */
+    volume_filter?: {
+        /** Apply Gaussian smoothing when sampling voxels. */
+        applyGaussianFiltering?: boolean;
+        /** Whether this volume is visible in the 3D view. */
+        enable3D?: boolean;
+        /** Whether this volume is visible in the MPR (multi-planar reconstruction) view. */
+        enableMPR?: boolean;
+        /** Tint applied to this volume's MPR/projection output. */
+        mprColor?: Array<number>;
+        /** Displayed voxel intensity range [min, max]. Values outside the material's valid range are clamped/ignored. */
+        range?: Array<number>;
+        /** Sample texels without hardware filtering (nearest). */
+        sampleUnfiltered?: boolean;
+    };
+    /** Reference to the volume material used for shading and transfer functions. */
+    volume_material_ref?: {
+        /** Referenced volume material (UUID). */
+        value?: string;
+    };
+    /** Reference to a volumetric dataset stored as a 3D texture (voxels). */
+    volume_ref?: {
+        /** Referenced 3D texture (UUID) containing the volume voxels. */
+        texture3dRef?: string;
+    };
 };
-export type AssetContainerWithPayload = 'animations' | 'animation_graphs' | 'animation_sequences' | 'collision_geometries' | 'meshes' | 'point_clouds' | 'scripts' | 'shaders' | 'skeletons' | 'sounds' | 'textures' | 'textures_3d';
-export type AssetContainerWithGraph = 'animation_graphs' | 'render_graphs' | 'scripts' | 'shaders';
-export type AssetContainerWithCode = 'animation_sequences' | 'modules' | 'scripts' | 'shaders';
-export type AssetContainerExportable = 'meshes' | 'sounds';
-export type Vector3 = Array<number>;
-/** An entity of a scene: its components, by class. */
-export type Entity = {
+/** An entity of a scene, with its global transform when it was asked for */
+export type SceneEntity = {
     /** Drives skeletal animation using an Animation Graph and Animation Set; animates descendant skinned meshes whose skeletons are compatible with the set. */
     animation_controller?: {
         /** Referenced Animation Graph (UUID). */
@@ -3705,6 +4218,15 @@ export type Entity = {
         /** Referenced 3D texture (UUID) containing the volume voxels. */
         texture3dRef?: string;
     };
+    /** The entity's transform in its scene's space, its parents' local transforms composed with its own. */
+    global_transform?: {
+        /** Position (x, y, z) in meters. */
+        position: Array<number>;
+        /** Orientation as a quaternion (x, y, z, w). */
+        orientation: Array<number>;
+        /** Scale (x, y, z), its parents' scales multiplied by its own. */
+        scale: Array<number>;
+    };
 };
 /** The settings of a scene: its settings blocks, by class. */
 export type SceneSettings = {
@@ -4076,10 +4598,6 @@ export type EventJobCompleted = {
     user_id: string;
 };
 export type AssetContainerCreatable = 'action_maps' | 'animation_graphs' | 'animation_sequences' | 'animation_sets' | 'cubemaps' | 'event_maps' | 'materials' | 'modules' | 'render_graphs' | 'scenes' | 'scripts' | 'shaders' | 'volume_materials';
-/** Signature that can be used to verify the authenticity of a request. */
-export type X3dverseSignature = string;
-/** Unix timestamp of when the signature was generated, in milliseconds. */
-export type X3dverseSignatureTimestamp = number;
 /** The body of every error response */
 export type ErrorResponse = {
     error: ServiceError;
@@ -4100,6 +4618,7 @@ export type ConvertingStatus = 'converting';
 export type ErrorStatus = 'error';
 /** The task was successfully processed, and the asset is ready to use. */
 export type SuccessStatus = 'success';
+export type PipelineId = ImportId;
 export type DuplicationResult = AssetDuplicationResult;
 export type GroupMemberInput = {
     user_id: UserId;
@@ -4340,6 +4859,8 @@ export type EditableAssetDescriptionInput = {
             [_additionalproperties_: string]: any;
         };
     };
+    /** Other modules this module uses */
+    moduleDependencies?: Array<string>;
     /** Name of the asset */
     name: string;
 } | {
@@ -5411,11 +5932,9 @@ export declare function listFolderSubFolders({ folder_id, }: {
  * exist. The submitted assets that already exist are overwritten only if they are listed in an `overwrite.json`
  * file, a JSON array of asset ids submitted along with them; without it, the import fails if one of them already
  * exists.
- * The import runs asynchronously, as a data pipeline:
- *   1. `GET /pipelines/{pipeline_id}`, with the returned `upload_task_id` as the pipeline id, tells its status and,
- *      on failure, the reason, such as the invalid assets or the missing permissions.
- *   2. Once it has succeeded, `GET /conversion_tasks/{conversion_task_id}/metadata/import_result.json`, with the id
- *      of the pipeline job as the conversion task id, returns the imported, overwritten and skipped asset ids.
+ * The import runs asynchronously, as a data pipeline, the returned `upload_task_id` being its id: once it has
+ * succeeded, `GET /conversion_tasks/{conversion_task_id}/metadata/import_result.json`, with the id of its conversion
+ * as the conversion task id, returns the imported, overwritten and skipped asset ids.
  */
 export declare function uploadSourceFiles({ folder_id, files, task_name, conversion_pipeline, source_files, options, }: {
     folder_id: FolderId;
@@ -5715,14 +6234,8 @@ export declare function schedulePipeline({ data_pipeline_id, pipeline_name, fold
         asset_id: AssetId;
     }>;
 }, headers?: RawAxiosRequestHeaders | AxiosRequestHeaders): AxiosPromise<{
-    pipeline_id: PipelineId;
+    pipeline_id: ImportId;
 }>;
-/**
- * Retrieves a specific instantiated Data Pipeline by its ID.
- */
-export declare function getPipeline({ pipeline_id, }: {
-    pipeline_id: PipelineId;
-}, headers?: RawAxiosRequestHeaders | AxiosRequestHeaders): AxiosPromise<Pipeline>;
 /**
  * Lists the assets of the caller's environment, at every depth, grouped by type, and with
  * `filter[include_public_assets]` those shared with the platform from any environment too, as asset pickers list
@@ -6562,7 +7075,7 @@ export declare function getEntity({ scene_id, entity_id, compute_global_transfor
     scene_id: AssetId;
     entity_id: string;
     compute_global_transform?: boolean;
-}, headers?: RawAxiosRequestHeaders | AxiosRequestHeaders): AxiosPromise<Entity>;
+}, headers?: RawAxiosRequestHeaders | AxiosRequestHeaders): AxiosPromise<SceneEntity>;
 /**
  * Update a specific entity from a scene.
  */
@@ -7164,7 +7677,7 @@ export declare function getRunningSessions({ filters, }: {
 /**
  * Create a new rendering session.
  */
-export declare function createSession({ scene_id, renderer_version, is_transient, options, }: {
+export declare function createSession({ scene_id, renderer_version, is_transient, options, metadata, }: {
     /** The unique identifier of the scene to launch. */
     scene_id: AssetId;
     /** The version of the renderer to use. */
@@ -7175,6 +7688,8 @@ export declare function createSession({ scene_id, renderer_version, is_transient
     options?: {
         [_additionalproperties_: string]: any;
     };
+    /** What the application attaches to the session, returned with it. */
+    metadata?: Metadata;
 }, headers?: RawAxiosRequestHeaders | AxiosRequestHeaders): AxiosPromise<{
     session_id: SessionId;
 }>;
@@ -7194,10 +7709,12 @@ export declare function killSession({ session_id, }: {
 /**
  * Creates a new client for the user and returns a token to join the session.
  */
-export declare function joinSession({ session_id, is_headless, }: {
+export declare function joinSession({ session_id, is_headless, metadata, }: {
     session_id: SessionId;
     /** Declare that the client is headless and will not receive any frames. Useful for clients running on servers or in the background. */
     is_headless?: boolean;
+    /** What the application attaches to the client the token creates, returned with it. */
+    metadata?: Metadata;
 }, headers?: RawAxiosRequestHeaders | AxiosRequestHeaders): AxiosPromise<SessionToken>;
 /**
  * Retrieves details about the target client.
@@ -7217,7 +7734,10 @@ export declare function kickClientFromSession({ session_id, client_id, }: {
 /**
  * Join a session as guest.
  */
-export declare function joinSessionAsGuest(headers?: RawAxiosRequestHeaders | AxiosRequestHeaders): AxiosPromise<SessionToken>;
+export declare function joinSessionAsGuest({ metadata, }: {
+    /** What the application attaches to the client the token creates, returned with it. */
+    metadata?: Metadata;
+}, headers?: RawAxiosRequestHeaders | AxiosRequestHeaders): AxiosPromise<SessionToken>;
 /**
  * Generates a token to join the session as a guest.
  */