@djangocfg/api 1.1.0 → 1.2.0

package/dist/index.cjs

@@ -181,11 +181,11 @@ __export(index_exports, {
   getNewsletterNewslettersRetrieve: () => getNewsletterNewslettersRetrieve,
   getNewsletterSubscriptionsList: () => getNewsletterSubscriptionsList,
   getPaymentsBalanceRetrieve: () => getPaymentsBalanceRetrieve,
-  getPaymentsCurrenciesRetrieve: () => getPaymentsCurrenciesRetrieve,
+  getPaymentsCurrenciesList: () => getPaymentsCurrenciesList,
   getPaymentsPaymentsList: () => getPaymentsPaymentsList,
   getPaymentsPaymentsRetrieve: () => getPaymentsPaymentsRetrieve,
   getPaymentsPaymentsStatusRetrieve: () => getPaymentsPaymentsStatusRetrieve,
-  getPaymentsTransactionsRetrieve: () => getPaymentsTransactionsRetrieve,
+  getPaymentsTransactionsList: () => getPaymentsTransactionsList,
   getSupportTicketsList: () => getSupportTicketsList,
   getSupportTicketsMessagesList: () => getSupportTicketsMessagesList,
   getSupportTicketsMessagesRetrieve: () => getSupportTicketsMessagesRetrieve,
@@ -1287,17 +1287,20 @@ var CfgPayments = class {
     this.client = client;
   }
   /**
-   * Get current user balance.
+   * Get user balance
+   * 
+   * Get current user balance and transaction statistics
    */
   async balanceRetrieve() {
     const response = await this.client.request("GET", "/cfg/payments/balance/");
     return response;
   }
   /**
-   * GET /api/v1/payments/currencies/ Returns list of available currencies
-   * with token+network info.
+   * Get available currencies
+   * 
+   * Returns list of available currencies with token+network info
    */
-  async currenciesRetrieve() {
+  async currenciesList() {
     const response = await this.client.request("GET", "/cfg/payments/currencies/");
     return response;
   }
@@ -1356,10 +1359,19 @@ var CfgPayments = class {
     return response;
   }
   /**
-   * Get user transactions with pagination.
+   * Get user transactions
+   * 
+   * Get user transactions with pagination and filtering
    */
-  async transactionsRetrieve() {
-    const response = await this.client.request("GET", "/cfg/payments/transactions/");
+  async transactionsList(...args) {
+    const isParamsObject = args.length === 1 && typeof args[0] === "object" && args[0] !== null && !Array.isArray(args[0]);
+    let params;
+    if (isParamsObject) {
+      params = args[0];
+    } else {
+      params = { limit: args[0], offset: args[1], type: args[2] };
+    }
+    const response = await this.client.request("GET", "/cfg/payments/transactions/", { params });
     return response;
   }
 };
@@ -2801,6 +2813,51 @@ var OPENAPI_SCHEMA = {
         ],
         "type": "object"
       },
+      "Balance": {
+        "description": "User balance serializer.",
+        "properties": {
+          "balance_display": {
+            "readOnly": true,
+            "type": "string"
+          },
+          "balance_usd": {
+            "description": "Current balance in USD",
+            "format": "decimal",
+            "pattern": "^-?\\d{0,8}(?:\\.\\d{0,2})?$",
+            "readOnly": true,
+            "type": "string"
+          },
+          "last_transaction_at": {
+            "description": "When the last transaction occurred",
+            "format": "date-time",
+            "nullable": true,
+            "readOnly": true,
+            "type": "string"
+          },
+          "total_deposited": {
+            "description": "Total amount deposited (lifetime)",
+            "format": "decimal",
+            "pattern": "^-?\\d{0,8}(?:\\.\\d{0,2})?$",
+            "readOnly": true,
+            "type": "string"
+          },
+          "total_withdrawn": {
+            "description": "Total amount withdrawn (lifetime)",
+            "format": "decimal",
+            "pattern": "^-?\\d{0,8}(?:\\.\\d{0,2})?$",
+            "readOnly": true,
+            "type": "string"
+          }
+        },
+        "required": [
+          "balance_display",
+          "balance_usd",
+          "last_transaction_at",
+          "total_deposited",
+          "total_withdrawn"
+        ],
+        "type": "object"
+      },
       "BulkEmailRequest": {
         "description": "Simple serializer for bulk email.",
         "properties": {
@@ -3286,6 +3343,76 @@ var OPENAPI_SCHEMA = {
         ],
         "type": "object"
       },
+      "Currency": {
+        "description": "Currency list serializer.",
+        "properties": {
+          "code": {
+            "description": "Currency code from provider (e.g., USDTTRC20, BTC, ETH)",
+            "readOnly": true,
+            "type": "string"
+          },
+          "decimal_places": {
+            "description": "Number of decimal places for this currency",
+            "readOnly": true,
+            "type": "integer"
+          },
+          "display_name": {
+            "readOnly": true,
+            "type": "string"
+          },
+          "is_active": {
+            "description": "Whether this currency is available for payments",
+            "readOnly": true,
+            "type": "boolean"
+          },
+          "min_amount_usd": {
+            "description": "Minimum payment amount in USD",
+            "format": "decimal",
+            "pattern": "^-?\\d{0,8}(?:\\.\\d{0,2})?$",
+            "readOnly": true,
+            "type": "string"
+          },
+          "name": {
+            "description": "Full currency name (e.g., USDT (TRC20), Bitcoin)",
+            "readOnly": true,
+            "type": "string"
+          },
+          "network": {
+            "description": "Network name (e.g., TRC20, ERC20, Bitcoin)",
+            "nullable": true,
+            "readOnly": true,
+            "type": "string"
+          },
+          "sort_order": {
+            "description": "Sort order for currency list (lower = higher priority)",
+            "readOnly": true,
+            "type": "integer"
+          },
+          "symbol": {
+            "description": "Currency symbol (e.g., \u20AE, \u20BF, \u039E)",
+            "readOnly": true,
+            "type": "string"
+          },
+          "token": {
+            "description": "Token symbol (e.g., USDT, BTC, ETH)",
+            "readOnly": true,
+            "type": "string"
+          }
+        },
+        "required": [
+          "code",
+          "decimal_places",
+          "display_name",
+          "is_active",
+          "min_amount_usd",
+          "name",
+          "network",
+          "sort_order",
+          "symbol",
+          "token"
+        ],
+        "type": "object"
+      },
       "Document": {
         "description": "Document response serializer.",
         "properties": {
@@ -6457,6 +6584,8 @@ var OPENAPI_SCHEMA = {
             "type": "string"
           },
           "explorer_link": {
+            "description": "Get blockchain explorer link.",
+            "nullable": true,
             "readOnly": true,
             "type": "string"
           },
@@ -6505,6 +6634,8 @@ var OPENAPI_SCHEMA = {
             "type": "string"
           },
           "qr_code_url": {
+            "description": "Get QR code URL.",
+            "nullable": true,
             "readOnly": true,
             "type": "string"
           },
@@ -7167,6 +7298,83 @@ var OPENAPI_SCHEMA = {
         ],
         "type": "object"
       },
+      "Transaction": {
+        "description": "Transaction serializer.",
+        "properties": {
+          "amount_display": {
+            "readOnly": true,
+            "type": "string"
+          },
+          "amount_usd": {
+            "description": "Transaction amount in USD (positive=credit, negative=debit)",
+            "format": "decimal",
+            "pattern": "^-?\\d{0,8}(?:\\.\\d{0,2})?$",
+            "readOnly": true,
+            "type": "string"
+          },
+          "balance_after": {
+            "description": "User balance after this transaction",
+            "format": "decimal",
+            "pattern": "^-?\\d{0,8}(?:\\.\\d{0,2})?$",
+            "readOnly": true,
+            "type": "string"
+          },
+          "created_at": {
+            "description": "When this record was created",
+            "format": "date-time",
+            "readOnly": true,
+            "type": "string"
+          },
+          "description": {
+            "description": "Transaction description",
+            "readOnly": true,
+            "type": "string"
+          },
+          "id": {
+            "description": "Unique identifier for this record",
+            "format": "uuid",
+            "readOnly": true,
+            "type": "string"
+          },
+          "payment_id": {
+            "description": "Related payment ID (if applicable)",
+            "nullable": true,
+            "readOnly": true,
+            "type": "string"
+          },
+          "transaction_type": {
+            "description": "Type of transaction\n\n* `deposit` - Deposit\n* `withdrawal` - Withdrawal\n* `payment` - Payment\n* `refund` - Refund\n* `fee` - Fee\n* `bonus` - Bonus\n* `adjustment` - Adjustment",
+            "enum": [
+              "deposit",
+              "withdrawal",
+              "payment",
+              "refund",
+              "fee",
+              "bonus",
+              "adjustment"
+            ],
+            "readOnly": true,
+            "type": "string",
+            "x-spec-enum-id": "25d1662d4db37694"
+          },
+          "type_display": {
+            "readOnly": true,
+            "type": "string"
+          }
+        },
+        "required": [
+          "amount_display",
+          "amount_usd",
+          "balance_after",
+          "created_at",
+          "description",
+          "id",
+          "payment_id",
+          "transaction_type",
+          "type_display"
+        ],
+        "type": "object"
+      },
       "Unsubscribe": {
         "description": "Simple serializer for unsubscribe.",
         "properties": {
@@ -7494,8 +7702,8 @@ var OPENAPI_SCHEMA = {
     }
   },
   "info": {
-    "description": "Complete API documentation for Django CFG sample project",
-    "title": "Django CFG Sample API",
+    "description": "Complete API documentation for Django CFG Demo Project",
+    "title": "Django CFG API",
     "version": "1.0.0",
     "x-django-metadata": {
       "apps": [
@@ -8746,40 +8954,13 @@ var OPENAPI_SCHEMA = {
             "description": ""
           },
           "400": {
-            "content": {
-              "application/json": {
-                "schema": {
-                  "additionalProperties": {},
-                  "description": "Unspecified response body",
-                  "type": "object"
-                }
-              }
-            },
-            "description": ""
+            "description": "Validation errors"
           },
           "413": {
-            "content": {
-              "application/json": {
-                "schema": {
-                  "additionalProperties": {},
-                  "description": "Unspecified response body",
-                  "type": "object"
-                }
-              }
-            },
-            "description": ""
+            "description": "File too large"
           },
           "429": {
-            "content": {
-              "application/json": {
-                "schema": {
-                  "additionalProperties": {},
-                  "description": "Unspecified response body",
-                  "type": "object"
-                }
-              }
-            },
-            "description": ""
+            "description": "Rate limit exceeded"
           }
         },
         "security": [
@@ -8846,28 +9027,10 @@ var OPENAPI_SCHEMA = {
         ],
         "responses": {
           "204": {
-            "content": {
-              "application/json": {
-                "schema": {
-                  "additionalProperties": {},
-                  "description": "Unspecified response body",
-                  "type": "object"
-                }
-              }
-            },
-            "description": ""
+            "description": "Document deleted successfully"
           },
           "404": {
-            "content": {
-              "application/json": {
-                "schema": {
-                  "additionalProperties": {},
-                  "description": "Unspecified response body",
-                  "type": "object"
-                }
-              }
-            },
-            "description": ""
+            "description": "Document not found"
           }
         },
         "security": [
@@ -8911,16 +9074,7 @@ var OPENAPI_SCHEMA = {
             "description": ""
           },
           "404": {
-            "content": {
-              "application/json": {
-                "schema": {
-                  "additionalProperties": {},
-                  "description": "Unspecified response body",
-                  "type": "object"
-                }
-              }
-            },
-            "description": ""
+            "description": "Document not found"
           }
         },
         "security": [
@@ -9659,16 +9813,7 @@ var OPENAPI_SCHEMA = {
             "description": ""
           },
           "404": {
-            "content": {
-              "application/json": {
-                "schema": {
-                  "additionalProperties": {},
-                  "description": "Unspecified response body",
-                  "type": "object"
-                }
-              }
-            },
-            "description": ""
+            "description": "Category not found"
           }
         },
         "security": [
@@ -9783,16 +9928,7 @@ var OPENAPI_SCHEMA = {
             "description": ""
           },
           "404": {
-            "content": {
-              "application/json": {
-                "schema": {
-                  "additionalProperties": {},
-                  "description": "Unspecified response body",
-                  "type": "object"
-                }
-              }
-            },
-            "description": ""
+            "description": "Document not found"
           }
         },
         "security": [
@@ -9908,40 +10044,13 @@ var OPENAPI_SCHEMA = {
             "description": ""
           },
           "400": {
-            "content": {
-              "application/json": {
-                "schema": {
-                  "additionalProperties": {},
-                  "description": "Unspecified response body",
-                  "type": "object"
-                }
-              }
-            },
-            "description": ""
+            "description": "Validation errors"
           },
           "413": {
-            "content": {
-              "application/json": {
-                "schema": {
-                  "additionalProperties": {},
-                  "description": "Unspecified response body",
-                  "type": "object"
-                }
-              }
-            },
-            "description": ""
+            "description": "File too large"
           },
           "429": {
-            "content": {
-              "application/json": {
-                "schema": {
-                  "additionalProperties": {},
-                  "description": "Unspecified response body",
-                  "type": "object"
-                }
-              }
-            },
-            "description": ""
+            "description": "Rate limit exceeded"
           }
         },
         "security": [
@@ -12509,11 +12618,18 @@ var OPENAPI_SCHEMA = {
     },
     "/cfg/payments/balance/": {
       "get": {
-        "description": "Get current user balance.",
+        "description": "Get current user balance and transaction statistics",
         "operationId": "cfg_payments_balance_retrieve",
         "responses": {
           "200": {
-            "description": "No response body"
+            "content": {
+              "application/json": {
+                "schema": {
+                  "$ref": "#/components/schemas/Balance"
+                }
+              }
+            },
+            "description": ""
           }
         },
         "security": [
@@ -12524,6 +12640,7 @@ var OPENAPI_SCHEMA = {
             "cookieAuth": []
           }
         ],
+        "summary": "Get user balance",
         "tags": [
           "payments"
         ],
@@ -12532,11 +12649,21 @@ var OPENAPI_SCHEMA = {
     },
     "/cfg/payments/currencies/": {
       "get": {
-        "description": "GET /api/v1/payments/currencies/\n\nReturns list of available currencies with token+network info.",
-        "operationId": "cfg_payments_currencies_retrieve",
+        "description": "Returns list of available currencies with token+network info",
+        "operationId": "cfg_payments_currencies_list",
         "responses": {
           "200": {
-            "description": "No response body"
+            "content": {
+              "application/json": {
+                "schema": {
+                  "items": {
+                    "$ref": "#/components/schemas/Currency"
+                  },
+                  "type": "array"
+                }
+              }
+            },
+            "description": ""
           }
         },
         "security": [
@@ -12547,6 +12674,7 @@ var OPENAPI_SCHEMA = {
             "cookieAuth": []
           }
         ],
+        "summary": "Get available currencies",
         "tags": [
           "payments"
         ],
@@ -12755,23 +12883,60 @@ var OPENAPI_SCHEMA = {
     },
     "/cfg/payments/transactions/": {
       "get": {
-        "description": "Get user transactions with pagination.",
-        "operationId": "cfg_payments_transactions_retrieve",
-        "responses": {
-          "200": {
-            "description": "No response body"
-          }
-        },
-        "security": [
+        "description": "Get user transactions with pagination and filtering",
+        "operationId": "cfg_payments_transactions_list",
+        "parameters": [
           {
-            "jwtAuth": []
+            "description": "Number of transactions to return (max 100)",
+            "in": "query",
+            "name": "limit",
+            "schema": {
+              "type": "integer"
+            }
           },
           {
-            "cookieAuth": []
-          }
-        ],
-        "tags": [
-          "payments"
+            "description": "Offset for pagination",
+            "in": "query",
+            "name": "offset",
+            "schema": {
+              "type": "integer"
+            }
+          },
+          {
+            "description": "Filter by transaction type (deposit/withdrawal)",
+            "in": "query",
+            "name": "type",
+            "schema": {
+              "type": "string"
+            }
+          }
+        ],
+        "responses": {
+          "200": {
+            "content": {
+              "application/json": {
+                "schema": {
+                  "items": {
+                    "$ref": "#/components/schemas/Transaction"
+                  },
+                  "type": "array"
+                }
+              }
+            },
+            "description": ""
+          }
+        },
+        "security": [
+          {
+            "jwtAuth": []
+          },
+          {
+            "cookieAuth": []
+          }
+        ],
+        "summary": "Get user transactions",
+        "tags": [
+          "payments"
         ],
         "x-async-capable": false
       }
@@ -13988,6 +14153,7 @@ __export(enums_exports, {
   QueueActionRequestAction: () => QueueActionRequestAction,
   TicketRequestStatus: () => TicketRequestStatus,
   TicketStatus: () => TicketStatus,
+  TransactionTransactionType: () => TransactionTransactionType,
   WorkerActionAction: () => WorkerActionAction,
   WorkerActionRequestAction: () => WorkerActionRequestAction
 });
@@ -14223,6 +14389,16 @@ var TicketRequestStatus = /* @__PURE__ */ ((TicketRequestStatus2) => {
   TicketRequestStatus2["CLOSED"] = "closed";
   return TicketRequestStatus2;
 })(TicketRequestStatus || {});
+var TransactionTransactionType = /* @__PURE__ */ ((TransactionTransactionType2) => {
+  TransactionTransactionType2["DEPOSIT"] = "deposit";
+  TransactionTransactionType2["WITHDRAWAL"] = "withdrawal";
+  TransactionTransactionType2["PAYMENT"] = "payment";
+  TransactionTransactionType2["REFUND"] = "refund";
+  TransactionTransactionType2["FEE"] = "fee";
+  TransactionTransactionType2["BONUS"] = "bonus";
+  TransactionTransactionType2["ADJUSTMENT"] = "adjustment";
+  return TransactionTransactionType2;
+})(TransactionTransactionType || {});
 var WorkerActionAction = /* @__PURE__ */ ((WorkerActionAction2) => {
   WorkerActionAction2["START"] = "start";
   WorkerActionAction2["STOP"] = "stop";
@@ -14251,6 +14427,7 @@ __export(schemas_exports, {
   ArchiveSearchRequestRequestSchema: () => ArchiveSearchRequestRequestSchema,
   ArchiveSearchResultSchema: () => ArchiveSearchResultSchema,
   ArchiveStatisticsSchema: () => ArchiveStatisticsSchema,
+  BalanceSchema: () => BalanceSchema,
   BulkEmailRequestSchema: () => BulkEmailRequestSchema,
   BulkEmailResponseSchema: () => BulkEmailResponseSchema,
   ChatHistorySchema: () => ChatHistorySchema,
@@ -14264,6 +14441,7 @@ __export(schemas_exports, {
   ChatSourceRequestSchema: () => ChatSourceRequestSchema,
   ChatSourceSchema: () => ChatSourceSchema,
   ChunkRevectorizationRequestRequestSchema: () => ChunkRevectorizationRequestRequestSchema,
+  CurrencySchema: () => CurrencySchema,
   DocumentArchiveDetailSchema: () => DocumentArchiveDetailSchema,
   DocumentArchiveListSchema: () => DocumentArchiveListSchema,
   DocumentArchiveRequestSchema: () => DocumentArchiveRequestSchema,
@@ -14347,6 +14525,7 @@ __export(schemas_exports, {
   TicketSchema: () => TicketSchema,
   TokenRefreshRequestSchema: () => TokenRefreshRequestSchema,
   TokenRefreshSchema: () => TokenRefreshSchema,
+  TransactionSchema: () => TransactionSchema,
   UnsubscribeRequestSchema: () => UnsubscribeRequestSchema,
   UnsubscribeSchema: () => UnsubscribeSchema,
   UserProfileUpdateRequestSchema: () => UserProfileUpdateRequestSchema,
@@ -14513,627 +14692,624 @@ var ArchiveStatisticsSchema = import_zod12.z.object({
   avg_chunks_per_archive: import_zod12.z.number()
 });
 
-// src/cfg/generated/_utils/schemas/BulkEmailRequest.schema.ts
+// src/cfg/generated/_utils/schemas/Balance.schema.ts
 var import_zod13 = require("zod");
-var BulkEmailRequestSchema = import_zod13.z.object({
-  recipients: import_zod13.z.array(import_zod13.z.email()),
-  subject: import_zod13.z.string().min(1).max(255),
-  email_title: import_zod13.z.string().min(1).max(255),
-  main_text: import_zod13.z.string().min(1),
-  main_html_content: import_zod13.z.string().optional(),
-  button_text: import_zod13.z.string().max(100).optional(),
-  button_url: import_zod13.z.url().optional(),
-  secondary_text: import_zod13.z.string().optional()
+var BalanceSchema = import_zod13.z.object({
+  balance_usd: import_zod13.z.string(),
+  balance_display: import_zod13.z.string(),
+  total_deposited: import_zod13.z.string(),
+  total_withdrawn: import_zod13.z.string(),
+  last_transaction_at: import_zod13.z.iso.datetime().nullable()
 });
 
-// src/cfg/generated/_utils/schemas/BulkEmailResponse.schema.ts
+// src/cfg/generated/_utils/schemas/BulkEmailRequest.schema.ts
 var import_zod14 = require("zod");
-var BulkEmailResponseSchema = import_zod14.z.object({
-  success: import_zod14.z.boolean(),
-  sent_count: import_zod14.z.int(),
-  failed_count: import_zod14.z.int(),
-  total_recipients: import_zod14.z.int(),
-  error: import_zod14.z.string().optional()
+var BulkEmailRequestSchema = import_zod14.z.object({
+  recipients: import_zod14.z.array(import_zod14.z.email()),
+  subject: import_zod14.z.string().min(1).max(255),
+  email_title: import_zod14.z.string().min(1).max(255),
+  main_text: import_zod14.z.string().min(1),
+  main_html_content: import_zod14.z.string().optional(),
+  button_text: import_zod14.z.string().max(100).optional(),
+  button_url: import_zod14.z.url().optional(),
+  secondary_text: import_zod14.z.string().optional()
+});
+
+// src/cfg/generated/_utils/schemas/BulkEmailResponse.schema.ts
+var import_zod15 = require("zod");
+var BulkEmailResponseSchema = import_zod15.z.object({
+  success: import_zod15.z.boolean(),
+  sent_count: import_zod15.z.int(),
+  failed_count: import_zod15.z.int(),
+  total_recipients: import_zod15.z.int(),
+  error: import_zod15.z.string().optional()
 });
 
 // src/cfg/generated/_utils/schemas/ChatHistory.schema.ts
-var import_zod16 = require("zod");
+var import_zod17 = require("zod");
 
 // src/cfg/generated/_utils/schemas/ChatMessage.schema.ts
-var import_zod15 = require("zod");
-var ChatMessageSchema = import_zod15.z.object({
-  id: import_zod15.z.uuid(),
-  role: import_zod15.z.nativeEnum(ChatMessageRole),
-  content: import_zod15.z.string(),
-  tokens_used: import_zod15.z.int().min(0).max(2147483647).optional(),
-  cost_usd: import_zod15.z.number(),
-  processing_time_ms: import_zod15.z.int().min(0).max(2147483647).optional(),
-  created_at: import_zod15.z.iso.datetime(),
-  context_chunks: import_zod15.z.string().optional()
+var import_zod16 = require("zod");
+var ChatMessageSchema = import_zod16.z.object({
+  id: import_zod16.z.uuid(),
+  role: import_zod16.z.nativeEnum(ChatMessageRole),
+  content: import_zod16.z.string(),
+  tokens_used: import_zod16.z.int().min(0).max(2147483647).optional(),
+  cost_usd: import_zod16.z.number(),
+  processing_time_ms: import_zod16.z.int().min(0).max(2147483647).optional(),
+  created_at: import_zod16.z.iso.datetime(),
+  context_chunks: import_zod16.z.string().optional()
 });
 
 // src/cfg/generated/_utils/schemas/ChatHistory.schema.ts
-var ChatHistorySchema = import_zod16.z.object({
-  session_id: import_zod16.z.uuid(),
-  messages: import_zod16.z.array(ChatMessageSchema),
-  total_messages: import_zod16.z.int()
+var ChatHistorySchema = import_zod17.z.object({
+  session_id: import_zod17.z.uuid(),
+  messages: import_zod17.z.array(ChatMessageSchema),
+  total_messages: import_zod17.z.int()
 });
 
 // src/cfg/generated/_utils/schemas/ChatQueryRequest.schema.ts
-var import_zod17 = require("zod");
-var ChatQueryRequestSchema = import_zod17.z.object({
-  session_id: import_zod17.z.uuid().nullable().optional(),
-  query: import_zod17.z.string().min(1).max(2e3),
-  max_tokens: import_zod17.z.int().min(1).max(4e3).optional(),
-  include_sources: import_zod17.z.boolean().optional()
+var import_zod18 = require("zod");
+var ChatQueryRequestSchema = import_zod18.z.object({
+  session_id: import_zod18.z.uuid().nullable().optional(),
+  query: import_zod18.z.string().min(1).max(2e3),
+  max_tokens: import_zod18.z.int().min(1).max(4e3).optional(),
+  include_sources: import_zod18.z.boolean().optional()
 });
 
 // src/cfg/generated/_utils/schemas/ChatResponse.schema.ts
-var import_zod19 = require("zod");
+var import_zod20 = require("zod");
 
 // src/cfg/generated/_utils/schemas/ChatSource.schema.ts
-var import_zod18 = require("zod");
-var ChatSourceSchema = import_zod18.z.object({
-  document_title: import_zod18.z.string(),
-  chunk_content: import_zod18.z.string(),
-  similarity: import_zod18.z.number()
+var import_zod19 = require("zod");
+var ChatSourceSchema = import_zod19.z.object({
+  document_title: import_zod19.z.string(),
+  chunk_content: import_zod19.z.string(),
+  similarity: import_zod19.z.number()
 });
 
 // src/cfg/generated/_utils/schemas/ChatResponse.schema.ts
-var ChatResponseSchema = import_zod19.z.object({
-  message_id: import_zod19.z.uuid(),
-  content: import_zod19.z.string(),
-  tokens_used: import_zod19.z.int(),
-  cost_usd: import_zod19.z.number(),
-  processing_time_ms: import_zod19.z.int(),
-  model_used: import_zod19.z.string(),
-  sources: import_zod19.z.array(ChatSourceSchema).nullable().optional()
+var ChatResponseSchema = import_zod20.z.object({
+  message_id: import_zod20.z.uuid(),
+  content: import_zod20.z.string(),
+  tokens_used: import_zod20.z.int(),
+  cost_usd: import_zod20.z.number(),
+  processing_time_ms: import_zod20.z.int(),
+  model_used: import_zod20.z.string(),
+  sources: import_zod20.z.array(ChatSourceSchema).nullable().optional()
 });
 
 // src/cfg/generated/_utils/schemas/ChatResponseRequest.schema.ts
-var import_zod21 = require("zod");
+var import_zod22 = require("zod");
 
 // src/cfg/generated/_utils/schemas/ChatSourceRequest.schema.ts
-var import_zod20 = require("zod");
-var ChatSourceRequestSchema = import_zod20.z.object({
-  document_title: import_zod20.z.string().min(1),
-  chunk_content: import_zod20.z.string().min(1),
-  similarity: import_zod20.z.number()
+var import_zod21 = require("zod");
+var ChatSourceRequestSchema = import_zod21.z.object({
+  document_title: import_zod21.z.string().min(1),
+  chunk_content: import_zod21.z.string().min(1),
+  similarity: import_zod21.z.number()
 });
 
 // src/cfg/generated/_utils/schemas/ChatResponseRequest.schema.ts
-var ChatResponseRequestSchema = import_zod21.z.object({
-  message_id: import_zod21.z.uuid(),
-  content: import_zod21.z.string().min(1),
-  tokens_used: import_zod21.z.int(),
-  cost_usd: import_zod21.z.number(),
-  processing_time_ms: import_zod21.z.int(),
-  model_used: import_zod21.z.string().min(1),
-  sources: import_zod21.z.array(ChatSourceRequestSchema).nullable().optional()
+var ChatResponseRequestSchema = import_zod22.z.object({
+  message_id: import_zod22.z.uuid(),
+  content: import_zod22.z.string().min(1),
+  tokens_used: import_zod22.z.int(),
+  cost_usd: import_zod22.z.number(),
+  processing_time_ms: import_zod22.z.int(),
+  model_used: import_zod22.z.string().min(1),
+  sources: import_zod22.z.array(ChatSourceRequestSchema).nullable().optional()
 });
 
 // src/cfg/generated/_utils/schemas/ChatSession.schema.ts
-var import_zod22 = require("zod");
-var ChatSessionSchema = import_zod22.z.object({
-  id: import_zod22.z.uuid(),
-  title: import_zod22.z.string().max(255).optional(),
-  is_active: import_zod22.z.boolean().optional(),
-  messages_count: import_zod22.z.int().min(0).max(2147483647).optional(),
-  total_tokens_used: import_zod22.z.int().min(0).max(2147483647).optional(),
-  total_cost_usd: import_zod22.z.number(),
-  model_name: import_zod22.z.string().max(100).optional(),
-  temperature: import_zod22.z.number().optional(),
-  max_context_chunks: import_zod22.z.int().min(0).max(2147483647).optional(),
-  created_at: import_zod22.z.iso.datetime(),
-  updated_at: import_zod22.z.iso.datetime()
-});
-
-// src/cfg/generated/_utils/schemas/ChatSessionCreateRequest.schema.ts
 var import_zod23 = require("zod");
-var ChatSessionCreateRequestSchema = import_zod23.z.object({
+var ChatSessionSchema = import_zod23.z.object({
+  id: import_zod23.z.uuid(),
   title: import_zod23.z.string().max(255).optional(),
-  model_name: import_zod23.z.string().min(1).max(100).optional(),
-  temperature: import_zod23.z.number().min(0).max(2).optional(),
-  max_context_chunks: import_zod23.z.int().min(1).max(10).optional()
+  is_active: import_zod23.z.boolean().optional(),
+  messages_count: import_zod23.z.int().min(0).max(2147483647).optional(),
+  total_tokens_used: import_zod23.z.int().min(0).max(2147483647).optional(),
+  total_cost_usd: import_zod23.z.number(),
+  model_name: import_zod23.z.string().max(100).optional(),
+  temperature: import_zod23.z.number().optional(),
+  max_context_chunks: import_zod23.z.int().min(0).max(2147483647).optional(),
+  created_at: import_zod23.z.iso.datetime(),
+  updated_at: import_zod23.z.iso.datetime()
 });
 
-// src/cfg/generated/_utils/schemas/ChatSessionRequest.schema.ts
+// src/cfg/generated/_utils/schemas/ChatSessionCreateRequest.schema.ts
 var import_zod24 = require("zod");
-var ChatSessionRequestSchema = import_zod24.z.object({
+var ChatSessionCreateRequestSchema = import_zod24.z.object({
   title: import_zod24.z.string().max(255).optional(),
-  is_active: import_zod24.z.boolean().optional(),
-  messages_count: import_zod24.z.int().min(0).max(2147483647).optional(),
-  total_tokens_used: import_zod24.z.int().min(0).max(2147483647).optional(),
   model_name: import_zod24.z.string().min(1).max(100).optional(),
-  temperature: import_zod24.z.number().optional(),
-  max_context_chunks: import_zod24.z.int().min(0).max(2147483647).optional()
+  temperature: import_zod24.z.number().min(0).max(2).optional(),
+  max_context_chunks: import_zod24.z.int().min(1).max(10).optional()
 });
 
-// src/cfg/generated/_utils/schemas/ChunkRevectorizationRequestRequest.schema.ts
+// src/cfg/generated/_utils/schemas/ChatSessionRequest.schema.ts
 var import_zod25 = require("zod");
-var ChunkRevectorizationRequestRequestSchema = import_zod25.z.object({
-  chunk_ids: import_zod25.z.array(import_zod25.z.uuid()),
-  force: import_zod25.z.boolean().optional()
+var ChatSessionRequestSchema = import_zod25.z.object({
+  title: import_zod25.z.string().max(255).optional(),
+  is_active: import_zod25.z.boolean().optional(),
+  messages_count: import_zod25.z.int().min(0).max(2147483647).optional(),
+  total_tokens_used: import_zod25.z.int().min(0).max(2147483647).optional(),
+  model_name: import_zod25.z.string().min(1).max(100).optional(),
+  temperature: import_zod25.z.number().optional(),
+  max_context_chunks: import_zod25.z.int().min(0).max(2147483647).optional()
 });
 
-// src/cfg/generated/_utils/schemas/Document.schema.ts
+// src/cfg/generated/_utils/schemas/ChunkRevectorizationRequestRequest.schema.ts
 var import_zod26 = require("zod");
-var DocumentSchema = import_zod26.z.object({
-  id: import_zod26.z.uuid(),
-  title: import_zod26.z.string().max(512),
-  file_type: import_zod26.z.string().max(100).optional(),
-  file_size: import_zod26.z.int().min(0).max(2147483647).optional(),
-  processing_status: import_zod26.z.string(),
-  chunks_count: import_zod26.z.int(),
-  total_tokens: import_zod26.z.int(),
-  total_cost_usd: import_zod26.z.number(),
-  created_at: import_zod26.z.iso.datetime(),
-  updated_at: import_zod26.z.iso.datetime(),
-  processing_started_at: import_zod26.z.iso.datetime(),
-  processing_completed_at: import_zod26.z.iso.datetime(),
-  processing_error: import_zod26.z.string(),
-  metadata: import_zod26.z.string().nullable().optional()
+var ChunkRevectorizationRequestRequestSchema = import_zod26.z.object({
+  chunk_ids: import_zod26.z.array(import_zod26.z.uuid()),
+  force: import_zod26.z.boolean().optional()
 });
 
-// src/cfg/generated/_utils/schemas/DocumentArchive.schema.ts
-var import_zod28 = require("zod");
-
-// src/cfg/generated/_utils/schemas/DocumentCategory.schema.ts
+// src/cfg/generated/_utils/schemas/Currency.schema.ts
 var import_zod27 = require("zod");
-var DocumentCategorySchema = import_zod27.z.object({
-  id: import_zod27.z.uuid(),
-  name: import_zod27.z.string().max(255),
-  description: import_zod27.z.string().optional(),
-  is_public: import_zod27.z.boolean().optional(),
-  created_at: import_zod27.z.iso.datetime()
+var CurrencySchema = import_zod27.z.object({
+  code: import_zod27.z.string(),
+  name: import_zod27.z.string(),
+  token: import_zod27.z.string(),
+  network: import_zod27.z.string().nullable(),
+  display_name: import_zod27.z.string(),
+  symbol: import_zod27.z.string(),
+  decimal_places: import_zod27.z.int(),
+  is_active: import_zod27.z.boolean(),
+  min_amount_usd: import_zod27.z.string(),
+  sort_order: import_zod27.z.int()
 });
 
-// src/cfg/generated/_utils/schemas/DocumentArchive.schema.ts
-var DocumentArchiveSchema = import_zod28.z.object({
+// src/cfg/generated/_utils/schemas/Document.schema.ts
+var import_zod28 = require("zod");
+var DocumentSchema = import_zod28.z.object({
   id: import_zod28.z.uuid(),
   title: import_zod28.z.string().max(512),
-  description: import_zod28.z.string().optional(),
-  categories: import_zod28.z.array(DocumentCategorySchema),
-  is_public: import_zod28.z.boolean().optional(),
-  archive_file: import_zod28.z.url(),
-  original_filename: import_zod28.z.string(),
-  file_size: import_zod28.z.int(),
-  archive_type: import_zod28.z.nativeEnum(DocumentArchiveArchiveType),
-  processing_status: import_zod28.z.nativeEnum(DocumentArchiveProcessingStatus),
-  processed_at: import_zod28.z.iso.datetime().nullable(),
-  processing_duration_ms: import_zod28.z.int(),
-  processing_error: import_zod28.z.string(),
-  total_items: import_zod28.z.int(),
-  processed_items: import_zod28.z.int(),
-  total_chunks: import_zod28.z.int(),
-  vectorized_chunks: import_zod28.z.int(),
+  file_type: import_zod28.z.string().max(100).optional(),
+  file_size: import_zod28.z.int().min(0).max(2147483647).optional(),
+  processing_status: import_zod28.z.string(),
+  chunks_count: import_zod28.z.int(),
   total_tokens: import_zod28.z.int(),
   total_cost_usd: import_zod28.z.number(),
-  processing_progress: import_zod28.z.number(),
-  vectorization_progress: import_zod28.z.number(),
-  is_processed: import_zod28.z.boolean(),
   created_at: import_zod28.z.iso.datetime(),
-  updated_at: import_zod28.z.iso.datetime()
+  updated_at: import_zod28.z.iso.datetime(),
+  processing_started_at: import_zod28.z.iso.datetime(),
+  processing_completed_at: import_zod28.z.iso.datetime(),
+  processing_error: import_zod28.z.string(),
+  metadata: import_zod28.z.string().nullable().optional()
 });
 
-// src/cfg/generated/_utils/schemas/DocumentArchiveDetail.schema.ts
+// src/cfg/generated/_utils/schemas/DocumentArchive.schema.ts
+var import_zod30 = require("zod");
+
+// src/cfg/generated/_utils/schemas/DocumentCategory.schema.ts
 var import_zod29 = require("zod");
-var DocumentArchiveDetailSchema = import_zod29.z.object({
+var DocumentCategorySchema = import_zod29.z.object({
   id: import_zod29.z.uuid(),
-  title: import_zod29.z.string().max(512),
+  name: import_zod29.z.string().max(255),
   description: import_zod29.z.string().optional(),
-  categories: import_zod29.z.array(DocumentCategorySchema),
   is_public: import_zod29.z.boolean().optional(),
-  archive_file: import_zod29.z.url(),
-  original_filename: import_zod29.z.string(),
-  file_size: import_zod29.z.int(),
-  archive_type: import_zod29.z.nativeEnum(DocumentArchiveDetailArchiveType),
-  processing_status: import_zod29.z.nativeEnum(DocumentArchiveDetailProcessingStatus),
-  processed_at: import_zod29.z.iso.datetime().nullable(),
-  processing_duration_ms: import_zod29.z.int(),
-  processing_error: import_zod29.z.string(),
-  total_items: import_zod29.z.int(),
-  processed_items: import_zod29.z.int(),
-  total_chunks: import_zod29.z.int(),
-  vectorized_chunks: import_zod29.z.int(),
-  total_tokens: import_zod29.z.int(),
-  total_cost_usd: import_zod29.z.number(),
-  processing_progress: import_zod29.z.number(),
-  vectorization_progress: import_zod29.z.number(),
-  is_processed: import_zod29.z.boolean(),
-  created_at: import_zod29.z.iso.datetime(),
-  updated_at: import_zod29.z.iso.datetime(),
-  items: import_zod29.z.array(ArchiveItemSchema),
-  file_tree: import_zod29.z.record(import_zod29.z.string(), import_zod29.z.any()),
-  metadata: import_zod29.z.string().nullable().optional()
+  created_at: import_zod29.z.iso.datetime()
 });
 
-// src/cfg/generated/_utils/schemas/DocumentArchiveList.schema.ts
-var import_zod30 = require("zod");
-var DocumentArchiveListSchema = import_zod30.z.object({
+// src/cfg/generated/_utils/schemas/DocumentArchive.schema.ts
+var DocumentArchiveSchema = import_zod30.z.object({
   id: import_zod30.z.uuid(),
-  title: import_zod30.z.string(),
-  description: import_zod30.z.string(),
+  title: import_zod30.z.string().max(512),
+  description: import_zod30.z.string().optional(),
   categories: import_zod30.z.array(DocumentCategorySchema),
-  is_public: import_zod30.z.boolean(),
+  is_public: import_zod30.z.boolean().optional(),
+  archive_file: import_zod30.z.url(),
   original_filename: import_zod30.z.string(),
   file_size: import_zod30.z.int(),
-  archive_type: import_zod30.z.nativeEnum(DocumentArchiveListArchiveType),
-  processing_status: import_zod30.z.nativeEnum(DocumentArchiveListProcessingStatus),
+  archive_type: import_zod30.z.nativeEnum(DocumentArchiveArchiveType),
+  processing_status: import_zod30.z.nativeEnum(DocumentArchiveProcessingStatus),
   processed_at: import_zod30.z.iso.datetime().nullable(),
+  processing_duration_ms: import_zod30.z.int(),
+  processing_error: import_zod30.z.string(),
   total_items: import_zod30.z.int(),
+  processed_items: import_zod30.z.int(),
   total_chunks: import_zod30.z.int(),
+  vectorized_chunks: import_zod30.z.int(),
+  total_tokens: import_zod30.z.int(),
   total_cost_usd: import_zod30.z.number(),
   processing_progress: import_zod30.z.number(),
-  created_at: import_zod30.z.iso.datetime()
+  vectorization_progress: import_zod30.z.number(),
+  is_processed: import_zod30.z.boolean(),
+  created_at: import_zod30.z.iso.datetime(),
+  updated_at: import_zod30.z.iso.datetime()
 });
 
-// src/cfg/generated/_utils/schemas/DocumentArchiveRequest.schema.ts
+// src/cfg/generated/_utils/schemas/DocumentArchiveDetail.schema.ts
 var import_zod31 = require("zod");
-var DocumentArchiveRequestSchema = import_zod31.z.object({
-  title: import_zod31.z.string().min(1).max(512),
+var DocumentArchiveDetailSchema = import_zod31.z.object({
+  id: import_zod31.z.uuid(),
+  title: import_zod31.z.string().max(512),
   description: import_zod31.z.string().optional(),
-  is_public: import_zod31.z.boolean().optional()
+  categories: import_zod31.z.array(DocumentCategorySchema),
+  is_public: import_zod31.z.boolean().optional(),
+  archive_file: import_zod31.z.url(),
+  original_filename: import_zod31.z.string(),
+  file_size: import_zod31.z.int(),
+  archive_type: import_zod31.z.nativeEnum(DocumentArchiveDetailArchiveType),
+  processing_status: import_zod31.z.nativeEnum(DocumentArchiveDetailProcessingStatus),
+  processed_at: import_zod31.z.iso.datetime().nullable(),
+  processing_duration_ms: import_zod31.z.int(),
+  processing_error: import_zod31.z.string(),
+  total_items: import_zod31.z.int(),
+  processed_items: import_zod31.z.int(),
+  total_chunks: import_zod31.z.int(),
+  vectorized_chunks: import_zod31.z.int(),
+  total_tokens: import_zod31.z.int(),
+  total_cost_usd: import_zod31.z.number(),
+  processing_progress: import_zod31.z.number(),
+  vectorization_progress: import_zod31.z.number(),
+  is_processed: import_zod31.z.boolean(),
+  created_at: import_zod31.z.iso.datetime(),
+  updated_at: import_zod31.z.iso.datetime(),
+  items: import_zod31.z.array(ArchiveItemSchema),
+  file_tree: import_zod31.z.record(import_zod31.z.string(), import_zod31.z.any()),
+  metadata: import_zod31.z.string().nullable().optional()
 });
 
-// src/cfg/generated/_utils/schemas/DocumentCategoryRequest.schema.ts
+// src/cfg/generated/_utils/schemas/DocumentArchiveList.schema.ts
 var import_zod32 = require("zod");
-var DocumentCategoryRequestSchema = import_zod32.z.object({
-  name: import_zod32.z.string().min(1).max(255),
-  description: import_zod32.z.string().optional(),
-  is_public: import_zod32.z.boolean().optional()
+var DocumentArchiveListSchema = import_zod32.z.object({
+  id: import_zod32.z.uuid(),
+  title: import_zod32.z.string(),
+  description: import_zod32.z.string(),
+  categories: import_zod32.z.array(DocumentCategorySchema),
+  is_public: import_zod32.z.boolean(),
+  original_filename: import_zod32.z.string(),
+  file_size: import_zod32.z.int(),
+  archive_type: import_zod32.z.nativeEnum(DocumentArchiveListArchiveType),
+  processing_status: import_zod32.z.nativeEnum(DocumentArchiveListProcessingStatus),
+  processed_at: import_zod32.z.iso.datetime().nullable(),
+  total_items: import_zod32.z.int(),
+  total_chunks: import_zod32.z.int(),
+  total_cost_usd: import_zod32.z.number(),
+  processing_progress: import_zod32.z.number(),
+  created_at: import_zod32.z.iso.datetime()
 });
 
-// src/cfg/generated/_utils/schemas/DocumentCreateRequest.schema.ts
+// src/cfg/generated/_utils/schemas/DocumentArchiveRequest.schema.ts
 var import_zod33 = require("zod");
-var DocumentCreateRequestSchema = import_zod33.z.object({
+var DocumentArchiveRequestSchema = import_zod33.z.object({
   title: import_zod33.z.string().min(1).max(512),
-  content: import_zod33.z.string().min(10).max(1e6),
-  file_type: import_zod33.z.string().min(1).optional(),
-  metadata: import_zod33.z.string().optional()
+  description: import_zod33.z.string().optional(),
+  is_public: import_zod33.z.boolean().optional()
 });
 
-// src/cfg/generated/_utils/schemas/DocumentProcessingStatus.schema.ts
+// src/cfg/generated/_utils/schemas/DocumentCategoryRequest.schema.ts
 var import_zod34 = require("zod");
-var DocumentProcessingStatusSchema = import_zod34.z.object({
-  id: import_zod34.z.uuid(),
-  status: import_zod34.z.string(),
-  progress: import_zod34.z.string(),
-  error: import_zod34.z.string().nullable().optional(),
-  processing_time_seconds: import_zod34.z.number().nullable().optional()
+var DocumentCategoryRequestSchema = import_zod34.z.object({
+  name: import_zod34.z.string().min(1).max(255),
+  description: import_zod34.z.string().optional(),
+  is_public: import_zod34.z.boolean().optional()
 });
 
-// src/cfg/generated/_utils/schemas/DocumentRequest.schema.ts
+// src/cfg/generated/_utils/schemas/DocumentCreateRequest.schema.ts
 var import_zod35 = require("zod");
-var DocumentRequestSchema = import_zod35.z.object({
+var DocumentCreateRequestSchema = import_zod35.z.object({
   title: import_zod35.z.string().min(1).max(512),
-  file_type: import_zod35.z.string().min(1).max(100).optional(),
-  file_size: import_zod35.z.int().min(0).max(2147483647).optional(),
-  metadata: import_zod35.z.string().nullable().optional()
+  content: import_zod35.z.string().min(10).max(1e6),
+  file_type: import_zod35.z.string().min(1).optional(),
+  metadata: import_zod35.z.string().optional()
 });
 
-// src/cfg/generated/_utils/schemas/DocumentStats.schema.ts
+// src/cfg/generated/_utils/schemas/DocumentProcessingStatus.schema.ts
 var import_zod36 = require("zod");
-var DocumentStatsSchema = import_zod36.z.object({
-  total_documents: import_zod36.z.int(),
-  completed_documents: import_zod36.z.int(),
-  processing_success_rate: import_zod36.z.number(),
-  total_chunks: import_zod36.z.int(),
-  total_tokens: import_zod36.z.int(),
-  total_cost_usd: import_zod36.z.number(),
-  avg_processing_time_seconds: import_zod36.z.number()
+var DocumentProcessingStatusSchema = import_zod36.z.object({
+  id: import_zod36.z.uuid(),
+  status: import_zod36.z.string(),
+  progress: import_zod36.z.string(),
+  error: import_zod36.z.string().nullable().optional(),
+  processing_time_seconds: import_zod36.z.number().nullable().optional()
 });
 
-// src/cfg/generated/_utils/schemas/EmailLog.schema.ts
+// src/cfg/generated/_utils/schemas/DocumentRequest.schema.ts
 var import_zod37 = require("zod");
-var EmailLogSchema = import_zod37.z.object({
-  id: import_zod37.z.uuid(),
-  user: import_zod37.z.int().nullable(),
-  user_email: import_zod37.z.string(),
-  newsletter: import_zod37.z.int().nullable(),
-  newsletter_title: import_zod37.z.string(),
-  recipient: import_zod37.z.string(),
-  subject: import_zod37.z.string(),
-  body: import_zod37.z.string(),
-  status: import_zod37.z.nativeEnum(EmailLogStatus),
-  created_at: import_zod37.z.iso.datetime(),
-  sent_at: import_zod37.z.iso.datetime().nullable(),
-  error_message: import_zod37.z.string().nullable()
+var DocumentRequestSchema = import_zod37.z.object({
+  title: import_zod37.z.string().min(1).max(512),
+  file_type: import_zod37.z.string().min(1).max(100).optional(),
+  file_size: import_zod37.z.int().min(0).max(2147483647).optional(),
+  metadata: import_zod37.z.string().nullable().optional()
 });
 
-// src/cfg/generated/_utils/schemas/Endpoint.schema.ts
+// src/cfg/generated/_utils/schemas/DocumentStats.schema.ts
 var import_zod38 = require("zod");
-var EndpointSchema = import_zod38.z.object({
-  url: import_zod38.z.string(),
-  url_pattern: import_zod38.z.string().nullable().optional(),
-  url_name: import_zod38.z.string().nullable().optional(),
-  namespace: import_zod38.z.string().optional(),
-  group: import_zod38.z.string(),
-  view: import_zod38.z.string().optional(),
-  status: import_zod38.z.string(),
-  status_code: import_zod38.z.int().nullable().optional(),
-  response_time_ms: import_zod38.z.number().nullable().optional(),
-  is_healthy: import_zod38.z.boolean().nullable().optional(),
-  error: import_zod38.z.string().optional(),
-  error_type: import_zod38.z.string().optional(),
-  reason: import_zod38.z.string().optional(),
-  last_checked: import_zod38.z.iso.datetime().nullable().optional(),
-  has_parameters: import_zod38.z.boolean().optional(),
-  required_auth: import_zod38.z.boolean().optional(),
-  rate_limited: import_zod38.z.boolean().optional()
+var DocumentStatsSchema = import_zod38.z.object({
+  total_documents: import_zod38.z.int(),
+  completed_documents: import_zod38.z.int(),
+  processing_success_rate: import_zod38.z.number(),
+  total_chunks: import_zod38.z.int(),
+  total_tokens: import_zod38.z.int(),
+  total_cost_usd: import_zod38.z.number(),
+  avg_processing_time_seconds: import_zod38.z.number()
 });
 
-// src/cfg/generated/_utils/schemas/EndpointsStatus.schema.ts
+// src/cfg/generated/_utils/schemas/EmailLog.schema.ts
 var import_zod39 = require("zod");
-var EndpointsStatusSchema = import_zod39.z.object({
-  status: import_zod39.z.string(),
-  timestamp: import_zod39.z.iso.datetime(),
-  total_endpoints: import_zod39.z.int(),
-  healthy: import_zod39.z.int(),
-  unhealthy: import_zod39.z.int(),
-  warnings: import_zod39.z.int(),
-  errors: import_zod39.z.int(),
-  skipped: import_zod39.z.int(),
-  endpoints: import_zod39.z.array(EndpointSchema)
+var EmailLogSchema = import_zod39.z.object({
+  id: import_zod39.z.uuid(),
+  user: import_zod39.z.int().nullable(),
+  user_email: import_zod39.z.string(),
+  newsletter: import_zod39.z.int().nullable(),
+  newsletter_title: import_zod39.z.string(),
+  recipient: import_zod39.z.string(),
+  subject: import_zod39.z.string(),
+  body: import_zod39.z.string(),
+  status: import_zod39.z.nativeEnum(EmailLogStatus),
+  created_at: import_zod39.z.iso.datetime(),
+  sent_at: import_zod39.z.iso.datetime().nullable(),
+  error_message: import_zod39.z.string().nullable()
 });
 
-// src/cfg/generated/_utils/schemas/ErrorResponse.schema.ts
+// src/cfg/generated/_utils/schemas/Endpoint.schema.ts
 var import_zod40 = require("zod");
-var ErrorResponseSchema = import_zod40.z.object({
-  success: import_zod40.z.boolean().optional(),
-  message: import_zod40.z.string()
+var EndpointSchema = import_zod40.z.object({
+  url: import_zod40.z.string(),
+  url_pattern: import_zod40.z.string().nullable().optional(),
+  url_name: import_zod40.z.string().nullable().optional(),
+  namespace: import_zod40.z.string().optional(),
+  group: import_zod40.z.string(),
+  view: import_zod40.z.string().optional(),
+  status: import_zod40.z.string(),
+  status_code: import_zod40.z.int().nullable().optional(),
+  response_time_ms: import_zod40.z.number().nullable().optional(),
+  is_healthy: import_zod40.z.boolean().nullable().optional(),
+  error: import_zod40.z.string().optional(),
+  error_type: import_zod40.z.string().optional(),
+  reason: import_zod40.z.string().optional(),
+  last_checked: import_zod40.z.iso.datetime().nullable().optional(),
+  has_parameters: import_zod40.z.boolean().optional(),
+  required_auth: import_zod40.z.boolean().optional(),
+  rate_limited: import_zod40.z.boolean().optional()
 });
 
-// src/cfg/generated/_utils/schemas/HealthCheck.schema.ts
+// src/cfg/generated/_utils/schemas/EndpointsStatus.schema.ts
 var import_zod41 = require("zod");
-var HealthCheckSchema = import_zod41.z.object({
+var EndpointsStatusSchema = import_zod41.z.object({
   status: import_zod41.z.string(),
   timestamp: import_zod41.z.iso.datetime(),
-  service: import_zod41.z.string(),
-  version: import_zod41.z.string(),
-  checks: import_zod41.z.record(import_zod41.z.string(), import_zod41.z.any()),
-  environment: import_zod41.z.record(import_zod41.z.string(), import_zod41.z.any())
+  total_endpoints: import_zod41.z.int(),
+  healthy: import_zod41.z.int(),
+  unhealthy: import_zod41.z.int(),
+  warnings: import_zod41.z.int(),
+  errors: import_zod41.z.int(),
+  skipped: import_zod41.z.int(),
+  endpoints: import_zod41.z.array(EndpointSchema)
 });
 
-// src/cfg/generated/_utils/schemas/LeadSubmission.schema.ts
+// src/cfg/generated/_utils/schemas/ErrorResponse.schema.ts
 var import_zod42 = require("zod");
-var LeadSubmissionSchema = import_zod42.z.object({
-  name: import_zod42.z.string().max(200),
-  email: import_zod42.z.email(),
-  company: import_zod42.z.string().max(200).nullable().optional(),
-  company_site: import_zod42.z.string().max(200).nullable().optional(),
-  contact_type: import_zod42.z.nativeEnum(LeadSubmissionContactType).optional(),
-  contact_value: import_zod42.z.string().max(200).nullable().optional(),
-  subject: import_zod42.z.string().max(200).nullable().optional(),
-  message: import_zod42.z.string(),
-  extra: import_zod42.z.string().nullable().optional(),
-  site_url: import_zod42.z.url()
+var ErrorResponseSchema = import_zod42.z.object({
+  success: import_zod42.z.boolean().optional(),
+  message: import_zod42.z.string()
 });
 
-// src/cfg/generated/_utils/schemas/LeadSubmissionError.schema.ts
+// src/cfg/generated/_utils/schemas/HealthCheck.schema.ts
 var import_zod43 = require("zod");
-var LeadSubmissionErrorSchema = import_zod43.z.object({
-  success: import_zod43.z.boolean(),
-  error: import_zod43.z.string(),
-  details: import_zod43.z.record(import_zod43.z.string(), import_zod43.z.any()).optional()
+var HealthCheckSchema = import_zod43.z.object({
+  status: import_zod43.z.string(),
+  timestamp: import_zod43.z.iso.datetime(),
+  service: import_zod43.z.string(),
+  version: import_zod43.z.string(),
+  checks: import_zod43.z.record(import_zod43.z.string(), import_zod43.z.any()),
+  environment: import_zod43.z.record(import_zod43.z.string(), import_zod43.z.any())
 });
 
-// src/cfg/generated/_utils/schemas/LeadSubmissionRequest.schema.ts
+// src/cfg/generated/_utils/schemas/LeadSubmission.schema.ts
 var import_zod44 = require("zod");
-var LeadSubmissionRequestSchema = import_zod44.z.object({
-  name: import_zod44.z.string().min(1).max(200),
+var LeadSubmissionSchema = import_zod44.z.object({
+  name: import_zod44.z.string().max(200),
   email: import_zod44.z.email(),
   company: import_zod44.z.string().max(200).nullable().optional(),
   company_site: import_zod44.z.string().max(200).nullable().optional(),
-  contact_type: import_zod44.z.nativeEnum(LeadSubmissionRequestContactType).optional(),
+  contact_type: import_zod44.z.nativeEnum(LeadSubmissionContactType).optional(),
   contact_value: import_zod44.z.string().max(200).nullable().optional(),
   subject: import_zod44.z.string().max(200).nullable().optional(),
-  message: import_zod44.z.string().min(1),
+  message: import_zod44.z.string(),
   extra: import_zod44.z.string().nullable().optional(),
   site_url: import_zod44.z.url()
 });
 
-// src/cfg/generated/_utils/schemas/LeadSubmissionResponse.schema.ts
+// src/cfg/generated/_utils/schemas/LeadSubmissionError.schema.ts
 var import_zod45 = require("zod");
-var LeadSubmissionResponseSchema = import_zod45.z.object({
+var LeadSubmissionErrorSchema = import_zod45.z.object({
   success: import_zod45.z.boolean(),
-  message: import_zod45.z.string(),
-  lead_id: import_zod45.z.int()
+  error: import_zod45.z.string(),
+  details: import_zod45.z.record(import_zod45.z.string(), import_zod45.z.any()).optional()
 });
 
-// src/cfg/generated/_utils/schemas/Message.schema.ts
-var import_zod47 = require("zod");
-
-// src/cfg/generated/_utils/schemas/Sender.schema.ts
+// src/cfg/generated/_utils/schemas/LeadSubmissionRequest.schema.ts
 var import_zod46 = require("zod");
-var SenderSchema = import_zod46.z.object({
-  id: import_zod46.z.int(),
-  display_username: import_zod46.z.string(),
+var LeadSubmissionRequestSchema = import_zod46.z.object({
+  name: import_zod46.z.string().min(1).max(200),
   email: import_zod46.z.email(),
-  avatar: import_zod46.z.string().nullable(),
-  initials: import_zod46.z.string(),
-  is_staff: import_zod46.z.boolean(),
-  is_superuser: import_zod46.z.boolean()
+  company: import_zod46.z.string().max(200).nullable().optional(),
+  company_site: import_zod46.z.string().max(200).nullable().optional(),
+  contact_type: import_zod46.z.nativeEnum(LeadSubmissionRequestContactType).optional(),
+  contact_value: import_zod46.z.string().max(200).nullable().optional(),
+  subject: import_zod46.z.string().max(200).nullable().optional(),
+  message: import_zod46.z.string().min(1),
+  extra: import_zod46.z.string().nullable().optional(),
+  site_url: import_zod46.z.url()
 });
 
-// src/cfg/generated/_utils/schemas/Message.schema.ts
-var MessageSchema = import_zod47.z.object({
-  uuid: import_zod47.z.uuid(),
-  ticket: import_zod47.z.uuid(),
-  sender: SenderSchema,
-  is_from_author: import_zod47.z.boolean(),
-  text: import_zod47.z.string(),
-  created_at: import_zod47.z.iso.datetime()
+// src/cfg/generated/_utils/schemas/LeadSubmissionResponse.schema.ts
+var import_zod47 = require("zod");
+var LeadSubmissionResponseSchema = import_zod47.z.object({
+  success: import_zod47.z.boolean(),
+  message: import_zod47.z.string(),
+  lead_id: import_zod47.z.int()
 });
 
-// src/cfg/generated/_utils/schemas/MessageCreate.schema.ts
+// src/cfg/generated/_utils/schemas/Message.schema.ts
+var import_zod49 = require("zod");
+
+// src/cfg/generated/_utils/schemas/Sender.schema.ts
 var import_zod48 = require("zod");
-var MessageCreateSchema = import_zod48.z.object({
-  text: import_zod48.z.string()
+var SenderSchema = import_zod48.z.object({
+  id: import_zod48.z.int(),
+  display_username: import_zod48.z.string(),
+  email: import_zod48.z.email(),
+  avatar: import_zod48.z.string().nullable(),
+  initials: import_zod48.z.string(),
+  is_staff: import_zod48.z.boolean(),
+  is_superuser: import_zod48.z.boolean()
 });
 
-// src/cfg/generated/_utils/schemas/MessageCreateRequest.schema.ts
-var import_zod49 = require("zod");
-var MessageCreateRequestSchema = import_zod49.z.object({
-  text: import_zod49.z.string().min(1)
+// src/cfg/generated/_utils/schemas/Message.schema.ts
+var MessageSchema = import_zod49.z.object({
+  uuid: import_zod49.z.uuid(),
+  ticket: import_zod49.z.uuid(),
+  sender: SenderSchema,
+  is_from_author: import_zod49.z.boolean(),
+  text: import_zod49.z.string(),
+  created_at: import_zod49.z.iso.datetime()
 });
 
-// src/cfg/generated/_utils/schemas/MessageRequest.schema.ts
+// src/cfg/generated/_utils/schemas/MessageCreate.schema.ts
 var import_zod50 = require("zod");
-var MessageRequestSchema = import_zod50.z.object({
-  text: import_zod50.z.string().min(1)
+var MessageCreateSchema = import_zod50.z.object({
+  text: import_zod50.z.string()
 });
 
-// src/cfg/generated/_utils/schemas/Newsletter.schema.ts
+// src/cfg/generated/_utils/schemas/MessageCreateRequest.schema.ts
 var import_zod51 = require("zod");
-var NewsletterSchema = import_zod51.z.object({
-  id: import_zod51.z.int(),
-  title: import_zod51.z.string().max(255),
-  description: import_zod51.z.string().optional(),
-  is_active: import_zod51.z.boolean().optional(),
-  auto_subscribe: import_zod51.z.boolean().optional(),
-  created_at: import_zod51.z.iso.datetime(),
-  updated_at: import_zod51.z.iso.datetime(),
-  subscribers_count: import_zod51.z.int()
+var MessageCreateRequestSchema = import_zod51.z.object({
+  text: import_zod51.z.string().min(1)
 });
 
-// src/cfg/generated/_utils/schemas/NewsletterCampaign.schema.ts
+// src/cfg/generated/_utils/schemas/MessageRequest.schema.ts
 var import_zod52 = require("zod");
-var NewsletterCampaignSchema = import_zod52.z.object({
-  id: import_zod52.z.int(),
-  newsletter: import_zod52.z.int(),
-  newsletter_title: import_zod52.z.string(),
-  subject: import_zod52.z.string().max(255),
-  email_title: import_zod52.z.string().max(255),
-  main_text: import_zod52.z.string(),
-  main_html_content: import_zod52.z.string().optional(),
-  button_text: import_zod52.z.string().max(100).optional(),
-  button_url: import_zod52.z.url().optional(),
-  secondary_text: import_zod52.z.string().optional(),
-  status: import_zod52.z.nativeEnum(NewsletterCampaignStatus),
-  created_at: import_zod52.z.iso.datetime(),
-  sent_at: import_zod52.z.iso.datetime().nullable(),
-  recipient_count: import_zod52.z.int()
+var MessageRequestSchema = import_zod52.z.object({
+  text: import_zod52.z.string().min(1)
 });
 
-// src/cfg/generated/_utils/schemas/NewsletterCampaignRequest.schema.ts
+// src/cfg/generated/_utils/schemas/Newsletter.schema.ts
 var import_zod53 = require("zod");
-var NewsletterCampaignRequestSchema = import_zod53.z.object({
-  newsletter: import_zod53.z.int(),
-  subject: import_zod53.z.string().min(1).max(255),
-  email_title: import_zod53.z.string().min(1).max(255),
-  main_text: import_zod53.z.string().min(1),
-  main_html_content: import_zod53.z.string().optional(),
-  button_text: import_zod53.z.string().max(100).optional(),
-  button_url: import_zod53.z.url().optional(),
-  secondary_text: import_zod53.z.string().optional()
+var NewsletterSchema = import_zod53.z.object({
+  id: import_zod53.z.int(),
+  title: import_zod53.z.string().max(255),
+  description: import_zod53.z.string().optional(),
+  is_active: import_zod53.z.boolean().optional(),
+  auto_subscribe: import_zod53.z.boolean().optional(),
+  created_at: import_zod53.z.iso.datetime(),
+  updated_at: import_zod53.z.iso.datetime(),
+  subscribers_count: import_zod53.z.int()
 });
 
-// src/cfg/generated/_utils/schemas/NewsletterSubscription.schema.ts
+// src/cfg/generated/_utils/schemas/NewsletterCampaign.schema.ts
 var import_zod54 = require("zod");
-var NewsletterSubscriptionSchema = import_zod54.z.object({
+var NewsletterCampaignSchema = import_zod54.z.object({
   id: import_zod54.z.int(),
   newsletter: import_zod54.z.int(),
   newsletter_title: import_zod54.z.string(),
-  user: import_zod54.z.int().nullable().optional(),
-  user_email: import_zod54.z.string(),
-  email: import_zod54.z.email(),
-  is_active: import_zod54.z.boolean().optional(),
-  subscribed_at: import_zod54.z.iso.datetime(),
-  unsubscribed_at: import_zod54.z.iso.datetime().nullable()
+  subject: import_zod54.z.string().max(255),
+  email_title: import_zod54.z.string().max(255),
+  main_text: import_zod54.z.string(),
+  main_html_content: import_zod54.z.string().optional(),
+  button_text: import_zod54.z.string().max(100).optional(),
+  button_url: import_zod54.z.url().optional(),
+  secondary_text: import_zod54.z.string().optional(),
+  status: import_zod54.z.nativeEnum(NewsletterCampaignStatus),
+  created_at: import_zod54.z.iso.datetime(),
+  sent_at: import_zod54.z.iso.datetime().nullable(),
+  recipient_count: import_zod54.z.int()
 });
 
-// src/cfg/generated/_utils/schemas/OTPErrorResponse.schema.ts
+// src/cfg/generated/_utils/schemas/NewsletterCampaignRequest.schema.ts
 var import_zod55 = require("zod");
-var OTPErrorResponseSchema = import_zod55.z.object({
-  error: import_zod55.z.string()
+var NewsletterCampaignRequestSchema = import_zod55.z.object({
+  newsletter: import_zod55.z.int(),
+  subject: import_zod55.z.string().min(1).max(255),
+  email_title: import_zod55.z.string().min(1).max(255),
+  main_text: import_zod55.z.string().min(1),
+  main_html_content: import_zod55.z.string().optional(),
+  button_text: import_zod55.z.string().max(100).optional(),
+  button_url: import_zod55.z.url().optional(),
+  secondary_text: import_zod55.z.string().optional()
 });
 
-// src/cfg/generated/_utils/schemas/OTPRequestRequest.schema.ts
+// src/cfg/generated/_utils/schemas/NewsletterSubscription.schema.ts
 var import_zod56 = require("zod");
-var OTPRequestRequestSchema = import_zod56.z.object({
-  identifier: import_zod56.z.string().min(1),
-  channel: import_zod56.z.nativeEnum(OTPRequestRequestChannel).optional(),
-  source_url: import_zod56.z.url().optional()
+var NewsletterSubscriptionSchema = import_zod56.z.object({
+  id: import_zod56.z.int(),
+  newsletter: import_zod56.z.int(),
+  newsletter_title: import_zod56.z.string(),
+  user: import_zod56.z.int().nullable().optional(),
+  user_email: import_zod56.z.string(),
+  email: import_zod56.z.email(),
+  is_active: import_zod56.z.boolean().optional(),
+  subscribed_at: import_zod56.z.iso.datetime(),
+  unsubscribed_at: import_zod56.z.iso.datetime().nullable()
 });
 
-// src/cfg/generated/_utils/schemas/OTPRequestResponse.schema.ts
+// src/cfg/generated/_utils/schemas/OTPErrorResponse.schema.ts
 var import_zod57 = require("zod");
-var OTPRequestResponseSchema = import_zod57.z.object({
-  message: import_zod57.z.string()
+var OTPErrorResponseSchema = import_zod57.z.object({
+  error: import_zod57.z.string()
 });
 
-// src/cfg/generated/_utils/schemas/OTPVerifyRequest.schema.ts
+// src/cfg/generated/_utils/schemas/OTPRequestRequest.schema.ts
 var import_zod58 = require("zod");
-var OTPVerifyRequestSchema = import_zod58.z.object({
+var OTPRequestRequestSchema = import_zod58.z.object({
   identifier: import_zod58.z.string().min(1),
-  otp: import_zod58.z.string().min(6).max(6),
-  channel: import_zod58.z.nativeEnum(OTPVerifyRequestChannel).optional(),
+  channel: import_zod58.z.nativeEnum(OTPRequestRequestChannel).optional(),
   source_url: import_zod58.z.url().optional()
 });
 
-// src/cfg/generated/_utils/schemas/OTPVerifyResponse.schema.ts
-var import_zod60 = require("zod");
-
-// src/cfg/generated/_utils/schemas/User.schema.ts
+// src/cfg/generated/_utils/schemas/OTPRequestResponse.schema.ts
 var import_zod59 = require("zod");
-var UserSchema = import_zod59.z.object({
-  id: import_zod59.z.int(),
-  email: import_zod59.z.email(),
-  first_name: import_zod59.z.string().max(50).optional(),
-  last_name: import_zod59.z.string().max(50).optional(),
-  full_name: import_zod59.z.string(),
-  initials: import_zod59.z.string(),
-  display_username: import_zod59.z.string(),
-  company: import_zod59.z.string().max(100).optional(),
-  phone: import_zod59.z.string().max(20).optional(),
-  position: import_zod59.z.string().max(100).optional(),
-  avatar: import_zod59.z.url().nullable(),
-  is_staff: import_zod59.z.boolean(),
-  is_superuser: import_zod59.z.boolean(),
-  date_joined: import_zod59.z.iso.datetime(),
-  last_login: import_zod59.z.iso.datetime().nullable(),
-  unanswered_messages_count: import_zod59.z.int()
+var OTPRequestResponseSchema = import_zod59.z.object({
+  message: import_zod59.z.string()
 });
 
-// src/cfg/generated/_utils/schemas/OTPVerifyResponse.schema.ts
-var OTPVerifyResponseSchema = import_zod60.z.object({
-  refresh: import_zod60.z.string(),
-  access: import_zod60.z.string(),
-  user: UserSchema
+// src/cfg/generated/_utils/schemas/OTPVerifyRequest.schema.ts
+var import_zod60 = require("zod");
+var OTPVerifyRequestSchema = import_zod60.z.object({
+  identifier: import_zod60.z.string().min(1),
+  otp: import_zod60.z.string().min(6).max(6),
+  channel: import_zod60.z.nativeEnum(OTPVerifyRequestChannel).optional(),
+  source_url: import_zod60.z.url().optional()
 });
 
-// src/cfg/generated/_utils/schemas/PaginatedArchiveItemChunkList.schema.ts
+// src/cfg/generated/_utils/schemas/OTPVerifyResponse.schema.ts
+var import_zod62 = require("zod");
+
+// src/cfg/generated/_utils/schemas/User.schema.ts
 var import_zod61 = require("zod");
-var PaginatedArchiveItemChunkListSchema = import_zod61.z.object({
-  count: import_zod61.z.int(),
-  page: import_zod61.z.int(),
-  pages: import_zod61.z.int(),
-  page_size: import_zod61.z.int(),
-  has_next: import_zod61.z.boolean(),
-  has_previous: import_zod61.z.boolean(),
-  next_page: import_zod61.z.int().nullable().optional(),
-  previous_page: import_zod61.z.int().nullable().optional(),
-  results: import_zod61.z.array(ArchiveItemChunkSchema)
+var UserSchema = import_zod61.z.object({
+  id: import_zod61.z.int(),
+  email: import_zod61.z.email(),
+  first_name: import_zod61.z.string().max(50).optional(),
+  last_name: import_zod61.z.string().max(50).optional(),
+  full_name: import_zod61.z.string(),
+  initials: import_zod61.z.string(),
+  display_username: import_zod61.z.string(),
+  company: import_zod61.z.string().max(100).optional(),
+  phone: import_zod61.z.string().max(20).optional(),
+  position: import_zod61.z.string().max(100).optional(),
+  avatar: import_zod61.z.url().nullable(),
+  is_staff: import_zod61.z.boolean(),
+  is_superuser: import_zod61.z.boolean(),
+  date_joined: import_zod61.z.iso.datetime(),
+  last_login: import_zod61.z.iso.datetime().nullable(),
+  unanswered_messages_count: import_zod61.z.int()
 });
 
-// src/cfg/generated/_utils/schemas/PaginatedArchiveItemList.schema.ts
-var import_zod62 = require("zod");
-var PaginatedArchiveItemListSchema = import_zod62.z.object({
-  count: import_zod62.z.int(),
-  page: import_zod62.z.int(),
-  pages: import_zod62.z.int(),
-  page_size: import_zod62.z.int(),
-  has_next: import_zod62.z.boolean(),
-  has_previous: import_zod62.z.boolean(),
-  next_page: import_zod62.z.int().nullable().optional(),
-  previous_page: import_zod62.z.int().nullable().optional(),
-  results: import_zod62.z.array(ArchiveItemSchema)
+// src/cfg/generated/_utils/schemas/OTPVerifyResponse.schema.ts
+var OTPVerifyResponseSchema = import_zod62.z.object({
+  refresh: import_zod62.z.string(),
+  access: import_zod62.z.string(),
+  user: UserSchema
 });
 
-// src/cfg/generated/_utils/schemas/PaginatedArchiveSearchResultList.schema.ts
+// src/cfg/generated/_utils/schemas/PaginatedArchiveItemChunkList.schema.ts
 var import_zod63 = require("zod");
-var PaginatedArchiveSearchResultListSchema = import_zod63.z.object({
+var PaginatedArchiveItemChunkListSchema = import_zod63.z.object({
   count: import_zod63.z.int(),
   page: import_zod63.z.int(),
   pages: import_zod63.z.int(),
@@ -15142,12 +15318,12 @@ var PaginatedArchiveSearchResultListSchema = import_zod63.z.object({
   has_previous: import_zod63.z.boolean(),
   next_page: import_zod63.z.int().nullable().optional(),
   previous_page: import_zod63.z.int().nullable().optional(),
-  results: import_zod63.z.array(ArchiveSearchResultSchema)
+  results: import_zod63.z.array(ArchiveItemChunkSchema)
 });
 
-// src/cfg/generated/_utils/schemas/PaginatedChatResponseList.schema.ts
+// src/cfg/generated/_utils/schemas/PaginatedArchiveItemList.schema.ts
 var import_zod64 = require("zod");
-var PaginatedChatResponseListSchema = import_zod64.z.object({
+var PaginatedArchiveItemListSchema = import_zod64.z.object({
   count: import_zod64.z.int(),
   page: import_zod64.z.int(),
   pages: import_zod64.z.int(),
@@ -15156,12 +15332,12 @@ var PaginatedChatResponseListSchema = import_zod64.z.object({
   has_previous: import_zod64.z.boolean(),
   next_page: import_zod64.z.int().nullable().optional(),
   previous_page: import_zod64.z.int().nullable().optional(),
-  results: import_zod64.z.array(ChatResponseSchema)
+  results: import_zod64.z.array(ArchiveItemSchema)
 });
 
-// src/cfg/generated/_utils/schemas/PaginatedChatSessionList.schema.ts
+// src/cfg/generated/_utils/schemas/PaginatedArchiveSearchResultList.schema.ts
 var import_zod65 = require("zod");
-var PaginatedChatSessionListSchema = import_zod65.z.object({
+var PaginatedArchiveSearchResultListSchema = import_zod65.z.object({
   count: import_zod65.z.int(),
   page: import_zod65.z.int(),
   pages: import_zod65.z.int(),
@@ -15170,12 +15346,12 @@ var PaginatedChatSessionListSchema = import_zod65.z.object({
   has_previous: import_zod65.z.boolean(),
   next_page: import_zod65.z.int().nullable().optional(),
   previous_page: import_zod65.z.int().nullable().optional(),
-  results: import_zod65.z.array(ChatSessionSchema)
+  results: import_zod65.z.array(ArchiveSearchResultSchema)
 });
 
-// src/cfg/generated/_utils/schemas/PaginatedDocumentArchiveListList.schema.ts
+// src/cfg/generated/_utils/schemas/PaginatedChatResponseList.schema.ts
 var import_zod66 = require("zod");
-var PaginatedDocumentArchiveListListSchema = import_zod66.z.object({
+var PaginatedChatResponseListSchema = import_zod66.z.object({
   count: import_zod66.z.int(),
   page: import_zod66.z.int(),
   pages: import_zod66.z.int(),
@@ -15184,12 +15360,12 @@ var PaginatedDocumentArchiveListListSchema = import_zod66.z.object({
   has_previous: import_zod66.z.boolean(),
   next_page: import_zod66.z.int().nullable().optional(),
   previous_page: import_zod66.z.int().nullable().optional(),
-  results: import_zod66.z.array(DocumentArchiveListSchema)
+  results: import_zod66.z.array(ChatResponseSchema)
 });
 
-// src/cfg/generated/_utils/schemas/PaginatedDocumentList.schema.ts
+// src/cfg/generated/_utils/schemas/PaginatedChatSessionList.schema.ts
 var import_zod67 = require("zod");
-var PaginatedDocumentListSchema = import_zod67.z.object({
+var PaginatedChatSessionListSchema = import_zod67.z.object({
   count: import_zod67.z.int(),
   page: import_zod67.z.int(),
   pages: import_zod67.z.int(),
@@ -15198,12 +15374,12 @@ var PaginatedDocumentListSchema = import_zod67.z.object({
   has_previous: import_zod67.z.boolean(),
   next_page: import_zod67.z.int().nullable().optional(),
   previous_page: import_zod67.z.int().nullable().optional(),
-  results: import_zod67.z.array(DocumentSchema)
+  results: import_zod67.z.array(ChatSessionSchema)
 });
 
-// src/cfg/generated/_utils/schemas/PaginatedEmailLogList.schema.ts
+// src/cfg/generated/_utils/schemas/PaginatedDocumentArchiveListList.schema.ts
 var import_zod68 = require("zod");
-var PaginatedEmailLogListSchema = import_zod68.z.object({
+var PaginatedDocumentArchiveListListSchema = import_zod68.z.object({
   count: import_zod68.z.int(),
   page: import_zod68.z.int(),
   pages: import_zod68.z.int(),
@@ -15212,12 +15388,12 @@ var PaginatedEmailLogListSchema = import_zod68.z.object({
   has_previous: import_zod68.z.boolean(),
   next_page: import_zod68.z.int().nullable().optional(),
   previous_page: import_zod68.z.int().nullable().optional(),
-  results: import_zod68.z.array(EmailLogSchema)
+  results: import_zod68.z.array(DocumentArchiveListSchema)
 });
 
-// src/cfg/generated/_utils/schemas/PaginatedLeadSubmissionList.schema.ts
+// src/cfg/generated/_utils/schemas/PaginatedDocumentList.schema.ts
 var import_zod69 = require("zod");
-var PaginatedLeadSubmissionListSchema = import_zod69.z.object({
+var PaginatedDocumentListSchema = import_zod69.z.object({
   count: import_zod69.z.int(),
   page: import_zod69.z.int(),
   pages: import_zod69.z.int(),
@@ -15226,12 +15402,12 @@ var PaginatedLeadSubmissionListSchema = import_zod69.z.object({
   has_previous: import_zod69.z.boolean(),
   next_page: import_zod69.z.int().nullable().optional(),
   previous_page: import_zod69.z.int().nullable().optional(),
-  results: import_zod69.z.array(LeadSubmissionSchema)
+  results: import_zod69.z.array(DocumentSchema)
 });
 
-// src/cfg/generated/_utils/schemas/PaginatedMessageList.schema.ts
+// src/cfg/generated/_utils/schemas/PaginatedEmailLogList.schema.ts
 var import_zod70 = require("zod");
-var PaginatedMessageListSchema = import_zod70.z.object({
+var PaginatedEmailLogListSchema = import_zod70.z.object({
   count: import_zod70.z.int(),
   page: import_zod70.z.int(),
   pages: import_zod70.z.int(),
@@ -15240,12 +15416,12 @@ var PaginatedMessageListSchema = import_zod70.z.object({
   has_previous: import_zod70.z.boolean(),
   next_page: import_zod70.z.int().nullable().optional(),
   previous_page: import_zod70.z.int().nullable().optional(),
-  results: import_zod70.z.array(MessageSchema)
+  results: import_zod70.z.array(EmailLogSchema)
 });
 
-// src/cfg/generated/_utils/schemas/PaginatedNewsletterCampaignList.schema.ts
+// src/cfg/generated/_utils/schemas/PaginatedLeadSubmissionList.schema.ts
 var import_zod71 = require("zod");
-var PaginatedNewsletterCampaignListSchema = import_zod71.z.object({
+var PaginatedLeadSubmissionListSchema = import_zod71.z.object({
   count: import_zod71.z.int(),
   page: import_zod71.z.int(),
   pages: import_zod71.z.int(),
@@ -15254,12 +15430,12 @@ var PaginatedNewsletterCampaignListSchema = import_zod71.z.object({
   has_previous: import_zod71.z.boolean(),
   next_page: import_zod71.z.int().nullable().optional(),
   previous_page: import_zod71.z.int().nullable().optional(),
-  results: import_zod71.z.array(NewsletterCampaignSchema)
+  results: import_zod71.z.array(LeadSubmissionSchema)
 });
 
-// src/cfg/generated/_utils/schemas/PaginatedNewsletterList.schema.ts
+// src/cfg/generated/_utils/schemas/PaginatedMessageList.schema.ts
 var import_zod72 = require("zod");
-var PaginatedNewsletterListSchema = import_zod72.z.object({
+var PaginatedMessageListSchema = import_zod72.z.object({
   count: import_zod72.z.int(),
   page: import_zod72.z.int(),
   pages: import_zod72.z.int(),
@@ -15268,12 +15444,12 @@ var PaginatedNewsletterListSchema = import_zod72.z.object({
   has_previous: import_zod72.z.boolean(),
   next_page: import_zod72.z.int().nullable().optional(),
   previous_page: import_zod72.z.int().nullable().optional(),
-  results: import_zod72.z.array(NewsletterSchema)
+  results: import_zod72.z.array(MessageSchema)
 });
 
-// src/cfg/generated/_utils/schemas/PaginatedNewsletterSubscriptionList.schema.ts
+// src/cfg/generated/_utils/schemas/PaginatedNewsletterCampaignList.schema.ts
 var import_zod73 = require("zod");
-var PaginatedNewsletterSubscriptionListSchema = import_zod73.z.object({
+var PaginatedNewsletterCampaignListSchema = import_zod73.z.object({
   count: import_zod73.z.int(),
   page: import_zod73.z.int(),
   pages: import_zod73.z.int(),
@@ -15282,28 +15458,26 @@ var PaginatedNewsletterSubscriptionListSchema = import_zod73.z.object({
   has_previous: import_zod73.z.boolean(),
   next_page: import_zod73.z.int().nullable().optional(),
   previous_page: import_zod73.z.int().nullable().optional(),
-  results: import_zod73.z.array(NewsletterSubscriptionSchema)
+  results: import_zod73.z.array(NewsletterCampaignSchema)
 });
 
-// src/cfg/generated/_utils/schemas/PaginatedPaymentListList.schema.ts
-var import_zod75 = require("zod");
-
-// src/cfg/generated/_utils/schemas/PaymentList.schema.ts
+// src/cfg/generated/_utils/schemas/PaginatedNewsletterList.schema.ts
 var import_zod74 = require("zod");
-var PaymentListSchema = import_zod74.z.object({
-  id: import_zod74.z.uuid(),
-  internal_payment_id: import_zod74.z.string(),
-  amount_usd: import_zod74.z.string(),
-  currency_code: import_zod74.z.string(),
-  currency_token: import_zod74.z.string(),
-  status: import_zod74.z.nativeEnum(PaymentListStatus),
-  status_display: import_zod74.z.string(),
-  created_at: import_zod74.z.iso.datetime(),
-  completed_at: import_zod74.z.iso.datetime().nullable()
+var PaginatedNewsletterListSchema = import_zod74.z.object({
+  count: import_zod74.z.int(),
+  page: import_zod74.z.int(),
+  pages: import_zod74.z.int(),
+  page_size: import_zod74.z.int(),
+  has_next: import_zod74.z.boolean(),
+  has_previous: import_zod74.z.boolean(),
+  next_page: import_zod74.z.int().nullable().optional(),
+  previous_page: import_zod74.z.int().nullable().optional(),
+  results: import_zod74.z.array(NewsletterSchema)
 });
 
-// src/cfg/generated/_utils/schemas/PaginatedPaymentListList.schema.ts
-var PaginatedPaymentListListSchema = import_zod75.z.object({
+// src/cfg/generated/_utils/schemas/PaginatedNewsletterSubscriptionList.schema.ts
+var import_zod75 = require("zod");
+var PaginatedNewsletterSubscriptionListSchema = import_zod75.z.object({
   count: import_zod75.z.int(),
   page: import_zod75.z.int(),
   pages: import_zod75.z.int(),
@@ -15312,22 +15486,28 @@ var PaginatedPaymentListListSchema = import_zod75.z.object({
   has_previous: import_zod75.z.boolean(),
   next_page: import_zod75.z.int().nullable().optional(),
   previous_page: import_zod75.z.int().nullable().optional(),
-  results: import_zod75.z.array(PaymentListSchema)
+  results: import_zod75.z.array(NewsletterSubscriptionSchema)
 });
 
-// src/cfg/generated/_utils/schemas/PaginatedPublicCategoryList.schema.ts
+// src/cfg/generated/_utils/schemas/PaginatedPaymentListList.schema.ts
 var import_zod77 = require("zod");
 
-// src/cfg/generated/_utils/schemas/PublicCategory.schema.ts
+// src/cfg/generated/_utils/schemas/PaymentList.schema.ts
 var import_zod76 = require("zod");
-var PublicCategorySchema = import_zod76.z.object({
+var PaymentListSchema = import_zod76.z.object({
   id: import_zod76.z.uuid(),
-  name: import_zod76.z.string().max(255),
-  description: import_zod76.z.string().optional()
+  internal_payment_id: import_zod76.z.string(),
+  amount_usd: import_zod76.z.string(),
+  currency_code: import_zod76.z.string(),
+  currency_token: import_zod76.z.string(),
+  status: import_zod76.z.nativeEnum(PaymentListStatus),
+  status_display: import_zod76.z.string(),
+  created_at: import_zod76.z.iso.datetime(),
+  completed_at: import_zod76.z.iso.datetime().nullable()
 });
 
-// src/cfg/generated/_utils/schemas/PaginatedPublicCategoryList.schema.ts
-var PaginatedPublicCategoryListSchema = import_zod77.z.object({
+// src/cfg/generated/_utils/schemas/PaginatedPaymentListList.schema.ts
+var PaginatedPaymentListListSchema = import_zod77.z.object({
   count: import_zod77.z.int(),
   page: import_zod77.z.int(),
   pages: import_zod77.z.int(),
@@ -15336,24 +15516,22 @@ var PaginatedPublicCategoryListSchema = import_zod77.z.object({
   has_previous: import_zod77.z.boolean(),
   next_page: import_zod77.z.int().nullable().optional(),
   previous_page: import_zod77.z.int().nullable().optional(),
-  results: import_zod77.z.array(PublicCategorySchema)
+  results: import_zod77.z.array(PaymentListSchema)
 });
 
-// src/cfg/generated/_utils/schemas/PaginatedPublicDocumentListList.schema.ts
+// src/cfg/generated/_utils/schemas/PaginatedPublicCategoryList.schema.ts
 var import_zod79 = require("zod");
 
-// src/cfg/generated/_utils/schemas/PublicDocumentList.schema.ts
+// src/cfg/generated/_utils/schemas/PublicCategory.schema.ts
 var import_zod78 = require("zod");
-var PublicDocumentListSchema = import_zod78.z.object({
+var PublicCategorySchema = import_zod78.z.object({
   id: import_zod78.z.uuid(),
-  title: import_zod78.z.string().max(512),
-  category: PublicCategorySchema,
-  created_at: import_zod78.z.iso.datetime(),
-  updated_at: import_zod78.z.iso.datetime()
+  name: import_zod78.z.string().max(255),
+  description: import_zod78.z.string().optional()
 });
 
-// src/cfg/generated/_utils/schemas/PaginatedPublicDocumentListList.schema.ts
-var PaginatedPublicDocumentListListSchema = import_zod79.z.object({
+// src/cfg/generated/_utils/schemas/PaginatedPublicCategoryList.schema.ts
+var PaginatedPublicCategoryListSchema = import_zod79.z.object({
   count: import_zod79.z.int(),
   page: import_zod79.z.int(),
   pages: import_zod79.z.int(),
@@ -15362,25 +15540,24 @@ var PaginatedPublicDocumentListListSchema = import_zod79.z.object({
   has_previous: import_zod79.z.boolean(),
   next_page: import_zod79.z.int().nullable().optional(),
   previous_page: import_zod79.z.int().nullable().optional(),
-  results: import_zod79.z.array(PublicDocumentListSchema)
+  results: import_zod79.z.array(PublicCategorySchema)
 });
 
-// src/cfg/generated/_utils/schemas/PaginatedTicketList.schema.ts
+// src/cfg/generated/_utils/schemas/PaginatedPublicDocumentListList.schema.ts
 var import_zod81 = require("zod");
 
-// src/cfg/generated/_utils/schemas/Ticket.schema.ts
+// src/cfg/generated/_utils/schemas/PublicDocumentList.schema.ts
 var import_zod80 = require("zod");
-var TicketSchema = import_zod80.z.object({
-  uuid: import_zod80.z.uuid(),
-  user: import_zod80.z.int(),
-  subject: import_zod80.z.string().max(255),
-  status: import_zod80.z.nativeEnum(TicketStatus).optional(),
+var PublicDocumentListSchema = import_zod80.z.object({
+  id: import_zod80.z.uuid(),
+  title: import_zod80.z.string().max(512),
+  category: PublicCategorySchema,
   created_at: import_zod80.z.iso.datetime(),
-  unanswered_messages_count: import_zod80.z.int()
+  updated_at: import_zod80.z.iso.datetime()
 });
 
-// src/cfg/generated/_utils/schemas/PaginatedTicketList.schema.ts
-var PaginatedTicketListSchema = import_zod81.z.object({
+// src/cfg/generated/_utils/schemas/PaginatedPublicDocumentListList.schema.ts
+var PaginatedPublicDocumentListListSchema = import_zod81.z.object({
   count: import_zod81.z.int(),
   page: import_zod81.z.int(),
   pages: import_zod81.z.int(),
@@ -15389,333 +15566,374 @@ var PaginatedTicketListSchema = import_zod81.z.object({
   has_previous: import_zod81.z.boolean(),
   next_page: import_zod81.z.int().nullable().optional(),
   previous_page: import_zod81.z.int().nullable().optional(),
-  results: import_zod81.z.array(TicketSchema)
+  results: import_zod81.z.array(PublicDocumentListSchema)
 });
 
-// src/cfg/generated/_utils/schemas/PatchedArchiveItemChunkRequest.schema.ts
+// src/cfg/generated/_utils/schemas/PaginatedTicketList.schema.ts
+var import_zod83 = require("zod");
+
+// src/cfg/generated/_utils/schemas/Ticket.schema.ts
 var import_zod82 = require("zod");
-var PatchedArchiveItemChunkRequestSchema = import_zod82.z.object({
-  content: import_zod82.z.string().min(1).optional(),
-  chunk_index: import_zod82.z.int().min(0).max(2147483647).optional(),
-  chunk_type: import_zod82.z.nativeEnum(PatchedArchiveItemChunkRequestChunkType).optional()
+var TicketSchema = import_zod82.z.object({
+  uuid: import_zod82.z.uuid(),
+  user: import_zod82.z.int(),
+  subject: import_zod82.z.string().max(255),
+  status: import_zod82.z.nativeEnum(TicketStatus).optional(),
+  created_at: import_zod82.z.iso.datetime(),
+  unanswered_messages_count: import_zod82.z.int()
 });
 
-// src/cfg/generated/_utils/schemas/PatchedArchiveItemRequest.schema.ts
-var import_zod83 = require("zod");
-var PatchedArchiveItemRequestSchema = import_zod83.z.object({
-  relative_path: import_zod83.z.string().min(1).max(1024).optional(),
-  item_name: import_zod83.z.string().min(1).max(255).optional(),
-  item_type: import_zod83.z.string().min(1).max(100).optional(),
-  file_size: import_zod83.z.int().min(0).max(2147483647).optional()
+// src/cfg/generated/_utils/schemas/PaginatedTicketList.schema.ts
+var PaginatedTicketListSchema = import_zod83.z.object({
+  count: import_zod83.z.int(),
+  page: import_zod83.z.int(),
+  pages: import_zod83.z.int(),
+  page_size: import_zod83.z.int(),
+  has_next: import_zod83.z.boolean(),
+  has_previous: import_zod83.z.boolean(),
+  next_page: import_zod83.z.int().nullable().optional(),
+  previous_page: import_zod83.z.int().nullable().optional(),
+  results: import_zod83.z.array(TicketSchema)
 });
 
-// src/cfg/generated/_utils/schemas/PatchedChatResponseRequest.schema.ts
+// src/cfg/generated/_utils/schemas/PatchedArchiveItemChunkRequest.schema.ts
 var import_zod84 = require("zod");
-var PatchedChatResponseRequestSchema = import_zod84.z.object({
-  message_id: import_zod84.z.uuid().optional(),
+var PatchedArchiveItemChunkRequestSchema = import_zod84.z.object({
   content: import_zod84.z.string().min(1).optional(),
-  tokens_used: import_zod84.z.int().optional(),
-  cost_usd: import_zod84.z.number().optional(),
-  processing_time_ms: import_zod84.z.int().optional(),
-  model_used: import_zod84.z.string().min(1).optional(),
-  sources: import_zod84.z.array(ChatSourceRequestSchema).nullable().optional()
+  chunk_index: import_zod84.z.int().min(0).max(2147483647).optional(),
+  chunk_type: import_zod84.z.nativeEnum(PatchedArchiveItemChunkRequestChunkType).optional()
 });
 
-// src/cfg/generated/_utils/schemas/PatchedChatSessionRequest.schema.ts
+// src/cfg/generated/_utils/schemas/PatchedArchiveItemRequest.schema.ts
 var import_zod85 = require("zod");
-var PatchedChatSessionRequestSchema = import_zod85.z.object({
-  title: import_zod85.z.string().max(255).optional(),
-  is_active: import_zod85.z.boolean().optional(),
-  messages_count: import_zod85.z.int().min(0).max(2147483647).optional(),
-  total_tokens_used: import_zod85.z.int().min(0).max(2147483647).optional(),
-  model_name: import_zod85.z.string().min(1).max(100).optional(),
-  temperature: import_zod85.z.number().optional(),
-  max_context_chunks: import_zod85.z.int().min(0).max(2147483647).optional()
+var PatchedArchiveItemRequestSchema = import_zod85.z.object({
+  relative_path: import_zod85.z.string().min(1).max(1024).optional(),
+  item_name: import_zod85.z.string().min(1).max(255).optional(),
+  item_type: import_zod85.z.string().min(1).max(100).optional(),
+  file_size: import_zod85.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_zod86 = require("zod");
-var PatchedDocumentArchiveRequestSchema = import_zod86.z.object({
-  title: import_zod86.z.string().min(1).max(512).optional(),
-  description: import_zod86.z.string().optional(),
-  is_public: import_zod86.z.boolean().optional()
+var PatchedChatResponseRequestSchema = import_zod86.z.object({
+  message_id: import_zod86.z.uuid().optional(),
+  content: import_zod86.z.string().min(1).optional(),
+  tokens_used: import_zod86.z.int().optional(),
+  cost_usd: import_zod86.z.number().optional(),
+  processing_time_ms: import_zod86.z.int().optional(),
+  model_used: import_zod86.z.string().min(1).optional(),
+  sources: import_zod86.z.array(ChatSourceRequestSchema).nullable().optional()
 });
 
-// src/cfg/generated/_utils/schemas/PatchedDocumentRequest.schema.ts
+// src/cfg/generated/_utils/schemas/PatchedChatSessionRequest.schema.ts
 var import_zod87 = require("zod");
-var PatchedDocumentRequestSchema = import_zod87.z.object({
-  title: import_zod87.z.string().min(1).max(512).optional(),
-  file_type: import_zod87.z.string().min(1).max(100).optional(),
-  file_size: import_zod87.z.int().min(0).max(2147483647).optional(),
-  metadata: import_zod87.z.string().nullable().optional()
+var PatchedChatSessionRequestSchema = import_zod87.z.object({
+  title: import_zod87.z.string().max(255).optional(),
+  is_active: import_zod87.z.boolean().optional(),
+  messages_count: import_zod87.z.int().min(0).max(2147483647).optional(),
+  total_tokens_used: import_zod87.z.int().min(0).max(2147483647).optional(),
+  model_name: import_zod87.z.string().min(1).max(100).optional(),
+  temperature: import_zod87.z.number().optional(),
+  max_context_chunks: import_zod87.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_zod88 = require("zod");
-var PatchedLeadSubmissionRequestSchema = import_zod88.z.object({
-  name: import_zod88.z.string().min(1).max(200).optional(),
-  email: import_zod88.z.email().optional(),
-  company: import_zod88.z.string().max(200).nullable().optional(),
-  company_site: import_zod88.z.string().max(200).nullable().optional(),
-  contact_type: import_zod88.z.nativeEnum(PatchedLeadSubmissionRequestContactType).optional(),
-  contact_value: import_zod88.z.string().max(200).nullable().optional(),
-  subject: import_zod88.z.string().max(200).nullable().optional(),
-  message: import_zod88.z.string().min(1).optional(),
-  extra: import_zod88.z.string().nullable().optional(),
-  site_url: import_zod88.z.url().optional()
+var PatchedDocumentArchiveRequestSchema = import_zod88.z.object({
+  title: import_zod88.z.string().min(1).max(512).optional(),
+  description: import_zod88.z.string().optional(),
+  is_public: import_zod88.z.boolean().optional()
 });
 
-// src/cfg/generated/_utils/schemas/PatchedMessageRequest.schema.ts
+// src/cfg/generated/_utils/schemas/PatchedDocumentRequest.schema.ts
 var import_zod89 = require("zod");
-var PatchedMessageRequestSchema = import_zod89.z.object({
-  text: import_zod89.z.string().min(1).optional()
+var PatchedDocumentRequestSchema = import_zod89.z.object({
+  title: import_zod89.z.string().min(1).max(512).optional(),
+  file_type: import_zod89.z.string().min(1).max(100).optional(),
+  file_size: import_zod89.z.int().min(0).max(2147483647).optional(),
+  metadata: import_zod89.z.string().nullable().optional()
 });
 
-// src/cfg/generated/_utils/schemas/PatchedNewsletterCampaignRequest.schema.ts
+// src/cfg/generated/_utils/schemas/PatchedLeadSubmissionRequest.schema.ts
 var import_zod90 = require("zod");
-var PatchedNewsletterCampaignRequestSchema = import_zod90.z.object({
-  newsletter: import_zod90.z.int().optional(),
-  subject: import_zod90.z.string().min(1).max(255).optional(),
-  email_title: import_zod90.z.string().min(1).max(255).optional(),
-  main_text: import_zod90.z.string().min(1).optional(),
-  main_html_content: import_zod90.z.string().optional(),
-  button_text: import_zod90.z.string().max(100).optional(),
-  button_url: import_zod90.z.url().optional(),
-  secondary_text: import_zod90.z.string().optional()
+var PatchedLeadSubmissionRequestSchema = import_zod90.z.object({
+  name: import_zod90.z.string().min(1).max(200).optional(),
+  email: import_zod90.z.email().optional(),
+  company: import_zod90.z.string().max(200).nullable().optional(),
+  company_site: import_zod90.z.string().max(200).nullable().optional(),
+  contact_type: import_zod90.z.nativeEnum(PatchedLeadSubmissionRequestContactType).optional(),
+  contact_value: import_zod90.z.string().max(200).nullable().optional(),
+  subject: import_zod90.z.string().max(200).nullable().optional(),
+  message: import_zod90.z.string().min(1).optional(),
+  extra: import_zod90.z.string().nullable().optional(),
+  site_url: import_zod90.z.url().optional()
 });
 
-// src/cfg/generated/_utils/schemas/PatchedTicketRequest.schema.ts
+// src/cfg/generated/_utils/schemas/PatchedMessageRequest.schema.ts
 var import_zod91 = require("zod");
-var PatchedTicketRequestSchema = import_zod91.z.object({
-  user: import_zod91.z.int().optional(),
-  subject: import_zod91.z.string().min(1).max(255).optional(),
-  status: import_zod91.z.nativeEnum(PatchedTicketRequestStatus).optional()
+var PatchedMessageRequestSchema = import_zod91.z.object({
+  text: import_zod91.z.string().min(1).optional()
 });
 
-// src/cfg/generated/_utils/schemas/PatchedUnsubscribeRequest.schema.ts
+// src/cfg/generated/_utils/schemas/PatchedNewsletterCampaignRequest.schema.ts
 var import_zod92 = require("zod");
-var PatchedUnsubscribeRequestSchema = import_zod92.z.object({
-  subscription_id: import_zod92.z.int().optional()
+var PatchedNewsletterCampaignRequestSchema = import_zod92.z.object({
+  newsletter: import_zod92.z.int().optional(),
+  subject: import_zod92.z.string().min(1).max(255).optional(),
+  email_title: import_zod92.z.string().min(1).max(255).optional(),
+  main_text: import_zod92.z.string().min(1).optional(),
+  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()
 });
 
-// src/cfg/generated/_utils/schemas/PatchedUserProfileUpdateRequest.schema.ts
+// src/cfg/generated/_utils/schemas/PatchedTicketRequest.schema.ts
 var import_zod93 = require("zod");
-var PatchedUserProfileUpdateRequestSchema = import_zod93.z.object({
-  first_name: import_zod93.z.string().max(50).optional(),
-  last_name: import_zod93.z.string().max(50).optional(),
-  company: import_zod93.z.string().max(100).optional(),
-  phone: import_zod93.z.string().max(20).optional(),
-  position: import_zod93.z.string().max(100).optional()
+var PatchedTicketRequestSchema = import_zod93.z.object({
+  user: import_zod93.z.int().optional(),
+  subject: import_zod93.z.string().min(1).max(255).optional(),
+  status: import_zod93.z.nativeEnum(PatchedTicketRequestStatus).optional()
 });
 
-// src/cfg/generated/_utils/schemas/PaymentDetail.schema.ts
+// src/cfg/generated/_utils/schemas/PatchedUnsubscribeRequest.schema.ts
 var import_zod94 = require("zod");
-var PaymentDetailSchema = import_zod94.z.object({
-  id: import_zod94.z.uuid(),
-  internal_payment_id: import_zod94.z.string(),
-  amount_usd: import_zod94.z.string(),
-  currency_code: import_zod94.z.string(),
-  currency_name: import_zod94.z.string(),
-  currency_token: import_zod94.z.string(),
-  currency_network: import_zod94.z.string(),
-  pay_amount: import_zod94.z.string().nullable(),
-  actual_amount: import_zod94.z.string().nullable(),
-  actual_amount_usd: import_zod94.z.string().nullable(),
-  status: import_zod94.z.nativeEnum(PaymentDetailStatus),
-  status_display: import_zod94.z.string(),
-  pay_address: import_zod94.z.string().nullable(),
-  qr_code_url: import_zod94.z.string(),
-  payment_url: import_zod94.z.url().nullable(),
-  transaction_hash: import_zod94.z.string().nullable(),
-  explorer_link: import_zod94.z.string(),
-  confirmations_count: import_zod94.z.int(),
-  expires_at: import_zod94.z.iso.datetime().nullable(),
-  completed_at: import_zod94.z.iso.datetime().nullable(),
-  created_at: import_zod94.z.iso.datetime(),
-  is_completed: import_zod94.z.boolean(),
-  is_failed: import_zod94.z.boolean(),
-  is_expired: import_zod94.z.boolean(),
-  description: import_zod94.z.string()
+var PatchedUnsubscribeRequestSchema = import_zod94.z.object({
+  subscription_id: import_zod94.z.int().optional()
 });
 
-// src/cfg/generated/_utils/schemas/PublicDocument.schema.ts
+// src/cfg/generated/_utils/schemas/PatchedUserProfileUpdateRequest.schema.ts
 var import_zod95 = require("zod");
-var PublicDocumentSchema = import_zod95.z.object({
-  id: import_zod95.z.uuid(),
-  title: import_zod95.z.string().max(512),
-  content: import_zod95.z.string(),
-  category: PublicCategorySchema,
-  created_at: import_zod95.z.iso.datetime(),
-  updated_at: import_zod95.z.iso.datetime()
+var PatchedUserProfileUpdateRequestSchema = import_zod95.z.object({
+  first_name: import_zod95.z.string().max(50).optional(),
+  last_name: import_zod95.z.string().max(50).optional(),
+  company: import_zod95.z.string().max(100).optional(),
+  phone: import_zod95.z.string().max(20).optional(),
+  position: import_zod95.z.string().max(100).optional()
 });
 
-// src/cfg/generated/_utils/schemas/QueueAction.schema.ts
+// src/cfg/generated/_utils/schemas/PaymentDetail.schema.ts
 var import_zod96 = require("zod");
-var QueueActionSchema = import_zod96.z.object({
-  action: import_zod96.z.nativeEnum(QueueActionAction),
-  queue_names: import_zod96.z.array(import_zod96.z.string()).optional()
+var PaymentDetailSchema = import_zod96.z.object({
+  id: import_zod96.z.uuid(),
+  internal_payment_id: import_zod96.z.string(),
+  amount_usd: import_zod96.z.string(),
+  currency_code: import_zod96.z.string(),
+  currency_name: import_zod96.z.string(),
+  currency_token: import_zod96.z.string(),
+  currency_network: import_zod96.z.string(),
+  pay_amount: import_zod96.z.string().nullable(),
+  actual_amount: import_zod96.z.string().nullable(),
+  actual_amount_usd: import_zod96.z.string().nullable(),
+  status: import_zod96.z.nativeEnum(PaymentDetailStatus),
+  status_display: import_zod96.z.string(),
+  pay_address: import_zod96.z.string().nullable(),
+  qr_code_url: import_zod96.z.string().nullable(),
+  payment_url: import_zod96.z.url().nullable(),
+  transaction_hash: import_zod96.z.string().nullable(),
+  explorer_link: import_zod96.z.string().nullable(),
+  confirmations_count: import_zod96.z.int(),
+  expires_at: import_zod96.z.iso.datetime().nullable(),
+  completed_at: import_zod96.z.iso.datetime().nullable(),
+  created_at: import_zod96.z.iso.datetime(),
+  is_completed: import_zod96.z.boolean(),
+  is_failed: import_zod96.z.boolean(),
+  is_expired: import_zod96.z.boolean(),
+  description: import_zod96.z.string()
 });
 
-// src/cfg/generated/_utils/schemas/QueueActionRequest.schema.ts
+// src/cfg/generated/_utils/schemas/PublicDocument.schema.ts
 var import_zod97 = require("zod");
-var QueueActionRequestSchema = import_zod97.z.object({
-  action: import_zod97.z.nativeEnum(QueueActionRequestAction),
-  queue_names: import_zod97.z.array(import_zod97.z.string().min(1)).optional()
+var PublicDocumentSchema = import_zod97.z.object({
+  id: import_zod97.z.uuid(),
+  title: import_zod97.z.string().max(512),
+  content: import_zod97.z.string(),
+  category: PublicCategorySchema,
+  created_at: import_zod97.z.iso.datetime(),
+  updated_at: import_zod97.z.iso.datetime()
 });
 
-// src/cfg/generated/_utils/schemas/QueueStatus.schema.ts
+// src/cfg/generated/_utils/schemas/QueueAction.schema.ts
 var import_zod98 = require("zod");
-var QueueStatusSchema = import_zod98.z.object({
-  queues: import_zod98.z.record(import_zod98.z.string(), import_zod98.z.any()),
-  workers: import_zod98.z.int(),
-  redis_connected: import_zod98.z.boolean(),
-  timestamp: import_zod98.z.string(),
-  error: import_zod98.z.string().optional()
+var QueueActionSchema = import_zod98.z.object({
+  action: import_zod98.z.nativeEnum(QueueActionAction),
+  queue_names: import_zod98.z.array(import_zod98.z.string()).optional()
 });
 
-// src/cfg/generated/_utils/schemas/QuickHealth.schema.ts
+// src/cfg/generated/_utils/schemas/QueueActionRequest.schema.ts
 var import_zod99 = require("zod");
-var QuickHealthSchema = import_zod99.z.object({
-  status: import_zod99.z.string(),
-  timestamp: import_zod99.z.iso.datetime(),
-  error: import_zod99.z.string().optional()
+var QueueActionRequestSchema = import_zod99.z.object({
+  action: import_zod99.z.nativeEnum(QueueActionRequestAction),
+  queue_names: import_zod99.z.array(import_zod99.z.string().min(1)).optional()
 });
 
-// src/cfg/generated/_utils/schemas/SendCampaignRequest.schema.ts
+// src/cfg/generated/_utils/schemas/QueueStatus.schema.ts
 var import_zod100 = require("zod");
-var SendCampaignRequestSchema = import_zod100.z.object({
-  campaign_id: import_zod100.z.int()
+var QueueStatusSchema = import_zod100.z.object({
+  queues: import_zod100.z.record(import_zod100.z.string(), import_zod100.z.any()),
+  workers: import_zod100.z.int(),
+  redis_connected: import_zod100.z.boolean(),
+  timestamp: import_zod100.z.string(),
+  error: import_zod100.z.string().optional()
 });
 
-// src/cfg/generated/_utils/schemas/SendCampaignResponse.schema.ts
+// src/cfg/generated/_utils/schemas/QuickHealth.schema.ts
 var import_zod101 = require("zod");
-var SendCampaignResponseSchema = import_zod101.z.object({
-  success: import_zod101.z.boolean(),
-  message: import_zod101.z.string().optional(),
-  sent_count: import_zod101.z.int().optional(),
+var QuickHealthSchema = import_zod101.z.object({
+  status: import_zod101.z.string(),
+  timestamp: import_zod101.z.iso.datetime(),
   error: import_zod101.z.string().optional()
 });
 
-// src/cfg/generated/_utils/schemas/SubscribeRequest.schema.ts
+// src/cfg/generated/_utils/schemas/SendCampaignRequest.schema.ts
 var import_zod102 = require("zod");
-var SubscribeRequestSchema = import_zod102.z.object({
-  newsletter_id: import_zod102.z.int(),
-  email: import_zod102.z.email()
+var SendCampaignRequestSchema = import_zod102.z.object({
+  campaign_id: import_zod102.z.int()
 });
 
-// src/cfg/generated/_utils/schemas/SubscribeResponse.schema.ts
+// src/cfg/generated/_utils/schemas/SendCampaignResponse.schema.ts
 var import_zod103 = require("zod");
-var SubscribeResponseSchema = import_zod103.z.object({
+var SendCampaignResponseSchema = import_zod103.z.object({
   success: import_zod103.z.boolean(),
-  message: import_zod103.z.string(),
-  subscription_id: import_zod103.z.int().optional()
+  message: import_zod103.z.string().optional(),
+  sent_count: import_zod103.z.int().optional(),
+  error: import_zod103.z.string().optional()
 });
 
-// src/cfg/generated/_utils/schemas/SuccessResponse.schema.ts
+// src/cfg/generated/_utils/schemas/SubscribeRequest.schema.ts
 var import_zod104 = require("zod");
-var SuccessResponseSchema = import_zod104.z.object({
-  success: import_zod104.z.boolean(),
-  message: import_zod104.z.string()
+var SubscribeRequestSchema = import_zod104.z.object({
+  newsletter_id: import_zod104.z.int(),
+  email: import_zod104.z.email()
 });
 
-// src/cfg/generated/_utils/schemas/TaskStatistics.schema.ts
+// src/cfg/generated/_utils/schemas/SubscribeResponse.schema.ts
 var import_zod105 = require("zod");
-var TaskStatisticsSchema = import_zod105.z.object({
-  statistics: import_zod105.z.record(import_zod105.z.string(), import_zod105.z.any()),
-  recent_tasks: import_zod105.z.array(import_zod105.z.record(import_zod105.z.string(), import_zod105.z.any())),
-  timestamp: import_zod105.z.string(),
-  error: import_zod105.z.string().optional()
+var SubscribeResponseSchema = import_zod105.z.object({
+  success: import_zod105.z.boolean(),
+  message: import_zod105.z.string(),
+  subscription_id: import_zod105.z.int().optional()
 });
 
-// src/cfg/generated/_utils/schemas/TestEmailRequest.schema.ts
+// src/cfg/generated/_utils/schemas/SuccessResponse.schema.ts
 var import_zod106 = require("zod");
-var TestEmailRequestSchema = import_zod106.z.object({
-  email: import_zod106.z.email(),
-  subject: import_zod106.z.string().min(1).max(255).optional(),
-  message: import_zod106.z.string().min(1).optional()
+var SuccessResponseSchema = import_zod106.z.object({
+  success: import_zod106.z.boolean(),
+  message: import_zod106.z.string()
 });
 
-// src/cfg/generated/_utils/schemas/TicketRequest.schema.ts
+// src/cfg/generated/_utils/schemas/TaskStatistics.schema.ts
 var import_zod107 = require("zod");
-var TicketRequestSchema = import_zod107.z.object({
-  user: import_zod107.z.int(),
-  subject: import_zod107.z.string().min(1).max(255),
-  status: import_zod107.z.nativeEnum(TicketRequestStatus).optional()
+var TaskStatisticsSchema = import_zod107.z.object({
+  statistics: import_zod107.z.record(import_zod107.z.string(), import_zod107.z.any()),
+  recent_tasks: import_zod107.z.array(import_zod107.z.record(import_zod107.z.string(), import_zod107.z.any())),
+  timestamp: import_zod107.z.string(),
+  error: import_zod107.z.string().optional()
 });
 
-// src/cfg/generated/_utils/schemas/TokenRefresh.schema.ts
+// src/cfg/generated/_utils/schemas/TestEmailRequest.schema.ts
 var import_zod108 = require("zod");
-var TokenRefreshSchema = import_zod108.z.object({
-  access: import_zod108.z.string(),
-  refresh: import_zod108.z.string()
+var TestEmailRequestSchema = import_zod108.z.object({
+  email: import_zod108.z.email(),
+  subject: import_zod108.z.string().min(1).max(255).optional(),
+  message: import_zod108.z.string().min(1).optional()
 });
 
-// src/cfg/generated/_utils/schemas/TokenRefreshRequest.schema.ts
+// src/cfg/generated/_utils/schemas/TicketRequest.schema.ts
 var import_zod109 = require("zod");
-var TokenRefreshRequestSchema = import_zod109.z.object({
-  refresh: import_zod109.z.string().min(1)
+var TicketRequestSchema = import_zod109.z.object({
+  user: import_zod109.z.int(),
+  subject: import_zod109.z.string().min(1).max(255),
+  status: import_zod109.z.nativeEnum(TicketRequestStatus).optional()
 });
 
-// src/cfg/generated/_utils/schemas/Unsubscribe.schema.ts
+// src/cfg/generated/_utils/schemas/TokenRefresh.schema.ts
 var import_zod110 = require("zod");
-var UnsubscribeSchema = import_zod110.z.object({
-  subscription_id: import_zod110.z.int()
+var TokenRefreshSchema = import_zod110.z.object({
+  access: import_zod110.z.string(),
+  refresh: import_zod110.z.string()
 });
 
-// src/cfg/generated/_utils/schemas/UnsubscribeRequest.schema.ts
+// src/cfg/generated/_utils/schemas/TokenRefreshRequest.schema.ts
 var import_zod111 = require("zod");
-var UnsubscribeRequestSchema = import_zod111.z.object({
-  subscription_id: import_zod111.z.int()
+var TokenRefreshRequestSchema = import_zod111.z.object({
+  refresh: import_zod111.z.string().min(1)
 });
 
-// src/cfg/generated/_utils/schemas/UserProfileUpdateRequest.schema.ts
+// src/cfg/generated/_utils/schemas/Transaction.schema.ts
 var import_zod112 = require("zod");
-var UserProfileUpdateRequestSchema = import_zod112.z.object({
-  first_name: import_zod112.z.string().max(50).optional(),
-  last_name: import_zod112.z.string().max(50).optional(),
-  company: import_zod112.z.string().max(100).optional(),
-  phone: import_zod112.z.string().max(20).optional(),
-  position: import_zod112.z.string().max(100).optional()
+var TransactionSchema = import_zod112.z.object({
+  id: import_zod112.z.uuid(),
+  transaction_type: import_zod112.z.nativeEnum(TransactionTransactionType),
+  type_display: import_zod112.z.string(),
+  amount_usd: import_zod112.z.string(),
+  amount_display: import_zod112.z.string(),
+  balance_after: import_zod112.z.string(),
+  payment_id: import_zod112.z.string().nullable(),
+  description: import_zod112.z.string(),
+  created_at: import_zod112.z.iso.datetime()
 });
 
-// src/cfg/generated/_utils/schemas/VectorizationResult.schema.ts
+// src/cfg/generated/_utils/schemas/Unsubscribe.schema.ts
 var import_zod113 = require("zod");
-var VectorizationResultSchema = import_zod113.z.object({
-  vectorized_count: import_zod113.z.int(),
-  failed_count: import_zod113.z.int(),
-  total_tokens: import_zod113.z.int(),
-  total_cost: import_zod113.z.number(),
-  success_rate: import_zod113.z.number(),
-  errors: import_zod113.z.array(import_zod113.z.string())
+var UnsubscribeSchema = import_zod113.z.object({
+  subscription_id: import_zod113.z.int()
 });
 
-// src/cfg/generated/_utils/schemas/VectorizationStatistics.schema.ts
+// src/cfg/generated/_utils/schemas/UnsubscribeRequest.schema.ts
 var import_zod114 = require("zod");
-var VectorizationStatisticsSchema = import_zod114.z.object({
-  total_chunks: import_zod114.z.int(),
-  vectorized_chunks: import_zod114.z.int(),
-  pending_chunks: import_zod114.z.int(),
-  vectorization_rate: import_zod114.z.number(),
-  total_tokens: import_zod114.z.int(),
-  total_cost: import_zod114.z.number(),
-  avg_tokens_per_chunk: import_zod114.z.number(),
-  avg_cost_per_chunk: import_zod114.z.number()
+var UnsubscribeRequestSchema = import_zod114.z.object({
+  subscription_id: import_zod114.z.int()
 });
 
-// src/cfg/generated/_utils/schemas/WorkerAction.schema.ts
+// src/cfg/generated/_utils/schemas/UserProfileUpdateRequest.schema.ts
 var import_zod115 = require("zod");
-var WorkerActionSchema = import_zod115.z.object({
-  action: import_zod115.z.nativeEnum(WorkerActionAction),
-  processes: import_zod115.z.int().min(1).max(10).optional(),
-  threads: import_zod115.z.int().min(1).max(20).optional()
+var UserProfileUpdateRequestSchema = import_zod115.z.object({
+  first_name: import_zod115.z.string().max(50).optional(),
+  last_name: import_zod115.z.string().max(50).optional(),
+  company: import_zod115.z.string().max(100).optional(),
+  phone: import_zod115.z.string().max(20).optional(),
+  position: import_zod115.z.string().max(100).optional()
 });
 
-// src/cfg/generated/_utils/schemas/WorkerActionRequest.schema.ts
+// src/cfg/generated/_utils/schemas/VectorizationResult.schema.ts
 var import_zod116 = require("zod");
-var WorkerActionRequestSchema = import_zod116.z.object({
-  action: import_zod116.z.nativeEnum(WorkerActionRequestAction),
-  processes: import_zod116.z.int().min(1).max(10).optional(),
-  threads: import_zod116.z.int().min(1).max(20).optional()
+var VectorizationResultSchema = import_zod116.z.object({
+  vectorized_count: import_zod116.z.int(),
+  failed_count: import_zod116.z.int(),
+  total_tokens: import_zod116.z.int(),
+  total_cost: import_zod116.z.number(),
+  success_rate: import_zod116.z.number(),
+  errors: import_zod116.z.array(import_zod116.z.string())
+});
+
+// src/cfg/generated/_utils/schemas/VectorizationStatistics.schema.ts
+var import_zod117 = require("zod");
+var VectorizationStatisticsSchema = import_zod117.z.object({
+  total_chunks: import_zod117.z.int(),
+  vectorized_chunks: import_zod117.z.int(),
+  pending_chunks: import_zod117.z.int(),
+  vectorization_rate: import_zod117.z.number(),
+  total_tokens: import_zod117.z.int(),
+  total_cost: import_zod117.z.number(),
+  avg_tokens_per_chunk: import_zod117.z.number(),
+  avg_cost_per_chunk: import_zod117.z.number()
+});
+
+// src/cfg/generated/_utils/schemas/WorkerAction.schema.ts
+var import_zod118 = require("zod");
+var WorkerActionSchema = import_zod118.z.object({
+  action: import_zod118.z.nativeEnum(WorkerActionAction),
+  processes: import_zod118.z.int().min(1).max(10).optional(),
+  threads: import_zod118.z.int().min(1).max(20).optional()
+});
+
+// src/cfg/generated/_utils/schemas/WorkerActionRequest.schema.ts
+var import_zod119 = require("zod");
+var WorkerActionRequestSchema = import_zod119.z.object({
+  action: import_zod119.z.nativeEnum(WorkerActionRequestAction),
+  processes: import_zod119.z.int().min(1).max(10).optional(),
+  threads: import_zod119.z.int().min(1).max(20).optional()
 });
 
 // src/cfg/generated/_utils/fetchers/index.ts
@@ -15805,11 +16023,11 @@ __export(fetchers_exports, {
   getNewsletterNewslettersRetrieve: () => getNewsletterNewslettersRetrieve,
   getNewsletterSubscriptionsList: () => getNewsletterSubscriptionsList,
   getPaymentsBalanceRetrieve: () => getPaymentsBalanceRetrieve,
-  getPaymentsCurrenciesRetrieve: () => getPaymentsCurrenciesRetrieve,
+  getPaymentsCurrenciesList: () => getPaymentsCurrenciesList,
   getPaymentsPaymentsList: () => getPaymentsPaymentsList,
   getPaymentsPaymentsRetrieve: () => getPaymentsPaymentsRetrieve,
   getPaymentsPaymentsStatusRetrieve: () => getPaymentsPaymentsStatusRetrieve,
-  getPaymentsTransactionsRetrieve: () => getPaymentsTransactionsRetrieve,
+  getPaymentsTransactionsList: () => getPaymentsTransactionsList,
   getSupportTicketsList: () => getSupportTicketsList,
   getSupportTicketsMessagesList: () => getSupportTicketsMessagesList,
   getSupportTicketsMessagesRetrieve: () => getSupportTicketsMessagesRetrieve,
@@ -16386,11 +16604,11 @@ async function createNewsletterTestCreate(data, client) {
 async function getPaymentsBalanceRetrieve(client) {
   const api2 = client || getAPIInstance();
   const response = await api2.cfg_payments.balanceRetrieve();
-  return response;
+  return BalanceSchema.parse(response);
 }
-async function getPaymentsCurrenciesRetrieve(client) {
+async function getPaymentsCurrenciesList(client) {
   const api2 = client || getAPIInstance();
-  const response = await api2.cfg_payments.currenciesRetrieve();
+  const response = await api2.cfg_payments.currenciesList();
   return response;
 }
 async function getPaymentsPaymentsList(params, client) {
@@ -16418,9 +16636,9 @@ async function createPaymentsPaymentsCreateCreate(client) {
   const response = await api2.cfg_payments.paymentsCreateCreate();
   return PaymentListSchema.parse(response);
 }
-async function getPaymentsTransactionsRetrieve(client) {
+async function getPaymentsTransactionsList(params, client) {
   const api2 = client || getAPIInstance();
-  const response = await api2.cfg_payments.transactionsRetrieve();
+  const response = await api2.cfg_payments.transactionsList(params?.limit, params?.offset, params?.type);
   return response;
 }
 
@@ -16639,11 +16857,11 @@ __export(hooks_exports, {
   usePartialUpdateSupportTicketsMessagesPartialUpdate: () => usePartialUpdateSupportTicketsMessagesPartialUpdate,
   usePartialUpdateSupportTicketsPartialUpdate: () => usePartialUpdateSupportTicketsPartialUpdate,
   usePaymentsBalanceRetrieve: () => usePaymentsBalanceRetrieve,
-  usePaymentsCurrenciesRetrieve: () => usePaymentsCurrenciesRetrieve,
+  usePaymentsCurrenciesList: () => usePaymentsCurrenciesList,
   usePaymentsPaymentsList: () => usePaymentsPaymentsList,
   usePaymentsPaymentsRetrieve: () => usePaymentsPaymentsRetrieve,
   usePaymentsPaymentsStatusRetrieve: () => usePaymentsPaymentsStatusRetrieve,
-  usePaymentsTransactionsRetrieve: () => usePaymentsTransactionsRetrieve,
+  usePaymentsTransactionsList: () => usePaymentsTransactionsList,
   useSupportTicketsList: () => useSupportTicketsList,
   useSupportTicketsMessagesList: () => useSupportTicketsMessagesList,
   useSupportTicketsMessagesRetrieve: () => useSupportTicketsMessagesRetrieve,
@@ -17407,10 +17625,10 @@ function usePaymentsBalanceRetrieve(client) {
     () => getPaymentsBalanceRetrieve(client)
   );
 }
-function usePaymentsCurrenciesRetrieve(client) {
+function usePaymentsCurrenciesList(client) {
   return (0, import_swr21.default)(
-    "cfg-payments-currencie",
-    () => getPaymentsCurrenciesRetrieve(client)
+    "cfg-payments-currencies",
+    () => getPaymentsCurrenciesList(client)
   );
 }
 function usePaymentsPaymentsList(params, client) {
@@ -17447,10 +17665,10 @@ function useCreatePaymentsPaymentsCreateCreate() {
     return result;
   };
 }
-function usePaymentsTransactionsRetrieve(client) {
+function usePaymentsTransactionsList(params, client) {
   return (0, import_swr21.default)(
-    "cfg-payments-transaction",
-    () => getPaymentsTransactionsRetrieve(client)
+    params ? ["cfg-payments-transactions", params] : "cfg-payments-transactions",
+    () => getPaymentsTransactionsList(params, client)
   );
 }
 
@@ -19190,7 +19408,7 @@ function CurrenciesProvider({ children }) {
     error: currenciesError,
     isLoading: isLoadingCurrencies,
     mutate: mutateCurrencies
-  } = usePaymentsCurrenciesRetrieve(api);
+  } = usePaymentsCurrenciesList(api);
   const refreshCurrencies = async () => {
     await mutateCurrencies();
   };
@@ -19273,7 +19491,7 @@ function OverviewProvider({ children }) {
     error: transactionsError,
     isLoading: isLoadingTransactions,
     mutate: mutateTransactions
-  } = usePaymentsTransactionsRetrieve(api);
+  } = usePaymentsTransactionsList({}, api);
   const createPaymentMutation = useCreatePaymentsPaymentsCreateCreate();
   const isLoadingOverview = isLoadingBalance || isLoadingPayments || isLoadingTransactions;
   const overviewError = balanceError || paymentsError || transactionsError;
@@ -19336,7 +19554,7 @@ function RootPaymentsProvider({ children }) {
     error: currenciesError,
     isLoading: isLoadingCurrencies,
     mutate: mutateCurrencies
-  } = usePaymentsCurrenciesRetrieve(api);
+  } = usePaymentsCurrenciesList(api);
   const refreshCurrencies = async () => {
     await mutateCurrencies();
   };
@@ -19790,11 +20008,11 @@ function useKnowbaseSessionsContext() {
   getNewsletterNewslettersRetrieve,
   getNewsletterSubscriptionsList,
   getPaymentsBalanceRetrieve,
-  getPaymentsCurrenciesRetrieve,
+  getPaymentsCurrenciesList,
   getPaymentsPaymentsList,
   getPaymentsPaymentsRetrieve,
   getPaymentsPaymentsStatusRetrieve,
-  getPaymentsTransactionsRetrieve,
+  getPaymentsTransactionsList,
   getSupportTicketsList,
   getSupportTicketsMessagesList,
   getSupportTicketsMessagesRetrieve,