@uug-ai/models 1.7.16 → 1.7.40

package/dist/types.d.ts

@@ -1758,6 +1758,45 @@ export interface paths {
         patch?: never;
         trace?: never;
     };
+    "/internal/auditauthorizationinfo": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        /**
+         * Get AuditAuthorizationInfo (schema generation only)
+         * @description Internal endpoint used only to ensure AuditAuthorizationInfo schema is generated in OpenAPI spec
+         */
+        get: {
+            parameters: {
+                query?: never;
+                header?: never;
+                path?: never;
+                cookie?: never;
+            };
+            requestBody?: never;
+            responses: {
+                /** @description OK */
+                200: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content: {
+                        "application/json": components["schemas"]["models.AuditAuthorizationInfo"];
+                    };
+                };
+            };
+        };
+        put?: never;
+        post?: never;
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
     "/internal/auditevent": {
         parameters: {
             query?: never;
@@ -1797,6 +1836,45 @@ export interface paths {
         patch?: never;
         trace?: never;
     };
+    "/internal/auditeventstatus": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        /**
+         * Get AuditEventStatus (schema generation only)
+         * @description Internal endpoint used only to ensure AuditEventStatus schema is generated in OpenAPI spec
+         */
+        get: {
+            parameters: {
+                query?: never;
+                header?: never;
+                path?: never;
+                cookie?: never;
+            };
+            requestBody?: never;
+            responses: {
+                /** @description OK */
+                200: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content: {
+                        "application/json": components["schemas"]["models.AuditEventStatus"];
+                    };
+                };
+            };
+        };
+        put?: never;
+        post?: never;
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
     "/internal/auditfieldchange": {
         parameters: {
             query?: never;
@@ -1836,6 +1914,45 @@ export interface paths {
         patch?: never;
         trace?: never;
     };
+    "/internal/auditrequestinfo": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        /**
+         * Get AuditRequestInfo (schema generation only)
+         * @description Internal endpoint used only to ensure AuditRequestInfo schema is generated in OpenAPI spec
+         */
+        get: {
+            parameters: {
+                query?: never;
+                header?: never;
+                path?: never;
+                cookie?: never;
+            };
+            requestBody?: never;
+            responses: {
+                /** @description OK */
+                200: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content: {
+                        "application/json": components["schemas"]["models.AuditRequestInfo"];
+                    };
+                };
+            };
+        };
+        put?: never;
+        post?: never;
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
     "/internal/callerinfo": {
         parameters: {
             query?: never;
@@ -3825,6 +3942,240 @@ export interface paths {
         patch?: never;
         trace?: never;
     };
+    "/internal/createprojecterrorresponse": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        /**
+         * Get CreateProjectErrorResponse (schema generation only)
+         * @description Internal endpoint used only to ensure CreateProjectErrorResponse schema is generated in OpenAPI spec
+         */
+        get: {
+            parameters: {
+                query?: never;
+                header?: never;
+                path?: never;
+                cookie?: never;
+            };
+            requestBody?: never;
+            responses: {
+                /** @description OK */
+                200: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content: {
+                        "application/json": components["schemas"]["api.CreateProjectErrorResponse"];
+                    };
+                };
+            };
+        };
+        put?: never;
+        post?: never;
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/internal/createprojectinput": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        /**
+         * Get CreateProjectInput (schema generation only)
+         * @description Internal endpoint used only to ensure CreateProjectInput schema is generated in OpenAPI spec
+         */
+        get: {
+            parameters: {
+                query?: never;
+                header?: never;
+                path?: never;
+                cookie?: never;
+            };
+            requestBody?: never;
+            responses: {
+                /** @description OK */
+                200: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content: {
+                        "application/json": components["schemas"]["models.CreateProjectInput"];
+                    };
+                };
+            };
+        };
+        put?: never;
+        post?: never;
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/internal/createprojectoutput": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        /**
+         * Get CreateProjectOutput (schema generation only)
+         * @description Internal endpoint used only to ensure CreateProjectOutput schema is generated in OpenAPI spec
+         */
+        get: {
+            parameters: {
+                query?: never;
+                header?: never;
+                path?: never;
+                cookie?: never;
+            };
+            requestBody?: never;
+            responses: {
+                /** @description OK */
+                200: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content: {
+                        "application/json": components["schemas"]["models.CreateProjectOutput"];
+                    };
+                };
+            };
+        };
+        put?: never;
+        post?: never;
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/internal/createprojectrequest": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        /**
+         * Get CreateProjectRequest (schema generation only)
+         * @description Internal endpoint used only to ensure CreateProjectRequest schema is generated in OpenAPI spec
+         */
+        get: {
+            parameters: {
+                query?: never;
+                header?: never;
+                path?: never;
+                cookie?: never;
+            };
+            requestBody?: never;
+            responses: {
+                /** @description OK */
+                200: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content: {
+                        "application/json": components["schemas"]["api.CreateProjectRequest"];
+                    };
+                };
+            };
+        };
+        put?: never;
+        post?: never;
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/internal/createprojectresponse": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        /**
+         * Get CreateProjectResponse (schema generation only)
+         * @description Internal endpoint used only to ensure CreateProjectResponse schema is generated in OpenAPI spec
+         */
+        get: {
+            parameters: {
+                query?: never;
+                header?: never;
+                path?: never;
+                cookie?: never;
+            };
+            requestBody?: never;
+            responses: {
+                /** @description OK */
+                200: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content: {
+                        "application/json": components["schemas"]["api.CreateProjectResponse"];
+                    };
+                };
+            };
+        };
+        put?: never;
+        post?: never;
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/internal/createprojectsuccessresponse": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        /**
+         * Get CreateProjectSuccessResponse (schema generation only)
+         * @description Internal endpoint used only to ensure CreateProjectSuccessResponse schema is generated in OpenAPI spec
+         */
+        get: {
+            parameters: {
+                query?: never;
+                header?: never;
+                path?: never;
+                cookie?: never;
+            };
+            requestBody?: never;
+            responses: {
+                /** @description OK */
+                200: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content: {
+                        "application/json": components["schemas"]["api.CreateProjectSuccessResponse"];
+                    };
+                };
+            };
+        };
+        put?: never;
+        post?: never;
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
     "/internal/createvideowallerrorresponse": {
         parameters: {
             query?: never;
@@ -5073,6 +5424,201 @@ export interface paths {
         patch?: never;
         trace?: never;
     };
+    "/internal/deleteprojecterrorresponse": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        /**
+         * Get DeleteProjectErrorResponse (schema generation only)
+         * @description Internal endpoint used only to ensure DeleteProjectErrorResponse schema is generated in OpenAPI spec
+         */
+        get: {
+            parameters: {
+                query?: never;
+                header?: never;
+                path?: never;
+                cookie?: never;
+            };
+            requestBody?: never;
+            responses: {
+                /** @description OK */
+                200: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content: {
+                        "application/json": components["schemas"]["api.DeleteProjectErrorResponse"];
+                    };
+                };
+            };
+        };
+        put?: never;
+        post?: never;
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/internal/deleteprojectinput": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        /**
+         * Get DeleteProjectInput (schema generation only)
+         * @description Internal endpoint used only to ensure DeleteProjectInput schema is generated in OpenAPI spec
+         */
+        get: {
+            parameters: {
+                query?: never;
+                header?: never;
+                path?: never;
+                cookie?: never;
+            };
+            requestBody?: never;
+            responses: {
+                /** @description OK */
+                200: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content: {
+                        "application/json": components["schemas"]["models.DeleteProjectInput"];
+                    };
+                };
+            };
+        };
+        put?: never;
+        post?: never;
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/internal/deleteprojectoutput": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        /**
+         * Get DeleteProjectOutput (schema generation only)
+         * @description Internal endpoint used only to ensure DeleteProjectOutput schema is generated in OpenAPI spec
+         */
+        get: {
+            parameters: {
+                query?: never;
+                header?: never;
+                path?: never;
+                cookie?: never;
+            };
+            requestBody?: never;
+            responses: {
+                /** @description OK */
+                200: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content: {
+                        "application/json": components["schemas"]["models.DeleteProjectOutput"];
+                    };
+                };
+            };
+        };
+        put?: never;
+        post?: never;
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/internal/deleteprojectresponse": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        /**
+         * Get DeleteProjectResponse (schema generation only)
+         * @description Internal endpoint used only to ensure DeleteProjectResponse schema is generated in OpenAPI spec
+         */
+        get: {
+            parameters: {
+                query?: never;
+                header?: never;
+                path?: never;
+                cookie?: never;
+            };
+            requestBody?: never;
+            responses: {
+                /** @description OK */
+                200: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content: {
+                        "application/json": components["schemas"]["api.DeleteProjectResponse"];
+                    };
+                };
+            };
+        };
+        put?: never;
+        post?: never;
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/internal/deleteprojectsuccessresponse": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        /**
+         * Get DeleteProjectSuccessResponse (schema generation only)
+         * @description Internal endpoint used only to ensure DeleteProjectSuccessResponse schema is generated in OpenAPI spec
+         */
+        get: {
+            parameters: {
+                query?: never;
+                header?: never;
+                path?: never;
+                cookie?: never;
+            };
+            requestBody?: never;
+            responses: {
+                /** @description OK */
+                200: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content: {
+                        "application/json": components["schemas"]["api.DeleteProjectSuccessResponse"];
+                    };
+                };
+            };
+        };
+        put?: never;
+        post?: never;
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
     "/internal/deletestateerrorresponse": {
         parameters: {
             query?: never;
@@ -13029,6 +13575,84 @@ export interface paths {
         patch?: never;
         trace?: never;
     };
+    "/internal/getprojectinput": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        /**
+         * Get GetProjectInput (schema generation only)
+         * @description Internal endpoint used only to ensure GetProjectInput schema is generated in OpenAPI spec
+         */
+        get: {
+            parameters: {
+                query?: never;
+                header?: never;
+                path?: never;
+                cookie?: never;
+            };
+            requestBody?: never;
+            responses: {
+                /** @description OK */
+                200: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content: {
+                        "application/json": components["schemas"]["models.GetProjectInput"];
+                    };
+                };
+            };
+        };
+        put?: never;
+        post?: never;
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/internal/getprojectoutput": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        /**
+         * Get GetProjectOutput (schema generation only)
+         * @description Internal endpoint used only to ensure GetProjectOutput schema is generated in OpenAPI spec
+         */
+        get: {
+            parameters: {
+                query?: never;
+                header?: never;
+                path?: never;
+                cookie?: never;
+            };
+            requestBody?: never;
+            responses: {
+                /** @description OK */
+                200: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content: {
+                        "application/json": components["schemas"]["models.GetProjectOutput"];
+                    };
+                };
+            };
+        };
+        put?: never;
+        post?: never;
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
     "/internal/getprojectresponse": {
         parameters: {
             query?: never;
@@ -20478,6 +21102,45 @@ export interface paths {
         patch?: never;
         trace?: never;
     };
+    "/internal/pipelinesourcedevice": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        /**
+         * Get PipelineSourceDevice (schema generation only)
+         * @description Internal endpoint used only to ensure PipelineSourceDevice schema is generated in OpenAPI spec
+         */
+        get: {
+            parameters: {
+                query?: never;
+                header?: never;
+                path?: never;
+                cookie?: never;
+            };
+            requestBody?: never;
+            responses: {
+                /** @description OK */
+                200: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content: {
+                        "application/json": components["schemas"]["models.PipelineSourceDevice"];
+                    };
+                };
+            };
+        };
+        put?: never;
+        post?: never;
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
     "/internal/plan": {
         parameters: {
             query?: never;
@@ -20790,6 +21453,45 @@ export interface paths {
         patch?: never;
         trace?: never;
     };
+    "/internal/projectupdate": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        /**
+         * Get ProjectUpdate (schema generation only)
+         * @description Internal endpoint used only to ensure ProjectUpdate schema is generated in OpenAPI spec
+         */
+        get: {
+            parameters: {
+                query?: never;
+                header?: never;
+                path?: never;
+                cookie?: never;
+            };
+            requestBody?: never;
+            responses: {
+                /** @description OK */
+                200: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content: {
+                        "application/json": components["schemas"]["models.ProjectUpdate"];
+                    };
+                };
+            };
+        };
+        put?: never;
+        post?: never;
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
     "/internal/publishfileerrorresponse": {
         parameters: {
             query?: never;
@@ -26250,6 +26952,240 @@ export interface paths {
         patch?: never;
         trace?: never;
     };
+    "/internal/updateprojecterrorresponse": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        /**
+         * Get UpdateProjectErrorResponse (schema generation only)
+         * @description Internal endpoint used only to ensure UpdateProjectErrorResponse schema is generated in OpenAPI spec
+         */
+        get: {
+            parameters: {
+                query?: never;
+                header?: never;
+                path?: never;
+                cookie?: never;
+            };
+            requestBody?: never;
+            responses: {
+                /** @description OK */
+                200: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content: {
+                        "application/json": components["schemas"]["api.UpdateProjectErrorResponse"];
+                    };
+                };
+            };
+        };
+        put?: never;
+        post?: never;
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/internal/updateprojectinput": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        /**
+         * Get UpdateProjectInput (schema generation only)
+         * @description Internal endpoint used only to ensure UpdateProjectInput schema is generated in OpenAPI spec
+         */
+        get: {
+            parameters: {
+                query?: never;
+                header?: never;
+                path?: never;
+                cookie?: never;
+            };
+            requestBody?: never;
+            responses: {
+                /** @description OK */
+                200: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content: {
+                        "application/json": components["schemas"]["models.UpdateProjectInput"];
+                    };
+                };
+            };
+        };
+        put?: never;
+        post?: never;
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/internal/updateprojectoutput": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        /**
+         * Get UpdateProjectOutput (schema generation only)
+         * @description Internal endpoint used only to ensure UpdateProjectOutput schema is generated in OpenAPI spec
+         */
+        get: {
+            parameters: {
+                query?: never;
+                header?: never;
+                path?: never;
+                cookie?: never;
+            };
+            requestBody?: never;
+            responses: {
+                /** @description OK */
+                200: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content: {
+                        "application/json": components["schemas"]["models.UpdateProjectOutput"];
+                    };
+                };
+            };
+        };
+        put?: never;
+        post?: never;
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/internal/updateprojectrequest": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        /**
+         * Get UpdateProjectRequest (schema generation only)
+         * @description Internal endpoint used only to ensure UpdateProjectRequest schema is generated in OpenAPI spec
+         */
+        get: {
+            parameters: {
+                query?: never;
+                header?: never;
+                path?: never;
+                cookie?: never;
+            };
+            requestBody?: never;
+            responses: {
+                /** @description OK */
+                200: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content: {
+                        "application/json": components["schemas"]["api.UpdateProjectRequest"];
+                    };
+                };
+            };
+        };
+        put?: never;
+        post?: never;
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/internal/updateprojectresponse": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        /**
+         * Get UpdateProjectResponse (schema generation only)
+         * @description Internal endpoint used only to ensure UpdateProjectResponse schema is generated in OpenAPI spec
+         */
+        get: {
+            parameters: {
+                query?: never;
+                header?: never;
+                path?: never;
+                cookie?: never;
+            };
+            requestBody?: never;
+            responses: {
+                /** @description OK */
+                200: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content: {
+                        "application/json": components["schemas"]["api.UpdateProjectResponse"];
+                    };
+                };
+            };
+        };
+        put?: never;
+        post?: never;
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/internal/updateprojectsuccessresponse": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        /**
+         * Get UpdateProjectSuccessResponse (schema generation only)
+         * @description Internal endpoint used only to ensure UpdateProjectSuccessResponse schema is generated in OpenAPI spec
+         */
+        get: {
+            parameters: {
+                query?: never;
+                header?: never;
+                path?: never;
+                cookie?: never;
+            };
+            requestBody?: never;
+            responses: {
+                /** @description OK */
+                200: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content: {
+                        "application/json": components["schemas"]["api.UpdateProjectSuccessResponse"];
+                    };
+                };
+            };
+        };
+        put?: never;
+        post?: never;
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
     "/internal/updateuserprofileerrorresponse": {
         parameters: {
             query?: never;
@@ -28705,8 +29641,7 @@ export interface components {
             /** @description legacy: read by v20130101 only */
             export_files?: components["schemas"]["models.ExportFile"][];
             export_files_count?: number;
-            /**
-             * @description ExportHeartbeatAgeSeconds is computed at API response time
+            /** @description ExportHeartbeatAgeSeconds is computed at API response time
              *     (NOT persisted — bson:"-") and ships the server-side delta
              *     between now and ExportUpdatedAt so the frontend can render a
              *     "stuck" state without depending on the user's local clock
@@ -28715,46 +29650,39 @@ export interface components {
              *     (legacy / pre-feature tasks); a zero value means the heartbeat
              *     was just written. The FE only interprets this field in
              *     combination with the in-flight signal — see isExportActive
-             *     and getExportUiState for the rule.
-             */
+             *     and getExportUiState for the rule. */
             export_heartbeat_age_seconds?: number;
             export_in_progress?: boolean;
             /** @description "0% -> 100%" */
             export_progress?: number;
             export_requested?: boolean;
             export_revision?: number;
-            /**
-             * @description ExportSelectionDirty signals that the curated bundle composition
+            /** @description ExportSelectionDirty signals that the curated bundle composition
              *     (include_in_export flags on case_media / attachments, or a newly
              *     added media row) changed since the last successful export
              *     completion. Bumped to true by curation toggles and media inserts
              *     in hub-api; cleared by hub-pipeline-export in CompleteExport.
              *     The FE uses this to disable the Regenerate action when no
              *     changes are pending and to surface a "selection changed" hint
-             *     next to the export status badge.
-             */
+             *     next to the export status badge. */
             export_selection_dirty?: boolean;
             /** @description An export task, is containing multiple video in a compressed file format (.zip) */
             export_status?: string;
-            /**
-             * @description ExportUpdatedAt is a heartbeat written by hub-pipeline-export
+            /** @description ExportUpdatedAt is a heartbeat written by hub-pipeline-export
              *     every time it transitions the export state (claim, status
              *     updates, per-file download, release, complete) and by hub-api
              *     when a new export run is requested. It lets the API detect
              *     orphaned runs whose worker died without releasing the lock:
              *     when (now - ExportUpdatedAt) exceeds the staleness threshold,
              *     isExportActive treats the lock as released so the user can
-             *     retry instead of being blocked by a 409 forever.
-             */
+             *     retry instead of being blocked by a 409 forever. */
             export_updated_at?: string;
             id?: string;
             is_private?: boolean;
             labels?: string[];
             legal_hold?: boolean;
-            /**
-             * @description Number of source case_media rows attached to this task. Mirrors
-             *     case_media documents where role == "source" and task_id matches.
-             */
+            /** @description Number of source case_media rows attached to this task. Mirrors
+             *     case_media documents where role == "source" and task_id matches. */
             media_count?: number;
             media_date?: string;
             media_datetime?: string;
@@ -28766,16 +29694,13 @@ export interface components {
             notes_short?: string;
             notify_assignees?: boolean;
             organisationId?: string;
-            /**
-             * @description ProjectId optionally places the case/task in a project within its organisation.
-             *     A nil value keeps it organisation-wide.
-             */
+            /** @description ProjectId optionally places the case/task in a project within its organisation.
+             *     A nil value keeps it organisation-wide. */
             projectId?: string;
             reporter_email?: string;
             reporter_id?: string;
             reporter_profile?: string;
-            /**
-             * @description Retention / lifecycle.
+            /** @description Retention / lifecycle.
              *
              *     RetentionDays captures the *policy intent*: how many days the
              *     case should be kept after its retention anchor (typically the
@@ -28802,8 +29727,7 @@ export interface components {
              *     regardless of ExpiresAt. It is intentionally a separate flag
              *     from the retention date so audits can distinguish "kept longer
              *     because investigator extended" from "kept because under legal
-             *     hold". Managed by a dedicated permission.
-             */
+             *     hold". Managed by a dedicated permission. */
             retention_days?: number;
             sequenceId?: string;
             sprite_url?: string;
@@ -28820,10 +29744,8 @@ export interface components {
             title?: string;
             user_id?: string;
             username?: string;
-            /**
-             * @description This is used for a single export, for a bulk export, we will use the first video as thumbnail and sprite.
-             *     Referencing to some media: video, thumbnail and sprite
-             */
+            /** @description This is used for a single export, for a bulk export, we will use the first video as thumbnail and sprite.
+             *     Referencing to some media: video, thumbnail and sprite */
             video_url?: string;
             videoFile?: string;
             videoProvider?: string;
@@ -28870,6 +29792,7 @@ export interface components {
             caseMediaId?: string;
             file?: string;
             organisationId?: string;
+            projectId?: string;
             provider?: string;
             status?: components["schemas"]["models.CaseMediaStatus"];
             statusError?: string;
@@ -28980,25 +29903,21 @@ export interface components {
             params?: {
                 [key: string]: unknown;
             };
-            /**
-             * @description SourceAttachmentId points at a video CaseAttachment by its id.
+            /** @description SourceAttachmentId points at a video CaseAttachment by its id.
              *     When both SourceCaseMediaId and SourceVideoFile are empty the API
              *     materialises (idempotently — reuses the attachment's linked row
              *     when present) a Role=source CaseMedia from the attachment's stored
              *     video and applies the edit to that row, so an attached video can
-             *     be redacted with the same flow as a device recording.
-             */
+             *     be redacted with the same flow as a device recording. */
             sourceAttachmentId?: string;
             sourceCaseMediaId?: string;
-            /**
-             * @description SourceVideoFile points at a legacy task.export_files entry by its
+            /** @description SourceVideoFile points at a legacy task.export_files entry by its
              *     storage key. When SourceCaseMediaId is empty the API resolves
              *     this key against the task's ExportFiles, lazily creates a
              *     Role=source CaseMedia row for it (idempotent — reuses an
              *     existing row with the same video_file when present), and then
              *     applies the edit to that row. Lets pre-migration cases be
-             *     redacted without requiring a workspace-wide backfill.
-             */
+             *     redacted without requiring a workspace-wide backfill. */
             sourceVideoFile?: string;
             supersedesId?: string;
         };
@@ -29049,6 +29968,37 @@ export interface components {
             /** @description Additional metadata about the response, such as timestamps and request IDs */
             metadata?: components["schemas"]["api.Metadata"];
         };
+        "api.CreateProjectErrorResponse": {
+            /** @description Application-specific error code */
+            applicationStatusCode?: string;
+            /** @description Entity-specific error code */
+            entityStatusCode?: string;
+            /** @description HTTP status code for the error */
+            httpStatusCode?: number;
+            /** @description Error message describing the issue */
+            message?: string;
+            /** @description Additional metadata about the error, such as timestamps and request IDs */
+            metadata?: components["schemas"]["api.Metadata"];
+        };
+        "api.CreateProjectRequest": {
+            project?: components["schemas"]["models.Project"];
+        };
+        "api.CreateProjectResponse": {
+            project?: components["schemas"]["models.Project"];
+        };
+        "api.CreateProjectSuccessResponse": {
+            /** @description Application-specific status code */
+            applicationStatusCode?: string;
+            data?: components["schemas"]["api.CreateProjectResponse"];
+            /** @description Entity-specific status code */
+            entityStatusCode?: string;
+            /** @description HTTP status code for the response */
+            httpStatusCode?: number;
+            /** @description Success message describing the operation */
+            message?: string;
+            /** @description Additional metadata about the response, such as timestamps and request IDs */
+            metadata?: components["schemas"]["api.Metadata"];
+        };
         "api.CreateVideowallErrorResponse": {
             /** @description Application-specific error code */
             applicationStatusCode?: string;
@@ -29115,6 +30065,20 @@ export interface components {
             /** @description Request fields (sent by client) */
             cursor?: string;
             hasMore?: boolean;
+            /** @description IncludeTotal asks the server to also count everything the filter matches,
+             *     not just the page being returned, and report it as Total.
+             *
+             *     It is opt-in because the count is a second query over the whole matched
+             *     set while the page itself stops at Limit, so its cost scales with the
+             *     tenant rather than with the response. Most callers page for display and
+             *     never read Total; making them pay for it is how a cheap list turns into
+             *     an expensive one, and it is why this defaults to off.
+             *
+             *     A caller that omits it gets Total unset rather than zero-as-a-count:
+             *     Total is omitempty, so "not asked for" and "asked for, and the answer is
+             *     nought" are the same wire value. Callers that need to tell the two apart
+             *     must rely on having asked. */
+            includeTotal?: boolean;
             limit?: number;
             /** @description Response fields (returned by server) */
             nextCursor?: string;
@@ -29122,6 +30086,8 @@ export interface components {
             page?: number;
             pageSize?: number;
             prevCursor?: string;
+            /** @description Total is the size of the whole matched set, populated only when the
+             *     request set IncludeTotal. It is not the length of the page. */
             total?: number;
         };
         "api.DebugResponse": {
@@ -29176,10 +30142,8 @@ export interface components {
             metadata?: components["schemas"]["api.Metadata"];
         };
         "api.DeleteCaseAttachmentResponse": {
-            /**
-             * @description Id of the removed attachment, echoed back for client cache
-             *     invalidation.
-             */
+            /** @description Id of the removed attachment, echoed back for client cache
+             *     invalidation. */
             id?: string;
         };
         "api.DeleteCaseAttachmentSuccessResponse": {
@@ -29224,6 +30188,34 @@ export interface components {
             /** @description Additional metadata about the response, such as timestamps and request IDs */
             metadata?: components["schemas"]["api.Metadata"];
         };
+        "api.DeleteProjectErrorResponse": {
+            /** @description Application-specific error code */
+            applicationStatusCode?: string;
+            /** @description Entity-specific error code */
+            entityStatusCode?: string;
+            /** @description HTTP status code for the error */
+            httpStatusCode?: number;
+            /** @description Error message describing the issue */
+            message?: string;
+            /** @description Additional metadata about the error, such as timestamps and request IDs */
+            metadata?: components["schemas"]["api.Metadata"];
+        };
+        "api.DeleteProjectResponse": {
+            project?: components["schemas"]["models.Project"];
+        };
+        "api.DeleteProjectSuccessResponse": {
+            /** @description Application-specific status code */
+            applicationStatusCode?: string;
+            data?: components["schemas"]["api.DeleteProjectResponse"];
+            /** @description Entity-specific status code */
+            entityStatusCode?: string;
+            /** @description HTTP status code for the response */
+            httpStatusCode?: number;
+            /** @description Success message describing the operation */
+            message?: string;
+            /** @description Additional metadata about the response, such as timestamps and request IDs */
+            metadata?: components["schemas"]["api.Metadata"];
+        };
         "api.DeleteStateErrorResponse": {
             /** @description Application-specific error code */
             applicationStatusCode?: string;
@@ -31291,26 +32283,18 @@ export interface components {
             metadata?: components["schemas"]["api.Metadata"];
         };
         "api.IngestRequest": {
-            /**
-             * @description AnalysisId targets the recording via its analysis document _id (an
-             *     ObjectID hex), as an alternative to MediaKey.
-             */
+            /** @description AnalysisId targets the recording via its analysis document _id (an
+             *     ObjectID hex), as an alternative to MediaKey. */
             analysisId?: string;
-            /**
-             * @description MediaKey is the recording KEY the result belongs to — the stable string
+            /** @description MediaKey is the recording KEY the result belongs to — the stable string
              *     stored as media.videoFile / analysis.key (NOT the media document _id).
-             *     Provide this or AnalysisId (MediaKey wins when both are present).
-             */
+             *     Provide this or AnalysisId (MediaKey wins when both are present). */
             mediaKey?: string;
-            /**
-             * @description Operation is the kind selector — the registry key the ingest dispatcher
-             *     routes on (e.g. "detection").
-             */
+            /** @description Operation is the kind selector — the registry key the ingest dispatcher
+             *     routes on (e.g. "detection"). */
             operation?: string;
-            /**
-             * @description Payload is the kind's typed result body, validated and normalised by the
-             *     kind's handler (for "detection" this is a PostDetectionsRequest).
-             */
+            /** @description Payload is the kind's typed result body, validated and normalised by the
+             *     kind's handler (for "detection" this is a PostDetectionsRequest). */
             payload?: number[];
         };
         "api.IngestResponse": {
@@ -31393,6 +32377,7 @@ export interface components {
             name?: string;
             names?: string[];
             sort?: string;
+            timeRanges?: components["schemas"]["models.TimeRange"][];
         };
         "api.MarkerEventFilter": {
             deviceKeys?: string[];
@@ -31537,22 +32522,20 @@ export interface components {
             metadata?: components["schemas"]["api.Metadata"];
         };
         "api.PostDetectionsRequest": {
-            /**
-             * @description AnalysisId targets the recording via its analysis document _id (an
-             *     ObjectID hex), as an alternative to MediaKey.
-             */
+            /** @description AnalysisId targets the recording via its analysis document _id (an
+             *     ObjectID hex), as an alternative to MediaKey. */
             analysisId?: string;
             categories?: components["schemas"]["models.DetectionCategory"][];
             /** @description "pixel" | "normalized" */
             coordinateSpace?: string;
             media?: components["schemas"]["models.DetectionMedia"];
-            /**
-             * @description MediaKey is the recording KEY the run belongs to - the stable string that
+            /** @description MediaKey is the recording KEY the run belongs to - the stable string that
              *     is stored as media.videoFile and analysis.key (NOT the media document's
              *     _id). The server resolves it against analysis.key. Provide this or
-             *     AnalysisId (MediaKey wins when both are present).
-             */
+             *     AnalysisId (MediaKey wins when both are present). */
             mediaKey?: string;
+            /** @description Name is an optional user-facing label for the run. */
+            name?: string;
             schemaVersion?: string;
             source?: components["schemas"]["models.DetectionSource"];
             /** @description Task is an optional run discriminator; defaults to "detection". */
@@ -31596,10 +32579,8 @@ export interface components {
             fileName?: string;
             fileSize?: number;
             provider?: string;
-            /**
-             * @description SignedURL is a vault-signed URL that can be used to fetch the file
-             *     after upload. It carries an HMAC signature and a TTL.
-             */
+            /** @description SignedURL is a vault-signed URL that can be used to fetch the file
+             *     after upload. It carries an HMAC signature and a TTL. */
             signedUrl?: string;
         };
         "api.PublishFileSuccessResponse": {
@@ -31845,14 +32826,13 @@ export interface components {
             faceRedaction?: components["schemas"]["models.FaceRedaction"];
             fileName?: string;
             mode?: components["schemas"]["models.RedactionMode"];
-            /**
-             * @description OrganisationId scopes the redaction job to the owning organisation. It is
+            /** @description OrganisationId scopes the redaction job to the owning organisation. It is
              *     carried on the request struct itself (not only on the transport envelope)
              *     so the worker can resolve the same Request whether the struct arrives on an
              *     on-demand PipelineEvent (event.Payload) or a hub-workflows stage dispatch
-             *     (run.User) — i.e. the request is self-contained and transport agnostic.
-             */
+             *     (run.User) — i.e. the request is self-contained and transport agnostic. */
             organisationId?: string;
+            projectId?: string;
             signedUrl?: string;
             taskId?: string;
         };
@@ -32304,6 +33284,37 @@ export interface components {
             /** @description Additional metadata about the response, such as timestamps and request IDs */
             metadata?: components["schemas"]["api.Metadata"];
         };
+        "api.UpdateProjectErrorResponse": {
+            /** @description Application-specific error code */
+            applicationStatusCode?: string;
+            /** @description Entity-specific error code */
+            entityStatusCode?: string;
+            /** @description HTTP status code for the error */
+            httpStatusCode?: number;
+            /** @description Error message describing the issue */
+            message?: string;
+            /** @description Additional metadata about the error, such as timestamps and request IDs */
+            metadata?: components["schemas"]["api.Metadata"];
+        };
+        "api.UpdateProjectRequest": {
+            project?: components["schemas"]["models.ProjectUpdate"];
+        };
+        "api.UpdateProjectResponse": {
+            project?: components["schemas"]["models.Project"];
+        };
+        "api.UpdateProjectSuccessResponse": {
+            /** @description Application-specific status code */
+            applicationStatusCode?: string;
+            data?: components["schemas"]["api.UpdateProjectResponse"];
+            /** @description Entity-specific status code */
+            entityStatusCode?: string;
+            /** @description HTTP status code for the response */
+            httpStatusCode?: number;
+            /** @description Success message describing the operation */
+            message?: string;
+            /** @description Additional metadata about the response, such as timestamps and request IDs */
+            metadata?: components["schemas"]["api.Metadata"];
+        };
         "api.UpdateUserProfileErrorResponse": {
             /** @description Application-specific error code */
             applicationStatusCode?: string;
@@ -32407,17 +33418,13 @@ export interface components {
             metadata?: components["schemas"]["api.Metadata"];
         };
         "api.UploadCaseAttachmentRequest": {
-            /**
-             * @description Name overrides the filename recorded on the attachment. Defaults
-             *     to the multipart part filename when omitted.
-             */
+            /** @description Name overrides the filename recorded on the attachment. Defaults
+             *     to the multipart part filename when omitted. */
             name?: string;
-            /**
-             * @description RelatedCaseMediaId optionally links the attachment to a specific
+            /** @description RelatedCaseMediaId optionally links the attachment to a specific
              *     case_media entry it documents or annotates (annotated screenshot
              *     of a redacted clip, etc.). Hex ObjectID; must belong to the same
-             *     task.
-             */
+             *     task. */
             relatedCaseMediaId?: string;
         };
         "api.UploadCaseAttachmentResponse": {
@@ -32487,25 +33494,27 @@ export interface components {
             triggerType?: components["schemas"]["models.WorkflowTriggerType"];
         };
         "api.WorkflowRunStatus": {
-            /**
-             * @description Dispatched / Resolved are the sizes of the run's dispatched and resolved
-             *     operation sets, exposed as a coarse progress hint.
-             */
+            /** @description Dispatched / Resolved are the sizes of the run's dispatched and resolved
+             *     operation sets, exposed as a coarse progress hint. */
             dispatched?: number;
+            /** @description DispatchedOperations / ResolvedOperations name the stages behind the
+             *     Dispatched / Resolved counts, in dispatch/resolution order, so a surface
+             *     can render per-stage progress (e.g. "pose done, redaction running")
+             *     instead of only a run-level running/completed flip for multi-stage runs. */
+            dispatchedOperations?: string[];
             end?: number;
             /** @description HasResults is true when the run accumulated any stage output. */
             hasResults?: boolean;
             key?: string;
             origin?: string;
             resolved?: number;
+            resolvedOperations?: string[];
             runId?: string;
             sourceRef?: string;
             /** @description Start / End are unix seconds; End is 0 while the run is still open. */
             start?: number;
-            /**
-             * @description State is the derived lifecycle: running | completed | noResult
-             *     (models.WorkflowRunState).
-             */
+            /** @description State is the derived lifecycle: running | completed | noResult
+             *     (models.WorkflowRunState). */
             state?: string;
             workflowId?: string;
             workflowName?: string;
@@ -32676,10 +33685,8 @@ export interface components {
             in_process?: number;
             key?: string;
             organisationId?: string;
-            /**
-             * @description ProjectId optionally places the analysis in a project within its organisation.
-             *     A nil value keeps the analysis organisation-wide.
-             */
+            /** @description ProjectId optionally places the analysis in a project within its organisation.
+             *     A nil value keeps the analysis organisation-wide. */
             projectId?: string;
             provider?: string;
             requiredOperations?: string[];
@@ -32773,52 +33780,87 @@ export interface components {
         "models.Audit": {
             createdAt?: string;
             createdBy?: string;
-            /**
-             * @description LastAction is a short semantic label describing the most recent change
+            /** @description LastAction is a short semantic label describing the most recent change
              *     (e.g. "role.assigned", "member.suspended", "device.renamed"). For the
-             *     complete history, query AuditEvent by TargetType/TargetId.
-             */
+             *     complete history, query AuditEvent by TargetType/TargetId. */
             lastAction?: string;
             updatedAt?: string;
             updatedBy?: string;
         };
+        "models.AuditAuthorizationInfo": {
+            granted?: boolean;
+            permission?: string;
+            policy?: string;
+            resourceId?: string;
+            resourceType?: string;
+            scope?: string;
+        };
         "models.AuditEvent": {
-            /**
-             * @description Action is a short semantic label, e.g. "case.commented", "device.renamed",
-             *     "member.suspended".
-             */
+            /** @description Action is a short semantic label, e.g. "case.commented", "device.renamed",
+             *     "member.suspended". */
             action?: string;
-            /**
-             * @description ActorId is the user who performed the action; ActorName is denormalised so
-             *     history can be rendered without a lookup.
-             */
+            /** @description ActorId is the user who performed the action; ActorName is denormalised so
+             *     history can be rendered without a lookup. */
             actorId?: string;
             actorName?: string;
+            /** @description ActorType identifies the principal kind, e.g. "user", "apikey" or "system". */
+            actorType?: string;
+            /** @description AuthorizationInfo records the permission decisions actually made for the
+             *     operation. Authentication and trusted system events may leave it empty. */
+            authorizationInfo?: components["schemas"]["models.AuditAuthorizationInfo"][];
+            /** @description Category groups the action by subsystem. */
+            category?: string;
             /** @description Changes optionally captures the field-level diff for this event. */
             changes?: components["schemas"]["models.AuditFieldChange"][];
             id?: string;
-            /** @description Metadata holds contextual key/value pairs (ip, userAgent, requestId, ...). */
+            /** @description Metadata holds additional action-specific context. */
             metadata?: {
                 [key: string]: string;
             };
+            /** @description Operation is the coarse CRUD-style action class. */
+            operation?: string;
             /** @description OrganisationId scopes the event to a tenant for org-wide audit queries. */
             organisationId?: string;
+            /** @description ProjectId optionally narrows the event to a project within the organisation.
+             *     Organisation-wide actions leave it nil. */
+            projectId?: string;
+            /** @description Request contains transport and correlation evidence captured at ingress. */
+            request?: components["schemas"]["models.AuditRequestInfo"];
+            /** @description SchemaVersion identifies the persisted audit event contract. */
+            schemaVersion?: number;
+            /** @description Source identifies the service that produced the event. */
+            source?: string;
+            /** @description Status records the operation result independently of authorization. */
+            status?: components["schemas"]["models.AuditEventStatus"];
             targetId?: string;
-            /**
-             * @description TargetType and TargetId identify the entity the action was performed on
+            targetName?: string;
+            /** @description TargetType and TargetId identify the entity the action was performed on
              *     (e.g. TargetType "case" with the case id). Query these to render an
              *     entity's audit history. TargetId is a string so it can hold either an
-             *     ObjectID hex or a non-ObjectID key (such as a media key).
-             */
+             *     ObjectID hex or a non-ObjectID key (such as a media key). TargetName is the
+             *     denormalised point-in-time label of the target. */
             targetType?: string;
             /** @description Timestamp is when the action occurred. */
             timestamp?: string;
         };
+        "models.AuditEventStatus": {
+            code?: string;
+            outcome?: string;
+        };
         "models.AuditFieldChange": {
             field?: string;
             newValue?: string;
             oldValue?: string;
         };
+        "models.AuditRequestInfo": {
+            correlationId?: string;
+            id?: string;
+            ip?: string;
+            method?: string;
+            path?: string;
+            traceId?: string;
+            userAgent?: string;
+        };
         /** @enum {string} */
         "models.BaseRole": "guest" | "editor" | "admin" | "owner" | "application";
         "models.CameraMetadata": {
@@ -32876,132 +33918,99 @@ export interface components {
         "models.CaseAttachment": {
             createdAt?: number;
             createdBy?: string;
-            /**
-             * @description Storage pointer into Vault (same abstraction as CaseMedia.File /
+            /** @description Storage pointer into Vault (same abstraction as CaseMedia.File /
              *     CaseMedia.Provider). Provider identifies the storage solution;
-             *     File is the object key inside it.
-             */
+             *     File is the object key inside it. */
             file?: string;
             id?: string;
-            /**
-             * @description IncludeInExport and IncludeInShare are per-attachment curation
+            /** @description IncludeInExport and IncludeInShare are per-attachment curation
              *     flags. Same semantics as the namesakes on CaseMedia: defaulted
              *     to true at upload time, toggled via PATCH, consulted by the
              *     export pipeline and the share recipient endpoint, and frozen
              *     into CaseShare.AttachmentSelection at CreateShare time.
              *
              *     BSON tags deliberately omit `,omitempty` so a `false` value is
-             *     persisted faithfully instead of being dropped to the default.
-             */
+             *     persisted faithfully instead of being dropped to the default. */
             includeInExport?: boolean;
             includeInShare?: boolean;
             mimeType?: string;
-            /**
-             * @description Name is the original filename at upload time. Users may rename
+            /** @description Name is the original filename at upload time. Users may rename
              *     the attachment afterwards without renaming the underlying object
-             *     in Vault.
-             */
+             *     in Vault. */
             name?: string;
             organisationId?: string;
-            /**
-             * @description ProjectId optionally places the attachment in a project within its organisation.
-             *     A nil value keeps it organisation-wide.
-             */
+            /** @description ProjectId optionally places the attachment in a project within its organisation.
+             *     A nil value keeps it organisation-wide. */
             projectId?: string;
             provider?: string;
-            /**
-             * @description RelatedCaseMediaId optionally links the attachment to a specific
+            /** @description RelatedCaseMediaId optionally links the attachment to a specific
              *     case_media entry it documents or annotates (for example, an
              *     annotated screenshot of a redacted clip). Nil for free-standing
-             *     case-level attachments.
-             */
+             *     case-level attachments. */
             relatedCaseMediaId?: string;
-            /**
-             * @description Sha256 is the hex-encoded SHA-256 of the uploaded bytes,
+            /** @description Sha256 is the hex-encoded SHA-256 of the uploaded bytes,
              *     computed by hub-api while streaming the upload to Vault. Used
              *     for de-duplication detection and integrity checks on large
-             *     files. Optional — older entries may not have it.
-             */
+             *     files. Optional — older entries may not have it. */
             sha256?: string;
-            /**
-             * @description Size in bytes of the stored object. Useful for UI display and
+            /** @description Size in bytes of the stored object. Useful for UI display and
              *     for sanity-checking that the Vault object still matches what we
-             *     recorded.
-             */
+             *     recorded. */
             size?: number;
-            /**
-             * @description TaskId / OrganisationId scope the row to its parent case and
+            /** @description TaskId / OrganisationId scope the row to its parent case and
              *     tenant. Required on every row in the case_attachments collection
              *     so list/get queries can index on them directly without joining
-             *     against the tasks collection.
-             */
+             *     against the tasks collection. */
             taskId?: string;
-            /**
-             * @description Optional derived preview generated by hub-api on upload (a
+            /** @description Optional derived preview generated by hub-api on upload (a
              *     downscaled JPEG for images, the first page rendered to an image
              *     for PDFs, etc.). Absence is fine — the UI falls back to a
-             *     kind-based icon.
-             */
+             *     kind-based icon. */
             thumbnailFile?: string;
             thumbnailProvider?: string;
             thumbnailUrl?: string;
-            /**
-             * @description Type is a coarse classification of the attachment used by the UI
+            /** @description Type is a coarse classification of the attachment used by the UI
              *     to pick an icon / viewer. MimeType is the source of truth for
-             *     content negotiation; Type is derived from it at upload time.
-             */
+             *     content negotiation; Type is derived from it at upload time. */
             type?: components["schemas"]["models.CaseAttachmentType"];
             updatedAt?: number;
-            /**
-             * @description Url / ThumbnailUrl are signed by hub-api at fetch time and never
+            /** @description Url / ThumbnailUrl are signed by hub-api at fetch time and never
              *     persisted. They should be excluded from list-cases projections
-             *     to keep that endpoint light.
-             */
+             *     to keep that endpoint light. */
             url?: string;
         };
         /** @enum {string} */
         "models.CaseAttachmentType": "pdf" | "image" | "document" | "audio" | "video" | "other";
         "models.CaseMedia": {
-            /**
-             * @description Action describes what the edit does. Only meaningful when
-             *     Role = "edit". See CaseMediaAction.
-             */
+            /** @description Action describes what the edit does. Only meaningful when
+             *     Role = "edit". See CaseMediaAction. */
             action?: components["schemas"]["models.CaseMediaAction"];
-            /**
-             * @description Analysis is a snapshot of the AnalysisWrapper associated with
+            /** @description Analysis is a snapshot of the AnalysisWrapper associated with
              *     the source media at attach time, including the per-operation
              *     lifecycle fields (AsyncOperations / RequiredOperations /
              *     ResolvedOperations) plus the analysis data (classify, counting,
              *     faceRedaction, …) so the detail page and the face-redaction
              *     edit modal can render without an extra lookup against the
-             *     `analysis` collection. Only populated on Role = "source".
-             */
+             *     `analysis` collection. Only populated on Role = "source". */
             analysis?: components["schemas"]["models.AnalysisWrapper"];
-            /**
-             * @description Optional job linkage — back-pointers to the analysis / face
-             *     redaction documents that drove the edit, when applicable.
-             */
+            /** @description Optional job linkage — back-pointers to the analysis / face
+             *     redaction documents that drove the edit, when applicable. */
             analysisId?: string;
             cameraId?: string;
             createdAt?: number;
             createdBy?: string;
-            /**
-             * @description EditType is a sub-variant of Action (for example "face_blur",
+            /** @description EditType is a sub-variant of Action (for example "face_blur",
              *     "face_pixelate", "face_mask" when Action = "redaction"). Display
              *     labels are derived from this in the UI. Canonical values are
-             *     declared as CaseMediaEditType constants below.
-             */
+             *     declared as CaseMediaEditType constants below. */
             editType?: components["schemas"]["models.CaseMediaEditType"];
             endTimestamp?: number;
             faceRedactionId?: string;
-            /**
-             * @description Produced artefact (populated on Role = "edit" once the worker
-             *     completes; for Role = "source" these mirror VideoFile/VideoProvider).
-             */
+            /** @description Produced artefact (populated on Role = "edit" once the worker
+             *     completes; for Role = "source" these mirror VideoFile/VideoProvider). */
             file?: string;
             id?: string;
-            /**
-             * @description IncludeInExport and IncludeInShare are per-row curation flags. A
+            /** @description IncludeInExport and IncludeInShare are per-row curation flags. A
              *     case_media is included in an export bundle / share recipient view
              *     when the corresponding flag is true. Both default to true at
              *     insert time (set explicitly by the create path — the Go zero
@@ -33014,23 +34023,19 @@ export interface components {
              *     from the source they resolve to.
              *
              *     BSON tags deliberately omit `,omitempty` so a `false` value is
-             *     persisted faithfully instead of being dropped to the default.
-             */
+             *     persisted faithfully instead of being dropped to the default. */
             includeInExport?: boolean;
             includeInShare?: boolean;
-            /**
-             * @description Media is a full snapshot of the source Media document captured at
+            /** @description Media is a full snapshot of the source Media document captured at
              *     attach time. It is only populated on Role = "source" and is what
              *     the media-detail page and edit modal consume — the flat fields
              *     above stay in place because they are queried directly by the
              *     export pipeline and the case-level summarisers. The snapshot
              *     makes the case self-contained: edits to or deletions of the
-             *     original media row do not affect what the case shows.
-             */
+             *     original media row do not affect what the case shows. */
             media?: components["schemas"]["models.Media"];
             organisationId?: string;
-            /**
-             * @description OriginAttachmentId marks a Role=source row that was materialised
+            /** @description OriginAttachmentId marks a Role=source row that was materialised
              *     from a video CaseAttachment (see the case_attachments collection)
              *     so a case's attached videos can flow through the same
              *     workflow-run and redaction machinery as device recordings. It
@@ -33038,89 +34043,66 @@ export interface components {
              *     out of the normal media playlist and default to
              *     IncludeInExport=false / IncludeInShare=false at insert time (the
              *     owning attachment carries its own export/share curation). Only
-             *     meaningful on Role = "source".
-             */
+             *     meaningful on Role = "source". */
             originAttachmentId?: string;
-            /**
-             * @description Params carries kind-specific parameters used to produce the edit.
+            /** @description Params carries kind-specific parameters used to produce the edit.
              *     For Action = "composite" it is expected to contain an
              *     "operations" array whose elements have an "op" discriminator
-             *     matching one of the single-op CaseMediaAction values.
-             */
+             *     matching one of the single-op CaseMediaAction values. */
             params?: {
                 [key: string]: unknown;
             };
-            /**
-             * @description ParentId links an edit (Role = "edit") to the case_media entry it
+            /** @description ParentId links an edit (Role = "edit") to the case_media entry it
              *     was produced from. For composite edits the parent is still a single
-             *     source — the individual operations are described in Params.
-             */
+             *     source — the individual operations are described in Params. */
             parentId?: string;
-            /**
-             * @description ProjectId optionally places the case media in a project within its organisation.
-             *     A nil value keeps it organisation-wide.
-             */
+            /** @description ProjectId optionally places the case media in a project within its organisation.
+             *     A nil value keeps it organisation-wide. */
             projectId?: string;
             provider?: string;
-            /**
-             * @description Role describes whether this entry represents a source attached to
-             *     the case or an edit derived from another entry. See CaseMediaRole.
-             */
+            /** @description Role describes whether this entry represents a source attached to
+             *     the case or an edit derived from another entry. See CaseMediaRole. */
             role?: components["schemas"]["models.CaseMediaRole"];
-            /**
-             * @description SelectedVersionId is only meaningful on Role = "source" rows and
+            /** @description SelectedVersionId is only meaningful on Role = "source" rows and
              *     records which version of the source the case should display and
              *     export. When set it points at an Role = "edit" CaseMedia entry
              *     that descends from this source (directly via ParentId or
              *     transitively via SupersedesId). When empty, consumers fall back
              *     to the default behaviour (use the latest completed edit if any,
              *     otherwise the source itself). Persisted so the choice survives
-             *     across sessions and is honoured by the export pipeline.
-             */
+             *     across sessions and is honoured by the export pipeline. */
             selectedVersionId?: string;
-            /**
-             * @description Source snapshot fields (populated on Role = "source"; mirrored from
+            /** @description Source snapshot fields (populated on Role = "source"; mirrored from
              *     Media at attach time so the case stays self-contained even after
-             *     the original media document is cleaned up).
-             */
+             *     the original media document is cleaned up). */
             sourceMediaId?: string;
             spriteFile?: string;
             spriteInterval?: number;
             spriteProvider?: string;
-            /**
-             * @description SpriteUrl is a signed playback URL for SpriteFile and is populated
-             *     by the API at fetch time. Not persisted.
-             */
+            /** @description SpriteUrl is a signed playback URL for SpriteFile and is populated
+             *     by the API at fetch time. Not persisted. */
             spriteUrl?: string;
-            /**
-             * @description Lifecycle (only meaningful on Role = "edit"). For sources this is
-             *     implicitly Completed at creation time.
-             */
+            /** @description Lifecycle (only meaningful on Role = "edit"). For sources this is
+             *     implicitly Completed at creation time. */
             status?: components["schemas"]["models.CaseMediaStatus"];
             statusError?: string;
             storageSolution?: string;
-            /**
-             * @description SupersedesId points at the previous version this entry replaces,
-             *     preserving the full edit chain for auditing / rollback.
-             */
+            /** @description SupersedesId points at the previous version this entry replaces,
+             *     preserving the full edit chain for auditing / rollback. */
             supersedesId?: string;
             taskId?: string;
             thumbnailFile?: string;
             thumbnailProvider?: string;
-            /**
-             * @description ThumbnailUrl is a signed playback URL for ThumbnailFile and is
-             *     populated by the API at fetch time. Not persisted.
-             */
+            /** @description ThumbnailUrl is a signed playback URL for ThumbnailFile and is
+             *     populated by the API at fetch time. Not persisted. */
             thumbnailUrl?: string;
             timestamp?: number;
             updatedAt?: number;
             /** @description Url is signed by the API at fetch time and not persisted. */
             url?: string;
-            /**
-             * @description Version is monotonically increasing within
+            /** @description Version is monotonically increasing within
              *     (TaskId, ParentId, Action, EditType). The most recent completed
-             *     version is the one the export pipeline picks up.
-             */
+             *     version is the one the export pipeline picks up. */
             version?: number;
             videoFile?: string;
             videoProvider?: string;
@@ -33134,12 +34116,10 @@ export interface components {
         /** @enum {string} */
         "models.CaseMediaStatus": "queued" | "processing" | "completed" | "failed";
         "models.CaseShare": {
-            /**
-             * @description AttachmentSelection is the per-share snapshot of the
+            /** @description AttachmentSelection is the per-share snapshot of the
              *     task.Attachments[] ids the recipient is allowed to browse.
              *     Same nil/empty/non-empty semantics as Selection — and the same
-             *     reason the bson tag drops `,omitempty`.
-             */
+             *     reason the bson tag drops `,omitempty`. */
             attachment_selection?: string[];
             created_at?: number;
             email?: string;
@@ -33149,13 +34129,10 @@ export interface components {
             organisation_id?: string;
             /** @description e.g. ["view"] */
             permissions?: string[];
-            /**
-             * @description ProjectId optionally places the case share in a project within its organisation.
-             *     A nil value keeps it organisation-wide.
-             */
+            /** @description ProjectId optionally places the case share in a project within its organisation.
+             *     A nil value keeps it organisation-wide. */
             projectId?: string;
-            /**
-             * @description Selection is the per-share snapshot of the case_media ids the
+            /** @description Selection is the per-share snapshot of the case_media ids the
              *     recipient is allowed to browse, captured at CreateShare time.
              *     It is the source of truth for what this specific token resolves
              *     to — task.ShareSelection is only used as the owner-side
@@ -33176,8 +34153,7 @@ export interface components {
              *     re-binding the share to whatever template the owner happens to
              *     have in place at read time. The JSON tag keeps `omitempty`
              *     because the frontend treats a missing field identically to
-             *     `[]`.
-             */
+             *     `[]`. */
             selection?: string[];
             task_id?: string;
             token?: string;
@@ -33254,20 +34230,16 @@ export interface components {
             audit?: components["schemas"]["models.Audit"];
             author?: string;
             content?: string;
-            /**
-             * @description RBAC information
+            /** @description RBAC information
              *     DeviceId is a unique identifier for the device, it can be used to identify the device in the system.
-             *     OrganisationId is used to identify the organisation that owns the device.
-             */
+             *     OrganisationId is used to identify the organisation that owns the device. */
             deviceId?: string;
             id?: string;
             organisationId?: string;
             /** @description ID of the parent comment, if this is a reply */
             parentId?: string;
-            /**
-             * @description ProjectId optionally places the comment in a project within its organisation.
-             *     A nil value keeps the comment organisation-wide.
-             */
+            /** @description ProjectId optionally places the comment in a project within its organisation.
+             *     A nil value keeps the comment organisation-wide. */
             projectId?: string;
             timestamps?: number[];
             /** @description Comment information */
@@ -33359,6 +34331,13 @@ export interface components {
         "models.CreateOrganisationOutput": {
             organisation?: components["schemas"]["models.Organisation"];
         };
+        "models.CreateProjectInput": {
+            project?: components["schemas"]["models.Project"];
+            user?: components["schemas"]["models.User"];
+        };
+        "models.CreateProjectOutput": {
+            project?: components["schemas"]["models.Project"];
+        };
         "models.CreateVideowallInput": {
             user?: components["schemas"]["models.User"];
             videowall?: components["schemas"]["models.Videowall"];
@@ -33410,10 +34389,8 @@ export interface components {
             motionRegions?: components["schemas"]["models.Region"][];
             organisationId?: string;
             outputList?: string[];
-            /**
-             * @description ProjectId optionally places the alert in a project within its organisation.
-             *     A nil value keeps the alert organisation-wide.
-             */
+            /** @description ProjectId optionally places the alert in a project within its organisation.
+             *     A nil value keeps the alert organisation-wide. */
             projectId?: string;
             pushbullet_apikey?: string;
             pushover_apikey?: string;
@@ -33455,6 +34432,13 @@ export interface components {
             user_id?: string;
         };
         "models.DeleteCaseShareOutput": Record<string, never>;
+        "models.DeleteProjectInput": {
+            projectId?: string;
+            user?: components["schemas"]["models.User"];
+        };
+        "models.DeleteProjectOutput": {
+            project?: components["schemas"]["models.Project"];
+        };
         "models.DeleteVideowallInput": {
             user?: components["schemas"]["models.User"];
             videowall_id?: string;
@@ -33552,43 +34536,33 @@ export interface components {
             categories?: components["schemas"]["models.DetectionCategory"][];
             /** @description CreatedAt is set by the server when the run is first stored (epoch millis). */
             createdAt?: number;
-            /**
-             * @description DeviceId is denormalised from the recording for convenient filtering and
-             *     cascade cleanup; it is not authoritative.
-             */
+            /** @description DeviceId is denormalised from the recording for convenient filtering and
+             *     cascade cleanup; it is not authoritative. */
             deviceId?: string;
             /** @description Id is the MongoDB document id, assigned on first insert. */
             id?: string;
-            /**
-             * @description Key is the recording/media key the run belongs to. It is the stable
-             *     identity the collection is keyed by (survives re-analysis).
-             */
+            /** @description Key is the recording/media key the run belongs to. It is the stable
+             *     identity the collection is keyed by (survives re-analysis). */
             key?: string;
             media?: components["schemas"]["models.DetectionMedia"];
-            /**
-             * @description OriginalBoxForm records the box geometry form the producer sent
-             *     ("xywh", "xyxy", or "mixed") before conversion to the editor's TrackBox.
-             */
+            /** @description Name is an optional user-facing label for the run. */
+            name?: string;
+            /** @description OriginalBoxForm records the box geometry form the producer sent
+             *     ("xywh", "xyxy", or "mixed") before conversion to the editor's TrackBox. */
             originalBoxForm?: string;
-            /**
-             * @description OriginalCoordinateSpace records the coordinate space the producer sent
+            /** @description OriginalCoordinateSpace records the coordinate space the producer sent
              *     ("pixel" or "normalized") before the server normalised it on write.
-             *     Tracks are always stored normalised; this preserves the original for audit.
-             */
+             *     Tracks are always stored normalised; this preserves the original for audit. */
             originalCoordinateSpace?: string;
-            /**
-             * @description RecordingTimestamp is the start time (epoch seconds) of the recording the
+            /** @description RecordingTimestamp is the start time (epoch seconds) of the recording the
              *     run belongs to, denormalised from the analysis on write. It lets cleanup
              *     expire a run on the same retention clock as its recording rather than by
-             *     the (possibly much later) post time.
-             */
+             *     the (possibly much later) post time. */
             recordingTimestamp?: number;
             schemaVersion?: string;
             source?: components["schemas"]["models.DetectionSource"];
-            /**
-             * @description Task is a forward-compatibility discriminator for the kind of run.
-             *     Defaults to "detection" when omitted.
-             */
+            /** @description Task is a forward-compatibility discriminator for the kind of run.
+             *     Defaults to "detection" when omitted. */
             task?: string;
             tracks?: components["schemas"]["models.FaceRedactionTrack"][];
             /** @description UpdatedAt is set by the server every time the run is written (epoch millis). */
@@ -33602,10 +34576,8 @@ export interface components {
             /** @description producer identifier / editor layer label */
             name?: string;
             nmsIou?: number;
-            /**
-             * @description RotationApplied indicates whether boxes are against the rotated/oriented
-             *     frame. Defaults to true on the wire; a nil pointer is treated as true.
-             */
+            /** @description RotationApplied indicates whether boxes are against the rotated/oriented
+             *     frame. Defaults to true on the wire; a nil pointer is treated as true. */
             rotationApplied?: boolean;
             /** @description ULID/UUID; upsert key */
             runId?: string;
@@ -33631,21 +34603,17 @@ export interface components {
             agentLastSeen?: number;
             /** @description Deprecated - to be removed */
             analytics?: components["schemas"]["models.DeprecatedHeartbeat"][];
-            /**
-             * @description AtRuntimeMetadata contains metadata that is generated at runtime, which can include
+            /** @description AtRuntimeMetadata contains metadata that is generated at runtime, which can include
              *     more verbose information about the device's current state, capabilities, or configuration.
-             *     for example the linked sites details, etc.
-             */
+             *     for example the linked sites details, etc. */
             atRuntimeMetadata?: components["schemas"]["models.DeviceAtRuntimeMetadata"];
             /** @description Audit information */
             audit?: components["schemas"]["models.Audit"];
             /** @description Device Specific Metadata */
             cameraMetadata?: components["schemas"]["models.CameraMetadata"];
-            /**
-             * @description Device status
+            /** @description Device status
              *     Note: Status is used to identify the status of the device, such as online, offline, maintenance, etc."
-             *     LastSeenTimestamp is used to identify the last time the device was seen online.
-             */
+             *     LastSeenTimestamp is used to identify the last time the device was seen online. */
             connectionStart?: number;
             /** @description Type of deployment used e.g. "factory", "docker", "docker compose", "kubernetes" */
             deployment?: string;
@@ -33653,13 +34621,11 @@ export interface components {
             deviceLastSeen?: number;
             /** @description threshold in milliseconds to consider a device offline, based on agentLastSeen */
             disconnectedThreshold?: number;
-            /**
-             * @description FeaturePermissions is used to identify the permissions of the device, such as read, write, delete, etc.
+            /** @description FeaturePermissions is used to identify the permissions of the device, such as read, write, delete, etc.
              *     It is a map of feature names to permissions.
              *     For example, "camera" can have permissions like "read", "write", "delete", etc.
              *     This allows for fine-grained control over what features are accessible by users or groups.
-             *     FeaturePermissions can be used to implement Role-Based Access Control (RBAC) for devices.
-             */
+             *     FeaturePermissions can be used to implement Role-Based Access Control (RBAC) for devices. */
             featurePermissions?: components["schemas"]["models.DeviceFeaturePermissions"];
             gpsMetadata?: components["schemas"]["models.GPSMetadata"];
             groupIds?: string[];
@@ -33669,11 +34635,9 @@ export interface components {
             id?: string;
             /** @description threshold in milliseconds to consider a device idle, based on deviceLastSeen */
             idleThreshold?: number;
-            /**
-             * @description Device information
+            /** @description Device information
              *     Note: DeviceId is a unique identifier for the device, it can be used to identify the device in the system.
-             *     DeviceType is used to identify the type of device, such as camera, sensor, access control, etc.
-             */
+             *     DeviceType is used to identify the type of device, such as camera, sensor, access control, etc. */
             key?: string;
             /** @description Latest Media information */
             latestMedia?: components["schemas"]["models.Media"];
@@ -33686,26 +34650,20 @@ export interface components {
             metadata?: components["schemas"]["models.DeviceMetadata"];
             /** @description e.g. "Front Door Camera" */
             name?: string;
-            /**
-             * @description RBAC information
+            /** @description RBAC information
              *     Note: SiteId is used to identify the site where the device is located.
              *     GroupId is used to identify the group of devices.
              *     OrganisationId is used to identify the organisation that owns the device.
-             *     FeaturePermissions is used to identify the permissions of the device, such as read, write, delete, etc.
-             */
+             *     FeaturePermissions is used to identify the permissions of the device, such as read, write, delete, etc. */
             organisationId?: string;
-            /**
-             * @description ProjectId optionally places the device in a project within its
-             *     organisation. A nil value keeps the device organisation-wide. It narrows
-             *     access on top of OrganisationId; it never replaces it.
-             */
+            /** @description ProjectId places the device in exactly one project within its organisation.
+             *     A nil or zero legacy value resolves to that organisation's default project;
+             *     it does not make the device organisation-wide. */
             projectId?: string;
-            /**
-             * @description Versioning information
+            /** @description Versioning information
              *     Note: Version is used to identify the version of the device software.
              *     ReleaseHash is used to identify the release hash of the device software, it can be used to identify the specific build of the device software.
-             *     Deployment is used to identify the deployment type of the device, such as factory, docker, docker compose, kubernetes, etc.
-             */
+             *     Deployment is used to identify the deployment type of the device, such as factory, docker, docker compose, kubernetes, etc. */
             repository?: string;
             siteIds?: string[];
             /** @description Type of device e.g. "camera", "sensor", "access_control" */
@@ -33855,6 +34813,7 @@ export interface components {
             /** @description Add fields relevant to event stage */
             eventData?: string;
             name?: string;
+            sourceDevice?: components["schemas"]["models.PipelineSourceDevice"];
         };
         "models.ExportFile": {
             camera_id?: string;
@@ -33872,13 +34831,11 @@ export interface components {
             video_url?: string;
         };
         "models.FaceRedaction": {
-            /**
-             * @description CaseMediaId back-references the case_media entry (role=edit,
+            /** @description CaseMediaId back-references the case_media entry (role=edit,
              *     action=redaction) created when the redaction is submitted. The
              *     lifecycle (queued/processing/completed/failed) is owned by that
              *     case_media document; this struct only carries the tracks/inputs
-             *     the user has defined.
-             */
+             *     the user has defined. */
             caseMediaId?: string;
             id?: string;
             tracks?: components["schemas"]["models.FaceRedactionTrack"][];
@@ -33887,10 +34844,8 @@ export interface components {
             classId?: number;
             classified?: string;
             colorStr?: string[];
-            /**
-             * @description Confidence, ClassId and Shape preserve track-level provenance from a
-             *     detection run; empty for tracks created by the editor.
-             */
+            /** @description Confidence, ClassId and Shape preserve track-level provenance from a
+             *     detection run; empty for tracks created by the editor. */
             confidence?: number;
             deletedFrames?: number[];
             /** @description frame -> [x1, y1, x2, y2] */
@@ -34020,7 +34975,15 @@ export interface components {
         "models.GetOrganisationsOutput": {
             organisations?: components["schemas"]["models.Organisation"][];
         };
+        "models.GetProjectInput": {
+            projectId?: string;
+            user?: components["schemas"]["models.User"];
+        };
+        "models.GetProjectOutput": {
+            project?: components["schemas"]["models.Project"];
+        };
         "models.GetProjectsInput": {
+            includeInactive?: boolean;
             user?: components["schemas"]["models.User"];
         };
         "models.GetProjectsOutput": {
@@ -34082,17 +35045,13 @@ export interface components {
             name?: string;
             /** @description RBAC information */
             organisationId?: string;
-            /**
-             * @description ProjectId optionally places the group in a project within its organisation.
-             *     A nil value keeps the group organisation-wide.
-             */
+            /** @description ProjectId optionally places the group in a project within its organisation.
+             *     A nil value keeps the group organisation-wide. */
             projectId?: string;
             /** @description Nested sites */
             sites?: string[];
-            /**
-             * @description Media file information (by default "vault", however might change
-             *     in the future (integration with other storage solutions, next to Vault).
-             */
+            /** @description Media file information (by default "vault", however might change
+             *     in the future (integration with other storage solutions, next to Vault). */
             storageSolution?: string;
             /** @description Deprecated */
             user_id?: string;
@@ -34116,11 +35075,9 @@ export interface components {
             value?: string;
         };
         "models.Health": {
-            /**
-             * @description AtRuntimeMetadata contains metadata that is generated at runtime, which can include
+            /** @description AtRuntimeMetadata contains metadata that is generated at runtime, which can include
              *     more verbose information about the device's current state, capabilities, or configuration.
-             *     for example the linked sites details, etc.
-             */
+             *     for example the linked sites details, etc. */
             atRuntimeMetadata?: components["schemas"]["models.HealthAtRuntimeMetadata"];
             /** @description Audit information */
             audit?: components["schemas"]["models.Audit"];
@@ -34197,10 +35154,8 @@ export interface components {
             /** @description last time the IO was seen */
             lastSeenTimestamp?: number;
             organisationId?: string;
-            /**
-             * @description ProjectId optionally places the IO in a project within its organisation.
-             *     A nil value keeps the IO organisation-wide.
-             */
+            /** @description ProjectId optionally places the IO in a project within its organisation.
+             *     A nil value keeps the IO organisation-wide. */
             projectId?: string;
             /** @description input or output */
             type?: string;
@@ -34227,10 +35182,8 @@ export interface components {
             name?: string;
             organisationId?: string;
             owner_id?: string;
-            /**
-             * @description ProjectId optionally places the label in a project within its organisation.
-             *     A nil value keeps the label organisation-wide.
-             */
+            /** @description ProjectId optionally places the label in a project within its organisation.
+             *     A nil value keeps the label organisation-wide. */
             projectId?: string;
             type?: string[];
             user_id?: string;
@@ -34262,11 +35215,9 @@ export interface components {
             name?: string;
         };
         "models.Marker": {
-            /**
-             * @description AtRuntimeMetadata contains metadata that is generated at runtime, which can include
+            /** @description AtRuntimeMetadata contains metadata that is generated at runtime, which can include
              *     more verbose information about the device's current state, capabilities, or configuration.
-             *     for example the linked sites details, etc.
-             */
+             *     for example the linked sites details, etc. */
             atRuntimeMetadata?: components["schemas"]["models.MarkerAtRuntimeMetadata"];
             /** @description Audit information */
             audit?: components["schemas"]["models.Audit"];
@@ -34277,12 +35228,10 @@ export interface components {
              * @example Person forcably opened a door
              */
             description?: string;
-            /**
-             * @description Detections links this marker to the detection track(s) it was derived from,
+            /** @description Detections links this marker to the detection track(s) it was derived from,
              *     enabling on-demand bounding-box overlays on the recording. Each entry points
              *     at a stored detection track (see DetectionRef). A marker usually links to a
-             *     single track but may reference several; empty when no detection link is known.
-             */
+             *     single track but may reference several; empty when no detection link is known. */
             detections?: components["schemas"]["models.DetectionRef"][];
             /**
              * @description RBAC information
@@ -34336,10 +35285,8 @@ export interface components {
              * @example 686a906345c1df594pad69f0
              */
             organisationId?: string;
-            /**
-             * @description ProjectId optionally places the marker in a project within its organisation.
-             *     A nil value keeps the marker organisation-wide.
-             */
+            /** @description ProjectId optionally places the marker in a project within its organisation.
+             *     A nil value keeps the marker organisation-wide. */
             projectId?: string;
             /**
              * @description SiteId is used to identify the site where the marker is located
@@ -34480,10 +35427,8 @@ export interface components {
             startTimestamp?: number;
         };
         "models.MarkerMetadata": {
-            /**
-             * @description BoundingBox is the normalized [0,1] region of the detection within the frame,
-             *     suitable for drawing overlays. Nil when no spatial information is available.
-             */
+            /** @description BoundingBox is the normalized [0,1] region of the detection within the frame,
+             *     suitable for drawing overlays. Nil when no spatial information is available. */
             boundingBox?: components["schemas"]["models.MarkerBox"];
             /** @description Additional comments or description of the marker */
             comments?: components["schemas"]["models.Comment"];
@@ -34507,11 +35452,9 @@ export interface components {
              * @example v1.4.0
              */
             modelVersion?: string;
-            /**
-             * @description Raw is an escape hatch for pipeline-specific metadata that does not warrant a
+            /** @description Raw is an escape hatch for pipeline-specific metadata that does not warrant a
              *     first-class field. Values here are not indexed or validated; promote anything
-             *     you need to query into a typed field instead.
-             */
+             *     you need to query into a typed field instead. */
             raw?: {
                 [key: string]: unknown;
             };
@@ -34561,11 +35504,9 @@ export interface components {
         };
         "models.MarkerSummary": {
             categoryNames?: string[];
-            /**
-             * @description Detections mirrors the source marker's Detections so the frontend can map a
+            /** @description Detections mirrors the source marker's Detections so the frontend can map a
              *     summarised marker to its detection track(s) — and toggle their bounding-box
-             *     overlay — without a second query. Empty when the marker has no detection link.
-             */
+             *     overlay — without a second query. Empty when the marker has no detection link. */
             detections?: components["schemas"]["models.DetectionRef"][];
             endTimestamp?: number;
             eventNames?: string[];
@@ -34617,22 +35558,18 @@ export interface components {
             markers?: components["schemas"]["models.MarkerGroup"][];
         };
         "models.Media": {
-            /**
-             * @description AtRuntimeMetadata contains metadata that is generated at runtime, which can include
+            /** @description AtRuntimeMetadata contains metadata that is generated at runtime, which can include
              *     more verbose information about the device's current state, capabilities, or configuration.
-             *     for example the linked sites details, etc.
-             */
+             *     for example the linked sites details, etc. */
             atRuntimeMetadata?: components["schemas"]["models.MediaAtRuntimeMetadata"];
             /** @description Audit information */
             audit?: components["schemas"]["models.Audit"];
             categoryNames?: string[];
             classificationSummary?: components["schemas"]["models.ClassificationSummary"][];
             countingSummary?: components["schemas"]["models.CountingSummary"][];
-            /**
-             * @description RBAC information
+            /** @description RBAC information
              *     DeviceId is a unique identifier for the device, it can be used to identify the device in the system.
-             *     OrganisationId is used to identify the organisation that owns the device.
-             */
+             *     OrganisationId is used to identify the organisation that owns the device. */
             deviceId?: string;
             /** @description device identifier */
             deviceKey?: string;
@@ -34645,32 +35582,28 @@ export interface components {
             /** @description Unique identifier for the media file */
             id?: string;
             markerNames?: string[];
-            /**
-             * @description MarkerSummary is a per-occurrence denormalisation of the markers that overlap
+            /** @description MarkerSummary is a per-occurrence denormalisation of the markers that overlap
              *     this media. Unlike the flat markerNames/eventNames/tagNames/categoryNames
              *     arrays that back filtering, each entry preserves the correlation between a
              *     single marker's name, its category/event/tag names and its time range, for
-             *     display/detail rendering (icons, listings).
-             */
+             *     display/detail rendering (icons, listings). */
             markerSummary?: components["schemas"]["models.MarkerSummary"][];
             /** @description Metadata */
             metadata?: components["schemas"]["models.MediaMetadata"];
             organisationId?: string;
-            /**
-             * @description ProjectId optionally places the media in a project within its organisation.
-             *     A nil value keeps the media organisation-wide.
-             */
+            /** @description ProjectId optionally places the media in a project within its organisation.
+             *     A nil value keeps the media organisation-wide. */
             projectId?: string;
             siteId?: string;
+            sourceMediaId?: string;
+            sourceVaultId?: string;
             spriteFile?: string;
             spriteProvider?: string;
             star?: boolean;
             /** @description Time window of media file. */
             startTimestamp?: number;
-            /**
-             * @description Media file information (by default "vault", however might change
-             *     in the future (integration with other storage solutions, next to Vault).
-             */
+            /** @description Media file information (by default "vault", however might change
+             *     in the future (integration with other storage solutions, next to Vault). */
             storageSolution?: string;
             tagNames?: string[];
             thumbnailFile?: string;
@@ -34800,10 +35733,8 @@ export interface components {
             notification_type?: string;
             number_of_media?: string;
             organisationId?: string;
-            /**
-             * @description ProjectId optionally places the message in a project within its organisation.
-             *     A nil value keeps the message organisation-wide.
-             */
+            /** @description ProjectId optionally places the message in a project within its organisation.
+             *     A nil value keeps the message organisation-wide. */
             projectId?: string;
             sequence_id?: string;
             sites?: components["schemas"]["models.Site"][];
@@ -34822,31 +35753,25 @@ export interface components {
             userid?: string;
         };
         "models.Model": {
-            /**
-             * @description AtRuntimeMetadata are computed or dynamic information about the model that is relevant during its usage or processing.
+            /** @description AtRuntimeMetadata are computed or dynamic information about the model that is relevant during its usage or processing.
              *     This information is generated at run time and is not stored into the database. All other information of the model is persisted into the database.
              *     and is not altered during runtime.
              *     e.g.
              *     Media model -> signed URLS for accessing the media, processing status, etc.
-             *     Device model -> current status (active, inactive), etc.
-             */
+             *     Device model -> current status (active, inactive), etc. */
             atRuntimeMetadata?: components["schemas"]["models.MediaAtRuntimeMetadata"];
-            /**
-             * @description Audit information: every model should have audit information to track its creation and modification history.
-             *     This is important for maintaining data integrity and accountability.
-             */
+            /** @description Audit information: every model should have audit information to track its creation and modification history.
+             *     This is important for maintaining data integrity and accountability. */
             audit?: components["schemas"]["models.Audit"];
             /** @description Unique identifier for the model, this is used to retrieve the model from the database by its unique ID. */
             id?: string;
-            /**
-             * @description Metadata is additional information about the model that is not critical for its primary function,
+            /** @description Metadata is additional information about the model that is not critical for its primary function,
              *     but can provide useful context or details.
              *     e.g.
              *     User model -> profile information, preferences, etc.
              *     Device model -> location, installation date, etc.
              *     Media model -> tags, description, etc.
-             *     Marker model -> comments, tags, etc.
-             */
+             *     Marker model -> comments, tags, etc. */
             metadata?: components["schemas"]["models.MediaMetadata"];
         };
         "models.ModelOption": {
@@ -34858,10 +35783,8 @@ export interface components {
             highUpload?: components["schemas"]["models.HighUpload"];
             monitorData?: string;
             name?: string;
-            /**
-             * @description OrganisationId and ProjectId snapshot the stored source device's ownership;
-             *     nested user and payload fields are mutable actor/request context instead.
-             */
+            /** @description OrganisationId and ProjectId snapshot the stored source device's ownership;
+             *     nested user and payload fields are mutable actor/request context instead. */
             organisationId?: string;
             plans?: {
                 [key: string]: components["schemas"]["models.Plan"];
@@ -34896,10 +35819,8 @@ export interface components {
             notification_type?: string;
             number_of_media?: string;
             organisationId?: string;
-            /**
-             * @description ProjectId optionally places the message in a project within its organisation.
-             *     A nil value keeps the message organisation-wide.
-             */
+            /** @description ProjectId optionally places the message in a project within its organisation.
+             *     A nil value keeps the message organisation-wide. */
             projectId?: string;
             sequence_id?: string;
             sites?: components["schemas"]["models.Site"][];
@@ -34947,11 +35868,9 @@ export interface components {
             /** @description The user who owns this organisation */
             ownerId?: string;
             settings?: components["schemas"]["models.OrganisationSettings"];
-            /**
-             * @description Slug is a stable, URL-friendly handle for the organisation (e.g. "acme-corp").
+            /** @description Slug is a stable, URL-friendly handle for the organisation (e.g. "acme-corp").
              *     It is unique and decoupled from the display Name so it can be used in URLs
-             *     and references without breaking when the name changes.
-             */
+             *     and references without breaking when the name changes. */
             slug?: string;
             /** @description Billing & Subscription */
             subscription?: components["schemas"]["models.Subscription"];
@@ -34971,13 +35890,11 @@ export interface components {
             organisationId?: string;
             /** @description Roles to assign upon acceptance */
             roleIds?: string[];
-            /**
-             * @description Scope is the granular scope applied to every role in RoleIds when the
+            /** @description Scope is the granular scope applied to every role in RoleIds when the
              *     invitation is accepted, i.e. it seeds the Scope of each resulting
              *     RoleAssignment. Following the RoleAssignmentScope convention, a zero value
              *     grants the roles organisation-wide; populate a dimension to restrict the
-             *     resulting assignments to specific resources (see RoleAssignmentScope).
-             */
+             *     resulting assignments to specific resources (see RoleAssignmentScope). */
             scope?: components["schemas"]["models.RoleAssignmentScope"];
             status?: components["schemas"]["models.InvitationStatus"];
             token?: string;
@@ -35009,10 +35926,8 @@ export interface components {
             primaryContact?: components["schemas"]["models.Contact"];
             /** @description Technical/support contact */
             technicalContact?: components["schemas"]["models.Contact"];
-            /**
-             * @description Regional defaults applied across the organisation for display, scheduling
-             *     and billing.
-             */
+            /** @description Regional defaults applied across the organisation for display, scheduling
+             *     and billing. */
             timezone?: string;
         };
         "models.OrganisationUpdate": {
@@ -35028,11 +35943,9 @@ export interface components {
         };
         "models.OrganisationUser": {
             audit?: components["schemas"]["models.Audit"];
-            /**
-             * @description ExpiresAt optionally bounds the membership in time. It is an overlay on
+            /** @description ExpiresAt optionally bounds the membership in time. It is an overlay on
              *     Status: a membership is only effectively active when Status is
-             *     MembershipStatusActive AND ExpiresAt is unset or in the future.
-             */
+             *     MembershipStatusActive AND ExpiresAt is unset or in the future. */
             expiresAt?: string;
             id?: string;
             invitedAt?: string;
@@ -35075,11 +35988,9 @@ export interface components {
             };
             date?: number;
             eventStage?: components["schemas"]["models.EventStage"];
-            /**
-             * @description Stages of the pipeline, e.g., event, monitor, sequence, analysis, throttler, notification
+            /** @description Stages of the pipeline, e.g., event, monitor, sequence, analysis, throttler, notification
              *     Idea is that we persist relevant data in each stage, so we have a good understanding what is used
-             *     or computed at which stage.
-             */
+             *     or computed at which stage. */
             events?: string[];
             fileName?: string;
             monitorStage?: components["schemas"]["models.MonitorStage"];
@@ -35125,18 +36036,26 @@ export interface components {
             metadata?: components["schemas"]["models.PipelineMetadata"];
             /** @description RBAC */
             organisationId?: string;
-            /**
-             * @description Result is the typed result a producer stage hands back for a delegated
+            /** @description Result is the typed result a producer stage hands back for a delegated
              *     ingest handler (e.g. a DetectionRun-shaped body). It is the result
              *     channel the ingest core reads from — distinct from the deprecated
              *     PipelineEvent.Data bag, which only carries storage credentials on
-             *     dispatch and must not be used to carry results.
-             */
+             *     dispatch and must not be used to carry results. */
             result?: number[];
             /** @description Signed URL */
             signedUrl?: string;
+            sourceMediaId?: string;
+            sourceVaultId?: string;
             timestamp?: number;
         };
+        "models.PipelineSourceDevice": {
+            cloudKey?: string;
+            deviceId?: string;
+            deviceKey?: string;
+            organisationId?: string;
+            ownerUserId?: string;
+            projectId?: string;
+        };
         "models.Plan": {
             /** @description AnalysisLimit is the maximum number of analysis operations allowed */
             analysisLimit?: number;
@@ -35160,13 +36079,21 @@ export interface components {
         };
         "models.Project": {
             audit?: components["schemas"]["models.Audit"];
+            dates?: string[];
             description?: string;
+            hasPincode?: boolean;
             id?: string;
             isActive?: boolean;
             name?: string;
             organisationId?: string;
             slug?: string;
         };
+        "models.ProjectUpdate": {
+            description?: string;
+            isActive?: boolean;
+            name?: string;
+            slug?: string;
+        };
         "models.Pushbullet": {
             apikey?: string;
             enabled?: boolean;
@@ -35205,22 +36132,18 @@ export interface components {
             isActive?: boolean;
             /** @description Organisation this role belongs to */
             organisationId?: string;
-            /**
-             * @description Pages and FeaturePermissions are two orthogonal authorization axes:
+            /** @description Pages and FeaturePermissions are two orthogonal authorization axes:
              *       - Pages controls which UI/nav pages are visible (coarse allow-list).
              *       - FeaturePermissions controls the CRUD AccessLevel per feature.
              *     Some names appear in both (e.g. sites/groups/roles/settings); that overlap
              *     is intentional - visibility and capability are decided independently, and
              *     the consuming service resolves them together (page hidden => not shown;
-             *     feature level => what may be done once on the page).
-             */
+             *     feature level => what may be done once on the page). */
             pages?: string[];
-            /**
-             * @description ParentRole is the built-in BaseRole tier this custom role extends. It is a
+            /** @description ParentRole is the built-in BaseRole tier this custom role extends. It is a
              *     live tier identifier (NOT an ObjectID reference to another Role document):
              *     it sets the effective tier/RoleLevel for coarse gating and bounds which
-             *     pages the role may grant. See BaseRole.
-             */
+             *     pages the role may grant. See BaseRole. */
             role?: components["schemas"]["models.BaseRole"];
             roleName?: string;
             timeWindow?: components["schemas"]["models.TimeWindow"];
@@ -35228,11 +36151,9 @@ export interface components {
         };
         "models.RoleAssignment": {
             audit?: components["schemas"]["models.Audit"];
-            /**
-             * @description ExpiresAt optionally bounds the assignment in time. It is an overlay on
+            /** @description ExpiresAt optionally bounds the assignment in time. It is an overlay on
              *     IsActive: an assignment is only effectively active when IsActive is true
-             *     AND ExpiresAt is unset or in the future. Use IsEffectivelyActive().
-             */
+             *     AND ExpiresAt is unset or in the future. Use IsEffectivelyActive(). */
             expiresAt?: string;
             id?: string;
             /** @description Administrative enable/disable switch (independent of expiry) */
@@ -35271,10 +36192,8 @@ export interface components {
             images?: components["schemas"]["models.Media"][];
             notified?: boolean;
             organisationId?: string;
-            /**
-             * @description ProjectId optionally places the sequence in a project within its organisation.
-             *     A nil value keeps the sequence organisation-wide.
-             */
+            /** @description ProjectId optionally places the sequence in a project within its organisation.
+             *     A nil value keeps the sequence organisation-wide. */
             projectId?: string;
             start?: number;
             user_id?: string;
@@ -35323,17 +36242,13 @@ export interface components {
             name?: string;
             /** @description RBAC information */
             organisationId?: string;
-            /**
-             * @description ProjectId optionally places the site in a project within its organisation.
-             *     A nil value keeps the site organisation-wide.
-             */
+            /** @description ProjectId optionally places the site in a project within its organisation.
+             *     A nil value keeps the site organisation-wide. */
             projectId?: string;
             secret_key?: string;
             storage_uri?: string;
-            /**
-             * @description Media file information (by default "vault", however might change
-             *     in the future (integration with other storage solutions, next to Vault).
-             */
+            /** @description Media file information (by default "vault", however might change
+             *     in the future (integration with other storage solutions, next to Vault). */
             storageSolution?: string;
             /** @description Deprecated */
             user_id?: string;
@@ -35386,20 +36301,16 @@ export interface components {
             value?: unknown;
         };
         "models.StageDependency": {
-            /**
-             * @description Condition is the predicate evaluated against the run root. Nil means the
-             *     need matches as soon as its gate (if any) is satisfied.
-             */
+            /** @description Condition is the predicate evaluated against the run root. Nil means the
+             *     need matches as soon as its gate (if any) is satisfied. */
             condition?: components["schemas"]["models.StageCondition"];
-            /**
-             * @description Operation is the id of the operation whose presence gates this need: it must
+            /** @description Operation is the id of the operation whose presence gates this need: it must
              *     be available on the run — present in Inputs or Results — before the need's
              *     Condition is evaluated. It is an operation id, not necessarily a deployed
              *     stage: the most common gate, "classify", is the analysis trigger (it arrives
              *     in Inputs at open), not a stage. Empty means the need is ungated: a check on
              *     the run root itself (device/user/identity, or an input present from open),
-             *     evaluated as soon as the run opens with nothing to wait for.
-             */
+             *     evaluated as soon as the run opens with nothing to wait for. */
             operation?: string;
         };
         "models.StageParam": {
@@ -35427,11 +36338,9 @@ export interface components {
             requests?: components["schemas"]["models.StageResourceList"];
         };
         "models.State": {
-            /**
-             * @description AtRuntimeMetadata contains metadata that is generated at runtime, which can include
+            /** @description AtRuntimeMetadata contains metadata that is generated at runtime, which can include
              *     more verbose information about the device's current state, capabilities, or configuration.
-             *     for example the linked sites details, etc.
-             */
+             *     for example the linked sites details, etc. */
             atRuntimeMetadata?: components["schemas"]["models.StateAtRuntimeMetadata"];
             /** @description Audit information */
             audit?: components["schemas"]["models.Audit"];
@@ -35572,8 +36481,7 @@ export interface components {
             /** @description legacy: read by v20130101 only */
             export_files?: components["schemas"]["models.ExportFile"][];
             export_files_count?: number;
-            /**
-             * @description ExportHeartbeatAgeSeconds is computed at API response time
+            /** @description ExportHeartbeatAgeSeconds is computed at API response time
              *     (NOT persisted — bson:"-") and ships the server-side delta
              *     between now and ExportUpdatedAt so the frontend can render a
              *     "stuck" state without depending on the user's local clock
@@ -35582,46 +36490,39 @@ export interface components {
              *     (legacy / pre-feature tasks); a zero value means the heartbeat
              *     was just written. The FE only interprets this field in
              *     combination with the in-flight signal — see isExportActive
-             *     and getExportUiState for the rule.
-             */
+             *     and getExportUiState for the rule. */
             export_heartbeat_age_seconds?: number;
             export_in_progress?: boolean;
             /** @description "0% -> 100%" */
             export_progress?: number;
             export_requested?: boolean;
             export_revision?: number;
-            /**
-             * @description ExportSelectionDirty signals that the curated bundle composition
+            /** @description ExportSelectionDirty signals that the curated bundle composition
              *     (include_in_export flags on case_media / attachments, or a newly
              *     added media row) changed since the last successful export
              *     completion. Bumped to true by curation toggles and media inserts
              *     in hub-api; cleared by hub-pipeline-export in CompleteExport.
              *     The FE uses this to disable the Regenerate action when no
              *     changes are pending and to surface a "selection changed" hint
-             *     next to the export status badge.
-             */
+             *     next to the export status badge. */
             export_selection_dirty?: boolean;
             /** @description An export task, is containing multiple video in a compressed file format (.zip) */
             export_status?: string;
-            /**
-             * @description ExportUpdatedAt is a heartbeat written by hub-pipeline-export
+            /** @description ExportUpdatedAt is a heartbeat written by hub-pipeline-export
              *     every time it transitions the export state (claim, status
              *     updates, per-file download, release, complete) and by hub-api
              *     when a new export run is requested. It lets the API detect
              *     orphaned runs whose worker died without releasing the lock:
              *     when (now - ExportUpdatedAt) exceeds the staleness threshold,
              *     isExportActive treats the lock as released so the user can
-             *     retry instead of being blocked by a 409 forever.
-             */
+             *     retry instead of being blocked by a 409 forever. */
             export_updated_at?: string;
             id?: string;
             is_private?: boolean;
             labels?: string[];
             legal_hold?: boolean;
-            /**
-             * @description Number of source case_media rows attached to this task. Mirrors
-             *     case_media documents where role == "source" and task_id matches.
-             */
+            /** @description Number of source case_media rows attached to this task. Mirrors
+             *     case_media documents where role == "source" and task_id matches. */
             media_count?: number;
             media_date?: string;
             media_datetime?: string;
@@ -35632,16 +36533,13 @@ export interface components {
             notes_short?: string;
             notify_assignees?: boolean;
             organisationId?: string;
-            /**
-             * @description ProjectId optionally places the case/task in a project within its organisation.
-             *     A nil value keeps it organisation-wide.
-             */
+            /** @description ProjectId optionally places the case/task in a project within its organisation.
+             *     A nil value keeps it organisation-wide. */
             projectId?: string;
             reporter_email?: string;
             reporter_id?: string;
             reporter_profile?: string;
-            /**
-             * @description Retention / lifecycle.
+            /** @description Retention / lifecycle.
              *
              *     RetentionDays captures the *policy intent*: how many days the
              *     case should be kept after its retention anchor (typically the
@@ -35668,8 +36566,7 @@ export interface components {
              *     regardless of ExpiresAt. It is intentionally a separate flag
              *     from the retention date so audits can distinguish "kept longer
              *     because investigator extended" from "kept because under legal
-             *     hold". Managed by a dedicated permission.
-             */
+             *     hold". Managed by a dedicated permission. */
             retention_days?: number;
             sequenceId?: string;
             sprite_url?: string;
@@ -35686,10 +36583,8 @@ export interface components {
             title?: string;
             user_id?: string;
             username?: string;
-            /**
-             * @description This is used for a single export, for a bulk export, we will use the first video as thumbnail and sprite.
-             *     Referencing to some media: video, thumbnail and sprite
-             */
+            /** @description This is used for a single export, for a bulk export, we will use the first video as thumbnail and sprite.
+             *     Referencing to some media: video, thumbnail and sprite */
             video_url?: string;
             videoFile?: string;
             videoProvider?: string;
@@ -35838,10 +36733,8 @@ export interface components {
         };
         "models.TrackBox": {
             classId?: number;
-            /**
-             * @description Confidence, ClassId and Label preserve the producer's per-box model
-             *     output so a stored detection run can be re-thresholded or audited later.
-             */
+            /** @description Confidence, ClassId and Label preserve the producer's per-box model
+             *     output so a stored detection run can be re-thresholded or audited later. */
             confidence?: number;
             edited?: boolean;
             label?: string;
@@ -35874,6 +36767,14 @@ export interface components {
         "models.UpdateOrganisationOutput": {
             organisation?: components["schemas"]["models.Organisation"];
         };
+        "models.UpdateProjectInput": {
+            project?: components["schemas"]["models.ProjectUpdate"];
+            projectId?: string;
+            user?: components["schemas"]["models.User"];
+        };
+        "models.UpdateProjectOutput": {
+            project?: components["schemas"]["models.Project"];
+        };
         "models.UpdateVideowallInput": {
             user?: components["schemas"]["models.User"];
             videowall?: components["schemas"]["models.Videowall"];
@@ -36074,6 +36975,7 @@ export interface components {
             forwarder_id?: string;
             forwarder_type?: string;
             forwarder_worker?: string;
+            id?: string;
             main_provider?: boolean;
             metadata?: components["schemas"]["models.VaultMediaMetadata"];
             provider?: string;
@@ -36117,18 +37019,14 @@ export interface components {
             time?: string;
         };
         "models.Videowall": {
-            /**
-             * @description AllowLayoutEdits lets any signed-in viewer (not just the owner) persist
-             *     changes to Layout. When false only the owner may save.
-             */
+            /** @description AllowLayoutEdits lets any signed-in viewer (not just the owner) persist
+             *     changes to Layout. When false only the owner may save. */
             allow_layout_edits?: boolean;
             assigned_users?: string[];
             cameras?: string[];
-            /**
-             * @description DefaultViewingMode chooses which stream quality the wall loads with:
+            /** @description DefaultViewingMode chooses which stream quality the wall loads with:
              *     "preview" (SD) or "live" (HD). Empty defaults to "live". Always clamped
-             *     to "preview" when Liveview only grants preview permission.
-             */
+             *     to "preview" when Liveview only grants preview permission. */
             default_viewing_mode?: string;
             description?: string;
             expiration?: number;
@@ -36138,22 +37036,18 @@ export interface components {
             id?: string;
             io?: number;
             isActive?: number;
-            /**
-             * @description Layout stores a shareable custom arrangement of the wall's camera tiles
+            /** @description Layout stores a shareable custom arrangement of the wall's camera tiles
              *     (order + per-tile column/row spans). When nil the wall falls back to the
              *     default responsive grid. It travels with the wall so it is shared with
-             *     everyone the wall is shared with.
-             */
+             *     everyone the wall is shared with. */
             layout?: components["schemas"]["models.VideowallLayout"];
             liveview?: number;
             master_user_id?: string;
             name?: string;
             organisationId?: string;
             pass_code?: string;
-            /**
-             * @description ProjectId optionally places the videowall in a project within its
-             *     organisation. A nil value keeps it organisation-wide.
-             */
+            /** @description ProjectId optionally places the videowall in a project within its
+             *     organisation. A nil value keeps it organisation-wide. */
             projectId?: string;
             /** @description ForceMFA    int      `json:"force_mfa" bson:"force_mfa"` */
             ptz?: number;
@@ -36186,10 +37080,8 @@ export interface components {
             timezone?: string;
         };
         "models.Workflow": {
-            /**
-             * @description Audit carries bounded actor/timestamp metadata for database-backed user
-             *     workflows. It is omitted from Helm-defined global workflows unless set.
-             */
+            /** @description Audit carries bounded actor/timestamp metadata for database-backed user
+             *     workflows. It is omitted from Helm-defined global workflows unless set. */
             audit?: components["schemas"]["models.Audit"];
             createdAt?: number;
             description?: string;
@@ -36198,29 +37090,22 @@ export interface components {
             id?: string;
             name?: string;
             nodes?: components["schemas"]["models.WorkflowNode"][];
-            /**
-             * @description OrganisationId is the canonical tenant key. It is persisted as the
+            /** @description OrganisationId is the canonical tenant key. It is persisted as the
              *     camelCase `organisationId` field to match the platform-wide convention for
              *     organisation-owned domain resources. Database-backed workflows are not yet
              *     materially used in deployments, so new documents start with this canonical
-             *     contract while readers may retain a legacy `organisation_id` fallback.
-             */
+             *     contract while readers may retain a legacy `organisation_id` fallback. */
             organisationId?: string;
-            /**
-             * @description ProjectId optionally places the workflow in a project within its organisation.
-             *     A nil value keeps the workflow organisation-wide.
-             */
+            /** @description ProjectId optionally places the workflow in a project within its organisation.
+             *     A nil value keeps the workflow organisation-wide. */
             projectId?: string;
-            /**
-             * @description Source is the workflow's provenance and availability (see WorkflowSource).
+            /** @description Source is the workflow's provenance and availability (see WorkflowSource).
              *     Empty means WorkflowSourceUser: an ordinary user workflow scoped to its
              *     OrganisationId. WorkflowSourceConfig marks a Helm-defined, deployment-global,
              *     read-only workflow. Every workflow persisted before this field existed
-             *     decodes as user.
-             */
+             *     decodes as user. */
             source?: components["schemas"]["models.WorkflowSource"];
-            /**
-             * @description Stages is the workflow's executable stage set: the runtime-authoritative
+            /** @description Stages is the workflow's executable stage set: the runtime-authoritative
              *     projection the engine dispatches against. When set it is used as-is (config
              *     workflows author it directly in the helm registry form: operation, dispatch,
              *     needs, needsMode); when empty it is derived from Nodes+Edges on demand (UI
@@ -36230,23 +37115,18 @@ export interface components {
              *     Only the routing fields (Operation, Dispatch, Needs, NeedsMode) are
              *     meaningful here; a stage's deployment fields (image, queue, replicas, …) are
              *     resolved by Operation against the shared deployed catalog, not per workflow.
-             *     Operations need only be unique within a single workflow, not globally.
-             */
+             *     Operations need only be unique within a single workflow, not globally. */
             stages?: components["schemas"]["models.WorkflowStage"][];
-            /**
-             * @description Trigger is the legacy single-trigger field kept only so workflows persisted
+            /** @description Trigger is the legacy single-trigger field kept only so workflows persisted
              *     before Triggers existed still decode (and are not silently dropped on
              *     re-save). New code should read and write Triggers; call NormalizeTriggers to
              *     fold any legacy value into Triggers.
              *
-             *     Deprecated: use Triggers.
-             */
+             *     Deprecated: use Triggers. */
             trigger?: components["schemas"]["models.WorkflowTrigger"];
-            /**
-             * @description Triggers is the set of activation modes for this workflow. A workflow may
+            /** @description Triggers is the set of activation modes for this workflow. A workflow may
              *     carry both an automatic and a manual trigger so it runs on its own for
-             *     matching recordings and can also be launched on demand from a surface.
-             */
+             *     matching recordings and can also be launched on demand from a surface. */
             triggers?: components["schemas"]["models.WorkflowTrigger"][];
             updatedAt?: number;
             userId?: string;
@@ -36263,82 +37143,63 @@ export interface components {
             storageSolution?: string;
         };
         "models.WorkflowEdge": {
-            /**
-             * @description Condition is the structured predicate evaluated against the source stage's
+            /** @description Condition is the structured predicate evaluated against the source stage's
              *     result. Nil means the edge is an unconditional dependency. The edge is the
              *     authoring source of truth for routing: this Condition is what compiles into
              *     the target stage's Needs[].Condition (see WorkflowStage.Needs), which is the
-             *     derived runtime projection.
-             */
+             *     derived runtime projection. */
             condition?: components["schemas"]["models.StageCondition"];
             id?: string;
             source?: string;
-            /**
-             * @description SourcePort optionally selects which of the source stage's declared Outputs
+            /** @description SourcePort optionally selects which of the source stage's declared Outputs
              *     (see WorkflowStage.Outputs) this edge reads; Condition is evaluated against
-             *     that output's result. Empty means the stage's single implicit default port.
-             */
+             *     that output's result. Empty means the stage's single implicit default port. */
             sourcePort?: string;
             target?: string;
-            /**
-             * @description TargetPort optionally selects which of the target stage's declared Inputs
-             *     (see WorkflowStage.Inputs) this edge feeds. Empty means the default port.
-             */
+            /** @description TargetPort optionally selects which of the target stage's declared Inputs
+             *     (see WorkflowStage.Inputs) this edge feeds. Empty means the default port. */
             targetPort?: string;
         };
         "models.WorkflowNode": {
-            /**
-             * @description Data holds optional per-instance parameter values for this placement, keyed
+            /** @description Data holds optional per-instance parameter values for this placement, keyed
              *     by parameter name. They are validated against and defaulted from the
              *     referenced stage's declared Params (see WorkflowStage.Params), layered over
-             *     the stage's catalog defaults.
-             */
+             *     the stage's catalog defaults. */
             data?: {
                 [key: string]: unknown;
             };
-            /**
-             * @description Id is this instance's identity within the workflow. It is the stable
+            /** @description Id is this instance's identity within the workflow. It is the stable
              *     handle that edges connect to, and the per-instance runtime key when the
-             *     same stage is placed more than once.
-             */
+             *     same stage is placed more than once. */
             id?: string;
             label?: string;
-            /**
-             * @description StageRef is the referenced stage's Operation key (the catalog key shared
+            /** @description StageRef is the referenced stage's Operation key (the catalog key shared
              *     by platform- and user-defined stages), not its Mongo Id. Always set:
-             *     every node is an instance of a catalog stage, resolved at compile time.
-             */
+             *     every node is an instance of a catalog stage, resolved at compile time. */
             stageRef?: string;
             x?: number;
             y?: number;
         };
         "models.WorkflowRun": {
-            /**
-             * @description Device identifies the recording the run derives from, with the few fields
+            /** @description Device identifies the recording the run derives from, with the few fields
              *     vault-override resolution and logging need (device key/name and where the
              *     media is stored/served from). Copied from the recording at hand-off time.
-             *     Wire-only.
-             */
+             *     Wire-only. */
             device?: components["schemas"]["models.WorkflowDevice"];
-            /**
-             * @description Inputs is the immutable start context the run opens with, keyed by the
+            /** @description Inputs is the immutable start context the run opens with, keyed by the
              *     upstream operation that produced it (e.g. "classify" → the classification
              *     result). Conditions and stages read upstream context from here; it is set
              *     once by analysis and never mutated by the run. Persisted at open so a run
-             *     reloaded mid-flight still sees its start context.
-             */
+             *     reloaded mid-flight still sees its start context. */
             inputs?: {
                 [key: string]: unknown;
             };
-            /**
-             * @description Key is the media key the run is about. It is copied from the recording at
+            /** @description Key is the media key the run is about. It is copied from the recording at
              *     hand-off time and can group all runs for that recording, but is not unique:
              *     run state is correlated by Id/RunId because several workflows and manual
-             *     re-runs may execute over the same key.
-             */
+             *     re-runs may execute over the same key. */
             key?: string;
-            /**
-             * @description Operation marks the message's role on the workflows queue (wire-only):
+            /** @description Operation marks the message's role on the workflows queue (wire-only):
              *       - "event": a fresh run hand-off from analysis. It opens the run and
              *         carries the start context in Inputs (e.g. the classification result).
              *       - any other value (e.g. "anpr"): either the engine dispatching that
@@ -36346,21 +37207,17 @@ export interface components {
              *         result back (Payload or Results populated). These never collide because the
              *         workflows queue only ever carries the "event" open and worker results —
              *         a dispatch goes to the worker's own queue — so the engine never has to
-             *         disambiguate a dispatch from a result.
-             */
+             *         disambiguate a dispatch from a result. */
             operation?: string;
-            /**
-             * @description Origin records how this run was opened — the run-side counterpart of the
+            /** @description Origin records how this run was opened — the run-side counterpart of the
              *     Workflow's trigger Type. An automatic run was teed off the pipeline by
              *     analysis for a matching recording; a manual run was launched on demand by a
              *     user from a surface. The engine reads it to skip automatic selection/time
              *     gating for on-demand runs; it is persisted so "all runs for a media key" can
              *     be filtered by how they started. Empty is treated as automatic for runs
-             *     opened before origins existed.
-             */
+             *     opened before origins existed. */
             origin?: components["schemas"]["models.WorkflowRunOrigin"];
-            /**
-             * @description Payload is the self-describing block envelope a delegated-ingest worker
+            /** @description Payload is the self-describing block envelope a delegated-ingest worker
              *     hands back for the platform to persist: one or more typed blocks (e.g. a
              *     "detection" block carrying a PostDetectionsRequest, optionally followed by
              *     "marker" blocks). It is the channel the shared ingest core reads from,
@@ -36385,11 +37242,9 @@ export interface components {
              *
              *     `bson:"-"` is load-bearing: the raw body is ingested into its own
              *     collection, never duplicated into the run's persisted state. The engine
-             *     never sets it on an outbound dispatch, so it never travels engine → worker.
-             */
+             *     never sets it on an outbound dispatch, so it never travels engine → worker. */
             payload?: number[];
-            /**
-             * @description RecordingTimestamp is the recording's start time (unix seconds), copied
+            /** @description RecordingTimestamp is the recording's start time (unix seconds), copied
              *     from the recording at hand-off time. It is denormalised onto any platform
              *     artifact the engine ingests (see Payload) so cleanup expires the artifact
              *     on the recording's retention clock rather than the post time. It is set on
@@ -36397,21 +37252,17 @@ export interface components {
              *     reads it from the run document when stamping an ingested artifact. It is
              *     therefore engine-internal — NOT sent on the engine→worker dispatch and not
              *     something a worker has to echo back, so it is not part of the stage
-             *     contract.
-             */
+             *     contract. */
             recordingTimestamp?: number;
-            /**
-             * @description Results is the run's accumulated stage outputs, keyed by operation. Each
+            /** @description Results is the run's accumulated stage outputs, keyed by operation. Each
              *     stage worker writes its result under its operation on the way back, and
              *     conditions / downstream stages read upstream outputs from here. It grows
              *     as the run progresses; the engine records each result into it. Together
-             *     with Inputs it is the durable condition bag (Results wins on any overlap).
-             */
+             *     with Inputs it is the durable condition bag (Results wins on any overlap). */
             results?: {
                 [key: string]: unknown;
             };
-            /**
-             * @description RunId is the run's identifier on the wire (the hex of the document Id). It
+            /** @description RunId is the run's identifier on the wire (the hex of the document Id). It
              *     is empty on an untargeted analysis hand-off; after workflow matching, the
              *     engine derives a distinct document identity per recording, organisation,
              *     and workflow. It is set on every engine→worker dispatch. The persisted
@@ -36421,11 +37272,9 @@ export interface components {
              *     has been opened (its _id is set) is serialized, so a producer only has to
              *     stamp Id and the two representations can never drift. A run without an Id
              *     yet (the analysis hand-off) keeps whatever RunId it was given (normally
-             *     empty, so runId is omitted).
-             */
+             *     empty, so runId is omitted). */
             runId?: string;
-            /**
-             * @description SignedURL is a vault-signed, short-lived URL (HMAC signature + TTL) a
+            /** @description SignedURL is a vault-signed, short-lived URL (HMAC signature + TTL) a
              *     dispatched stage worker can use to fetch the run's media directly, instead
              *     of constructing the request from the raw Storage credentials. It is the
              *     signed URL the upstream pipeline already holds for the recording (the same
@@ -36433,19 +37282,15 @@ export interface components {
              *     analysis hand-off and carried on the engine→worker dispatch alongside
              *     Storage. `bson:"-"` is load-bearing: a signed URL is credential-equivalent
              *     and short-lived, so — like Storage — it is wire-only and never lands in the
-             *     run's persisted state; a stage dispatched after a reload fetches via Storage.
-             */
+             *     run's persisted state; a stage dispatched after a reload fetches via Storage. */
             signedUrl?: string;
-            /**
-             * @description SourceRef ties a manual run back to the thing it was launched from — e.g.
+            /** @description SourceRef ties a manual run back to the thing it was launched from — e.g.
              *     the case id when launched from a case surface — so sibling runs fanned out
              *     from one user action (one seed per selected media key) can be grouped above
              *     the run. Empty for automatic runs. It generalises to any run-grouping handle
-             *     (a case id today; a temporal device-series id is a forward-looking twin).
-             */
+             *     (a case id today; a temporal device-series id is a forward-looking twin). */
             sourceRef?: string;
-            /**
-             * @description Stages is the run's self-describing routing: the compiled stage set of the
+            /** @description Stages is the run's self-describing routing: the compiled stage set of the
              *     workflow this run executes (the output of Workflow.CompileStages) embedded
              *     on the hand-off so the engine can dispatch a workflow it does not hold in
              *     its boot-loaded config registry — a user/DB workflow launched manually.
@@ -36455,41 +37300,32 @@ export interface components {
              *     legacy/config path: the engine falls back to the config registry keyed by
              *     WorkflowId, so config workflows and older hand-offs are unchanged. It is
              *     persisted so the return path — a stage result reopening the run on any
-             *     replica — resolves the same routing without re-fetching the definition.
-             */
+             *     replica — resolves the same routing without re-fetching the definition. */
             stages?: components["schemas"]["models.WorkflowStage"][];
-            /**
-             * @description Storage carries the credentials a dispatched stage worker needs to fetch
+            /** @description Storage carries the credentials a dispatched stage worker needs to fetch
              *     the media (global Kerberos Storage plus any resolved per-recording vault
              *     override). It is populated by the engine only on the engine→worker
              *     dispatch hop and is empty on the analysis hand-off and the worker→engine
              *     result. `bson:"-"` is load-bearing: credentials never sit in the run's
-             *     persisted state.
-             */
+             *     persisted state. */
             storage?: components["schemas"]["models.WorkflowStorage"];
             /** @description TraceId continues the distributed trace across the workflow tail. */
             traceId?: string;
-            /**
-             * @description User is the curated, secret-free account context a run needs: the
+            /** @description User is the curated, secret-free account context a run needs: the
              *     organisation that owns the recording (for logging/scoping) and the account
              *     Storage block used to resolve a per-recording vault override. Copied (and
              *     scrubbed) from the analysis monitor stage — credential/secret fields and the
              *     individual user id never cross the boundary. Wire-only; the persisted scope
-             *     is OrganisationId.
-             */
+             *     is OrganisationId. */
             user?: components["schemas"]["models.WorkflowUser"];
-            /**
-             * @description WorkflowId is the id of the Workflow definition (models.Workflow) this run
+            /** @description WorkflowId is the id of the Workflow definition (models.Workflow) this run
              *     executes — the authored graph (nodes/edges/triggers) the run is an execution
              *     of. It is empty only on an untargeted analysis hand-off; the engine stamps it
-             *     as it fans that recording out to each matching config or database workflow.
-             */
+             *     as it fans that recording out to each matching config or database workflow. */
             workflowId?: string;
-            /**
-             * @description WorkflowName is the human-readable name of that Workflow, carried so a
+            /** @description WorkflowName is the human-readable name of that Workflow, carried so a
              *     dispatch/result is legible in worker context and logs without a lookup.
-             *     Populated alongside WorkflowId.
-             */
+             *     Populated alongside WorkflowId. */
             workflowName?: string;
         };
         /** @enum {string} */
@@ -36499,55 +37335,44 @@ export interface components {
         "models.WorkflowStage": {
             /** @description Description explains what the stage does, for the catalog UI. */
             description?: string;
-            /**
-             * @description Dispatch is when the stage runs: DispatchAlways or DispatchConditional (the
+            /** @description Dispatch is when the stage runs: DispatchAlways or DispatchConditional (the
              *     closed Dispatch enum). Empty defaults to DispatchAlways. For a user
              *     workflow it is derived from the graph's edges (conditional when the node has
-             *     at least one incoming edge); see the Routing note above.
-             */
+             *     at least one incoming edge); see the Routing note above. */
             dispatch?: components["schemas"]["models.Dispatch"];
             /** @description Env is extra environment passed to the stage's workers. */
             env?: {
                 [key: string]: string;
             };
-            /**
-             * @description Id is the catalog entry's Mongo id for user-defined stages. It is empty
-             *     for platform-defined stages supplied via the runtime registry.
-             */
+            /** @description Id is the catalog entry's Mongo id for user-defined stages. It is empty
+             *     for platform-defined stages supplied via the runtime registry. */
             id?: string;
-            /**
-             * @description Inputs and Outputs declare the stage's named ports — the connection points
+            /** @description Inputs and Outputs declare the stage's named ports — the connection points
              *     workflow edges attach to (WorkflowEdge.TargetPort / SourcePort). Empty means
-             *     a single implicit default port.
-             */
+             *     a single implicit default port. */
             inputs?: components["schemas"]["models.StagePort"][];
             /** @description LogLevel is the worker log verbosity (trace | debug | info | warn | error). */
             logLevel?: string;
             /** @description Name is a human-friendly catalog name shown in the stage library. */
             name?: string;
-            /**
-             * @description Needs lists the dependencies of a conditional stage — its fan-in. It is the
+            /** @description Needs lists the dependencies of a conditional stage — its fan-in. It is the
              *     compiled, runtime-authoritative projection of the workflow's incoming edges
              *     (one entry per edge), not an independently editable field. At least one
              *     entry is required when Dispatch is DispatchConditional; ignored otherwise.
              *     The runtime re-evaluates the stage against the run root whenever the run
              *     progresses; each need's Operation gates when its Condition may be read (an
              *     empty Operation is ungated, evaluated at open) and the stage fires for the
-             *     first need whose Condition matches (a nil Condition matches unconditionally).
-             */
+             *     first need whose Condition matches (a nil Condition matches unconditionally). */
             needs?: components["schemas"]["models.StageDependency"][];
-            /**
-             * @description NeedsMode controls how multiple Needs combine into a dispatch decision:
+            /** @description NeedsMode controls how multiple Needs combine into a dispatch decision:
              *     NeedsModeAny (the default) fires the stage as soon as one need is satisfied
              *     (its gate operation available and its condition matching); NeedsModeAll
              *     fires the stage only once every need is satisfied (a join). It is
              *     meaningful only when Dispatch is DispatchConditional and there is more than
              *     one need; with a single need both modes behave identically. Empty defaults
-             *     to NeedsModeAny.
-             */
+             *     to NeedsModeAny. */
             needsMode?: components["schemas"]["models.NeedsMode"];
-            /**
-             * @description Operation uniquely identifies the stage and binds its queue, dispatch and
+            /** @description Operation uniquely identifies the stage and binds its queue, dispatch and
              *     resolution. It is the key workflow nodes reference, and the key under which
              *     the stage's result is filed in a run's Inputs/Results. Two stages may never
              *     share an operation.
@@ -36562,22 +37387,17 @@ export interface components {
              *     (e.g. "classify"), which seeds Inputs and can gate a need or be read by a
              *     condition, yet is not itself a deployed stage. That is why routing —
              *     Needs/gates, conditions, and the run's dispatched/resolved tiers — is keyed
-             *     by operation (the wider id space), while deployment talks in stages.
-             */
+             *     by operation (the wider id space), while deployment talks in stages. */
             operation?: string;
             outputs?: components["schemas"]["models.StagePort"][];
-            /**
-             * @description Params declares the configurable parameters this stage accepts. A node's
+            /** @description Params declares the configurable parameters this stage accepts. A node's
              *     Data is validated against and defaulted from these (see WorkflowNode.Data);
-             *     empty means the stage takes no parameters.
-             */
+             *     empty means the stage takes no parameters. */
             params?: components["schemas"]["models.StageParam"][];
             /** @description PullPolicy is the image pull policy (e.g. "IfNotPresent", "Always"). */
             pullPolicy?: string;
-            /**
-             * @description Queue is the queue the stage's workers consume from. Defaults to a name
-             *     derived from Operation when empty.
-             */
+            /** @description Queue is the queue the stage's workers consume from. Defaults to a name
+             *     derived from Operation when empty. */
             queue?: string;
             /** @description Replicas is the desired number of worker pods for the stage. */
             replicas?: number;
@@ -36598,18 +37418,15 @@ export interface components {
             vaultOverrideUri?: string;
         };
         "models.WorkflowTrigger": {
-            /**
-             * @description Conditions further scopes the automatic trigger with the same structured
+            /** @description Conditions further scopes the automatic trigger with the same structured
              *     (path, op, value) predicates a stage uses, evaluated against the pre-run
              *     envelope (device.*, user.*, and the identity scalars known when a recording
              *     arrives). All conditions must hold (AND) and they combine with the compiled
              *     Devices shorthand, so `matches`, `in`, `eq`, … apply to device matching the
              *     way they do to stages. An empty list adds no constraint. See
-             *     CompiledConditions and StageCondition.
-             */
+             *     CompiledConditions and StageCondition. */
             conditions?: components["schemas"]["models.StageCondition"][];
-            /**
-             * @description Devices restricts the automatic trigger to recordings from the listed
+            /** @description Devices restricts the automatic trigger to recordings from the listed
              *     devices, matched by DeviceKey.Key. An empty list means every device is
              *     eligible. Mirrors the alert device selection (see CustomAlert.DevicesList).
              *
@@ -36617,28 +37434,21 @@ export interface components {
              *     CompiledConditions) into a single StageCondition — device.deviceKey `in`
              *     [keys…] — evaluated by the same operator engine stage conditions use, so
              *     device scoping and stage matching stay consistent. Author richer scoping
-             *     (a device-name pattern, an organisation check, …) with Conditions.
-             */
+             *     (a device-name pattern, an organisation check, …) with Conditions. */
             devices?: components["schemas"]["models.DeviceKey"][];
-            /**
-             * @description Surfaces lists the UI surfaces a manual trigger can be launched from
-             *     (manual). Ignored for automatic triggers.
-             */
+            /** @description Surfaces lists the UI surfaces a manual trigger can be launched from
+             *     (manual). Ignored for automatic triggers. */
             surfaces?: components["schemas"]["models.WorkflowTriggerSurface"][];
-            /**
-             * @description Type is the activation mode. An empty Type is treated as
+            /** @description Type is the activation mode. An empty Type is treated as
              *     WorkflowTriggerAutomatic for backwards compatibility with triggers authored
-             *     before manual triggers existed.
-             */
+             *     before manual triggers existed. */
             type?: components["schemas"]["models.WorkflowTriggerType"];
-            /**
-             * @description WeeklySchedule bounds the automatic trigger to recurring weekly windows,
+            /** @description WeeklySchedule bounds the automatic trigger to recurring weekly windows,
              *     each with its own day, time segments and IANA Timezone. An empty schedule
              *     means any time is eligible. Reuses the alert weekly-schedule shape so the
              *     same editor and evaluation semantics apply. The Timezone on each entry is
              *     the user's timezone captured when the schedule was authored. Time is not
-             *     path-expressible, so it stays a dedicated field rather than a condition.
-             */
+             *     path-expressible, so it stays a dedicated field rather than a condition. */
             weeklySchedule?: components["schemas"]["models.WeeklySchedule"][];
         };
         /** @enum {string} */
@@ -36683,8 +37493,11 @@ export declare namespace models {
     type AnalyticsLists = components['schemas']['models.AnalyticsLists'];
     type AnalyticsSummary = components['schemas']['models.AnalyticsSummary'];
     type Audit = components['schemas']['models.Audit'];
+    type AuditAuthorizationInfo = components['schemas']['models.AuditAuthorizationInfo'];
     type AuditEvent = components['schemas']['models.AuditEvent'];
+    type AuditEventStatus = components['schemas']['models.AuditEventStatus'];
     type AuditFieldChange = components['schemas']['models.AuditFieldChange'];
+    type AuditRequestInfo = components['schemas']['models.AuditRequestInfo'];
     type CameraMetadata = components['schemas']['models.CameraMetadata'];
     type CameraPreset = components['schemas']['models.CameraPreset'];
     type CameraTour = components['schemas']['models.CameraTour'];
@@ -36716,6 +37529,8 @@ export declare namespace models {
     type CreateCaseShareOutput = components['schemas']['models.CreateCaseShareOutput'];
     type CreateOrganisationInput = components['schemas']['models.CreateOrganisationInput'];
     type CreateOrganisationOutput = components['schemas']['models.CreateOrganisationOutput'];
+    type CreateProjectInput = components['schemas']['models.CreateProjectInput'];
+    type CreateProjectOutput = components['schemas']['models.CreateProjectOutput'];
     type CreateVideowallInput = components['schemas']['models.CreateVideowallInput'];
     type CreateVideowallOutput = components['schemas']['models.CreateVideowallOutput'];
     type CreateWorkflowInput = components['schemas']['models.CreateWorkflowInput'];
@@ -36727,6 +37542,8 @@ export declare namespace models {
     type DateRangeSchedule = components['schemas']['models.DateRangeSchedule'];
     type DayTimeRange = components['schemas']['models.DayTimeRange'];
     type DeleteCaseShareInput = components['schemas']['models.DeleteCaseShareInput'];
+    type DeleteProjectInput = components['schemas']['models.DeleteProjectInput'];
+    type DeleteProjectOutput = components['schemas']['models.DeleteProjectOutput'];
     type DeleteVideowallInput = components['schemas']['models.DeleteVideowallInput'];
     type DeleteWorkflowInput = components['schemas']['models.DeleteWorkflowInput'];
     type DeleteWorkflowStageInput = components['schemas']['models.DeleteWorkflowStageInput'];
@@ -36775,6 +37592,8 @@ export declare namespace models {
     type GetOrganisationOutput = components['schemas']['models.GetOrganisationOutput'];
     type GetOrganisationsInput = components['schemas']['models.GetOrganisationsInput'];
     type GetOrganisationsOutput = components['schemas']['models.GetOrganisationsOutput'];
+    type GetProjectInput = components['schemas']['models.GetProjectInput'];
+    type GetProjectOutput = components['schemas']['models.GetProjectOutput'];
     type GetProjectsInput = components['schemas']['models.GetProjectsInput'];
     type GetProjectsOutput = components['schemas']['models.GetProjectsOutput'];
     type GetVideowallInput = components['schemas']['models.GetVideowallInput'];
@@ -36857,10 +37676,12 @@ export declare namespace models {
     type PipelineMetadata = components['schemas']['models.PipelineMetadata'];
     type PipelineMetrics = components['schemas']['models.PipelineMetrics'];
     type PipelinePayload = components['schemas']['models.PipelinePayload'];
+    type PipelineSourceDevice = components['schemas']['models.PipelineSourceDevice'];
     type Plan = components['schemas']['models.Plan'];
     type Point = components['schemas']['models.Point'];
     type ProfileSettings = components['schemas']['models.ProfileSettings'];
     type Project = components['schemas']['models.Project'];
+    type ProjectUpdate = components['schemas']['models.ProjectUpdate'];
     type Pushbullet = components['schemas']['models.Pushbullet'];
     type Pushover = components['schemas']['models.Pushover'];
     type Region = components['schemas']['models.Region'];
@@ -36914,6 +37735,8 @@ export declare namespace models {
     type UpdateCaseShareOTPInput = components['schemas']['models.UpdateCaseShareOTPInput'];
     type UpdateOrganisationInput = components['schemas']['models.UpdateOrganisationInput'];
     type UpdateOrganisationOutput = components['schemas']['models.UpdateOrganisationOutput'];
+    type UpdateProjectInput = components['schemas']['models.UpdateProjectInput'];
+    type UpdateProjectOutput = components['schemas']['models.UpdateProjectOutput'];
     type UpdateVideowallInput = components['schemas']['models.UpdateVideowallInput'];
     type UpdateVideowallOutput = components['schemas']['models.UpdateVideowallOutput'];
     type UpdateWorkflowInput = components['schemas']['models.UpdateWorkflowInput'];
@@ -36991,6 +37814,10 @@ export declare namespace api {
     type CreateOrganisationRequest = components['schemas']['api.CreateOrganisationRequest'];
     type CreateOrganisationResponse = components['schemas']['api.CreateOrganisationResponse'];
     type CreateOrganisationSuccessResponse = components['schemas']['api.CreateOrganisationSuccessResponse'];
+    type CreateProjectErrorResponse = components['schemas']['api.CreateProjectErrorResponse'];
+    type CreateProjectRequest = components['schemas']['api.CreateProjectRequest'];
+    type CreateProjectResponse = components['schemas']['api.CreateProjectResponse'];
+    type CreateProjectSuccessResponse = components['schemas']['api.CreateProjectSuccessResponse'];
     type CreateVideowallErrorResponse = components['schemas']['api.CreateVideowallErrorResponse'];
     type CreateVideowallRequest = components['schemas']['api.CreateVideowallRequest'];
     type CreateVideowallResponse = components['schemas']['api.CreateVideowallResponse'];
@@ -37009,6 +37836,9 @@ export declare namespace api {
     type DeleteDetectionRunErrorResponse = components['schemas']['api.DeleteDetectionRunErrorResponse'];
     type DeleteDetectionRunResponse = components['schemas']['api.DeleteDetectionRunResponse'];
     type DeleteDetectionRunSuccessResponse = components['schemas']['api.DeleteDetectionRunSuccessResponse'];
+    type DeleteProjectErrorResponse = components['schemas']['api.DeleteProjectErrorResponse'];
+    type DeleteProjectResponse = components['schemas']['api.DeleteProjectResponse'];
+    type DeleteProjectSuccessResponse = components['schemas']['api.DeleteProjectSuccessResponse'];
     type DeleteStateErrorResponse = components['schemas']['api.DeleteStateErrorResponse'];
     type DeleteStateSuccessResponse = components['schemas']['api.DeleteStateSuccessResponse'];
     type DeleteTaskCommentErrorResponse = components['schemas']['api.DeleteTaskCommentErrorResponse'];
@@ -37342,6 +38172,10 @@ export declare namespace api {
     type UpdateOrganisationRequest = components['schemas']['api.UpdateOrganisationRequest'];
     type UpdateOrganisationResponse = components['schemas']['api.UpdateOrganisationResponse'];
     type UpdateOrganisationSuccessResponse = components['schemas']['api.UpdateOrganisationSuccessResponse'];
+    type UpdateProjectErrorResponse = components['schemas']['api.UpdateProjectErrorResponse'];
+    type UpdateProjectRequest = components['schemas']['api.UpdateProjectRequest'];
+    type UpdateProjectResponse = components['schemas']['api.UpdateProjectResponse'];
+    type UpdateProjectSuccessResponse = components['schemas']['api.UpdateProjectSuccessResponse'];
     type UpdateUserProfileErrorResponse = components['schemas']['api.UpdateUserProfileErrorResponse'];
     type UpdateUserProfileResponse = components['schemas']['api.UpdateUserProfileResponse'];
     type UpdateUserProfileSuccessResponse = components['schemas']['api.UpdateUserProfileSuccessResponse'];