@worldlabsai/client 0.4.0 → 0.6.0

package/src/generated/developer-api.gen.ts

@@ -106,6 +106,23 @@ export interface paths {
         patch?: never;
         trace?: never;
     };
+    "/api/v2/tasks:posedImages2Splats": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        get?: never;
+        put?: never;
+        /** Submit the posedImages2Splats task */
+        post: operations["submit_posedImages2Splats_api_v2_tasks_posedImages2Splats_post"];
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
     "/api/v2/tasks:splats2Mesh": {
         parameters: {
             query?: never;
@@ -607,20 +624,37 @@ export interface components {
          * @enum {string}
          */
         AssetState: "CREATED" | "UPLOADING" | "READY" | "DELETED";
+        /**
+         * AtlasChiselContextFrameAsset
+         * @description A context frame: its camera plus a depth, an image, or both.
+         */
+        AtlasChiselContextFrameAsset: {
+            /** @description Source image as a URL or inline asset, or null (depth-only). */
+            imageAsset?: components["schemas"]["TaskAsset"] | null;
+            /** @description Optional alpha mask as a URL or inline asset: an 8-bit grayscale PNG on the image grid whose pixel value / 255 is the alpha in [0, 1] (1 = kept, 0 = excluded). Null when the frame carries no mask. */
+            maskAsset?: components["schemas"]["TaskAsset"] | null;
+            /** @description Camera-to-world pose and intrinsics. */
+            camera: components["schemas"]["PinholeCamera"];
+            /**
+             * Depth
+             * @description Depth buffer aligned to the camera, with an optional mask; null for an image-only frame.
+             */
+            depth?: components["schemas"]["MaskedLogDepthBufferAsset"] | components["schemas"]["MaskedLinearDepthBufferAsset"] | null;
+        };
         /**
          * AtlasChiselModelParameters
-         * @description Model-specific parameters forwarded to the atlasChisel servable.
+         * @description Sampling controls for atlasChisel.
          */
         AtlasChiselModelParameters: {
             /**
              * Seed
-             * @description RNG seed forwarded to the servable when set.
+             * @description Random seed for image generation.
              * @default 42
              */
             seed?: number | null;
             /**
              * Numsteps
-             * @description Diffusion step count. Unset uses the served model's own sampler.
+             * @description Number of denoising steps. Omit to use the model's default.
              */
             numSteps?: number | null;
         };
@@ -639,19 +673,27 @@ export interface components {
              * @description Purge this operation's outputs and the transient uploads it consumed one hour after it finishes. Omitted, the account's setting applies; true raises it for this operation; false is refused when the account already purges. Uploads in the library are never purged by an operation.
              */
             purgeContentOnOperationCompletion?: boolean | null;
+            /**
+             * Base64Outputs
+             * @description When a ?wait=true submission is answered inline, return each output file as base64 in that response rather than by assetId and url. This skips storing the files before the answer and the caller's download after it. Any other submission, and every later read of the operation, names the outputs by assetId and url.
+             * @default false
+             */
+            base64Outputs?: boolean;
             /**
              * Contextframes
-             * @description Posed depth frames, one per target camera and posed at it, in target order; each camera is 1280x720. Frames may also carry an imageAsset (the view's known pixels) and a maskAsset (8-bit grayscale, white where the frame's image and depth are known), each on every frame or on none: the model keeps the image where the mask is set and generates the rest, takes frames without masks as fully known, and conditions on the depth alone for frames without an image. Frames carry no depth confidenceAsset. Leave empty to generate from the prompt alone.
+             * @description Posed frames, one per target camera and posed at it, in target order; each camera is 1280x720. Each frame carries a depth, an imageAsset (the view's known pixels), or both, and may carry a maskAsset (8-bit grayscale, white where the frame's image and depth are known). Send each of depth, imageAsset and maskAsset on every frame or on none: the model keeps the image where the mask is set and generates the rest, takes frames without masks as fully known, conditions on the depth alone for frames without an image, and for frames without depth keeps the image inside the mask and generates the geometry (the frames atlasMasked takes). A depth.maskAsset (8-bit grayscale on the depth grid, white where the depth is known), on every frame or on none, masks the depth apart from the image: the maskAsset then marks only the image and needs an imageAsset beside it. Both masks read as known above half intensity. Frames carry no depth confidenceAsset. Leave empty to generate from the prompt alone.
              */
-            contextFrames?: components["schemas"]["PosedDepthAsset"][];
+            contextFrames?: components["schemas"]["AtlasChiselContextFrameAsset"][];
             /**
              * Sourceframes
-             * @description Posed RGB photographs of the scene, each an image and its camera in the targets' coordinate convention and scale. The generated views stay consistent with them: the servable feeds them to the model as views it has already committed, so a target that sees the same surfaces keeps their materials, colors, and lighting. Any cameras and any resolution; each is cover-resized and center-cropped onto 1280x720. Frames carry no maskAsset or depth. Together with contextFrames and targetCameras they fill at most 128 views of the servable's rollout, where a context frame costs 3 and a photograph or target one.
+             * @description Posed RGB photographs of the scene, each an image and its camera in the targets' coordinate convention and scale. The generated views use them as visual references for materials, colors, and lighting. Any cameras and any resolution; each image is scaled to cover the output dimensions, then center-cropped onto 1280x720. Frames carry no maskAsset or depth. Together with contextFrames and targetCameras they share the served model's rollout, and a request that overflows it fails.
              */
             sourceFrames?: components["schemas"]["PosedRGBAsset"][];
+            /** @description Optional style-reference image that guides appearance; it supplies no camera or geometry. Not applied yet: the current model does not support style references, so frames generate without it. */
+            styleReferenceImageAsset?: components["schemas"]["TaskAsset"] | null;
             /**
              * Targetcameras
-             * @description Pinhole cameras at 1280x720 for the views to generate, in output order, returned in `frames`. At most 32.
+             * @description Pinhole cameras at 1280x720 for the views to generate, in output order, returned in `frames`. At most 1440.
              */
             targetCameras: components["schemas"]["PinholeCamera"][];
             /**
@@ -661,25 +703,25 @@ export interface components {
             prompt: string;
             /**
              * Enhanceprompt
-             * @description Rewrite the prompt into the structured scene caption the model trained on before inference. Set false to send the prompt as is.
+             * @description Expand the prompt into a detailed scene description before generation. Set false to use your wording unchanged.
              * @default true
              */
             enhancePrompt?: boolean;
             /**
              * Voxelsize
-             * @description Voxel side length in the normalized scene gauge (90th-percentile disparity is approximately 1). The recommended range is 0 to 0.4. Omit or set to 0 to keep the original depth conditioning.
+             * @description Side length of the cubes used to simplify depth geometry. Uses normalized scene units, not input distance units: the scene is rescaled so the 90th percentile of inverse depth is approximately 1. The recommended range is 0 to 0.4. Omit or set to 0 to keep the original geometry.
              */
             voxelSize?: number | null;
             /**
              * Voxelgridorientation
-             * @description Frame the voxelization grid axes align to. 'world' (the default) axis-aligns voxels with the request's world coordinates, so world-axis-aligned faces (blockout walls) quantize flat; 'gauge' keeps the legacy grid aligned to the normalized scene gauge (the recentered mean camera pose). Ignored unless voxelSize is set.
+             * @description Grid orientation for simplifying depth geometry. 'world' (the default) aligns the grid with the request's world axes so walls aligned with those axes stay flat. 'gauge' aligns the grid with the average camera pose after recentering the scene. Ignored unless voxelSize is set.
              */
             voxelGridOrientation?: ("world" | "gauge") | null;
             /** @description Model-specific parameters for atlasChisel. */
             modelParameters?: components["schemas"]["AtlasChiselModelParameters"];
             /**
              * Returndepth
-             * @description Return the generated frames as posed RGBD: they are reconstructed together so the depth lands in the request's own camera frame and scale, and every entry in `frames` then carries a `depth` buffer. The contextFrames' own depth is not reconstructed or returned. A source photograph joins the reconstruction as an anchor, and gets no depth back, only when its image is at the generated resolution and its camera's principal point is centered. Needs at least two target cameras. Limitation: the depth scale is recovered from the camera centers that joined, so targets that share one center (a pure-rotation rig) and no anchor come back with a 0.0 or NaN scale and a success status.
+             * @description Return the generated frames as posed RGBD: they are reconstructed together so the depth lands in the request's own camera frame and scale, and every entry in `frames` then carries a `depth` buffer. The contextFrames' own depth is not reconstructed or returned, and source photographs get no depth back. Needs 2 to 256 target cameras. Limitation: the depth scale is recovered from the camera centers that joined, so targets that share one center (a pure-rotation rig) and nothing else anchoring them come back with a 0.0 or NaN scale and a success status.
              * @default false
              */
             returnDepth?: boolean;
@@ -701,7 +743,7 @@ export interface components {
             promptUsed?: string | null;
             /**
              * Requestid
-             * @description Meridian request id from servable runtime metadata.
+             * @description Generation request ID for troubleshooting.
              */
             requestId?: string | null;
         };
@@ -758,18 +800,18 @@ export interface components {
         };
         /**
          * AtlasGenerateModelParameters
-         * @description Model-specific parameters forwarded to the atlasGenerate servable.
+         * @description Sampling controls for atlasGenerate.
          */
         AtlasGenerateModelParameters: {
             /**
              * Seed
-             * @description RNG seed forwarded to the servable when set.
+             * @description Random seed for image generation.
              * @default 42
              */
             seed?: number | null;
             /**
              * Numsteps
-             * @description Diffusion step-count override.
+             * @description Number of denoising steps. Omit to use the model's default.
              */
             numSteps?: number | null;
         };
@@ -796,12 +838,12 @@ export interface components {
             base64Outputs?: boolean;
             /**
              * Contextframes
-             * @description Posed RGBD context views: each an image, its depth buffer, and its camera, all required. All context cameras must declare the same width and height. On the reference-context warp route the depth conditions the generation geometrically, so the generated views stay consistent with the provided scene; the hero base checkpoint conditions on the posed images only and does not consume the depth.
+             * @description Posed RGBD context views: each an image, its depth buffer, and its camera, all required. All context cameras must declare the same width and height. Context depth is required and supplies sparse depth references for generation.
              */
             contextFrames: components["schemas"]["PosedRGBDAsset"][];
             /**
              * Targetcameras
-             * @description Pinhole cameras for the views to generate, in output order. Generated frames are returned in `frames`, one per camera.
+             * @description Pinhole cameras for the views to generate, in output order. Generated frames are returned in `frames`, one per camera. All cameras share one size (width x height): 1280x720, 960x720, 528x704, or 720x1280.
              */
             targetCameras: components["schemas"]["PinholeCamera"][];
             /**
@@ -811,13 +853,13 @@ export interface components {
             prompt?: string | null;
             /**
              * Enhanceprompt
-             * @description Enhance the prompt with the ViewGen preset before inference. With no prompt, the enhancer captions the context images.
+             * @description Expand the prompt into a scene description before generation. With no prompt, describe the context images. Set false to use your wording unchanged.
              * @default true
              */
             enhancePrompt?: boolean;
             /**
              * Returndepth
-             * @description Return the generated frames as posed RGBD: they are reconstructed together with the context frames so the depth lands in the request's own camera frame and scale, and every entry in `frames` then carries a `depth` buffer. The scale is recovered from camera centres, so a request whose cameras all share one centre (a pure-rotation rig) is rejected. On the hero base route, with more than 19 context frames, or with a masked context frame, a context frame joins the reconstruction only when its image is at the generated resolution and its camera's principal point is centered.
+             * @description Return the generated frames as posed RGBD: they are reconstructed together with the context frames so the depth lands in the request's own camera frame and scale, and every entry in `frames` then carries a `depth` buffer. The scale is recovered from camera centres, so a request whose cameras all share one centre (a pure-rotation rig) is rejected. The context frames anchor the reconstruction, so they must have the targets' aspect ratio and every target camera's principal point must be within 5% of the image centre, or the request is rejected, and a context frame helps reconstruct depth only when its camera's principal point is centered.
              * @default false
              */
             returnDepth?: boolean;
@@ -841,7 +883,7 @@ export interface components {
             promptUsed?: string | null;
             /**
              * Requestid
-             * @description Meridian request id from servable runtime metadata.
+             * @description Generation request ID for troubleshooting.
              */
             requestId?: string | null;
         };
@@ -898,12 +940,12 @@ export interface components {
         };
         /**
          * AtlasMaskedModelParameters
-         * @description Model-specific parameters forwarded to the atlasMasked servable.
+         * @description Sampling controls for atlasMasked.
          */
         AtlasMaskedModelParameters: {
             /**
              * Seed
-             * @description RNG seed forwarded to the servable when set.
+             * @description Random seed for image generation.
              * @default 42
              */
             seed?: number | null;
@@ -936,7 +978,7 @@ export interface components {
             contextFrames: components["schemas"]["PosedRGBAAsset"][];
             /**
              * Targetcameras
-             * @description Pinhole cameras for the views to generate, one per context frame in the same order. Warning: the partial checkpoints condition target i on contextFrames[i]'s masked view and were trained with one context view per target, rendered from the target's own viewpoint. A count that differs from contextFrames, or a target off its frame's camera, is accepted but runs outside the training distribution and may generate degraded views.
+             * @description Pinhole cameras for the views to generate, one per context frame in the same order. For best results, targetCameras[i] should match the camera in contextFrames[i]. Different counts or cameras that do not match their context views are accepted, but may produce lower-quality results.
              */
             targetCameras: components["schemas"]["PinholeCamera"][];
             /**
@@ -976,7 +1018,7 @@ export interface components {
             promptUsed?: string | null;
             /**
              * Requestid
-             * @description Meridian request id from servable runtime metadata.
+             * @description Generation request ID for troubleshooting.
              */
             requestId?: string | null;
         };
@@ -1096,9 +1138,14 @@ export interface components {
             frames: components["schemas"]["FrameRGBAsset"][];
             /**
              * Promptused
-             * @description Final prompt supplied to inference, if any.
+             * @description Final prompt for the first output image, if any. See promptsUsed for all images.
              */
             promptUsed?: string | null;
+            /**
+             * Promptsused
+             * @description Final prompts in the same order as frames. Empty for older results.
+             */
+            promptsUsed?: string[];
             /**
              * Aspectratio
              * @description Resolved width-to-height ratio used for generation.
@@ -1582,11 +1629,7 @@ export interface components {
             canonicalizeToFirstFrame?: boolean;
             /**
              * Targetresolution
-             * @description Return the depth, confidence and camera intrinsics on this (width, height) pixel grid. The reconstruction is scaled to cover the requested size and center-cropped to it, so the result is exactly the size asked for and never stretched, and the intrinsics are updated with it -- unprojecting the returned depth with the returned camera gives the same geometry either way. A requested aspect that differs from the reconstruction's costs field of view, since the crop is what makes the size exact, and centroidWorld then describes the cropped view. Omit for the 1280 by 720 default; pass null to take the instance's own default.
-             * @default [
-             *       1280,
-             *       720
-             *     ]
+             * @description Return the depth, confidence and camera intrinsics on this (width, height) pixel grid: one of 1280 by 720, 720 by 1280, 960 by 720 or 528 by 704, the grids the depth model serves. The reconstruction is scaled to cover the requested size and center-cropped to it, so the result is exactly the size asked for and never stretched, and the intrinsics are updated with it -- unprojecting the returned depth with the returned camera gives the same geometry either way. A requested aspect that differs from the frames' costs field of view, since the crop is what makes the size exact, and centroidWorld then describes the cropped view. Omit it (or pass null) and a multi-view capture with camera translation comes back on whichever of those four grids is closest in aspect to the frames: smaller frames are scaled up onto it, and other aspects (square or 3:2, for example) are center-cropped onto the closest one, with squares going to 960 by 720. A single image or a capture without camera translation comes back on the reconstruction backend's native grid. Set it when a later step needs a particular grid: atlasGenerate, for example, needs context frames with the same aspect as its target cameras.
              */
             targetResolution?: [
                 number,
@@ -1790,6 +1833,40 @@ export interface components {
              */
             zMax: number;
         };
+        /**
+         * MaskedLinearDepthBufferAsset
+         * @description Linear-depth EXR plus an optional mask.
+         */
+        MaskedLinearDepthBufferAsset: {
+            /** @description Optional 8-bit grayscale PNG on the depth grid whose pixel value / 255 is the per-pixel depth confidence in [0, 1], as a URL or inline asset. */
+            confidenceAsset?: components["schemas"]["TaskAsset"] | null;
+            /** @description Optional 8-bit grayscale PNG on the depth grid, as a URL or inline asset: white where the buffer's depth is known, black where it has none. Null when every pixel's depth is known. */
+            maskAsset?: components["schemas"]["TaskAsset"] | null;
+            /** @description EXR of linear depth in world units, as a URL or inline asset. */
+            depthAsset: components["schemas"]["TaskAsset"];
+        };
+        /**
+         * MaskedLogDepthBufferAsset
+         * @description Inverted log-depth PNG plus its decode range and an optional mask.
+         */
+        MaskedLogDepthBufferAsset: {
+            /** @description Optional 8-bit grayscale PNG on the depth grid whose pixel value / 255 is the per-pixel depth confidence in [0, 1], as a URL or inline asset. */
+            confidenceAsset?: components["schemas"]["TaskAsset"] | null;
+            /** @description Optional 8-bit grayscale PNG on the depth grid, as a URL or inline asset: white where the buffer's depth is known, black where it has none. Null when every pixel's depth is known. */
+            maskAsset?: components["schemas"]["TaskAsset"] | null;
+            /** @description Inverted log-depth grayscale PNG, as a URL or inline asset. */
+            logDepthAsset: components["schemas"]["TaskAsset"];
+            /**
+             * Zmin
+             * @description Linear depth in world units encoded as white (1.0).
+             */
+            zMin: number;
+            /**
+             * Zmax
+             * @description Linear depth in world units encoded as black (>0).
+             */
+            zMax: number;
+        };
         /**
          * Operation
          * @description An operation with its result, available through singular reads.
@@ -1907,6 +1984,28 @@ export interface components {
             /** @description The Operation's ``error``, served the same way. */
             error?: components["schemas"]["OperationError"] | null;
         };
+        /**
+         * OrientedBoundingBox
+         * @description A box with its own orientation, given as a pose and half-extents.
+         *
+         *     ``frame`` carries the coordinate system the box is expressed in, so a caller
+         *     does not have to convert into whatever convention the receiver works in.
+         *     ``half_extents`` are measured along the box's own axes after that rotation, so
+         *     an axis-aligned box is one whose quaternion is identity.
+         */
+        OrientedBoundingBox: {
+            /** @description Centre and orientation of the box, with its convention. */
+            frame: components["schemas"]["CoordinateFrame"];
+            /**
+             * Halfextents
+             * @description Half the box's size along each of its own axes, in metres.
+             */
+            halfExtents: [
+                number,
+                number,
+                number
+            ];
+        };
         /**
          * PinholeCamera
          * @description A posed pinhole camera.
@@ -1942,21 +2041,128 @@ export interface components {
             height: number;
         };
         /**
-         * PosedDepthAsset
-         * @description A posed depth-only frame: a depth buffer with its camera.
+         * PosedImages2SplatsRequest
+         * @description Body of ``POST /api/v2/tasks:posedImages2Splats``.
          */
-        PosedDepthAsset: {
-            /** @description Source image as a URL or inline asset, or null (depth-only). */
-            imageAsset?: components["schemas"]["TaskAsset"] | null;
-            /** @description Optional alpha mask as a URL or inline asset: an 8-bit grayscale PNG on the image grid whose pixel value / 255 is the alpha in [0, 1] (1 = kept, 0 = excluded). Null when the frame carries no mask. */
-            maskAsset?: components["schemas"]["TaskAsset"] | null;
-            /** @description Camera-to-world pose and intrinsics. */
-            camera: components["schemas"]["PinholeCamera"];
+        PosedImages2SplatsRequest: {
             /**
-             * Depth
-             * @description Depth buffer aligned to the camera.
+             * Webhookurl
+             * @description Where Marble POSTs one signed task.succeeded or task.failed event when this operation finishes; retried for 24 hours. Verify the signature with the public keys at /.well-known/webhooks/jwks.json. Cannot be combined with ?wait=true. https on port 443 only, no IP literals. Developer API only.
              */
-            depth: components["schemas"]["LogDepthBufferAsset"] | components["schemas"]["LinearDepthBufferAsset"];
+            webhookUrl?: string | null;
+            /**
+             * Purgecontentonoperationcompletion
+             * @description Purge this operation's outputs and the transient uploads it consumed one hour after it finishes. Omitted, the account's setting applies; true raises it for this operation; false is refused when the account already purges. Uploads in the library are never purged by an operation.
+             */
+            purgeContentOnOperationCompletion?: boolean | null;
+            /**
+             * Prompt
+             * @description Optional scene description. Enhancement combines it with the input images; when omitted, enhancement captions the images.
+             */
+            prompt?: string | null;
+            /**
+             * Enhanceprompt
+             * @description Enhance the prompt using the context images before generation. Set false with a prepared prompt to skip enhancement and reduce latency.
+             * @default true
+             */
+            enhancePrompt?: boolean;
+            /**
+             * Refine
+             * @description Run the refiner after drafting: the free-running loop that places cameras, render-difixes them and trains SSO on the draft until its recipe's step count or wall budget, publishing its level under refinedSplats. Off ends the run at the draft pass, fit at 2,000,000 splats by default or at the one targetSplatCounts entry, and published under draftSplat alone. It runs in a fraction of the time and is billed as a draft.
+             * @default true
+             */
+            refine?: boolean;
+            /**
+             * Targetsplatcounts
+             * @description Splat counts to publish. With refine=false, an explicit list must contain exactly one count, the draft's, returned under draftSplat; omitted, the draft is fit at 2,000,000 splats. With refinement the loop's recipe sets the one level it publishes under refinedSplats, and this list is accepted and ignored.
+             */
+            targetSplatCounts?: number[] | null;
+            /**
+             * Regionofinterest
+             * @description Oriented box to focus the reconstruction on, or a list of them for separate areas. Each box should enclose both the geometry of interest and the space it can be viewed from. The rest of the scene is still reconstructed from the frames. Omitted, the task covers the whole capture.
+             */
+            regionOfInterest?: components["schemas"]["OrientedBoundingBox"] | components["schemas"]["OrientedBoundingBox"][] | null;
+            /**
+             * Debug
+             * @description Flag for custom debug behavior. Currently has no effect on the pipeline.
+             * @default false
+             */
+            debug?: boolean;
+            /**
+             * Posedframes
+             * @description Ordered posed RGBD frames (2 to 512): each image an account asset, inline bytes, or a public URL, with its camera and its depth buffer (a linear-depth EXR under depth.depthAsset, as images2PosedRGBD returns). Every camera grid must be 1280x720, 720x1280, 960x720, or 528x704 (width x height), and all frames must use the same grid. RGB images are resampled to the camera grid.
+             */
+            posedFrames: components["schemas"]["PosedRGBDAsset"][];
+        };
+        /**
+         * PosedImages2SplatsResponse
+         * @description Public response projected into the completed Operation.
+         *
+         *     Each splat is a bare TaskAsset, the shape the task requests take
+         *     (splats2Mesh's splatAsset), so a response feeds the next task without
+         *     translation.
+         */
+        PosedImages2SplatsResponse: {
+            /**
+             * Refinedsplats
+             * @description Refined splats (SPZ) keyed by splat count.
+             */
+            refinedSplats?: {
+                [key: string]: components["schemas"]["TaskAsset"];
+            };
+            /** @description The splat (SPZ) the run ends on when refine=false: the draft pass's, fit at the requested count (2,000,000 by default). Null when the refiner ran; its levels are under refinedSplats. */
+            draftSplat?: components["schemas"]["TaskAsset"] | null;
+        };
+        /**
+         * PosedImages2SplatsResponseOperation
+         * @description Long-running operation whose successful terminal ``response`` has type ``PosedImages2SplatsResponse``. This is the common Operation envelope with a task-specific response type, not a separate operation resource.
+         */
+        PosedImages2SplatsResponseOperation: {
+            /**
+             * Id
+             * @description Short operation id used in ``/operations/{operation}`` paths.
+             */
+            id: string;
+            /**
+             * Ownerid
+             * @description Account that owns the operation.
+             */
+            ownerId: string;
+            /**
+             * Metadata
+             * @description Task information and optional progress details. Use ``metadata.task`` to interpret a generic operation response, and use ``done`` to determine completion.
+             */
+            metadata?: {
+                [key: string]: unknown;
+            } | null;
+            /**
+             * Done
+             * @description Whether the operation is terminal. When true, a non-null ``error`` indicates failure; otherwise the operation succeeded.
+             */
+            done: boolean;
+            /** @description Failure details when ``done`` is true and the task failed; null while running and after success. */
+            error?: components["schemas"]["OperationError"] | null;
+            /**
+             * Expiresatsecs
+             * @description Task execution deadline as Unix seconds, when one is exposed. This is not an asset URL expiration.
+             */
+            expiresAtSecs?: number | null;
+            /**
+             * Createdatsecs
+             * @description Unix seconds when the operation was accepted.
+             */
+            createdAtSecs?: number | null;
+            /** @description ``PosedImages2SplatsResponse`` result when ``done`` is true and the task succeeded; null while running and after failure. */
+            response?: components["schemas"]["PosedImages2SplatsResponse"] | null;
+            /**
+             * Name
+             * @description Full resource name for the operation.
+             *
+             *     For project operations:
+             *     ``accounts/{account}/projects/{project}/operations/{operation}``.
+             *     Operation paths accept the short ``id``.
+             */
+            readonly name: string;
         };
         /**
          * PosedRGBAAsset
@@ -2459,6 +2665,7 @@ export type AssetPart = components['schemas']['AssetPart'];
 export type AssetPartDeclaration = components['schemas']['AssetPartDeclaration'];
 export type AssetProducer = components['schemas']['AssetProducer'];
 export type AssetState = components['schemas']['AssetState'];
+export type AtlasChiselContextFrameAsset = components['schemas']['AtlasChiselContextFrameAsset'];
 export type AtlasChiselModelParameters = components['schemas']['AtlasChiselModelParameters'];
 export type AtlasChiselRequest = components['schemas']['AtlasChiselRequest'];
 export type AtlasChiselResponse = components['schemas']['AtlasChiselResponse'];
@@ -2500,13 +2707,18 @@ export type ListAssetsResponse = components['schemas']['ListAssetsResponse'];
 export type ListedOperation = components['schemas']['ListedOperation'];
 export type ListedOperationsResponse = components['schemas']['ListedOperationsResponse'];
 export type LogDepthBufferAsset = components['schemas']['LogDepthBufferAsset'];
+export type MaskedLinearDepthBufferAsset = components['schemas']['MaskedLinearDepthBufferAsset'];
+export type MaskedLogDepthBufferAsset = components['schemas']['MaskedLogDepthBufferAsset'];
 export type Operation = components['schemas']['Operation'];
 export type OperationError = components['schemas']['OperationError'];
 export type OperationStatus = components['schemas']['OperationStatus'];
 export type OperationTrace = components['schemas']['OperationTrace'];
+export type OrientedBoundingBox = components['schemas']['OrientedBoundingBox'];
 export type PinholeCamera = components['schemas']['PinholeCamera'];
 export type PinholeCameraIntrinsics = components['schemas']['PinholeCameraIntrinsics'];
-export type PosedDepthAsset = components['schemas']['PosedDepthAsset'];
+export type PosedImages2SplatsRequest = components['schemas']['PosedImages2SplatsRequest'];
+export type PosedImages2SplatsResponse = components['schemas']['PosedImages2SplatsResponse'];
+export type PosedImages2SplatsResponseOperation = components['schemas']['PosedImages2SplatsResponseOperation'];
 export type PosedRGBAAsset = components['schemas']['PosedRGBAAsset'];
 export type PosedRGBAsset = components['schemas']['PosedRGBAsset'];
 export type PosedRGBDAsset = components['schemas']['PosedRGBDAsset'];
@@ -2743,6 +2955,45 @@ export interface operations {
             };
         };
     };
+    submit_posedImages2Splats_api_v2_tasks_posedImages2Splats_post: {
+        parameters: {
+            query?: {
+                /** @description Block for the operation to finish before returning, up to the server wait cap. Returns the Operation either way — done with a response if it finished in time, otherwise still running. */
+                wait?: boolean;
+            };
+            header?: {
+                /** @description Optional idempotency key. */
+                "Idempotency-Key"?: string | null;
+            };
+            path?: never;
+            cookie?: never;
+        };
+        requestBody: {
+            content: {
+                "application/json": components["schemas"]["PosedImages2SplatsRequest"];
+            };
+        };
+        responses: {
+            /** @description Successful Response */
+            201: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["PosedImages2SplatsResponseOperation"];
+                };
+            };
+            /** @description Validation Error */
+            422: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["HTTPValidationError"];
+                };
+            };
+        };
+    };
     submit_splats2Mesh_api_v2_tasks_splats2Mesh_post: {
         parameters: {
             query?: {

package/src/generated/tasks.gen.ts

@@ -13,6 +13,8 @@ import type {
   AtlasTextToImageResponseOperation,
   Images2PosedRGBDRequest,
   Images2PosedRGBDResponseOperation,
+  PosedImages2SplatsRequest,
+  PosedImages2SplatsResponseOperation,
   Splats2MeshRequest,
   Splats2MeshResponseOperation,
 } from "./developer-api.gen.ts";
@@ -94,6 +96,20 @@ export const createTasks = (transport: Transport) => ({
   images2PosedRGBD: async (body: Images2PosedRGBDRequest, options?: SubmitOptions) =>
     await submitTask<Images2PosedRGBDResponseOperation>(transport, "/api/v2/tasks:images2PosedRGBD", body, options),
 
+  /**
+   * Submit the posedImages2Splats task
+   * Retries network failures and HTTP 429/502/503/504 up to three times with the same key and body.
+   *
+   * @param body - Task inputs and settings.
+   * @param options - Abort signal, idempotency key, and server-wait preference.
+   * @returns An operation to pass to `client.operations.wait` for the typed result.
+   * Check the completed operation's `error` before reading its `response`.
+   * @throws {ApiError} If the API rejects the submission or retries are exhausted.
+   * @beta Requires beta access for your account.
+   */
+  posedImages2Splats: async (body: PosedImages2SplatsRequest, options?: SubmitOptions) =>
+    await submitTask<PosedImages2SplatsResponseOperation>(transport, "/api/v2/tasks:posedImages2Splats", body, options),
+
   /**
    * Submit the splats2Mesh task
    * Retries network failures and HTTP 429/502/503/504 up to three times with the same key and body.

package/src/version.ts

@@ -0,0 +1,2 @@
+/** This package's npm version. The release sets it together with `package.json`. */
+export const VERSION = "0.6.0";