@djangocfg/api 1.2.7 → 1.2.8

package/dist/index.cjs

@@ -131,6 +131,7 @@ __export(index_exports, {
   createCentrifugoTestingPublishTestCreate: () => createCentrifugoTestingPublishTestCreate,
   createCentrifugoTestingPublishWithLoggingCreate: () => createCentrifugoTestingPublishWithLoggingCreate,
   createCentrifugoTestingSendAckCreate: () => createCentrifugoTestingSendAckCreate,
+  createDashboardApiCommandsExecuteCreate: () => createDashboardApiCommandsExecuteCreate,
   createKnowbaseAdminChatCreate: () => createKnowbaseAdminChatCreate,
   createKnowbaseAdminChatQueryCreate: () => createKnowbaseAdminChatQueryCreate,
   createKnowbaseAdminDocumentsCreate: () => createKnowbaseAdminDocumentsCreate,
@@ -191,6 +192,7 @@ __export(index_exports, {
   getDashboardApiChartsRecentUsersList: () => getDashboardApiChartsRecentUsersList,
   getDashboardApiChartsRegistrationsRetrieve: () => getDashboardApiChartsRegistrationsRetrieve,
   getDashboardApiChartsTrackerList: () => getDashboardApiChartsTrackerList,
+  getDashboardApiCommandsHelpRetrieve: () => getDashboardApiCommandsHelpRetrieve,
   getDashboardApiCommandsList: () => getDashboardApiCommandsList,
   getDashboardApiCommandsSummaryRetrieve: () => getDashboardApiCommandsSummaryRetrieve,
   getDashboardApiOverviewOverviewRetrieve: () => getDashboardApiOverviewOverviewRetrieve,
@@ -892,6 +894,25 @@ var CfgDashboardCommands = class {
     const response = await this.client.request("GET", "/cfg/dashboard/api/commands/");
     return response;
   }
+  /**
+   * Get command help
+   * 
+   * Get detailed help text for a specific Django management command
+   */
+  async dashboardApiCommandsHelpRetrieve(id) {
+    const response = await this.client.request("GET", `/cfg/dashboard/api/commands/${id}/help/`);
+    return response;
+  }
+  /**
+   * Execute command
+   * 
+   * Execute a Django management command and stream output in Server-Sent
+   * Events format
+   */
+  async dashboardApiCommandsExecuteCreate(data) {
+    const response = await this.client.request("POST", "/cfg/dashboard/api/commands/execute/", { body: data });
+    return response;
+  }
   /**
    * Get commands summary
    * 
@@ -4989,6 +5010,9 @@ var OPENAPI_SCHEMA = {
           "help": {
             "type": "string"
           },
+          "is_allowed": {
+            "type": "boolean"
+          },
           "is_core": {
             "type": "boolean"
           },
@@ -4997,6 +5021,9 @@ var OPENAPI_SCHEMA = {
           },
           "name": {
             "type": "string"
+          },
+          "risk_level": {
+            "type": "string"
           }
         },
         "required": [
@@ -5008,6 +5035,64 @@ var OPENAPI_SCHEMA = {
         ],
         "type": "object"
       },
+      "CommandExecuteRequestRequest": {
+        "description": "Request serializer for command execution.",
+        "properties": {
+          "args": {
+            "description": "Positional arguments for the command",
+            "items": {
+              "minLength": 1,
+              "type": "string"
+            },
+            "type": "array"
+          },
+          "command": {
+            "description": "Name of the Django management command",
+            "minLength": 1,
+            "type": "string"
+          },
+          "options": {
+            "additionalProperties": {},
+            "description": "Named options for the command (e.g., {'verbosity': '2'})",
+            "type": "object"
+          }
+        },
+        "required": [
+          "command"
+        ],
+        "type": "object"
+      },
+      "CommandHelpResponse": {
+        "description": "Response serializer for command help.",
+        "properties": {
+          "app": {
+            "type": "string"
+          },
+          "command": {
+            "type": "string"
+          },
+          "error": {
+            "type": "string"
+          },
+          "help_text": {
+            "type": "string"
+          },
+          "is_allowed": {
+            "type": "boolean"
+          },
+          "risk_level": {
+            "type": "string"
+          },
+          "status": {
+            "type": "string"
+          }
+        },
+        "required": [
+          "command",
+          "status"
+        ],
+        "type": "object"
+      },
       "CommandsSummary": {
         "description": "Commands summary serializer.",
         "properties": {
@@ -12704,6 +12789,9 @@ var OPENAPI_SCHEMA = {
           }
         },
         "security": [
+          {
+            "jwtAuth": []
+          },
           {
             "cookieAuth": []
           },
@@ -12718,6 +12806,80 @@ var OPENAPI_SCHEMA = {
         "x-async-capable": false
       }
     },
+    "/cfg/dashboard/api/commands/execute/": {
+      "post": {
+        "description": "Execute a Django management command and stream output in Server-Sent Events format",
+        "operationId": "cfg_dashboard_api_commands_execute_create",
+        "requestBody": {
+          "content": {
+            "application/json": {
+              "schema": {
+                "$ref": "#/components/schemas/CommandExecuteRequestRequest"
+              }
+            },
+            "application/x-www-form-urlencoded": {
+              "schema": {
+                "$ref": "#/components/schemas/CommandExecuteRequestRequest"
+              }
+            },
+            "multipart/form-data": {
+              "schema": {
+                "$ref": "#/components/schemas/CommandExecuteRequestRequest"
+              }
+            }
+          },
+          "required": true
+        },
+        "responses": {
+          "200": {
+            "content": {
+              "application/json": {
+                "schema": {
+                  "description": "Command execution started (SSE stream)"
+                }
+              }
+            },
+            "description": ""
+          },
+          "400": {
+            "content": {
+              "application/json": {
+                "schema": {
+                  "description": "Invalid request"
+                }
+              }
+            },
+            "description": ""
+          },
+          "403": {
+            "content": {
+              "application/json": {
+                "schema": {
+                  "description": "Command not allowed"
+                }
+              }
+            },
+            "description": ""
+          }
+        },
+        "security": [
+          {
+            "jwtAuth": []
+          },
+          {
+            "cookieAuth": []
+          },
+          {
+            "basicAuth": []
+          }
+        ],
+        "summary": "Execute command",
+        "tags": [
+          "Dashboard - Commands"
+        ],
+        "x-async-capable": false
+      }
+    },
     "/cfg/dashboard/api/commands/summary/": {
       "get": {
         "description": "Retrieve commands summary with statistics and categorization",
@@ -12735,6 +12897,9 @@ var OPENAPI_SCHEMA = {
           }
         },
         "security": [
+          {
+            "jwtAuth": []
+          },
           {
             "cookieAuth": []
           },
@@ -12749,6 +12914,50 @@ var OPENAPI_SCHEMA = {
         "x-async-capable": false
       }
     },
+    "/cfg/dashboard/api/commands/{id}/help/": {
+      "get": {
+        "description": "Get detailed help text for a specific Django management command",
+        "operationId": "cfg_dashboard_api_commands_help_retrieve",
+        "parameters": [
+          {
+            "in": "path",
+            "name": "id",
+            "required": true,
+            "schema": {
+              "type": "string"
+            }
+          }
+        ],
+        "responses": {
+          "200": {
+            "content": {
+              "application/json": {
+                "schema": {
+                  "$ref": "#/components/schemas/CommandHelpResponse"
+                }
+              }
+            },
+            "description": ""
+          }
+        },
+        "security": [
+          {
+            "jwtAuth": []
+          },
+          {
+            "cookieAuth": []
+          },
+          {
+            "basicAuth": []
+          }
+        ],
+        "summary": "Get command help",
+        "tags": [
+          "Dashboard - Commands"
+        ],
+        "x-async-capable": false
+      }
+    },
     "/cfg/dashboard/api/overview/overview/": {
       "get": {
         "description": "Retrieve complete dashboard data including stats, health, actions, and metrics",
@@ -18905,6 +19114,8 @@ __export(schemas_exports, {
   ChatSourceRequestSchema: () => ChatSourceRequestSchema,
   ChatSourceSchema: () => ChatSourceSchema,
   ChunkRevectorizationRequestRequestSchema: () => ChunkRevectorizationRequestRequestSchema,
+  CommandExecuteRequestRequestSchema: () => CommandExecuteRequestRequestSchema,
+  CommandHelpResponseSchema: () => CommandHelpResponseSchema,
   CommandSchema: () => CommandSchema,
   CommandsSummarySchema: () => CommandsSummarySchema,
   ConnectionTokenRequestRequestSchema: () => ConnectionTokenRequestRequestSchema,
@@ -19607,566 +19818,560 @@ var CommandSchema = import_zod58.z.object({
   app: import_zod58.z.string(),
   help: import_zod58.z.string(),
   is_core: import_zod58.z.boolean(),
-  is_custom: import_zod58.z.boolean()
+  is_custom: import_zod58.z.boolean(),
+  is_allowed: import_zod58.z.boolean().optional(),
+  risk_level: import_zod58.z.string().optional()
 });
 
-// src/cfg/generated/_utils/schemas/CommandsSummary.schema.ts
+// src/cfg/generated/_utils/schemas/CommandExecuteRequestRequest.schema.ts
 var import_zod59 = require("zod");
-var CommandsSummarySchema = import_zod59.z.object({
-  total_commands: import_zod59.z.int(),
-  core_commands: import_zod59.z.int(),
-  custom_commands: import_zod59.z.int(),
-  categories: import_zod59.z.array(import_zod59.z.string()),
-  commands: import_zod59.z.array(CommandSchema),
-  categorized: import_zod59.z.record(import_zod59.z.string(), import_zod59.z.any())
+var CommandExecuteRequestRequestSchema = import_zod59.z.object({
+  command: import_zod59.z.string().min(1),
+  args: import_zod59.z.array(import_zod59.z.string().min(1)).optional(),
+  options: import_zod59.z.record(import_zod59.z.string(), import_zod59.z.any()).optional()
 });
 
-// src/cfg/generated/_utils/schemas/ConnectionTokenRequestRequest.schema.ts
+// src/cfg/generated/_utils/schemas/CommandHelpResponse.schema.ts
 var import_zod60 = require("zod");
-var ConnectionTokenRequestRequestSchema = import_zod60.z.object({
-  user_id: import_zod60.z.string(),
-  channels: import_zod60.z.array(import_zod60.z.string()).optional()
+var CommandHelpResponseSchema = import_zod60.z.object({
+  status: import_zod60.z.string(),
+  command: import_zod60.z.string(),
+  app: import_zod60.z.string().optional(),
+  help_text: import_zod60.z.string().optional(),
+  is_allowed: import_zod60.z.boolean().optional(),
+  risk_level: import_zod60.z.string().optional(),
+  error: import_zod60.z.string().optional()
 });
 
-// src/cfg/generated/_utils/schemas/ConnectionTokenResponse.schema.ts
+// src/cfg/generated/_utils/schemas/CommandsSummary.schema.ts
 var import_zod61 = require("zod");
-var ConnectionTokenResponseSchema = import_zod61.z.object({
-  token: import_zod61.z.string(),
-  centrifugo_url: import_zod61.z.string(),
-  expires_at: import_zod61.z.string()
+var CommandsSummarySchema = import_zod61.z.object({
+  total_commands: import_zod61.z.int(),
+  core_commands: import_zod61.z.int(),
+  custom_commands: import_zod61.z.int(),
+  categories: import_zod61.z.array(import_zod61.z.string()),
+  commands: import_zod61.z.array(CommandSchema),
+  categorized: import_zod61.z.record(import_zod61.z.string(), import_zod61.z.any())
 });
 
-// src/cfg/generated/_utils/schemas/Currency.schema.ts
+// src/cfg/generated/_utils/schemas/ConnectionTokenRequestRequest.schema.ts
 var import_zod62 = require("zod");
-var CurrencySchema = import_zod62.z.object({
-  code: import_zod62.z.string(),
-  name: import_zod62.z.string(),
-  token: import_zod62.z.string(),
-  network: import_zod62.z.string().nullable(),
-  display_name: import_zod62.z.string(),
-  symbol: import_zod62.z.string(),
-  decimal_places: import_zod62.z.int(),
-  is_active: import_zod62.z.boolean(),
-  min_amount_usd: import_zod62.z.string(),
-  sort_order: import_zod62.z.int()
+var ConnectionTokenRequestRequestSchema = import_zod62.z.object({
+  user_id: import_zod62.z.string(),
+  channels: import_zod62.z.array(import_zod62.z.string()).optional()
 });
 
-// src/cfg/generated/_utils/schemas/DashboardOverview.schema.ts
+// src/cfg/generated/_utils/schemas/ConnectionTokenResponse.schema.ts
 var import_zod63 = require("zod");
-var DashboardOverviewSchema = import_zod63.z.object({
-  stat_cards: import_zod63.z.array(import_zod63.z.record(import_zod63.z.string(), import_zod63.z.any())),
-  system_health: import_zod63.z.array(import_zod63.z.record(import_zod63.z.string(), import_zod63.z.any())),
-  quick_actions: import_zod63.z.array(import_zod63.z.record(import_zod63.z.string(), import_zod63.z.any())),
-  recent_activity: import_zod63.z.array(import_zod63.z.record(import_zod63.z.string(), import_zod63.z.any())),
-  system_metrics: import_zod63.z.record(import_zod63.z.string(), import_zod63.z.any()),
-  user_statistics: import_zod63.z.record(import_zod63.z.string(), import_zod63.z.any()),
-  timestamp: import_zod63.z.string()
+var ConnectionTokenResponseSchema = import_zod63.z.object({
+  token: import_zod63.z.string(),
+  centrifugo_url: import_zod63.z.string(),
+  expires_at: import_zod63.z.string()
 });
 
-// src/cfg/generated/_utils/schemas/Document.schema.ts
+// src/cfg/generated/_utils/schemas/Currency.schema.ts
 var import_zod64 = require("zod");
-var DocumentSchema = import_zod64.z.object({
-  id: import_zod64.z.uuid(),
-  title: import_zod64.z.string().max(512),
-  file_type: import_zod64.z.string().max(100).optional(),
-  file_size: import_zod64.z.int().min(0).max(2147483647).optional(),
-  processing_status: import_zod64.z.string(),
-  chunks_count: import_zod64.z.int(),
-  total_tokens: import_zod64.z.int(),
-  total_cost_usd: import_zod64.z.number(),
-  created_at: import_zod64.z.iso.datetime(),
-  updated_at: import_zod64.z.iso.datetime(),
-  processing_started_at: import_zod64.z.iso.datetime(),
-  processing_completed_at: import_zod64.z.iso.datetime(),
-  processing_error: import_zod64.z.string(),
-  metadata: import_zod64.z.string().nullable().optional()
+var CurrencySchema = import_zod64.z.object({
+  code: import_zod64.z.string(),
+  name: import_zod64.z.string(),
+  token: import_zod64.z.string(),
+  network: import_zod64.z.string().nullable(),
+  display_name: import_zod64.z.string(),
+  symbol: import_zod64.z.string(),
+  decimal_places: import_zod64.z.int(),
+  is_active: import_zod64.z.boolean(),
+  min_amount_usd: import_zod64.z.string(),
+  sort_order: import_zod64.z.int()
 });
 
-// src/cfg/generated/_utils/schemas/DocumentArchive.schema.ts
-var import_zod66 = require("zod");
-
-// src/cfg/generated/_utils/schemas/DocumentCategory.schema.ts
+// src/cfg/generated/_utils/schemas/DashboardOverview.schema.ts
 var import_zod65 = require("zod");
-var DocumentCategorySchema = import_zod65.z.object({
-  id: import_zod65.z.uuid(),
-  name: import_zod65.z.string().max(255),
-  description: import_zod65.z.string().optional(),
-  is_public: import_zod65.z.boolean().optional(),
-  created_at: import_zod65.z.iso.datetime()
+var DashboardOverviewSchema = import_zod65.z.object({
+  stat_cards: import_zod65.z.array(import_zod65.z.record(import_zod65.z.string(), import_zod65.z.any())),
+  system_health: import_zod65.z.array(import_zod65.z.record(import_zod65.z.string(), import_zod65.z.any())),
+  quick_actions: import_zod65.z.array(import_zod65.z.record(import_zod65.z.string(), import_zod65.z.any())),
+  recent_activity: import_zod65.z.array(import_zod65.z.record(import_zod65.z.string(), import_zod65.z.any())),
+  system_metrics: import_zod65.z.record(import_zod65.z.string(), import_zod65.z.any()),
+  user_statistics: import_zod65.z.record(import_zod65.z.string(), import_zod65.z.any()),
+  timestamp: import_zod65.z.string()
 });
 
-// src/cfg/generated/_utils/schemas/DocumentArchive.schema.ts
-var DocumentArchiveSchema = import_zod66.z.object({
+// src/cfg/generated/_utils/schemas/Document.schema.ts
+var import_zod66 = require("zod");
+var DocumentSchema = import_zod66.z.object({
   id: import_zod66.z.uuid(),
   title: import_zod66.z.string().max(512),
-  description: import_zod66.z.string().optional(),
-  categories: import_zod66.z.array(DocumentCategorySchema),
-  is_public: import_zod66.z.boolean().optional(),
-  archive_file: import_zod66.z.url(),
-  original_filename: import_zod66.z.string(),
-  file_size: import_zod66.z.int(),
-  archive_type: import_zod66.z.nativeEnum(DocumentArchiveArchiveType),
-  processing_status: import_zod66.z.nativeEnum(DocumentArchiveProcessingStatus),
-  processed_at: import_zod66.z.iso.datetime().nullable(),
-  processing_duration_ms: import_zod66.z.int(),
-  processing_error: import_zod66.z.string(),
-  total_items: import_zod66.z.int(),
-  processed_items: import_zod66.z.int(),
-  total_chunks: import_zod66.z.int(),
-  vectorized_chunks: import_zod66.z.int(),
+  file_type: import_zod66.z.string().max(100).optional(),
+  file_size: import_zod66.z.int().min(0).max(2147483647).optional(),
+  processing_status: import_zod66.z.string(),
+  chunks_count: import_zod66.z.int(),
   total_tokens: import_zod66.z.int(),
   total_cost_usd: import_zod66.z.number(),
-  processing_progress: import_zod66.z.number(),
-  vectorization_progress: import_zod66.z.number(),
-  is_processed: import_zod66.z.boolean(),
   created_at: import_zod66.z.iso.datetime(),
-  updated_at: import_zod66.z.iso.datetime()
+  updated_at: import_zod66.z.iso.datetime(),
+  processing_started_at: import_zod66.z.iso.datetime(),
+  processing_completed_at: import_zod66.z.iso.datetime(),
+  processing_error: import_zod66.z.string(),
+  metadata: import_zod66.z.string().nullable().optional()
 });
 
-// src/cfg/generated/_utils/schemas/DocumentArchiveDetail.schema.ts
+// src/cfg/generated/_utils/schemas/DocumentArchive.schema.ts
+var import_zod68 = require("zod");
+
+// src/cfg/generated/_utils/schemas/DocumentCategory.schema.ts
 var import_zod67 = require("zod");
-var DocumentArchiveDetailSchema = import_zod67.z.object({
+var DocumentCategorySchema = import_zod67.z.object({
   id: import_zod67.z.uuid(),
-  title: import_zod67.z.string().max(512),
+  name: import_zod67.z.string().max(255),
   description: import_zod67.z.string().optional(),
-  categories: import_zod67.z.array(DocumentCategorySchema),
   is_public: import_zod67.z.boolean().optional(),
-  archive_file: import_zod67.z.url(),
-  original_filename: import_zod67.z.string(),
-  file_size: import_zod67.z.int(),
-  archive_type: import_zod67.z.nativeEnum(DocumentArchiveDetailArchiveType),
-  processing_status: import_zod67.z.nativeEnum(DocumentArchiveDetailProcessingStatus),
-  processed_at: import_zod67.z.iso.datetime().nullable(),
-  processing_duration_ms: import_zod67.z.int(),
-  processing_error: import_zod67.z.string(),
-  total_items: import_zod67.z.int(),
-  processed_items: import_zod67.z.int(),
-  total_chunks: import_zod67.z.int(),
-  vectorized_chunks: import_zod67.z.int(),
-  total_tokens: import_zod67.z.int(),
-  total_cost_usd: import_zod67.z.number(),
-  processing_progress: import_zod67.z.number(),
-  vectorization_progress: import_zod67.z.number(),
-  is_processed: import_zod67.z.boolean(),
-  created_at: import_zod67.z.iso.datetime(),
-  updated_at: import_zod67.z.iso.datetime(),
-  items: import_zod67.z.array(ArchiveItemSchema),
-  file_tree: import_zod67.z.record(import_zod67.z.string(), import_zod67.z.any()),
-  metadata: import_zod67.z.string().nullable().optional()
+  created_at: import_zod67.z.iso.datetime()
 });
 
-// src/cfg/generated/_utils/schemas/DocumentArchiveList.schema.ts
-var import_zod68 = require("zod");
-var DocumentArchiveListSchema = import_zod68.z.object({
+// src/cfg/generated/_utils/schemas/DocumentArchive.schema.ts
+var DocumentArchiveSchema = import_zod68.z.object({
   id: import_zod68.z.uuid(),
-  title: import_zod68.z.string(),
-  description: import_zod68.z.string(),
+  title: import_zod68.z.string().max(512),
+  description: import_zod68.z.string().optional(),
   categories: import_zod68.z.array(DocumentCategorySchema),
-  is_public: import_zod68.z.boolean(),
+  is_public: import_zod68.z.boolean().optional(),
+  archive_file: import_zod68.z.url(),
   original_filename: import_zod68.z.string(),
   file_size: import_zod68.z.int(),
-  archive_type: import_zod68.z.nativeEnum(DocumentArchiveListArchiveType),
-  processing_status: import_zod68.z.nativeEnum(DocumentArchiveListProcessingStatus),
+  archive_type: import_zod68.z.nativeEnum(DocumentArchiveArchiveType),
+  processing_status: import_zod68.z.nativeEnum(DocumentArchiveProcessingStatus),
   processed_at: import_zod68.z.iso.datetime().nullable(),
+  processing_duration_ms: import_zod68.z.int(),
+  processing_error: import_zod68.z.string(),
   total_items: import_zod68.z.int(),
+  processed_items: import_zod68.z.int(),
   total_chunks: import_zod68.z.int(),
+  vectorized_chunks: import_zod68.z.int(),
+  total_tokens: import_zod68.z.int(),
   total_cost_usd: import_zod68.z.number(),
   processing_progress: import_zod68.z.number(),
-  created_at: import_zod68.z.iso.datetime()
+  vectorization_progress: import_zod68.z.number(),
+  is_processed: import_zod68.z.boolean(),
+  created_at: import_zod68.z.iso.datetime(),
+  updated_at: import_zod68.z.iso.datetime()
 });
 
-// src/cfg/generated/_utils/schemas/DocumentArchiveRequest.schema.ts
+// src/cfg/generated/_utils/schemas/DocumentArchiveDetail.schema.ts
 var import_zod69 = require("zod");
-var DocumentArchiveRequestSchema = import_zod69.z.object({
-  title: import_zod69.z.string().min(1).max(512),
+var DocumentArchiveDetailSchema = import_zod69.z.object({
+  id: import_zod69.z.uuid(),
+  title: import_zod69.z.string().max(512),
   description: import_zod69.z.string().optional(),
-  is_public: import_zod69.z.boolean().optional()
+  categories: import_zod69.z.array(DocumentCategorySchema),
+  is_public: import_zod69.z.boolean().optional(),
+  archive_file: import_zod69.z.url(),
+  original_filename: import_zod69.z.string(),
+  file_size: import_zod69.z.int(),
+  archive_type: import_zod69.z.nativeEnum(DocumentArchiveDetailArchiveType),
+  processing_status: import_zod69.z.nativeEnum(DocumentArchiveDetailProcessingStatus),
+  processed_at: import_zod69.z.iso.datetime().nullable(),
+  processing_duration_ms: import_zod69.z.int(),
+  processing_error: import_zod69.z.string(),
+  total_items: import_zod69.z.int(),
+  processed_items: import_zod69.z.int(),
+  total_chunks: import_zod69.z.int(),
+  vectorized_chunks: import_zod69.z.int(),
+  total_tokens: import_zod69.z.int(),
+  total_cost_usd: import_zod69.z.number(),
+  processing_progress: import_zod69.z.number(),
+  vectorization_progress: import_zod69.z.number(),
+  is_processed: import_zod69.z.boolean(),
+  created_at: import_zod69.z.iso.datetime(),
+  updated_at: import_zod69.z.iso.datetime(),
+  items: import_zod69.z.array(ArchiveItemSchema),
+  file_tree: import_zod69.z.record(import_zod69.z.string(), import_zod69.z.any()),
+  metadata: import_zod69.z.string().nullable().optional()
 });
 
-// src/cfg/generated/_utils/schemas/DocumentCategoryRequest.schema.ts
+// src/cfg/generated/_utils/schemas/DocumentArchiveList.schema.ts
 var import_zod70 = require("zod");
-var DocumentCategoryRequestSchema = import_zod70.z.object({
-  name: import_zod70.z.string().min(1).max(255),
-  description: import_zod70.z.string().optional(),
-  is_public: import_zod70.z.boolean().optional()
+var DocumentArchiveListSchema = import_zod70.z.object({
+  id: import_zod70.z.uuid(),
+  title: import_zod70.z.string(),
+  description: import_zod70.z.string(),
+  categories: import_zod70.z.array(DocumentCategorySchema),
+  is_public: import_zod70.z.boolean(),
+  original_filename: import_zod70.z.string(),
+  file_size: import_zod70.z.int(),
+  archive_type: import_zod70.z.nativeEnum(DocumentArchiveListArchiveType),
+  processing_status: import_zod70.z.nativeEnum(DocumentArchiveListProcessingStatus),
+  processed_at: import_zod70.z.iso.datetime().nullable(),
+  total_items: import_zod70.z.int(),
+  total_chunks: import_zod70.z.int(),
+  total_cost_usd: import_zod70.z.number(),
+  processing_progress: import_zod70.z.number(),
+  created_at: import_zod70.z.iso.datetime()
 });
 
-// src/cfg/generated/_utils/schemas/DocumentCreateRequest.schema.ts
+// src/cfg/generated/_utils/schemas/DocumentArchiveRequest.schema.ts
 var import_zod71 = require("zod");
-var DocumentCreateRequestSchema = import_zod71.z.object({
+var DocumentArchiveRequestSchema = import_zod71.z.object({
   title: import_zod71.z.string().min(1).max(512),
-  content: import_zod71.z.string().min(10).max(1e6),
-  file_type: import_zod71.z.string().min(1).optional(),
-  metadata: import_zod71.z.string().optional()
+  description: import_zod71.z.string().optional(),
+  is_public: import_zod71.z.boolean().optional()
 });
 
-// src/cfg/generated/_utils/schemas/DocumentProcessingStatus.schema.ts
+// src/cfg/generated/_utils/schemas/DocumentCategoryRequest.schema.ts
 var import_zod72 = require("zod");
-var DocumentProcessingStatusSchema = import_zod72.z.object({
-  id: import_zod72.z.uuid(),
-  status: import_zod72.z.string(),
-  progress: import_zod72.z.string(),
-  error: import_zod72.z.string().nullable().optional(),
-  processing_time_seconds: import_zod72.z.number().nullable().optional()
+var DocumentCategoryRequestSchema = import_zod72.z.object({
+  name: import_zod72.z.string().min(1).max(255),
+  description: import_zod72.z.string().optional(),
+  is_public: import_zod72.z.boolean().optional()
 });
 
-// src/cfg/generated/_utils/schemas/DocumentRequest.schema.ts
+// src/cfg/generated/_utils/schemas/DocumentCreateRequest.schema.ts
 var import_zod73 = require("zod");
-var DocumentRequestSchema = import_zod73.z.object({
+var DocumentCreateRequestSchema = import_zod73.z.object({
   title: import_zod73.z.string().min(1).max(512),
-  file_type: import_zod73.z.string().min(1).max(100).optional(),
-  file_size: import_zod73.z.int().min(0).max(2147483647).optional(),
-  metadata: import_zod73.z.string().nullable().optional()
+  content: import_zod73.z.string().min(10).max(1e6),
+  file_type: import_zod73.z.string().min(1).optional(),
+  metadata: import_zod73.z.string().optional()
 });
 
-// src/cfg/generated/_utils/schemas/DocumentStats.schema.ts
+// src/cfg/generated/_utils/schemas/DocumentProcessingStatus.schema.ts
 var import_zod74 = require("zod");
-var DocumentStatsSchema = import_zod74.z.object({
-  total_documents: import_zod74.z.int(),
-  completed_documents: import_zod74.z.int(),
-  processing_success_rate: import_zod74.z.number(),
-  total_chunks: import_zod74.z.int(),
-  total_tokens: import_zod74.z.int(),
-  total_cost_usd: import_zod74.z.number(),
-  avg_processing_time_seconds: import_zod74.z.number()
+var DocumentProcessingStatusSchema = import_zod74.z.object({
+  id: import_zod74.z.uuid(),
+  status: import_zod74.z.string(),
+  progress: import_zod74.z.string(),
+  error: import_zod74.z.string().nullable().optional(),
+  processing_time_seconds: import_zod74.z.number().nullable().optional()
 });
 
-// src/cfg/generated/_utils/schemas/EmailLog.schema.ts
+// src/cfg/generated/_utils/schemas/DocumentRequest.schema.ts
 var import_zod75 = require("zod");
-var EmailLogSchema = import_zod75.z.object({
-  id: import_zod75.z.uuid(),
-  user: import_zod75.z.int().nullable(),
-  user_email: import_zod75.z.string(),
-  newsletter: import_zod75.z.int().nullable(),
-  newsletter_title: import_zod75.z.string(),
-  recipient: import_zod75.z.string(),
-  subject: import_zod75.z.string(),
-  body: import_zod75.z.string(),
-  status: import_zod75.z.nativeEnum(EmailLogStatus),
-  created_at: import_zod75.z.iso.datetime(),
-  sent_at: import_zod75.z.iso.datetime().nullable(),
-  error_message: import_zod75.z.string().nullable()
+var DocumentRequestSchema = import_zod75.z.object({
+  title: import_zod75.z.string().min(1).max(512),
+  file_type: import_zod75.z.string().min(1).max(100).optional(),
+  file_size: import_zod75.z.int().min(0).max(2147483647).optional(),
+  metadata: import_zod75.z.string().nullable().optional()
 });
 
-// src/cfg/generated/_utils/schemas/Endpoint.schema.ts
+// src/cfg/generated/_utils/schemas/DocumentStats.schema.ts
 var import_zod76 = require("zod");
-var EndpointSchema = import_zod76.z.object({
-  url: import_zod76.z.string(),
-  url_pattern: import_zod76.z.string().nullable().optional(),
-  url_name: import_zod76.z.string().nullable().optional(),
-  namespace: import_zod76.z.string().optional(),
-  group: import_zod76.z.string(),
-  view: import_zod76.z.string().optional(),
-  status: import_zod76.z.string(),
-  status_code: import_zod76.z.int().nullable().optional(),
-  response_time_ms: import_zod76.z.number().nullable().optional(),
-  is_healthy: import_zod76.z.boolean().nullable().optional(),
-  error: import_zod76.z.string().optional(),
-  error_type: import_zod76.z.string().optional(),
-  reason: import_zod76.z.string().optional(),
-  last_checked: import_zod76.z.iso.datetime().nullable().optional(),
-  has_parameters: import_zod76.z.boolean().optional(),
-  required_auth: import_zod76.z.boolean().optional(),
-  rate_limited: import_zod76.z.boolean().optional()
+var DocumentStatsSchema = import_zod76.z.object({
+  total_documents: import_zod76.z.int(),
+  completed_documents: import_zod76.z.int(),
+  processing_success_rate: import_zod76.z.number(),
+  total_chunks: import_zod76.z.int(),
+  total_tokens: import_zod76.z.int(),
+  total_cost_usd: import_zod76.z.number(),
+  avg_processing_time_seconds: import_zod76.z.number()
 });
 
-// src/cfg/generated/_utils/schemas/EndpointsStatus.schema.ts
+// src/cfg/generated/_utils/schemas/EmailLog.schema.ts
 var import_zod77 = require("zod");
-var EndpointsStatusSchema = import_zod77.z.object({
-  status: import_zod77.z.string(),
-  timestamp: import_zod77.z.iso.datetime(),
-  total_endpoints: import_zod77.z.int(),
-  healthy: import_zod77.z.int(),
-  unhealthy: import_zod77.z.int(),
-  warnings: import_zod77.z.int(),
-  errors: import_zod77.z.int(),
-  skipped: import_zod77.z.int(),
-  endpoints: import_zod77.z.array(EndpointSchema)
+var EmailLogSchema = import_zod77.z.object({
+  id: import_zod77.z.uuid(),
+  user: import_zod77.z.int().nullable(),
+  user_email: import_zod77.z.string(),
+  newsletter: import_zod77.z.int().nullable(),
+  newsletter_title: import_zod77.z.string(),
+  recipient: import_zod77.z.string(),
+  subject: import_zod77.z.string(),
+  body: import_zod77.z.string(),
+  status: import_zod77.z.nativeEnum(EmailLogStatus),
+  created_at: import_zod77.z.iso.datetime(),
+  sent_at: import_zod77.z.iso.datetime().nullable(),
+  error_message: import_zod77.z.string().nullable()
 });
 
-// src/cfg/generated/_utils/schemas/ErrorResponse.schema.ts
+// src/cfg/generated/_utils/schemas/Endpoint.schema.ts
 var import_zod78 = require("zod");
-var ErrorResponseSchema = import_zod78.z.object({
-  success: import_zod78.z.boolean().optional(),
-  message: import_zod78.z.string()
+var EndpointSchema = import_zod78.z.object({
+  url: import_zod78.z.string(),
+  url_pattern: import_zod78.z.string().nullable().optional(),
+  url_name: import_zod78.z.string().nullable().optional(),
+  namespace: import_zod78.z.string().optional(),
+  group: import_zod78.z.string(),
+  view: import_zod78.z.string().optional(),
+  status: import_zod78.z.string(),
+  status_code: import_zod78.z.int().nullable().optional(),
+  response_time_ms: import_zod78.z.number().nullable().optional(),
+  is_healthy: import_zod78.z.boolean().nullable().optional(),
+  error: import_zod78.z.string().optional(),
+  error_type: import_zod78.z.string().optional(),
+  reason: import_zod78.z.string().optional(),
+  last_checked: import_zod78.z.iso.datetime().nullable().optional(),
+  has_parameters: import_zod78.z.boolean().optional(),
+  required_auth: import_zod78.z.boolean().optional(),
+  rate_limited: import_zod78.z.boolean().optional()
 });
 
-// src/cfg/generated/_utils/schemas/HealthCheck.schema.ts
+// src/cfg/generated/_utils/schemas/EndpointsStatus.schema.ts
 var import_zod79 = require("zod");
-var HealthCheckSchema = import_zod79.z.object({
+var EndpointsStatusSchema = import_zod79.z.object({
   status: import_zod79.z.string(),
-  wrapper_url: import_zod79.z.string(),
-  has_api_key: import_zod79.z.boolean(),
-  timestamp: import_zod79.z.string()
+  timestamp: import_zod79.z.iso.datetime(),
+  total_endpoints: import_zod79.z.int(),
+  healthy: import_zod79.z.int(),
+  unhealthy: import_zod79.z.int(),
+  warnings: import_zod79.z.int(),
+  errors: import_zod79.z.int(),
+  skipped: import_zod79.z.int(),
+  endpoints: import_zod79.z.array(EndpointSchema)
 });
 
-// src/cfg/generated/_utils/schemas/LeadSubmission.schema.ts
+// src/cfg/generated/_utils/schemas/ErrorResponse.schema.ts
 var import_zod80 = require("zod");
-var LeadSubmissionSchema = import_zod80.z.object({
-  name: import_zod80.z.string().max(200),
-  email: import_zod80.z.email(),
-  company: import_zod80.z.string().max(200).nullable().optional(),
-  company_site: import_zod80.z.string().max(200).nullable().optional(),
-  contact_type: import_zod80.z.nativeEnum(LeadSubmissionContactType).optional(),
-  contact_value: import_zod80.z.string().max(200).nullable().optional(),
-  subject: import_zod80.z.string().max(200).nullable().optional(),
-  message: import_zod80.z.string(),
-  extra: import_zod80.z.string().nullable().optional(),
-  site_url: import_zod80.z.url()
+var ErrorResponseSchema = import_zod80.z.object({
+  success: import_zod80.z.boolean().optional(),
+  message: import_zod80.z.string()
 });
 
-// src/cfg/generated/_utils/schemas/LeadSubmissionError.schema.ts
+// src/cfg/generated/_utils/schemas/HealthCheck.schema.ts
 var import_zod81 = require("zod");
-var LeadSubmissionErrorSchema = import_zod81.z.object({
-  success: import_zod81.z.boolean(),
-  error: import_zod81.z.string(),
-  details: import_zod81.z.record(import_zod81.z.string(), import_zod81.z.any()).optional()
+var HealthCheckSchema = import_zod81.z.object({
+  status: import_zod81.z.string(),
+  wrapper_url: import_zod81.z.string(),
+  has_api_key: import_zod81.z.boolean(),
+  timestamp: import_zod81.z.string()
 });
 
-// src/cfg/generated/_utils/schemas/LeadSubmissionRequest.schema.ts
+// src/cfg/generated/_utils/schemas/LeadSubmission.schema.ts
 var import_zod82 = require("zod");
-var LeadSubmissionRequestSchema = import_zod82.z.object({
-  name: import_zod82.z.string().min(1).max(200),
+var LeadSubmissionSchema = import_zod82.z.object({
+  name: import_zod82.z.string().max(200),
   email: import_zod82.z.email(),
   company: import_zod82.z.string().max(200).nullable().optional(),
   company_site: import_zod82.z.string().max(200).nullable().optional(),
-  contact_type: import_zod82.z.nativeEnum(LeadSubmissionRequestContactType).optional(),
+  contact_type: import_zod82.z.nativeEnum(LeadSubmissionContactType).optional(),
   contact_value: import_zod82.z.string().max(200).nullable().optional(),
   subject: import_zod82.z.string().max(200).nullable().optional(),
-  message: import_zod82.z.string().min(1),
+  message: import_zod82.z.string(),
   extra: import_zod82.z.string().nullable().optional(),
   site_url: import_zod82.z.url()
 });
 
-// src/cfg/generated/_utils/schemas/LeadSubmissionResponse.schema.ts
+// src/cfg/generated/_utils/schemas/LeadSubmissionError.schema.ts
 var import_zod83 = require("zod");
-var LeadSubmissionResponseSchema = import_zod83.z.object({
+var LeadSubmissionErrorSchema = import_zod83.z.object({
   success: import_zod83.z.boolean(),
-  message: import_zod83.z.string(),
-  lead_id: import_zod83.z.int()
+  error: import_zod83.z.string(),
+  details: import_zod83.z.record(import_zod83.z.string(), import_zod83.z.any()).optional()
 });
 
-// src/cfg/generated/_utils/schemas/ManualAckRequestRequest.schema.ts
+// src/cfg/generated/_utils/schemas/LeadSubmissionRequest.schema.ts
 var import_zod84 = require("zod");
-var ManualAckRequestRequestSchema = import_zod84.z.object({
-  message_id: import_zod84.z.string(),
-  client_id: import_zod84.z.string()
+var LeadSubmissionRequestSchema = import_zod84.z.object({
+  name: import_zod84.z.string().min(1).max(200),
+  email: import_zod84.z.email(),
+  company: import_zod84.z.string().max(200).nullable().optional(),
+  company_site: import_zod84.z.string().max(200).nullable().optional(),
+  contact_type: import_zod84.z.nativeEnum(LeadSubmissionRequestContactType).optional(),
+  contact_value: import_zod84.z.string().max(200).nullable().optional(),
+  subject: import_zod84.z.string().max(200).nullable().optional(),
+  message: import_zod84.z.string().min(1),
+  extra: import_zod84.z.string().nullable().optional(),
+  site_url: import_zod84.z.url()
 });
 
-// src/cfg/generated/_utils/schemas/ManualAckResponse.schema.ts
+// src/cfg/generated/_utils/schemas/LeadSubmissionResponse.schema.ts
 var import_zod85 = require("zod");
-var ManualAckResponseSchema = import_zod85.z.object({
+var LeadSubmissionResponseSchema = import_zod85.z.object({
   success: import_zod85.z.boolean(),
-  message_id: import_zod85.z.string(),
-  error: import_zod85.z.string().nullable().optional()
+  message: import_zod85.z.string(),
+  lead_id: import_zod85.z.int()
 });
 
-// src/cfg/generated/_utils/schemas/Message.schema.ts
-var import_zod87 = require("zod");
-
-// src/cfg/generated/_utils/schemas/Sender.schema.ts
+// src/cfg/generated/_utils/schemas/ManualAckRequestRequest.schema.ts
 var import_zod86 = require("zod");
-var SenderSchema = import_zod86.z.object({
-  id: import_zod86.z.int(),
-  display_username: import_zod86.z.string(),
-  email: import_zod86.z.email(),
-  avatar: import_zod86.z.string().nullable(),
-  initials: import_zod86.z.string(),
-  is_staff: import_zod86.z.boolean(),
-  is_superuser: import_zod86.z.boolean()
+var ManualAckRequestRequestSchema = import_zod86.z.object({
+  message_id: import_zod86.z.string(),
+  client_id: import_zod86.z.string()
 });
 
-// src/cfg/generated/_utils/schemas/Message.schema.ts
-var MessageSchema = import_zod87.z.object({
-  uuid: import_zod87.z.uuid(),
-  ticket: import_zod87.z.uuid(),
-  sender: SenderSchema,
-  is_from_author: import_zod87.z.boolean(),
-  text: import_zod87.z.string(),
-  created_at: import_zod87.z.iso.datetime()
+// src/cfg/generated/_utils/schemas/ManualAckResponse.schema.ts
+var import_zod87 = require("zod");
+var ManualAckResponseSchema = import_zod87.z.object({
+  success: import_zod87.z.boolean(),
+  message_id: import_zod87.z.string(),
+  error: import_zod87.z.string().nullable().optional()
 });
 
-// src/cfg/generated/_utils/schemas/MessageCreate.schema.ts
+// src/cfg/generated/_utils/schemas/Message.schema.ts
+var import_zod89 = require("zod");
+
+// src/cfg/generated/_utils/schemas/Sender.schema.ts
 var import_zod88 = require("zod");
-var MessageCreateSchema = import_zod88.z.object({
-  text: import_zod88.z.string()
+var SenderSchema = import_zod88.z.object({
+  id: import_zod88.z.int(),
+  display_username: import_zod88.z.string(),
+  email: import_zod88.z.email(),
+  avatar: import_zod88.z.string().nullable(),
+  initials: import_zod88.z.string(),
+  is_staff: import_zod88.z.boolean(),
+  is_superuser: import_zod88.z.boolean()
 });
 
-// src/cfg/generated/_utils/schemas/MessageCreateRequest.schema.ts
-var import_zod89 = require("zod");
-var MessageCreateRequestSchema = import_zod89.z.object({
-  text: import_zod89.z.string().min(1)
+// src/cfg/generated/_utils/schemas/Message.schema.ts
+var MessageSchema = import_zod89.z.object({
+  uuid: import_zod89.z.uuid(),
+  ticket: import_zod89.z.uuid(),
+  sender: SenderSchema,
+  is_from_author: import_zod89.z.boolean(),
+  text: import_zod89.z.string(),
+  created_at: import_zod89.z.iso.datetime()
 });
 
-// src/cfg/generated/_utils/schemas/MessageRequest.schema.ts
+// src/cfg/generated/_utils/schemas/MessageCreate.schema.ts
 var import_zod90 = require("zod");
-var MessageRequestSchema = import_zod90.z.object({
-  text: import_zod90.z.string().min(1)
+var MessageCreateSchema = import_zod90.z.object({
+  text: import_zod90.z.string()
 });
 
-// src/cfg/generated/_utils/schemas/Newsletter.schema.ts
+// src/cfg/generated/_utils/schemas/MessageCreateRequest.schema.ts
 var import_zod91 = require("zod");
-var NewsletterSchema = import_zod91.z.object({
-  id: import_zod91.z.int(),
-  title: import_zod91.z.string().max(255),
-  description: import_zod91.z.string().optional(),
-  is_active: import_zod91.z.boolean().optional(),
-  auto_subscribe: import_zod91.z.boolean().optional(),
-  created_at: import_zod91.z.iso.datetime(),
-  updated_at: import_zod91.z.iso.datetime(),
-  subscribers_count: import_zod91.z.int()
+var MessageCreateRequestSchema = import_zod91.z.object({
+  text: import_zod91.z.string().min(1)
 });
 
-// src/cfg/generated/_utils/schemas/NewsletterCampaign.schema.ts
+// src/cfg/generated/_utils/schemas/MessageRequest.schema.ts
 var import_zod92 = require("zod");
-var NewsletterCampaignSchema = import_zod92.z.object({
-  id: import_zod92.z.int(),
-  newsletter: import_zod92.z.int(),
-  newsletter_title: import_zod92.z.string(),
-  subject: import_zod92.z.string().max(255),
-  email_title: import_zod92.z.string().max(255),
-  main_text: import_zod92.z.string(),
-  main_html_content: import_zod92.z.string().optional(),
-  button_text: import_zod92.z.string().max(100).optional(),
-  button_url: import_zod92.z.url().optional(),
-  secondary_text: import_zod92.z.string().optional(),
-  status: import_zod92.z.nativeEnum(NewsletterCampaignStatus),
-  created_at: import_zod92.z.iso.datetime(),
-  sent_at: import_zod92.z.iso.datetime().nullable(),
-  recipient_count: import_zod92.z.int()
+var MessageRequestSchema = import_zod92.z.object({
+  text: import_zod92.z.string().min(1)
 });
 
-// src/cfg/generated/_utils/schemas/NewsletterCampaignRequest.schema.ts
+// src/cfg/generated/_utils/schemas/Newsletter.schema.ts
 var import_zod93 = require("zod");
-var NewsletterCampaignRequestSchema = import_zod93.z.object({
-  newsletter: import_zod93.z.int(),
-  subject: import_zod93.z.string().min(1).max(255),
-  email_title: import_zod93.z.string().min(1).max(255),
-  main_text: import_zod93.z.string().min(1),
-  main_html_content: import_zod93.z.string().optional(),
-  button_text: import_zod93.z.string().max(100).optional(),
-  button_url: import_zod93.z.url().optional(),
-  secondary_text: import_zod93.z.string().optional()
+var NewsletterSchema = import_zod93.z.object({
+  id: import_zod93.z.int(),
+  title: import_zod93.z.string().max(255),
+  description: import_zod93.z.string().optional(),
+  is_active: import_zod93.z.boolean().optional(),
+  auto_subscribe: import_zod93.z.boolean().optional(),
+  created_at: import_zod93.z.iso.datetime(),
+  updated_at: import_zod93.z.iso.datetime(),
+  subscribers_count: import_zod93.z.int()
 });
 
-// src/cfg/generated/_utils/schemas/NewsletterSubscription.schema.ts
+// src/cfg/generated/_utils/schemas/NewsletterCampaign.schema.ts
 var import_zod94 = require("zod");
-var NewsletterSubscriptionSchema = import_zod94.z.object({
+var NewsletterCampaignSchema = import_zod94.z.object({
   id: import_zod94.z.int(),
   newsletter: import_zod94.z.int(),
   newsletter_title: import_zod94.z.string(),
-  user: import_zod94.z.int().nullable().optional(),
-  user_email: import_zod94.z.string(),
-  email: import_zod94.z.email(),
-  is_active: import_zod94.z.boolean().optional(),
-  subscribed_at: import_zod94.z.iso.datetime(),
-  unsubscribed_at: import_zod94.z.iso.datetime().nullable()
+  subject: import_zod94.z.string().max(255),
+  email_title: import_zod94.z.string().max(255),
+  main_text: import_zod94.z.string(),
+  main_html_content: import_zod94.z.string().optional(),
+  button_text: import_zod94.z.string().max(100).optional(),
+  button_url: import_zod94.z.url().optional(),
+  secondary_text: import_zod94.z.string().optional(),
+  status: import_zod94.z.nativeEnum(NewsletterCampaignStatus),
+  created_at: import_zod94.z.iso.datetime(),
+  sent_at: import_zod94.z.iso.datetime().nullable(),
+  recipient_count: import_zod94.z.int()
 });
 
-// src/cfg/generated/_utils/schemas/OTPErrorResponse.schema.ts
+// src/cfg/generated/_utils/schemas/NewsletterCampaignRequest.schema.ts
 var import_zod95 = require("zod");
-var OTPErrorResponseSchema = import_zod95.z.object({
-  error: import_zod95.z.string()
+var NewsletterCampaignRequestSchema = import_zod95.z.object({
+  newsletter: import_zod95.z.int(),
+  subject: import_zod95.z.string().min(1).max(255),
+  email_title: import_zod95.z.string().min(1).max(255),
+  main_text: import_zod95.z.string().min(1),
+  main_html_content: import_zod95.z.string().optional(),
+  button_text: import_zod95.z.string().max(100).optional(),
+  button_url: import_zod95.z.url().optional(),
+  secondary_text: import_zod95.z.string().optional()
 });
 
-// src/cfg/generated/_utils/schemas/OTPRequestRequest.schema.ts
+// src/cfg/generated/_utils/schemas/NewsletterSubscription.schema.ts
 var import_zod96 = require("zod");
-var OTPRequestRequestSchema = import_zod96.z.object({
-  identifier: import_zod96.z.string().min(1),
-  channel: import_zod96.z.nativeEnum(OTPRequestRequestChannel).optional(),
-  source_url: import_zod96.z.url().optional()
+var NewsletterSubscriptionSchema = import_zod96.z.object({
+  id: import_zod96.z.int(),
+  newsletter: import_zod96.z.int(),
+  newsletter_title: import_zod96.z.string(),
+  user: import_zod96.z.int().nullable().optional(),
+  user_email: import_zod96.z.string(),
+  email: import_zod96.z.email(),
+  is_active: import_zod96.z.boolean().optional(),
+  subscribed_at: import_zod96.z.iso.datetime(),
+  unsubscribed_at: import_zod96.z.iso.datetime().nullable()
 });
 
-// src/cfg/generated/_utils/schemas/OTPRequestResponse.schema.ts
+// src/cfg/generated/_utils/schemas/OTPErrorResponse.schema.ts
 var import_zod97 = require("zod");
-var OTPRequestResponseSchema = import_zod97.z.object({
-  message: import_zod97.z.string()
+var OTPErrorResponseSchema = import_zod97.z.object({
+  error: import_zod97.z.string()
 });
 
-// src/cfg/generated/_utils/schemas/OTPVerifyRequest.schema.ts
+// src/cfg/generated/_utils/schemas/OTPRequestRequest.schema.ts
 var import_zod98 = require("zod");
-var OTPVerifyRequestSchema = import_zod98.z.object({
+var OTPRequestRequestSchema = import_zod98.z.object({
   identifier: import_zod98.z.string().min(1),
-  otp: import_zod98.z.string().min(6).max(6),
-  channel: import_zod98.z.nativeEnum(OTPVerifyRequestChannel).optional(),
+  channel: import_zod98.z.nativeEnum(OTPRequestRequestChannel).optional(),
   source_url: import_zod98.z.url().optional()
 });
 
-// src/cfg/generated/_utils/schemas/OTPVerifyResponse.schema.ts
-var import_zod100 = require("zod");
-
-// src/cfg/generated/_utils/schemas/User.schema.ts
+// src/cfg/generated/_utils/schemas/OTPRequestResponse.schema.ts
 var import_zod99 = require("zod");
-var UserSchema = import_zod99.z.object({
-  id: import_zod99.z.int(),
-  email: import_zod99.z.email(),
-  first_name: import_zod99.z.string().max(50).optional(),
-  last_name: import_zod99.z.string().max(50).optional(),
-  full_name: import_zod99.z.string(),
-  initials: import_zod99.z.string(),
-  display_username: import_zod99.z.string(),
-  company: import_zod99.z.string().max(100).optional(),
-  phone: import_zod99.z.string().max(20).optional(),
-  position: import_zod99.z.string().max(100).optional(),
-  avatar: import_zod99.z.url().nullable(),
-  is_staff: import_zod99.z.boolean(),
-  is_superuser: import_zod99.z.boolean(),
-  date_joined: import_zod99.z.iso.datetime(),
-  last_login: import_zod99.z.iso.datetime().nullable(),
-  unanswered_messages_count: import_zod99.z.int()
+var OTPRequestResponseSchema = import_zod99.z.object({
+  message: import_zod99.z.string()
 });
 
-// src/cfg/generated/_utils/schemas/OTPVerifyResponse.schema.ts
-var OTPVerifyResponseSchema = import_zod100.z.object({
-  refresh: import_zod100.z.string(),
-  access: import_zod100.z.string(),
-  user: UserSchema
+// src/cfg/generated/_utils/schemas/OTPVerifyRequest.schema.ts
+var import_zod100 = require("zod");
+var OTPVerifyRequestSchema = import_zod100.z.object({
+  identifier: import_zod100.z.string().min(1),
+  otp: import_zod100.z.string().min(6).max(6),
+  channel: import_zod100.z.nativeEnum(OTPVerifyRequestChannel).optional(),
+  source_url: import_zod100.z.url().optional()
 });
 
-// src/cfg/generated/_utils/schemas/OverviewStats.schema.ts
+// src/cfg/generated/_utils/schemas/OTPVerifyResponse.schema.ts
+var import_zod102 = require("zod");
+
+// src/cfg/generated/_utils/schemas/User.schema.ts
 var import_zod101 = require("zod");
-var OverviewStatsSchema = import_zod101.z.object({
-  total: import_zod101.z.int(),
-  successful: import_zod101.z.int(),
-  failed: import_zod101.z.int(),
-  timeout: import_zod101.z.int(),
-  success_rate: import_zod101.z.number(),
-  avg_duration_ms: import_zod101.z.number(),
-  avg_acks_received: import_zod101.z.number(),
-  period_hours: import_zod101.z.int()
+var UserSchema = import_zod101.z.object({
+  id: import_zod101.z.int(),
+  email: import_zod101.z.email(),
+  first_name: import_zod101.z.string().max(50).optional(),
+  last_name: import_zod101.z.string().max(50).optional(),
+  full_name: import_zod101.z.string(),
+  initials: import_zod101.z.string(),
+  display_username: import_zod101.z.string(),
+  company: import_zod101.z.string().max(100).optional(),
+  phone: import_zod101.z.string().max(20).optional(),
+  position: import_zod101.z.string().max(100).optional(),
+  avatar: import_zod101.z.url().nullable(),
+  is_staff: import_zod101.z.boolean(),
+  is_superuser: import_zod101.z.boolean(),
+  date_joined: import_zod101.z.iso.datetime(),
+  last_login: import_zod101.z.iso.datetime().nullable(),
+  unanswered_messages_count: import_zod101.z.int()
 });
 
-// src/cfg/generated/_utils/schemas/PaginatedArchiveItemChunkList.schema.ts
-var import_zod102 = require("zod");
-var PaginatedArchiveItemChunkListSchema = import_zod102.z.object({
-  count: import_zod102.z.int(),
-  page: import_zod102.z.int(),
-  pages: import_zod102.z.int(),
-  page_size: import_zod102.z.int(),
-  has_next: import_zod102.z.boolean(),
-  has_previous: import_zod102.z.boolean(),
-  next_page: import_zod102.z.int().nullable().optional(),
-  previous_page: import_zod102.z.int().nullable().optional(),
-  results: import_zod102.z.array(ArchiveItemChunkSchema)
+// src/cfg/generated/_utils/schemas/OTPVerifyResponse.schema.ts
+var OTPVerifyResponseSchema = import_zod102.z.object({
+  refresh: import_zod102.z.string(),
+  access: import_zod102.z.string(),
+  user: UserSchema
 });
 
-// src/cfg/generated/_utils/schemas/PaginatedArchiveItemList.schema.ts
+// src/cfg/generated/_utils/schemas/OverviewStats.schema.ts
 var import_zod103 = require("zod");
-var PaginatedArchiveItemListSchema = import_zod103.z.object({
-  count: import_zod103.z.int(),
-  page: import_zod103.z.int(),
-  pages: import_zod103.z.int(),
-  page_size: import_zod103.z.int(),
-  has_next: import_zod103.z.boolean(),
-  has_previous: import_zod103.z.boolean(),
-  next_page: import_zod103.z.int().nullable().optional(),
-  previous_page: import_zod103.z.int().nullable().optional(),
-  results: import_zod103.z.array(ArchiveItemSchema)
+var OverviewStatsSchema = import_zod103.z.object({
+  total: import_zod103.z.int(),
+  successful: import_zod103.z.int(),
+  failed: import_zod103.z.int(),
+  timeout: import_zod103.z.int(),
+  success_rate: import_zod103.z.number(),
+  avg_duration_ms: import_zod103.z.number(),
+  avg_acks_received: import_zod103.z.number(),
+  period_hours: import_zod103.z.int()
 });
 
-// src/cfg/generated/_utils/schemas/PaginatedArchiveSearchResultList.schema.ts
+// src/cfg/generated/_utils/schemas/PaginatedArchiveItemChunkList.schema.ts
 var import_zod104 = require("zod");
-var PaginatedArchiveSearchResultListSchema = import_zod104.z.object({
+var PaginatedArchiveItemChunkListSchema = import_zod104.z.object({
   count: import_zod104.z.int(),
   page: import_zod104.z.int(),
   pages: import_zod104.z.int(),
@@ -20175,12 +20380,12 @@ var PaginatedArchiveSearchResultListSchema = import_zod104.z.object({
   has_previous: import_zod104.z.boolean(),
   next_page: import_zod104.z.int().nullable().optional(),
   previous_page: import_zod104.z.int().nullable().optional(),
-  results: import_zod104.z.array(ArchiveSearchResultSchema)
+  results: import_zod104.z.array(ArchiveItemChunkSchema)
 });
 
-// src/cfg/generated/_utils/schemas/PaginatedChatResponseList.schema.ts
+// src/cfg/generated/_utils/schemas/PaginatedArchiveItemList.schema.ts
 var import_zod105 = require("zod");
-var PaginatedChatResponseListSchema = import_zod105.z.object({
+var PaginatedArchiveItemListSchema = import_zod105.z.object({
   count: import_zod105.z.int(),
   page: import_zod105.z.int(),
   pages: import_zod105.z.int(),
@@ -20189,12 +20394,12 @@ var PaginatedChatResponseListSchema = import_zod105.z.object({
   has_previous: import_zod105.z.boolean(),
   next_page: import_zod105.z.int().nullable().optional(),
   previous_page: import_zod105.z.int().nullable().optional(),
-  results: import_zod105.z.array(ChatResponseSchema)
+  results: import_zod105.z.array(ArchiveItemSchema)
 });
 
-// src/cfg/generated/_utils/schemas/PaginatedChatSessionList.schema.ts
+// src/cfg/generated/_utils/schemas/PaginatedArchiveSearchResultList.schema.ts
 var import_zod106 = require("zod");
-var PaginatedChatSessionListSchema = import_zod106.z.object({
+var PaginatedArchiveSearchResultListSchema = import_zod106.z.object({
   count: import_zod106.z.int(),
   page: import_zod106.z.int(),
   pages: import_zod106.z.int(),
@@ -20203,12 +20408,12 @@ var PaginatedChatSessionListSchema = import_zod106.z.object({
   has_previous: import_zod106.z.boolean(),
   next_page: import_zod106.z.int().nullable().optional(),
   previous_page: import_zod106.z.int().nullable().optional(),
-  results: import_zod106.z.array(ChatSessionSchema)
+  results: import_zod106.z.array(ArchiveSearchResultSchema)
 });
 
-// src/cfg/generated/_utils/schemas/PaginatedDocumentArchiveListList.schema.ts
+// src/cfg/generated/_utils/schemas/PaginatedChatResponseList.schema.ts
 var import_zod107 = require("zod");
-var PaginatedDocumentArchiveListListSchema = import_zod107.z.object({
+var PaginatedChatResponseListSchema = import_zod107.z.object({
   count: import_zod107.z.int(),
   page: import_zod107.z.int(),
   pages: import_zod107.z.int(),
@@ -20217,12 +20422,12 @@ var PaginatedDocumentArchiveListListSchema = import_zod107.z.object({
   has_previous: import_zod107.z.boolean(),
   next_page: import_zod107.z.int().nullable().optional(),
   previous_page: import_zod107.z.int().nullable().optional(),
-  results: import_zod107.z.array(DocumentArchiveListSchema)
+  results: import_zod107.z.array(ChatResponseSchema)
 });
 
-// src/cfg/generated/_utils/schemas/PaginatedDocumentList.schema.ts
+// src/cfg/generated/_utils/schemas/PaginatedChatSessionList.schema.ts
 var import_zod108 = require("zod");
-var PaginatedDocumentListSchema = import_zod108.z.object({
+var PaginatedChatSessionListSchema = import_zod108.z.object({
   count: import_zod108.z.int(),
   page: import_zod108.z.int(),
   pages: import_zod108.z.int(),
@@ -20231,12 +20436,12 @@ var PaginatedDocumentListSchema = import_zod108.z.object({
   has_previous: import_zod108.z.boolean(),
   next_page: import_zod108.z.int().nullable().optional(),
   previous_page: import_zod108.z.int().nullable().optional(),
-  results: import_zod108.z.array(DocumentSchema)
+  results: import_zod108.z.array(ChatSessionSchema)
 });
 
-// src/cfg/generated/_utils/schemas/PaginatedEmailLogList.schema.ts
+// src/cfg/generated/_utils/schemas/PaginatedDocumentArchiveListList.schema.ts
 var import_zod109 = require("zod");
-var PaginatedEmailLogListSchema = import_zod109.z.object({
+var PaginatedDocumentArchiveListListSchema = import_zod109.z.object({
   count: import_zod109.z.int(),
   page: import_zod109.z.int(),
   pages: import_zod109.z.int(),
@@ -20245,12 +20450,12 @@ var PaginatedEmailLogListSchema = import_zod109.z.object({
   has_previous: import_zod109.z.boolean(),
   next_page: import_zod109.z.int().nullable().optional(),
   previous_page: import_zod109.z.int().nullable().optional(),
-  results: import_zod109.z.array(EmailLogSchema)
+  results: import_zod109.z.array(DocumentArchiveListSchema)
 });
 
-// src/cfg/generated/_utils/schemas/PaginatedLeadSubmissionList.schema.ts
+// src/cfg/generated/_utils/schemas/PaginatedDocumentList.schema.ts
 var import_zod110 = require("zod");
-var PaginatedLeadSubmissionListSchema = import_zod110.z.object({
+var PaginatedDocumentListSchema = import_zod110.z.object({
   count: import_zod110.z.int(),
   page: import_zod110.z.int(),
   pages: import_zod110.z.int(),
@@ -20259,12 +20464,12 @@ var PaginatedLeadSubmissionListSchema = import_zod110.z.object({
   has_previous: import_zod110.z.boolean(),
   next_page: import_zod110.z.int().nullable().optional(),
   previous_page: import_zod110.z.int().nullable().optional(),
-  results: import_zod110.z.array(LeadSubmissionSchema)
+  results: import_zod110.z.array(DocumentSchema)
 });
 
-// src/cfg/generated/_utils/schemas/PaginatedMessageList.schema.ts
+// src/cfg/generated/_utils/schemas/PaginatedEmailLogList.schema.ts
 var import_zod111 = require("zod");
-var PaginatedMessageListSchema = import_zod111.z.object({
+var PaginatedEmailLogListSchema = import_zod111.z.object({
   count: import_zod111.z.int(),
   page: import_zod111.z.int(),
   pages: import_zod111.z.int(),
@@ -20273,12 +20478,12 @@ var PaginatedMessageListSchema = import_zod111.z.object({
   has_previous: import_zod111.z.boolean(),
   next_page: import_zod111.z.int().nullable().optional(),
   previous_page: import_zod111.z.int().nullable().optional(),
-  results: import_zod111.z.array(MessageSchema)
+  results: import_zod111.z.array(EmailLogSchema)
 });
 
-// src/cfg/generated/_utils/schemas/PaginatedNewsletterCampaignList.schema.ts
+// src/cfg/generated/_utils/schemas/PaginatedLeadSubmissionList.schema.ts
 var import_zod112 = require("zod");
-var PaginatedNewsletterCampaignListSchema = import_zod112.z.object({
+var PaginatedLeadSubmissionListSchema = import_zod112.z.object({
   count: import_zod112.z.int(),
   page: import_zod112.z.int(),
   pages: import_zod112.z.int(),
@@ -20287,12 +20492,12 @@ var PaginatedNewsletterCampaignListSchema = import_zod112.z.object({
   has_previous: import_zod112.z.boolean(),
   next_page: import_zod112.z.int().nullable().optional(),
   previous_page: import_zod112.z.int().nullable().optional(),
-  results: import_zod112.z.array(NewsletterCampaignSchema)
+  results: import_zod112.z.array(LeadSubmissionSchema)
 });
 
-// src/cfg/generated/_utils/schemas/PaginatedNewsletterList.schema.ts
+// src/cfg/generated/_utils/schemas/PaginatedMessageList.schema.ts
 var import_zod113 = require("zod");
-var PaginatedNewsletterListSchema = import_zod113.z.object({
+var PaginatedMessageListSchema = import_zod113.z.object({
   count: import_zod113.z.int(),
   page: import_zod113.z.int(),
   pages: import_zod113.z.int(),
@@ -20301,12 +20506,12 @@ var PaginatedNewsletterListSchema = import_zod113.z.object({
   has_previous: import_zod113.z.boolean(),
   next_page: import_zod113.z.int().nullable().optional(),
   previous_page: import_zod113.z.int().nullable().optional(),
-  results: import_zod113.z.array(NewsletterSchema)
+  results: import_zod113.z.array(MessageSchema)
 });
 
-// src/cfg/generated/_utils/schemas/PaginatedNewsletterSubscriptionList.schema.ts
+// src/cfg/generated/_utils/schemas/PaginatedNewsletterCampaignList.schema.ts
 var import_zod114 = require("zod");
-var PaginatedNewsletterSubscriptionListSchema = import_zod114.z.object({
+var PaginatedNewsletterCampaignListSchema = import_zod114.z.object({
   count: import_zod114.z.int(),
   page: import_zod114.z.int(),
   pages: import_zod114.z.int(),
@@ -20315,28 +20520,26 @@ var PaginatedNewsletterSubscriptionListSchema = import_zod114.z.object({
   has_previous: import_zod114.z.boolean(),
   next_page: import_zod114.z.int().nullable().optional(),
   previous_page: import_zod114.z.int().nullable().optional(),
-  results: import_zod114.z.array(NewsletterSubscriptionSchema)
+  results: import_zod114.z.array(NewsletterCampaignSchema)
 });
 
-// src/cfg/generated/_utils/schemas/PaginatedPaymentListList.schema.ts
-var import_zod116 = require("zod");
-
-// src/cfg/generated/_utils/schemas/PaymentList.schema.ts
+// src/cfg/generated/_utils/schemas/PaginatedNewsletterList.schema.ts
 var import_zod115 = require("zod");
-var PaymentListSchema = import_zod115.z.object({
-  id: import_zod115.z.uuid(),
-  internal_payment_id: import_zod115.z.string(),
-  amount_usd: import_zod115.z.string(),
-  currency_code: import_zod115.z.string(),
-  currency_token: import_zod115.z.string(),
-  status: import_zod115.z.nativeEnum(PaymentListStatus),
-  status_display: import_zod115.z.string(),
-  created_at: import_zod115.z.iso.datetime(),
-  completed_at: import_zod115.z.iso.datetime().nullable()
+var PaginatedNewsletterListSchema = import_zod115.z.object({
+  count: import_zod115.z.int(),
+  page: import_zod115.z.int(),
+  pages: import_zod115.z.int(),
+  page_size: import_zod115.z.int(),
+  has_next: import_zod115.z.boolean(),
+  has_previous: import_zod115.z.boolean(),
+  next_page: import_zod115.z.int().nullable().optional(),
+  previous_page: import_zod115.z.int().nullable().optional(),
+  results: import_zod115.z.array(NewsletterSchema)
 });
 
-// src/cfg/generated/_utils/schemas/PaginatedPaymentListList.schema.ts
-var PaginatedPaymentListListSchema = import_zod116.z.object({
+// src/cfg/generated/_utils/schemas/PaginatedNewsletterSubscriptionList.schema.ts
+var import_zod116 = require("zod");
+var PaginatedNewsletterSubscriptionListSchema = import_zod116.z.object({
   count: import_zod116.z.int(),
   page: import_zod116.z.int(),
   pages: import_zod116.z.int(),
@@ -20345,22 +20548,28 @@ var PaginatedPaymentListListSchema = import_zod116.z.object({
   has_previous: import_zod116.z.boolean(),
   next_page: import_zod116.z.int().nullable().optional(),
   previous_page: import_zod116.z.int().nullable().optional(),
-  results: import_zod116.z.array(PaymentListSchema)
+  results: import_zod116.z.array(NewsletterSubscriptionSchema)
 });
 
-// src/cfg/generated/_utils/schemas/PaginatedPublicCategoryList.schema.ts
+// src/cfg/generated/_utils/schemas/PaginatedPaymentListList.schema.ts
 var import_zod118 = require("zod");
 
-// src/cfg/generated/_utils/schemas/PublicCategory.schema.ts
+// src/cfg/generated/_utils/schemas/PaymentList.schema.ts
 var import_zod117 = require("zod");
-var PublicCategorySchema = import_zod117.z.object({
+var PaymentListSchema = import_zod117.z.object({
   id: import_zod117.z.uuid(),
-  name: import_zod117.z.string().max(255),
-  description: import_zod117.z.string().optional()
+  internal_payment_id: import_zod117.z.string(),
+  amount_usd: import_zod117.z.string(),
+  currency_code: import_zod117.z.string(),
+  currency_token: import_zod117.z.string(),
+  status: import_zod117.z.nativeEnum(PaymentListStatus),
+  status_display: import_zod117.z.string(),
+  created_at: import_zod117.z.iso.datetime(),
+  completed_at: import_zod117.z.iso.datetime().nullable()
 });
 
-// src/cfg/generated/_utils/schemas/PaginatedPublicCategoryList.schema.ts
-var PaginatedPublicCategoryListSchema = import_zod118.z.object({
+// src/cfg/generated/_utils/schemas/PaginatedPaymentListList.schema.ts
+var PaginatedPaymentListListSchema = import_zod118.z.object({
   count: import_zod118.z.int(),
   page: import_zod118.z.int(),
   pages: import_zod118.z.int(),
@@ -20369,24 +20578,22 @@ var PaginatedPublicCategoryListSchema = import_zod118.z.object({
   has_previous: import_zod118.z.boolean(),
   next_page: import_zod118.z.int().nullable().optional(),
   previous_page: import_zod118.z.int().nullable().optional(),
-  results: import_zod118.z.array(PublicCategorySchema)
+  results: import_zod118.z.array(PaymentListSchema)
 });
 
-// src/cfg/generated/_utils/schemas/PaginatedPublicDocumentListList.schema.ts
+// src/cfg/generated/_utils/schemas/PaginatedPublicCategoryList.schema.ts
 var import_zod120 = require("zod");
 
-// src/cfg/generated/_utils/schemas/PublicDocumentList.schema.ts
+// src/cfg/generated/_utils/schemas/PublicCategory.schema.ts
 var import_zod119 = require("zod");
-var PublicDocumentListSchema = import_zod119.z.object({
+var PublicCategorySchema = import_zod119.z.object({
   id: import_zod119.z.uuid(),
-  title: import_zod119.z.string().max(512),
-  category: PublicCategorySchema,
-  created_at: import_zod119.z.iso.datetime(),
-  updated_at: import_zod119.z.iso.datetime()
+  name: import_zod119.z.string().max(255),
+  description: import_zod119.z.string().optional()
 });
 
-// src/cfg/generated/_utils/schemas/PaginatedPublicDocumentListList.schema.ts
-var PaginatedPublicDocumentListListSchema = import_zod120.z.object({
+// src/cfg/generated/_utils/schemas/PaginatedPublicCategoryList.schema.ts
+var PaginatedPublicCategoryListSchema = import_zod120.z.object({
   count: import_zod120.z.int(),
   page: import_zod120.z.int(),
   pages: import_zod120.z.int(),
@@ -20395,25 +20602,24 @@ var PaginatedPublicDocumentListListSchema = import_zod120.z.object({
   has_previous: import_zod120.z.boolean(),
   next_page: import_zod120.z.int().nullable().optional(),
   previous_page: import_zod120.z.int().nullable().optional(),
-  results: import_zod120.z.array(PublicDocumentListSchema)
+  results: import_zod120.z.array(PublicCategorySchema)
 });
 
-// src/cfg/generated/_utils/schemas/PaginatedTicketList.schema.ts
+// src/cfg/generated/_utils/schemas/PaginatedPublicDocumentListList.schema.ts
 var import_zod122 = require("zod");
 
-// src/cfg/generated/_utils/schemas/Ticket.schema.ts
+// src/cfg/generated/_utils/schemas/PublicDocumentList.schema.ts
 var import_zod121 = require("zod");
-var TicketSchema = import_zod121.z.object({
-  uuid: import_zod121.z.uuid(),
-  user: import_zod121.z.int(),
-  subject: import_zod121.z.string().max(255),
-  status: import_zod121.z.nativeEnum(TicketStatus).optional(),
+var PublicDocumentListSchema = import_zod121.z.object({
+  id: import_zod121.z.uuid(),
+  title: import_zod121.z.string().max(512),
+  category: PublicCategorySchema,
   created_at: import_zod121.z.iso.datetime(),
-  unanswered_messages_count: import_zod121.z.int()
+  updated_at: import_zod121.z.iso.datetime()
 });
 
-// src/cfg/generated/_utils/schemas/PaginatedTicketList.schema.ts
-var PaginatedTicketListSchema = import_zod122.z.object({
+// src/cfg/generated/_utils/schemas/PaginatedPublicDocumentListList.schema.ts
+var PaginatedPublicDocumentListListSchema = import_zod122.z.object({
   count: import_zod122.z.int(),
   page: import_zod122.z.int(),
   pages: import_zod122.z.int(),
@@ -20422,479 +20628,506 @@ var PaginatedTicketListSchema = import_zod122.z.object({
   has_previous: import_zod122.z.boolean(),
   next_page: import_zod122.z.int().nullable().optional(),
   previous_page: import_zod122.z.int().nullable().optional(),
-  results: import_zod122.z.array(TicketSchema)
+  results: import_zod122.z.array(PublicDocumentListSchema)
 });
 
-// src/cfg/generated/_utils/schemas/PatchedArchiveItemChunkRequest.schema.ts
+// src/cfg/generated/_utils/schemas/PaginatedTicketList.schema.ts
+var import_zod124 = require("zod");
+
+// src/cfg/generated/_utils/schemas/Ticket.schema.ts
 var import_zod123 = require("zod");
-var PatchedArchiveItemChunkRequestSchema = import_zod123.z.object({
-  content: import_zod123.z.string().min(1).optional(),
-  chunk_index: import_zod123.z.int().min(0).max(2147483647).optional(),
-  chunk_type: import_zod123.z.nativeEnum(PatchedArchiveItemChunkRequestChunkType).optional()
+var TicketSchema = import_zod123.z.object({
+  uuid: import_zod123.z.uuid(),
+  user: import_zod123.z.int(),
+  subject: import_zod123.z.string().max(255),
+  status: import_zod123.z.nativeEnum(TicketStatus).optional(),
+  created_at: import_zod123.z.iso.datetime(),
+  unanswered_messages_count: import_zod123.z.int()
 });
 
-// src/cfg/generated/_utils/schemas/PatchedArchiveItemRequest.schema.ts
-var import_zod124 = require("zod");
-var PatchedArchiveItemRequestSchema = import_zod124.z.object({
-  relative_path: import_zod124.z.string().min(1).max(1024).optional(),
-  item_name: import_zod124.z.string().min(1).max(255).optional(),
-  item_type: import_zod124.z.string().min(1).max(100).optional(),
-  file_size: import_zod124.z.int().min(0).max(2147483647).optional()
+// src/cfg/generated/_utils/schemas/PaginatedTicketList.schema.ts
+var PaginatedTicketListSchema = import_zod124.z.object({
+  count: import_zod124.z.int(),
+  page: import_zod124.z.int(),
+  pages: import_zod124.z.int(),
+  page_size: import_zod124.z.int(),
+  has_next: import_zod124.z.boolean(),
+  has_previous: import_zod124.z.boolean(),
+  next_page: import_zod124.z.int().nullable().optional(),
+  previous_page: import_zod124.z.int().nullable().optional(),
+  results: import_zod124.z.array(TicketSchema)
 });
 
-// src/cfg/generated/_utils/schemas/PatchedChatResponseRequest.schema.ts
+// src/cfg/generated/_utils/schemas/PatchedArchiveItemChunkRequest.schema.ts
 var import_zod125 = require("zod");
-var PatchedChatResponseRequestSchema = import_zod125.z.object({
-  message_id: import_zod125.z.uuid().optional(),
+var PatchedArchiveItemChunkRequestSchema = import_zod125.z.object({
   content: import_zod125.z.string().min(1).optional(),
-  tokens_used: import_zod125.z.int().optional(),
-  cost_usd: import_zod125.z.number().optional(),
-  processing_time_ms: import_zod125.z.int().optional(),
-  model_used: import_zod125.z.string().min(1).optional(),
-  sources: import_zod125.z.array(ChatSourceRequestSchema).nullable().optional()
+  chunk_index: import_zod125.z.int().min(0).max(2147483647).optional(),
+  chunk_type: import_zod125.z.nativeEnum(PatchedArchiveItemChunkRequestChunkType).optional()
 });
 
-// src/cfg/generated/_utils/schemas/PatchedChatSessionRequest.schema.ts
+// src/cfg/generated/_utils/schemas/PatchedArchiveItemRequest.schema.ts
 var import_zod126 = require("zod");
-var PatchedChatSessionRequestSchema = import_zod126.z.object({
-  title: import_zod126.z.string().max(255).optional(),
-  is_active: import_zod126.z.boolean().optional(),
-  messages_count: import_zod126.z.int().min(0).max(2147483647).optional(),
-  total_tokens_used: import_zod126.z.int().min(0).max(2147483647).optional(),
-  model_name: import_zod126.z.string().min(1).max(100).optional(),
-  temperature: import_zod126.z.number().optional(),
-  max_context_chunks: import_zod126.z.int().min(0).max(2147483647).optional()
+var PatchedArchiveItemRequestSchema = import_zod126.z.object({
+  relative_path: import_zod126.z.string().min(1).max(1024).optional(),
+  item_name: import_zod126.z.string().min(1).max(255).optional(),
+  item_type: import_zod126.z.string().min(1).max(100).optional(),
+  file_size: import_zod126.z.int().min(0).max(2147483647).optional()
 });
 
-// src/cfg/generated/_utils/schemas/PatchedDocumentArchiveRequest.schema.ts
+// src/cfg/generated/_utils/schemas/PatchedChatResponseRequest.schema.ts
 var import_zod127 = require("zod");
-var PatchedDocumentArchiveRequestSchema = import_zod127.z.object({
-  title: import_zod127.z.string().min(1).max(512).optional(),
-  description: import_zod127.z.string().optional(),
-  is_public: import_zod127.z.boolean().optional()
+var PatchedChatResponseRequestSchema = import_zod127.z.object({
+  message_id: import_zod127.z.uuid().optional(),
+  content: import_zod127.z.string().min(1).optional(),
+  tokens_used: import_zod127.z.int().optional(),
+  cost_usd: import_zod127.z.number().optional(),
+  processing_time_ms: import_zod127.z.int().optional(),
+  model_used: import_zod127.z.string().min(1).optional(),
+  sources: import_zod127.z.array(ChatSourceRequestSchema).nullable().optional()
 });
 
-// src/cfg/generated/_utils/schemas/PatchedDocumentRequest.schema.ts
+// src/cfg/generated/_utils/schemas/PatchedChatSessionRequest.schema.ts
 var import_zod128 = require("zod");
-var PatchedDocumentRequestSchema = import_zod128.z.object({
-  title: import_zod128.z.string().min(1).max(512).optional(),
-  file_type: import_zod128.z.string().min(1).max(100).optional(),
-  file_size: import_zod128.z.int().min(0).max(2147483647).optional(),
-  metadata: import_zod128.z.string().nullable().optional()
+var PatchedChatSessionRequestSchema = import_zod128.z.object({
+  title: import_zod128.z.string().max(255).optional(),
+  is_active: import_zod128.z.boolean().optional(),
+  messages_count: import_zod128.z.int().min(0).max(2147483647).optional(),
+  total_tokens_used: import_zod128.z.int().min(0).max(2147483647).optional(),
+  model_name: import_zod128.z.string().min(1).max(100).optional(),
+  temperature: import_zod128.z.number().optional(),
+  max_context_chunks: import_zod128.z.int().min(0).max(2147483647).optional()
 });
 
-// src/cfg/generated/_utils/schemas/PatchedLeadSubmissionRequest.schema.ts
+// src/cfg/generated/_utils/schemas/PatchedDocumentArchiveRequest.schema.ts
 var import_zod129 = require("zod");
-var PatchedLeadSubmissionRequestSchema = import_zod129.z.object({
-  name: import_zod129.z.string().min(1).max(200).optional(),
-  email: import_zod129.z.email().optional(),
-  company: import_zod129.z.string().max(200).nullable().optional(),
-  company_site: import_zod129.z.string().max(200).nullable().optional(),
-  contact_type: import_zod129.z.nativeEnum(PatchedLeadSubmissionRequestContactType).optional(),
-  contact_value: import_zod129.z.string().max(200).nullable().optional(),
-  subject: import_zod129.z.string().max(200).nullable().optional(),
-  message: import_zod129.z.string().min(1).optional(),
-  extra: import_zod129.z.string().nullable().optional(),
-  site_url: import_zod129.z.url().optional()
+var PatchedDocumentArchiveRequestSchema = import_zod129.z.object({
+  title: import_zod129.z.string().min(1).max(512).optional(),
+  description: import_zod129.z.string().optional(),
+  is_public: import_zod129.z.boolean().optional()
 });
 
-// src/cfg/generated/_utils/schemas/PatchedMessageRequest.schema.ts
+// src/cfg/generated/_utils/schemas/PatchedDocumentRequest.schema.ts
 var import_zod130 = require("zod");
-var PatchedMessageRequestSchema = import_zod130.z.object({
-  text: import_zod130.z.string().min(1).optional()
+var PatchedDocumentRequestSchema = import_zod130.z.object({
+  title: import_zod130.z.string().min(1).max(512).optional(),
+  file_type: import_zod130.z.string().min(1).max(100).optional(),
+  file_size: import_zod130.z.int().min(0).max(2147483647).optional(),
+  metadata: import_zod130.z.string().nullable().optional()
 });
 
-// src/cfg/generated/_utils/schemas/PatchedNewsletterCampaignRequest.schema.ts
+// src/cfg/generated/_utils/schemas/PatchedLeadSubmissionRequest.schema.ts
 var import_zod131 = require("zod");
-var PatchedNewsletterCampaignRequestSchema = import_zod131.z.object({
-  newsletter: import_zod131.z.int().optional(),
-  subject: import_zod131.z.string().min(1).max(255).optional(),
-  email_title: import_zod131.z.string().min(1).max(255).optional(),
-  main_text: import_zod131.z.string().min(1).optional(),
-  main_html_content: import_zod131.z.string().optional(),
-  button_text: import_zod131.z.string().max(100).optional(),
-  button_url: import_zod131.z.url().optional(),
-  secondary_text: import_zod131.z.string().optional()
+var PatchedLeadSubmissionRequestSchema = import_zod131.z.object({
+  name: import_zod131.z.string().min(1).max(200).optional(),
+  email: import_zod131.z.email().optional(),
+  company: import_zod131.z.string().max(200).nullable().optional(),
+  company_site: import_zod131.z.string().max(200).nullable().optional(),
+  contact_type: import_zod131.z.nativeEnum(PatchedLeadSubmissionRequestContactType).optional(),
+  contact_value: import_zod131.z.string().max(200).nullable().optional(),
+  subject: import_zod131.z.string().max(200).nullable().optional(),
+  message: import_zod131.z.string().min(1).optional(),
+  extra: import_zod131.z.string().nullable().optional(),
+  site_url: import_zod131.z.url().optional()
 });
 
-// src/cfg/generated/_utils/schemas/PatchedTicketRequest.schema.ts
+// src/cfg/generated/_utils/schemas/PatchedMessageRequest.schema.ts
 var import_zod132 = require("zod");
-var PatchedTicketRequestSchema = import_zod132.z.object({
-  user: import_zod132.z.int().optional(),
-  subject: import_zod132.z.string().min(1).max(255).optional(),
-  status: import_zod132.z.nativeEnum(PatchedTicketRequestStatus).optional()
+var PatchedMessageRequestSchema = import_zod132.z.object({
+  text: import_zod132.z.string().min(1).optional()
 });
 
-// src/cfg/generated/_utils/schemas/PatchedUnsubscribeRequest.schema.ts
+// src/cfg/generated/_utils/schemas/PatchedNewsletterCampaignRequest.schema.ts
 var import_zod133 = require("zod");
-var PatchedUnsubscribeRequestSchema = import_zod133.z.object({
-  subscription_id: import_zod133.z.int().optional()
+var PatchedNewsletterCampaignRequestSchema = import_zod133.z.object({
+  newsletter: import_zod133.z.int().optional(),
+  subject: import_zod133.z.string().min(1).max(255).optional(),
+  email_title: import_zod133.z.string().min(1).max(255).optional(),
+  main_text: import_zod133.z.string().min(1).optional(),
+  main_html_content: import_zod133.z.string().optional(),
+  button_text: import_zod133.z.string().max(100).optional(),
+  button_url: import_zod133.z.url().optional(),
+  secondary_text: import_zod133.z.string().optional()
 });
 
-// src/cfg/generated/_utils/schemas/PatchedUserProfileUpdateRequest.schema.ts
+// src/cfg/generated/_utils/schemas/PatchedTicketRequest.schema.ts
 var import_zod134 = require("zod");
-var PatchedUserProfileUpdateRequestSchema = import_zod134.z.object({
-  first_name: import_zod134.z.string().max(50).optional(),
-  last_name: import_zod134.z.string().max(50).optional(),
-  company: import_zod134.z.string().max(100).optional(),
-  phone: import_zod134.z.string().max(20).optional(),
-  position: import_zod134.z.string().max(100).optional()
+var PatchedTicketRequestSchema = import_zod134.z.object({
+  user: import_zod134.z.int().optional(),
+  subject: import_zod134.z.string().min(1).max(255).optional(),
+  status: import_zod134.z.nativeEnum(PatchedTicketRequestStatus).optional()
 });
 
-// src/cfg/generated/_utils/schemas/PaymentDetail.schema.ts
+// src/cfg/generated/_utils/schemas/PatchedUnsubscribeRequest.schema.ts
 var import_zod135 = require("zod");
-var PaymentDetailSchema = import_zod135.z.object({
-  id: import_zod135.z.uuid(),
-  internal_payment_id: import_zod135.z.string(),
-  amount_usd: import_zod135.z.string(),
-  currency_code: import_zod135.z.string(),
-  currency_name: import_zod135.z.string(),
-  currency_token: import_zod135.z.string(),
-  currency_network: import_zod135.z.string(),
-  pay_amount: import_zod135.z.string().nullable(),
-  actual_amount: import_zod135.z.string().nullable(),
-  actual_amount_usd: import_zod135.z.string().nullable(),
-  status: import_zod135.z.nativeEnum(PaymentDetailStatus),
-  status_display: import_zod135.z.string(),
-  pay_address: import_zod135.z.string().nullable(),
-  qr_code_url: import_zod135.z.string().nullable(),
-  payment_url: import_zod135.z.url().nullable(),
-  transaction_hash: import_zod135.z.string().nullable(),
-  explorer_link: import_zod135.z.string().nullable(),
-  confirmations_count: import_zod135.z.int(),
-  expires_at: import_zod135.z.iso.datetime().nullable(),
-  completed_at: import_zod135.z.iso.datetime().nullable(),
-  created_at: import_zod135.z.iso.datetime(),
-  is_completed: import_zod135.z.boolean(),
-  is_failed: import_zod135.z.boolean(),
-  is_expired: import_zod135.z.boolean(),
-  description: import_zod135.z.string()
+var PatchedUnsubscribeRequestSchema = import_zod135.z.object({
+  subscription_id: import_zod135.z.int().optional()
 });
 
-// src/cfg/generated/_utils/schemas/PublicDocument.schema.ts
+// src/cfg/generated/_utils/schemas/PatchedUserProfileUpdateRequest.schema.ts
 var import_zod136 = require("zod");
-var PublicDocumentSchema = import_zod136.z.object({
-  id: import_zod136.z.uuid(),
-  title: import_zod136.z.string().max(512),
-  content: import_zod136.z.string(),
-  category: PublicCategorySchema,
-  created_at: import_zod136.z.iso.datetime(),
-  updated_at: import_zod136.z.iso.datetime()
+var PatchedUserProfileUpdateRequestSchema = import_zod136.z.object({
+  first_name: import_zod136.z.string().max(50).optional(),
+  last_name: import_zod136.z.string().max(50).optional(),
+  company: import_zod136.z.string().max(100).optional(),
+  phone: import_zod136.z.string().max(20).optional(),
+  position: import_zod136.z.string().max(100).optional()
 });
 
-// src/cfg/generated/_utils/schemas/PublishTestRequestRequest.schema.ts
+// src/cfg/generated/_utils/schemas/PaymentDetail.schema.ts
 var import_zod137 = require("zod");
-var PublishTestRequestRequestSchema = import_zod137.z.object({
-  channel: import_zod137.z.string(),
-  data: import_zod137.z.record(import_zod137.z.string(), import_zod137.z.any()),
-  wait_for_ack: import_zod137.z.boolean().optional(),
-  ack_timeout: import_zod137.z.int().min(1).max(60).optional()
+var PaymentDetailSchema = import_zod137.z.object({
+  id: import_zod137.z.uuid(),
+  internal_payment_id: import_zod137.z.string(),
+  amount_usd: import_zod137.z.string(),
+  currency_code: import_zod137.z.string(),
+  currency_name: import_zod137.z.string(),
+  currency_token: import_zod137.z.string(),
+  currency_network: import_zod137.z.string(),
+  pay_amount: import_zod137.z.string().nullable(),
+  actual_amount: import_zod137.z.string().nullable(),
+  actual_amount_usd: import_zod137.z.string().nullable(),
+  status: import_zod137.z.nativeEnum(PaymentDetailStatus),
+  status_display: import_zod137.z.string(),
+  pay_address: import_zod137.z.string().nullable(),
+  qr_code_url: import_zod137.z.string().nullable(),
+  payment_url: import_zod137.z.url().nullable(),
+  transaction_hash: import_zod137.z.string().nullable(),
+  explorer_link: import_zod137.z.string().nullable(),
+  confirmations_count: import_zod137.z.int(),
+  expires_at: import_zod137.z.iso.datetime().nullable(),
+  completed_at: import_zod137.z.iso.datetime().nullable(),
+  created_at: import_zod137.z.iso.datetime(),
+  is_completed: import_zod137.z.boolean(),
+  is_failed: import_zod137.z.boolean(),
+  is_expired: import_zod137.z.boolean(),
+  description: import_zod137.z.string()
 });
 
-// src/cfg/generated/_utils/schemas/PublishTestResponse.schema.ts
+// src/cfg/generated/_utils/schemas/PublicDocument.schema.ts
 var import_zod138 = require("zod");
-var PublishTestResponseSchema = import_zod138.z.object({
-  success: import_zod138.z.boolean(),
-  message_id: import_zod138.z.string(),
-  channel: import_zod138.z.string(),
-  acks_received: import_zod138.z.int().optional(),
-  delivered: import_zod138.z.boolean().optional(),
-  error: import_zod138.z.string().nullable().optional()
+var PublicDocumentSchema = import_zod138.z.object({
+  id: import_zod138.z.uuid(),
+  title: import_zod138.z.string().max(512),
+  content: import_zod138.z.string(),
+  category: PublicCategorySchema,
+  created_at: import_zod138.z.iso.datetime(),
+  updated_at: import_zod138.z.iso.datetime()
 });
 
-// src/cfg/generated/_utils/schemas/QueueAction.schema.ts
+// src/cfg/generated/_utils/schemas/PublishTestRequestRequest.schema.ts
 var import_zod139 = require("zod");
-var QueueActionSchema = import_zod139.z.object({
-  action: import_zod139.z.nativeEnum(QueueActionAction),
-  queue_names: import_zod139.z.array(import_zod139.z.string()).optional()
+var PublishTestRequestRequestSchema = import_zod139.z.object({
+  channel: import_zod139.z.string(),
+  data: import_zod139.z.record(import_zod139.z.string(), import_zod139.z.any()),
+  wait_for_ack: import_zod139.z.boolean().optional(),
+  ack_timeout: import_zod139.z.int().min(1).max(60).optional()
 });
 
-// src/cfg/generated/_utils/schemas/QueueActionRequest.schema.ts
+// src/cfg/generated/_utils/schemas/PublishTestResponse.schema.ts
 var import_zod140 = require("zod");
-var QueueActionRequestSchema = import_zod140.z.object({
-  action: import_zod140.z.nativeEnum(QueueActionRequestAction),
-  queue_names: import_zod140.z.array(import_zod140.z.string().min(1)).optional()
+var PublishTestResponseSchema = import_zod140.z.object({
+  success: import_zod140.z.boolean(),
+  message_id: import_zod140.z.string(),
+  channel: import_zod140.z.string(),
+  acks_received: import_zod140.z.int().optional(),
+  delivered: import_zod140.z.boolean().optional(),
+  error: import_zod140.z.string().nullable().optional()
 });
 
-// src/cfg/generated/_utils/schemas/QueueStatus.schema.ts
+// src/cfg/generated/_utils/schemas/QueueAction.schema.ts
 var import_zod141 = require("zod");
-var QueueStatusSchema = import_zod141.z.object({
-  queues: import_zod141.z.record(import_zod141.z.string(), import_zod141.z.any()),
-  workers: import_zod141.z.int(),
-  redis_connected: import_zod141.z.boolean(),
-  timestamp: import_zod141.z.string(),
-  error: import_zod141.z.string().optional()
+var QueueActionSchema = import_zod141.z.object({
+  action: import_zod141.z.nativeEnum(QueueActionAction),
+  queue_names: import_zod141.z.array(import_zod141.z.string()).optional()
 });
 
-// src/cfg/generated/_utils/schemas/QuickAction.schema.ts
+// src/cfg/generated/_utils/schemas/QueueActionRequest.schema.ts
 var import_zod142 = require("zod");
-var QuickActionSchema = import_zod142.z.object({
-  title: import_zod142.z.string(),
-  description: import_zod142.z.string(),
-  icon: import_zod142.z.string(),
-  link: import_zod142.z.string(),
-  color: import_zod142.z.nativeEnum(QuickActionColor).optional(),
-  category: import_zod142.z.string().optional()
+var QueueActionRequestSchema = import_zod142.z.object({
+  action: import_zod142.z.nativeEnum(QueueActionRequestAction),
+  queue_names: import_zod142.z.array(import_zod142.z.string().min(1)).optional()
 });
 
-// src/cfg/generated/_utils/schemas/QuickHealth.schema.ts
+// src/cfg/generated/_utils/schemas/QueueStatus.schema.ts
 var import_zod143 = require("zod");
-var QuickHealthSchema = import_zod143.z.object({
-  status: import_zod143.z.string(),
-  timestamp: import_zod143.z.iso.datetime(),
+var QueueStatusSchema = import_zod143.z.object({
+  queues: import_zod143.z.record(import_zod143.z.string(), import_zod143.z.any()),
+  workers: import_zod143.z.int(),
+  redis_connected: import_zod143.z.boolean(),
+  timestamp: import_zod143.z.string(),
   error: import_zod143.z.string().optional()
 });
 
-// src/cfg/generated/_utils/schemas/RecentPublishes.schema.ts
+// src/cfg/generated/_utils/schemas/QuickAction.schema.ts
 var import_zod144 = require("zod");
-var RecentPublishesSchema = import_zod144.z.object({
-  publishes: import_zod144.z.array(import_zod144.z.record(import_zod144.z.string(), import_zod144.z.any())),
-  count: import_zod144.z.int(),
-  total_available: import_zod144.z.int(),
-  offset: import_zod144.z.int().optional(),
-  has_more: import_zod144.z.boolean().optional()
+var QuickActionSchema = import_zod144.z.object({
+  title: import_zod144.z.string(),
+  description: import_zod144.z.string(),
+  icon: import_zod144.z.string(),
+  link: import_zod144.z.string(),
+  color: import_zod144.z.nativeEnum(QuickActionColor).optional(),
+  category: import_zod144.z.string().optional()
 });
 
-// src/cfg/generated/_utils/schemas/RecentUser.schema.ts
+// src/cfg/generated/_utils/schemas/QuickHealth.schema.ts
 var import_zod145 = require("zod");
-var RecentUserSchema = import_zod145.z.object({
-  id: import_zod145.z.int(),
-  username: import_zod145.z.string(),
-  email: import_zod145.z.email(),
-  date_joined: import_zod145.z.string(),
-  is_active: import_zod145.z.boolean(),
-  is_staff: import_zod145.z.boolean(),
-  is_superuser: import_zod145.z.boolean(),
-  last_login: import_zod145.z.string().nullable()
+var QuickHealthSchema = import_zod145.z.object({
+  status: import_zod145.z.string(),
+  timestamp: import_zod145.z.iso.datetime(),
+  error: import_zod145.z.string().optional()
 });
 
-// src/cfg/generated/_utils/schemas/SendCampaignRequest.schema.ts
+// src/cfg/generated/_utils/schemas/RecentPublishes.schema.ts
 var import_zod146 = require("zod");
-var SendCampaignRequestSchema = import_zod146.z.object({
-  campaign_id: import_zod146.z.int()
+var RecentPublishesSchema = import_zod146.z.object({
+  publishes: import_zod146.z.array(import_zod146.z.record(import_zod146.z.string(), import_zod146.z.any())),
+  count: import_zod146.z.int(),
+  total_available: import_zod146.z.int(),
+  offset: import_zod146.z.int().optional(),
+  has_more: import_zod146.z.boolean().optional()
 });
 
-// src/cfg/generated/_utils/schemas/SendCampaignResponse.schema.ts
+// src/cfg/generated/_utils/schemas/RecentUser.schema.ts
 var import_zod147 = require("zod");
-var SendCampaignResponseSchema = import_zod147.z.object({
-  success: import_zod147.z.boolean(),
-  message: import_zod147.z.string().optional(),
-  sent_count: import_zod147.z.int().optional(),
-  error: import_zod147.z.string().optional()
+var RecentUserSchema = import_zod147.z.object({
+  id: import_zod147.z.int(),
+  username: import_zod147.z.string(),
+  email: import_zod147.z.email(),
+  date_joined: import_zod147.z.string(),
+  is_active: import_zod147.z.boolean(),
+  is_staff: import_zod147.z.boolean(),
+  is_superuser: import_zod147.z.boolean(),
+  last_login: import_zod147.z.string().nullable()
 });
 
-// src/cfg/generated/_utils/schemas/StatCard.schema.ts
+// src/cfg/generated/_utils/schemas/SendCampaignRequest.schema.ts
 var import_zod148 = require("zod");
-var StatCardSchema = import_zod148.z.object({
-  title: import_zod148.z.string(),
-  value: import_zod148.z.string(),
-  icon: import_zod148.z.string(),
-  change: import_zod148.z.string().nullable().optional(),
-  change_type: import_zod148.z.nativeEnum(StatCardChangeType).optional(),
-  description: import_zod148.z.string().nullable().optional(),
-  color: import_zod148.z.string().optional()
+var SendCampaignRequestSchema = import_zod148.z.object({
+  campaign_id: import_zod148.z.int()
 });
 
-// src/cfg/generated/_utils/schemas/SubscribeRequest.schema.ts
+// src/cfg/generated/_utils/schemas/SendCampaignResponse.schema.ts
 var import_zod149 = require("zod");
-var SubscribeRequestSchema = import_zod149.z.object({
-  newsletter_id: import_zod149.z.int(),
-  email: import_zod149.z.email()
+var SendCampaignResponseSchema = import_zod149.z.object({
+  success: import_zod149.z.boolean(),
+  message: import_zod149.z.string().optional(),
+  sent_count: import_zod149.z.int().optional(),
+  error: import_zod149.z.string().optional()
 });
 
-// src/cfg/generated/_utils/schemas/SubscribeResponse.schema.ts
+// src/cfg/generated/_utils/schemas/StatCard.schema.ts
 var import_zod150 = require("zod");
-var SubscribeResponseSchema = import_zod150.z.object({
-  success: import_zod150.z.boolean(),
-  message: import_zod150.z.string(),
-  subscription_id: import_zod150.z.int().optional()
+var StatCardSchema = import_zod150.z.object({
+  title: import_zod150.z.string(),
+  value: import_zod150.z.string(),
+  icon: import_zod150.z.string(),
+  change: import_zod150.z.string().nullable().optional(),
+  change_type: import_zod150.z.nativeEnum(StatCardChangeType).optional(),
+  description: import_zod150.z.string().nullable().optional(),
+  color: import_zod150.z.string().optional()
 });
 
-// src/cfg/generated/_utils/schemas/SuccessResponse.schema.ts
+// src/cfg/generated/_utils/schemas/SubscribeRequest.schema.ts
 var import_zod151 = require("zod");
-var SuccessResponseSchema = import_zod151.z.object({
-  success: import_zod151.z.boolean(),
-  message: import_zod151.z.string()
+var SubscribeRequestSchema = import_zod151.z.object({
+  newsletter_id: import_zod151.z.int(),
+  email: import_zod151.z.email()
 });
 
-// src/cfg/generated/_utils/schemas/SystemHealth.schema.ts
+// src/cfg/generated/_utils/schemas/SubscribeResponse.schema.ts
+var import_zod152 = require("zod");
+var SubscribeResponseSchema = import_zod152.z.object({
+  success: import_zod152.z.boolean(),
+  message: import_zod152.z.string(),
+  subscription_id: import_zod152.z.int().optional()
+});
+
+// src/cfg/generated/_utils/schemas/SuccessResponse.schema.ts
 var import_zod153 = require("zod");
+var SuccessResponseSchema = import_zod153.z.object({
+  success: import_zod153.z.boolean(),
+  message: import_zod153.z.string()
+});
+
+// src/cfg/generated/_utils/schemas/SystemHealth.schema.ts
+var import_zod155 = require("zod");
 
 // src/cfg/generated/_utils/schemas/SystemHealthItem.schema.ts
-var import_zod152 = require("zod");
-var SystemHealthItemSchema = import_zod152.z.object({
-  component: import_zod152.z.string(),
-  status: import_zod152.z.nativeEnum(SystemHealthItemStatus),
-  description: import_zod152.z.string(),
-  last_check: import_zod152.z.string(),
-  health_percentage: import_zod152.z.int().min(0).max(100).nullable().optional()
+var import_zod154 = require("zod");
+var SystemHealthItemSchema = import_zod154.z.object({
+  component: import_zod154.z.string(),
+  status: import_zod154.z.nativeEnum(SystemHealthItemStatus),
+  description: import_zod154.z.string(),
+  last_check: import_zod154.z.string(),
+  health_percentage: import_zod154.z.int().min(0).max(100).nullable().optional()
 });
 
 // src/cfg/generated/_utils/schemas/SystemHealth.schema.ts
-var SystemHealthSchema = import_zod153.z.object({
-  overall_status: import_zod153.z.nativeEnum(SystemHealthOverallStatus),
-  overall_health_percentage: import_zod153.z.int().min(0).max(100),
-  components: import_zod153.z.array(SystemHealthItemSchema),
-  timestamp: import_zod153.z.string()
+var SystemHealthSchema = import_zod155.z.object({
+  overall_status: import_zod155.z.nativeEnum(SystemHealthOverallStatus),
+  overall_health_percentage: import_zod155.z.int().min(0).max(100),
+  components: import_zod155.z.array(SystemHealthItemSchema),
+  timestamp: import_zod155.z.string()
 });
 
 // src/cfg/generated/_utils/schemas/SystemMetrics.schema.ts
-var import_zod154 = require("zod");
-var SystemMetricsSchema = import_zod154.z.object({
-  cpu_usage: import_zod154.z.number(),
-  memory_usage: import_zod154.z.number(),
-  disk_usage: import_zod154.z.number(),
-  network_in: import_zod154.z.string(),
-  network_out: import_zod154.z.string(),
-  response_time: import_zod154.z.string(),
-  uptime: import_zod154.z.string()
+var import_zod156 = require("zod");
+var SystemMetricsSchema = import_zod156.z.object({
+  cpu_usage: import_zod156.z.number(),
+  memory_usage: import_zod156.z.number(),
+  disk_usage: import_zod156.z.number(),
+  network_in: import_zod156.z.string(),
+  network_out: import_zod156.z.string(),
+  response_time: import_zod156.z.string(),
+  uptime: import_zod156.z.string()
 });
 
 // src/cfg/generated/_utils/schemas/TaskStatistics.schema.ts
-var import_zod155 = require("zod");
-var TaskStatisticsSchema = import_zod155.z.object({
-  statistics: import_zod155.z.record(import_zod155.z.string(), import_zod155.z.any()),
-  recent_tasks: import_zod155.z.array(import_zod155.z.record(import_zod155.z.string(), import_zod155.z.any())),
-  timestamp: import_zod155.z.string(),
-  error: import_zod155.z.string().optional()
+var import_zod157 = require("zod");
+var TaskStatisticsSchema = import_zod157.z.object({
+  statistics: import_zod157.z.record(import_zod157.z.string(), import_zod157.z.any()),
+  recent_tasks: import_zod157.z.array(import_zod157.z.record(import_zod157.z.string(), import_zod157.z.any())),
+  timestamp: import_zod157.z.string(),
+  error: import_zod157.z.string().optional()
 });
 
 // src/cfg/generated/_utils/schemas/TestEmailRequest.schema.ts
-var import_zod156 = require("zod");
-var TestEmailRequestSchema = import_zod156.z.object({
-  email: import_zod156.z.email(),
-  subject: import_zod156.z.string().min(1).max(255).optional(),
-  message: import_zod156.z.string().min(1).optional()
+var import_zod158 = require("zod");
+var TestEmailRequestSchema = import_zod158.z.object({
+  email: import_zod158.z.email(),
+  subject: import_zod158.z.string().min(1).max(255).optional(),
+  message: import_zod158.z.string().min(1).optional()
 });
 
 // src/cfg/generated/_utils/schemas/TicketRequest.schema.ts
-var import_zod157 = require("zod");
-var TicketRequestSchema = import_zod157.z.object({
-  user: import_zod157.z.int(),
-  subject: import_zod157.z.string().min(1).max(255),
-  status: import_zod157.z.nativeEnum(TicketRequestStatus).optional()
+var import_zod159 = require("zod");
+var TicketRequestSchema = import_zod159.z.object({
+  user: import_zod159.z.int(),
+  subject: import_zod159.z.string().min(1).max(255),
+  status: import_zod159.z.nativeEnum(TicketRequestStatus).optional()
 });
 
 // src/cfg/generated/_utils/schemas/TokenRefresh.schema.ts
-var import_zod158 = require("zod");
-var TokenRefreshSchema = import_zod158.z.object({
-  access: import_zod158.z.string(),
-  refresh: import_zod158.z.string()
+var import_zod160 = require("zod");
+var TokenRefreshSchema = import_zod160.z.object({
+  access: import_zod160.z.string(),
+  refresh: import_zod160.z.string()
 });
 
 // src/cfg/generated/_utils/schemas/TokenRefreshRequest.schema.ts
-var import_zod159 = require("zod");
-var TokenRefreshRequestSchema = import_zod159.z.object({
-  refresh: import_zod159.z.string().min(1)
+var import_zod161 = require("zod");
+var TokenRefreshRequestSchema = import_zod161.z.object({
+  refresh: import_zod161.z.string().min(1)
 });
 
 // src/cfg/generated/_utils/schemas/Transaction.schema.ts
-var import_zod160 = require("zod");
-var TransactionSchema = import_zod160.z.object({
-  id: import_zod160.z.uuid(),
-  transaction_type: import_zod160.z.nativeEnum(TransactionTransactionType),
-  type_display: import_zod160.z.string(),
-  amount_usd: import_zod160.z.string(),
-  amount_display: import_zod160.z.string(),
-  balance_after: import_zod160.z.string(),
-  payment_id: import_zod160.z.string().nullable(),
-  description: import_zod160.z.string(),
-  created_at: import_zod160.z.iso.datetime()
+var import_zod162 = require("zod");
+var TransactionSchema = import_zod162.z.object({
+  id: import_zod162.z.uuid(),
+  transaction_type: import_zod162.z.nativeEnum(TransactionTransactionType),
+  type_display: import_zod162.z.string(),
+  amount_usd: import_zod162.z.string(),
+  amount_display: import_zod162.z.string(),
+  balance_after: import_zod162.z.string(),
+  payment_id: import_zod162.z.string().nullable(),
+  description: import_zod162.z.string(),
+  created_at: import_zod162.z.iso.datetime()
 });
 
 // src/cfg/generated/_utils/schemas/URLPattern.schema.ts
-var import_zod161 = require("zod");
-var URLPatternSchema = import_zod161.z.object({
-  pattern: import_zod161.z.string(),
-  name: import_zod161.z.string().nullable().optional(),
-  full_name: import_zod161.z.string().nullable().optional(),
-  namespace: import_zod161.z.string().nullable().optional(),
-  view: import_zod161.z.string().nullable().optional(),
-  view_class: import_zod161.z.string().nullable().optional(),
-  methods: import_zod161.z.array(import_zod161.z.string()).optional(),
-  module: import_zod161.z.string().nullable().optional()
+var import_zod163 = require("zod");
+var URLPatternSchema = import_zod163.z.object({
+  pattern: import_zod163.z.string(),
+  name: import_zod163.z.string().nullable().optional(),
+  full_name: import_zod163.z.string().nullable().optional(),
+  namespace: import_zod163.z.string().nullable().optional(),
+  view: import_zod163.z.string().nullable().optional(),
+  view_class: import_zod163.z.string().nullable().optional(),
+  methods: import_zod163.z.array(import_zod163.z.string()).optional(),
+  module: import_zod163.z.string().nullable().optional()
 });
 
 // src/cfg/generated/_utils/schemas/URLsList.schema.ts
-var import_zod162 = require("zod");
-var URLsListSchema = import_zod162.z.object({
-  status: import_zod162.z.string(),
-  service: import_zod162.z.string(),
-  version: import_zod162.z.string(),
-  base_url: import_zod162.z.string(),
-  total_urls: import_zod162.z.int(),
-  urls: import_zod162.z.array(URLPatternSchema)
+var import_zod164 = require("zod");
+var URLsListSchema = import_zod164.z.object({
+  status: import_zod164.z.string(),
+  service: import_zod164.z.string(),
+  version: import_zod164.z.string(),
+  base_url: import_zod164.z.string(),
+  total_urls: import_zod164.z.int(),
+  urls: import_zod164.z.array(URLPatternSchema)
 });
 
 // src/cfg/generated/_utils/schemas/Unsubscribe.schema.ts
-var import_zod163 = require("zod");
-var UnsubscribeSchema = import_zod163.z.object({
-  subscription_id: import_zod163.z.int()
+var import_zod165 = require("zod");
+var UnsubscribeSchema = import_zod165.z.object({
+  subscription_id: import_zod165.z.int()
 });
 
 // src/cfg/generated/_utils/schemas/UnsubscribeRequest.schema.ts
-var import_zod164 = require("zod");
-var UnsubscribeRequestSchema = import_zod164.z.object({
-  subscription_id: import_zod164.z.int()
+var import_zod166 = require("zod");
+var UnsubscribeRequestSchema = import_zod166.z.object({
+  subscription_id: import_zod166.z.int()
 });
 
 // src/cfg/generated/_utils/schemas/UserProfileUpdateRequest.schema.ts
-var import_zod165 = require("zod");
-var UserProfileUpdateRequestSchema = import_zod165.z.object({
-  first_name: import_zod165.z.string().max(50).optional(),
-  last_name: import_zod165.z.string().max(50).optional(),
-  company: import_zod165.z.string().max(100).optional(),
-  phone: import_zod165.z.string().max(20).optional(),
-  position: import_zod165.z.string().max(100).optional()
+var import_zod167 = require("zod");
+var UserProfileUpdateRequestSchema = import_zod167.z.object({
+  first_name: import_zod167.z.string().max(50).optional(),
+  last_name: import_zod167.z.string().max(50).optional(),
+  company: import_zod167.z.string().max(100).optional(),
+  phone: import_zod167.z.string().max(20).optional(),
+  position: import_zod167.z.string().max(100).optional()
 });
 
 // src/cfg/generated/_utils/schemas/UserStatistics.schema.ts
-var import_zod166 = require("zod");
-var UserStatisticsSchema = import_zod166.z.object({
-  total_users: import_zod166.z.int(),
-  active_users: import_zod166.z.int(),
-  new_users: import_zod166.z.int(),
-  superusers: import_zod166.z.int()
+var import_zod168 = require("zod");
+var UserStatisticsSchema = import_zod168.z.object({
+  total_users: import_zod168.z.int(),
+  active_users: import_zod168.z.int(),
+  new_users: import_zod168.z.int(),
+  superusers: import_zod168.z.int()
 });
 
 // src/cfg/generated/_utils/schemas/VectorizationResult.schema.ts
-var import_zod167 = require("zod");
-var VectorizationResultSchema = import_zod167.z.object({
-  vectorized_count: import_zod167.z.int(),
-  failed_count: import_zod167.z.int(),
-  total_tokens: import_zod167.z.int(),
-  total_cost: import_zod167.z.number(),
-  success_rate: import_zod167.z.number(),
-  errors: import_zod167.z.array(import_zod167.z.string())
+var import_zod169 = require("zod");
+var VectorizationResultSchema = import_zod169.z.object({
+  vectorized_count: import_zod169.z.int(),
+  failed_count: import_zod169.z.int(),
+  total_tokens: import_zod169.z.int(),
+  total_cost: import_zod169.z.number(),
+  success_rate: import_zod169.z.number(),
+  errors: import_zod169.z.array(import_zod169.z.string())
 });
 
 // src/cfg/generated/_utils/schemas/VectorizationStatistics.schema.ts
-var import_zod168 = require("zod");
-var VectorizationStatisticsSchema = import_zod168.z.object({
-  total_chunks: import_zod168.z.int(),
-  vectorized_chunks: import_zod168.z.int(),
-  pending_chunks: import_zod168.z.int(),
-  vectorization_rate: import_zod168.z.number(),
-  total_tokens: import_zod168.z.int(),
-  total_cost: import_zod168.z.number(),
-  avg_tokens_per_chunk: import_zod168.z.number(),
-  avg_cost_per_chunk: import_zod168.z.number()
+var import_zod170 = require("zod");
+var VectorizationStatisticsSchema = import_zod170.z.object({
+  total_chunks: import_zod170.z.int(),
+  vectorized_chunks: import_zod170.z.int(),
+  pending_chunks: import_zod170.z.int(),
+  vectorization_rate: import_zod170.z.number(),
+  total_tokens: import_zod170.z.int(),
+  total_cost: import_zod170.z.number(),
+  avg_tokens_per_chunk: import_zod170.z.number(),
+  avg_cost_per_chunk: import_zod170.z.number()
 });
 
 // src/cfg/generated/_utils/schemas/WorkerAction.schema.ts
-var import_zod169 = require("zod");
-var WorkerActionSchema = import_zod169.z.object({
-  action: import_zod169.z.nativeEnum(WorkerActionAction),
-  processes: import_zod169.z.int().min(1).max(10).optional(),
-  threads: import_zod169.z.int().min(1).max(20).optional()
+var import_zod171 = require("zod");
+var WorkerActionSchema = import_zod171.z.object({
+  action: import_zod171.z.nativeEnum(WorkerActionAction),
+  processes: import_zod171.z.int().min(1).max(10).optional(),
+  threads: import_zod171.z.int().min(1).max(20).optional()
 });
 
 // src/cfg/generated/_utils/schemas/WorkerActionRequest.schema.ts
-var import_zod170 = require("zod");
-var WorkerActionRequestSchema = import_zod170.z.object({
-  action: import_zod170.z.nativeEnum(WorkerActionRequestAction),
-  processes: import_zod170.z.int().min(1).max(10).optional(),
-  threads: import_zod170.z.int().min(1).max(20).optional()
+var import_zod172 = require("zod");
+var WorkerActionRequestSchema = import_zod172.z.object({
+  action: import_zod172.z.nativeEnum(WorkerActionRequestAction),
+  processes: import_zod172.z.int().min(1).max(10).optional(),
+  threads: import_zod172.z.int().min(1).max(20).optional()
 });
 
 // src/cfg/generated/_utils/fetchers/index.ts
@@ -20924,6 +21157,7 @@ __export(fetchers_exports, {
   createCentrifugoTestingPublishTestCreate: () => createCentrifugoTestingPublishTestCreate,
   createCentrifugoTestingPublishWithLoggingCreate: () => createCentrifugoTestingPublishWithLoggingCreate,
   createCentrifugoTestingSendAckCreate: () => createCentrifugoTestingSendAckCreate,
+  createDashboardApiCommandsExecuteCreate: () => createDashboardApiCommandsExecuteCreate,
   createKnowbaseAdminChatCreate: () => createKnowbaseAdminChatCreate,
   createKnowbaseAdminChatQueryCreate: () => createKnowbaseAdminChatQueryCreate,
   createKnowbaseAdminDocumentsCreate: () => createKnowbaseAdminDocumentsCreate,
@@ -20982,6 +21216,7 @@ __export(fetchers_exports, {
   getDashboardApiChartsRecentUsersList: () => getDashboardApiChartsRecentUsersList,
   getDashboardApiChartsRegistrationsRetrieve: () => getDashboardApiChartsRegistrationsRetrieve,
   getDashboardApiChartsTrackerList: () => getDashboardApiChartsTrackerList,
+  getDashboardApiCommandsHelpRetrieve: () => getDashboardApiCommandsHelpRetrieve,
   getDashboardApiCommandsList: () => getDashboardApiCommandsList,
   getDashboardApiCommandsSummaryRetrieve: () => getDashboardApiCommandsSummaryRetrieve,
   getDashboardApiOverviewOverviewRetrieve: () => getDashboardApiOverviewOverviewRetrieve,
@@ -21375,6 +21610,16 @@ async function getDashboardApiCommandsList(client) {
   const response = await api2.cfg_dashboard_commands.dashboardApiCommandsList();
   return response;
 }
+async function getDashboardApiCommandsHelpRetrieve(id, client) {
+  const api2 = client || getAPIInstance();
+  const response = await api2.cfg_dashboard_commands.dashboardApiCommandsHelpRetrieve(id);
+  return CommandHelpResponseSchema.parse(response);
+}
+async function createDashboardApiCommandsExecuteCreate(data, client) {
+  const api2 = client || getAPIInstance();
+  const response = await api2.cfg_dashboard_commands.dashboardApiCommandsExecuteCreate(data);
+  return response;
+}
 async function getDashboardApiCommandsSummaryRetrieve(client) {
   const api2 = client || getAPIInstance();
   const response = await api2.cfg_dashboard_commands.dashboardApiCommandsSummaryRetrieve();
@@ -22065,6 +22310,7 @@ __export(hooks_exports, {
   useCreateCentrifugoTestingPublishTestCreate: () => useCreateCentrifugoTestingPublishTestCreate,
   useCreateCentrifugoTestingPublishWithLoggingCreate: () => useCreateCentrifugoTestingPublishWithLoggingCreate,
   useCreateCentrifugoTestingSendAckCreate: () => useCreateCentrifugoTestingSendAckCreate,
+  useCreateDashboardApiCommandsExecuteCreate: () => useCreateDashboardApiCommandsExecuteCreate,
   useCreateKnowbaseAdminChatCreate: () => useCreateKnowbaseAdminChatCreate,
   useCreateKnowbaseAdminChatQueryCreate: () => useCreateKnowbaseAdminChatQueryCreate,
   useCreateKnowbaseAdminDocumentsCreate: () => useCreateKnowbaseAdminDocumentsCreate,
@@ -22102,6 +22348,7 @@ __export(hooks_exports, {
   useDashboardApiChartsRecentUsersList: () => useDashboardApiChartsRecentUsersList,
   useDashboardApiChartsRegistrationsRetrieve: () => useDashboardApiChartsRegistrationsRetrieve,
   useDashboardApiChartsTrackerList: () => useDashboardApiChartsTrackerList,
+  useDashboardApiCommandsHelpRetrieve: () => useDashboardApiCommandsHelpRetrieve,
   useDashboardApiCommandsList: () => useDashboardApiCommandsList,
   useDashboardApiCommandsSummaryRetrieve: () => useDashboardApiCommandsSummaryRetrieve,
   useDashboardApiOverviewOverviewRetrieve: () => useDashboardApiOverviewOverviewRetrieve,
@@ -22551,12 +22798,27 @@ function useDashboardApiChartsTrackerList(params, client) {
 
 // src/cfg/generated/_utils/hooks/cfg__dashboard__dashboard_commands.ts
 var import_swr11 = __toESM(require("swr"), 1);
+var import_swr12 = require("swr");
 function useDashboardApiCommandsList(client) {
   return (0, import_swr11.default)(
     "cfg-dashboard-api-commands",
     () => getDashboardApiCommandsList(client)
   );
 }
+function useDashboardApiCommandsHelpRetrieve(id, client) {
+  return (0, import_swr11.default)(
+    ["cfg-dashboard-api-commands-help", id],
+    () => getDashboardApiCommandsHelpRetrieve(id, client)
+  );
+}
+function useCreateDashboardApiCommandsExecuteCreate() {
+  const { mutate } = (0, import_swr12.useSWRConfig)();
+  return async (data, client) => {
+    const result = await createDashboardApiCommandsExecuteCreate(data, client);
+    mutate("cfg-dashboard-api-commands-execute");
+    return result;
+  };
+}
 function useDashboardApiCommandsSummaryRetrieve(client) {
   return (0, import_swr11.default)(
     "cfg-dashboard-api-commands-summary",
@@ -22565,54 +22827,54 @@ function useDashboardApiCommandsSummaryRetrieve(client) {
 }
 
 // src/cfg/generated/_utils/hooks/cfg__dashboard__dashboard_overview.ts
-var import_swr12 = __toESM(require("swr"), 1);
+var import_swr13 = __toESM(require("swr"), 1);
 function useDashboardApiOverviewOverviewRetrieve(client) {
-  return (0, import_swr12.default)(
+  return (0, import_swr13.default)(
     "cfg-dashboard-api-overview-overview",
     () => getDashboardApiOverviewOverviewRetrieve(client)
   );
 }
 
 // src/cfg/generated/_utils/hooks/cfg__dashboard__dashboard_statistics.ts
-var import_swr13 = __toESM(require("swr"), 1);
+var import_swr14 = __toESM(require("swr"), 1);
 function useDashboardApiStatisticsAppsList(client) {
-  return (0, import_swr13.default)(
+  return (0, import_swr14.default)(
     "cfg-dashboard-api-statistics-apps",
     () => getDashboardApiStatisticsAppsList(client)
   );
 }
 function useDashboardApiStatisticsCardsList(client) {
-  return (0, import_swr13.default)(
+  return (0, import_swr14.default)(
     "cfg-dashboard-api-statistics-cards",
     () => getDashboardApiStatisticsCardsList(client)
   );
 }
 function useDashboardApiStatisticsUsersRetrieve(client) {
-  return (0, import_swr13.default)(
+  return (0, import_swr14.default)(
     "cfg-dashboard-api-statistics-user",
     () => getDashboardApiStatisticsUsersRetrieve(client)
   );
 }
 
 // src/cfg/generated/_utils/hooks/cfg__dashboard__dashboard_system.ts
-var import_swr14 = __toESM(require("swr"), 1);
+var import_swr15 = __toESM(require("swr"), 1);
 function useDashboardApiSystemHealthRetrieve(client) {
-  return (0, import_swr14.default)(
+  return (0, import_swr15.default)(
     "cfg-dashboard-api-system-health",
     () => getDashboardApiSystemHealthRetrieve(client)
   );
 }
 function useDashboardApiSystemMetricsRetrieve(client) {
-  return (0, import_swr14.default)(
+  return (0, import_swr15.default)(
     "cfg-dashboard-api-system-metric",
     () => getDashboardApiSystemMetricsRetrieve(client)
   );
 }
 
 // src/cfg/generated/_utils/hooks/cfg__leads__lead_submission.ts
-var import_swr15 = require("swr");
+var import_swr16 = require("swr");
 function useCreateLeadsSubmitCreate() {
-  const { mutate } = (0, import_swr15.useSWRConfig)();
+  const { mutate } = (0, import_swr16.useSWRConfig)();
   return async (data, client) => {
     const result = await createLeadsSubmitCreate(data, client);
     mutate("cfg-leads-submit");
@@ -22621,34 +22883,34 @@ function useCreateLeadsSubmitCreate() {
 }
 
 // src/cfg/generated/_utils/hooks/cfg__newsletter__logs.ts
-var import_swr16 = __toESM(require("swr"), 1);
+var import_swr17 = __toESM(require("swr"), 1);
 function useNewsletterLogsList(params, client) {
-  return (0, import_swr16.default)(
+  return (0, import_swr17.default)(
     params ? ["cfg-newsletter-logs", params] : "cfg-newsletter-logs",
     () => getNewsletterLogsList(params, client)
   );
 }
 
 // src/cfg/generated/_utils/hooks/cfg__newsletter__newsletters.ts
-var import_swr17 = __toESM(require("swr"), 1);
+var import_swr18 = __toESM(require("swr"), 1);
 function useNewsletterNewslettersList(params, client) {
-  return (0, import_swr17.default)(
+  return (0, import_swr18.default)(
     params ? ["cfg-newsletter-newsletters", params] : "cfg-newsletter-newsletters",
     () => getNewsletterNewslettersList(params, client)
   );
 }
 function useNewsletterNewslettersRetrieve(id, client) {
-  return (0, import_swr17.default)(
+  return (0, import_swr18.default)(
     ["cfg-newsletter-newsletter", id],
     () => getNewsletterNewslettersRetrieve(id, client)
   );
 }
 
 // src/cfg/generated/_utils/hooks/cfg__newsletter__subscriptions.ts
-var import_swr18 = __toESM(require("swr"), 1);
-var import_swr19 = require("swr");
+var import_swr19 = __toESM(require("swr"), 1);
+var import_swr20 = require("swr");
 function useCreateNewsletterSubscribeCreate() {
-  const { mutate } = (0, import_swr19.useSWRConfig)();
+  const { mutate } = (0, import_swr20.useSWRConfig)();
   return async (data, client) => {
     const result = await createNewsletterSubscribeCreate(data, client);
     mutate("cfg-newsletter-subscribe");
@@ -22656,13 +22918,13 @@ function useCreateNewsletterSubscribeCreate() {
   };
 }
 function useNewsletterSubscriptionsList(params, client) {
-  return (0, import_swr18.default)(
+  return (0, import_swr19.default)(
     params ? ["cfg-newsletter-subscriptions", params] : "cfg-newsletter-subscriptions",
     () => getNewsletterSubscriptionsList(params, client)
   );
 }
 function useCreateNewsletterUnsubscribeCreate() {
-  const { mutate } = (0, import_swr19.useSWRConfig)();
+  const { mutate } = (0, import_swr20.useSWRConfig)();
   return async (data, client) => {
     const result = await createNewsletterUnsubscribeCreate(data, client);
     mutate("cfg-newsletter-unsubscribe");
@@ -22671,9 +22933,9 @@ function useCreateNewsletterUnsubscribeCreate() {
 }
 
 // src/cfg/generated/_utils/hooks/cfg__newsletter__testing.ts
-var import_swr20 = require("swr");
+var import_swr21 = require("swr");
 function useCreateNewsletterTestCreate() {
-  const { mutate } = (0, import_swr20.useSWRConfig)();
+  const { mutate } = (0, import_swr21.useSWRConfig)();
   return async (data, client) => {
     const result = await createNewsletterTestCreate(data, client);
     mutate("cfg-newsletter-test");
@@ -22682,16 +22944,16 @@ function useCreateNewsletterTestCreate() {
 }
 
 // src/cfg/generated/_utils/hooks/cfg__accounts__user_profile.ts
-var import_swr21 = __toESM(require("swr"), 1);
-var import_swr22 = require("swr");
+var import_swr22 = __toESM(require("swr"), 1);
+var import_swr23 = require("swr");
 function useAccountsProfileRetrieve(client) {
-  return (0, import_swr21.default)(
+  return (0, import_swr22.default)(
     "cfg-accounts-profile",
     () => getAccountsProfileRetrieve(client)
   );
 }
 function useCreateAccountsProfileAvatarCreate() {
-  const { mutate } = (0, import_swr22.useSWRConfig)();
+  const { mutate } = (0, import_swr23.useSWRConfig)();
   return async (data, client) => {
     const result = await createAccountsProfileAvatarCreate(data, client);
     mutate("cfg-accounts-profile-avatar");
@@ -22699,7 +22961,7 @@ function useCreateAccountsProfileAvatarCreate() {
   };
 }
 function usePartialUpdateAccountsProfilePartialUpdate() {
-  const { mutate } = (0, import_swr22.useSWRConfig)();
+  const { mutate } = (0, import_swr23.useSWRConfig)();
   return async (data, client) => {
     const result = await partialUpdateAccountsProfilePartialUpdate(data, client);
     mutate("cfg-accounts-profile-partial");
@@ -22707,7 +22969,7 @@ function usePartialUpdateAccountsProfilePartialUpdate() {
   };
 }
 function usePartialUpdateAccountsProfilePartialPartialUpdate() {
-  const { mutate } = (0, import_swr22.useSWRConfig)();
+  const { mutate } = (0, import_swr23.useSWRConfig)();
   return async (data, client) => {
     const result = await partialUpdateAccountsProfilePartialPartialUpdate(data, client);
     mutate("cfg-accounts-profile-partial-partial");
@@ -22715,7 +22977,7 @@ function usePartialUpdateAccountsProfilePartialPartialUpdate() {
   };
 }
 function useUpdateAccountsProfileUpdateUpdate() {
-  const { mutate } = (0, import_swr22.useSWRConfig)();
+  const { mutate } = (0, import_swr23.useSWRConfig)();
   return async (data, client) => {
     const result = await updateAccountsProfileUpdateUpdate(data, client);
     mutate("cfg-accounts-profile");
@@ -22723,7 +22985,7 @@ function useUpdateAccountsProfileUpdateUpdate() {
   };
 }
 function usePartialUpdateAccountsProfileUpdatePartialUpdate() {
-  const { mutate } = (0, import_swr22.useSWRConfig)();
+  const { mutate } = (0, import_swr23.useSWRConfig)();
   return async (data, client) => {
     const result = await partialUpdateAccountsProfileUpdatePartialUpdate(data, client);
     mutate("cfg-accounts-profile-partial");
@@ -22732,9 +22994,9 @@ function usePartialUpdateAccountsProfileUpdatePartialUpdate() {
 }
 
 // src/cfg/generated/_utils/hooks/cfg__accounts.ts
-var import_swr23 = require("swr");
+var import_swr24 = require("swr");
 function useCreateAccountsOtpRequestCreate() {
-  const { mutate } = (0, import_swr23.useSWRConfig)();
+  const { mutate } = (0, import_swr24.useSWRConfig)();
   return async (data, client) => {
     const result = await createAccountsOtpRequestCreate(data, client);
     mutate("cfg-accounts-otp-request");
@@ -22742,7 +23004,7 @@ function useCreateAccountsOtpRequestCreate() {
   };
 }
 function useCreateAccountsOtpVerifyCreate() {
-  const { mutate } = (0, import_swr23.useSWRConfig)();
+  const { mutate } = (0, import_swr24.useSWRConfig)();
   return async (data, client) => {
     const result = await createAccountsOtpVerifyCreate(data, client);
     mutate("cfg-accounts-otp-verify");
@@ -22751,67 +23013,67 @@ function useCreateAccountsOtpVerifyCreate() {
 }
 
 // src/cfg/generated/_utils/hooks/cfg__centrifugo.ts
-var import_swr24 = __toESM(require("swr"), 1);
+var import_swr25 = __toESM(require("swr"), 1);
 function useCentrifugoAdminApiMonitorChannelsRetrieve(client) {
-  return (0, import_swr24.default)(
+  return (0, import_swr25.default)(
     "cfg-centrifugo-admin-api-monitor-channel",
     () => getCentrifugoAdminApiMonitorChannelsRetrieve(client)
   );
 }
 function useCentrifugoMonitorChannelsRetrieve(client) {
-  return (0, import_swr24.default)(
+  return (0, import_swr25.default)(
     "cfg-centrifugo-monitor-channel",
     () => getCentrifugoMonitorChannelsRetrieve(client)
   );
 }
 
 // src/cfg/generated/_utils/hooks/cfg__endpoints.ts
-var import_swr25 = __toESM(require("swr"), 1);
+var import_swr26 = __toESM(require("swr"), 1);
 function useEndpointsDrfRetrieve(client) {
-  return (0, import_swr25.default)(
+  return (0, import_swr26.default)(
     "cfg-endpoints-drf",
     () => getEndpointsDrfRetrieve(client)
   );
 }
 function useEndpointsUrlsRetrieve(client) {
-  return (0, import_swr25.default)(
+  return (0, import_swr26.default)(
     "cfg-endpoints-url",
     () => getEndpointsUrlsRetrieve(client)
   );
 }
 function useEndpointsUrlsCompactRetrieve(client) {
-  return (0, import_swr25.default)(
+  return (0, import_swr26.default)(
     "cfg-endpoints-urls-compact",
     () => getEndpointsUrlsCompactRetrieve(client)
   );
 }
 
 // src/cfg/generated/_utils/hooks/cfg__health.ts
-var import_swr26 = __toESM(require("swr"), 1);
+var import_swr27 = __toESM(require("swr"), 1);
 function useHealthDrfRetrieve(client) {
-  return (0, import_swr26.default)(
+  return (0, import_swr27.default)(
     "cfg-health-drf",
     () => getHealthDrfRetrieve(client)
   );
 }
 function useHealthDrfQuickRetrieve(client) {
-  return (0, import_swr26.default)(
+  return (0, import_swr27.default)(
     "cfg-health-drf-quick",
     () => getHealthDrfQuickRetrieve(client)
   );
 }
 
 // src/cfg/generated/_utils/hooks/cfg__knowbase.ts
-var import_swr27 = __toESM(require("swr"), 1);
-var import_swr28 = require("swr");
+var import_swr28 = __toESM(require("swr"), 1);
+var import_swr29 = require("swr");
 function useKnowbaseAdminChatList(params, client) {
-  return (0, import_swr27.default)(
+  return (0, import_swr28.default)(
     params ? ["cfg-knowbase-admin-chat", params] : "cfg-knowbase-admin-chat",
     () => getKnowbaseAdminChatList(params, client)
   );
 }
 function useCreateKnowbaseAdminChatCreate() {
-  const { mutate } = (0, import_swr28.useSWRConfig)();
+  const { mutate } = (0, import_swr29.useSWRConfig)();
   return async (data, client) => {
     const result = await createKnowbaseAdminChatCreate(data, client);
     mutate("cfg-knowbase-admin-chat");
@@ -22819,13 +23081,13 @@ function useCreateKnowbaseAdminChatCreate() {
   };
 }
 function useKnowbaseAdminChatRetrieve(id, client) {
-  return (0, import_swr27.default)(
+  return (0, import_swr28.default)(
     ["cfg-knowbase-admin-chat", id],
     () => getKnowbaseAdminChatRetrieve(id, client)
   );
 }
 function useUpdateKnowbaseAdminChatUpdate() {
-  const { mutate } = (0, import_swr28.useSWRConfig)();
+  const { mutate } = (0, import_swr29.useSWRConfig)();
   return async (id, data, client) => {
     const result = await updateKnowbaseAdminChatUpdate(id, data, client);
     mutate("cfg-knowbase-admin-chat");
@@ -22833,7 +23095,7 @@ function useUpdateKnowbaseAdminChatUpdate() {
   };
 }
 function usePartialUpdateKnowbaseAdminChatPartialUpdate() {
-  const { mutate } = (0, import_swr28.useSWRConfig)();
+  const { mutate } = (0, import_swr29.useSWRConfig)();
   return async (id, data, client) => {
     const result = await partialUpdateKnowbaseAdminChatPartialUpdate(id, data, client);
     mutate("cfg-knowbase-admin-chat-partial");
@@ -22841,7 +23103,7 @@ function usePartialUpdateKnowbaseAdminChatPartialUpdate() {
   };
 }
 function useDeleteKnowbaseAdminChatDestroy() {
-  const { mutate } = (0, import_swr28.useSWRConfig)();
+  const { mutate } = (0, import_swr29.useSWRConfig)();
   return async (id, client) => {
     const result = await deleteKnowbaseAdminChatDestroy(id, client);
     mutate("cfg-knowbase-admin-chat");
@@ -22849,13 +23111,13 @@ function useDeleteKnowbaseAdminChatDestroy() {
   };
 }
 function useKnowbaseAdminChatHistoryRetrieve(id, client) {
-  return (0, import_swr27.default)(
+  return (0, import_swr28.default)(
     ["cfg-knowbase-admin-chat-history", id],
     () => getKnowbaseAdminChatHistoryRetrieve(id, client)
   );
 }
 function useCreateKnowbaseAdminChatQueryCreate() {
-  const { mutate } = (0, import_swr28.useSWRConfig)();
+  const { mutate } = (0, import_swr29.useSWRConfig)();
   return async (data, client) => {
     const result = await createKnowbaseAdminChatQueryCreate(data, client);
     mutate("cfg-knowbase-admin-chat-query");
@@ -22863,13 +23125,13 @@ function useCreateKnowbaseAdminChatQueryCreate() {
   };
 }
 function useKnowbaseAdminDocumentsList(params, client) {
-  return (0, import_swr27.default)(
+  return (0, import_swr28.default)(
     params ? ["cfg-knowbase-admin-documents", params] : "cfg-knowbase-admin-documents",
     () => getKnowbaseAdminDocumentsList(params, client)
   );
 }
 function useCreateKnowbaseAdminDocumentsCreate() {
-  const { mutate } = (0, import_swr28.useSWRConfig)();
+  const { mutate } = (0, import_swr29.useSWRConfig)();
   return async (data, client) => {
     const result = await createKnowbaseAdminDocumentsCreate(data, client);
     mutate("cfg-knowbase-admin-documents");
@@ -22877,13 +23139,13 @@ function useCreateKnowbaseAdminDocumentsCreate() {
   };
 }
 function useKnowbaseAdminDocumentsRetrieve(id, client) {
-  return (0, import_swr27.default)(
+  return (0, import_swr28.default)(
     ["cfg-knowbase-admin-document", id],
     () => getKnowbaseAdminDocumentsRetrieve(id, client)
   );
 }
 function useUpdateKnowbaseAdminDocumentsUpdate() {
-  const { mutate } = (0, import_swr28.useSWRConfig)();
+  const { mutate } = (0, import_swr29.useSWRConfig)();
   return async (id, data, client) => {
     const result = await updateKnowbaseAdminDocumentsUpdate(id, data, client);
     mutate("cfg-knowbase-admin-documents");
@@ -22892,7 +23154,7 @@ function useUpdateKnowbaseAdminDocumentsUpdate() {
   };
 }
 function usePartialUpdateKnowbaseAdminDocumentsPartialUpdate() {
-  const { mutate } = (0, import_swr28.useSWRConfig)();
+  const { mutate } = (0, import_swr29.useSWRConfig)();
   return async (id, data, client) => {
     const result = await partialUpdateKnowbaseAdminDocumentsPartialUpdate(id, data, client);
     mutate("cfg-knowbase-admin-documents-partial");
@@ -22900,7 +23162,7 @@ function usePartialUpdateKnowbaseAdminDocumentsPartialUpdate() {
   };
 }
 function useDeleteKnowbaseAdminDocumentsDestroy() {
-  const { mutate } = (0, import_swr28.useSWRConfig)();
+  const { mutate } = (0, import_swr29.useSWRConfig)();
   return async (id, client) => {
     const result = await deleteKnowbaseAdminDocumentsDestroy(id, client);
     mutate("cfg-knowbase-admin-documents");
@@ -22909,7 +23171,7 @@ function useDeleteKnowbaseAdminDocumentsDestroy() {
   };
 }
 function useCreateKnowbaseAdminDocumentsReprocessCreate() {
-  const { mutate } = (0, import_swr28.useSWRConfig)();
+  const { mutate } = (0, import_swr29.useSWRConfig)();
   return async (id, data, client) => {
     const result = await createKnowbaseAdminDocumentsReprocessCreate(id, data, client);
     mutate("cfg-knowbase-admin-documents-reprocess");
@@ -22917,25 +23179,25 @@ function useCreateKnowbaseAdminDocumentsReprocessCreate() {
   };
 }
 function useKnowbaseAdminDocumentsStatusRetrieve(id, client) {
-  return (0, import_swr27.default)(
+  return (0, import_swr28.default)(
     ["cfg-knowbase-admin-documents-statu", id],
     () => getKnowbaseAdminDocumentsStatusRetrieve(id, client)
   );
 }
 function useKnowbaseAdminDocumentsStatsRetrieve(client) {
-  return (0, import_swr27.default)(
+  return (0, import_swr28.default)(
     "cfg-knowbase-admin-documents-stat",
     () => getKnowbaseAdminDocumentsStatsRetrieve(client)
   );
 }
 function useKnowbaseAdminSessionsList(params, client) {
-  return (0, import_swr27.default)(
+  return (0, import_swr28.default)(
     params ? ["cfg-knowbase-admin-sessions", params] : "cfg-knowbase-admin-sessions",
     () => getKnowbaseAdminSessionsList(params, client)
   );
 }
 function useCreateKnowbaseAdminSessionsCreate() {
-  const { mutate } = (0, import_swr28.useSWRConfig)();
+  const { mutate } = (0, import_swr29.useSWRConfig)();
   return async (data, client) => {
     const result = await createKnowbaseAdminSessionsCreate(data, client);
     mutate("cfg-knowbase-admin-sessions");
@@ -22943,13 +23205,13 @@ function useCreateKnowbaseAdminSessionsCreate() {
   };
 }
 function useKnowbaseAdminSessionsRetrieve(id, client) {
-  return (0, import_swr27.default)(
+  return (0, import_swr28.default)(
     ["cfg-knowbase-admin-session", id],
     () => getKnowbaseAdminSessionsRetrieve(id, client)
   );
 }
 function useUpdateKnowbaseAdminSessionsUpdate() {
-  const { mutate } = (0, import_swr28.useSWRConfig)();
+  const { mutate } = (0, import_swr29.useSWRConfig)();
   return async (id, data, client) => {
     const result = await updateKnowbaseAdminSessionsUpdate(id, data, client);
     mutate("cfg-knowbase-admin-sessions");
@@ -22958,7 +23220,7 @@ function useUpdateKnowbaseAdminSessionsUpdate() {
   };
 }
 function usePartialUpdateKnowbaseAdminSessionsPartialUpdate() {
-  const { mutate } = (0, import_swr28.useSWRConfig)();
+  const { mutate } = (0, import_swr29.useSWRConfig)();
   return async (id, data, client) => {
     const result = await partialUpdateKnowbaseAdminSessionsPartialUpdate(id, data, client);
     mutate("cfg-knowbase-admin-sessions-partial");
@@ -22966,7 +23228,7 @@ function usePartialUpdateKnowbaseAdminSessionsPartialUpdate() {
   };
 }
 function useDeleteKnowbaseAdminSessionsDestroy() {
-  const { mutate } = (0, import_swr28.useSWRConfig)();
+  const { mutate } = (0, import_swr29.useSWRConfig)();
   return async (id, client) => {
     const result = await deleteKnowbaseAdminSessionsDestroy(id, client);
     mutate("cfg-knowbase-admin-sessions");
@@ -22975,7 +23237,7 @@ function useDeleteKnowbaseAdminSessionsDestroy() {
   };
 }
 function useCreateKnowbaseAdminSessionsActivateCreate() {
-  const { mutate } = (0, import_swr28.useSWRConfig)();
+  const { mutate } = (0, import_swr29.useSWRConfig)();
   return async (id, data, client) => {
     const result = await createKnowbaseAdminSessionsActivateCreate(id, data, client);
     mutate("cfg-knowbase-admin-sessions-activate");
@@ -22983,7 +23245,7 @@ function useCreateKnowbaseAdminSessionsActivateCreate() {
   };
 }
 function useCreateKnowbaseAdminSessionsArchiveCreate() {
-  const { mutate } = (0, import_swr28.useSWRConfig)();
+  const { mutate } = (0, import_swr29.useSWRConfig)();
   return async (id, data, client) => {
     const result = await createKnowbaseAdminSessionsArchiveCreate(id, data, client);
     mutate("cfg-knowbase-admin-sessions-archive");
@@ -22991,37 +23253,37 @@ function useCreateKnowbaseAdminSessionsArchiveCreate() {
   };
 }
 function useKnowbaseCategoriesList(params, client) {
-  return (0, import_swr27.default)(
+  return (0, import_swr28.default)(
     params ? ["cfg-knowbase-categories", params] : "cfg-knowbase-categories",
     () => getKnowbaseCategoriesList(params, client)
   );
 }
 function useKnowbaseCategoriesRetrieve(id, client) {
-  return (0, import_swr27.default)(
+  return (0, import_swr28.default)(
     ["cfg-knowbase-categorie", id],
     () => getKnowbaseCategoriesRetrieve(id, client)
   );
 }
 function useKnowbaseDocumentsList(params, client) {
-  return (0, import_swr27.default)(
+  return (0, import_swr28.default)(
     params ? ["cfg-knowbase-documents", params] : "cfg-knowbase-documents",
     () => getKnowbaseDocumentsList(params, client)
   );
 }
 function useKnowbaseDocumentsRetrieve(id, client) {
-  return (0, import_swr27.default)(
+  return (0, import_swr28.default)(
     ["cfg-knowbase-document", id],
     () => getKnowbaseDocumentsRetrieve(id, client)
   );
 }
 function useKnowbaseSystemArchivesList(params, client) {
-  return (0, import_swr27.default)(
+  return (0, import_swr28.default)(
     params ? ["cfg-knowbase-system-archives", params] : "cfg-knowbase-system-archives",
     () => getKnowbaseSystemArchivesList(params, client)
   );
 }
 function useCreateKnowbaseSystemArchivesCreate() {
-  const { mutate } = (0, import_swr28.useSWRConfig)();
+  const { mutate } = (0, import_swr29.useSWRConfig)();
   return async (data, client) => {
     const result = await createKnowbaseSystemArchivesCreate(data, client);
     mutate("cfg-knowbase-system-archives");
@@ -23029,13 +23291,13 @@ function useCreateKnowbaseSystemArchivesCreate() {
   };
 }
 function useKnowbaseSystemArchivesRetrieve(id, client) {
-  return (0, import_swr27.default)(
+  return (0, import_swr28.default)(
     ["cfg-knowbase-system-archive", id],
     () => getKnowbaseSystemArchivesRetrieve(id, client)
   );
 }
 function useUpdateKnowbaseSystemArchivesUpdate() {
-  const { mutate } = (0, import_swr28.useSWRConfig)();
+  const { mutate } = (0, import_swr29.useSWRConfig)();
   return async (id, data, client) => {
     const result = await updateKnowbaseSystemArchivesUpdate(id, data, client);
     mutate("cfg-knowbase-system-archives");
@@ -23044,7 +23306,7 @@ function useUpdateKnowbaseSystemArchivesUpdate() {
   };
 }
 function usePartialUpdateKnowbaseSystemArchivesPartialUpdate() {
-  const { mutate } = (0, import_swr28.useSWRConfig)();
+  const { mutate } = (0, import_swr29.useSWRConfig)();
   return async (id, data, client) => {
     const result = await partialUpdateKnowbaseSystemArchivesPartialUpdate(id, data, client);
     mutate("cfg-knowbase-system-archives-partial");
@@ -23052,7 +23314,7 @@ function usePartialUpdateKnowbaseSystemArchivesPartialUpdate() {
   };
 }
 function useDeleteKnowbaseSystemArchivesDestroy() {
-  const { mutate } = (0, import_swr28.useSWRConfig)();
+  const { mutate } = (0, import_swr29.useSWRConfig)();
   return async (id, client) => {
     const result = await deleteKnowbaseSystemArchivesDestroy(id, client);
     mutate("cfg-knowbase-system-archives");
@@ -23061,19 +23323,19 @@ function useDeleteKnowbaseSystemArchivesDestroy() {
   };
 }
 function useKnowbaseSystemArchivesFileTreeRetrieve(id, client) {
-  return (0, import_swr27.default)(
+  return (0, import_swr28.default)(
     ["cfg-knowbase-system-archives-file-tree", id],
     () => getKnowbaseSystemArchivesFileTreeRetrieve(id, client)
   );
 }
 function useKnowbaseSystemArchivesItemsList(id, params, client) {
-  return (0, import_swr27.default)(
+  return (0, import_swr28.default)(
     ["cfg-knowbase-system-archives-items", id],
     () => getKnowbaseSystemArchivesItemsList(id, params, client)
   );
 }
 function useCreateKnowbaseSystemArchivesSearchCreate() {
-  const { mutate } = (0, import_swr28.useSWRConfig)();
+  const { mutate } = (0, import_swr29.useSWRConfig)();
   return async (id, data, params, client) => {
     const result = await createKnowbaseSystemArchivesSearchCreate(id, data, params, client);
     mutate("cfg-knowbase-system-archives-search");
@@ -23081,7 +23343,7 @@ function useCreateKnowbaseSystemArchivesSearchCreate() {
   };
 }
 function useCreateKnowbaseSystemArchivesRevectorizeCreate() {
-  const { mutate } = (0, import_swr28.useSWRConfig)();
+  const { mutate } = (0, import_swr29.useSWRConfig)();
   return async (data, client) => {
     const result = await createKnowbaseSystemArchivesRevectorizeCreate(data, client);
     mutate("cfg-knowbase-system-archives-revectorize");
@@ -23089,25 +23351,25 @@ function useCreateKnowbaseSystemArchivesRevectorizeCreate() {
   };
 }
 function useKnowbaseSystemArchivesStatisticsRetrieve(client) {
-  return (0, import_swr27.default)(
+  return (0, import_swr28.default)(
     "cfg-knowbase-system-archives-statistic",
     () => getKnowbaseSystemArchivesStatisticsRetrieve(client)
   );
 }
 function useKnowbaseSystemArchivesVectorizationStatsRetrieve(client) {
-  return (0, import_swr27.default)(
+  return (0, import_swr28.default)(
     "cfg-knowbase-system-archives-vectorization-stat",
     () => getKnowbaseSystemArchivesVectorizationStatsRetrieve(client)
   );
 }
 function useKnowbaseSystemChunksList(params, client) {
-  return (0, import_swr27.default)(
+  return (0, import_swr28.default)(
     params ? ["cfg-knowbase-system-chunks", params] : "cfg-knowbase-system-chunks",
     () => getKnowbaseSystemChunksList(params, client)
   );
 }
 function useCreateKnowbaseSystemChunksCreate() {
-  const { mutate } = (0, import_swr28.useSWRConfig)();
+  const { mutate } = (0, import_swr29.useSWRConfig)();
   return async (data, client) => {
     const result = await createKnowbaseSystemChunksCreate(data, client);
     mutate("cfg-knowbase-system-chunks");
@@ -23115,13 +23377,13 @@ function useCreateKnowbaseSystemChunksCreate() {
   };
 }
 function useKnowbaseSystemChunksRetrieve(id, client) {
-  return (0, import_swr27.default)(
+  return (0, import_swr28.default)(
     ["cfg-knowbase-system-chunk", id],
     () => getKnowbaseSystemChunksRetrieve(id, client)
   );
 }
 function useUpdateKnowbaseSystemChunksUpdate() {
-  const { mutate } = (0, import_swr28.useSWRConfig)();
+  const { mutate } = (0, import_swr29.useSWRConfig)();
   return async (id, data, client) => {
     const result = await updateKnowbaseSystemChunksUpdate(id, data, client);
     mutate("cfg-knowbase-system-chunks");
@@ -23130,7 +23392,7 @@ function useUpdateKnowbaseSystemChunksUpdate() {
   };
 }
 function usePartialUpdateKnowbaseSystemChunksPartialUpdate() {
-  const { mutate } = (0, import_swr28.useSWRConfig)();
+  const { mutate } = (0, import_swr29.useSWRConfig)();
   return async (id, data, client) => {
     const result = await partialUpdateKnowbaseSystemChunksPartialUpdate(id, data, client);
     mutate("cfg-knowbase-system-chunks-partial");
@@ -23138,7 +23400,7 @@ function usePartialUpdateKnowbaseSystemChunksPartialUpdate() {
   };
 }
 function useDeleteKnowbaseSystemChunksDestroy() {
-  const { mutate } = (0, import_swr28.useSWRConfig)();
+  const { mutate } = (0, import_swr29.useSWRConfig)();
   return async (id, client) => {
     const result = await deleteKnowbaseSystemChunksDestroy(id, client);
     mutate("cfg-knowbase-system-chunks");
@@ -23147,13 +23409,13 @@ function useDeleteKnowbaseSystemChunksDestroy() {
   };
 }
 function useKnowbaseSystemChunksContextRetrieve(id, client) {
-  return (0, import_swr27.default)(
+  return (0, import_swr28.default)(
     ["cfg-knowbase-system-chunks-context", id],
     () => getKnowbaseSystemChunksContextRetrieve(id, client)
   );
 }
 function useCreateKnowbaseSystemChunksVectorizeCreate() {
-  const { mutate } = (0, import_swr28.useSWRConfig)();
+  const { mutate } = (0, import_swr29.useSWRConfig)();
   return async (id, data, client) => {
     const result = await createKnowbaseSystemChunksVectorizeCreate(id, data, client);
     mutate("cfg-knowbase-system-chunks-vectorize");
@@ -23161,13 +23423,13 @@ function useCreateKnowbaseSystemChunksVectorizeCreate() {
   };
 }
 function useKnowbaseSystemItemsList(params, client) {
-  return (0, import_swr27.default)(
+  return (0, import_swr28.default)(
     params ? ["cfg-knowbase-system-items", params] : "cfg-knowbase-system-items",
     () => getKnowbaseSystemItemsList(params, client)
   );
 }
 function useCreateKnowbaseSystemItemsCreate() {
-  const { mutate } = (0, import_swr28.useSWRConfig)();
+  const { mutate } = (0, import_swr29.useSWRConfig)();
   return async (data, client) => {
     const result = await createKnowbaseSystemItemsCreate(data, client);
     mutate("cfg-knowbase-system-items");
@@ -23175,13 +23437,13 @@ function useCreateKnowbaseSystemItemsCreate() {
   };
 }
 function useKnowbaseSystemItemsRetrieve(id, client) {
-  return (0, import_swr27.default)(
+  return (0, import_swr28.default)(
     ["cfg-knowbase-system-item", id],
     () => getKnowbaseSystemItemsRetrieve(id, client)
   );
 }
 function useUpdateKnowbaseSystemItemsUpdate() {
-  const { mutate } = (0, import_swr28.useSWRConfig)();
+  const { mutate } = (0, import_swr29.useSWRConfig)();
   return async (id, data, client) => {
     const result = await updateKnowbaseSystemItemsUpdate(id, data, client);
     mutate("cfg-knowbase-system-items");
@@ -23190,7 +23452,7 @@ function useUpdateKnowbaseSystemItemsUpdate() {
   };
 }
 function usePartialUpdateKnowbaseSystemItemsPartialUpdate() {
-  const { mutate } = (0, import_swr28.useSWRConfig)();
+  const { mutate } = (0, import_swr29.useSWRConfig)();
   return async (id, data, client) => {
     const result = await partialUpdateKnowbaseSystemItemsPartialUpdate(id, data, client);
     mutate("cfg-knowbase-system-items-partial");
@@ -23198,7 +23460,7 @@ function usePartialUpdateKnowbaseSystemItemsPartialUpdate() {
   };
 }
 function useDeleteKnowbaseSystemItemsDestroy() {
-  const { mutate } = (0, import_swr28.useSWRConfig)();
+  const { mutate } = (0, import_swr29.useSWRConfig)();
   return async (id, client) => {
     const result = await deleteKnowbaseSystemItemsDestroy(id, client);
     mutate("cfg-knowbase-system-items");
@@ -23207,29 +23469,29 @@ function useDeleteKnowbaseSystemItemsDestroy() {
   };
 }
 function useKnowbaseSystemItemsChunksList(id, params, client) {
-  return (0, import_swr27.default)(
+  return (0, import_swr28.default)(
     ["cfg-knowbase-system-items-chunks", id],
     () => getKnowbaseSystemItemsChunksList(id, params, client)
   );
 }
 function useKnowbaseSystemItemsContentRetrieve(id, client) {
-  return (0, import_swr27.default)(
+  return (0, import_swr28.default)(
     ["cfg-knowbase-system-items-content", id],
     () => getKnowbaseSystemItemsContentRetrieve(id, client)
   );
 }
 
 // src/cfg/generated/_utils/hooks/cfg__leads.ts
-var import_swr29 = __toESM(require("swr"), 1);
-var import_swr30 = require("swr");
+var import_swr30 = __toESM(require("swr"), 1);
+var import_swr31 = require("swr");
 function useLeadsList(params, client) {
-  return (0, import_swr29.default)(
+  return (0, import_swr30.default)(
     params ? ["cfg-leads", params] : "cfg-leads",
     () => getLeadsList(params, client)
   );
 }
 function useCreateLeadsCreate() {
-  const { mutate } = (0, import_swr30.useSWRConfig)();
+  const { mutate } = (0, import_swr31.useSWRConfig)();
   return async (data, client) => {
     const result = await createLeadsCreate(data, client);
     mutate("cfg-leads");
@@ -23237,13 +23499,13 @@ function useCreateLeadsCreate() {
   };
 }
 function useLeadsRetrieve(id, client) {
-  return (0, import_swr29.default)(
+  return (0, import_swr30.default)(
     ["cfg-lead", id],
     () => getLeadsRetrieve(id, client)
   );
 }
 function useUpdateLeadsUpdate() {
-  const { mutate } = (0, import_swr30.useSWRConfig)();
+  const { mutate } = (0, import_swr31.useSWRConfig)();
   return async (id, data, client) => {
     const result = await updateLeadsUpdate(id, data, client);
     mutate("cfg-leads");
@@ -23252,7 +23514,7 @@ function useUpdateLeadsUpdate() {
   };
 }
 function usePartialUpdateLeadsPartialUpdate() {
-  const { mutate } = (0, import_swr30.useSWRConfig)();
+  const { mutate } = (0, import_swr31.useSWRConfig)();
   return async (id, data, client) => {
     const result = await partialUpdateLeadsPartialUpdate(id, data, client);
     mutate("cfg-leads-partial");
@@ -23260,7 +23522,7 @@ function usePartialUpdateLeadsPartialUpdate() {
   };
 }
 function useDeleteLeadsDestroy() {
-  const { mutate } = (0, import_swr30.useSWRConfig)();
+  const { mutate } = (0, import_swr31.useSWRConfig)();
   return async (id, client) => {
     const result = await deleteLeadsDestroy(id, client);
     mutate("cfg-leads");
@@ -23270,9 +23532,9 @@ function useDeleteLeadsDestroy() {
 }
 
 // src/cfg/generated/_utils/hooks/cfg__newsletter.ts
-var import_swr31 = require("swr");
+var import_swr32 = require("swr");
 function usePartialUpdateNewsletterCampaignsPartialUpdate() {
-  const { mutate } = (0, import_swr31.useSWRConfig)();
+  const { mutate } = (0, import_swr32.useSWRConfig)();
   return async (id, data, client) => {
     const result = await partialUpdateNewsletterCampaignsPartialUpdate(id, data, client);
     mutate("cfg-newsletter-campaigns-partial");
@@ -23280,7 +23542,7 @@ function usePartialUpdateNewsletterCampaignsPartialUpdate() {
   };
 }
 function useUpdateNewsletterUnsubscribeUpdate() {
-  const { mutate } = (0, import_swr31.useSWRConfig)();
+  const { mutate } = (0, import_swr32.useSWRConfig)();
   return async (data, client) => {
     const result = await updateNewsletterUnsubscribeUpdate(data, client);
     mutate("cfg-newsletter-unsubscribe");
@@ -23288,7 +23550,7 @@ function useUpdateNewsletterUnsubscribeUpdate() {
   };
 }
 function usePartialUpdateNewsletterUnsubscribePartialUpdate() {
-  const { mutate } = (0, import_swr31.useSWRConfig)();
+  const { mutate } = (0, import_swr32.useSWRConfig)();
   return async (data, client) => {
     const result = await partialUpdateNewsletterUnsubscribePartialUpdate(data, client);
     mutate("cfg-newsletter-unsubscribe-partial");
@@ -23297,34 +23559,34 @@ function usePartialUpdateNewsletterUnsubscribePartialUpdate() {
 }
 
 // src/cfg/generated/_utils/hooks/cfg__payments.ts
-var import_swr32 = __toESM(require("swr"), 1);
-var import_swr33 = require("swr");
+var import_swr33 = __toESM(require("swr"), 1);
+var import_swr34 = require("swr");
 function usePaymentsBalanceRetrieve(client) {
-  return (0, import_swr32.default)(
+  return (0, import_swr33.default)(
     "cfg-payments-balance",
     () => getPaymentsBalanceRetrieve(client)
   );
 }
 function usePaymentsCurrenciesList(client) {
-  return (0, import_swr32.default)(
+  return (0, import_swr33.default)(
     "cfg-payments-currencies",
     () => getPaymentsCurrenciesList(client)
   );
 }
 function usePaymentsPaymentsList(params, client) {
-  return (0, import_swr32.default)(
+  return (0, import_swr33.default)(
     params ? ["cfg-payments-payments", params] : "cfg-payments-payments",
     () => getPaymentsPaymentsList(params, client)
   );
 }
 function usePaymentsPaymentsRetrieve(id, client) {
-  return (0, import_swr32.default)(
+  return (0, import_swr33.default)(
     ["cfg-payments-payment", id],
     () => getPaymentsPaymentsRetrieve(id, client)
   );
 }
 function useCreatePaymentsPaymentsConfirmCreate() {
-  const { mutate } = (0, import_swr33.useSWRConfig)();
+  const { mutate } = (0, import_swr34.useSWRConfig)();
   return async (id, client) => {
     const result = await createPaymentsPaymentsConfirmCreate(id, client);
     mutate("cfg-payments-payments-confirm");
@@ -23332,13 +23594,13 @@ function useCreatePaymentsPaymentsConfirmCreate() {
   };
 }
 function usePaymentsPaymentsStatusRetrieve(id, client) {
-  return (0, import_swr32.default)(
+  return (0, import_swr33.default)(
     ["cfg-payments-payments-statu", id],
     () => getPaymentsPaymentsStatusRetrieve(id, client)
   );
 }
 function useCreatePaymentsPaymentsCreateCreate() {
-  const { mutate } = (0, import_swr33.useSWRConfig)();
+  const { mutate } = (0, import_swr34.useSWRConfig)();
   return async (client) => {
     const result = await createPaymentsPaymentsCreateCreate(client);
     mutate("cfg-payments-payments");
@@ -23346,23 +23608,23 @@ function useCreatePaymentsPaymentsCreateCreate() {
   };
 }
 function usePaymentsTransactionsList(params, client) {
-  return (0, import_swr32.default)(
+  return (0, import_swr33.default)(
     params ? ["cfg-payments-transactions", params] : "cfg-payments-transactions",
     () => getPaymentsTransactionsList(params, client)
   );
 }
 
 // src/cfg/generated/_utils/hooks/cfg__support.ts
-var import_swr34 = __toESM(require("swr"), 1);
-var import_swr35 = require("swr");
+var import_swr35 = __toESM(require("swr"), 1);
+var import_swr36 = require("swr");
 function useSupportTicketsList(params, client) {
-  return (0, import_swr34.default)(
+  return (0, import_swr35.default)(
     params ? ["cfg-support-tickets", params] : "cfg-support-tickets",
     () => getSupportTicketsList(params, client)
   );
 }
 function useCreateSupportTicketsCreate() {
-  const { mutate } = (0, import_swr35.useSWRConfig)();
+  const { mutate } = (0, import_swr36.useSWRConfig)();
   return async (data, client) => {
     const result = await createSupportTicketsCreate(data, client);
     mutate("cfg-support-tickets");
@@ -23370,13 +23632,13 @@ function useCreateSupportTicketsCreate() {
   };
 }
 function useSupportTicketsMessagesList(ticket_uuid, params, client) {
-  return (0, import_swr34.default)(
+  return (0, import_swr35.default)(
     ["cfg-support-tickets-messages", ticket_uuid],
     () => getSupportTicketsMessagesList(ticket_uuid, params, client)
   );
 }
 function useCreateSupportTicketsMessagesCreate() {
-  const { mutate } = (0, import_swr35.useSWRConfig)();
+  const { mutate } = (0, import_swr36.useSWRConfig)();
   return async (ticket_uuid, data, client) => {
     const result = await createSupportTicketsMessagesCreate(ticket_uuid, data, client);
     mutate("cfg-support-tickets-messages");
@@ -23384,13 +23646,13 @@ function useCreateSupportTicketsMessagesCreate() {
   };
 }
 function useSupportTicketsMessagesRetrieve(ticket_uuid, uuid, client) {
-  return (0, import_swr34.default)(
+  return (0, import_swr35.default)(
     ["cfg-support-tickets-message", ticket_uuid],
     () => getSupportTicketsMessagesRetrieve(ticket_uuid, uuid, client)
   );
 }
 function useUpdateSupportTicketsMessagesUpdate() {
-  const { mutate } = (0, import_swr35.useSWRConfig)();
+  const { mutate } = (0, import_swr36.useSWRConfig)();
   return async (ticket_uuid, uuid, data, client) => {
     const result = await updateSupportTicketsMessagesUpdate(ticket_uuid, uuid, data, client);
     mutate("cfg-support-tickets-messages");
@@ -23399,7 +23661,7 @@ function useUpdateSupportTicketsMessagesUpdate() {
   };
 }
 function usePartialUpdateSupportTicketsMessagesPartialUpdate() {
-  const { mutate } = (0, import_swr35.useSWRConfig)();
+  const { mutate } = (0, import_swr36.useSWRConfig)();
   return async (ticket_uuid, uuid, data, client) => {
     const result = await partialUpdateSupportTicketsMessagesPartialUpdate(ticket_uuid, uuid, data, client);
     mutate("cfg-support-tickets-messages-partial");
@@ -23407,7 +23669,7 @@ function usePartialUpdateSupportTicketsMessagesPartialUpdate() {
   };
 }
 function useDeleteSupportTicketsMessagesDestroy() {
-  const { mutate } = (0, import_swr35.useSWRConfig)();
+  const { mutate } = (0, import_swr36.useSWRConfig)();
   return async (ticket_uuid, uuid, client) => {
     const result = await deleteSupportTicketsMessagesDestroy(ticket_uuid, uuid, client);
     mutate("cfg-support-tickets-messages");
@@ -23416,13 +23678,13 @@ function useDeleteSupportTicketsMessagesDestroy() {
   };
 }
 function useSupportTicketsRetrieve(uuid, client) {
-  return (0, import_swr34.default)(
+  return (0, import_swr35.default)(
     ["cfg-support-ticket", uuid],
     () => getSupportTicketsRetrieve(uuid, client)
   );
 }
 function useUpdateSupportTicketsUpdate() {
-  const { mutate } = (0, import_swr35.useSWRConfig)();
+  const { mutate } = (0, import_swr36.useSWRConfig)();
   return async (uuid, data, client) => {
     const result = await updateSupportTicketsUpdate(uuid, data, client);
     mutate("cfg-support-tickets");
@@ -23431,7 +23693,7 @@ function useUpdateSupportTicketsUpdate() {
   };
 }
 function usePartialUpdateSupportTicketsPartialUpdate() {
-  const { mutate } = (0, import_swr35.useSWRConfig)();
+  const { mutate } = (0, import_swr36.useSWRConfig)();
   return async (uuid, data, client) => {
     const result = await partialUpdateSupportTicketsPartialUpdate(uuid, data, client);
     mutate("cfg-support-tickets-partial");
@@ -23439,7 +23701,7 @@ function usePartialUpdateSupportTicketsPartialUpdate() {
   };
 }
 function useDeleteSupportTicketsDestroy() {
-  const { mutate } = (0, import_swr35.useSWRConfig)();
+  const { mutate } = (0, import_swr36.useSWRConfig)();
   return async (uuid, client) => {
     const result = await deleteSupportTicketsDestroy(uuid, client);
     mutate("cfg-support-tickets");
@@ -23449,10 +23711,10 @@ function useDeleteSupportTicketsDestroy() {
 }
 
 // src/cfg/generated/_utils/hooks/cfg__tasks.ts
-var import_swr36 = __toESM(require("swr"), 1);
-var import_swr37 = require("swr");
+var import_swr37 = __toESM(require("swr"), 1);
+var import_swr38 = require("swr");
 function useCreateTasksApiClearCreate() {
-  const { mutate } = (0, import_swr37.useSWRConfig)();
+  const { mutate } = (0, import_swr38.useSWRConfig)();
   return async (data, client) => {
     const result = await createTasksApiClearCreate(data, client);
     mutate("cfg-tasks-api-clear");
@@ -23460,7 +23722,7 @@ function useCreateTasksApiClearCreate() {
   };
 }
 function useCreateTasksApiClearQueuesCreate() {
-  const { mutate } = (0, import_swr37.useSWRConfig)();
+  const { mutate } = (0, import_swr38.useSWRConfig)();
   return async (data, client) => {
     const result = await createTasksApiClearQueuesCreate(data, client);
     mutate("cfg-tasks-api-clear-queues");
@@ -23468,7 +23730,7 @@ function useCreateTasksApiClearQueuesCreate() {
   };
 }
 function useCreateTasksApiPurgeFailedCreate() {
-  const { mutate } = (0, import_swr37.useSWRConfig)();
+  const { mutate } = (0, import_swr38.useSWRConfig)();
   return async (data, client) => {
     const result = await createTasksApiPurgeFailedCreate(data, client);
     mutate("cfg-tasks-api-purge-failed");
@@ -23476,7 +23738,7 @@ function useCreateTasksApiPurgeFailedCreate() {
   };
 }
 function useCreateTasksApiQueuesManageCreate() {
-  const { mutate } = (0, import_swr37.useSWRConfig)();
+  const { mutate } = (0, import_swr38.useSWRConfig)();
   return async (data, client) => {
     const result = await createTasksApiQueuesManageCreate(data, client);
     mutate("cfg-tasks-api-queues-manage");
@@ -23484,13 +23746,13 @@ function useCreateTasksApiQueuesManageCreate() {
   };
 }
 function useTasksApiQueuesStatusRetrieve(client) {
-  return (0, import_swr36.default)(
+  return (0, import_swr37.default)(
     "cfg-tasks-api-queues-statu",
     () => getTasksApiQueuesStatusRetrieve(client)
   );
 }
 function useCreateTasksApiSimulateCreate() {
-  const { mutate } = (0, import_swr37.useSWRConfig)();
+  const { mutate } = (0, import_swr38.useSWRConfig)();
   return async (data, client) => {
     const result = await createTasksApiSimulateCreate(data, client);
     mutate("cfg-tasks-api-simulate");
@@ -23498,25 +23760,25 @@ function useCreateTasksApiSimulateCreate() {
   };
 }
 function useTasksApiTasksListRetrieve(client) {
-  return (0, import_swr36.default)(
+  return (0, import_swr37.default)(
     "cfg-tasks-api-task",
     () => getTasksApiTasksListRetrieve(client)
   );
 }
 function useTasksApiTasksStatsRetrieve(client) {
-  return (0, import_swr36.default)(
+  return (0, import_swr37.default)(
     "cfg-tasks-api-tasks-stat",
     () => getTasksApiTasksStatsRetrieve(client)
   );
 }
 function useTasksApiWorkersListRetrieve(client) {
-  return (0, import_swr36.default)(
+  return (0, import_swr37.default)(
     "cfg-tasks-api-worker",
     () => getTasksApiWorkersListRetrieve(client)
   );
 }
 function useCreateTasksApiWorkersManageCreate() {
-  const { mutate } = (0, import_swr37.useSWRConfig)();
+  const { mutate } = (0, import_swr38.useSWRConfig)();
   return async (data, client) => {
     const result = await createTasksApiWorkersManageCreate(data, client);
     mutate("cfg-tasks-api-workers-manage");
@@ -24633,11 +24895,11 @@ var NewsletterService = class extends BaseClient {
 
 // src/cfg/contexts/AccountsContext.tsx
 var import_react = require("react");
-var import_swr38 = require("swr");
+var import_swr39 = require("swr");
 var import_jsx_runtime = require("react/jsx-runtime");
 var AccountsContext = (0, import_react.createContext)(void 0);
 function AccountsProvider({ children }) {
-  const { mutate } = (0, import_swr38.useSWRConfig)();
+  const { mutate } = (0, import_swr39.useSWRConfig)();
   const swrConfig = {
     revalidateOnFocus: false,
     revalidateOnReconnect: false,
@@ -24709,7 +24971,7 @@ function AccountsProvider({ children }) {
     refreshToken,
     logout
   };
-  return /* @__PURE__ */ (0, import_jsx_runtime.jsx)(import_swr38.SWRConfig, { value: swrConfig, children: /* @__PURE__ */ (0, import_jsx_runtime.jsx)(AccountsContext.Provider, { value, children }) });
+  return /* @__PURE__ */ (0, import_jsx_runtime.jsx)(import_swr39.SWRConfig, { value: swrConfig, children: /* @__PURE__ */ (0, import_jsx_runtime.jsx)(AccountsContext.Provider, { value, children }) });
 }
 function useAccountsContext() {
   const context = (0, import_react.useContext)(AccountsContext);
@@ -24721,7 +24983,7 @@ function useAccountsContext() {
 
 // src/cfg/contexts/NewsletterContext.tsx
 var import_react2 = require("react");
-var import_swr39 = require("swr");
+var import_swr40 = require("swr");
 var import_jsx_runtime2 = require("react/jsx-runtime");
 var NewsletterContext = (0, import_react2.createContext)(void 0);
 function NewsletterProvider({
@@ -24729,7 +24991,7 @@ function NewsletterProvider({
   page = 1,
   pageSize = 100
 }) {
-  const { mutate } = (0, import_swr39.useSWRConfig)();
+  const { mutate } = (0, import_swr40.useSWRConfig)();
   const swrConfig = {
     revalidateOnFocus: false,
     revalidateOnReconnect: false,
@@ -24817,7 +25079,7 @@ function NewsletterProvider({
     subscribe,
     unsubscribe
   };
-  return /* @__PURE__ */ (0, import_jsx_runtime2.jsx)(import_swr39.SWRConfig, { value: swrConfig, children: /* @__PURE__ */ (0, import_jsx_runtime2.jsx)(NewsletterContext.Provider, { value, children }) });
+  return /* @__PURE__ */ (0, import_jsx_runtime2.jsx)(import_swr40.SWRConfig, { value: swrConfig, children: /* @__PURE__ */ (0, import_jsx_runtime2.jsx)(NewsletterContext.Provider, { value, children }) });
 }
 function useNewsletterContext() {
   const context = (0, import_react2.useContext)(NewsletterContext);
@@ -24829,7 +25091,7 @@ function useNewsletterContext() {
 
 // src/cfg/contexts/LeadsContext.tsx
 var import_react3 = require("react");
-var import_swr40 = require("swr");
+var import_swr41 = require("swr");
 var import_jsx_runtime3 = require("react/jsx-runtime");
 var LeadsContext = (0, import_react3.createContext)(void 0);
 function LeadsProvider({ children }) {
@@ -24885,7 +25147,7 @@ function LeadsProvider({ children }) {
     partialUpdateLead,
     deleteLead
   };
-  return /* @__PURE__ */ (0, import_jsx_runtime3.jsx)(import_swr40.SWRConfig, { value: swrConfig, children: /* @__PURE__ */ (0, import_jsx_runtime3.jsx)(LeadsContext.Provider, { value, children }) });
+  return /* @__PURE__ */ (0, import_jsx_runtime3.jsx)(import_swr41.SWRConfig, { value: swrConfig, children: /* @__PURE__ */ (0, import_jsx_runtime3.jsx)(LeadsContext.Provider, { value, children }) });
 }
 function useLeadsContext() {
   const context = (0, import_react3.useContext)(LeadsContext);
@@ -25164,7 +25426,7 @@ function useApiKeysContext() {
 
 // src/cfg/contexts/payments/OverviewContext.tsx
 var import_react9 = require("react");
-var import_swr41 = require("swr");
+var import_swr42 = require("swr");
 var import_jsx_runtime9 = require("react/jsx-runtime");
 var OverviewContext = (0, import_react9.createContext)(void 0);
 function OverviewProvider({ children }) {
@@ -25233,7 +25495,7 @@ function OverviewProvider({ children }) {
     overviewError,
     refreshOverview
   };
-  return /* @__PURE__ */ (0, import_jsx_runtime9.jsx)(import_swr41.SWRConfig, { value: swrConfig, children: /* @__PURE__ */ (0, import_jsx_runtime9.jsx)(OverviewContext.Provider, { value, children }) });
+  return /* @__PURE__ */ (0, import_jsx_runtime9.jsx)(import_swr42.SWRConfig, { value: swrConfig, children: /* @__PURE__ */ (0, import_jsx_runtime9.jsx)(OverviewContext.Provider, { value, children }) });
 }
 function useOverviewContext() {
   const context = (0, import_react9.useContext)(OverviewContext);
@@ -25557,7 +25819,7 @@ function useKnowbaseSessionsContext() {
 
 // src/cfg/contexts/TasksContext.tsx
 var import_react14 = require("react");
-var import_swr42 = require("swr");
+var import_swr43 = require("swr");
 var import_jsx_runtime14 = require("react/jsx-runtime");
 var TasksContext = (0, import_react14.createContext)(void 0);
 function TasksProvider({
@@ -25565,7 +25827,7 @@ function TasksProvider({
   autoRefresh = false,
   refreshInterval = 5e3
 }) {
-  const { mutate } = (0, import_swr42.useSWRConfig)();
+  const { mutate } = (0, import_swr43.useSWRConfig)();
   const {
     data: stats,
     error: statsError,
@@ -25765,6 +26027,7 @@ function useTasks() {
   createCentrifugoTestingPublishTestCreate,
   createCentrifugoTestingPublishWithLoggingCreate,
   createCentrifugoTestingSendAckCreate,
+  createDashboardApiCommandsExecuteCreate,
   createKnowbaseAdminChatCreate,
   createKnowbaseAdminChatQueryCreate,
   createKnowbaseAdminDocumentsCreate,
@@ -25824,6 +26087,7 @@ function useTasks() {
   getDashboardApiChartsRecentUsersList,
   getDashboardApiChartsRegistrationsRetrieve,
   getDashboardApiChartsTrackerList,
+  getDashboardApiCommandsHelpRetrieve,
   getDashboardApiCommandsList,
   getDashboardApiCommandsSummaryRetrieve,
   getDashboardApiOverviewOverviewRetrieve,