@uug-ai/models 1.4.7 → 1.4.13

package/dist/types.d.ts

@@ -3357,6 +3357,45 @@ export interface paths {
         patch?: never;
         trace?: never;
     };
+    "/internal/exportfile": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        /**
+         * Get ExportFile (schema generation only)
+         * @description Internal endpoint used only to ensure ExportFile 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.ExportFile"];
+                    };
+                };
+            };
+        };
+        put?: never;
+        post?: never;
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
     "/internal/faceredaction": {
         parameters: {
             query?: never;
@@ -5814,6 +5853,162 @@ export interface paths {
         patch?: never;
         trace?: never;
     };
+    "/internal/getmediabyvideofileerrorresponse": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        /**
+         * Get GetMediaByVideoFileErrorResponse (schema generation only)
+         * @description Internal endpoint used only to ensure GetMediaByVideoFileErrorResponse 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.GetMediaByVideoFileErrorResponse"];
+                    };
+                };
+            };
+        };
+        put?: never;
+        post?: never;
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/internal/getmediabyvideofilerequest": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        /**
+         * Get GetMediaByVideoFileRequest (schema generation only)
+         * @description Internal endpoint used only to ensure GetMediaByVideoFileRequest 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.GetMediaByVideoFileRequest"];
+                    };
+                };
+            };
+        };
+        put?: never;
+        post?: never;
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/internal/getmediabyvideofileresponse": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        /**
+         * Get GetMediaByVideoFileResponse (schema generation only)
+         * @description Internal endpoint used only to ensure GetMediaByVideoFileResponse 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.GetMediaByVideoFileResponse"];
+                    };
+                };
+            };
+        };
+        put?: never;
+        post?: never;
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/internal/getmediabyvideofilesuccessresponse": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        /**
+         * Get GetMediaByVideoFileSuccessResponse (schema generation only)
+         * @description Internal endpoint used only to ensure GetMediaByVideoFileSuccessResponse 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.GetMediaByVideoFileSuccessResponse"];
+                    };
+                };
+            };
+        };
+        put?: never;
+        post?: never;
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
     "/internal/getmediaerrorresponse": {
         parameters: {
             query?: never;
@@ -8700,6 +8895,123 @@ export interface paths {
         patch?: never;
         trace?: never;
     };
+    "/internal/mediaurlrequest": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        /**
+         * Get MediaUrlRequest (schema generation only)
+         * @description Internal endpoint used only to ensure MediaUrlRequest 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.MediaUrlRequest"];
+                    };
+                };
+            };
+        };
+        put?: never;
+        post?: never;
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/internal/mediaurlresponse": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        /**
+         * Get MediaUrlResponse (schema generation only)
+         * @description Internal endpoint used only to ensure MediaUrlResponse 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.MediaUrlResponse"];
+                    };
+                };
+            };
+        };
+        put?: never;
+        post?: never;
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/internal/mediawrapper": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        /**
+         * Get MediaWrapper (schema generation only)
+         * @description Internal endpoint used only to ensure MediaWrapper 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.MediaWrapper"];
+                    };
+                };
+            };
+        };
+        put?: never;
+        post?: never;
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
     "/internal/message": {
         parameters: {
             query?: never;
@@ -11235,6 +11547,123 @@ export interface paths {
         patch?: never;
         trace?: never;
     };
+    "/internal/task": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        /**
+         * Get Task (schema generation only)
+         * @description Internal endpoint used only to ensure Task 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.Task"];
+                    };
+                };
+            };
+        };
+        put?: never;
+        post?: never;
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/internal/taskfilter": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        /**
+         * Get TaskFilter (schema generation only)
+         * @description Internal endpoint used only to ensure TaskFilter 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.TaskFilter"];
+                    };
+                };
+            };
+        };
+        put?: never;
+        post?: never;
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/internal/taskwrapper": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        /**
+         * Get TaskWrapper (schema generation only)
+         * @description Internal endpoint used only to ensure TaskWrapper 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.TaskWrapper"];
+                    };
+                };
+            };
+        };
+        put?: never;
+        post?: never;
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
     "/internal/telegram": {
         parameters: {
             query?: never;
@@ -13860,6 +14289,35 @@ export interface components {
             /** @description Additional metadata about the response, such as timestamps and request IDs */
             metadata?: components["schemas"]["api.Metadata"];
         };
