@uug-ai/models 1.6.10 → 1.6.11

package/dist/types.d.ts

@@ -20049,6 +20049,162 @@ export interface paths {
         patch?: never;
         trace?: never;
     };
+    "/internal/runworkflowerrorresponse": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        /**
+         * Get RunWorkflowErrorResponse (schema generation only)
+         * @description Internal endpoint used only to ensure RunWorkflowErrorResponse 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.RunWorkflowErrorResponse"];
+                    };
+                };
+            };
+        };
+        put?: never;
+        post?: never;
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/internal/runworkflowrequest": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        /**
+         * Get RunWorkflowRequest (schema generation only)
+         * @description Internal endpoint used only to ensure RunWorkflowRequest 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.RunWorkflowRequest"];
+                    };
+                };
+            };
+        };
+        put?: never;
+        post?: never;
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/internal/runworkflowresponse": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        /**
+         * Get RunWorkflowResponse (schema generation only)
+         * @description Internal endpoint used only to ensure RunWorkflowResponse 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.RunWorkflowResponse"];
+                    };
+                };
+            };
+        };
+        put?: never;
+        post?: never;
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/internal/runworkflowsuccessresponse": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        /**
+         * Get RunWorkflowSuccessResponse (schema generation only)
+         * @description Internal endpoint used only to ensure RunWorkflowSuccessResponse 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.RunWorkflowSuccessResponse"];
+                    };
+                };
+            };
+        };
+        put?: never;
+        post?: never;
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
     "/internal/savefaceredactionerrorresponse": {
         parameters: {
             query?: never;
@@ -28876,6 +29032,39 @@ export interface components {
             /** @description Additional metadata about the response, such as timestamps and request IDs */
             metadata?: components["schemas"]["api.Metadata"];
         };
+        "api.RunWorkflowErrorResponse": {
+            /** @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.RunWorkflowRequest": {
+            mediaIds?: string[];
+            workflowId?: string;
+        };
+        "api.RunWorkflowResponse": {
+            count?: number;
+            runIds?: string[];
+        };
+        "api.RunWorkflowSuccessResponse": {
+            /** @description Application-specific status code */
+            applicationStatusCode?: string;
+            data?: components["schemas"]["api.RunWorkflowResponse"];
+            /** @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.SaveFaceRedactionErrorResponse": {
             /** @description Application-specific error code */
             applicationStatusCode?: string;
@@ -30237,7 +30426,7 @@ export interface components {
             website?: string;
         };
         /** @enum {string} */
-        "models.ConditionOp": "eq" | "ne" | "contains" | "in" | "exists" | "gt" | "gte" | "lt" | "lte";
+        "models.ConditionOp": "eq" | "ne" | "contains" | "in" | "exists" | "matches" | "gt" | "gte" | "lt" | "lte";
         "models.Contact": {
             email?: string;
             name?: string;
@@ -32838,6 +33027,8 @@ export interface components {
             deviceName?: string;
             /** @description media VideoProvider: where the media is served from */
             provider?: string;
+            /** @description site ids the device is linked to (Device.SiteIds); a gate value, matchable with contains/in/exists/matches */
+            siteIds?: string[];
             /** @description media StorageSolution: where the media is stored */
             storageSolution?: string;
         };
@@ -33020,6 +33211,20 @@ export interface components {
              *     (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
+             *     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.
+             *     Only routing fields are meaningful here (Operation, Dispatch, Needs,
+             *     NeedsMode; Queue when the source workflow set one); the engine compiles
+             *     these into the same validated registry a config workflow gets. Empty is the
+             *     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.
+             */
+            stages?: components["schemas"]["models.WorkflowStage"][];
             /**
              * @description Storage carries the credentials a dispatched stage worker needs to fetch
              *     the media (global Kerberos Storage plus any resolved per-recording vault
@@ -33161,10 +33366,26 @@ export interface components {
             vaultOverrideUri?: string;
         };
         "models.WorkflowTrigger": {
+            /**
+             * @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.
+             */
+            conditions?: components["schemas"]["models.StageCondition"][];
             /**
              * @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).
+             *
+             *     It is a convenience shorthand: a non-empty list compiles (see
+             *     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.
              */
             devices?: components["schemas"]["models.DeviceKey"][];
             /**
@@ -33183,7 +33404,8 @@ export interface components {
              *     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.
+             *     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.
              */
             weeklySchedule?: components["schemas"]["models.WeeklySchedule"][];
         };
@@ -33767,6 +33989,10 @@ export declare namespace api {
     type RequestTaskExportErrorResponse = components['schemas']['api.RequestTaskExportErrorResponse'];
     type RequestTaskExportResponse = components['schemas']['api.RequestTaskExportResponse'];
     type RequestTaskExportSuccessResponse = components['schemas']['api.RequestTaskExportSuccessResponse'];
+    type RunWorkflowErrorResponse = components['schemas']['api.RunWorkflowErrorResponse'];
+    type RunWorkflowRequest = components['schemas']['api.RunWorkflowRequest'];
+    type RunWorkflowResponse = components['schemas']['api.RunWorkflowResponse'];
+    type RunWorkflowSuccessResponse = components['schemas']['api.RunWorkflowSuccessResponse'];
     type SaveFaceRedactionErrorResponse = components['schemas']['api.SaveFaceRedactionErrorResponse'];
     type SaveFaceRedactionRequest = components['schemas']['api.SaveFaceRedactionRequest'];
     type SaveFaceRedactionResponse = components['schemas']['api.SaveFaceRedactionResponse'];

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@uug-ai/models",
-  "version": "1.6.10",
+  "version": "1.6.11",
   "description": "TypeScript type definitions for Go models",
   "main": "dist/types.js",
   "types": "dist/types.d.ts",