@uug-ai/models 1.6.10 → 1.6.12

package/dist/types.d.ts

@@ -15174,6 +15174,123 @@ export interface paths {
         patch?: never;
         trace?: never;
     };
+    "/internal/getworkflowrunserrorresponse": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        /**
+         * Get GetWorkflowRunsErrorResponse (schema generation only)
+         * @description Internal endpoint used only to ensure GetWorkflowRunsErrorResponse 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.GetWorkflowRunsErrorResponse"];
+                    };
+                };
+            };
+        };
+        put?: never;
+        post?: never;
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/internal/getworkflowrunsresponse": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        /**
+         * Get GetWorkflowRunsResponse (schema generation only)
+         * @description Internal endpoint used only to ensure GetWorkflowRunsResponse 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.GetWorkflowRunsResponse"];
+                    };
+                };
+            };
+        };
+        put?: never;
+        post?: never;
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/internal/getworkflowrunssuccessresponse": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        /**
+         * Get GetWorkflowRunsSuccessResponse (schema generation only)
+         * @description Internal endpoint used only to ensure GetWorkflowRunsSuccessResponse 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.GetWorkflowRunsSuccessResponse"];
+                    };
+                };
+            };
+        };
+        put?: never;
+        post?: never;
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
     "/internal/getworkflowserrorresponse": {
         parameters: {
             query?: never;
@@ -20049,6 +20166,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;
@@ -25665,6 +25938,84 @@ export interface paths {
         patch?: never;
         trace?: never;
     };
+    "/internal/workflowrunstatus": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        /**
+         * Get WorkflowRunStatus (schema generation only)
+         * @description Internal endpoint used only to ensure WorkflowRunStatus 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.WorkflowRunStatus"];
+                    };
+                };
+            };
+        };
+        put?: never;
+        post?: never;
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/internal/workflowrunstatussummary": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        /**
+         * Get WorkflowRunStatusSummary (schema generation only)
+         * @description Internal endpoint used only to ensure WorkflowRunStatusSummary 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.WorkflowRunStatusSummary"];
+                    };
+                };
+            };
+        };
+        put?: never;
+        post?: never;
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
     "/internal/workflowstage": {
         parameters: {
             query?: never;
@@ -26361,6 +26712,15 @@ export interface components {
             params?: {
                 [key: string]: unknown;
             };
+            /**
+             * @description SourceAttachmentId points at a video CaseAttachment by its id.
+             *     When both SourceCaseMediaId and SourceVideoFile are empty the API
+             *     materialises (idempotently — reuses the attachment's linked row
+             *     when present) a Role=source CaseMedia from the attachment's stored
+             *     video and applies the edit to that row, so an attached video can
+             *     be redacted with the same flow as a device recording.
+             */
+            sourceAttachmentId?: string;
             sourceCaseMediaId?: string;
             /**
              * @description SourceVideoFile points at a legacy task.export_files entry by its
@@ -28429,6 +28789,35 @@ export interface components {
         "api.GetWorkflowResponse": {
             workflow?: components["schemas"]["models.Workflow"];
         };
+        "api.GetWorkflowRunsErrorResponse": {
+            /** @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.GetWorkflowRunsResponse": {
+            runs?: components["schemas"]["api.WorkflowRunStatus"][];
+            summary?: components["schemas"]["api.WorkflowRunStatusSummary"];
+        };
+        "api.GetWorkflowRunsSuccessResponse": {
+            /** @description Application-specific status code */
+            applicationStatusCode?: string;
+            data?: components["schemas"]["api.GetWorkflowRunsResponse"];
+            /** @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.GetWorkflowSuccessResponse": {
             /** @description Application-specific status code */
             applicationStatusCode?: string;
@@ -28876,6 +29265,40 @@ 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": {
+            attachmentIds?: string[];
+            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;
@@ -29549,6 +29972,36 @@ export interface components {
             surface?: components["schemas"]["models.WorkflowTriggerSurface"];
             triggerType?: components["schemas"]["models.WorkflowTriggerType"];
         };
+        "api.WorkflowRunStatus": {
+            /**
+             * @description Dispatched / Resolved are the sizes of the run's dispatched and resolved
+             *     operation sets, exposed as a coarse progress hint.
+             */
+            dispatched?: number;
+            end?: number;
+            /** @description HasResults is true when the run accumulated any stage output. */
+            hasResults?: boolean;
+            key?: string;
+            origin?: string;
+            resolved?: number;
+            runId?: string;
+            sourceRef?: string;
+            /** @description Start / End are unix seconds; End is 0 while the run is still open. */
+            start?: number;
+            /**
+             * @description State is the derived lifecycle: running | completed | noResult
+             *     (models.WorkflowRunState).
+             */
+            state?: string;
+            workflowId?: string;
+            workflowName?: string;
+        };
+        "api.WorkflowRunStatusSummary": {
+            completed?: number;
+            noResult?: number;
+            running?: number;
+            total?: number;
+        };
         /** @enum {integer} */
         "models.AccessLevel": 0 | 1 | 2 | 3;
         "models.AccessToken": {
@@ -29994,6 +30447,18 @@ export interface components {
              */
             media?: components["schemas"]["models.Media"];
             organisationId?: string;
+            /**
+             * @description OriginAttachmentId marks a Role=source row that was materialised
+             *     from a video CaseAttachment (see the case_attachments collection)
+             *     so a case's attached videos can flow through the same
+             *     workflow-run and redaction machinery as device recordings. It
+             *     back-links to the CaseAttachment.Id. Rows carrying it are kept
+             *     out of the normal media playlist and default to
+             *     IncludeInExport=false / IncludeInShare=false at insert time (the
+             *     owning attachment carries its own export/share curation). Only
+             *     meaningful on Role = "source".
+             */
+            originAttachmentId?: string;
             /**
              * @description Params carries kind-specific parameters used to produce the edit.
              *     For Action = "composite" it is expected to contain an
@@ -30237,7 +30702,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 +33303,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 +33487,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 +33642,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 +33680,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"][];
         };
@@ -33725,6 +34223,9 @@ export declare namespace api {
     type GetVideowallsSuccessResponse = components['schemas']['api.GetVideowallsSuccessResponse'];
     type GetWorkflowErrorResponse = components['schemas']['api.GetWorkflowErrorResponse'];
     type GetWorkflowResponse = components['schemas']['api.GetWorkflowResponse'];
+    type GetWorkflowRunsErrorResponse = components['schemas']['api.GetWorkflowRunsErrorResponse'];
+    type GetWorkflowRunsResponse = components['schemas']['api.GetWorkflowRunsResponse'];
+    type GetWorkflowRunsSuccessResponse = components['schemas']['api.GetWorkflowRunsSuccessResponse'];
     type GetWorkflowSuccessResponse = components['schemas']['api.GetWorkflowSuccessResponse'];
     type GetWorkflowsErrorResponse = components['schemas']['api.GetWorkflowsErrorResponse'];
     type GetWorkflowsRequest = components['schemas']['api.GetWorkflowsRequest'];
@@ -33767,6 +34268,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'];
@@ -33843,4 +34348,6 @@ export declare namespace api {
     type UpsertStateSuccessResponse = components['schemas']['api.UpsertStateSuccessResponse'];
     type WarningResponse = components['schemas']['api.WarningResponse'];
     type WorkflowFilter = components['schemas']['api.WorkflowFilter'];
+    type WorkflowRunStatus = components['schemas']['api.WorkflowRunStatus'];
+    type WorkflowRunStatusSummary = components['schemas']['api.WorkflowRunStatusSummary'];
 }

package/package.json

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