+        "api.GetMediaByVideoFileErrorResponse": {
+            /** @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.GetMediaByVideoFileRequest": Record<string, never>;
+        "api.GetMediaByVideoFileResponse": {
+            media?: components["schemas"]["models.Media"];
+        };
+        "api.GetMediaByVideoFileSuccessResponse": {
+            /** @description Application-specific status code */
+            applicationStatusCode?: string;
+            data?: components["schemas"]["api.GetMediaByVideoFileResponse"];
+            /** @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.GetMediaErrorResponse": {
             /** @description Application-specific error code */
             applicationStatusCode?: string;
@@ -15281,6 +15739,18 @@ export interface components {
             eventData?: string;
             name?: string;
         };
+        "models.ExportFile": {
+            camera_id?: string;
+            key?: string;
+            provider?: string;
+            source?: string;
+            spriteFile?: string;
+            spriteInterval?: number;
+            spriteProvider?: string;
+            thumbnailFile?: string;
+            thumbnailProvider?: string;
+            timestamp?: number;
+        };
         "models.FaceRedaction": {
             id?: string;
             tracks?: components["schemas"]["models.FaceRedactionTrack"][];
@@ -15783,6 +16253,8 @@ export interface components {
              *     DeviceId is a unique identifier for the device, it can be used to identify the device in the system.
              *     OrganisationId is used to identify the organisation that owns the device.
              */
+            deviceId?: string;
+            /** @description device identifier */
             deviceKey?: string;
             /** @description Name of the device that uploaded media */
             deviceName?: string;
@@ -15872,6 +16344,31 @@ export interface components {
             /** @description in pixels */
             width?: number;
         };
+        "models.MediaUrlRequest": {
+            filename?: string;
+            provider?: string;
+            uriExpiryTime?: string;
+        };
+        "models.MediaUrlResponse": {
+            data?: string;
+        };
+        "models.MediaWrapper": {
+            description?: string;
+            index?: number;
+            instanceName?: string;
+            labels?: string[];
+            metadata?: components["schemas"]["models.Media"];
+            persisted?: boolean;
+            properties?: string[];
+            spriteUrl?: string;
+            src?: string;
+            task_created?: boolean;
+            thumbnailUrl?: string;
+            time?: string;
+            timestamp?: number;
+            type?: string;
+            vault?: boolean;
+        };
         "models.Message": {
             alert_id?: string;
             alert_master_user?: string;
@@ -16127,6 +16624,7 @@ export interface components {
         };
         "models.Region": {
             device?: string;
+            direction?: string;
             height?: number;
             id?: string;
             regionPoints?: components["schemas"]["models.Point"][];
@@ -16347,6 +16845,7 @@ export interface components {
         "models.Status": "pending" | "skipped" | "assigned" | "inProgress" | "completed" | "failed";
         "models.Storage": {
             access_key?: string;
+            provider?: string;
             secret_key?: string;
             uri?: string;
         };
@@ -16388,6 +16887,83 @@ export interface components {
             /** @description ID of the worker handling synchronization */
             workerId?: string;
         };
+        "models.Task": {
+            /** @description Users associated with this task */
+            assignees?: string[];
+            assignees_profile?: string[];
+            assignees_sent_to?: string[];
+            /** @description A task can be assigned to a single camera or multiple cameras (depending of the export) */
+            camera?: string;
+            /** @description this is for the camera names (is computed on demand) */
+            camera_names?: string[];
+            /** @description these are camera ids */
+            cameras?: string[];
+            /** @description Related collections */
+            comments?: components["schemas"]["models.Comment"][];
+            compressed_url?: string;
+            compressedFile?: string;
+            compressedProvider?: string;
+            creation_date?: number;
+            creation_datetime?: string;
+            date?: number;
+            downloaded_files?: string[];
+            export_files?: components["schemas"]["models.ExportFile"][];
+            export_files_count?: number;
+            /** @description "0% -> 100%" */
+            export_progress?: number;
+            /** @description An export task, is containing multiple video in a compressed file format (.zip) */
+            export_status?: string;
+            id?: string;
+            is_private?: boolean;
+            labels?: string[];
+            media_date?: string;
+            media_datetime?: string;
+            media_end_datetime?: string;
+            media_end_timestamp?: number;
+            media_timestamp?: number;
+            notes?: string;
+            notes_short?: string;
+            notify_assignees?: boolean;
+            reporter_email?: string;
+            reporter_id?: string;
+            reporter_profile?: string;
+            sequenceId?: string;
+            sprite_url?: string;
+            spriteFile?: string;
+            spriteInterval?: number;
+            spriteProvider?: string;
+            /** @description open, approved, rejected */
+            status?: string;
+            /** @description base 64 encoded */
+            thumbnail?: string;
+            thumbnail_url?: string;
+            thumbnailFile?: string;
+            thumbnailProvider?: string;
+            title?: string;
+            user_id?: string;
+            username?: string;
+            /**
+             * @description This is used for a single export, for a bulk export, we will use the first video as thumbnail and sprite.
+             *     Referencing to some media: video, thumbnail and sprite
+             */
+            video_url?: string;
+            videoFile?: string;
+            videoProvider?: string;
+        };
+        "models.TaskFilter": {
+            assignees?: string[];
+            devices?: string[];
+            groups?: string[];
+            labels?: string[];
+            limit?: number;
+            offset?: number;
+            sites?: string[];
+            status?: string[];
+            title?: string;
+        };
+        "models.TaskWrapper": {
+            task?: components["schemas"]["models.Task"];
+        };
         "models.Telegram": {
             channel?: string;
             enabled?: boolean;
@@ -16837,6 +17413,7 @@ export declare namespace models {
     type Email = components['schemas']['models.Email'];
     type Encryption = components['schemas']['models.Encryption'];
     type EventStage = components['schemas']['models.EventStage'];
+    type ExportFile = components['schemas']['models.ExportFile'];
     type FaceRedaction = components['schemas']['models.FaceRedaction'];
     type FaceRedactionTrack = components['schemas']['models.FaceRedactionTrack'];
     type FeaturePermissions = components['schemas']['models.FeaturePermissions'];
@@ -16877,6 +17454,9 @@ export declare namespace models {
     type Media = components['schemas']['models.Media'];
     type MediaAtRuntimeMetadata = components['schemas']['models.MediaAtRuntimeMetadata'];
     type MediaMetadata = components['schemas']['models.MediaMetadata'];
+    type MediaUrlRequest = components['schemas']['models.MediaUrlRequest'];
+    type MediaUrlResponse = components['schemas']['models.MediaUrlResponse'];
+    type MediaWrapper = components['schemas']['models.MediaWrapper'];
     type Message = components['schemas']['models.Message'];
     type Model = components['schemas']['models.Model'];
     type ModelOption = components['schemas']['models.ModelOption'];
@@ -16919,6 +17499,9 @@ export declare namespace models {
     type Subscription = components['schemas']['models.Subscription'];
     type Synchronize = components['schemas']['models.Synchronize'];
     type SynchronizeEvent = components['schemas']['models.SynchronizeEvent'];
+    type Task = components['schemas']['models.Task'];
+    type TaskFilter = components['schemas']['models.TaskFilter'];
+    type TaskWrapper = components['schemas']['models.TaskWrapper'];
     type Telegram = components['schemas']['models.Telegram'];
     type ThrottlerStage = components['schemas']['models.ThrottlerStage'];
     type Thumbnail = components['schemas']['models.Thumbnail'];
@@ -17021,6 +17604,9 @@ export declare namespace api {
     type GetMediaByIdRequest = components['schemas']['api.GetMediaByIdRequest'];
     type GetMediaByIdResponse = components['schemas']['api.GetMediaByIdResponse'];
     type GetMediaByIdSuccessResponse = components['schemas']['api.GetMediaByIdSuccessResponse'];
+    type GetMediaByVideoFileErrorResponse = components['schemas']['api.GetMediaByVideoFileErrorResponse'];
+    type GetMediaByVideoFileResponse = components['schemas']['api.GetMediaByVideoFileResponse'];
+    type GetMediaByVideoFileSuccessResponse = components['schemas']['api.GetMediaByVideoFileSuccessResponse'];
     type GetMediaErrorResponse = components['schemas']['api.GetMediaErrorResponse'];
     type GetMediaRequest = components['schemas']['api.GetMediaRequest'];
     type GetMediaResponse = components['schemas']['api.GetMediaResponse'];

package/package.json

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