@uug-ai/models 1.5.10 → 1.6.2

package/dist/types.d.ts

@@ -1680,6 +1680,396 @@ export interface paths {
         patch?: never;
         trace?: never;
     };
+    "/internal/anprbox": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        /**
+         * Get ANPRBox (schema generation only)
+         * @description Internal endpoint used only to ensure ANPRBox 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.ANPRBox"];
+                    };
+                };
+            };
+        };
+        put?: never;
+        post?: never;
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/internal/anprcandidate": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        /**
+         * Get ANPRCandidate (schema generation only)
+         * @description Internal endpoint used only to ensure ANPRCandidate 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.ANPRCandidate"];
+                    };
+                };
+            };
+        };
+        put?: never;
+        post?: never;
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/internal/anprcandidateinput": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        /**
+         * Get ANPRCandidateInput (schema generation only)
+         * @description Internal endpoint used only to ensure ANPRCandidateInput 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.ANPRCandidateInput"];
+                    };
+                };
+            };
+        };
+        put?: never;
+        post?: never;
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/internal/anprmedia": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        /**
+         * Get ANPRMedia (schema generation only)
+         * @description Internal endpoint used only to ensure ANPRMedia 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.ANPRMedia"];
+                    };
+                };
+            };
+        };
+        put?: never;
+        post?: never;
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/internal/anprmediainput": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        /**
+         * Get ANPRMediaInput (schema generation only)
+         * @description Internal endpoint used only to ensure ANPRMediaInput 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.ANPRMediaInput"];
+                    };
+                };
+            };
+        };
+        put?: never;
+        post?: never;
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/internal/anprplate": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        /**
+         * Get ANPRPlate (schema generation only)
+         * @description Internal endpoint used only to ensure ANPRPlate 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.ANPRPlate"];
+                    };
+                };
+            };
+        };
+        put?: never;
+        post?: never;
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/internal/anprplateinput": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        /**
+         * Get ANPRPlateInput (schema generation only)
+         * @description Internal endpoint used only to ensure ANPRPlateInput 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.ANPRPlateInput"];
+                    };
+                };
+            };
+        };
+        put?: never;
+        post?: never;
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/internal/anprrejection": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        /**
+         * Get ANPRRejection (schema generation only)
+         * @description Internal endpoint used only to ensure ANPRRejection 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.ANPRRejection"];
+                    };
+                };
+            };
+        };
+        put?: never;
+        post?: never;
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/internal/anprrun": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        /**
+         * Get ANPRRun (schema generation only)
+         * @description Internal endpoint used only to ensure ANPRRun 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.ANPRRun"];
+                    };
+                };
+            };
+        };
+        put?: never;
+        post?: never;
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/internal/anprsource": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        /**
+         * Get ANPRSource (schema generation only)
+         * @description Internal endpoint used only to ensure ANPRSource 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.ANPRSource"];
+                    };
+                };
+            };
+        };
+        put?: never;
+        post?: never;
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
     "/internal/audit": {
         parameters: {
             query?: never;
@@ -18398,7 +18788,163 @@ export interface paths {
                         [name: string]: unknown;
                     };
                     content: {
-                        "application/json": components["schemas"]["models.OrganisationUserDetails"];
+                        "application/json": components["schemas"]["models.OrganisationUserDetails"];
+                    };
+                };
+            };
+        };
+        put?: never;
+        post?: never;
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/internal/panicresponse": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        /**
+         * Get PanicResponse (schema generation only)
+         * @description Internal endpoint used only to ensure PanicResponse 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.PanicResponse"];
+                    };
+                };
+            };
+        };
+        put?: never;
+        post?: never;
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/internal/patchvideowallerrorresponse": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        /**
+         * Get PatchVideowallErrorResponse (schema generation only)
+         * @description Internal endpoint used only to ensure PatchVideowallErrorResponse 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.PatchVideowallErrorResponse"];
+                    };
+                };
+            };
+        };
+        put?: never;
+        post?: never;
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/internal/patchvideowallinput": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        /**
+         * Get PatchVideowallInput (schema generation only)
+         * @description Internal endpoint used only to ensure PatchVideowallInput 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.PatchVideowallInput"];
+                    };
+                };
+            };
+        };
+        put?: never;
+        post?: never;
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/internal/patchvideowalloutput": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        /**
+         * Get PatchVideowallOutput (schema generation only)
+         * @description Internal endpoint used only to ensure PatchVideowallOutput 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.PatchVideowallOutput"];
                     };
                 };
             };
@@ -18411,7 +18957,7 @@ export interface paths {
         patch?: never;
         trace?: never;
     };
-    "/internal/panicresponse": {
+    "/internal/patchvideowallrequest": {
         parameters: {
             query?: never;
             header?: never;
@@ -18419,8 +18965,8 @@ export interface paths {
             cookie?: never;
         };
         /**
-         * Get PanicResponse (schema generation only)
-         * @description Internal endpoint used only to ensure PanicResponse schema is generated in OpenAPI spec
+         * Get PatchVideowallRequest (schema generation only)
+         * @description Internal endpoint used only to ensure PatchVideowallRequest schema is generated in OpenAPI spec
          */
         get: {
             parameters: {
@@ -18437,7 +18983,7 @@ export interface paths {
                         [name: string]: unknown;
                     };
                     content: {
-                        "application/json": components["schemas"]["api.PanicResponse"];
+                        "application/json": components["schemas"]["api.PatchVideowallRequest"];
                     };
                 };
             };
@@ -18450,7 +18996,7 @@ export interface paths {
         patch?: never;
         trace?: never;
     };
