@worldlabsai/client 0.1.0

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

@@ -0,0 +1,2760 @@
+/**
+ * This file was auto-generated by openapi-typescript.
+ * Do not make direct changes to the file.
+ */
+
+export interface paths {
+    "/api/v2/health": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        /** Health check */
+        get: operations["api_health_api_v2_health_get"];
+        put?: never;
+        post?: never;
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/api/v2/tasks:atlasChisel": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        get?: never;
+        put?: never;
+        /** Submit a atlasChisel task */
+        post: operations["submit_atlasChisel_api_v2_tasks_atlasChisel_post"];
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/api/v2/tasks:atlasGenerate": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        get?: never;
+        put?: never;
+        /** Submit a atlasGenerate task */
+        post: operations["submit_atlasGenerate_api_v2_tasks_atlasGenerate_post"];
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/api/v2/tasks:atlasMasked": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        get?: never;
+        put?: never;
+        /** Submit a atlasMasked task */
+        post: operations["submit_atlasMasked_api_v2_tasks_atlasMasked_post"];
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/api/v2/tasks:atlasTextToImage": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        get?: never;
+        put?: never;
+        /** Submit a atlasTextToImage task */
+        post: operations["submit_atlasTextToImage_api_v2_tasks_atlasTextToImage_post"];
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/api/v2/tasks:images2PosedRGBD": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        get?: never;
+        put?: never;
+        /** Submit a images2PosedRGBD task */
+        post: operations["submit_images2PosedRGBD_api_v2_tasks_images2PosedRGBD_post"];
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/api/v2/tasks:splats2Mesh": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        get?: never;
+        put?: never;
+        /** Submit a splats2Mesh task */
+        post: operations["submit_splats2Mesh_api_v2_tasks_splats2Mesh_post"];
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/api/v2/operations": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        /** List a project's long-running operations, newest first */
+        get: operations["list_operations_api_v2_operations_get"];
+        put?: never;
+        post?: never;
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/api/v2/operations/{operation}:trace": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        /** Get the public request and response for an operation */
+        get: operations["get_operation_trace_api_v2_operations__operation__trace_get"];
+        put?: never;
+        post?: never;
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/api/v2/operations/{operation}:wait": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        get?: never;
+        put?: never;
+        /** Block until a long-running operation is done */
+        post: operations["wait_operation_api_v2_operations__operation__wait_post"];
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/api/v2/operations/{operation}:cancel": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        get?: never;
+        put?: never;
+        /** Record cancellation intent for a long-running operation */
+        post: operations["cancel_operation_api_v2_operations__operation__cancel_post"];
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/api/v2/operations/{operation}": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        /** Get a long-running operation */
+        get: operations["get_operation_api_v2_operations__operation__get"];
+        put?: never;
+        post?: never;
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/api/v2/assets": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        /** List assets in a project */
+        get: operations["list_assets_api_v2_assets_get"];
+        put?: never;
+        /** Create an asset in a project */
+        post: operations["create_asset_api_v2_assets_post"];
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/api/v2/assets/{asset}": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        /** Get an asset */
+        get: operations["get_asset_api_v2_assets__asset__get"];
+        put?: never;
+        post?: never;
+        /** Delete an asset (soft-delete) */
+        delete: operations["delete_asset_api_v2_assets__asset__delete"];
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/api/v2/assets/{asset}:createUploadUrl": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        get?: never;
+        put?: never;
+        /** Mint a signed upload URL for an asset */
+        post: operations["create_upload_url_api_v2_assets__asset__createUploadUrl_post"];
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/api/v2/assets/{asset}:createReadUrl": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        get?: never;
+        put?: never;
+        /** Mint a signed read URL for an asset */
+        post: operations["create_read_url_api_v2_assets__asset__createReadUrl_post"];
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/api/v2/assets/{asset}:createUploadUrls": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        get?: never;
+        put?: never;
+        /** Re-mint upload URLs for a typed asset's parts */
+        post: operations["create_upload_urls_api_v2_assets__asset__createUploadUrls_post"];
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/api/v2/assets/{asset}:completeUpload": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        get?: never;
+        put?: never;
+        /** Mark an asset upload complete */
+        post: operations["complete_upload_api_v2_assets__asset__completeUpload_post"];
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/api/v2/assets:createReadPrefix": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        get?: never;
+        put?: never;
+        /** Mint a signed read prefix for the key's project library */
+        post: operations["create_read_prefix_api_v2_assets_createReadPrefix_post"];
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+}
+export type webhooks = Record<string, never>;
+export interface components {
+    schemas: {
+        /**
+         * Asset
+         * @description A project-owned media asset.
+         */
+        Asset: {
+            /**
+             * Id
+             * @description Asset id, ``asset_<hex>``.
+             */
+            id: string;
+            /**
+             * Displayname
+             * @description User-visible label.
+             */
+            displayName: string;
+            /**
+             * Mimetype
+             * @description Media MIME type, e.g. ``image/png``.
+             */
+            mimeType: string;
+            /** @default CREATED */
+            state?: components["schemas"]["AssetState"];
+            /**
+             * Width
+             * @description Pixel width when known.
+             */
+            width?: number | null;
+            /**
+             * Height
+             * @description Pixel height when known.
+             */
+            height?: number | null;
+            /**
+             * Sizebytes
+             * @description Size in bytes serialized as a string for large-integer compatibility with JSON consumers.
+             */
+            sizeBytes?: string | null;
+            /**
+             * Checksum
+             * @description Checksum the store reports, e.g. ``crc32c:...``.
+             */
+            checksum?: string | null;
+            /**
+             * Createtime
+             * @description Server-assigned.
+             */
+            createTime?: string | null;
+            /**
+             * Type
+             * @description Asset type, e.g. ``image``. Null for an untyped upload.
+             */
+            type?: string | null;
+            /**
+             * Parts
+             * @description The asset's media files. Empty until the upload completes; an untyped asset then holds one part covering the whole media.
+             */
+            parts?: components["schemas"]["AssetPart"][];
+            /**
+             * Structure
+             * @description What a reader needs besides the bytes.
+             */
+            structure?: {
+                [key: string]: unknown;
+            } | null;
+            /** @description Set when a task produced the asset. */
+            producedBy?: components["schemas"]["ProducedBy"] | null;
+            /**
+             * Contentpath
+             * @description Where the asset's bytes sit under the project's content prefix, ``<class>/<asset>[/<role>]``, each segment percent-encoded as a URL path segment. Appended to a read prefix's ``baseUrl`` and followed by its ``signedQuery`` it addresses the bytes on the content edge; on its own it grants nothing. A read prefix is minted per project by ``:createReadPrefix`` (on the project for web sessions, on ``/assets`` for API keys); ``:createReadUrl`` stays the single-object download. Null until the bytes exist.
+             */
+            contentPath?: string | null;
+        };
+        /**
+         * AssetCreate
+         * @description Client-provided fields for creating a project-owned asset.
+         */
+        AssetCreate: {
+            /**
+             * Displayname
+             * @description User-visible label.
+             */
+            displayName: string;
+            /**
+             * Type
+             * @description Asset type, e.g. ``image``. Decides which part roles the asset may carry and what each may hold. Omit for a single untyped object uploaded through ``:createUploadUrl``.
+             */
+            type?: string | null;
+            /**
+             * Parts
+             * @description The parts to be uploaded. One grant comes back per part.
+             */
+            parts?: components["schemas"]["AssetPartDeclaration"][];
+            /**
+             * Structure
+             * @description What a reader needs besides the bytes, in the shape the asset type defines, e.g. an image's camera.
+             */
+            structure?: {
+                [key: string]: unknown;
+            } | null;
+            /**
+             * Base64
+             * @description Bytes carried in the request, optionally as a ``data:`` URL. The asset comes back ``READY``. Capped at 10 MiB decoded; above that, declare a part and upload to its grant.
+             */
+            base64?: string | null;
+            /**
+             * Url
+             * @description A URL the platform fetches. The asset comes back ``READY``. The address is opened by a sandboxed workload, never by the API.
+             */
+            url?: string | null;
+        };
+        /**
+         * AssetPart
+         * @description One media file belonging to an asset.
+         *
+         *     Every field but the role is what the store and the bytes reported at
+         *     ``:completeUpload``; nothing here is echoed back from the request that
+         *     declared the part.
+         */
+        AssetPart: {
+            /**
+             * Role
+             * @description What the part holds, e.g. ``rgb``.
+             */
+            role: string;
+            /**
+             * Mimetype
+             * @description Media type read off the bytes.
+             */
+            mimeType?: string | null;
+            /**
+             * Width
+             * @description Pixel width when known.
+             */
+            width?: number | null;
+            /**
+             * Height
+             * @description Pixel height when known.
+             */
+            height?: number | null;
+            /**
+             * Sizebytes
+             * @description Size in bytes serialized as a string for large-integer compatibility with JSON consumers.
+             */
+            sizeBytes?: string | null;
+            /**
+             * Checksum
+             * @description Checksum the store reports, e.g. ``crc32c:...``.
+             */
+            checksum?: string | null;
+            /**
+             * Metadata
+             * @description The role's own contract, e.g. a depth encoding.
+             */
+            metadata?: {
+                [key: string]: unknown;
+            } | null;
+            /**
+             * State
+             * @description ``CREATED`` until the bytes arrive.
+             */
+            state: string;
+        };
+        /**
+         * AssetPartDeclaration
+         * @description A part the client intends to upload.
+         *
+         *     The content type and length are signed into the upload URL, so they bound
+         *     what may be sent rather than describing what the asset is.
+         */
+        AssetPartDeclaration: {
+            /** Role */
+            role: string;
+            /** Contenttype */
+            contentType: string;
+            /**
+             * Contentlength
+             * @description Upload size in bytes, serialized on the wire as a string.
+             */
+            contentLength: number;
+            /**
+             * Metadata
+             * @description The role's own contract, e.g. a depth encoding.
+             */
+            metadata?: {
+                [key: string]: unknown;
+            } | null;
+        };
+        /**
+         * AssetState
+         * @enum {string}
+         */
+        AssetState: "CREATED" | "UPLOADING" | "READY" | "DELETED";
+        /**
+         * AtlasChiselModelParameters
+         * @description Model-specific parameters forwarded to the atlasChisel servable.
+         */
+        AtlasChiselModelParameters: {
+            /**
+             * Seed
+             * @description RNG seed forwarded to the servable when set.
+             * @default 42
+             */
+            seed?: number | null;
+            /**
+             * Cfg
+             * @description Classifier-free guidance scale.
+             * @default 2.5
+             */
+            cfg?: number | null;
+            /**
+             * Numsteps
+             * @description Diffusion step count.
+             * @default 50
+             */
+            numSteps?: number | null;
+        };
+        /**
+         * AtlasChiselRequest
+         * @description Body of ``POST /api/v2/tasks:atlasChisel``.
+         */
+        AtlasChiselRequest: {
+            /**
+             * Contextframes
+             * @description Posed depth frames, one per target camera and posed at it, in target order; each camera is 1280x720. Depth only: frames carry no imageAsset, maskAsset, or depth confidenceAsset. Leave empty to generate from the prompt alone.
+             */
+            contextFrames?: components["schemas"]["PosedDepthAsset"][];
+            /**
+             * Targetcameras
+             * @description Pinhole cameras at 1280x720 for the views to generate, in output order, returned in `frames`. At most 32.
+             */
+            targetCameras: components["schemas"]["PinholeCamera"][];
+            /**
+             * Prompt
+             * @description Text prompt describing the scene.
+             */
+            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.
+             * @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.
+             */
+            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.
+             */
+            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. Needs at least two target cameras. Limitation: the depth scale is recovered from the target cameras' centres, so targets that share one centre (a pure-rotation rig) come back with a 0.0 or NaN scale and a success status.
+             * @default false
+             */
+            returnDepth?: boolean;
+        };
+        /**
+         * AtlasChiselResponse
+         * @description Public response projected into the completed Operation.
+         */
+        AtlasChiselResponse: {
+            /**
+             * Frames
+             * @description Generated RGB frames (image + camera), one per target camera in order.
+             */
+            frames?: components["schemas"]["PosedRGBAsset"][] | null;
+            /**
+             * Promptused
+             * @description Final prompt supplied to inference.
+             */
+            promptUsed?: string | null;
+            /**
+             * Requestid
+             * @description Meridian request id from servable runtime metadata.
+             */
+            requestId?: string | null;
+        };
+        /** AtlasChiselResponseOperation */
+        AtlasChiselResponseOperation: {
+            /** Id */
+            id: string;
+            /** Ownerid */
+            ownerId: string;
+            /** Metadata */
+            metadata?: {
+                [key: string]: unknown;
+            } | null;
+            /** Done */
+            done: boolean;
+            error?: components["schemas"]["OperationError"] | null;
+            /** @description Task response payload when the operation is done. */
+            response?: components["schemas"]["AtlasChiselResponse"] | null;
+            /** Expiresatsecs */
+            expiresAtSecs?: number | null;
+            /**
+             * Createdatsecs
+             * @description Unix seconds when the operation was created (output-only).
+             */
+            createdAtSecs?: number | null;
+            /**
+             * Name
+             * @description Canonical resource name ``accounts/{account}/operations/{operation}``.
+             *
+             *     ``owner_id`` is the owning account, so the public name is derived, not
+             *     stored. Output-only: serialized for clients (AIP-style), and harmlessly
+             *     ignored when the LRO client deserializes a service response.
+             */
+            readonly name: string;
+        };
+        /**
+         * AtlasGenerateModelParameters
+         * @description Model-specific parameters forwarded to the atlasGenerate servable.
+         */
+        AtlasGenerateModelParameters: {
+            /**
+             * Seed
+             * @description RNG seed forwarded to the servable when set.
+             * @default 42
+             */
+            seed?: number | null;
+            /**
+             * Cfg
+             * @description Classifier-free guidance scale.
+             * @default 2.5
+             */
+            cfg?: number | null;
+            /**
+             * Numsteps
+             * @description Diffusion step count.
+             * @default 50
+             */
+            numSteps?: number | null;
+        };
+        /**
+         * AtlasGenerateRequest
+         * @description Body of ``POST /api/v2/tasks:atlasGenerate``.
+         */
+        AtlasGenerateRequest: {
+            /**
+             * Contextframes
+             * @description Posed RGBD context views: each an image, its depth buffer, and its camera, all required. 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.
+             */
+            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.
+             */
+            targetCameras: components["schemas"]["PinholeCamera"][];
+            /**
+             * Prompt
+             * @description Text prompt describing the scene, if any.
+             */
+            prompt?: string | null;
+            /**
+             * Enhanceprompt
+             * @description Enhance the prompt with the ViewGen preset before inference. With no prompt, the enhancer captions the context images.
+             * @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. A context frame joins that reconstruction only when its image is at the generated resolution and its camera's principal point is centered. The scale is recovered from the camera centres that joined, so a request whose joined cameras all share one centre (a pure-rotation rig) is rejected.
+             * @default false
+             */
+            returnDepth?: boolean;
+            /** @description Model-specific parameters for atlasGenerate. */
+            modelParameters?: components["schemas"]["AtlasGenerateModelParameters"];
+        };
+        /**
+         * AtlasGenerateResponse
+         * @description Public response projected into the completed Operation.
+         */
+        AtlasGenerateResponse: {
+            /**
+             * Frames
+             * @description Generated RGB frames (image + camera), one per target camera in order. Every frame also carries a `depth` buffer when the request set returnDepth.
+             */
+            frames?: components["schemas"]["PosedRGBAsset"][] | null;
+            /**
+             * Promptused
+             * @description Final prompt supplied to inference, if any.
+             */
+            promptUsed?: string | null;
+            /**
+             * Requestid
+             * @description Meridian request id from servable runtime metadata.
+             */
+            requestId?: string | null;
+        };
+        /** AtlasGenerateResponseOperation */
+        AtlasGenerateResponseOperation: {
+            /** Id */
+            id: string;
+            /** Ownerid */
+            ownerId: string;
+            /** Metadata */
+            metadata?: {
+                [key: string]: unknown;
+            } | null;
+            /** Done */
+            done: boolean;
+            error?: components["schemas"]["OperationError"] | null;
+            /** @description Task response payload when the operation is done. */
+            response?: components["schemas"]["AtlasGenerateResponse"] | null;
+            /** Expiresatsecs */
+            expiresAtSecs?: number | null;
+            /**
+             * Createdatsecs
+             * @description Unix seconds when the operation was created (output-only).
+             */
+            createdAtSecs?: number | null;
+            /**
+             * Name
+             * @description Canonical resource name ``accounts/{account}/operations/{operation}``.
+             *
+             *     ``owner_id`` is the owning account, so the public name is derived, not
+             *     stored. Output-only: serialized for clients (AIP-style), and harmlessly
+             *     ignored when the LRO client deserializes a service response.
+             */
+            readonly name: string;
+        };
+        /**
+         * AtlasMaskedModelParameters
+         * @description Model-specific parameters forwarded to the atlasMasked servable.
+         */
+        AtlasMaskedModelParameters: {
+            /**
+             * Seed
+             * @description RNG seed forwarded to the servable when set.
+             * @default 42
+             */
+            seed?: number | null;
+            /**
+             * Cfg
+             * @description Classifier-free guidance scale.
+             * @default 2.5
+             */
+            cfg?: number | null;
+            /**
+             * Numsteps
+             * @description Diffusion step count.
+             * @default 50
+             */
+            numSteps?: number | null;
+        };
+        /**
+         * AtlasMaskedRequest
+         * @description Body of ``POST /api/v2/tasks:atlasMasked``.
+         */
+        AtlasMaskedRequest: {
+            /**
+             * Contextframes
+             * @description The views to complete, in output order: each an image, its alpha mask, and its camera. The mask is an 8-bit grayscale PNG on the image grid where 1 is kept -- those pixels are the observed image -- and 0 is what the model fills in. Each view is completed at its targetCameras entry of the same index.
+             */
+            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.
+             */
+            targetCameras: components["schemas"]["PinholeCamera"][];
+            /**
+             * Prompt
+             * @description Text prompt describing what belongs in the masked region.
+             */
+            prompt?: string | null;
+            /**
+             * Enhanceprompt
+             * @description Enhance the prompt with the ViewGen preset before inference. Off by default: the observed pixels already describe the scene, so a completion usually wants the prompt it was given.
+             * @default false
+             */
+            enhancePrompt?: boolean;
+            /**
+             * Returndepth
+             * @description Return the completed 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. Needs at least two targetCameras. Limitation: the depth scale is recovered from the frames' camera centres, so views that share one centre (a pure-rotation rig) come back with a 0.0 or NaN scale and a success status.
+             * @default false
+             */
+            returnDepth?: boolean;
+            /** @description Model-specific parameters for atlasMasked. */
+            modelParameters?: components["schemas"]["AtlasMaskedModelParameters"];
+        };
+        /**
+         * AtlasMaskedResponse
+         * @description Public response projected into the completed Operation.
+         */
+        AtlasMaskedResponse: {
+            /**
+             * Frames
+             * @description Generated frames (image + camera): one per target camera, in order. Every frame also carries a `depth` buffer when the request set returnDepth.
+             */
+            frames?: components["schemas"]["PosedRGBAsset"][] | null;
+            /**
+             * Promptused
+             * @description Final prompt supplied to inference, if any.
+             */
+            promptUsed?: string | null;
+            /**
+             * Requestid
+             * @description Meridian request id from servable runtime metadata.
+             */
+            requestId?: string | null;
+        };
+        /** AtlasMaskedResponseOperation */
+        AtlasMaskedResponseOperation: {
+            /** Id */
+            id: string;
+            /** Ownerid */
+            ownerId: string;
+            /** Metadata */
+            metadata?: {
+                [key: string]: unknown;
+            } | null;
+            /** Done */
+            done: boolean;
+            error?: components["schemas"]["OperationError"] | null;
+            /** @description Task response payload when the operation is done. */
+            response?: components["schemas"]["AtlasMaskedResponse"] | null;
+            /** Expiresatsecs */
+            expiresAtSecs?: number | null;
+            /**
+             * Createdatsecs
+             * @description Unix seconds when the operation was created (output-only).
+             */
+            createdAtSecs?: number | null;
+            /**
+             * Name
+             * @description Canonical resource name ``accounts/{account}/operations/{operation}``.
+             *
+             *     ``owner_id`` is the owning account, so the public name is derived, not
+             *     stored. Output-only: serialized for clients (AIP-style), and harmlessly
+             *     ignored when the LRO client deserializes a service response.
+             */
+            readonly name: string;
+        };
+        /**
+         * AtlasTextToImageRequest
+         * @description Body of ``POST /api/v2/tasks:atlasTextToImage``.
+         */
+        AtlasTextToImageRequest: {
+            /**
+             * Prompt
+             * @description Text prompt to generate from.
+             */
+            prompt: string;
+            /**
+             * Aspectratio
+             * @description Output width-to-height ratio. Omit for the model default.
+             */
+            aspectRatio?: ("16:9" | "9:16" | "4:3" | "3:4" | "1:1") | null;
+            /**
+             * Enhanceprompt
+             * @description Whether to enhance the prompt before generation. Defaults to true.
+             * @default true
+             */
+            enhancePrompt?: boolean;
+            /**
+             * Seed
+             * @description Optional RNG seed.
+             */
+            seed?: number | null;
+            /**
+             * Cfg
+             * @description Classifier-free guidance scale.
+             */
+            cfg?: number | null;
+            /**
+             * Numsteps
+             * @description Diffusion step count.
+             */
+            numSteps?: number | null;
+            /**
+             * Numsamples
+             * @description Number of images to generate.
+             */
+            numSamples?: number | null;
+            /**
+             * Returndepth
+             * @description Also return each image as a posed RGBD frame in `frames`: depth is estimated per image (metric, single-view) along with the camera it was estimated under.
+             * @default false
+             */
+            returnDepth?: boolean;
+        };
+        /**
+         * AtlasTextToImageResponse
+         * @description Public response projected into the completed Operation.
+         */
+        AtlasTextToImageResponse: {
+            /**
+             * Generationid
+             * @description Stable id for this generation run.
+             */
+            generationId: string;
+            /**
+             * Imageurls
+             * @description Public URLs of generated PNG images.
+             */
+            imageUrls: string[];
+            /** @description Task outputs using the shared output URL contract. */
+            assetOutput?: components["schemas"]["ImageCollectionAssetOutput"] | null;
+            /**
+             * Enhancedprompt
+             * @description Prompt after enhancement, if any.
+             */
+            enhancedPrompt?: string | null;
+            /**
+             * Prompt
+             * @description Original prompt submitted by the caller.
+             */
+            prompt?: string | null;
+            /**
+             * Modelname
+             * @description Resolved model display name or slug.
+             */
+            modelName?: string | null;
+            /**
+             * Aspectratio
+             * @description Resolved width-to-height ratio used for generation.
+             */
+            aspectRatio?: ("16:9" | "9:16" | "4:3" | "3:4" | "1:1") | null;
+            /**
+             * Frames
+             * @description Only with returnDepth: one posed RGBD frame per image, in imageUrls order, carrying the estimated camera and a `depth` buffer.
+             */
+            frames?: components["schemas"]["PosedRGBAsset"][] | null;
+        };
+        /** AtlasTextToImageResponseOperation */
+        AtlasTextToImageResponseOperation: {
+            /** Id */
+            id: string;
+            /** Ownerid */
+            ownerId: string;
+            /** Metadata */
+            metadata?: {
+                [key: string]: unknown;
+            } | null;
+            /** Done */
+            done: boolean;
+            error?: components["schemas"]["OperationError"] | null;
+            /** @description Task response payload when the operation is done. */
+            response?: components["schemas"]["AtlasTextToImageResponse"] | null;
+            /** Expiresatsecs */
+            expiresAtSecs?: number | null;
+            /**
+             * Createdatsecs
+             * @description Unix seconds when the operation was created (output-only).
+             */
+            createdAtSecs?: number | null;
+            /**
+             * Name
+             * @description Canonical resource name ``accounts/{account}/operations/{operation}``.
+             *
+             *     ``owner_id`` is the owning account, so the public name is derived, not
+             *     stored. Output-only: serialized for clients (AIP-style), and harmlessly
+             *     ignored when the LRO client deserializes a service response.
+             */
+            readonly name: string;
+        };
+        /**
+         * CamerasAutoAnchors
+         * @description Find anchor positions automatically, then render from them.
+         *
+         *     Candidates come from the free space the geometry encloses, and `oriented`
+         *     picks which rule judges one valid. The default when a request names no
+         *     cameras.
+         */
+        CamerasAutoAnchors: {
+            /**
+             * @description discriminator enum property added by openapi-typescript
+             * @enum {string}
+             */
+            strategy: "auto_anchors";
+            /**
+             * Oriented
+             * @description Judge a candidate by whether the surface faces it, which needs splats whose normals are oriented -- usually only true if they were optimized for it. Leave false to judge by enclosure alone, which is safe on any scene.
+             * @default false
+             */
+            oriented?: boolean;
+        };
+        /**
+         * CamerasExteriorSphere
+         * @description Render from a sphere around the splats, looking inward.
+         *
+         *     For anything whose surface can be seen from outside -- an object, a turntable
+         *     capture -- no anchors are needed. Cameras are spread evenly over a sphere
+         *     bounding the splats and aimed at its center. Naming an
+         *     `orientedBoundingBox` sizes that sphere on the splats inside it, which is
+         *     what picks one object out of a larger capture.
+         */
+        CamerasExteriorSphere: {
+            /**
+             * @description discriminator enum property added by openapi-typescript
+             * @enum {string}
+             */
+            strategy: "exterior_sphere";
+        };
+        /**
+         * CamerasManualAnchors
+         * @description Render from explicitly placed anchor positions.
+         *
+         *     A cubemap is rendered at each anchor, and more cameras are sampled around
+         *     it. Anchors belong in open space, with a clear view of the regions that
+         *     matter most.
+         */
+        CamerasManualAnchors: {
+            /**
+             * @description discriminator enum property added by openapi-typescript
+             * @enum {string}
+             */
+            strategy: "manual_anchors";
+            /**
+             * Anchors
+             * @description Anchor positions in Three.js coordinates (+X right, +Y up, -Z forward).
+             */
+            anchors: [
+                number,
+                number,
+                number
+            ][];
+        };
+        /**
+         * CancelOperationRequest
+         * @description Body of ``POST /api/v2/operations/{operation}:cancel``.
+         */
+        CancelOperationRequest: {
+            /**
+             * Reason
+             * @description Optional caller-provided reason for cancellation.
+             */
+            reason?: string | null;
+            /**
+             * Requestid
+             * @description Stable cancellation request id; supply to make retries idempotent. Server generates one if omitted.
+             */
+            requestId?: string | null;
+        };
+        /**
+         * CompleteUploadRequest
+         * @description Body of an ``:completeUpload`` request.
+         */
+        CompleteUploadRequest: {
+            /** Checksum */
+            checksum?: string | null;
+            /** Width */
+            width?: number | null;
+            /** Height */
+            height?: number | null;
+            /** Sizebytes */
+            sizeBytes?: number | null;
+        };
+        /**
+         * CoordinateFrame
+         * @description Pose represented by a position and an XYZW quaternion.
+         *
+         *     ``coordinate_system`` names the axes convention the pose is expressed in:
+         *     ``rub`` (right-up-back, the OpenGL/Three.js convention) or ``rdf``
+         *     (right-down-forward, the OpenCV convention). Both the ``coordinateSystem``
+         *     (camelCase) and ``coordinate_system`` spellings are accepted.
+         */
+        CoordinateFrame: {
+            /** Position */
+            position: [
+                number,
+                number,
+                number
+            ];
+            /** Quaternion */
+            quaternion: [
+                number,
+                number,
+                number,
+                number
+            ];
+            /**
+             * Coordinatesystem
+             * @default rub
+             * @enum {string}
+             */
+            coordinateSystem?: "rub" | "rdf";
+        };
+        /**
+         * CreateAssetRequest
+         * @description Body of a project-owned asset-create request.
+         */
+        CreateAssetRequest: {
+            /**
+             * Assetid
+             * @description Optional client-supplied resource id.
+             */
+            assetId?: string | null;
+            asset: components["schemas"]["AssetCreate"];
+        };
+        /**
+         * CreateAssetResponse
+         * @description The new asset, plus a grant for every part it declared.
+         */
+        CreateAssetResponse: {
+            /**
+             * Id
+             * @description Asset id, ``asset_<hex>``.
+             */
+            id: string;
+            /**
+             * Displayname
+             * @description User-visible label.
+             */
+            displayName: string;
+            /**
+             * Mimetype
+             * @description Media MIME type, e.g. ``image/png``.
+             */
+            mimeType: string;
+            /** @default CREATED */
+            state?: components["schemas"]["AssetState"];
+            /**
+             * Width
+             * @description Pixel width when known.
+             */
+            width?: number | null;
+            /**
+             * Height
+             * @description Pixel height when known.
+             */
+            height?: number | null;
+            /**
+             * Sizebytes
+             * @description Size in bytes serialized as a string for large-integer compatibility with JSON consumers.
+             */
+            sizeBytes?: string | null;
+            /**
+             * Checksum
+             * @description Checksum the store reports, e.g. ``crc32c:...``.
+             */
+            checksum?: string | null;
+            /**
+             * Createtime
+             * @description Server-assigned.
+             */
+            createTime?: string | null;
+            /**
+             * Type
+             * @description Asset type, e.g. ``image``. Null for an untyped upload.
+             */
+            type?: string | null;
+            /**
+             * Parts
+             * @description The asset's media files. Empty until the upload completes; an untyped asset then holds one part covering the whole media.
+             */
+            parts?: components["schemas"]["AssetPart"][];
+            /**
+             * Structure
+             * @description What a reader needs besides the bytes.
+             */
+            structure?: {
+                [key: string]: unknown;
+            } | null;
+            /** @description Set when a task produced the asset. */
+            producedBy?: components["schemas"]["ProducedBy"] | null;
+            /**
+             * Contentpath
+             * @description Where the asset's bytes sit under the project's content prefix, ``<class>/<asset>[/<role>]``, each segment percent-encoded as a URL path segment. Appended to a read prefix's ``baseUrl`` and followed by its ``signedQuery`` it addresses the bytes on the content edge; on its own it grants nothing. A read prefix is minted per project by ``:createReadPrefix`` (on the project for web sessions, on ``/assets`` for API keys); ``:createReadUrl`` stays the single-object download. Null until the bytes exist.
+             */
+            contentPath?: string | null;
+            /** Uploads */
+            uploads?: components["schemas"]["UploadGrant"][];
+        };
+        /**
+         * CreateReadPrefixResponse
+         * @description One credential for a project's whole library on the content edge.
+         *
+         *     A Cloud CDN prefix-signed URL: append an asset's ``contentPath`` to
+         *     ``baseUrl`` and then ``?`` plus ``signedQuery`` to address its bytes.
+         *     The same ``signedQuery`` serves every asset of the project until
+         *     ``expiresAt``; the edge validates it on every request.
+         */
+        CreateReadPrefixResponse: {
+            /**
+             * Baseurl
+             * @description The project's content prefix on the edge, ending in ``/``. Append an asset's ``contentPath`` to address its bytes.
+             */
+            baseUrl: string;
+            /**
+             * Signedquery
+             * @description Query string (without the leading ``?``) authorizing every URL under ``baseUrl``: ``URLPrefix``, ``Expires``, ``KeyName`` and ``Signature`` as Cloud CDN defines them. Knowledge of it grants read access to the project's library until it expires; mint a fresh one rather than persisting this.
+             */
+            signedQuery: string;
+            /**
+             * Expiresat
+             * Format: date-time
+             * @description When the signature stops admitting reads; mint again after.
+             */
+            expiresAt: string;
+        };
+        /** CreateReadUrlResponse */
+        CreateReadUrlResponse: {
+            /**
+             * Readurl
+             * @description Short-lived signed URL for the asset's bytes. Knowledge of the URL grants read access until it expires; mint a fresh one rather than persisting this.
+             */
+            readUrl: string;
+            /**
+             * Expiresat
+             * Format: date-time
+             */
+            expiresAt: string;
+        };
+        /**
+         * CreateUploadUrlRequest
+         * @description Body of an ``:createUploadUrl`` request.
+         *
+         *     ``content_length`` is the wire-format string the API contract requires
+         *     (JSON's large-integer limitation); the validator parses it to an int so
+         *     handlers can pass it to the service layer untouched.
+         */
+        CreateUploadUrlRequest: {
+            /** Contenttype */
+            contentType: string;
+            /**
+             * Contentlength
+             * @description Expected upload size in bytes, serialized on the wire as a string.
+             */
+            contentLength: number;
+        };
+        /**
+         * CreateUploadUrlResponse
+         * @description Upload ticket for a project-owned Asset.
+         */
+        CreateUploadUrlResponse: {
+            /** Uploadurl */
+            uploadUrl: string;
+            /**
+             * Method
+             * @description HTTP verb to use for the upload, e.g. PUT.
+             */
+            method: string;
+            /**
+             * Expiresat
+             * Format: date-time
+             */
+            expiresAt: string;
+            /**
+             * Headers
+             * @description Headers the client MUST include on the upload request.
+             */
+            headers?: {
+                [key: string]: string;
+            };
+        };
+        /**
+         * CreateUploadUrlsRequest
+         * @description Body of a ``:createUploadUrls`` request.
+         */
+        CreateUploadUrlsRequest: {
+            /**
+             * Roles
+             * @description Parts to re-mint. Empty grants every declared part.
+             */
+            roles?: string[];
+        };
+        /** CreateUploadUrlsResponse */
+        CreateUploadUrlsResponse: {
+            /** Uploads */
+            uploads?: components["schemas"]["UploadGrant"][];
+        };
+        /**
+         * Empty
+         * @description Empty response body for endpoints that have no payload.
+         */
+        Empty: Record<string, never>;
+        /**
+         * FrameRGBAsset
+         * @description A frame whose RGB image is always present; camera stays optional.
+         */
+        FrameRGBAsset: {
+            /** @description Source image as a URL or inline asset. */
+            imageAsset: components["schemas"]["TaskAsset"];
+            /** @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 Optional camera-to-world pose and intrinsics. */
+            camera?: components["schemas"]["PinholeCamera"] | null;
+            /**
+             * Depth
+             * @description Optional depth buffer, as an inverted log-depth PNG (logDepthAsset) or a linear-depth EXR (depthAsset).
+             */
+            depth?: components["schemas"]["LogDepthBufferAsset"] | components["schemas"]["LinearDepthBufferAsset"] | null;
+        };
+        /** HTTPValidationError */
+        HTTPValidationError: {
+            /** Detail */
+            detail?: components["schemas"]["ValidationError"][];
+        };
+        /**
+         * ImageCollectionAssetOutput
+         * @description Asset output for tasks that return `files.images.images`.
+         */
+        ImageCollectionAssetOutput: {
+            files: components["schemas"]["ImageCollectionAssetOutputFiles"];
+        };
+        /**
+         * ImageCollectionAssetOutputFiles
+         * @description Asset output files for tasks that return an image collection.
+         */
+        ImageCollectionAssetOutputFiles: {
+            images: components["schemas"]["ImageCollectionFiles"];
+        };
+        /**
+         * ImageCollectionFiles
+         * @description Image family containing the image collection role.
+         */
+        ImageCollectionFiles: {
+            /**
+             * Images
+             * @description Generated image files.
+             */
+            images: string[];
+        };
+        /**
+         * Images2PosedRGBDPerImageResult
+         * @description Per-image reconstruction output.
+         *
+         *     Geometry is the depth EXR: unproject it with ``camera`` to recover the
+         *     camera-space point cloud. ``camera``'s intrinsics describe the depth grid,
+         *     which is whatever grid the backbone reconstructed on, so they are not
+         *     necessarily the intrinsics of ``imageAsset``.
+         */
+        Images2PosedRGBDPerImageResult: {
+            /** @description The source image the depth was estimated from. */
+            imageAsset: components["schemas"]["TaskAsset"];
+            /** @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"];
+            /** @description Linear-depth EXR in world units, aligned to camera, beside a confidence map. Multiple frames carry the calibrated keep-probability ('ultimate'); a single frame carries the backbone's own mask ('model'), the only score one view can support. Unproject the depth with the camera intrinsics to recover camera-space points in Three.js convention. */
+            depth: components["schemas"]["LinearDepthBufferAsset"];
+            /**
+             * Centroidworld
+             * @description Ground-plane pivot formed from the mean finite camera-space point transformed into world space and projected to y=0.
+             */
+            centroidWorld: [
+                number,
+                number,
+                number
+            ];
+        };
+        /**
+         * Images2PosedRGBDRequest
+         * @description Body of ``POST /api/v2/tasks:images2PosedRGBD``.
+         */
+        Images2PosedRGBDRequest: {
+            /**
+             * Frames
+             * @description Ordered image inputs (min 1). A frame that carries a camera, a depth buffer or a mask is rejected rather than quietly ignored: none of them reaches the reconstruction.
+             */
+            frames: components["schemas"]["FrameRGBAsset"][];
+            /**
+             * Canonicalizetofirstframe
+             * @description Place the first camera at the origin facing forward.
+             * @default false
+             */
+            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
+             *     ]
+             */
+            targetResolution?: [
+                number,
+                number
+            ] | null;
+        };
+        /**
+         * Images2PosedRGBDResponse
+         * @description Public response projected into the completed Operation.
+         */
+        Images2PosedRGBDResponse: {
+            /**
+             * Results
+             * @description One result per input image.
+             */
+            results: components["schemas"]["Images2PosedRGBDPerImageResult"][];
+        };
+        /** Images2PosedRGBDResponseOperation */
+        Images2PosedRGBDResponseOperation: {
+            /** Id */
+            id: string;
+            /** Ownerid */
+            ownerId: string;
+            /** Metadata */
+            metadata?: {
+                [key: string]: unknown;
+            } | null;
+            /** Done */
+            done: boolean;
+            error?: components["schemas"]["OperationError"] | null;
+            /** @description Task response payload when the operation is done. */
+            response?: components["schemas"]["Images2PosedRGBDResponse"] | null;
+            /** Expiresatsecs */
+            expiresAtSecs?: number | null;
+            /**
+             * Createdatsecs
+             * @description Unix seconds when the operation was created (output-only).
+             */
+            createdAtSecs?: number | null;
+            /**
+             * Name
+             * @description Canonical resource name ``accounts/{account}/operations/{operation}``.
+             *
+             *     ``owner_id`` is the owning account, so the public name is derived, not
+             *     stored. Output-only: serialized for clients (AIP-style), and harmlessly
+             *     ignored when the LRO client deserializes a service response.
+             */
+            readonly name: string;
+        };
+        /**
+         * LinearDepthBufferAsset
+         * @description Linear-depth EXR (URL or inline asset).
+         */
+        LinearDepthBufferAsset: {
+            /** @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 EXR of linear depth in world units, as a URL or inline asset. */
+            depthAsset: components["schemas"]["TaskAsset"];
+        };
+        /** ListAssetsResponse */
+        ListAssetsResponse: {
+            /** Assets */
+            assets?: components["schemas"]["Asset"][];
+            /**
+             * Nextpagetoken
+             * @default
+             */
+            nextPageToken?: string;
+        };
+        /**
+         * ListOperationsResponse
+         * @description A page of operations, newest first.
+         */
+        ListOperationsResponse: {
+            /** Operations */
+            operations: components["schemas"]["Operation"][];
+            /**
+             * Nextpagetoken
+             * @description Token for the next page; absent when there are no more.
+             */
+            nextPageToken?: string | null;
+        };
+        /**
+         * LogDepthBufferAsset
+         * @description Inverted log-depth PNG (URL or inline asset) plus its decode range.
+         */
+        LogDepthBufferAsset: {
+            /** @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 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;
+        };
+        /**
+         * MeshAssetOutput
+         * @description Asset output for tasks that return `files.meshes.mesh`.
+         */
+        MeshAssetOutput: {
+            files: components["schemas"]["MeshAssetOutputFiles"];
+        };
+        /**
+         * MeshAssetOutputFiles
+         * @description Asset output files for mesh tasks.
+         */
+        MeshAssetOutputFiles: {
+            meshes: components["schemas"]["MeshFiles"];
+        };
+        /**
+         * MeshFiles
+         * @description Mesh family containing the generic mesh role.
+         */
+        MeshFiles: {
+            /**
+             * Mesh
+             * @description Generated mesh files.
+             */
+            mesh: string[];
+        };
+        /**
+         * Operation
+         * @description An asynchronous long-running task operation.
+         */
+        Operation: {
+            /** Id */
+            id: string;
+            /** Ownerid */
+            ownerId: string;
+            /** Metadata */
+            metadata?: {
+                [key: string]: unknown;
+            } | null;
+            /** Done */
+            done: boolean;
+            error?: components["schemas"]["OperationError"] | null;
+            /** Response */
+            response?: {
+                [key: string]: unknown;
+            } | null;
+            /** Expiresatsecs */
+            expiresAtSecs?: number | null;
+            /**
+             * Createdatsecs
+             * @description Unix seconds when the operation was created (output-only).
+             */
+            createdAtSecs?: number | null;
+            /**
+             * Name
+             * @description Canonical resource name ``accounts/{account}/operations/{operation}``.
+             *
+             *     ``owner_id`` is the owning account, so the public name is derived, not
+             *     stored. Output-only: serialized for clients (AIP-style), and harmlessly
+             *     ignored when the LRO client deserializes a service response.
+             */
+            readonly name: string;
+        };
+        /**
+         * OperationError
+         * @description Error payload set on a failed operation.
+         */
+        OperationError: {
+            /**
+             * Code
+             * @description Numeric status code; conventionally a google.rpc.Code value.
+             */
+            code?: number | null;
+            /**
+             * Message
+             * @description Developer-readable error message in English.
+             */
+            message?: string | null;
+            /**
+             * Details
+             * @description Structured error details, matching google.rpc.Status.details.
+             */
+            details?: {
+                [key: string]: unknown;
+            }[];
+        };
+        /**
+         * OperationTrace
+         * @description Public request/response data without the internal task record or raw LRO.
+         */
+        OperationTrace: {
+            /** Operationid */
+            operationId: string;
+            /** Taskname */
+            taskName: string;
+            /** Taskversion */
+            taskVersion: string;
+            /** Request */
+            request: {
+                [key: string]: unknown;
+            };
+            /** Response */
+            response?: {
+                [key: string]: unknown;
+            } | null;
+        };
+        /**
+         * PinholeCamera
+         * @description A posed pinhole camera.
+         *
+         *     The axes convention of the pose is carried by
+         *     ``extrinsics.coordinate_system``.
+         */
+        PinholeCamera: {
+            extrinsics: components["schemas"]["CoordinateFrame"];
+            intrinsics: components["schemas"]["PinholeCameraIntrinsics"];
+        };
+        /**
+         * PinholeCameraIntrinsics
+         * @description Pinhole camera intrinsics in pixel coordinates (not normalized).
+         *
+         *     Pixel coordinates have their origin (0, 0) at the top-left corner of the
+         *     image, +x right and +y down, so ``cx``/``cy`` measure from the top-left.
+         *     ``width`` and ``height`` are the image size in pixels the intrinsics
+         *     refer to. This is independent of the pose's ``coordinate_system``.
+         */
+        PinholeCameraIntrinsics: {
+            /** Fx */
+            fx: number;
+            /** Fy */
+            fy: number;
+            /** Cx */
+            cx: number;
+            /** Cy */
+            cy: number;
+            /** Width */
+            width: number;
+            /** Height */
+            height: number;
+        };
+        /**
+         * PosedDepthAsset
+         * @description A posed depth-only frame: a depth buffer with its camera.
+         */
+        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"];
+            /**
+             * Depth
+             * @description Depth buffer aligned to the camera.
+             */
+            depth: components["schemas"]["LogDepthBufferAsset"] | components["schemas"]["LinearDepthBufferAsset"];
+        };
+        /**
+         * PosedRGBAAsset
+         * @description A posed frame carrying both its RGB image and its alpha mask.
+         */
+        PosedRGBAAsset: {
+            /** @description Source image as a URL or inline asset. */
+            imageAsset: components["schemas"]["TaskAsset"];
+            /** @description 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). */
+            maskAsset: components["schemas"]["TaskAsset"];
+            /** @description Camera-to-world pose and intrinsics. */
+            camera: components["schemas"]["PinholeCamera"];
+            /**
+             * Depth
+             * @description Optional depth buffer, as an inverted log-depth PNG (logDepthAsset) or a linear-depth EXR (depthAsset).
+             */
+            depth?: components["schemas"]["LogDepthBufferAsset"] | components["schemas"]["LinearDepthBufferAsset"] | null;
+        };
+        /**
+         * PosedRGBAsset
+         * @description A posed RGB frame: image plus its known camera.
+         */
+        PosedRGBAsset: {
+            /** @description Source image as a URL or inline asset. */
+            imageAsset: components["schemas"]["TaskAsset"];
+            /** @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 Optional depth buffer, as an inverted log-depth PNG (logDepthAsset) or a linear-depth EXR (depthAsset).
+             */
+            depth?: components["schemas"]["LogDepthBufferAsset"] | components["schemas"]["LinearDepthBufferAsset"] | null;
+        };
+        /**
+         * PosedRGBDAsset
+         * @description A posed frame carrying both its RGB image and its depth buffer.
+         */
+        PosedRGBDAsset: {
+            /** @description Source image as a URL or inline asset. */
+            imageAsset: components["schemas"]["TaskAsset"];
+            /** @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.
+             */
+            depth: components["schemas"]["LogDepthBufferAsset"] | components["schemas"]["LinearDepthBufferAsset"];
+        };
+        /**
+         * ProducedBy
+         * @description The task that produced this asset. Absent on an upload or import.
+         */
+        ProducedBy: {
+            /**
+             * Task
+             * @description The task that produced it, e.g. ``image2DraftSplats``.
+             */
+            task?: string | null;
+            /**
+             * Operation
+             * @description The Operation that produced it.
+             */
+            operation?: string | null;
+        };
+        /**
+         * ResourceOrigin
+         * @description Product surface that created a project resource.
+         * @enum {string}
+         */
+        ResourceOrigin: "APPLET" | "DEVELOPER_API";
+        /**
+         * Splats2MeshAdvancedOptions
+         * @description Advanced reconstruction controls for custom mesh generation.
+         */
+        Splats2MeshAdvancedOptions: {
+            /**
+             * Renderhw
+             * @description Height and width of the main views rendered to measure the splat surface and texture it, in pixels.
+             * @default 1024
+             */
+            renderHw?: number;
+            /**
+             * Renderhwsecondary
+             * @description Height and width of the secondary views, in pixels. The anchor strategies sample extra cameras around each anchor and render them here, covering what the main views miss. `exterior_sphere` and a supplied camera list render no secondary views and ignore this.
+             * @default 640
+             */
+            renderHwSecondary?: number;
+            /**
+             * Normalsource
+             * @description Normals orient the implicit surface the mesh is extracted from. `depth` estimates them from the rendered depth; `render` aggregates the splats' own, which assumes each splat's local z axis points along the surface normal.
+             * @default depth
+             * @enum {string}
+             */
+            normalSource?: "depth" | "render";
+            /**
+             * Resolution
+             * @description Resolution of the grid the implicit surface is built on, across the region's longest side. Powers of two only. This sets the finest detail the mesh can carry.
+             * @default 512
+             */
+            resolution?: number;
+            /**
+             * Trimquantile
+             * @description Drop vertices whose sample density falls below this quantile. Reconstruction closes the surface over regions it saw no samples in, and trimming cuts that invented skin back off. 0 keeps every vertex.
+             * @default 0
+             */
+            trimQuantile?: number;
+        };
+        /**
+         * Splats2MeshOrientedBoundingBox
+         * @description Region to extract, as an oriented box in Three.js coordinates.
+         */
+        Splats2MeshOrientedBoundingBox: {
+            /**
+             * Center
+             * @description Center of the region, in world space.
+             */
+            center: [
+                number,
+                number,
+                number
+            ];
+            /**
+             * Orientation
+             * @description Rotation of the region away from the world axes, as an xyzw quaternion.
+             */
+            orientation: [
+                number,
+                number,
+                number,
+                number
+            ];
+            /**
+             * Halfextents
+             * @description Half the region's size along each of its own axes. All three must be positive.
+             */
+            halfExtents: [
+                number,
+                number,
+                number
+            ];
+        };
+        /**
+         * Splats2MeshRequest
+         * @description Body of a splats2Mesh request.
+         */
+        Splats2MeshRequest: {
+            /**
+             * Cameras
+             * @description Cameras the splats are rendered from. The surface is reconstructed from those renders, so geometry no camera sees is not meshed. Name a strategy -- `auto_anchors` (the default) finds viewpoints in the scene's free space, `manual_anchors` takes them from the request, `exterior_sphere` rings the scene from outside for an object or turntable capture -- or pass a list of cameras to render as given, at most 512, sharing one width and height between 64 and 1024 that becomes the render resolution.
+             */
+            cameras?: components["schemas"]["PinholeCamera"][] | (components["schemas"]["CamerasManualAnchors"] | components["schemas"]["CamerasAutoAnchors"] | components["schemas"]["CamerasExteriorSphere"]) | null;
+            /** @description Finer control over how the splats are rendered and how the surface is extracted. Omit for the defaults. */
+            advancedOptions?: components["schemas"]["Splats2MeshAdvancedOptions"] | null;
+            /** @description Region to extract, as an oriented box in Three.js coordinates. Omit to mesh the whole scene. */
+            orientedBoundingBox?: components["schemas"]["Splats2MeshOrientedBoundingBox"] | null;
+            /**
+             * Targetfaces
+             * @description Decimate the extracted mesh to at most this many faces. A target above the extracted count does nothing. Omit to keep every face.
+             */
+            targetFaces?: number | null;
+            /**
+             * Texturemode
+             * @description Mesh appearance: 'image_texture' projects rendered views onto a UV atlas, 'vertex_color' bakes per-vertex colors, and 'none' leaves the mesh untextured.
+             * @default image_texture
+             * @enum {string}
+             */
+            textureMode?: "image_texture" | "vertex_color" | "none";
+            /**
+             * Texturesize
+             * @description Height and width of the texture atlas, in pixels, for `image_texture` mode. One rendered view plus its border has to fit, so this must be at least 2% above the render size in play: the larger render bank under the anchor strategies, `renderHw` under `exterior_sphere`, or the supplied cameras' own size.
+             * @default 4096
+             */
+            textureSize?: number;
+            /** @description The Gaussian splat scene (.spz) to mesh. Inline base64 must carry a `data:` prefix to declare its media type: asset creation otherwise infers the type from the bytes, and the sniffer knows image formats only. */
+            splatAsset: components["schemas"]["TaskAsset"];
+        };
+        /**
+         * Splats2MeshResponse
+         * @description Public response projected into the completed Operation.
+         */
+        Splats2MeshResponse: {
+            /** @description The generated mesh. The GLB is at `files.meshes.mesh`. */
+            assetOutput?: components["schemas"]["MeshAssetOutput"] | null;
+            /**
+             * Anchorpositions
+             * @description Anchor positions the cameras were generated from, in Three.js coordinates. Null when no anchors were used: cameras were supplied directly, or `exterior_sphere` was chosen.
+             */
+            anchorPositions?: [
+                number,
+                number,
+                number
+            ][] | null;
+            /**
+             * Metadata
+             * @deprecated
+             * @description Deprecated runtime diagnostics. Informational only -- keys are not part of the contract and may change.
+             */
+            metadata?: {
+                [key: string]: string;
+            };
+        };
+        /** Splats2MeshResponseOperation */
+        Splats2MeshResponseOperation: {
+            /** Id */
+            id: string;
+            /** Ownerid */
+            ownerId: string;
+            /** Metadata */
+            metadata?: {
+                [key: string]: unknown;
+            } | null;
+            /** Done */
+            done: boolean;
+            error?: components["schemas"]["OperationError"] | null;
+            /** @description Task response payload when the operation is done. */
+            response?: components["schemas"]["Splats2MeshResponse"] | null;
+            /** Expiresatsecs */
+            expiresAtSecs?: number | null;
+            /**
+             * Createdatsecs
+             * @description Unix seconds when the operation was created (output-only).
+             */
+            createdAtSecs?: number | null;
+            /**
+             * Name
+             * @description Canonical resource name ``accounts/{account}/operations/{operation}``.
+             *
+             *     ``owner_id`` is the owning account, so the public name is derived, not
+             *     stored. Output-only: serialized for clients (AIP-style), and harmlessly
+             *     ignored when the LRO client deserializes a service response.
+             */
+            readonly name: string;
+        };
+        /**
+         * TaskAsset
+         * @description Media input supplied by asset id, inline base64, or public URL.
+         */
+        TaskAsset: {
+            /**
+             * Assetid
+             * @description Account-owned asset id, e.g. `asset_...`.
+             */
+            assetId?: string | null;
+            /**
+             * Base64
+             * @description Base64-encoded media bytes, with or without a data URL prefix. Decoded size must be less than 10 MiB.
+             */
+            base64?: string | null;
+            /**
+             * Url
+             * @description Public HTTP(S) URL containing the media.
+             */
+            url?: string | null;
+        };
+        /**
+         * UploadGrant
+         * @description Permission to upload one part's bytes, straight to the store.
+         */
+        UploadGrant: {
+            /** Role */
+            role: string;
+            /**
+             * Method
+             * @description HTTP verb to use for the upload, e.g. PUT.
+             */
+            method: string;
+            /** Url */
+            url: string;
+            /**
+             * Headers
+             * @description Headers the client MUST include on the upload request.
+             */
+            headers?: {
+                [key: string]: string;
+            };
+            /**
+             * Expiresat
+             * Format: date-time
+             */
+            expiresAt: string;
+        };
+        /** ValidationError */
+        ValidationError: {
+            /** Location */
+            loc: (string | number)[];
+            /** Message */
+            msg: string;
+            /** Error Type */
+            type: string;
+            /** Input */
+            input?: unknown;
+            /** Context */
+            ctx?: Record<string, never>;
+        };
+        /**
+         * WaitOperationRequest
+         * @description Body of ``POST /api/v2/operations/{operation}:wait``.
+         */
+        WaitOperationRequest: {
+            /**
+             * Timeoutsecs
+             * @description Seconds to block waiting for the operation to finish, capped server-side at 30; omit to use the cap. Best-effort: the operation may still be running when this returns.
+             */
+            timeoutSecs?: number | null;
+        };
+    };
+    responses: never;
+    parameters: never;
+    requestBodies: never;
+    headers: never;
+    pathItems: never;
+}
+export type Asset = components['schemas']['Asset'];
+export type AssetCreate = components['schemas']['AssetCreate'];
+export type AssetPart = components['schemas']['AssetPart'];
+export type AssetPartDeclaration = components['schemas']['AssetPartDeclaration'];
+export type AssetState = components['schemas']['AssetState'];
+export type AtlasChiselModelParameters = components['schemas']['AtlasChiselModelParameters'];
+export type AtlasChiselRequest = components['schemas']['AtlasChiselRequest'];
+export type AtlasChiselResponse = components['schemas']['AtlasChiselResponse'];
+export type AtlasChiselResponseOperation = components['schemas']['AtlasChiselResponseOperation'];
+export type AtlasGenerateModelParameters = components['schemas']['AtlasGenerateModelParameters'];
+export type AtlasGenerateRequest = components['schemas']['AtlasGenerateRequest'];
+export type AtlasGenerateResponse = components['schemas']['AtlasGenerateResponse'];
+export type AtlasGenerateResponseOperation = components['schemas']['AtlasGenerateResponseOperation'];
+export type AtlasMaskedModelParameters = components['schemas']['AtlasMaskedModelParameters'];
+export type AtlasMaskedRequest = components['schemas']['AtlasMaskedRequest'];
+export type AtlasMaskedResponse = components['schemas']['AtlasMaskedResponse'];
+export type AtlasMaskedResponseOperation = components['schemas']['AtlasMaskedResponseOperation'];
+export type AtlasTextToImageRequest = components['schemas']['AtlasTextToImageRequest'];
+export type AtlasTextToImageResponse = components['schemas']['AtlasTextToImageResponse'];
+export type AtlasTextToImageResponseOperation = components['schemas']['AtlasTextToImageResponseOperation'];
+export type CamerasAutoAnchors = components['schemas']['CamerasAutoAnchors'];
+export type CamerasExteriorSphere = components['schemas']['CamerasExteriorSphere'];
+export type CamerasManualAnchors = components['schemas']['CamerasManualAnchors'];
+export type CancelOperationRequest = components['schemas']['CancelOperationRequest'];
+export type CompleteUploadRequest = components['schemas']['CompleteUploadRequest'];
+export type CoordinateFrame = components['schemas']['CoordinateFrame'];
+export type CreateAssetRequest = components['schemas']['CreateAssetRequest'];
+export type CreateAssetResponse = components['schemas']['CreateAssetResponse'];
+export type CreateReadPrefixResponse = components['schemas']['CreateReadPrefixResponse'];
+export type CreateReadUrlResponse = components['schemas']['CreateReadUrlResponse'];
+export type CreateUploadUrlRequest = components['schemas']['CreateUploadUrlRequest'];
+export type CreateUploadUrlResponse = components['schemas']['CreateUploadUrlResponse'];
+export type CreateUploadUrlsRequest = components['schemas']['CreateUploadUrlsRequest'];
+export type CreateUploadUrlsResponse = components['schemas']['CreateUploadUrlsResponse'];
+export type Empty = components['schemas']['Empty'];
+export type FrameRGBAsset = components['schemas']['FrameRGBAsset'];
+export type HTTPValidationError = components['schemas']['HTTPValidationError'];
+export type ImageCollectionAssetOutput = components['schemas']['ImageCollectionAssetOutput'];
+export type ImageCollectionAssetOutputFiles = components['schemas']['ImageCollectionAssetOutputFiles'];
+export type ImageCollectionFiles = components['schemas']['ImageCollectionFiles'];
+export type Images2PosedRGBDPerImageResult = components['schemas']['Images2PosedRGBDPerImageResult'];
+export type Images2PosedRGBDRequest = components['schemas']['Images2PosedRGBDRequest'];
+export type Images2PosedRGBDResponse = components['schemas']['Images2PosedRGBDResponse'];
+export type Images2PosedRGBDResponseOperation = components['schemas']['Images2PosedRGBDResponseOperation'];
+export type LinearDepthBufferAsset = components['schemas']['LinearDepthBufferAsset'];
+export type ListAssetsResponse = components['schemas']['ListAssetsResponse'];
+export type ListOperationsResponse = components['schemas']['ListOperationsResponse'];
+export type LogDepthBufferAsset = components['schemas']['LogDepthBufferAsset'];
+export type MeshAssetOutput = components['schemas']['MeshAssetOutput'];
+export type MeshAssetOutputFiles = components['schemas']['MeshAssetOutputFiles'];
+export type MeshFiles = components['schemas']['MeshFiles'];
+export type Operation = components['schemas']['Operation'];
+export type OperationError = components['schemas']['OperationError'];
+export type OperationTrace = components['schemas']['OperationTrace'];
+export type PinholeCamera = components['schemas']['PinholeCamera'];
+export type PinholeCameraIntrinsics = components['schemas']['PinholeCameraIntrinsics'];
+export type PosedDepthAsset = components['schemas']['PosedDepthAsset'];
+export type PosedRGBAAsset = components['schemas']['PosedRGBAAsset'];
+export type PosedRGBAsset = components['schemas']['PosedRGBAsset'];
+export type PosedRGBDAsset = components['schemas']['PosedRGBDAsset'];
+export type ProducedBy = components['schemas']['ProducedBy'];
+export type ResourceOrigin = components['schemas']['ResourceOrigin'];
+export type Splats2MeshAdvancedOptions = components['schemas']['Splats2MeshAdvancedOptions'];
+export type Splats2MeshOrientedBoundingBox = components['schemas']['Splats2MeshOrientedBoundingBox'];
+export type Splats2MeshRequest = components['schemas']['Splats2MeshRequest'];
+export type Splats2MeshResponse = components['schemas']['Splats2MeshResponse'];
+export type Splats2MeshResponseOperation = components['schemas']['Splats2MeshResponseOperation'];
+export type TaskAsset = components['schemas']['TaskAsset'];
+export type UploadGrant = components['schemas']['UploadGrant'];
+export type ValidationError = components['schemas']['ValidationError'];
+export type WaitOperationRequest = components['schemas']['WaitOperationRequest'];
+export type $defs = Record<string, never>;
+export interface operations {
+    api_health_api_v2_health_get: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            /** @description Successful Response */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": {
+                        [key: string]: string;
+                    };
+                };
+            };
+        };
+    };
+    submit_atlasChisel_api_v2_tasks_atlasChisel_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"]["AtlasChiselRequest"];
+            };
+        };
+        responses: {
+            /** @description Successful Response */
+            201: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["AtlasChiselResponseOperation"];
+                };
+            };
+            /** @description Validation Error */
+            422: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["HTTPValidationError"];
+                };
+            };
+        };
+    };
+    submit_atlasGenerate_api_v2_tasks_atlasGenerate_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"]["AtlasGenerateRequest"];
+            };
+        };
+        responses: {
+            /** @description Successful Response */
+            201: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["AtlasGenerateResponseOperation"];
+                };
+            };
+            /** @description Validation Error */
+            422: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["HTTPValidationError"];
+                };
+            };
+        };
+    };
+    submit_atlasMasked_api_v2_tasks_atlasMasked_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"]["AtlasMaskedRequest"];
+            };
+        };
+        responses: {
+            /** @description Successful Response */
+            201: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["AtlasMaskedResponseOperation"];
+                };
+            };
+            /** @description Validation Error */
+            422: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["HTTPValidationError"];
+                };
+            };
+        };
+    };
+    submit_atlasTextToImage_api_v2_tasks_atlasTextToImage_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"]["AtlasTextToImageRequest"];
+            };
+        };
+        responses: {
+            /** @description Successful Response */
+            201: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["AtlasTextToImageResponseOperation"];
+                };
+            };
+            /** @description Validation Error */
+            422: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["HTTPValidationError"];
+                };
+            };
+        };
+    };
+    submit_images2PosedRGBD_api_v2_tasks_images2PosedRGBD_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"]["Images2PosedRGBDRequest"];
+            };
+        };
+        responses: {
+            /** @description Successful Response */
+            201: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["Images2PosedRGBDResponseOperation"];
+                };
+            };
+            /** @description Validation Error */
+            422: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["HTTPValidationError"];
+                };
+            };
+        };
+    };
+    submit_splats2Mesh_api_v2_tasks_splats2Mesh_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"]["Splats2MeshRequest"];
+            };
+        };
+        responses: {
+            /** @description Successful Response */
+            201: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["Splats2MeshResponseOperation"];
+                };
+            };
+            /** @description Validation Error */
+            422: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["HTTPValidationError"];
+                };
+            };
+        };
+    };
+    list_operations_api_v2_operations_get: {
+        parameters: {
+            query?: {
+                origin?: components["schemas"]["ResourceOrigin"] | null;
+                pageSize?: number;
+                pageToken?: string | null;
+            };
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            /** @description Successful Response */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["ListOperationsResponse"];
+                };
+            };
+            /** @description Validation Error */
+            422: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["HTTPValidationError"];
+                };
+            };
+        };
+    };
+    get_operation_trace_api_v2_operations__operation__trace_get: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path: {
+                operation: string;
+            };
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            /** @description Successful Response */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["OperationTrace"];
+                };
+            };
+            /** @description Validation Error */
+            422: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["HTTPValidationError"];
+                };
+            };
+        };
+    };
+    wait_operation_api_v2_operations__operation__wait_post: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path: {
+                operation: string;
+            };
+            cookie?: never;
+        };
+        requestBody?: {
+            content: {
+                "application/json": components["schemas"]["WaitOperationRequest"] | null;
+            };
+        };
+        responses: {
+            /** @description Successful Response */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["Operation"];
+                };
+            };
+            /** @description Validation Error */
+            422: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["HTTPValidationError"];
+                };
+            };
+        };
+    };
+    cancel_operation_api_v2_operations__operation__cancel_post: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path: {
+                operation: string;
+            };
+            cookie?: never;
+        };
+        requestBody?: {
+            content: {
+                "application/json": components["schemas"]["CancelOperationRequest"] | null;
+            };
+        };
+        responses: {
+            /** @description Successful Response */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["Operation"];
+                };
+            };
+            /** @description Validation Error */
+            422: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["HTTPValidationError"];
+                };
+            };
+        };
+    };
+    get_operation_api_v2_operations__operation__get: {
+        parameters: {
+            query?: {
+                /** @description Block for the operation to finish before returning, up to the server wait cap. */
+                wait?: boolean;
+            };
+            header?: never;
+            path: {
+                operation: string;
+            };
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            /** @description Successful Response */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["Operation"];
+                };
+            };
+            /** @description Validation Error */
+            422: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["HTTPValidationError"];
+                };
+            };
+        };
+    };
+    list_assets_api_v2_assets_get: {
+        parameters: {
+            query?: {
+                origin?: components["schemas"]["ResourceOrigin"] | null;
+                pageSize?: number;
+                pageToken?: string | null;
+            };
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            /** @description Successful Response */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["ListAssetsResponse"];
+                };
+            };
+            /** @description Validation Error */
+            422: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["HTTPValidationError"];
+                };
+            };
+        };
+    };
+    create_asset_api_v2_assets_post: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        requestBody: {
+            content: {
+                "application/json": components["schemas"]["CreateAssetRequest"];
+            };
+        };
+        responses: {
+            /** @description Successful Response */
+            201: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["CreateAssetResponse"];
+                };
+            };
+            /** @description Validation Error */
+            422: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["HTTPValidationError"];
+                };
+            };
+        };
+    };
+    get_asset_api_v2_assets__asset__get: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path: {
+                asset: string;
+            };
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            /** @description Successful Response */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["Asset"];
+                };
+            };
+            /** @description Validation Error */
+            422: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["HTTPValidationError"];
+                };
+            };
+        };
+    };
+    delete_asset_api_v2_assets__asset__delete: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path: {
+                asset: string;
+            };
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            /** @description Successful Response */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["Empty"];
+                };
+            };
+            /** @description Validation Error */
+            422: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["HTTPValidationError"];
+                };
+            };
+        };
+    };
+    create_upload_url_api_v2_assets__asset__createUploadUrl_post: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path: {
+                asset: string;
+            };
+            cookie?: never;
+        };
+        requestBody: {
+            content: {
+                "application/json": components["schemas"]["CreateUploadUrlRequest"];
+            };
+        };
+        responses: {
+            /** @description Successful Response */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["CreateUploadUrlResponse"];
+                };
+            };
+            /** @description Validation Error */
+            422: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["HTTPValidationError"];
+                };
+            };
+        };
+    };
+    create_read_url_api_v2_assets__asset__createReadUrl_post: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path: {
+                asset: string;
+            };
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            /** @description Successful Response */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["CreateReadUrlResponse"];
+                };
+            };
+            /** @description Validation Error */
+            422: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["HTTPValidationError"];
+                };
+            };
+        };
+    };
+    create_upload_urls_api_v2_assets__asset__createUploadUrls_post: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path: {
+                asset: string;
+            };
+            cookie?: never;
+        };
+        requestBody: {
+            content: {
+                "application/json": components["schemas"]["CreateUploadUrlsRequest"];
+            };
+        };
+        responses: {
+            /** @description Successful Response */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["CreateUploadUrlsResponse"];
+                };
+            };
+            /** @description Validation Error */
+            422: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["HTTPValidationError"];
+                };
+            };
+        };
+    };
+    complete_upload_api_v2_assets__asset__completeUpload_post: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path: {
+                asset: string;
+            };
+            cookie?: never;
+        };
+        requestBody: {
+            content: {
+                "application/json": components["schemas"]["CompleteUploadRequest"];
+            };
+        };
+        responses: {
+            /** @description Successful Response */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["Asset"];
+                };
+            };
+            /** @description Validation Error */
+            422: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["HTTPValidationError"];
+                };
+            };
+        };
+    };
+    create_read_prefix_api_v2_assets_createReadPrefix_post: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            /** @description Successful Response */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["CreateReadPrefixResponse"];
+                };
+            };
+        };
+    };
+}