-    "/internal/patchvideowallerrorresponse": {
+    "/internal/patchvideowallresponse": {
         parameters: {
             query?: never;
             header?: never;
@@ -18458,8 +19004,8 @@ export interface paths {
             cookie?: never;
         };
         /**
-         * Get PatchVideowallErrorResponse (schema generation only)
-         * @description Internal endpoint used only to ensure PatchVideowallErrorResponse schema is generated in OpenAPI spec
+         * Get PatchVideowallResponse (schema generation only)
+         * @description Internal endpoint used only to ensure PatchVideowallResponse schema is generated in OpenAPI spec
          */
         get: {
             parameters: {
@@ -18476,7 +19022,7 @@ export interface paths {
                         [name: string]: unknown;
                     };
                     content: {
-                        "application/json": components["schemas"]["api.PatchVideowallErrorResponse"];
+                        "application/json": components["schemas"]["api.PatchVideowallResponse"];
                     };
                 };
             };
@@ -18489,7 +19035,7 @@ export interface paths {
         patch?: never;
         trace?: never;
     };
-    "/internal/patchvideowallinput": {
+    "/internal/patchvideowallsuccessresponse": {
         parameters: {
             query?: never;
             header?: never;
@@ -18497,8 +19043,8 @@ export interface paths {
             cookie?: never;
         };
         /**
-         * Get PatchVideowallInput (schema generation only)
-         * @description Internal endpoint used only to ensure PatchVideowallInput schema is generated in OpenAPI spec
+         * Get PatchVideowallSuccessResponse (schema generation only)
+         * @description Internal endpoint used only to ensure PatchVideowallSuccessResponse schema is generated in OpenAPI spec
          */
         get: {
             parameters: {
@@ -18515,7 +19061,7 @@ export interface paths {
                         [name: string]: unknown;
                     };
                     content: {
-                        "application/json": components["schemas"]["models.PatchVideowallInput"];
+                        "application/json": components["schemas"]["api.PatchVideowallSuccessResponse"];
                     };
                 };
             };
@@ -18528,7 +19074,7 @@ export interface paths {
         patch?: never;
         trace?: never;
     };
-    "/internal/patchvideowalloutput": {
+    "/internal/permissions": {
         parameters: {
             query?: never;
             header?: never;
@@ -18536,8 +19082,8 @@ export interface paths {
             cookie?: never;
         };
         /**
-         * Get PatchVideowallOutput (schema generation only)
-         * @description Internal endpoint used only to ensure PatchVideowallOutput schema is generated in OpenAPI spec
+         * Get Permissions (schema generation only)
+         * @description Internal endpoint used only to ensure Permissions schema is generated in OpenAPI spec
          */
         get: {
             parameters: {
@@ -18554,7 +19100,7 @@ export interface paths {
                         [name: string]: unknown;
                     };
                     content: {
-                        "application/json": components["schemas"]["models.PatchVideowallOutput"];
+                        "application/json": components["schemas"]["models.Permissions"];
                     };
                 };
             };
@@ -18567,7 +19113,7 @@ export interface paths {
         patch?: never;
         trace?: never;
     };
-    "/internal/patchvideowallrequest": {
+    "/internal/pipelineevent": {
         parameters: {
             query?: never;
             header?: never;
@@ -18575,8 +19121,8 @@ export interface paths {
             cookie?: never;
         };
         /**
-         * Get PatchVideowallRequest (schema generation only)
-         * @description Internal endpoint used only to ensure PatchVideowallRequest schema is generated in OpenAPI spec
+         * Get PipelineEvent (schema generation only)
+         * @description Internal endpoint used only to ensure PipelineEvent schema is generated in OpenAPI spec
          */
         get: {
             parameters: {
@@ -18593,7 +19139,7 @@ export interface paths {
                         [name: string]: unknown;
                     };
                     content: {
-                        "application/json": components["schemas"]["api.PatchVideowallRequest"];
+                        "application/json": components["schemas"]["models.PipelineEvent"];
                     };
                 };
             };
@@ -18606,7 +19152,7 @@ export interface paths {
         patch?: never;
         trace?: never;
     };
-    "/internal/patchvideowallresponse": {
+    "/internal/pipelinemetadata": {
         parameters: {
             query?: never;
             header?: never;
@@ -18614,8 +19160,8 @@ export interface paths {
             cookie?: never;
         };
         /**
-         * Get PatchVideowallResponse (schema generation only)
-         * @description Internal endpoint used only to ensure PatchVideowallResponse schema is generated in OpenAPI spec
+         * Get PipelineMetadata (schema generation only)
+         * @description Internal endpoint used only to ensure PipelineMetadata schema is generated in OpenAPI spec
          */
         get: {
             parameters: {
@@ -18632,7 +19178,7 @@ export interface paths {
                         [name: string]: unknown;
                     };
                     content: {
-                        "application/json": components["schemas"]["api.PatchVideowallResponse"];
+                        "application/json": components["schemas"]["models.PipelineMetadata"];
                     };
                 };
             };
@@ -18645,7 +19191,7 @@ export interface paths {
         patch?: never;
         trace?: never;
     };
-    "/internal/patchvideowallsuccessresponse": {
+    "/internal/pipelinemetrics": {
         parameters: {
             query?: never;
             header?: never;
@@ -18653,8 +19199,8 @@ export interface paths {
             cookie?: never;
         };
         /**
-         * Get PatchVideowallSuccessResponse (schema generation only)
-         * @description Internal endpoint used only to ensure PatchVideowallSuccessResponse schema is generated in OpenAPI spec
+         * Get PipelineMetrics (schema generation only)
+         * @description Internal endpoint used only to ensure PipelineMetrics schema is generated in OpenAPI spec
          */
         get: {
             parameters: {
@@ -18671,7 +19217,7 @@ export interface paths {
                         [name: string]: unknown;
                     };
                     content: {
-                        "application/json": components["schemas"]["api.PatchVideowallSuccessResponse"];
+                        "application/json": components["schemas"]["models.PipelineMetrics"];
                     };
                 };
             };
@@ -18684,7 +19230,7 @@ export interface paths {
         patch?: never;
         trace?: never;
     };
-    "/internal/permissions": {
+    "/internal/pipelinepayload": {
         parameters: {
             query?: never;
             header?: never;
@@ -18692,8 +19238,8 @@ export interface paths {
             cookie?: never;
         };
         /**
-         * Get Permissions (schema generation only)
-         * @description Internal endpoint used only to ensure Permissions schema is generated in OpenAPI spec
+         * Get PipelinePayload (schema generation only)
+         * @description Internal endpoint used only to ensure PipelinePayload schema is generated in OpenAPI spec
          */
         get: {
             parameters: {
@@ -18710,7 +19256,7 @@ export interface paths {
                         [name: string]: unknown;
                     };
                     content: {
-                        "application/json": components["schemas"]["models.Permissions"];
+                        "application/json": components["schemas"]["models.PipelinePayload"];
                     };
                 };
             };
@@ -18723,7 +19269,7 @@ export interface paths {
         patch?: never;
         trace?: never;
     };
-    "/internal/pipelineevent": {
+    "/internal/plan": {
         parameters: {
             query?: never;
             header?: never;
@@ -18731,8 +19277,8 @@ export interface paths {
             cookie?: never;
         };
         /**
-         * Get PipelineEvent (schema generation only)
-         * @description Internal endpoint used only to ensure PipelineEvent schema is generated in OpenAPI spec
+         * Get Plan (schema generation only)
+         * @description Internal endpoint used only to ensure Plan schema is generated in OpenAPI spec
          */
         get: {
             parameters: {
@@ -18749,7 +19295,7 @@ export interface paths {
                         [name: string]: unknown;
                     };
                     content: {
-                        "application/json": components["schemas"]["models.PipelineEvent"];
+                        "application/json": components["schemas"]["models.Plan"];
                     };
                 };
             };
@@ -18762,7 +19308,7 @@ export interface paths {
         patch?: never;
         trace?: never;
     };
-    "/internal/pipelinemetadata": {
+    "/internal/point": {
         parameters: {
             query?: never;
             header?: never;
@@ -18770,8 +19316,8 @@ export interface paths {
             cookie?: never;
         };
         /**
-         * Get PipelineMetadata (schema generation only)
-         * @description Internal endpoint used only to ensure PipelineMetadata schema is generated in OpenAPI spec
+         * Get Point (schema generation only)
+         * @description Internal endpoint used only to ensure Point schema is generated in OpenAPI spec
          */
         get: {
             parameters: {
@@ -18788,7 +19334,7 @@ export interface paths {
                         [name: string]: unknown;
                     };
                     content: {
-                        "application/json": components["schemas"]["models.PipelineMetadata"];
+                        "application/json": components["schemas"]["models.Point"];
                     };
                 };
             };
@@ -18801,7 +19347,7 @@ export interface paths {
         patch?: never;
         trace?: never;
     };
-    "/internal/pipelinemetrics": {
+    "/internal/postanprerrorresponse": {
         parameters: {
             query?: never;
             header?: never;
@@ -18809,8 +19355,8 @@ export interface paths {
             cookie?: never;
         };
         /**
-         * Get PipelineMetrics (schema generation only)
-         * @description Internal endpoint used only to ensure PipelineMetrics schema is generated in OpenAPI spec
+         * Get PostANPRErrorResponse (schema generation only)
+         * @description Internal endpoint used only to ensure PostANPRErrorResponse schema is generated in OpenAPI spec
          */
         get: {
             parameters: {
@@ -18827,7 +19373,7 @@ export interface paths {
                         [name: string]: unknown;
                     };
                     content: {
-                        "application/json": components["schemas"]["models.PipelineMetrics"];
+                        "application/json": components["schemas"]["api.PostANPRErrorResponse"];
                     };
                 };
             };
@@ -18840,7 +19386,7 @@ export interface paths {
         patch?: never;
         trace?: never;
     };
-    "/internal/pipelinepayload": {
+    "/internal/postanprrequest": {
         parameters: {
             query?: never;
             header?: never;
@@ -18848,8 +19394,8 @@ export interface paths {
             cookie?: never;
         };
         /**
-         * Get PipelinePayload (schema generation only)
-         * @description Internal endpoint used only to ensure PipelinePayload schema is generated in OpenAPI spec
+         * Get PostANPRRequest (schema generation only)
+         * @description Internal endpoint used only to ensure PostANPRRequest schema is generated in OpenAPI spec
          */
         get: {
             parameters: {
@@ -18866,7 +19412,7 @@ export interface paths {
                         [name: string]: unknown;
                     };
                     content: {
-                        "application/json": components["schemas"]["models.PipelinePayload"];
+                        "application/json": components["schemas"]["api.PostANPRRequest"];
                     };
                 };
             };
@@ -18879,7 +19425,7 @@ export interface paths {
         patch?: never;
         trace?: never;
     };
-    "/internal/plan": {
+    "/internal/postanprresponse": {
         parameters: {
             query?: never;
             header?: never;
@@ -18887,8 +19433,8 @@ export interface paths {
             cookie?: never;
         };
         /**
-         * Get Plan (schema generation only)
-         * @description Internal endpoint used only to ensure Plan schema is generated in OpenAPI spec
+         * Get PostANPRResponse (schema generation only)
+         * @description Internal endpoint used only to ensure PostANPRResponse schema is generated in OpenAPI spec
          */
         get: {
             parameters: {
@@ -18905,7 +19451,7 @@ export interface paths {
                         [name: string]: unknown;
                     };
                     content: {
-                        "application/json": components["schemas"]["models.Plan"];
+                        "application/json": components["schemas"]["api.PostANPRResponse"];
                     };
                 };
             };
@@ -18918,7 +19464,7 @@ export interface paths {
         patch?: never;
         trace?: never;
     };
-    "/internal/point": {
+    "/internal/postanprsuccessresponse": {
         parameters: {
             query?: never;
             header?: never;
@@ -18926,8 +19472,8 @@ export interface paths {
             cookie?: never;
         };
         /**
-         * Get Point (schema generation only)
-         * @description Internal endpoint used only to ensure Point schema is generated in OpenAPI spec
+         * Get PostANPRSuccessResponse (schema generation only)
+         * @description Internal endpoint used only to ensure PostANPRSuccessResponse schema is generated in OpenAPI spec
          */
         get: {
             parameters: {
@@ -18944,7 +19490,7 @@ export interface paths {
                         [name: string]: unknown;
                     };
                     content: {
-                        "application/json": components["schemas"]["models.Point"];
+                        "application/json": components["schemas"]["api.PostANPRSuccessResponse"];
                     };
                 };
             };
@@ -25197,7 +25743,163 @@ export interface paths {
         patch?: never;
         trace?: never;
     };
-    "/internal/videobytesrangeontime": {
+    "/internal/videobytesrangeontime": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        /**
+         * Get VideoBytesRangeOnTime (schema generation only)
+         * @description Internal endpoint used only to ensure VideoBytesRangeOnTime 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.VideoBytesRangeOnTime"];
+                    };
+                };
+            };
+        };
+        put?: never;
+        post?: never;
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/internal/videowall": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        /**
+         * Get Videowall (schema generation only)
+         * @description Internal endpoint used only to ensure Videowall 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.Videowall"];
+                    };
+                };
+            };
+        };
+        put?: never;
+        post?: never;
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/internal/warningresponse": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        /**
+         * Get WarningResponse (schema generation only)
+         * @description Internal endpoint used only to ensure WarningResponse 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.WarningResponse"];
+                    };
+                };
+            };
+        };
+        put?: never;
+        post?: never;
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/internal/webhook": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        /**
+         * Get Webhook (schema generation only)
+         * @description Internal endpoint used only to ensure Webhook 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.Webhook"];
+                    };
+                };
+            };
+        };
+        put?: never;
+        post?: never;
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/internal/weeklyschedule": {
         parameters: {
             query?: never;
             header?: never;
@@ -25205,8 +25907,8 @@ export interface paths {
             cookie?: never;
         };
         /**
-         * Get VideoBytesRangeOnTime (schema generation only)
-         * @description Internal endpoint used only to ensure VideoBytesRangeOnTime schema is generated in OpenAPI spec
+         * Get WeeklySchedule (schema generation only)
+         * @description Internal endpoint used only to ensure WeeklySchedule schema is generated in OpenAPI spec
          */
         get: {
             parameters: {
@@ -25223,7 +25925,7 @@ export interface paths {
                         [name: string]: unknown;
                     };
                     content: {
-                        "application/json": components["schemas"]["models.VideoBytesRangeOnTime"];
+                        "application/json": components["schemas"]["models.WeeklySchedule"];
                     };
                 };
             };
@@ -25236,7 +25938,7 @@ export interface paths {
         patch?: never;
         trace?: never;
     };
-    "/internal/videowall": {
+    "/internal/workflow": {
         parameters: {
             query?: never;
             header?: never;
@@ -25244,8 +25946,8 @@ export interface paths {
             cookie?: never;
         };
         /**
-         * Get Videowall (schema generation only)
-         * @description Internal endpoint used only to ensure Videowall schema is generated in OpenAPI spec
+         * Get Workflow (schema generation only)
+         * @description Internal endpoint used only to ensure Workflow schema is generated in OpenAPI spec
          */
         get: {
             parameters: {
@@ -25262,7 +25964,7 @@ export interface paths {
                         [name: string]: unknown;
                     };
                     content: {
-                        "application/json": components["schemas"]["models.Videowall"];
+                        "application/json": components["schemas"]["models.Workflow"];
                     };
                 };
             };
@@ -25275,7 +25977,7 @@ export interface paths {
         patch?: never;
         trace?: never;
     };
-    "/internal/warningresponse": {
+    "/internal/workflowdevice": {
         parameters: {
             query?: never;
             header?: never;
@@ -25283,8 +25985,8 @@ export interface paths {
             cookie?: never;
         };
         /**
-         * Get WarningResponse (schema generation only)
-         * @description Internal endpoint used only to ensure WarningResponse schema is generated in OpenAPI spec
+         * Get WorkflowDevice (schema generation only)
+         * @description Internal endpoint used only to ensure WorkflowDevice schema is generated in OpenAPI spec
          */
         get: {
             parameters: {
@@ -25301,7 +26003,7 @@ export interface paths {
                         [name: string]: unknown;
                     };
                     content: {
-                        "application/json": components["schemas"]["api.WarningResponse"];
+                        "application/json": components["schemas"]["models.WorkflowDevice"];
                     };
                 };
             };
@@ -25314,7 +26016,7 @@ export interface paths {
         patch?: never;
         trace?: never;
     };
-    "/internal/webhook": {
+    "/internal/workflowedge": {
         parameters: {
             query?: never;
             header?: never;
@@ -25322,8 +26024,8 @@ export interface paths {
             cookie?: never;
         };
         /**
-         * Get Webhook (schema generation only)
-         * @description Internal endpoint used only to ensure Webhook schema is generated in OpenAPI spec
+         * Get WorkflowEdge (schema generation only)
+         * @description Internal endpoint used only to ensure WorkflowEdge schema is generated in OpenAPI spec
          */
         get: {
             parameters: {
@@ -25340,7 +26042,7 @@ export interface paths {
                         [name: string]: unknown;
                     };
                     content: {
-                        "application/json": components["schemas"]["models.Webhook"];
+                        "application/json": components["schemas"]["models.WorkflowEdge"];
                     };
                 };
             };
@@ -25353,7 +26055,7 @@ export interface paths {
         patch?: never;
         trace?: never;
     };
-    "/internal/weeklyschedule": {
+    "/internal/workflownode": {
         parameters: {
             query?: never;
             header?: never;
@@ -25361,8 +26063,8 @@ export interface paths {
             cookie?: never;
         };
         /**
-         * Get WeeklySchedule (schema generation only)
-         * @description Internal endpoint used only to ensure WeeklySchedule schema is generated in OpenAPI spec
+         * Get WorkflowNode (schema generation only)
+         * @description Internal endpoint used only to ensure WorkflowNode schema is generated in OpenAPI spec
          */
         get: {
             parameters: {
@@ -25379,7 +26081,7 @@ export interface paths {
                         [name: string]: unknown;
                     };
                     content: {
-                        "application/json": components["schemas"]["models.WeeklySchedule"];
+                        "application/json": components["schemas"]["models.WorkflowNode"];
                     };
                 };
             };
@@ -25392,7 +26094,7 @@ export interface paths {
         patch?: never;
         trace?: never;
     };
-    "/internal/workflow": {
+    "/internal/workflowrun": {
         parameters: {
             query?: never;
             header?: never;
@@ -25400,8 +26102,8 @@ export interface paths {
             cookie?: never;
         };
         /**
-         * Get Workflow (schema generation only)
-         * @description Internal endpoint used only to ensure Workflow schema is generated in OpenAPI spec
+         * Get WorkflowRun (schema generation only)
+         * @description Internal endpoint used only to ensure WorkflowRun schema is generated in OpenAPI spec
          */
         get: {
             parameters: {
@@ -25418,7 +26120,7 @@ export interface paths {
                         [name: string]: unknown;
                     };
                     content: {
-                        "application/json": components["schemas"]["models.Workflow"];
+                        "application/json": components["schemas"]["models.WorkflowRun"];
                     };
                 };
             };
@@ -25431,7 +26133,7 @@ export interface paths {
         patch?: never;
         trace?: never;
     };
-    "/internal/workflowedge": {
+    "/internal/workflowstage": {
         parameters: {
             query?: never;
             header?: never;
@@ -25439,8 +26141,8 @@ export interface paths {
             cookie?: never;
         };
         /**
-         * Get WorkflowEdge (schema generation only)
-         * @description Internal endpoint used only to ensure WorkflowEdge schema is generated in OpenAPI spec
+         * Get WorkflowStage (schema generation only)
+         * @description Internal endpoint used only to ensure WorkflowStage schema is generated in OpenAPI spec
          */
         get: {
             parameters: {
@@ -25457,7 +26159,7 @@ export interface paths {
                         [name: string]: unknown;
                     };
                     content: {
-                        "application/json": components["schemas"]["models.WorkflowEdge"];
+                        "application/json": components["schemas"]["models.WorkflowStage"];
                     };
                 };
             };
@@ -25470,7 +26172,7 @@ export interface paths {
         patch?: never;
         trace?: never;
     };
-    "/internal/workflownode": {
+    "/internal/workflowstorage": {
         parameters: {
             query?: never;
             header?: never;
@@ -25478,8 +26180,8 @@ export interface paths {
             cookie?: never;
         };
         /**
-         * Get WorkflowNode (schema generation only)
-         * @description Internal endpoint used only to ensure WorkflowNode schema is generated in OpenAPI spec
+         * Get WorkflowStorage (schema generation only)
+         * @description Internal endpoint used only to ensure WorkflowStorage schema is generated in OpenAPI spec
          */
         get: {
             parameters: {
@@ -25496,7 +26198,7 @@ export interface paths {
                         [name: string]: unknown;
                     };
                     content: {
-                        "application/json": components["schemas"]["models.WorkflowNode"];
+                        "application/json": components["schemas"]["models.WorkflowStorage"];
                     };
                 };
             };
@@ -25509,7 +26211,7 @@ export interface paths {
         patch?: never;
         trace?: never;
     };
-    "/internal/workflowstage": {
+    "/internal/workflowtrigger": {
         parameters: {
             query?: never;
             header?: never;
@@ -25517,8 +26219,8 @@ export interface paths {
             cookie?: never;
         };
         /**
-         * Get WorkflowStage (schema generation only)
-         * @description Internal endpoint used only to ensure WorkflowStage schema is generated in OpenAPI spec
+         * Get WorkflowTrigger (schema generation only)
+         * @description Internal endpoint used only to ensure WorkflowTrigger schema is generated in OpenAPI spec
          */
         get: {
             parameters: {
@@ -25535,7 +26237,7 @@ export interface paths {
                         [name: string]: unknown;
                     };
                     content: {
-                        "application/json": components["schemas"]["models.WorkflowStage"];
+                        "application/json": components["schemas"]["models.WorkflowTrigger"];
                     };
                 };
             };
@@ -25548,7 +26250,7 @@ export interface paths {
         patch?: never;
         trace?: never;
     };
-    "/internal/workflowtrigger": {
+    "/internal/workflowuser": {
         parameters: {
             query?: never;
             header?: never;
@@ -25556,8 +26258,8 @@ export interface paths {
             cookie?: never;
         };
         /**
-         * Get WorkflowTrigger (schema generation only)
-         * @description Internal endpoint used only to ensure WorkflowTrigger schema is generated in OpenAPI spec
+         * Get WorkflowUser (schema generation only)
+         * @description Internal endpoint used only to ensure WorkflowUser schema is generated in OpenAPI spec
          */
         get: {
             parameters: {
@@ -25574,7 +26276,7 @@ export interface paths {
                         [name: string]: unknown;
                     };
                     content: {
-                        "application/json": components["schemas"]["models.WorkflowTrigger"];
+                        "application/json": components["schemas"]["models.WorkflowUser"];
                     };
                 };
             };
@@ -25695,6 +26397,55 @@ export interface paths {
 export type webhooks = Record<string, never>;
 export interface components {
     schemas: {
+        "api.ANPRCandidateInput": {
+            confidence?: number;
+            plate?: string;
+        };
+        "api.ANPRMediaInput": {
+            fps?: number;
+            height?: number;
+            width?: number;
+        };
+        "api.ANPRPlateInput": {
+            /** @description Candidates are alternative reads ranked below Plate (optional). */
+            candidates?: components["schemas"]["api.ANPRCandidateInput"][];
+            /** @description Confidence is the read confidence; clamped to [0, 1] on ingest. */
+            confidence?: number;
+            /** @description Country is the ISO 3166-1 alpha-2 jurisdiction (optional). */
+            country?: string;
+            /** @description Display is the optional human-readable rendering. */
+            display?: string;
+            /** @description Frame is the representative frame the read came from (optional). */
+            frame?: number;
+            h?: number;
+            /**
+             * @description Meta carries producer-specific extras (e.g. vehicle attributes); capped on
+             *     ingest.
+             */
+            meta?: {
+                [key: string]: unknown;
+            };
+            /** @description Plate is the recognised registration; stored normalised for search. */
+            plate?: string;
+            /** @description Region is the sub-jurisdiction (optional). */
+            region?: string;
+            /** @description TimestampMs is the representative time in ms into the recording (optional). */
+            timestampMs?: number;
+            w?: number;
+            /** @description Box geometry — preferred {x, y, w, h}. */
+            x?: number;
+            /** @description Box geometry — legacy {x1, y1, x2, y2}. */
+            x1?: number;
+            x2?: number;
+            y?: number;
+            y1?: number;
+            y2?: number;
+        };
+        "api.ANPRRejection": {
+            frame?: number;
+            plate?: string;
+            reason?: string;
+        };
         "api.AddAccessTokenErrorResponse": {
             /** @description Application-specific error code */
             applicationStatusCode?: string;
@@ -28488,6 +29239,71 @@ export interface components {
             /** @description Additional metadata about the response, such as timestamps and request IDs */
             metadata?: components["schemas"]["api.Metadata"];
         };
+        "api.PostANPRErrorResponse": {
+            /** @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.PostANPRRequest": {
+            /**
+             * @description AnalysisId targets the recording via its analysis document _id (an
+             *     ObjectID hex), as an alternative to MediaKey.
+             */
+            analysisId?: string;
+            /**
+             * @description CoordinateSpace is the space plate boxes are sent in: "pixel" or
+             *     "normalized". Required only when a plate carries a box.
+             */
+            coordinateSpace?: string;
+            /**
+             * @description Media gives the recording dimensions used to normalise pixel-space boxes.
+             *     Required when CoordinateSpace is "pixel" and any plate carries a box.
+             */
+            media?: components["schemas"]["api.ANPRMediaInput"];
+            /**
+             * @description MediaKey is the recording KEY the run 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). Only the
+             *     HTTP door uses these; over the workflows queue the engine resolves the
+             *     target from the run envelope.
+             */
+            mediaKey?: string;
+            /**
+             * @description Plates are the recognised plates. An empty list is valid — it records that
+             *     ANPR ran and found nothing.
+             */
+            plates?: components["schemas"]["api.ANPRPlateInput"][];
+            /** @description SchemaVersion is the producer's payload schema (optional). */
+            schemaVersion?: string;
+            /** @description Source identifies the producer; Source.RunId is the upsert key. */
+            source?: components["schemas"]["models.ANPRSource"];
+        };
+        "api.PostANPRResponse": {
+            platesStored?: number;
+            rejected?: components["schemas"]["api.ANPRRejection"][];
+            runId?: string;
+            warnings?: string[];
+        };
+        "api.PostANPRSuccessResponse": {
+            /** @description Application-specific status code */
+            applicationStatusCode?: string;
+            data?: components["schemas"]["api.PostANPRResponse"];
+            /** @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.PostDetectionsErrorResponse": {
             /** @description Application-specific error code */
             applicationStatusCode?: string;
@@ -29306,6 +30122,113 @@ export interface components {
             /** @description Additional metadata about the error, such as timestamps and request IDs */
             metadata?: components["schemas"]["api.Metadata"];
         };
+        "models.ANPRBox": {
+            x1?: number;
+            x2?: number;
+            y1?: number;
+            y2?: number;
+        };
+        "models.ANPRCandidate": {
+            confidence?: number;
+            plate?: string;
+        };
+        "models.ANPRMedia": {
+            fps?: number;
+            height?: number;
+            width?: number;
+        };
+        "models.ANPRPlate": {
+            /**
+             * @description Box is the plate's location at the representative frame, normalised to the
+             *     [0, 1] frame. Nil when the producer reported no geometry.
+             */
+            box?: components["schemas"]["models.ANPRBox"];
+            /**
+             * @description Candidates are alternative reads ranked below Plate, highest confidence
+             *     first (optional).
+             */
+            candidates?: components["schemas"]["models.ANPRCandidate"][];
+            /** @description Confidence is the chosen read's confidence in [0, 1]. */
+            confidence?: number;
+            /** @description Country is the ISO 3166-1 alpha-2 jurisdiction, e.g. "BE" (optional). */
+            country?: string;
+            /** @description Display is the optional human-readable rendering, e.g. "1-ABC-234". */
+            display?: string;
+            /** @description Frame is the representative frame the chosen read came from. */
+            frame?: number;
+            /**
+             * @description Meta carries producer-specific extras (e.g. vehicle make/colour) without
+             *     expanding the core contract. Capped on ingest.
+             */
+            meta?: {
+                [key: string]: unknown;
+            };
+            /**
+             * @description Plate is the recognised registration in a normalised, searchable form
+             *     (uppercase, no separators), e.g. "1ABC234".
+             */
+            plate?: string;
+            /**
+             * @description Region is the sub-jurisdiction (state/province) when the producer reports
+             *     one, e.g. "CA" (optional).
+             */
+            region?: string;
+            /** @description TimestampMs is the representative time (ms into the recording) of the read. */
+            timestampMs?: number;
+        };
+        "models.ANPRRun": {
+            /** @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.
+             */
+            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 — the stable identity
+             *     the collection is keyed by (survives re-analysis).
+             */
+            key?: string;
+            /**
+             * @description Media describes the recording the plates were read against; kept so a
+             *     normalised plate box can be rendered back at pixel scale.
+             */
+            media?: components["schemas"]["models.ANPRMedia"];
+            /**
+             * @description OriginalCoordinateSpace records the space the producer sent plate boxes in
+             *     ("pixel" or "normalized") before the server normalised them. Empty when no
+             *     plate carried a box.
+             */
+            originalCoordinateSpace?: string;
+            /**
+             * @description Plates are the recognised plates, stored verbatim after the box (if any)
+             *     is normalised to the [0, 1] frame.
+             */
+            plates?: components["schemas"]["models.ANPRPlate"][];
+            /**
+             * @description RecordingTimestamp is the start time (epoch seconds) of the recording,
+             *     denormalised on write so cleanup expires the run on the recording's
+             *     retention clock rather than the (possibly much later) post time.
+             */
+            recordingTimestamp?: number;
+            /** @description SchemaVersion is the producer's payload schema (optional). */
+            schemaVersion?: string;
+            /** @description Source identifies the producer and carries RunId, the natural upsert key. */
+            source?: components["schemas"]["models.ANPRSource"];
+            /** @description UpdatedAt is set by the server every time the run is written (epoch millis). */
+            updatedAt?: number;
+        };
+        "models.ANPRSource": {
+            /** @description pipeline | model | import */
+            kind?: string;
+            /** @description producer identifier */
+            name?: string;
+            /** @description ULID/UUID; upsert key */
+            runId?: string;
+            version?: string;
+        };
         /** @enum {integer} */
         "models.AccessLevel": 0 | 1 | 2 | 3;
         "models.AccessToken": {
@@ -31329,6 +32252,8 @@ export interface components {
             /** @description Add more fields as needed */
             user?: components["schemas"]["models.User"];
         };
+        /** @enum {string} */
+        "models.NeedsMode": "any" | "all";
         "models.NotificationSettings": {
             detections?: components["schemas"]["models.Detections"];
             devices?: components["schemas"]["models.Devices"];
@@ -31698,18 +32623,26 @@ export interface components {
         "models.StageCondition": {
             /** @description see the ConditionOp consts */
             op?: components["schemas"]["models.ConditionOp"];
-            /** @description dot-path into the upstream op's result */
+            /** @description absolute dot-path into the run root (see type doc) */
             path?: string;
             /** @description comparison operand (unused for ConditionOpExists) */
             value?: unknown;
         };
         "models.StageDependency": {
             /**
-             * @description Condition is the predicate evaluated against the upstream's result. Nil
-             *     means the dependency matches as soon as the upstream resolves.
+             * @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 upstream stage this dependency waits on. */
+            /**
+             * @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.
+             */
             operation?: string;
         };
         "models.StageParam": {
@@ -32469,6 +33402,14 @@ export interface components {
             user_id?: string;
             username?: string;
         };
+        "models.WorkflowDevice": {
+            deviceKey?: string;
+            deviceName?: string;
+            /** @description media VideoProvider: where the media is served from */
+            provider?: string;
+            /** @description media StorageSolution: where the media is stored */
+            storageSolution?: string;
+        };
         "models.WorkflowEdge": {
             /**
              * @description Condition is the structured predicate evaluated against the source stage's
@@ -32519,6 +33460,131 @@ export interface components {
             x?: number;
             y?: number;
         };
+        "models.WorkflowRun": {
+            /**
+             * @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.
+             */
+            device?: components["schemas"]["models.WorkflowDevice"];
+            /**
+             * @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.
+             */
+            inputs?: {
+                [key: string]: unknown;
+            };
+            /**
+             * @description Key is the media key the run is about: its natural identity, used to load
+             *     or open the run document. Copied from the recording at hand-off time.
+             */
+            key?: string;
+            /**
+             * @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
+             *         stage to its worker (Storage populated), or the worker routing its
+             *         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.
+             */
+            operation?: string;
+            /**
+             * @description Payload is the raw, typed result body a delegated-ingest stage hands back
+             *     for the platform to persist — the single operation in Operation, in its
+             *     kind's contract shape (e.g. a detection-run body). It is the channel the
+             *     shared ingest core reads from, distinct from Results:
+             *
+             *       - Results is the multi-operation, decoded routing/state ledger the
+             *         condition matcher reads and the run persists.
+             *       - Payload is a single stage's raw typed bytes for one ingest hop.
+             *
+             *     Lifecycle mirrors Storage and is one-directional (worker → engine):
+             *       - A delegated-ingest stage (its WorkflowStage declares an ingest Kind)
+             *         sets Payload on its result; the engine routes it through ingest.Ingest
+             *         into the stage's platform-owned collection and mirrors its decoded form
+             *         into Results so downstream conditions can branch on it. The engine
+             *         targets the run's own recording (Key/User/Device), so a payload that
+             *         also carries its own recording reference (e.g. a PostDetectionsRequest
+             *         mediaKey/analysisId) has that reference ignored on the queue path.
+             *       - A self-persisting stage (no Kind) writes its own collection and returns
+             *         its routing values in Results instead; Payload is empty.
+             *
+             *     `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.
+             */
+            payload?: number[];
+            /**
+             * @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
+             *     the analysis hand-off and persisted on the run at open; the engine then
+             *     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.
+             */
+            recordingTimestamp?: number;
+            /**
+             * @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).
+             */
+            results?: {
+                [key: string]: unknown;
+            };
+            /**
+             * @description RunId is the run's identifier on the wire (the hex of the document Id). It
+             *     is empty on the analysis hand-off — the run is keyed by Key until the
+             *     engine opens it — and set on every engine→worker dispatch. The persisted
+             *     identity is Id, so RunId itself is wire-only.
+             */
+            runId?: string;
+            /**
+             * @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.
+             */
+            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
+             *     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 UserId (which holds the organisation id).
+             */
+            user?: components["schemas"]["models.WorkflowUser"];
+            /**
+             * @description WorkflowId is the id of the Workflow definition (models.Workflow) this run
+             *     executes — the authored graph (nodes/edges/trigger) the run is an execution
+             *     of, as opposed to the global stage registry. Forward-looking: it is set once
+             *     the engine executes Workflow graphs; while the engine is driven by the flat
+             *     stage registry it is empty.
+             */
+            workflowId?: string;
+            /**
+             * @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.
+             */
+            workflowName?: string;
+        };
         "models.WorkflowStage": {
             /** @description Description explains what the stage does, for the catalog UI. */
             description?: string;
@@ -32544,24 +33610,60 @@ export interface components {
              *     a single implicit default port.
              */
             inputs?: components["schemas"]["models.StagePort"][];
+            /**
+             * @description Kind names the ingest handler the platform routes this stage's typed result
+             *     through (e.g. "detection"). When set, the stage is delegated-ingest: its
+             *     worker hands the typed result back in WorkflowRun.Payload and the engine
+             *     calls the shared ingest core to persist it into the kind's platform-owned
+             *     collection (and mirrors the decoded form into the run's Results for
+             *     routing). When empty the stage is self-persisting: its worker writes its
+             *     own collection and the engine only records the result it returns in
+             *     Results. A Kind with no handler registered in the ingest core is treated as
+             *     self-persist — the result is recorded, not ingested.
+             */
+            kind?: string;
             /** @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 upstream 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 whenever any listed upstream
-             *     resolves, and the stage fires for the first dependency whose Condition
-             *     matches that upstream's result (a nil Condition matches unconditionally).
+             * @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).
              */
             needs?: components["schemas"]["models.StageDependency"][];
+            /**
+             * @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.
+             */
+            needsMode?: components["schemas"]["models.NeedsMode"];
             /**
              * @description Operation uniquely identifies the stage and binds its queue, dispatch and
-             *     resolution. It is the key that workflow nodes reference. Two stages may
-             *     never share an operation.
+             *     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.
+             *
+             *     Stage vs. operation — they are not synonyms:
+             *       - a STAGE is this definition: a deployed worker with a queue and a
+             *         dispatch rule.
+             *       - an OPERATION is the id string. It names this stage, and it is also the
+             *         key results are filed under on a run.
+             *     Every deployed stage has an operation, but a run's operation keyspace is
+             *     wider than its stages: it also includes the trigger analysis hands off
+             *     (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.
              */
             operation?: string;
             outputs?: components["schemas"]["models.StagePort"][];
@@ -32587,6 +33689,15 @@ export interface components {
             /** @description Tag is the image tag deployed for the stage. */
             tag?: string;
         };
+        "models.WorkflowStorage": {
+            accessKey?: string;
+            secret?: string;
+            uri?: string;
+            vaultOverrideAccessKey?: string;
+            vaultOverrideProvider?: string;
+            vaultOverrideSecret?: string;
+            vaultOverrideUri?: string;
+        };
         "models.WorkflowTrigger": {
             endAt?: string;
             /** @description Selection is the set of devices/streams the workflow applies to. */
@@ -32596,6 +33707,10 @@ export interface components {
             /** @description Weekdays restricts the workflow to the listed days of week. */
             weekdays?: number[];
         };
+        "models.WorkflowUser": {
+            organisationId?: string;
+            storage?: components["schemas"]["models.Storage"];
+        };
     };
     responses: never;
     parameters: never;
@@ -32606,6 +33721,12 @@ export interface components {
 export type $defs = Record<string, never>;
 export type operations = Record<string, never>;
 export declare namespace models {
+    type ANPRBox = components['schemas']['models.ANPRBox'];
+    type ANPRCandidate = components['schemas']['models.ANPRCandidate'];
+    type ANPRMedia = components['schemas']['models.ANPRMedia'];
+    type ANPRPlate = components['schemas']['models.ANPRPlate'];
+    type ANPRRun = components['schemas']['models.ANPRRun'];
+    type ANPRSource = components['schemas']['models.ANPRSource'];
     type AccessToken = components['schemas']['models.AccessToken'];
     type Account = components['schemas']['models.Account'];
     type AccountBody = components['schemas']['models.AccountBody'];
@@ -32854,12 +33975,20 @@ export declare namespace models {
     type Webhook = components['schemas']['models.Webhook'];
     type WeeklySchedule = components['schemas']['models.WeeklySchedule'];
     type Workflow = components['schemas']['models.Workflow'];
+    type WorkflowDevice = components['schemas']['models.WorkflowDevice'];
     type WorkflowEdge = components['schemas']['models.WorkflowEdge'];
     type WorkflowNode = components['schemas']['models.WorkflowNode'];
+    type WorkflowRun = components['schemas']['models.WorkflowRun'];
     type WorkflowStage = components['schemas']['models.WorkflowStage'];
+    type WorkflowStorage = components['schemas']['models.WorkflowStorage'];
     type WorkflowTrigger = components['schemas']['models.WorkflowTrigger'];
+    type WorkflowUser = components['schemas']['models.WorkflowUser'];
 }
 export declare namespace api {
+    type ANPRCandidateInput = components['schemas']['api.ANPRCandidateInput'];
+    type ANPRMediaInput = components['schemas']['api.ANPRMediaInput'];
+    type ANPRPlateInput = components['schemas']['api.ANPRPlateInput'];
+    type ANPRRejection = components['schemas']['api.ANPRRejection'];
     type AddAccessTokenErrorResponse = components['schemas']['api.AddAccessTokenErrorResponse'];
     type AddAccessTokenRequest = components['schemas']['api.AddAccessTokenRequest'];
     type AddAccessTokenResponse = components['schemas']['api.AddAccessTokenResponse'];
@@ -33149,6 +34278,10 @@ export declare namespace api {
     type PatchVideowallRequest = components['schemas']['api.PatchVideowallRequest'];
     type PatchVideowallResponse = components['schemas']['api.PatchVideowallResponse'];
     type PatchVideowallSuccessResponse = components['schemas']['api.PatchVideowallSuccessResponse'];
+    type PostANPRErrorResponse = components['schemas']['api.PostANPRErrorResponse'];
+    type PostANPRRequest = components['schemas']['api.PostANPRRequest'];
+    type PostANPRResponse = components['schemas']['api.PostANPRResponse'];
+    type PostANPRSuccessResponse = components['schemas']['api.PostANPRSuccessResponse'];
     type PostDetectionsErrorResponse = components['schemas']['api.PostDetectionsErrorResponse'];
     type PostDetectionsRequest = components['schemas']['api.PostDetectionsRequest'];
     type PostDetectionsResponse = components['schemas']['api.PostDetectionsResponse'];