@djangocfg/api 1.2.36 → 1.2.38

package/dist/index.cjs

@@ -4011,6 +4011,7 @@ __export(schemas_exports, {
   CentrifugoClientInfoSchema: () => CentrifugoClientInfoSchema,
   CentrifugoConfigSchema: () => CentrifugoConfigSchema,
   CentrifugoErrorSchema: () => CentrifugoErrorSchema,
+  CentrifugoHealthCheckSchema: () => CentrifugoHealthCheckSchema,
   CentrifugoHistoryRequestRequestSchema: () => CentrifugoHistoryRequestRequestSchema,
   CentrifugoHistoryResponseSchema: () => CentrifugoHistoryResponseSchema,
   CentrifugoHistoryResultSchema: () => CentrifugoHistoryResultSchema,
@@ -4056,6 +4057,7 @@ __export(schemas_exports, {
   ConstanceConfigSchema: () => ConstanceConfigSchema,
   CurrencySchema: () => CurrencySchema,
   DRFConfigSchema: () => DRFConfigSchema,
+  DRFHealthCheckSchema: () => DRFHealthCheckSchema,
   DashboardChartsSchema: () => DashboardChartsSchema,
   DashboardOverviewSchema: () => DashboardOverviewSchema,
   DatabaseConfigSchema: () => DatabaseConfigSchema,
@@ -4089,15 +4091,16 @@ __export(schemas_exports, {
   GRPCFrameworkConfigSchema: () => GRPCFrameworkConfigSchema,
   GRPCHealthCheckSchema: () => GRPCHealthCheckSchema,
   GRPCInterceptorInfoSchema: () => GRPCInterceptorInfoSchema,
+  GRPCMethodStatsSchema: () => GRPCMethodStatsSchema,
   GRPCOverviewStatsSchema: () => GRPCOverviewStatsSchema,
   GRPCRegisteredServiceSchema: () => GRPCRegisteredServiceSchema,
   GRPCServerConfigSchema: () => GRPCServerConfigSchema,
   GRPCServerInfoSchema: () => GRPCServerInfoSchema,
   GRPCServerStatusSchema: () => GRPCServerStatusSchema,
   GRPCServiceInfoSchema: () => GRPCServiceInfoSchema,
+  GRPCServiceRegistryMethodStatsSchema: () => GRPCServiceRegistryMethodStatsSchema,
   GRPCStatsSchema: () => GRPCStatsSchema,
   GRPCTestLogSchema: () => GRPCTestLogSchema,
-  HealthCheckSchema: () => HealthCheckSchema,
   JWTConfigSchema: () => JWTConfigSchema,
   JobActionResponseSchema: () => JobActionResponseSchema,
   JobDetailSchema: () => JobDetailSchema,
@@ -4115,7 +4118,6 @@ __export(schemas_exports, {
   MessageSchema: () => MessageSchema,
   MethodInfoSchema: () => MethodInfoSchema,
   MethodListSchema: () => MethodListSchema,
-  MethodStatsSchema: () => MethodStatsSchema,
   MethodSummarySchema: () => MethodSummarySchema,
   ModelStatisticsSchema: () => ModelStatisticsSchema,
   NewsletterCampaignRequestSchema: () => NewsletterCampaignRequestSchema,
@@ -4186,6 +4188,7 @@ __export(schemas_exports, {
   QuickActionSchema: () => QuickActionSchema,
   QuickHealthSchema: () => QuickHealthSchema,
   RQConfigSchema: () => RQConfigSchema,
+  RQHealthCheckSchema: () => RQHealthCheckSchema,
   RQScheduleSchema: () => RQScheduleSchema,
   RecentErrorSchema: () => RecentErrorSchema,
   RecentRequestSchema: () => RecentRequestSchema,
@@ -4378,7 +4381,7 @@ var ArchiveItemChunkSchema = import_zod11.z.object({
   character_count: import_zod11.z.int(),
   embedding_model: import_zod11.z.string(),
   embedding_cost: import_zod11.z.number(),
-  context_summary: import_zod11.z.record(import_zod11.z.string(), import_zod11.z.record(import_zod11.z.string(), import_zod11.z.any())),
+  context_summary: import_zod11.z.object({}),
   created_at: import_zod11.z.iso.datetime()
 });
 
@@ -4393,7 +4396,7 @@ var ArchiveItemChunkDetailSchema = import_zod12.z.object({
   character_count: import_zod12.z.int(),
   embedding_model: import_zod12.z.string(),
   embedding_cost: import_zod12.z.number(),
-  context_summary: import_zod12.z.record(import_zod12.z.string(), import_zod12.z.record(import_zod12.z.string(), import_zod12.z.any())),
+  context_summary: import_zod12.z.object({}),
   created_at: import_zod12.z.iso.datetime(),
   context_metadata: import_zod12.z.record(import_zod12.z.string(), import_zod12.z.any())
 });
@@ -4594,621 +4597,630 @@ var CentrifugoConfigSchema = import_zod30.z.object({
   timeout: import_zod30.z.int().nullable().optional()
 });
 
+// src/cfg/generated/_utils/schemas/CentrifugoHealthCheck.schema.ts
+var import_zod31 = require("zod");
+var CentrifugoHealthCheckSchema = import_zod31.z.object({
+  status: import_zod31.z.string(),
+  wrapper_url: import_zod31.z.string(),
+  has_api_key: import_zod31.z.boolean(),
+  timestamp: import_zod31.z.string()
+});
+
 // src/cfg/generated/_utils/schemas/CentrifugoHistoryRequestRequest.schema.ts
-var import_zod32 = require("zod");
+var import_zod33 = require("zod");
 
 // src/cfg/generated/_utils/schemas/CentrifugoStreamPosition.schema.ts
-var import_zod31 = require("zod");
-var CentrifugoStreamPositionSchema = import_zod31.z.object({
-  offset: import_zod31.z.int(),
-  epoch: import_zod31.z.string()
+var import_zod32 = require("zod");
+var CentrifugoStreamPositionSchema = import_zod32.z.object({
+  offset: import_zod32.z.int(),
+  epoch: import_zod32.z.string()
 });
 
 // src/cfg/generated/_utils/schemas/CentrifugoHistoryRequestRequest.schema.ts
-var CentrifugoHistoryRequestRequestSchema = import_zod32.z.object({
-  channel: import_zod32.z.string(),
-  limit: import_zod32.z.int().nullable().optional(),
+var CentrifugoHistoryRequestRequestSchema = import_zod33.z.object({
+  channel: import_zod33.z.string(),
+  limit: import_zod33.z.int().nullable().optional(),
   since: CentrifugoStreamPositionSchema.optional(),
-  reverse: import_zod32.z.boolean().nullable().optional()
+  reverse: import_zod33.z.boolean().nullable().optional()
 });
 
 // src/cfg/generated/_utils/schemas/CentrifugoHistoryResponse.schema.ts
-var import_zod35 = require("zod");
+var import_zod36 = require("zod");
 
 // src/cfg/generated/_utils/schemas/CentrifugoHistoryResult.schema.ts
-var import_zod34 = require("zod");
+var import_zod35 = require("zod");
 
 // src/cfg/generated/_utils/schemas/CentrifugoPublication.schema.ts
-var import_zod33 = require("zod");
-var CentrifugoPublicationSchema = import_zod33.z.object({
-  data: import_zod33.z.record(import_zod33.z.string(), import_zod33.z.any()),
+var import_zod34 = require("zod");
+var CentrifugoPublicationSchema = import_zod34.z.object({
+  data: import_zod34.z.record(import_zod34.z.string(), import_zod34.z.any()),
   info: CentrifugoClientInfoSchema.optional(),
-  offset: import_zod33.z.int(),
-  tags: import_zod33.z.record(import_zod33.z.string(), import_zod33.z.any()).nullable().optional()
+  offset: import_zod34.z.int(),
+  tags: import_zod34.z.record(import_zod34.z.string(), import_zod34.z.any()).nullable().optional()
 });
 
 // src/cfg/generated/_utils/schemas/CentrifugoHistoryResult.schema.ts
-var CentrifugoHistoryResultSchema = import_zod34.z.object({
-  publications: import_zod34.z.array(CentrifugoPublicationSchema),
-  epoch: import_zod34.z.string(),
-  offset: import_zod34.z.int()
+var CentrifugoHistoryResultSchema = import_zod35.z.object({
+  publications: import_zod35.z.array(CentrifugoPublicationSchema),
+  epoch: import_zod35.z.string(),
+  offset: import_zod35.z.int()
 });
 
 // src/cfg/generated/_utils/schemas/CentrifugoHistoryResponse.schema.ts
-var CentrifugoHistoryResponseSchema = import_zod35.z.object({
+var CentrifugoHistoryResponseSchema = import_zod36.z.object({
   error: CentrifugoErrorSchema.optional(),
   result: CentrifugoHistoryResultSchema.optional()
 });
 
 // src/cfg/generated/_utils/schemas/CentrifugoInfoResponse.schema.ts
-var import_zod40 = require("zod");
+var import_zod41 = require("zod");
 
 // src/cfg/generated/_utils/schemas/CentrifugoInfoResult.schema.ts
-var import_zod39 = require("zod");
+var import_zod40 = require("zod");
 
 // src/cfg/generated/_utils/schemas/CentrifugoNodeInfo.schema.ts
-var import_zod38 = require("zod");
+var import_zod39 = require("zod");
 
 // src/cfg/generated/_utils/schemas/CentrifugoMetrics.schema.ts
-var import_zod36 = require("zod");
-var CentrifugoMetricsSchema = import_zod36.z.object({
-  interval: import_zod36.z.number(),
-  items: import_zod36.z.record(import_zod36.z.string(), import_zod36.z.number())
+var import_zod37 = require("zod");
+var CentrifugoMetricsSchema = import_zod37.z.object({
+  interval: import_zod37.z.number(),
+  items: import_zod37.z.record(import_zod37.z.string(), import_zod37.z.number())
 });
 
 // src/cfg/generated/_utils/schemas/CentrifugoProcess.schema.ts
-var import_zod37 = require("zod");
-var CentrifugoProcessSchema = import_zod37.z.object({
-  cpu: import_zod37.z.number(),
-  rss: import_zod37.z.int()
+var import_zod38 = require("zod");
+var CentrifugoProcessSchema = import_zod38.z.object({
+  cpu: import_zod38.z.number(),
+  rss: import_zod38.z.int()
 });
 
 // src/cfg/generated/_utils/schemas/CentrifugoNodeInfo.schema.ts
-var CentrifugoNodeInfoSchema = import_zod38.z.object({
-  uid: import_zod38.z.string(),
-  name: import_zod38.z.string(),
-  version: import_zod38.z.string(),
-  num_clients: import_zod38.z.int(),
-  num_users: import_zod38.z.int(),
-  num_channels: import_zod38.z.int(),
-  uptime: import_zod38.z.int(),
-  num_subs: import_zod38.z.int(),
+var CentrifugoNodeInfoSchema = import_zod39.z.object({
+  uid: import_zod39.z.string(),
+  name: import_zod39.z.string(),
+  version: import_zod39.z.string(),
+  num_clients: import_zod39.z.int(),
+  num_users: import_zod39.z.int(),
+  num_channels: import_zod39.z.int(),
+  uptime: import_zod39.z.int(),
+  num_subs: import_zod39.z.int(),
   metrics: CentrifugoMetricsSchema.optional(),
   process: CentrifugoProcessSchema.optional()
 });
 
 // src/cfg/generated/_utils/schemas/CentrifugoInfoResult.schema.ts
-var CentrifugoInfoResultSchema = import_zod39.z.object({
-  nodes: import_zod39.z.array(CentrifugoNodeInfoSchema)
+var CentrifugoInfoResultSchema = import_zod40.z.object({
+  nodes: import_zod40.z.array(CentrifugoNodeInfoSchema)
 });
 
 // src/cfg/generated/_utils/schemas/CentrifugoInfoResponse.schema.ts
-var CentrifugoInfoResponseSchema = import_zod40.z.object({
+var CentrifugoInfoResponseSchema = import_zod41.z.object({
   error: CentrifugoErrorSchema.optional(),
   result: CentrifugoInfoResultSchema.optional()
 });
 
 // src/cfg/generated/_utils/schemas/CentrifugoOverviewStats.schema.ts
-var import_zod41 = require("zod");
-var CentrifugoOverviewStatsSchema = import_zod41.z.object({
-  total: import_zod41.z.int(),
-  successful: import_zod41.z.int(),
-  failed: import_zod41.z.int(),
-  timeout: import_zod41.z.int(),
-  success_rate: import_zod41.z.number(),
-  avg_duration_ms: import_zod41.z.number(),
-  avg_acks_received: import_zod41.z.number(),
-  period_hours: import_zod41.z.int()
+var import_zod42 = require("zod");
+var CentrifugoOverviewStatsSchema = import_zod42.z.object({
+  total: import_zod42.z.int(),
+  successful: import_zod42.z.int(),
+  failed: import_zod42.z.int(),
+  timeout: import_zod42.z.int(),
+  success_rate: import_zod42.z.number(),
+  avg_duration_ms: import_zod42.z.number(),
+  avg_acks_received: import_zod42.z.number(),
+  period_hours: import_zod42.z.int()
 });
 
 // src/cfg/generated/_utils/schemas/CentrifugoPresenceRequestRequest.schema.ts
-var import_zod42 = require("zod");
-var CentrifugoPresenceRequestRequestSchema = import_zod42.z.object({
-  channel: import_zod42.z.string()
+var import_zod43 = require("zod");
+var CentrifugoPresenceRequestRequestSchema = import_zod43.z.object({
+  channel: import_zod43.z.string()
 });
 
 // src/cfg/generated/_utils/schemas/CentrifugoPresenceResponse.schema.ts
-var import_zod44 = require("zod");
+var import_zod45 = require("zod");
 
 // src/cfg/generated/_utils/schemas/CentrifugoPresenceResult.schema.ts
-var import_zod43 = require("zod");
-var CentrifugoPresenceResultSchema = import_zod43.z.object({
-  presence: import_zod43.z.record(import_zod43.z.string(), CentrifugoClientInfoSchema)
+var import_zod44 = require("zod");
+var CentrifugoPresenceResultSchema = import_zod44.z.object({
+  presence: import_zod44.z.record(import_zod44.z.string(), CentrifugoClientInfoSchema)
 });
 
 // src/cfg/generated/_utils/schemas/CentrifugoPresenceResponse.schema.ts
-var CentrifugoPresenceResponseSchema = import_zod44.z.object({
+var CentrifugoPresenceResponseSchema = import_zod45.z.object({
   error: CentrifugoErrorSchema.optional(),
   result: CentrifugoPresenceResultSchema.optional()
 });
 
 // src/cfg/generated/_utils/schemas/CentrifugoPresenceStatsRequestRequest.schema.ts
-var import_zod45 = require("zod");
-var CentrifugoPresenceStatsRequestRequestSchema = import_zod45.z.object({
-  channel: import_zod45.z.string()
+var import_zod46 = require("zod");
+var CentrifugoPresenceStatsRequestRequestSchema = import_zod46.z.object({
+  channel: import_zod46.z.string()
 });
 
 // src/cfg/generated/_utils/schemas/CentrifugoPresenceStatsResponse.schema.ts
-var import_zod47 = require("zod");
+var import_zod48 = require("zod");
 
 // src/cfg/generated/_utils/schemas/CentrifugoPresenceStatsResult.schema.ts
-var import_zod46 = require("zod");
-var CentrifugoPresenceStatsResultSchema = import_zod46.z.object({
-  num_clients: import_zod46.z.int(),
-  num_users: import_zod46.z.int()
+var import_zod47 = require("zod");
+var CentrifugoPresenceStatsResultSchema = import_zod47.z.object({
+  num_clients: import_zod47.z.int(),
+  num_users: import_zod47.z.int()
 });
 
 // src/cfg/generated/_utils/schemas/CentrifugoPresenceStatsResponse.schema.ts
-var CentrifugoPresenceStatsResponseSchema = import_zod47.z.object({
+var CentrifugoPresenceStatsResponseSchema = import_zod48.z.object({
   error: CentrifugoErrorSchema.optional(),
   result: CentrifugoPresenceStatsResultSchema.optional()
 });
 
 // src/cfg/generated/_utils/schemas/CentrifugoToken.schema.ts
-var import_zod48 = require("zod");
-var CentrifugoTokenSchema = import_zod48.z.object({
-  token: import_zod48.z.string(),
-  centrifugo_url: import_zod48.z.url(),
-  expires_at: import_zod48.z.iso.datetime(),
-  channels: import_zod48.z.array(import_zod48.z.string())
+var import_zod49 = require("zod");
+var CentrifugoTokenSchema = import_zod49.z.object({
+  token: import_zod49.z.string(),
+  centrifugo_url: import_zod49.z.url(),
+  expires_at: import_zod49.z.iso.datetime(),
+  channels: import_zod49.z.array(import_zod49.z.string())
 });
 
 // src/cfg/generated/_utils/schemas/ChannelList.schema.ts
-var import_zod50 = require("zod");
+var import_zod51 = require("zod");
 
 // src/cfg/generated/_utils/schemas/ChannelStats.schema.ts
-var import_zod49 = require("zod");
-var ChannelStatsSchema = import_zod49.z.object({
-  channel: import_zod49.z.string(),
-  total: import_zod49.z.int(),
-  successful: import_zod49.z.int(),
-  failed: import_zod49.z.int(),
-  avg_duration_ms: import_zod49.z.number(),
-  avg_acks: import_zod49.z.number(),
-  last_activity_at: import_zod49.z.string().nullable()
+var import_zod50 = require("zod");
+var ChannelStatsSchema = import_zod50.z.object({
+  channel: import_zod50.z.string(),
+  total: import_zod50.z.int(),
+  successful: import_zod50.z.int(),
+  failed: import_zod50.z.int(),
+  avg_duration_ms: import_zod50.z.number(),
+  avg_acks: import_zod50.z.number(),
+  last_activity_at: import_zod50.z.string().nullable()
 });
 
 // src/cfg/generated/_utils/schemas/ChannelList.schema.ts
-var ChannelListSchema = import_zod50.z.object({
-  channels: import_zod50.z.array(ChannelStatsSchema),
-  total_channels: import_zod50.z.int()
+var ChannelListSchema = import_zod51.z.object({
+  channels: import_zod51.z.array(ChannelStatsSchema),
+  total_channels: import_zod51.z.int()
 });
 
 // src/cfg/generated/_utils/schemas/ChartData.schema.ts
-var import_zod52 = require("zod");
+var import_zod53 = require("zod");
 
 // src/cfg/generated/_utils/schemas/ChartDataset.schema.ts
-var import_zod51 = require("zod");
-var ChartDatasetSchema = import_zod51.z.object({
-  label: import_zod51.z.string(),
-  data: import_zod51.z.array(import_zod51.z.int()),
-  backgroundColor: import_zod51.z.string(),
-  borderColor: import_zod51.z.string(),
-  tension: import_zod51.z.number(),
-  fill: import_zod51.z.boolean().optional()
+var import_zod52 = require("zod");
+var ChartDatasetSchema = import_zod52.z.object({
+  label: import_zod52.z.string(),
+  data: import_zod52.z.array(import_zod52.z.int()),
+  backgroundColor: import_zod52.z.string(),
+  borderColor: import_zod52.z.string(),
+  tension: import_zod52.z.number(),
+  fill: import_zod52.z.boolean().optional()
 });
 
 // src/cfg/generated/_utils/schemas/ChartData.schema.ts
-var ChartDataSchema = import_zod52.z.object({
-  labels: import_zod52.z.array(import_zod52.z.string()),
-  datasets: import_zod52.z.array(ChartDatasetSchema)
+var ChartDataSchema = import_zod53.z.object({
+  labels: import_zod53.z.array(import_zod53.z.string()),
+  datasets: import_zod53.z.array(ChartDatasetSchema)
 });
 
 // src/cfg/generated/_utils/schemas/ChatHistory.schema.ts
-var import_zod54 = require("zod");
+var import_zod55 = require("zod");
 
 // src/cfg/generated/_utils/schemas/ChatMessage.schema.ts
-var import_zod53 = require("zod");
-var ChatMessageSchema = import_zod53.z.object({
-  id: import_zod53.z.uuid(),
-  role: import_zod53.z.nativeEnum(ChatMessageRole),
-  content: import_zod53.z.string(),
-  tokens_used: import_zod53.z.int().min(0).max(2147483647).optional(),
-  cost_usd: import_zod53.z.number(),
-  processing_time_ms: import_zod53.z.int().min(0).max(2147483647).optional(),
-  created_at: import_zod53.z.iso.datetime(),
-  context_chunks: import_zod53.z.record(import_zod53.z.string(), import_zod53.z.any()).optional()
+var import_zod54 = require("zod");
+var ChatMessageSchema = import_zod54.z.object({
+  id: import_zod54.z.uuid(),
+  role: import_zod54.z.nativeEnum(ChatMessageRole),
+  content: import_zod54.z.string(),
+  tokens_used: import_zod54.z.int().min(0).max(2147483647).optional(),
+  cost_usd: import_zod54.z.number(),
+  processing_time_ms: import_zod54.z.int().min(0).max(2147483647).optional(),
+  created_at: import_zod54.z.iso.datetime(),
+  context_chunks: import_zod54.z.record(import_zod54.z.string(), import_zod54.z.any()).optional()
 });
 
 // src/cfg/generated/_utils/schemas/ChatHistory.schema.ts
-var ChatHistorySchema = import_zod54.z.object({
-  session_id: import_zod54.z.uuid(),
-  messages: import_zod54.z.array(ChatMessageSchema),
-  total_messages: import_zod54.z.int()
+var ChatHistorySchema = import_zod55.z.object({
+  session_id: import_zod55.z.uuid(),
+  messages: import_zod55.z.array(ChatMessageSchema),
+  total_messages: import_zod55.z.int()
 });
 
 // src/cfg/generated/_utils/schemas/ChatQueryRequest.schema.ts
-var import_zod55 = require("zod");
-var ChatQueryRequestSchema = import_zod55.z.object({
-  session_id: import_zod55.z.uuid().nullable().optional(),
-  query: import_zod55.z.string().min(1).max(2e3),
-  max_tokens: import_zod55.z.int().min(1).max(4e3).optional(),
-  include_sources: import_zod55.z.boolean().optional()
+var import_zod56 = require("zod");
+var ChatQueryRequestSchema = import_zod56.z.object({
+  session_id: import_zod56.z.uuid().nullable().optional(),
+  query: import_zod56.z.string().min(1).max(2e3),
+  max_tokens: import_zod56.z.int().min(1).max(4e3).optional(),
+  include_sources: import_zod56.z.boolean().optional()
 });
 
 // src/cfg/generated/_utils/schemas/ChatResponse.schema.ts
-var import_zod57 = require("zod");
+var import_zod58 = require("zod");
 
 // src/cfg/generated/_utils/schemas/ChatSource.schema.ts
-var import_zod56 = require("zod");
-var ChatSourceSchema = import_zod56.z.object({
-  document_title: import_zod56.z.string(),
-  chunk_content: import_zod56.z.string(),
-  similarity: import_zod56.z.number()
+var import_zod57 = require("zod");
+var ChatSourceSchema = import_zod57.z.object({
+  document_title: import_zod57.z.string(),
+  chunk_content: import_zod57.z.string(),
+  similarity: import_zod57.z.number()
 });
 
 // src/cfg/generated/_utils/schemas/ChatResponse.schema.ts
-var ChatResponseSchema = import_zod57.z.object({
-  message_id: import_zod57.z.uuid(),
-  content: import_zod57.z.string(),
-  tokens_used: import_zod57.z.int(),
-  cost_usd: import_zod57.z.number(),
-  processing_time_ms: import_zod57.z.int(),
-  model_used: import_zod57.z.string(),
-  sources: import_zod57.z.array(ChatSourceSchema).nullable().optional()
+var ChatResponseSchema = import_zod58.z.object({
+  message_id: import_zod58.z.uuid(),
+  content: import_zod58.z.string(),
+  tokens_used: import_zod58.z.int(),
+  cost_usd: import_zod58.z.number(),
+  processing_time_ms: import_zod58.z.int(),
+  model_used: import_zod58.z.string(),
+  sources: import_zod58.z.array(ChatSourceSchema).nullable().optional()
 });
 
 // src/cfg/generated/_utils/schemas/ChatResponseRequest.schema.ts
-var import_zod59 = require("zod");
+var import_zod60 = require("zod");
 
 // src/cfg/generated/_utils/schemas/ChatSourceRequest.schema.ts
-var import_zod58 = require("zod");
-var ChatSourceRequestSchema = import_zod58.z.object({
-  document_title: import_zod58.z.string().min(1),
-  chunk_content: import_zod58.z.string().min(1),
-  similarity: import_zod58.z.number()
+var import_zod59 = require("zod");
+var ChatSourceRequestSchema = import_zod59.z.object({
+  document_title: import_zod59.z.string().min(1),
+  chunk_content: import_zod59.z.string().min(1),
+  similarity: import_zod59.z.number()
 });
 
 // src/cfg/generated/_utils/schemas/ChatResponseRequest.schema.ts
-var ChatResponseRequestSchema = import_zod59.z.object({
-  message_id: import_zod59.z.uuid(),
-  content: import_zod59.z.string().min(1),
-  tokens_used: import_zod59.z.int(),
-  cost_usd: import_zod59.z.number(),
-  processing_time_ms: import_zod59.z.int(),
-  model_used: import_zod59.z.string().min(1),
-  sources: import_zod59.z.array(ChatSourceRequestSchema).nullable().optional()
+var ChatResponseRequestSchema = import_zod60.z.object({
+  message_id: import_zod60.z.uuid(),
+  content: import_zod60.z.string().min(1),
+  tokens_used: import_zod60.z.int(),
+  cost_usd: import_zod60.z.number(),
+  processing_time_ms: import_zod60.z.int(),
+  model_used: import_zod60.z.string().min(1),
+  sources: import_zod60.z.array(ChatSourceRequestSchema).nullable().optional()
 });
 
 // src/cfg/generated/_utils/schemas/ChatSession.schema.ts
-var import_zod60 = require("zod");
-var ChatSessionSchema = import_zod60.z.object({
-  id: import_zod60.z.uuid(),
-  title: import_zod60.z.string().max(255).optional(),
-  is_active: import_zod60.z.boolean().optional(),
-  messages_count: import_zod60.z.int().min(0).max(2147483647).optional(),
-  total_tokens_used: import_zod60.z.int().min(0).max(2147483647).optional(),
-  total_cost_usd: import_zod60.z.number(),
-  model_name: import_zod60.z.string().max(100).optional(),
-  temperature: import_zod60.z.number().optional(),
-  max_context_chunks: import_zod60.z.int().min(0).max(2147483647).optional(),
-  created_at: import_zod60.z.iso.datetime(),
-  updated_at: import_zod60.z.iso.datetime()
-});
-
-// src/cfg/generated/_utils/schemas/ChatSessionCreateRequest.schema.ts
 var import_zod61 = require("zod");
-var ChatSessionCreateRequestSchema = import_zod61.z.object({
+var ChatSessionSchema = import_zod61.z.object({
+  id: import_zod61.z.uuid(),
   title: import_zod61.z.string().max(255).optional(),
-  model_name: import_zod61.z.string().min(1).max(100).optional(),
-  temperature: import_zod61.z.number().min(0).max(2).optional(),
-  max_context_chunks: import_zod61.z.int().min(1).max(10).optional()
+  is_active: import_zod61.z.boolean().optional(),
+  messages_count: import_zod61.z.int().min(0).max(2147483647).optional(),
+  total_tokens_used: import_zod61.z.int().min(0).max(2147483647).optional(),
+  total_cost_usd: import_zod61.z.number(),
+  model_name: import_zod61.z.string().max(100).optional(),
+  temperature: import_zod61.z.number().optional(),
+  max_context_chunks: import_zod61.z.int().min(0).max(2147483647).optional(),
+  created_at: import_zod61.z.iso.datetime(),
+  updated_at: import_zod61.z.iso.datetime()
 });
 
-// src/cfg/generated/_utils/schemas/ChatSessionRequest.schema.ts
+// src/cfg/generated/_utils/schemas/ChatSessionCreateRequest.schema.ts
 var import_zod62 = require("zod");
-var ChatSessionRequestSchema = import_zod62.z.object({
+var ChatSessionCreateRequestSchema = import_zod62.z.object({
   title: import_zod62.z.string().max(255).optional(),
-  is_active: import_zod62.z.boolean().optional(),
-  messages_count: import_zod62.z.int().min(0).max(2147483647).optional(),
-  total_tokens_used: import_zod62.z.int().min(0).max(2147483647).optional(),
   model_name: import_zod62.z.string().min(1).max(100).optional(),
-  temperature: import_zod62.z.number().optional(),
-  max_context_chunks: import_zod62.z.int().min(0).max(2147483647).optional()
+  temperature: import_zod62.z.number().min(0).max(2).optional(),
+  max_context_chunks: import_zod62.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_zod63 = require("zod");
-var ChunkRevectorizationRequestRequestSchema = import_zod63.z.object({
-  chunk_ids: import_zod63.z.array(import_zod63.z.uuid()),
-  force: import_zod63.z.boolean().optional()
+var ChatSessionRequestSchema = import_zod63.z.object({
+  title: import_zod63.z.string().max(255).optional(),
+  is_active: import_zod63.z.boolean().optional(),
+  messages_count: import_zod63.z.int().min(0).max(2147483647).optional(),
+  total_tokens_used: import_zod63.z.int().min(0).max(2147483647).optional(),
+  model_name: import_zod63.z.string().min(1).max(100).optional(),
+  temperature: import_zod63.z.number().optional(),
+  max_context_chunks: import_zod63.z.int().min(0).max(2147483647).optional()
 });
 
-// src/cfg/generated/_utils/schemas/Command.schema.ts
+// src/cfg/generated/_utils/schemas/ChunkRevectorizationRequestRequest.schema.ts
 var import_zod64 = require("zod");
-var CommandSchema = import_zod64.z.object({
-  name: import_zod64.z.string(),
-  app: import_zod64.z.string(),
-  help: import_zod64.z.string(),
-  is_core: import_zod64.z.boolean(),
-  is_custom: import_zod64.z.boolean(),
-  is_allowed: import_zod64.z.boolean().optional(),
-  risk_level: import_zod64.z.string().optional(),
-  web_executable: import_zod64.z.boolean().nullable().optional(),
-  requires_input: import_zod64.z.boolean().nullable().optional(),
-  is_destructive: import_zod64.z.boolean().nullable().optional()
+var ChunkRevectorizationRequestRequestSchema = import_zod64.z.object({
+  chunk_ids: import_zod64.z.array(import_zod64.z.uuid()),
+  force: import_zod64.z.boolean().optional()
 });
 
-// src/cfg/generated/_utils/schemas/CommandCategory.schema.ts
+// src/cfg/generated/_utils/schemas/Command.schema.ts
 var import_zod65 = require("zod");
-var CommandCategorySchema = import_zod65.z.object({
-  category: import_zod65.z.string(),
-  commands: import_zod65.z.array(CommandSchema)
+var CommandSchema = import_zod65.z.object({
+  name: import_zod65.z.string(),
+  app: import_zod65.z.string(),
+  help: import_zod65.z.string(),
+  is_core: import_zod65.z.boolean(),
+  is_custom: import_zod65.z.boolean(),
+  is_allowed: import_zod65.z.boolean().optional(),
+  risk_level: import_zod65.z.string().optional(),
+  web_executable: import_zod65.z.boolean().nullable().optional(),
+  requires_input: import_zod65.z.boolean().nullable().optional(),
+  is_destructive: import_zod65.z.boolean().nullable().optional()
 });
 
-// src/cfg/generated/_utils/schemas/CommandExecuteRequestRequest.schema.ts
+// src/cfg/generated/_utils/schemas/CommandCategory.schema.ts
 var import_zod66 = require("zod");
-var CommandExecuteRequestRequestSchema = import_zod66.z.object({
-  command: import_zod66.z.string().min(1),
-  args: import_zod66.z.array(import_zod66.z.string().min(1)).optional(),
-  options: import_zod66.z.record(import_zod66.z.string(), import_zod66.z.record(import_zod66.z.string(), import_zod66.z.any())).optional()
+var CommandCategorySchema = import_zod66.z.object({
+  category: import_zod66.z.string(),
+  commands: import_zod66.z.array(CommandSchema)
 });
 
-// src/cfg/generated/_utils/schemas/CommandHelpResponse.schema.ts
+// src/cfg/generated/_utils/schemas/CommandExecuteRequestRequest.schema.ts
 var import_zod67 = require("zod");
-var CommandHelpResponseSchema = import_zod67.z.object({
-  status: import_zod67.z.string(),
-  command: import_zod67.z.string(),
-  app: import_zod67.z.string().optional(),
-  help_text: import_zod67.z.string().optional(),
-  is_allowed: import_zod67.z.boolean().optional(),
-  risk_level: import_zod67.z.string().optional(),
-  error: import_zod67.z.string().optional()
+var CommandExecuteRequestRequestSchema = import_zod67.z.object({
+  command: import_zod67.z.string().min(1),
+  args: import_zod67.z.array(import_zod67.z.string().min(1)).optional(),
+  options: import_zod67.z.record(import_zod67.z.string(), import_zod67.z.record(import_zod67.z.string(), import_zod67.z.any())).optional()
 });
 
-// src/cfg/generated/_utils/schemas/CommandsSummary.schema.ts
+// src/cfg/generated/_utils/schemas/CommandHelpResponse.schema.ts
 var import_zod68 = require("zod");
-var CommandsSummarySchema = import_zod68.z.object({
-  total_commands: import_zod68.z.int(),
-  core_commands: import_zod68.z.int(),
-  custom_commands: import_zod68.z.int(),
-  categories: import_zod68.z.array(import_zod68.z.string()),
-  commands: import_zod68.z.array(CommandSchema),
-  categorized: import_zod68.z.array(CommandCategorySchema)
+var CommandHelpResponseSchema = import_zod68.z.object({
+  status: import_zod68.z.string(),
+  command: import_zod68.z.string(),
+  app: import_zod68.z.string().optional(),
+  help_text: import_zod68.z.string().optional(),
+  is_allowed: import_zod68.z.boolean().optional(),
+  risk_level: import_zod68.z.string().optional(),
+  error: import_zod68.z.string().optional()
+});
+
+// src/cfg/generated/_utils/schemas/CommandsSummary.schema.ts
+var import_zod69 = require("zod");
+var CommandsSummarySchema = import_zod69.z.object({
+  total_commands: import_zod69.z.int(),
+  core_commands: import_zod69.z.int(),
+  custom_commands: import_zod69.z.int(),
+  categories: import_zod69.z.array(import_zod69.z.string()),
+  commands: import_zod69.z.array(CommandSchema),
+  categorized: import_zod69.z.array(CommandCategorySchema)
 });
 
 // src/cfg/generated/_utils/schemas/ConfigData.schema.ts
-var import_zod88 = require("zod");
+var import_zod89 = require("zod");
 
 // src/cfg/generated/_utils/schemas/ConfigValidation.schema.ts
-var import_zod69 = require("zod");
-var ConfigValidationSchema = import_zod69.z.object({
-  status: import_zod69.z.string(),
-  missing_in_serializer: import_zod69.z.array(import_zod69.z.string()),
-  extra_in_serializer: import_zod69.z.array(import_zod69.z.string()),
-  type_mismatches: import_zod69.z.array(import_zod69.z.record(import_zod69.z.string(), import_zod69.z.any())),
-  total_config_fields: import_zod69.z.int(),
-  total_serializer_fields: import_zod69.z.int()
+var import_zod70 = require("zod");
+var ConfigValidationSchema = import_zod70.z.object({
+  status: import_zod70.z.string(),
+  missing_in_serializer: import_zod70.z.array(import_zod70.z.string()),
+  extra_in_serializer: import_zod70.z.array(import_zod70.z.string()),
+  type_mismatches: import_zod70.z.array(import_zod70.z.record(import_zod70.z.string(), import_zod70.z.any())),
+  total_config_fields: import_zod70.z.int(),
+  total_serializer_fields: import_zod70.z.int()
 });
 
 // src/cfg/generated/_utils/schemas/DjangoConfig.schema.ts
-var import_zod87 = require("zod");
+var import_zod88 = require("zod");
 
 // src/cfg/generated/_utils/schemas/ConfigMeta.schema.ts
-var import_zod70 = require("zod");
-var ConfigMetaSchema = import_zod70.z.object({
-  config_class: import_zod70.z.string(),
-  secret_key_configured: import_zod70.z.boolean()
+var import_zod71 = require("zod");
+var ConfigMetaSchema = import_zod71.z.object({
+  config_class: import_zod71.z.string(),
+  secret_key_configured: import_zod71.z.boolean()
 });
 
 // src/cfg/generated/_utils/schemas/ConstanceConfig.schema.ts
-var import_zod71 = require("zod");
-var ConstanceConfigSchema = import_zod71.z.object({
-  config: import_zod71.z.record(import_zod71.z.string(), import_zod71.z.any()).nullable().optional(),
-  config_fieldsets: import_zod71.z.record(import_zod71.z.string(), import_zod71.z.any()).nullable().optional(),
-  backend: import_zod71.z.string().nullable().optional(),
-  database_prefix: import_zod71.z.string().nullable().optional(),
-  database_cache_backend: import_zod71.z.string().nullable().optional(),
-  additional_config: import_zod71.z.record(import_zod71.z.string(), import_zod71.z.any()).nullable().optional()
+var import_zod72 = require("zod");
+var ConstanceConfigSchema = import_zod72.z.object({
+  config: import_zod72.z.record(import_zod72.z.string(), import_zod72.z.any()).nullable().optional(),
+  config_fieldsets: import_zod72.z.record(import_zod72.z.string(), import_zod72.z.any()).nullable().optional(),
+  backend: import_zod72.z.string().nullable().optional(),
+  database_prefix: import_zod72.z.string().nullable().optional(),
+  database_cache_backend: import_zod72.z.string().nullable().optional(),
+  additional_config: import_zod72.z.record(import_zod72.z.string(), import_zod72.z.any()).nullable().optional()
 });
 
 // src/cfg/generated/_utils/schemas/DRFConfig.schema.ts
-var import_zod72 = require("zod");
-var DRFConfigSchema = import_zod72.z.object({
-  default_pagination_class: import_zod72.z.string().nullable().optional(),
-  page_size: import_zod72.z.int().nullable().optional()
+var import_zod73 = require("zod");
+var DRFConfigSchema = import_zod73.z.object({
+  default_pagination_class: import_zod73.z.string().nullable().optional(),
+  page_size: import_zod73.z.int().nullable().optional()
 });
 
 // src/cfg/generated/_utils/schemas/DatabaseConfig.schema.ts
-var import_zod73 = require("zod");
-var DatabaseConfigSchema = import_zod73.z.object({
-  engine: import_zod73.z.string(),
-  name: import_zod73.z.string(),
-  user: import_zod73.z.string().nullable().optional(),
-  password: import_zod73.z.string().nullable().optional(),
-  host: import_zod73.z.string().nullable().optional(),
-  port: import_zod73.z.int().nullable().optional(),
-  connect_timeout: import_zod73.z.int().nullable().optional(),
-  sslmode: import_zod73.z.string().nullable().optional(),
-  options: import_zod73.z.record(import_zod73.z.string(), import_zod73.z.any()).nullable().optional(),
-  apps: import_zod73.z.array(import_zod73.z.string()).nullable().optional(),
-  operations: import_zod73.z.array(import_zod73.z.string()).nullable().optional(),
-  migrate_to: import_zod73.z.string().nullable().optional(),
-  routing_description: import_zod73.z.string().nullable().optional()
+var import_zod74 = require("zod");
+var DatabaseConfigSchema = import_zod74.z.object({
+  engine: import_zod74.z.string(),
+  name: import_zod74.z.string(),
+  user: import_zod74.z.string().nullable().optional(),
+  password: import_zod74.z.string().nullable().optional(),
+  host: import_zod74.z.string().nullable().optional(),
+  port: import_zod74.z.int().nullable().optional(),
+  connect_timeout: import_zod74.z.int().nullable().optional(),
+  sslmode: import_zod74.z.string().nullable().optional(),
+  options: import_zod74.z.record(import_zod74.z.string(), import_zod74.z.any()).nullable().optional(),
+  apps: import_zod74.z.array(import_zod74.z.string()).nullable().optional(),
+  operations: import_zod74.z.array(import_zod74.z.string()).nullable().optional(),
+  migrate_to: import_zod74.z.string().nullable().optional(),
+  routing_description: import_zod74.z.string().nullable().optional()
 });
 
 // src/cfg/generated/_utils/schemas/DjangoRQConfig.schema.ts
-var import_zod76 = require("zod");
+var import_zod77 = require("zod");
 
 // src/cfg/generated/_utils/schemas/RQSchedule.schema.ts
-var import_zod74 = require("zod");
-var RQScheduleSchema = import_zod74.z.object({
-  func: import_zod74.z.string().nullable().optional(),
-  cron_string: import_zod74.z.string().nullable().optional(),
-  queue: import_zod74.z.string().nullable().optional(),
-  kwargs: import_zod74.z.record(import_zod74.z.string(), import_zod74.z.any()).nullable().optional(),
-  args: import_zod74.z.array(import_zod74.z.record(import_zod74.z.string(), import_zod74.z.any())).nullable().optional(),
-  meta: import_zod74.z.record(import_zod74.z.string(), import_zod74.z.any()).nullable().optional(),
-  repeat: import_zod74.z.int().nullable().optional(),
-  result_ttl: import_zod74.z.int().nullable().optional()
+var import_zod75 = require("zod");
+var RQScheduleSchema = import_zod75.z.object({
+  func: import_zod75.z.string().nullable().optional(),
+  cron_string: import_zod75.z.string().nullable().optional(),
+  queue: import_zod75.z.string().nullable().optional(),
+  kwargs: import_zod75.z.record(import_zod75.z.string(), import_zod75.z.any()).nullable().optional(),
+  args: import_zod75.z.array(import_zod75.z.record(import_zod75.z.string(), import_zod75.z.any())).nullable().optional(),
+  meta: import_zod75.z.record(import_zod75.z.string(), import_zod75.z.any()).nullable().optional(),
+  repeat: import_zod75.z.int().nullable().optional(),
+  result_ttl: import_zod75.z.int().nullable().optional()
 });
 
 // src/cfg/generated/_utils/schemas/RedisQueueConfig.schema.ts
-var import_zod75 = require("zod");
-var RedisQueueConfigSchema = import_zod75.z.object({
-  url: import_zod75.z.string().nullable().optional(),
-  host: import_zod75.z.string().nullable().optional(),
-  port: import_zod75.z.int().nullable().optional(),
-  db: import_zod75.z.int().nullable().optional(),
-  username: import_zod75.z.string().nullable().optional(),
-  password: import_zod75.z.string().nullable().optional(),
-  default_timeout: import_zod75.z.int().nullable().optional(),
-  default_result_ttl: import_zod75.z.int().nullable().optional(),
-  sentinels: import_zod75.z.record(import_zod75.z.string(), import_zod75.z.any()).nullable().optional(),
-  master_name: import_zod75.z.string().nullable().optional(),
-  socket_timeout: import_zod75.z.int().nullable().optional()
+var import_zod76 = require("zod");
+var RedisQueueConfigSchema = import_zod76.z.object({
+  url: import_zod76.z.string().nullable().optional(),
+  host: import_zod76.z.string().nullable().optional(),
+  port: import_zod76.z.int().nullable().optional(),
+  db: import_zod76.z.int().nullable().optional(),
+  username: import_zod76.z.string().nullable().optional(),
+  password: import_zod76.z.string().nullable().optional(),
+  default_timeout: import_zod76.z.int().nullable().optional(),
+  default_result_ttl: import_zod76.z.int().nullable().optional(),
+  sentinels: import_zod76.z.record(import_zod76.z.string(), import_zod76.z.any()).nullable().optional(),
+  master_name: import_zod76.z.string().nullable().optional(),
+  socket_timeout: import_zod76.z.int().nullable().optional()
 });
 
 // src/cfg/generated/_utils/schemas/DjangoRQConfig.schema.ts
-var DjangoRQConfigSchema = import_zod76.z.object({
-  enabled: import_zod76.z.boolean().nullable().optional(),
-  queues: import_zod76.z.array(RedisQueueConfigSchema).nullable().optional(),
-  show_admin_link: import_zod76.z.boolean().nullable().optional(),
-  exception_handlers: import_zod76.z.array(import_zod76.z.string()).nullable().optional(),
-  api_token: import_zod76.z.string().nullable().optional(),
-  prometheus_enabled: import_zod76.z.boolean().nullable().optional(),
-  schedules: import_zod76.z.array(RQScheduleSchema).nullable().optional()
+var DjangoRQConfigSchema = import_zod77.z.object({
+  enabled: import_zod77.z.boolean().nullable().optional(),
+  queues: import_zod77.z.array(RedisQueueConfigSchema).nullable().optional(),
+  show_admin_link: import_zod77.z.boolean().nullable().optional(),
+  exception_handlers: import_zod77.z.array(import_zod77.z.string()).nullable().optional(),
+  api_token: import_zod77.z.string().nullable().optional(),
+  prometheus_enabled: import_zod77.z.boolean().nullable().optional(),
+  schedules: import_zod77.z.array(RQScheduleSchema).nullable().optional()
 });
 
 // src/cfg/generated/_utils/schemas/EmailConfig.schema.ts
-var import_zod77 = require("zod");
-var EmailConfigSchema = import_zod77.z.object({
-  backend: import_zod77.z.string().nullable().optional(),
-  host: import_zod77.z.string().nullable().optional(),
-  port: import_zod77.z.int().nullable().optional(),
-  username: import_zod77.z.string().nullable().optional(),
-  password: import_zod77.z.string().nullable().optional(),
-  use_tls: import_zod77.z.boolean().nullable().optional(),
-  use_ssl: import_zod77.z.boolean().nullable().optional(),
-  ssl_verify: import_zod77.z.boolean().nullable().optional(),
-  timeout: import_zod77.z.int().nullable().optional(),
-  default_from: import_zod77.z.string().nullable().optional()
-});
-
-// src/cfg/generated/_utils/schemas/GRPCConfigDashboard.schema.ts
 var import_zod78 = require("zod");
-var GRPCConfigDashboardSchema = import_zod78.z.object({
-  enabled: import_zod78.z.boolean().nullable().optional(),
+var EmailConfigSchema = import_zod78.z.object({
+  backend: import_zod78.z.string().nullable().optional(),
   host: import_zod78.z.string().nullable().optional(),
   port: import_zod78.z.int().nullable().optional(),
-  max_workers: import_zod78.z.int().nullable().optional(),
-  reflection: import_zod78.z.boolean().nullable().optional(),
-  health_check: import_zod78.z.boolean().nullable().optional(),
-  interceptors: import_zod78.z.array(import_zod78.z.string()).nullable().optional()
+  username: import_zod78.z.string().nullable().optional(),
+  password: import_zod78.z.string().nullable().optional(),
+  use_tls: import_zod78.z.boolean().nullable().optional(),
+  use_ssl: import_zod78.z.boolean().nullable().optional(),
+  ssl_verify: import_zod78.z.boolean().nullable().optional(),
+  timeout: import_zod78.z.int().nullable().optional(),
+  default_from: import_zod78.z.string().nullable().optional()
 });
 
-// src/cfg/generated/_utils/schemas/JWTConfig.schema.ts
+// src/cfg/generated/_utils/schemas/GRPCConfigDashboard.schema.ts
 var import_zod79 = require("zod");
-var JWTConfigSchema = import_zod79.z.object({
-  access_token_lifetime: import_zod79.z.int().nullable().optional(),
-  refresh_token_lifetime: import_zod79.z.int().nullable().optional(),
-  algorithm: import_zod79.z.string().nullable().optional()
+var GRPCConfigDashboardSchema = import_zod79.z.object({
+  enabled: import_zod79.z.boolean().nullable().optional(),
+  host: import_zod79.z.string().nullable().optional(),
+  port: import_zod79.z.int().nullable().optional(),
+  max_workers: import_zod79.z.int().nullable().optional(),
+  reflection: import_zod79.z.boolean().nullable().optional(),
+  health_check: import_zod79.z.boolean().nullable().optional(),
+  interceptors: import_zod79.z.array(import_zod79.z.string()).nullable().optional()
 });
 
-// src/cfg/generated/_utils/schemas/NextJSAdminConfig.schema.ts
+// src/cfg/generated/_utils/schemas/JWTConfig.schema.ts
 var import_zod80 = require("zod");
-var NextJSAdminConfigSchema = import_zod80.z.object({
-  enabled: import_zod80.z.boolean().nullable().optional(),
-  url: import_zod80.z.string().nullable().optional(),
-  api_base_url: import_zod80.z.string().nullable().optional()
+var JWTConfigSchema = import_zod80.z.object({
+  access_token_lifetime: import_zod80.z.int().nullable().optional(),
+  refresh_token_lifetime: import_zod80.z.int().nullable().optional(),
+  algorithm: import_zod80.z.string().nullable().optional()
 });
 
-// src/cfg/generated/_utils/schemas/NgrokConfig.schema.ts
+// src/cfg/generated/_utils/schemas/NextJSAdminConfig.schema.ts
 var import_zod81 = require("zod");
-var NgrokConfigSchema = import_zod81.z.object({
+var NextJSAdminConfigSchema = import_zod81.z.object({
   enabled: import_zod81.z.boolean().nullable().optional(),
-  authtoken: import_zod81.z.string().nullable().optional(),
-  basic_auth: import_zod81.z.array(import_zod81.z.string()).nullable().optional(),
-  compression: import_zod81.z.boolean().nullable().optional()
+  url: import_zod81.z.string().nullable().optional(),
+  api_base_url: import_zod81.z.string().nullable().optional()
 });
 
-// src/cfg/generated/_utils/schemas/OpenAPIClientConfig.schema.ts
+// src/cfg/generated/_utils/schemas/NgrokConfig.schema.ts
 var import_zod82 = require("zod");
-var OpenAPIClientConfigSchema = import_zod82.z.object({
+var NgrokConfigSchema = import_zod82.z.object({
   enabled: import_zod82.z.boolean().nullable().optional(),
-  output_dir: import_zod82.z.string().nullable().optional(),
-  client_name: import_zod82.z.string().nullable().optional(),
-  schema_url: import_zod82.z.string().nullable().optional(),
-  generator: import_zod82.z.string().nullable().optional(),
-  additional_properties: import_zod82.z.record(import_zod82.z.string(), import_zod82.z.any()).nullable().optional(),
-  templates: import_zod82.z.array(import_zod82.z.string()).nullable().optional(),
-  global_properties: import_zod82.z.record(import_zod82.z.string(), import_zod82.z.any()).nullable().optional()
+  authtoken: import_zod82.z.string().nullable().optional(),
+  basic_auth: import_zod82.z.array(import_zod82.z.string()).nullable().optional(),
+  compression: import_zod82.z.boolean().nullable().optional()
+});
+
+// src/cfg/generated/_utils/schemas/OpenAPIClientConfig.schema.ts
+var import_zod83 = require("zod");
+var OpenAPIClientConfigSchema = import_zod83.z.object({
+  enabled: import_zod83.z.boolean().nullable().optional(),
+  output_dir: import_zod83.z.string().nullable().optional(),
+  client_name: import_zod83.z.string().nullable().optional(),
+  schema_url: import_zod83.z.string().nullable().optional(),
+  generator: import_zod83.z.string().nullable().optional(),
+  additional_properties: import_zod83.z.record(import_zod83.z.string(), import_zod83.z.any()).nullable().optional(),
+  templates: import_zod83.z.array(import_zod83.z.string()).nullable().optional(),
+  global_properties: import_zod83.z.record(import_zod83.z.string(), import_zod83.z.any()).nullable().optional()
 });
 
 // src/cfg/generated/_utils/schemas/PaymentsConfig.schema.ts
-var import_zod84 = require("zod");
+var import_zod85 = require("zod");
 
 // src/cfg/generated/_utils/schemas/PaymentsNowPayments.schema.ts
-var import_zod83 = require("zod");
-var PaymentsNowPaymentsSchema = import_zod83.z.object({
-  api_key: import_zod83.z.string().nullable().optional(),
-  ipn_secret: import_zod83.z.string().nullable().optional(),
-  sandbox: import_zod83.z.boolean().nullable().optional(),
-  enabled: import_zod83.z.boolean().nullable().optional()
+var import_zod84 = require("zod");
+var PaymentsNowPaymentsSchema = import_zod84.z.object({
+  api_key: import_zod84.z.string().nullable().optional(),
+  ipn_secret: import_zod84.z.string().nullable().optional(),
+  sandbox: import_zod84.z.boolean().nullable().optional(),
+  enabled: import_zod84.z.boolean().nullable().optional()
 });
 
 // src/cfg/generated/_utils/schemas/PaymentsConfig.schema.ts
-var PaymentsConfigSchema = import_zod84.z.object({
-  enabled: import_zod84.z.boolean().nullable().optional(),
+var PaymentsConfigSchema = import_zod85.z.object({
+  enabled: import_zod85.z.boolean().nullable().optional(),
   nowpayments: PaymentsNowPaymentsSchema.nullable().optional()
 });
 
 // src/cfg/generated/_utils/schemas/SpectacularConfig.schema.ts
-var import_zod85 = require("zod");
-var SpectacularConfigSchema = import_zod85.z.object({
-  title: import_zod85.z.string().nullable().optional(),
-  description: import_zod85.z.string().nullable().optional(),
-  version: import_zod85.z.string().nullable().optional()
+var import_zod86 = require("zod");
+var SpectacularConfigSchema = import_zod86.z.object({
+  title: import_zod86.z.string().nullable().optional(),
+  description: import_zod86.z.string().nullable().optional(),
+  version: import_zod86.z.string().nullable().optional()
 });
 
 // src/cfg/generated/_utils/schemas/TelegramConfig.schema.ts
-var import_zod86 = require("zod");
-var TelegramConfigSchema = import_zod86.z.object({
-  bot_token: import_zod86.z.string().nullable().optional(),
-  chat_id: import_zod86.z.int().nullable().optional(),
-  parse_mode: import_zod86.z.string().nullable().optional(),
-  disable_notification: import_zod86.z.boolean().nullable().optional(),
-  disable_web_page_preview: import_zod86.z.boolean().nullable().optional(),
-  timeout: import_zod86.z.int().nullable().optional(),
-  webhook_url: import_zod86.z.string().nullable().optional(),
-  webhook_secret: import_zod86.z.string().nullable().optional(),
-  max_retries: import_zod86.z.int().nullable().optional(),
-  retry_delay: import_zod86.z.number().nullable().optional()
+var import_zod87 = require("zod");
+var TelegramConfigSchema = import_zod87.z.object({
+  bot_token: import_zod87.z.string().nullable().optional(),
+  chat_id: import_zod87.z.int().nullable().optional(),
+  parse_mode: import_zod87.z.string().nullable().optional(),
+  disable_notification: import_zod87.z.boolean().nullable().optional(),
+  disable_web_page_preview: import_zod87.z.boolean().nullable().optional(),
+  timeout: import_zod87.z.int().nullable().optional(),
+  webhook_url: import_zod87.z.string().nullable().optional(),
+  webhook_secret: import_zod87.z.string().nullable().optional(),
+  max_retries: import_zod87.z.int().nullable().optional(),
+  retry_delay: import_zod87.z.number().nullable().optional()
 });
 
 // src/cfg/generated/_utils/schemas/DjangoConfig.schema.ts
-var DjangoConfigSchema = import_zod87.z.object({
-  env_mode: import_zod87.z.string().nullable().optional(),
-  project_name: import_zod87.z.string().nullable().optional(),
-  project_logo: import_zod87.z.string().nullable().optional(),
-  project_version: import_zod87.z.string().nullable().optional(),
-  project_description: import_zod87.z.string().nullable().optional(),
-  startup_info_mode: import_zod87.z.string().nullable().optional(),
-  enable_support: import_zod87.z.boolean().nullable().optional(),
-  enable_accounts: import_zod87.z.boolean().nullable().optional(),
-  enable_newsletter: import_zod87.z.boolean().nullable().optional(),
-  enable_leads: import_zod87.z.boolean().nullable().optional(),
-  enable_knowbase: import_zod87.z.boolean().nullable().optional(),
-  enable_agents: import_zod87.z.boolean().nullable().optional(),
-  enable_maintenance: import_zod87.z.boolean().nullable().optional(),
-  enable_frontend: import_zod87.z.boolean().nullable().optional(),
-  enable_drf_tailwind: import_zod87.z.boolean().nullable().optional(),
-  enable_pool_cleanup: import_zod87.z.boolean().nullable().optional(),
-  site_url: import_zod87.z.string().nullable().optional(),
-  api_url: import_zod87.z.string().nullable().optional(),
-  debug: import_zod87.z.boolean().nullable().optional(),
-  debug_warnings: import_zod87.z.boolean().nullable().optional(),
-  root_urlconf: import_zod87.z.string().nullable().optional(),
-  wsgi_application: import_zod87.z.string().nullable().optional(),
-  auth_user_model: import_zod87.z.string().nullable().optional(),
-  project_apps: import_zod87.z.array(import_zod87.z.string()).nullable().optional(),
-  databases: import_zod87.z.record(import_zod87.z.string(), DatabaseConfigSchema).nullable().optional(),
-  redis_url: import_zod87.z.string().nullable().optional(),
-  cache_default: import_zod87.z.string().nullable().optional(),
-  cache_sessions: import_zod87.z.string().nullable().optional(),
-  security_domains: import_zod87.z.array(import_zod87.z.string()).nullable().optional(),
-  ssl_redirect: import_zod87.z.boolean().nullable().optional(),
-  cors_allow_headers: import_zod87.z.array(import_zod87.z.string()).nullable().optional(),
+var DjangoConfigSchema = import_zod88.z.object({
+  env_mode: import_zod88.z.string().nullable().optional(),
+  project_name: import_zod88.z.string().nullable().optional(),
+  project_logo: import_zod88.z.string().nullable().optional(),
+  project_version: import_zod88.z.string().nullable().optional(),
+  project_description: import_zod88.z.string().nullable().optional(),
+  startup_info_mode: import_zod88.z.string().nullable().optional(),
+  enable_support: import_zod88.z.boolean().nullable().optional(),
+  enable_accounts: import_zod88.z.boolean().nullable().optional(),
+  enable_newsletter: import_zod88.z.boolean().nullable().optional(),
+  enable_leads: import_zod88.z.boolean().nullable().optional(),
+  enable_knowbase: import_zod88.z.boolean().nullable().optional(),
+  enable_agents: import_zod88.z.boolean().nullable().optional(),
+  enable_maintenance: import_zod88.z.boolean().nullable().optional(),
+  enable_frontend: import_zod88.z.boolean().nullable().optional(),
+  enable_drf_tailwind: import_zod88.z.boolean().nullable().optional(),
+  enable_pool_cleanup: import_zod88.z.boolean().nullable().optional(),
+  site_url: import_zod88.z.string().nullable().optional(),
+  api_url: import_zod88.z.string().nullable().optional(),
+  debug: import_zod88.z.boolean().nullable().optional(),
+  debug_warnings: import_zod88.z.boolean().nullable().optional(),
+  root_urlconf: import_zod88.z.string().nullable().optional(),
+  wsgi_application: import_zod88.z.string().nullable().optional(),
+  auth_user_model: import_zod88.z.string().nullable().optional(),
+  project_apps: import_zod88.z.array(import_zod88.z.string()).nullable().optional(),
+  databases: import_zod88.z.record(import_zod88.z.string(), DatabaseConfigSchema).nullable().optional(),
+  redis_url: import_zod88.z.string().nullable().optional(),
+  cache_default: import_zod88.z.string().nullable().optional(),
+  cache_sessions: import_zod88.z.string().nullable().optional(),
+  security_domains: import_zod88.z.array(import_zod88.z.string()).nullable().optional(),
+  ssl_redirect: import_zod88.z.boolean().nullable().optional(),
+  cors_allow_headers: import_zod88.z.array(import_zod88.z.string()).nullable().optional(),
   email: EmailConfigSchema.nullable().optional(),
   payments: PaymentsConfigSchema.nullable().optional(),
   grpc: GRPCConfigDashboardSchema.nullable().optional(),
@@ -5220,1041 +5232,1027 @@ var DjangoConfigSchema = import_zod87.z.object({
   telegram: TelegramConfigSchema.nullable().optional(),
   ngrok: NgrokConfigSchema.nullable().optional(),
   axes: AxesConfigSchema.nullable().optional(),
-  crypto_fields: import_zod87.z.record(import_zod87.z.string(), import_zod87.z.any()).nullable().optional(),
-  unfold: import_zod87.z.record(import_zod87.z.string(), import_zod87.z.any()).nullable().optional(),
-  tailwind_app_name: import_zod87.z.string().nullable().optional(),
-  tailwind_version: import_zod87.z.int().nullable().optional(),
-  limits: import_zod87.z.record(import_zod87.z.string(), import_zod87.z.any()).nullable().optional(),
-  api_keys: import_zod87.z.record(import_zod87.z.string(), import_zod87.z.any()).nullable().optional(),
-  custom_middleware: import_zod87.z.array(import_zod87.z.string()).nullable().optional(),
+  crypto_fields: import_zod88.z.record(import_zod88.z.string(), import_zod88.z.any()).nullable().optional(),
+  unfold: import_zod88.z.record(import_zod88.z.string(), import_zod88.z.any()).nullable().optional(),
+  tailwind_app_name: import_zod88.z.string().nullable().optional(),
+  tailwind_version: import_zod88.z.int().nullable().optional(),
+  limits: import_zod88.z.record(import_zod88.z.string(), import_zod88.z.any()).nullable().optional(),
+  api_keys: import_zod88.z.record(import_zod88.z.string(), import_zod88.z.any()).nullable().optional(),
+  custom_middleware: import_zod88.z.array(import_zod88.z.string()).nullable().optional(),
   nextjs_admin: NextJSAdminConfigSchema.nullable().optional(),
-  admin_emails: import_zod87.z.array(import_zod87.z.string()).nullable().optional(),
+  admin_emails: import_zod88.z.array(import_zod88.z.string()).nullable().optional(),
   constance: ConstanceConfigSchema.nullable().optional(),
   openapi_client: OpenAPIClientConfigSchema.nullable().optional(),
   _meta: ConfigMetaSchema.nullable().optional()
 });
 
 // src/cfg/generated/_utils/schemas/ConfigData.schema.ts
-var ConfigDataSchema = import_zod88.z.object({
+var ConfigDataSchema = import_zod89.z.object({
   django_config: DjangoConfigSchema,
-  django_settings: import_zod88.z.record(import_zod88.z.string(), import_zod88.z.any()),
+  django_settings: import_zod89.z.record(import_zod89.z.string(), import_zod89.z.any()),
   _validation: ConfigValidationSchema
 });
 
 // src/cfg/generated/_utils/schemas/ConnectionTokenResponse.schema.ts
-var import_zod89 = require("zod");
-var ConnectionTokenResponseSchema = import_zod89.z.object({
-  token: import_zod89.z.string(),
-  centrifugo_url: import_zod89.z.string(),
-  expires_at: import_zod89.z.string(),
-  channels: import_zod89.z.array(import_zod89.z.string())
-});
-
-// src/cfg/generated/_utils/schemas/Currency.schema.ts
 var import_zod90 = require("zod");
-var CurrencySchema = import_zod90.z.object({
-  code: import_zod90.z.string(),
-  name: import_zod90.z.string(),
+var ConnectionTokenResponseSchema = import_zod90.z.object({
   token: import_zod90.z.string(),
-  network: import_zod90.z.string().nullable(),
-  display_name: import_zod90.z.string(),
-  symbol: import_zod90.z.string(),
-  decimal_places: import_zod90.z.int(),
-  is_active: import_zod90.z.boolean(),
-  min_amount_usd: import_zod90.z.string(),
-  sort_order: import_zod90.z.int()
+  centrifugo_url: import_zod90.z.string(),
+  expires_at: import_zod90.z.string(),
+  channels: import_zod90.z.array(import_zod90.z.string())
 });
 
-// src/cfg/generated/_utils/schemas/DashboardCharts.schema.ts
-var import_zod101 = require("zod");
-
-// src/cfg/generated/_utils/schemas/ErrorDistributionChart.schema.ts
-var import_zod92 = require("zod");
-
-// src/cfg/generated/_utils/schemas/ErrorDistributionDataPoint.schema.ts
+// src/cfg/generated/_utils/schemas/Currency.schema.ts
 var import_zod91 = require("zod");
-var ErrorDistributionDataPointSchema = import_zod91.z.object({
-  error_code: import_zod91.z.string(),
-  count: import_zod91.z.int(),
-  percentage: import_zod91.z.number(),
-  service_name: import_zod91.z.string().nullable().optional()
+var CurrencySchema = import_zod91.z.object({
+  code: import_zod91.z.string(),
+  name: import_zod91.z.string(),
+  token: import_zod91.z.string(),
+  network: import_zod91.z.string().nullable(),
+  display_name: import_zod91.z.string(),
+  symbol: import_zod91.z.string(),
+  decimal_places: import_zod91.z.int(),
+  is_active: import_zod91.z.boolean(),
+  min_amount_usd: import_zod91.z.string(),
+  sort_order: import_zod91.z.int()
+});
+
+// src/cfg/generated/_utils/schemas/DRFHealthCheck.schema.ts
+var import_zod92 = require("zod");
+var DRFHealthCheckSchema = import_zod92.z.object({
+  status: import_zod92.z.string(),
+  timestamp: import_zod92.z.iso.datetime(),
+  service: import_zod92.z.string(),
+  version: import_zod92.z.string(),
+  checks: import_zod92.z.record(import_zod92.z.string(), import_zod92.z.record(import_zod92.z.string(), import_zod92.z.any())),
+  environment: import_zod92.z.record(import_zod92.z.string(), import_zod92.z.record(import_zod92.z.string(), import_zod92.z.any())),
+  links: import_zod92.z.record(import_zod92.z.string(), import_zod92.z.record(import_zod92.z.string(), import_zod92.z.any())).optional()
 });
 
-// src/cfg/generated/_utils/schemas/ErrorDistributionChart.schema.ts
-var ErrorDistributionChartSchema = import_zod92.z.object({
-  title: import_zod92.z.string().optional(),
-  error_types: import_zod92.z.array(ErrorDistributionDataPointSchema).optional(),
-  period_hours: import_zod92.z.int(),
-  total_errors: import_zod92.z.int(),
-  most_common_error: import_zod92.z.string().nullable().optional()
-});
+// src/cfg/generated/_utils/schemas/DashboardCharts.schema.ts
+var import_zod103 = require("zod");
 
-// src/cfg/generated/_utils/schemas/RequestVolumeChart.schema.ts
+// src/cfg/generated/_utils/schemas/ErrorDistributionChart.schema.ts
 var import_zod94 = require("zod");
 
-// src/cfg/generated/_utils/schemas/RequestVolumeDataPoint.schema.ts
+// src/cfg/generated/_utils/schemas/ErrorDistributionDataPoint.schema.ts
 var import_zod93 = require("zod");
-var RequestVolumeDataPointSchema = import_zod93.z.object({
-  timestamp: import_zod93.z.string(),
-  total_requests: import_zod93.z.int(),
-  successful_requests: import_zod93.z.int(),
-  failed_requests: import_zod93.z.int(),
-  success_rate: import_zod93.z.number()
+var ErrorDistributionDataPointSchema = import_zod93.z.object({
+  error_code: import_zod93.z.string(),
+  count: import_zod93.z.int(),
+  percentage: import_zod93.z.number(),
+  service_name: import_zod93.z.string().nullable().optional()
 });
 
-// src/cfg/generated/_utils/schemas/RequestVolumeChart.schema.ts
-var RequestVolumeChartSchema = import_zod94.z.object({
+// src/cfg/generated/_utils/schemas/ErrorDistributionChart.schema.ts
+var ErrorDistributionChartSchema = import_zod94.z.object({
   title: import_zod94.z.string().optional(),
-  data_points: import_zod94.z.array(RequestVolumeDataPointSchema).optional(),
+  error_types: import_zod94.z.array(ErrorDistributionDataPointSchema).optional(),
   period_hours: import_zod94.z.int(),
-  granularity: import_zod94.z.string(),
-  total_requests: import_zod94.z.int(),
-  avg_success_rate: import_zod94.z.number()
+  total_errors: import_zod94.z.int(),
+  most_common_error: import_zod94.z.string().nullable().optional()
 });
 
-// src/cfg/generated/_utils/schemas/ResponseTimeChart.schema.ts
+// src/cfg/generated/_utils/schemas/RequestVolumeChart.schema.ts
 var import_zod96 = require("zod");
 
-// src/cfg/generated/_utils/schemas/ResponseTimeDataPoint.schema.ts
+// src/cfg/generated/_utils/schemas/RequestVolumeDataPoint.schema.ts
 var import_zod95 = require("zod");
-var ResponseTimeDataPointSchema = import_zod95.z.object({
+var RequestVolumeDataPointSchema = import_zod95.z.object({
   timestamp: import_zod95.z.string(),
-  avg_duration_ms: import_zod95.z.number(),
-  p50_duration_ms: import_zod95.z.number(),
-  p95_duration_ms: import_zod95.z.number(),
-  p99_duration_ms: import_zod95.z.number(),
-  min_duration_ms: import_zod95.z.number(),
-  max_duration_ms: import_zod95.z.number()
+  total_requests: import_zod95.z.int(),
+  successful_requests: import_zod95.z.int(),
+  failed_requests: import_zod95.z.int(),
+  success_rate: import_zod95.z.number()
 });
 
-// src/cfg/generated/_utils/schemas/ResponseTimeChart.schema.ts
-var ResponseTimeChartSchema = import_zod96.z.object({
+// src/cfg/generated/_utils/schemas/RequestVolumeChart.schema.ts
+var RequestVolumeChartSchema = import_zod96.z.object({
   title: import_zod96.z.string().optional(),
-  data_points: import_zod96.z.array(ResponseTimeDataPointSchema).optional(),
+  data_points: import_zod96.z.array(RequestVolumeDataPointSchema).optional(),
   period_hours: import_zod96.z.int(),
   granularity: import_zod96.z.string(),
-  overall_avg_ms: import_zod96.z.number(),
-  overall_p95_ms: import_zod96.z.number()
+  total_requests: import_zod96.z.int(),
+  avg_success_rate: import_zod96.z.number()
 });
 
-// src/cfg/generated/_utils/schemas/ServerUptimeChart.schema.ts
+// src/cfg/generated/_utils/schemas/ResponseTimeChart.schema.ts
 var import_zod98 = require("zod");
 
-// src/cfg/generated/_utils/schemas/ServerUptimeDataPoint.schema.ts
+// src/cfg/generated/_utils/schemas/ResponseTimeDataPoint.schema.ts
 var import_zod97 = require("zod");
-var ServerUptimeDataPointSchema = import_zod97.z.object({
+var ResponseTimeDataPointSchema = import_zod97.z.object({
   timestamp: import_zod97.z.string(),
-  server_count: import_zod97.z.int(),
-  servers: import_zod97.z.array(import_zod97.z.string()).optional()
+  avg_duration_ms: import_zod97.z.number(),
+  p50_duration_ms: import_zod97.z.number(),
+  p95_duration_ms: import_zod97.z.number(),
+  p99_duration_ms: import_zod97.z.number(),
+  min_duration_ms: import_zod97.z.number(),
+  max_duration_ms: import_zod97.z.number()
 });
 
-// src/cfg/generated/_utils/schemas/ServerUptimeChart.schema.ts
-var ServerUptimeChartSchema = import_zod98.z.object({
+// src/cfg/generated/_utils/schemas/ResponseTimeChart.schema.ts
+var ResponseTimeChartSchema = import_zod98.z.object({
   title: import_zod98.z.string().optional(),
-  data_points: import_zod98.z.array(ServerUptimeDataPointSchema).optional(),
+  data_points: import_zod98.z.array(ResponseTimeDataPointSchema).optional(),
   period_hours: import_zod98.z.int(),
   granularity: import_zod98.z.string(),
-  total_servers: import_zod98.z.int(),
-  currently_running: import_zod98.z.int()
+  overall_avg_ms: import_zod98.z.number(),
+  overall_p95_ms: import_zod98.z.number()
 });
 
-// src/cfg/generated/_utils/schemas/ServiceActivityChart.schema.ts
+// src/cfg/generated/_utils/schemas/ServerUptimeChart.schema.ts
 var import_zod100 = require("zod");
 
-// src/cfg/generated/_utils/schemas/ServiceActivityDataPoint.schema.ts
+// src/cfg/generated/_utils/schemas/ServerUptimeDataPoint.schema.ts
 var import_zod99 = require("zod");
-var ServiceActivityDataPointSchema = import_zod99.z.object({
-  service_name: import_zod99.z.string(),
-  request_count: import_zod99.z.int(),
-  success_rate: import_zod99.z.number(),
-  avg_duration_ms: import_zod99.z.number()
+var ServerUptimeDataPointSchema = import_zod99.z.object({
+  timestamp: import_zod99.z.string(),
+  server_count: import_zod99.z.int(),
+  servers: import_zod99.z.array(import_zod99.z.string()).optional()
 });
 
-// src/cfg/generated/_utils/schemas/ServiceActivityChart.schema.ts
-var ServiceActivityChartSchema = import_zod100.z.object({
+// src/cfg/generated/_utils/schemas/ServerUptimeChart.schema.ts
+var ServerUptimeChartSchema = import_zod100.z.object({
   title: import_zod100.z.string().optional(),
-  services: import_zod100.z.array(ServiceActivityDataPointSchema).optional(),
+  data_points: import_zod100.z.array(ServerUptimeDataPointSchema).optional(),
   period_hours: import_zod100.z.int(),
-  total_services: import_zod100.z.int(),
-  most_active_service: import_zod100.z.string().nullable().optional()
+  granularity: import_zod100.z.string(),
+  total_servers: import_zod100.z.int(),
+  currently_running: import_zod100.z.int()
+});
+
+// src/cfg/generated/_utils/schemas/ServiceActivityChart.schema.ts
+var import_zod102 = require("zod");
+
+// src/cfg/generated/_utils/schemas/ServiceActivityDataPoint.schema.ts
+var import_zod101 = require("zod");
+var ServiceActivityDataPointSchema = import_zod101.z.object({
+  service_name: import_zod101.z.string(),
+  request_count: import_zod101.z.int(),
+  success_rate: import_zod101.z.number(),
+  avg_duration_ms: import_zod101.z.number()
+});
+
+// src/cfg/generated/_utils/schemas/ServiceActivityChart.schema.ts
+var ServiceActivityChartSchema = import_zod102.z.object({
+  title: import_zod102.z.string().optional(),
+  services: import_zod102.z.array(ServiceActivityDataPointSchema).optional(),
+  period_hours: import_zod102.z.int(),
+  total_services: import_zod102.z.int(),
+  most_active_service: import_zod102.z.string().nullable().optional()
 });
 
 // src/cfg/generated/_utils/schemas/DashboardCharts.schema.ts
-var DashboardChartsSchema = import_zod101.z.object({
+var DashboardChartsSchema = import_zod103.z.object({
   server_uptime: ServerUptimeChartSchema,
   request_volume: RequestVolumeChartSchema,
   response_time: ResponseTimeChartSchema,
   service_activity: ServiceActivityChartSchema,
   error_distribution: ErrorDistributionChartSchema,
-  period_hours: import_zod101.z.int(),
-  generated_at: import_zod101.z.string()
+  period_hours: import_zod103.z.int(),
+  generated_at: import_zod103.z.string()
 });
 
 // src/cfg/generated/_utils/schemas/DashboardOverview.schema.ts
-var import_zod108 = require("zod");
+var import_zod110 = require("zod");
 
 // src/cfg/generated/_utils/schemas/QuickAction.schema.ts
-var import_zod102 = require("zod");
-var QuickActionSchema = import_zod102.z.object({
-  title: import_zod102.z.string(),
-  description: import_zod102.z.string(),
-  icon: import_zod102.z.string(),
-  link: import_zod102.z.string(),
-  color: import_zod102.z.nativeEnum(QuickActionColor).optional(),
-  category: import_zod102.z.string().optional()
+var import_zod104 = require("zod");
+var QuickActionSchema = import_zod104.z.object({
+  title: import_zod104.z.string(),
+  description: import_zod104.z.string(),
+  icon: import_zod104.z.string(),
+  link: import_zod104.z.string(),
+  color: import_zod104.z.nativeEnum(QuickActionColor).optional(),
+  category: import_zod104.z.string().optional()
 });
 
 // src/cfg/generated/_utils/schemas/StatCard.schema.ts
-var import_zod103 = require("zod");
-var StatCardSchema = import_zod103.z.object({
-  title: import_zod103.z.string(),
-  value: import_zod103.z.string(),
-  icon: import_zod103.z.string(),
-  change: import_zod103.z.string().nullable().optional(),
-  change_type: import_zod103.z.nativeEnum(StatCardChangeType).optional(),
-  description: import_zod103.z.string().nullable().optional(),
-  color: import_zod103.z.string().optional()
+var import_zod105 = require("zod");
+var StatCardSchema = import_zod105.z.object({
+  title: import_zod105.z.string(),
+  value: import_zod105.z.string(),
+  icon: import_zod105.z.string(),
+  change: import_zod105.z.string().nullable().optional(),
+  change_type: import_zod105.z.nativeEnum(StatCardChangeType).optional(),
+  description: import_zod105.z.string().nullable().optional(),
+  color: import_zod105.z.string().optional()
 });
 
 // src/cfg/generated/_utils/schemas/SystemHealth.schema.ts
-var import_zod105 = require("zod");
+var import_zod107 = require("zod");
 
 // src/cfg/generated/_utils/schemas/SystemHealthItem.schema.ts
-var import_zod104 = require("zod");
-var SystemHealthItemSchema = import_zod104.z.object({
-  component: import_zod104.z.string(),
-  status: import_zod104.z.nativeEnum(SystemHealthItemStatus),
-  description: import_zod104.z.string(),
-  last_check: import_zod104.z.string(),
-  health_percentage: import_zod104.z.int().min(0).max(100).nullable().optional()
+var import_zod106 = require("zod");
+var SystemHealthItemSchema = import_zod106.z.object({
+  component: import_zod106.z.string(),
+  status: import_zod106.z.nativeEnum(SystemHealthItemStatus),
+  description: import_zod106.z.string(),
+  last_check: import_zod106.z.string(),
+  health_percentage: import_zod106.z.int().min(0).max(100).nullable().optional()
 });
 
 // src/cfg/generated/_utils/schemas/SystemHealth.schema.ts
-var SystemHealthSchema = import_zod105.z.object({
-  overall_status: import_zod105.z.nativeEnum(SystemHealthOverallStatus),
-  overall_health_percentage: import_zod105.z.int().min(0).max(100),
-  components: import_zod105.z.array(SystemHealthItemSchema),
-  timestamp: import_zod105.z.string()
+var SystemHealthSchema = import_zod107.z.object({
+  overall_status: import_zod107.z.nativeEnum(SystemHealthOverallStatus),
+  overall_health_percentage: import_zod107.z.int().min(0).max(100),
+  components: import_zod107.z.array(SystemHealthItemSchema),
+  timestamp: import_zod107.z.string()
 });
 
 // src/cfg/generated/_utils/schemas/SystemMetrics.schema.ts
-var import_zod106 = require("zod");
-var SystemMetricsSchema = import_zod106.z.object({
-  cpu_usage: import_zod106.z.number(),
-  memory_usage: import_zod106.z.number(),
-  disk_usage: import_zod106.z.number(),
-  network_in: import_zod106.z.string(),
-  network_out: import_zod106.z.string(),
-  response_time: import_zod106.z.string(),
-  uptime: import_zod106.z.string()
+var import_zod108 = require("zod");
+var SystemMetricsSchema = import_zod108.z.object({
+  cpu_usage: import_zod108.z.number(),
+  memory_usage: import_zod108.z.number(),
+  disk_usage: import_zod108.z.number(),
+  network_in: import_zod108.z.string(),
+  network_out: import_zod108.z.string(),
+  response_time: import_zod108.z.string(),
+  uptime: import_zod108.z.string()
 });
 
 // src/cfg/generated/_utils/schemas/UserStatistics.schema.ts
-var import_zod107 = require("zod");
-var UserStatisticsSchema = import_zod107.z.object({
-  total_users: import_zod107.z.int(),
-  active_users: import_zod107.z.int(),
-  new_users: import_zod107.z.int(),
-  superusers: import_zod107.z.int()
+var import_zod109 = require("zod");
+var UserStatisticsSchema = import_zod109.z.object({
+  total_users: import_zod109.z.int(),
+  active_users: import_zod109.z.int(),
+  new_users: import_zod109.z.int(),
+  superusers: import_zod109.z.int()
 });
 
 // src/cfg/generated/_utils/schemas/DashboardOverview.schema.ts
-var DashboardOverviewSchema = import_zod108.z.object({
-  stat_cards: import_zod108.z.array(StatCardSchema),
+var DashboardOverviewSchema = import_zod110.z.object({
+  stat_cards: import_zod110.z.array(StatCardSchema),
   system_health: SystemHealthSchema,
-  quick_actions: import_zod108.z.array(QuickActionSchema),
-  recent_activity: import_zod108.z.array(ActivityEntrySchema),
+  quick_actions: import_zod110.z.array(QuickActionSchema),
+  recent_activity: import_zod110.z.array(ActivityEntrySchema),
   system_metrics: SystemMetricsSchema,
   user_statistics: UserStatisticsSchema,
-  app_statistics: import_zod108.z.array(AppStatisticsSchema).optional(),
-  timestamp: import_zod108.z.string()
+  app_statistics: import_zod110.z.array(AppStatisticsSchema).optional(),
+  timestamp: import_zod110.z.string()
 });
 
 // src/cfg/generated/_utils/schemas/Document.schema.ts
-var import_zod109 = require("zod");
-var DocumentSchema = import_zod109.z.object({
-  id: import_zod109.z.uuid(),
-  title: import_zod109.z.string().max(512),
-  file_type: import_zod109.z.string().max(100).optional(),
-  file_size: import_zod109.z.int().min(0).max(2147483647).optional(),
-  processing_status: import_zod109.z.string(),
-  chunks_count: import_zod109.z.int(),
-  total_tokens: import_zod109.z.int(),
-  total_cost_usd: import_zod109.z.number(),
-  created_at: import_zod109.z.iso.datetime(),
-  updated_at: import_zod109.z.iso.datetime(),
-  processing_started_at: import_zod109.z.iso.datetime(),
-  processing_completed_at: import_zod109.z.iso.datetime(),
-  processing_error: import_zod109.z.string(),
-  metadata: import_zod109.z.record(import_zod109.z.string(), import_zod109.z.any()).nullable().optional()
-});
-
-// src/cfg/generated/_utils/schemas/DocumentArchive.schema.ts
 var import_zod111 = require("zod");
-
-// src/cfg/generated/_utils/schemas/DocumentCategory.schema.ts
-var import_zod110 = require("zod");
-var DocumentCategorySchema = import_zod110.z.object({
-  id: import_zod110.z.uuid(),
-  name: import_zod110.z.string().max(255),
-  description: import_zod110.z.string().optional(),
-  is_public: import_zod110.z.boolean().optional(),
-  created_at: import_zod110.z.iso.datetime()
-});
-
-// src/cfg/generated/_utils/schemas/DocumentArchive.schema.ts
-var DocumentArchiveSchema = import_zod111.z.object({
+var DocumentSchema = import_zod111.z.object({
   id: import_zod111.z.uuid(),
   title: import_zod111.z.string().max(512),
-  description: import_zod111.z.string().optional(),
-  categories: import_zod111.z.array(DocumentCategorySchema),
-  is_public: import_zod111.z.boolean().optional(),
-  archive_file: import_zod111.z.url(),
-  original_filename: import_zod111.z.string(),
-  file_size: import_zod111.z.int(),
-  archive_type: import_zod111.z.nativeEnum(DocumentArchiveArchiveType),
-  processing_status: import_zod111.z.nativeEnum(DocumentArchiveProcessingStatus),
-  processed_at: import_zod111.z.iso.datetime().nullable(),
-  processing_duration_ms: import_zod111.z.int(),
-  processing_error: import_zod111.z.string(),
-  total_items: import_zod111.z.int(),
-  processed_items: import_zod111.z.int(),
-  total_chunks: import_zod111.z.int(),
-  vectorized_chunks: import_zod111.z.int(),
+  file_type: import_zod111.z.string().max(100).optional(),
+  file_size: import_zod111.z.int().min(0).max(2147483647).optional(),
+  processing_status: import_zod111.z.string(),
+  chunks_count: import_zod111.z.int(),
   total_tokens: import_zod111.z.int(),
   total_cost_usd: import_zod111.z.number(),
-  processing_progress: import_zod111.z.number(),
-  vectorization_progress: import_zod111.z.number(),
-  is_processed: import_zod111.z.boolean(),
   created_at: import_zod111.z.iso.datetime(),
-  updated_at: import_zod111.z.iso.datetime()
+  updated_at: import_zod111.z.iso.datetime(),
+  processing_started_at: import_zod111.z.iso.datetime(),
+  processing_completed_at: import_zod111.z.iso.datetime(),
+  processing_error: import_zod111.z.string(),
+  metadata: import_zod111.z.record(import_zod111.z.string(), import_zod111.z.any()).nullable().optional()
 });
 
-// src/cfg/generated/_utils/schemas/DocumentArchiveDetail.schema.ts
+// src/cfg/generated/_utils/schemas/DocumentArchive.schema.ts
+var import_zod113 = require("zod");
+
+// src/cfg/generated/_utils/schemas/DocumentCategory.schema.ts
 var import_zod112 = require("zod");
-var DocumentArchiveDetailSchema = import_zod112.z.object({
+var DocumentCategorySchema = import_zod112.z.object({
   id: import_zod112.z.uuid(),
-  title: import_zod112.z.string().max(512),
+  name: import_zod112.z.string().max(255),
   description: import_zod112.z.string().optional(),
-  categories: import_zod112.z.array(DocumentCategorySchema),
   is_public: import_zod112.z.boolean().optional(),
-  archive_file: import_zod112.z.url(),
-  original_filename: import_zod112.z.string(),
-  file_size: import_zod112.z.int(),
-  archive_type: import_zod112.z.nativeEnum(DocumentArchiveDetailArchiveType),
-  processing_status: import_zod112.z.nativeEnum(DocumentArchiveDetailProcessingStatus),
-  processed_at: import_zod112.z.iso.datetime().nullable(),
-  processing_duration_ms: import_zod112.z.int(),
-  processing_error: import_zod112.z.string(),
-  total_items: import_zod112.z.int(),
-  processed_items: import_zod112.z.int(),
-  total_chunks: import_zod112.z.int(),
-  vectorized_chunks: import_zod112.z.int(),
-  total_tokens: import_zod112.z.int(),
-  total_cost_usd: import_zod112.z.number(),
-  processing_progress: import_zod112.z.number(),
-  vectorization_progress: import_zod112.z.number(),
-  is_processed: import_zod112.z.boolean(),
-  created_at: import_zod112.z.iso.datetime(),
-  updated_at: import_zod112.z.iso.datetime(),
-  items: import_zod112.z.array(ArchiveItemSchema),
-  file_tree: import_zod112.z.record(import_zod112.z.string(), import_zod112.z.record(import_zod112.z.string(), import_zod112.z.any())),
-  metadata: import_zod112.z.record(import_zod112.z.string(), import_zod112.z.any()).nullable().optional()
+  created_at: import_zod112.z.iso.datetime()
 });
 
-// src/cfg/generated/_utils/schemas/DocumentArchiveList.schema.ts
-var import_zod113 = require("zod");
-var DocumentArchiveListSchema = import_zod113.z.object({
+// src/cfg/generated/_utils/schemas/DocumentArchive.schema.ts
+var DocumentArchiveSchema = import_zod113.z.object({
   id: import_zod113.z.uuid(),
-  title: import_zod113.z.string(),
-  description: import_zod113.z.string(),
+  title: import_zod113.z.string().max(512),
+  description: import_zod113.z.string().optional(),
   categories: import_zod113.z.array(DocumentCategorySchema),
-  is_public: import_zod113.z.boolean(),
+  is_public: import_zod113.z.boolean().optional(),
+  archive_file: import_zod113.z.url(),
   original_filename: import_zod113.z.string(),
   file_size: import_zod113.z.int(),
-  archive_type: import_zod113.z.nativeEnum(DocumentArchiveListArchiveType),
-  processing_status: import_zod113.z.nativeEnum(DocumentArchiveListProcessingStatus),
+  archive_type: import_zod113.z.nativeEnum(DocumentArchiveArchiveType),
+  processing_status: import_zod113.z.nativeEnum(DocumentArchiveProcessingStatus),
   processed_at: import_zod113.z.iso.datetime().nullable(),
+  processing_duration_ms: import_zod113.z.int(),
+  processing_error: import_zod113.z.string(),
   total_items: import_zod113.z.int(),
+  processed_items: import_zod113.z.int(),
   total_chunks: import_zod113.z.int(),
+  vectorized_chunks: import_zod113.z.int(),
+  total_tokens: import_zod113.z.int(),
   total_cost_usd: import_zod113.z.number(),
   processing_progress: import_zod113.z.number(),
-  created_at: import_zod113.z.iso.datetime()
+  vectorization_progress: import_zod113.z.number(),
+  is_processed: import_zod113.z.boolean(),
+  created_at: import_zod113.z.iso.datetime(),
+  updated_at: import_zod113.z.iso.datetime()
 });
 
-// src/cfg/generated/_utils/schemas/DocumentArchiveRequest.schema.ts
+// src/cfg/generated/_utils/schemas/DocumentArchiveDetail.schema.ts
 var import_zod114 = require("zod");
-var DocumentArchiveRequestSchema = import_zod114.z.object({
-  title: import_zod114.z.string().min(1).max(512),
+var DocumentArchiveDetailSchema = import_zod114.z.object({
+  id: import_zod114.z.uuid(),
+  title: import_zod114.z.string().max(512),
   description: import_zod114.z.string().optional(),
-  is_public: import_zod114.z.boolean().optional()
+  categories: import_zod114.z.array(DocumentCategorySchema),
+  is_public: import_zod114.z.boolean().optional(),
+  archive_file: import_zod114.z.url(),
+  original_filename: import_zod114.z.string(),
+  file_size: import_zod114.z.int(),
+  archive_type: import_zod114.z.nativeEnum(DocumentArchiveDetailArchiveType),
+  processing_status: import_zod114.z.nativeEnum(DocumentArchiveDetailProcessingStatus),
+  processed_at: import_zod114.z.iso.datetime().nullable(),
+  processing_duration_ms: import_zod114.z.int(),
+  processing_error: import_zod114.z.string(),
+  total_items: import_zod114.z.int(),
+  processed_items: import_zod114.z.int(),
+  total_chunks: import_zod114.z.int(),
+  vectorized_chunks: import_zod114.z.int(),
+  total_tokens: import_zod114.z.int(),
+  total_cost_usd: import_zod114.z.number(),
+  processing_progress: import_zod114.z.number(),
+  vectorization_progress: import_zod114.z.number(),
+  is_processed: import_zod114.z.boolean(),
+  created_at: import_zod114.z.iso.datetime(),
+  updated_at: import_zod114.z.iso.datetime(),
+  items: import_zod114.z.array(ArchiveItemSchema),
+  file_tree: import_zod114.z.record(import_zod114.z.string(), import_zod114.z.any()),
+  metadata: import_zod114.z.record(import_zod114.z.string(), import_zod114.z.any()).nullable().optional()
 });
 
-// src/cfg/generated/_utils/schemas/DocumentCategoryRequest.schema.ts
+// src/cfg/generated/_utils/schemas/DocumentArchiveList.schema.ts
 var import_zod115 = require("zod");
-var DocumentCategoryRequestSchema = import_zod115.z.object({
-  name: import_zod115.z.string().min(1).max(255),
-  description: import_zod115.z.string().optional(),
-  is_public: import_zod115.z.boolean().optional()
+var DocumentArchiveListSchema = import_zod115.z.object({
+  id: import_zod115.z.uuid(),
+  title: import_zod115.z.string(),
+  description: import_zod115.z.string(),
+  categories: import_zod115.z.array(DocumentCategorySchema),
+  is_public: import_zod115.z.boolean(),
+  original_filename: import_zod115.z.string(),
+  file_size: import_zod115.z.int(),
+  archive_type: import_zod115.z.nativeEnum(DocumentArchiveListArchiveType),
+  processing_status: import_zod115.z.nativeEnum(DocumentArchiveListProcessingStatus),
+  processed_at: import_zod115.z.iso.datetime().nullable(),
+  total_items: import_zod115.z.int(),
+  total_chunks: import_zod115.z.int(),
+  total_cost_usd: import_zod115.z.number(),
+  processing_progress: import_zod115.z.number(),
+  created_at: import_zod115.z.iso.datetime()
 });
 
-// src/cfg/generated/_utils/schemas/DocumentCreateRequest.schema.ts
+// src/cfg/generated/_utils/schemas/DocumentArchiveRequest.schema.ts
 var import_zod116 = require("zod");
-var DocumentCreateRequestSchema = import_zod116.z.object({
+var DocumentArchiveRequestSchema = import_zod116.z.object({
   title: import_zod116.z.string().min(1).max(512),
-  content: import_zod116.z.string().min(10).max(1e6),
-  file_type: import_zod116.z.string().min(1).optional(),
-  metadata: import_zod116.z.record(import_zod116.z.string(), import_zod116.z.any()).optional()
+  description: import_zod116.z.string().optional(),
+  is_public: import_zod116.z.boolean().optional()
 });
 
-// src/cfg/generated/_utils/schemas/DocumentProcessingStatus.schema.ts
+// src/cfg/generated/_utils/schemas/DocumentCategoryRequest.schema.ts
 var import_zod117 = require("zod");
-var DocumentProcessingStatusSchema = import_zod117.z.object({
-  id: import_zod117.z.uuid(),
-  status: import_zod117.z.string(),
-  progress: import_zod117.z.record(import_zod117.z.string(), import_zod117.z.any()),
-  error: import_zod117.z.string().nullable().optional(),
-  processing_time_seconds: import_zod117.z.number().nullable().optional()
+var DocumentCategoryRequestSchema = import_zod117.z.object({
+  name: import_zod117.z.string().min(1).max(255),
+  description: import_zod117.z.string().optional(),
+  is_public: import_zod117.z.boolean().optional()
 });
 
-// src/cfg/generated/_utils/schemas/DocumentRequest.schema.ts
+// src/cfg/generated/_utils/schemas/DocumentCreateRequest.schema.ts
 var import_zod118 = require("zod");
-var DocumentRequestSchema = import_zod118.z.object({
+var DocumentCreateRequestSchema = import_zod118.z.object({
   title: import_zod118.z.string().min(1).max(512),
-  file_type: import_zod118.z.string().min(1).max(100).optional(),
-  file_size: import_zod118.z.int().min(0).max(2147483647).optional(),
-  metadata: import_zod118.z.record(import_zod118.z.string(), import_zod118.z.any()).nullable().optional()
+  content: import_zod118.z.string().min(10).max(1e6),
+  file_type: import_zod118.z.string().min(1).optional(),
+  metadata: import_zod118.z.record(import_zod118.z.string(), import_zod118.z.any()).optional()
 });
 
-// src/cfg/generated/_utils/schemas/DocumentStats.schema.ts
+// src/cfg/generated/_utils/schemas/DocumentProcessingStatus.schema.ts
 var import_zod119 = require("zod");
-var DocumentStatsSchema = import_zod119.z.object({
-  total_documents: import_zod119.z.int(),
-  completed_documents: import_zod119.z.int(),
-  processing_success_rate: import_zod119.z.number(),
-  total_chunks: import_zod119.z.int(),
-  total_tokens: import_zod119.z.int(),
-  total_cost_usd: import_zod119.z.number(),
-  avg_processing_time_seconds: import_zod119.z.number()
+var DocumentProcessingStatusSchema = import_zod119.z.object({
+  id: import_zod119.z.uuid(),
+  status: import_zod119.z.string(),
+  progress: import_zod119.z.record(import_zod119.z.string(), import_zod119.z.any()),
+  error: import_zod119.z.string().nullable().optional(),
+  processing_time_seconds: import_zod119.z.number().nullable().optional()
 });
 
-// src/cfg/generated/_utils/schemas/EmailLog.schema.ts
+// src/cfg/generated/_utils/schemas/DocumentRequest.schema.ts
 var import_zod120 = require("zod");
-var EmailLogSchema = import_zod120.z.object({
-  id: import_zod120.z.uuid(),
-  user: import_zod120.z.int().nullable(),
-  user_email: import_zod120.z.string(),
-  newsletter: import_zod120.z.int().nullable(),
-  newsletter_title: import_zod120.z.string(),
-  recipient: import_zod120.z.string(),
-  subject: import_zod120.z.string(),
-  body: import_zod120.z.string(),
-  status: import_zod120.z.nativeEnum(EmailLogStatus),
-  created_at: import_zod120.z.iso.datetime(),
-  sent_at: import_zod120.z.iso.datetime().nullable(),
-  error_message: import_zod120.z.string().nullable()
+var DocumentRequestSchema = import_zod120.z.object({
+  title: import_zod120.z.string().min(1).max(512),
+  file_type: import_zod120.z.string().min(1).max(100).optional(),
+  file_size: import_zod120.z.int().min(0).max(2147483647).optional(),
+  metadata: import_zod120.z.record(import_zod120.z.string(), import_zod120.z.any()).nullable().optional()
 });
 
-// src/cfg/generated/_utils/schemas/Endpoint.schema.ts
+// src/cfg/generated/_utils/schemas/DocumentStats.schema.ts
 var import_zod121 = require("zod");
-var EndpointSchema = import_zod121.z.object({
-  url: import_zod121.z.string(),
-  url_pattern: import_zod121.z.string().nullable().optional(),
-  url_name: import_zod121.z.string().nullable().optional(),
-  namespace: import_zod121.z.string().optional(),
-  group: import_zod121.z.string(),
-  view: import_zod121.z.string().optional(),
-  status: import_zod121.z.string(),
-  status_code: import_zod121.z.int().nullable().optional(),
-  response_time_ms: import_zod121.z.number().nullable().optional(),
-  is_healthy: import_zod121.z.boolean().nullable().optional(),
-  error: import_zod121.z.string().optional(),
-  error_type: import_zod121.z.string().optional(),
-  reason: import_zod121.z.string().optional(),
-  last_checked: import_zod121.z.iso.datetime().nullable().optional(),
-  has_parameters: import_zod121.z.boolean().optional(),
-  required_auth: import_zod121.z.boolean().optional(),
-  rate_limited: import_zod121.z.boolean().optional()
+var DocumentStatsSchema = import_zod121.z.object({
+  total_documents: import_zod121.z.int(),
+  completed_documents: import_zod121.z.int(),
+  processing_success_rate: import_zod121.z.number(),
+  total_chunks: import_zod121.z.int(),
+  total_tokens: import_zod121.z.int(),
+  total_cost_usd: import_zod121.z.number(),
+  avg_processing_time_seconds: import_zod121.z.number()
 });
 
-// src/cfg/generated/_utils/schemas/EndpointsStatus.schema.ts
+// src/cfg/generated/_utils/schemas/EmailLog.schema.ts
 var import_zod122 = require("zod");
-var EndpointsStatusSchema = import_zod122.z.object({
-  status: import_zod122.z.string(),
-  timestamp: import_zod122.z.iso.datetime(),
-  total_endpoints: import_zod122.z.int(),
-  healthy: import_zod122.z.int(),
-  unhealthy: import_zod122.z.int(),
-  warnings: import_zod122.z.int(),
-  errors: import_zod122.z.int(),
-  skipped: import_zod122.z.int(),
-  endpoints: import_zod122.z.array(EndpointSchema)
+var EmailLogSchema = import_zod122.z.object({
+  id: import_zod122.z.uuid(),
+  user: import_zod122.z.int().nullable(),
+  user_email: import_zod122.z.string(),
+  newsletter: import_zod122.z.int().nullable(),
+  newsletter_title: import_zod122.z.string(),
+  recipient: import_zod122.z.string(),
+  subject: import_zod122.z.string(),
+  body: import_zod122.z.string(),
+  status: import_zod122.z.nativeEnum(EmailLogStatus),
+  created_at: import_zod122.z.iso.datetime(),
+  sent_at: import_zod122.z.iso.datetime().nullable(),
+  error_message: import_zod122.z.string().nullable()
 });
 
-// src/cfg/generated/_utils/schemas/ErrorResponse.schema.ts
+// src/cfg/generated/_utils/schemas/Endpoint.schema.ts
 var import_zod123 = require("zod");
-var ErrorResponseSchema = import_zod123.z.object({
-  success: import_zod123.z.boolean().optional(),
-  message: import_zod123.z.string()
+var EndpointSchema = import_zod123.z.object({
+  url: import_zod123.z.string(),
+  url_pattern: import_zod123.z.string().nullable().optional(),
+  url_name: import_zod123.z.string().nullable().optional(),
+  namespace: import_zod123.z.string().optional(),
+  group: import_zod123.z.string(),
+  view: import_zod123.z.string().optional(),
+  status: import_zod123.z.string(),
+  status_code: import_zod123.z.int().nullable().optional(),
+  response_time_ms: import_zod123.z.number().nullable().optional(),
+  is_healthy: import_zod123.z.boolean().nullable().optional(),
+  error: import_zod123.z.string().optional(),
+  error_type: import_zod123.z.string().optional(),
+  reason: import_zod123.z.string().optional(),
+  last_checked: import_zod123.z.iso.datetime().nullable().optional(),
+  has_parameters: import_zod123.z.boolean().optional(),
+  required_auth: import_zod123.z.boolean().optional(),
+  rate_limited: import_zod123.z.boolean().optional()
 });
 
-// src/cfg/generated/_utils/schemas/GRPCCallRequestRequest.schema.ts
+// src/cfg/generated/_utils/schemas/EndpointsStatus.schema.ts
 var import_zod124 = require("zod");
-var GRPCCallRequestRequestSchema = import_zod124.z.object({
-  service: import_zod124.z.string().min(1),
-  method: import_zod124.z.string().min(1),
-  payload: import_zod124.z.record(import_zod124.z.string(), import_zod124.z.record(import_zod124.z.string(), import_zod124.z.any())),
-  metadata: import_zod124.z.record(import_zod124.z.string(), import_zod124.z.record(import_zod124.z.string(), import_zod124.z.any())).optional(),
-  timeout_ms: import_zod124.z.int().optional()
+var EndpointsStatusSchema = import_zod124.z.object({
+  status: import_zod124.z.string(),
+  timestamp: import_zod124.z.iso.datetime(),
+  total_endpoints: import_zod124.z.int(),
+  healthy: import_zod124.z.int(),
+  unhealthy: import_zod124.z.int(),
+  warnings: import_zod124.z.int(),
+  errors: import_zod124.z.int(),
+  skipped: import_zod124.z.int(),
+  endpoints: import_zod124.z.array(EndpointSchema)
 });
 
-// src/cfg/generated/_utils/schemas/GRPCCallResponse.schema.ts
+// src/cfg/generated/_utils/schemas/ErrorResponse.schema.ts
 var import_zod125 = require("zod");
-var GRPCCallResponseSchema = import_zod125.z.object({
-  success: import_zod125.z.boolean(),
-  request_id: import_zod125.z.string(),
-  service: import_zod125.z.string(),
-  method: import_zod125.z.string(),
-  status: import_zod125.z.string(),
-  grpc_status_code: import_zod125.z.string(),
-  duration_ms: import_zod125.z.int(),
-  response: import_zod125.z.string().nullable().optional(),
-  error: import_zod125.z.string().nullable().optional(),
-  metadata: import_zod125.z.record(import_zod125.z.string(), import_zod125.z.record(import_zod125.z.string(), import_zod125.z.any())).optional(),
-  timestamp: import_zod125.z.string()
+var ErrorResponseSchema = import_zod125.z.object({
+  success: import_zod125.z.boolean().optional(),
+  message: import_zod125.z.string()
+});
+
+// src/cfg/generated/_utils/schemas/GRPCCallRequestRequest.schema.ts
+var import_zod126 = require("zod");
+var GRPCCallRequestRequestSchema = import_zod126.z.object({
+  service: import_zod126.z.string().min(1),
+  method: import_zod126.z.string().min(1),
+  payload: import_zod126.z.record(import_zod126.z.string(), import_zod126.z.record(import_zod126.z.string(), import_zod126.z.any())),
+  metadata: import_zod126.z.record(import_zod126.z.string(), import_zod126.z.record(import_zod126.z.string(), import_zod126.z.any())).optional(),
+  timeout_ms: import_zod126.z.int().optional()
+});
+
+// src/cfg/generated/_utils/schemas/GRPCCallResponse.schema.ts
+var import_zod127 = require("zod");
+var GRPCCallResponseSchema = import_zod127.z.object({
+  success: import_zod127.z.boolean(),
+  request_id: import_zod127.z.string(),
+  service: import_zod127.z.string(),
+  method: import_zod127.z.string(),
+  status: import_zod127.z.string(),
+  grpc_status_code: import_zod127.z.string(),
+  duration_ms: import_zod127.z.int(),
+  response: import_zod127.z.string().nullable().optional(),
+  error: import_zod127.z.string().nullable().optional(),
+  metadata: import_zod127.z.record(import_zod127.z.string(), import_zod127.z.record(import_zod127.z.string(), import_zod127.z.any())).optional(),
+  timestamp: import_zod127.z.string()
 });
 
 // src/cfg/generated/_utils/schemas/GRPCConfig.schema.ts
-var import_zod129 = require("zod");
+var import_zod131 = require("zod");
 
 // src/cfg/generated/_utils/schemas/GRPCFeatures.schema.ts
-var import_zod126 = require("zod");
-var GRPCFeaturesSchema = import_zod126.z.object({
-  api_key_auth: import_zod126.z.boolean(),
-  request_logging: import_zod126.z.boolean(),
-  metrics: import_zod126.z.boolean(),
-  reflection: import_zod126.z.boolean()
+var import_zod128 = require("zod");
+var GRPCFeaturesSchema = import_zod128.z.object({
+  api_key_auth: import_zod128.z.boolean(),
+  request_logging: import_zod128.z.boolean(),
+  metrics: import_zod128.z.boolean(),
+  reflection: import_zod128.z.boolean()
 });
 
 // src/cfg/generated/_utils/schemas/GRPCFrameworkConfig.schema.ts
-var import_zod127 = require("zod");
-var GRPCFrameworkConfigSchema = import_zod127.z.object({
-  enabled: import_zod127.z.boolean(),
-  auto_discover: import_zod127.z.boolean(),
-  services_path: import_zod127.z.string(),
-  interceptors: import_zod127.z.array(import_zod127.z.string()).optional()
+var import_zod129 = require("zod");
+var GRPCFrameworkConfigSchema = import_zod129.z.object({
+  enabled: import_zod129.z.boolean(),
+  auto_discover: import_zod129.z.boolean(),
+  services_path: import_zod129.z.string(),
+  interceptors: import_zod129.z.array(import_zod129.z.string()).optional()
 });
 
 // src/cfg/generated/_utils/schemas/GRPCServerConfig.schema.ts
-var import_zod128 = require("zod");
-var GRPCServerConfigSchema = import_zod128.z.object({
-  host: import_zod128.z.string(),
-  port: import_zod128.z.int(),
-  enabled: import_zod128.z.boolean(),
-  max_concurrent_streams: import_zod128.z.int().nullable().optional(),
-  max_concurrent_rpcs: import_zod128.z.int().nullable().optional()
+var import_zod130 = require("zod");
+var GRPCServerConfigSchema = import_zod130.z.object({
+  host: import_zod130.z.string(),
+  port: import_zod130.z.int(),
+  enabled: import_zod130.z.boolean(),
+  max_concurrent_streams: import_zod130.z.int().nullable().optional(),
+  max_concurrent_rpcs: import_zod130.z.int().nullable().optional()
 });
 
 // src/cfg/generated/_utils/schemas/GRPCConfig.schema.ts
-var GRPCConfigSchema = import_zod129.z.object({
+var GRPCConfigSchema = import_zod131.z.object({
   server: GRPCServerConfigSchema,
   framework: GRPCFrameworkConfigSchema,
   features: GRPCFeaturesSchema,
-  registered_services: import_zod129.z.int(),
-  total_methods: import_zod129.z.int()
+  registered_services: import_zod131.z.int(),
+  total_methods: import_zod131.z.int()
 });
 
 // src/cfg/generated/_utils/schemas/GRPCExample.schema.ts
-var import_zod130 = require("zod");
-var GRPCExampleSchema = import_zod130.z.object({
-  service: import_zod130.z.string(),
-  method: import_zod130.z.string(),
-  description: import_zod130.z.string(),
-  payload_example: import_zod130.z.record(import_zod130.z.string(), import_zod130.z.record(import_zod130.z.string(), import_zod130.z.any())),
-  expected_response: import_zod130.z.record(import_zod130.z.string(), import_zod130.z.record(import_zod130.z.string(), import_zod130.z.any())),
-  metadata_example: import_zod130.z.record(import_zod130.z.string(), import_zod130.z.record(import_zod130.z.string(), import_zod130.z.any())).optional()
+var import_zod132 = require("zod");
+var GRPCExampleSchema = import_zod132.z.object({
+  service: import_zod132.z.string(),
+  method: import_zod132.z.string(),
+  description: import_zod132.z.string(),
+  payload_example: import_zod132.z.record(import_zod132.z.string(), import_zod132.z.record(import_zod132.z.string(), import_zod132.z.any())),
+  expected_response: import_zod132.z.record(import_zod132.z.string(), import_zod132.z.record(import_zod132.z.string(), import_zod132.z.any())),
+  metadata_example: import_zod132.z.record(import_zod132.z.string(), import_zod132.z.record(import_zod132.z.string(), import_zod132.z.any())).optional()
 });
 
 // src/cfg/generated/_utils/schemas/GRPCExamplesList.schema.ts
-var import_zod131 = require("zod");
-var GRPCExamplesListSchema = import_zod131.z.object({
-  examples: import_zod131.z.array(GRPCExampleSchema).optional(),
-  total_examples: import_zod131.z.int()
+var import_zod133 = require("zod");
+var GRPCExamplesListSchema = import_zod133.z.object({
+  examples: import_zod133.z.array(GRPCExampleSchema).optional(),
+  total_examples: import_zod133.z.int()
 });
 
 // src/cfg/generated/_utils/schemas/GRPCHealthCheck.schema.ts
-var import_zod132 = require("zod");
-var GRPCHealthCheckSchema = import_zod132.z.object({
-  status: import_zod132.z.string(),
-  server_host: import_zod132.z.string(),
-  server_port: import_zod132.z.int(),
-  enabled: import_zod132.z.boolean(),
-  timestamp: import_zod132.z.string()
+var import_zod134 = require("zod");
+var GRPCHealthCheckSchema = import_zod134.z.object({
+  status: import_zod134.z.string(),
+  server_host: import_zod134.z.string(),
+  server_port: import_zod134.z.int(),
+  enabled: import_zod134.z.boolean(),
+  timestamp: import_zod134.z.string()
 });
 
 // src/cfg/generated/_utils/schemas/GRPCInterceptorInfo.schema.ts
-var import_zod133 = require("zod");
-var GRPCInterceptorInfoSchema = import_zod133.z.object({
-  name: import_zod133.z.string(),
-  enabled: import_zod133.z.boolean()
+var import_zod135 = require("zod");
+var GRPCInterceptorInfoSchema = import_zod135.z.object({
+  name: import_zod135.z.string(),
+  enabled: import_zod135.z.boolean()
 });
 
-// src/cfg/generated/_utils/schemas/GRPCOverviewStats.schema.ts
+// src/cfg/generated/_utils/schemas/GRPCMethodStats.schema.ts
 var import_zod136 = require("zod");
+var GRPCMethodStatsSchema = import_zod136.z.object({
+  method_name: import_zod136.z.string(),
+  service_name: import_zod136.z.string(),
+  total: import_zod136.z.int(),
+  successful: import_zod136.z.int(),
+  errors: import_zod136.z.int(),
+  avg_duration_ms: import_zod136.z.number(),
+  last_activity_at: import_zod136.z.string().nullable()
+});
+
+// src/cfg/generated/_utils/schemas/GRPCOverviewStats.schema.ts
+var import_zod139 = require("zod");
 
 // src/cfg/generated/_utils/schemas/GRPCServerStatus.schema.ts
-var import_zod135 = require("zod");
+var import_zod138 = require("zod");
 
 // src/cfg/generated/_utils/schemas/GRPCRegisteredService.schema.ts
-var import_zod134 = require("zod");
-var GRPCRegisteredServiceSchema = import_zod134.z.object({
-  name: import_zod134.z.string(),
-  full_name: import_zod134.z.string(),
-  methods_count: import_zod134.z.int(),
-  request_count: import_zod134.z.int(),
-  error_count: import_zod134.z.int(),
-  success_rate: import_zod134.z.number()
+var import_zod137 = require("zod");
+var GRPCRegisteredServiceSchema = import_zod137.z.object({
+  name: import_zod137.z.string(),
+  full_name: import_zod137.z.string(),
+  methods_count: import_zod137.z.int(),
+  request_count: import_zod137.z.int(),
+  error_count: import_zod137.z.int(),
+  success_rate: import_zod137.z.number()
 });
 
 // src/cfg/generated/_utils/schemas/GRPCServerStatus.schema.ts
-var GRPCServerStatusSchema = import_zod135.z.object({
-  status: import_zod135.z.string(),
-  is_running: import_zod135.z.boolean(),
-  host: import_zod135.z.string(),
-  port: import_zod135.z.int(),
-  address: import_zod135.z.string(),
-  pid: import_zod135.z.int().nullable(),
-  started_at: import_zod135.z.iso.datetime().nullable(),
-  uptime_seconds: import_zod135.z.int(),
-  uptime_display: import_zod135.z.string(),
-  registered_services_count: import_zod135.z.int(),
-  enable_reflection: import_zod135.z.boolean(),
-  enable_health_check: import_zod135.z.boolean(),
-  last_heartbeat: import_zod135.z.iso.datetime().nullable(),
-  services: import_zod135.z.array(GRPCRegisteredServiceSchema),
-  services_healthy: import_zod135.z.boolean()
+var GRPCServerStatusSchema = import_zod138.z.object({
+  status: import_zod138.z.string(),
+  is_running: import_zod138.z.boolean(),
+  host: import_zod138.z.string(),
+  port: import_zod138.z.int(),
+  address: import_zod138.z.string(),
+  pid: import_zod138.z.int().nullable(),
+  started_at: import_zod138.z.iso.datetime().nullable(),
+  uptime_seconds: import_zod138.z.int(),
+  uptime_display: import_zod138.z.string(),
+  registered_services_count: import_zod138.z.int(),
+  enable_reflection: import_zod138.z.boolean(),
+  enable_health_check: import_zod138.z.boolean(),
+  last_heartbeat: import_zod138.z.iso.datetime().nullable(),
+  services: import_zod138.z.array(GRPCRegisteredServiceSchema),
+  services_healthy: import_zod138.z.boolean()
 });
 
 // src/cfg/generated/_utils/schemas/GRPCOverviewStats.schema.ts
-var GRPCOverviewStatsSchema = import_zod136.z.object({
-  total: import_zod136.z.int(),
-  successful: import_zod136.z.int(),
-  errors: import_zod136.z.int(),
-  cancelled: import_zod136.z.int(),
-  timeout: import_zod136.z.int(),
-  success_rate: import_zod136.z.number(),
-  avg_duration_ms: import_zod136.z.number(),
-  p95_duration_ms: import_zod136.z.number().nullable(),
-  period_hours: import_zod136.z.int(),
+var GRPCOverviewStatsSchema = import_zod139.z.object({
+  total: import_zod139.z.int(),
+  successful: import_zod139.z.int(),
+  errors: import_zod139.z.int(),
+  cancelled: import_zod139.z.int(),
+  timeout: import_zod139.z.int(),
+  success_rate: import_zod139.z.number(),
+  avg_duration_ms: import_zod139.z.number(),
+  p95_duration_ms: import_zod139.z.number().nullable(),
+  period_hours: import_zod139.z.int(),
   server: GRPCServerStatusSchema
 });
 
 // src/cfg/generated/_utils/schemas/GRPCServerInfo.schema.ts
-var import_zod139 = require("zod");
+var import_zod142 = require("zod");
 
 // src/cfg/generated/_utils/schemas/GRPCServiceInfo.schema.ts
-var import_zod137 = require("zod");
-var GRPCServiceInfoSchema = import_zod137.z.object({
-  name: import_zod137.z.string(),
-  methods: import_zod137.z.array(import_zod137.z.string()).optional(),
-  full_name: import_zod137.z.string(),
-  description: import_zod137.z.string().optional()
+var import_zod140 = require("zod");
+var GRPCServiceInfoSchema = import_zod140.z.object({
+  name: import_zod140.z.string(),
+  methods: import_zod140.z.array(import_zod140.z.string()).optional(),
+  full_name: import_zod140.z.string(),
+  description: import_zod140.z.string().optional()
 });
 
 // src/cfg/generated/_utils/schemas/GRPCStats.schema.ts
-var import_zod138 = require("zod");
-var GRPCStatsSchema = import_zod138.z.object({
-  total_requests: import_zod138.z.int(),
-  success_rate: import_zod138.z.number(),
-  avg_duration_ms: import_zod138.z.number()
+var import_zod141 = require("zod");
+var GRPCStatsSchema = import_zod141.z.object({
+  total_requests: import_zod141.z.int(),
+  success_rate: import_zod141.z.number(),
+  avg_duration_ms: import_zod141.z.number()
 });
 
 // src/cfg/generated/_utils/schemas/GRPCServerInfo.schema.ts
-var GRPCServerInfoSchema = import_zod139.z.object({
-  server_status: import_zod139.z.string(),
-  address: import_zod139.z.string(),
-  started_at: import_zod139.z.string().nullable().optional(),
-  uptime_seconds: import_zod139.z.int().nullable().optional(),
-  services: import_zod139.z.array(GRPCServiceInfoSchema).optional(),
-  interceptors: import_zod139.z.array(GRPCInterceptorInfoSchema).optional(),
+var GRPCServerInfoSchema = import_zod142.z.object({
+  server_status: import_zod142.z.string(),
+  address: import_zod142.z.string(),
+  started_at: import_zod142.z.string().nullable().optional(),
+  uptime_seconds: import_zod142.z.int().nullable().optional(),
+  services: import_zod142.z.array(GRPCServiceInfoSchema).optional(),
+  interceptors: import_zod142.z.array(GRPCInterceptorInfoSchema).optional(),
   stats: GRPCStatsSchema
 });
 
+// src/cfg/generated/_utils/schemas/GRPCServiceRegistryMethodStats.schema.ts
+var import_zod143 = require("zod");
+var GRPCServiceRegistryMethodStatsSchema = import_zod143.z.object({
+  total_requests: import_zod143.z.int().optional(),
+  successful: import_zod143.z.int().optional(),
+  errors: import_zod143.z.int().optional(),
+  success_rate: import_zod143.z.number().optional(),
+  avg_duration_ms: import_zod143.z.number().optional(),
+  p50_duration_ms: import_zod143.z.number().optional(),
+  p95_duration_ms: import_zod143.z.number().optional(),
+  p99_duration_ms: import_zod143.z.number().optional()
+});
+
 // src/cfg/generated/_utils/schemas/GRPCTestLog.schema.ts
-var import_zod140 = require("zod");
-var GRPCTestLogSchema = import_zod140.z.object({
-  request_id: import_zod140.z.string(),
-  service: import_zod140.z.string(),
-  method: import_zod140.z.string(),
-  status: import_zod140.z.string(),
-  grpc_status_code: import_zod140.z.string().nullable().optional(),
-  error_message: import_zod140.z.string().nullable().optional(),
-  duration_ms: import_zod140.z.int().nullable().optional(),
-  created_at: import_zod140.z.string(),
-  user: import_zod140.z.string().nullable().optional()
-});
-
-// src/cfg/generated/_utils/schemas/HealthCheck.schema.ts
-var import_zod141 = require("zod");
-var HealthCheckSchema = import_zod141.z.object({
-  status: import_zod141.z.string(),
-  wrapper_url: import_zod141.z.string(),
-  has_api_key: import_zod141.z.boolean(),
-  timestamp: import_zod141.z.string()
+var import_zod144 = require("zod");
+var GRPCTestLogSchema = import_zod144.z.object({
+  request_id: import_zod144.z.string(),
+  service: import_zod144.z.string(),
+  method: import_zod144.z.string(),
+  status: import_zod144.z.string(),
+  grpc_status_code: import_zod144.z.string().nullable().optional(),
+  error_message: import_zod144.z.string().nullable().optional(),
+  duration_ms: import_zod144.z.int().nullable().optional(),
+  created_at: import_zod144.z.string(),
+  user: import_zod144.z.string().nullable().optional()
 });
 
 // src/cfg/generated/_utils/schemas/JobActionResponse.schema.ts
-var import_zod142 = require("zod");
-var JobActionResponseSchema = import_zod142.z.object({
-  success: import_zod142.z.boolean(),
-  message: import_zod142.z.string(),
-  job_id: import_zod142.z.string(),
-  action: import_zod142.z.string()
+var import_zod145 = require("zod");
+var JobActionResponseSchema = import_zod145.z.object({
+  success: import_zod145.z.boolean(),
+  message: import_zod145.z.string(),
+  job_id: import_zod145.z.string(),
+  action: import_zod145.z.string()
 });
 
 // src/cfg/generated/_utils/schemas/JobDetail.schema.ts
-var import_zod143 = require("zod");
-var JobDetailSchema = import_zod143.z.object({
-  id: import_zod143.z.string(),
-  func_name: import_zod143.z.string(),
-  args: import_zod143.z.array(import_zod143.z.record(import_zod143.z.string(), import_zod143.z.any())).optional(),
-  kwargs: import_zod143.z.record(import_zod143.z.string(), import_zod143.z.any()).optional(),
-  created_at: import_zod143.z.iso.datetime(),
-  enqueued_at: import_zod143.z.iso.datetime().nullable().optional(),
-  started_at: import_zod143.z.iso.datetime().nullable().optional(),
-  ended_at: import_zod143.z.iso.datetime().nullable().optional(),
-  status: import_zod143.z.string(),
-  queue: import_zod143.z.string(),
-  worker_name: import_zod143.z.string().nullable().optional(),
-  timeout: import_zod143.z.int().nullable().optional(),
-  result_ttl: import_zod143.z.int().nullable().optional(),
-  failure_ttl: import_zod143.z.int().nullable().optional(),
-  result: import_zod143.z.record(import_zod143.z.string(), import_zod143.z.any()).nullable().optional(),
-  exc_info: import_zod143.z.string().nullable().optional(),
-  meta: import_zod143.z.record(import_zod143.z.string(), import_zod143.z.any()).optional(),
-  dependency_ids: import_zod143.z.array(import_zod143.z.string()).optional()
+var import_zod146 = require("zod");
+var JobDetailSchema = import_zod146.z.object({
+  id: import_zod146.z.string(),
+  func_name: import_zod146.z.string(),
+  args: import_zod146.z.array(import_zod146.z.record(import_zod146.z.string(), import_zod146.z.any())).optional(),
+  kwargs: import_zod146.z.record(import_zod146.z.string(), import_zod146.z.any()).optional(),
+  created_at: import_zod146.z.iso.datetime(),
+  enqueued_at: import_zod146.z.iso.datetime().nullable().optional(),
+  started_at: import_zod146.z.iso.datetime().nullable().optional(),
+  ended_at: import_zod146.z.iso.datetime().nullable().optional(),
+  status: import_zod146.z.string(),
+  queue: import_zod146.z.string(),
+  worker_name: import_zod146.z.string().nullable().optional(),
+  timeout: import_zod146.z.int().nullable().optional(),
+  result_ttl: import_zod146.z.int().nullable().optional(),
+  failure_ttl: import_zod146.z.int().nullable().optional(),
+  result: import_zod146.z.record(import_zod146.z.string(), import_zod146.z.any()).nullable().optional(),
+  exc_info: import_zod146.z.string().nullable().optional(),
+  meta: import_zod146.z.record(import_zod146.z.string(), import_zod146.z.any()).optional(),
+  dependency_ids: import_zod146.z.array(import_zod146.z.string()).optional()
 });
 
 // src/cfg/generated/_utils/schemas/JobList.schema.ts
-var import_zod144 = require("zod");
-var JobListSchema = import_zod144.z.object({
-  id: import_zod144.z.string(),
-  func_name: import_zod144.z.string(),
-  created_at: import_zod144.z.iso.datetime(),
-  status: import_zod144.z.string(),
-  queue: import_zod144.z.string(),
-  timeout: import_zod144.z.int().nullable().optional()
+var import_zod147 = require("zod");
+var JobListSchema = import_zod147.z.object({
+  id: import_zod147.z.string(),
+  func_name: import_zod147.z.string(),
+  created_at: import_zod147.z.iso.datetime(),
+  status: import_zod147.z.string(),
+  queue: import_zod147.z.string(),
+  timeout: import_zod147.z.int().nullable().optional()
 });
 
 // src/cfg/generated/_utils/schemas/JobListRequest.schema.ts
-var import_zod145 = require("zod");
-var JobListRequestSchema = import_zod145.z.object({
-  id: import_zod145.z.string().min(1),
-  func_name: import_zod145.z.string().min(1),
-  created_at: import_zod145.z.iso.datetime(),
-  status: import_zod145.z.string().min(1),
-  queue: import_zod145.z.string().min(1),
-  timeout: import_zod145.z.int().nullable().optional()
+var import_zod148 = require("zod");
+var JobListRequestSchema = import_zod148.z.object({
+  id: import_zod148.z.string().min(1),
+  func_name: import_zod148.z.string().min(1),
+  created_at: import_zod148.z.iso.datetime(),
+  status: import_zod148.z.string().min(1),
+  queue: import_zod148.z.string().min(1),
+  timeout: import_zod148.z.int().nullable().optional()
 });
 
 // src/cfg/generated/_utils/schemas/LeadSubmission.schema.ts
-var import_zod146 = require("zod");
-var LeadSubmissionSchema = import_zod146.z.object({
-  name: import_zod146.z.string().max(200),
-  email: import_zod146.z.email(),
-  company: import_zod146.z.string().max(200).nullable().optional(),
-  company_site: import_zod146.z.string().max(200).nullable().optional(),
-  contact_type: import_zod146.z.nativeEnum(LeadSubmissionContactType).optional(),
-  contact_value: import_zod146.z.string().max(200).nullable().optional(),
-  subject: import_zod146.z.string().max(200).nullable().optional(),
-  message: import_zod146.z.string(),
-  extra: import_zod146.z.record(import_zod146.z.string(), import_zod146.z.any()).nullable().optional(),
-  site_url: import_zod146.z.url()
+var import_zod149 = require("zod");
+var LeadSubmissionSchema = import_zod149.z.object({
+  name: import_zod149.z.string().max(200),
+  email: import_zod149.z.email(),
+  company: import_zod149.z.string().max(200).nullable().optional(),
+  company_site: import_zod149.z.string().max(200).nullable().optional(),
+  contact_type: import_zod149.z.nativeEnum(LeadSubmissionContactType).optional(),
+  contact_value: import_zod149.z.string().max(200).nullable().optional(),
+  subject: import_zod149.z.string().max(200).nullable().optional(),
+  message: import_zod149.z.string(),
+  extra: import_zod149.z.record(import_zod149.z.string(), import_zod149.z.any()).nullable().optional(),
+  site_url: import_zod149.z.url()
 });
 
 // src/cfg/generated/_utils/schemas/LeadSubmissionError.schema.ts
-var import_zod147 = require("zod");
-var LeadSubmissionErrorSchema = import_zod147.z.object({
-  success: import_zod147.z.boolean(),
-  error: import_zod147.z.string(),
-  details: import_zod147.z.record(import_zod147.z.string(), import_zod147.z.record(import_zod147.z.string(), import_zod147.z.any())).optional()
+var import_zod150 = require("zod");
+var LeadSubmissionErrorSchema = import_zod150.z.object({
+  success: import_zod150.z.boolean(),
+  error: import_zod150.z.string(),
+  details: import_zod150.z.record(import_zod150.z.string(), import_zod150.z.record(import_zod150.z.string(), import_zod150.z.any())).optional()
 });
 
 // src/cfg/generated/_utils/schemas/LeadSubmissionRequest.schema.ts
-var import_zod148 = require("zod");
-var LeadSubmissionRequestSchema = import_zod148.z.object({
-  name: import_zod148.z.string().min(1).max(200),
-  email: import_zod148.z.email(),
-  company: import_zod148.z.string().max(200).nullable().optional(),
-  company_site: import_zod148.z.string().max(200).nullable().optional(),
-  contact_type: import_zod148.z.nativeEnum(LeadSubmissionRequestContactType).optional(),
-  contact_value: import_zod148.z.string().max(200).nullable().optional(),
-  subject: import_zod148.z.string().max(200).nullable().optional(),
-  message: import_zod148.z.string().min(1),
-  extra: import_zod148.z.record(import_zod148.z.string(), import_zod148.z.any()).nullable().optional(),
-  site_url: import_zod148.z.url()
+var import_zod151 = require("zod");
+var LeadSubmissionRequestSchema = import_zod151.z.object({
+  name: import_zod151.z.string().min(1).max(200),
+  email: import_zod151.z.email(),
+  company: import_zod151.z.string().max(200).nullable().optional(),
+  company_site: import_zod151.z.string().max(200).nullable().optional(),
+  contact_type: import_zod151.z.nativeEnum(LeadSubmissionRequestContactType).optional(),
+  contact_value: import_zod151.z.string().max(200).nullable().optional(),
+  subject: import_zod151.z.string().max(200).nullable().optional(),
+  message: import_zod151.z.string().min(1),
+  extra: import_zod151.z.record(import_zod151.z.string(), import_zod151.z.any()).nullable().optional(),
+  site_url: import_zod151.z.url()
 });
 
 // src/cfg/generated/_utils/schemas/LeadSubmissionResponse.schema.ts
-var import_zod149 = require("zod");
-var LeadSubmissionResponseSchema = import_zod149.z.object({
-  success: import_zod149.z.boolean(),
-  message: import_zod149.z.string(),
-  lead_id: import_zod149.z.int()
+var import_zod152 = require("zod");
+var LeadSubmissionResponseSchema = import_zod152.z.object({
+  success: import_zod152.z.boolean(),
+  message: import_zod152.z.string(),
+  lead_id: import_zod152.z.int()
 });
 
 // src/cfg/generated/_utils/schemas/ManualAckRequestRequest.schema.ts
-var import_zod150 = require("zod");
-var ManualAckRequestRequestSchema = import_zod150.z.object({
-  message_id: import_zod150.z.string(),
-  client_id: import_zod150.z.string()
+var import_zod153 = require("zod");
+var ManualAckRequestRequestSchema = import_zod153.z.object({
+  message_id: import_zod153.z.string(),
+  client_id: import_zod153.z.string()
 });
 
 // src/cfg/generated/_utils/schemas/ManualAckResponse.schema.ts
-var import_zod151 = require("zod");
-var ManualAckResponseSchema = import_zod151.z.object({
-  success: import_zod151.z.boolean(),
-  message_id: import_zod151.z.string(),
-  error: import_zod151.z.string().nullable().optional()
+var import_zod154 = require("zod");
+var ManualAckResponseSchema = import_zod154.z.object({
+  success: import_zod154.z.boolean(),
+  message_id: import_zod154.z.string(),
+  error: import_zod154.z.string().nullable().optional()
 });
 
 // src/cfg/generated/_utils/schemas/Message.schema.ts
-var import_zod153 = require("zod");
+var import_zod156 = require("zod");
 
 // src/cfg/generated/_utils/schemas/Sender.schema.ts
-var import_zod152 = require("zod");
-var SenderSchema = import_zod152.z.object({
-  id: import_zod152.z.int(),
-  display_username: import_zod152.z.string(),
-  email: import_zod152.z.email(),
-  avatar: import_zod152.z.string().nullable(),
-  initials: import_zod152.z.string(),
-  is_staff: import_zod152.z.boolean(),
-  is_superuser: import_zod152.z.boolean()
+var import_zod155 = require("zod");
+var SenderSchema = import_zod155.z.object({
+  id: import_zod155.z.int(),
+  display_username: import_zod155.z.string(),
+  email: import_zod155.z.email(),
+  avatar: import_zod155.z.string().nullable(),
+  initials: import_zod155.z.string(),
+  is_staff: import_zod155.z.boolean(),
+  is_superuser: import_zod155.z.boolean()
 });
 
 // src/cfg/generated/_utils/schemas/Message.schema.ts
-var MessageSchema = import_zod153.z.object({
-  uuid: import_zod153.z.uuid(),
-  ticket: import_zod153.z.uuid(),
+var MessageSchema = import_zod156.z.object({
+  uuid: import_zod156.z.uuid(),
+  ticket: import_zod156.z.uuid(),
   sender: SenderSchema,
-  is_from_author: import_zod153.z.boolean(),
-  text: import_zod153.z.string(),
-  created_at: import_zod153.z.iso.datetime()
+  is_from_author: import_zod156.z.boolean(),
+  text: import_zod156.z.string(),
+  created_at: import_zod156.z.iso.datetime()
 });
 
 // src/cfg/generated/_utils/schemas/MessageCreate.schema.ts
-var import_zod154 = require("zod");
-var MessageCreateSchema = import_zod154.z.object({
-  text: import_zod154.z.string()
-});
-
-// src/cfg/generated/_utils/schemas/MessageCreateRequest.schema.ts
-var import_zod155 = require("zod");
-var MessageCreateRequestSchema = import_zod155.z.object({
-  text: import_zod155.z.string().min(1)
-});
-
-// src/cfg/generated/_utils/schemas/MessageRequest.schema.ts
-var import_zod156 = require("zod");
-var MessageRequestSchema = import_zod156.z.object({
-  text: import_zod156.z.string().min(1)
-});
-
-// src/cfg/generated/_utils/schemas/MethodInfo.schema.ts
 var import_zod157 = require("zod");
-var MethodInfoSchema = import_zod157.z.object({
-  name: import_zod157.z.string(),
-  full_name: import_zod157.z.string(),
-  request_type: import_zod157.z.string().optional(),
-  response_type: import_zod157.z.string().optional(),
-  streaming: import_zod157.z.boolean().optional(),
-  auth_required: import_zod157.z.boolean().optional()
+var MessageCreateSchema = import_zod157.z.object({
+  text: import_zod157.z.string()
 });
 
-// src/cfg/generated/_utils/schemas/MethodList.schema.ts
-var import_zod159 = require("zod");
-
-// src/cfg/generated/_utils/schemas/MethodStats.schema.ts
+// src/cfg/generated/_utils/schemas/MessageCreateRequest.schema.ts
 var import_zod158 = require("zod");
-var MethodStatsSchema = import_zod158.z.object({
-  method_name: import_zod158.z.string(),
-  service_name: import_zod158.z.string(),
-  total: import_zod158.z.int(),
-  successful: import_zod158.z.int(),
-  errors: import_zod158.z.int(),
-  avg_duration_ms: import_zod158.z.number(),
-  last_activity_at: import_zod158.z.string().nullable()
+var MessageCreateRequestSchema = import_zod158.z.object({
+  text: import_zod158.z.string().min(1)
 });
 
-// src/cfg/generated/_utils/schemas/MethodList.schema.ts
-var MethodListSchema = import_zod159.z.object({
-  methods: import_zod159.z.array(MethodStatsSchema),
-  total_methods: import_zod159.z.int()
+// src/cfg/generated/_utils/schemas/MessageRequest.schema.ts
+var import_zod159 = require("zod");
+var MessageRequestSchema = import_zod159.z.object({
+  text: import_zod159.z.string().min(1)
 });
 
-// src/cfg/generated/_utils/schemas/MethodSummary.schema.ts
+// src/cfg/generated/_utils/schemas/MethodInfo.schema.ts
 var import_zod160 = require("zod");
-var MethodSummarySchema = import_zod160.z.object({
+var MethodInfoSchema = import_zod160.z.object({
   name: import_zod160.z.string(),
   full_name: import_zod160.z.string(),
-  service_name: import_zod160.z.string(),
   request_type: import_zod160.z.string().optional(),
   response_type: import_zod160.z.string().optional(),
-  stats: MethodStatsSchema
+  streaming: import_zod160.z.boolean().optional(),
+  auth_required: import_zod160.z.boolean().optional()
 });
 
-// src/cfg/generated/_utils/schemas/Newsletter.schema.ts
+// src/cfg/generated/_utils/schemas/MethodList.schema.ts
 var import_zod161 = require("zod");
-var NewsletterSchema = import_zod161.z.object({
-  id: import_zod161.z.int(),
-  title: import_zod161.z.string().max(255),
-  description: import_zod161.z.string().optional(),
-  is_active: import_zod161.z.boolean().optional(),
-  auto_subscribe: import_zod161.z.boolean().optional(),
-  created_at: import_zod161.z.iso.datetime(),
-  updated_at: import_zod161.z.iso.datetime(),
-  subscribers_count: import_zod161.z.int()
+var MethodListSchema = import_zod161.z.object({
+  methods: import_zod161.z.array(GRPCMethodStatsSchema),
+  total_methods: import_zod161.z.int()
 });
 
-// src/cfg/generated/_utils/schemas/NewsletterCampaign.schema.ts
+// src/cfg/generated/_utils/schemas/MethodSummary.schema.ts
 var import_zod162 = require("zod");
-var NewsletterCampaignSchema = import_zod162.z.object({
-  id: import_zod162.z.int(),
-  newsletter: import_zod162.z.int(),
-  newsletter_title: import_zod162.z.string(),
-  subject: import_zod162.z.string().max(255),
-  email_title: import_zod162.z.string().max(255),
-  main_text: import_zod162.z.string(),
-  main_html_content: import_zod162.z.string().optional(),
-  button_text: import_zod162.z.string().max(100).optional(),
-  button_url: import_zod162.z.url().optional(),
-  secondary_text: import_zod162.z.string().optional(),
-  status: import_zod162.z.nativeEnum(NewsletterCampaignStatus),
-  created_at: import_zod162.z.iso.datetime(),
-  sent_at: import_zod162.z.iso.datetime().nullable(),
-  recipient_count: import_zod162.z.int()
+var MethodSummarySchema = import_zod162.z.object({
+  name: import_zod162.z.string(),
+  full_name: import_zod162.z.string(),
+  service_name: import_zod162.z.string(),
+  request_type: import_zod162.z.string().optional(),
+  response_type: import_zod162.z.string().optional(),
+  stats: GRPCServiceRegistryMethodStatsSchema
 });
 
-// src/cfg/generated/_utils/schemas/NewsletterCampaignRequest.schema.ts
+// src/cfg/generated/_utils/schemas/Newsletter.schema.ts
 var import_zod163 = require("zod");
-var NewsletterCampaignRequestSchema = import_zod163.z.object({
-  newsletter: import_zod163.z.int(),
-  subject: import_zod163.z.string().min(1).max(255),
-  email_title: import_zod163.z.string().min(1).max(255),
-  main_text: import_zod163.z.string().min(1),
-  main_html_content: import_zod163.z.string().optional(),
-  button_text: import_zod163.z.string().max(100).optional(),
-  button_url: import_zod163.z.url().optional(),
-  secondary_text: import_zod163.z.string().optional()
+var NewsletterSchema = import_zod163.z.object({
+  id: import_zod163.z.int(),
+  title: import_zod163.z.string().max(255),
+  description: import_zod163.z.string().optional(),
+  is_active: import_zod163.z.boolean().optional(),
+  auto_subscribe: import_zod163.z.boolean().optional(),
+  created_at: import_zod163.z.iso.datetime(),
+  updated_at: import_zod163.z.iso.datetime(),
+  subscribers_count: import_zod163.z.int()
 });
 
-// src/cfg/generated/_utils/schemas/NewsletterSubscription.schema.ts
+// src/cfg/generated/_utils/schemas/NewsletterCampaign.schema.ts
 var import_zod164 = require("zod");
-var NewsletterSubscriptionSchema = import_zod164.z.object({
+var NewsletterCampaignSchema = import_zod164.z.object({
   id: import_zod164.z.int(),
   newsletter: import_zod164.z.int(),
   newsletter_title: import_zod164.z.string(),
-  user: import_zod164.z.int().nullable().optional(),
-  user_email: import_zod164.z.string(),
-  email: import_zod164.z.email(),
-  is_active: import_zod164.z.boolean().optional(),
-  subscribed_at: import_zod164.z.iso.datetime(),
-  unsubscribed_at: import_zod164.z.iso.datetime().nullable()
+  subject: import_zod164.z.string().max(255),
+  email_title: import_zod164.z.string().max(255),
+  main_text: import_zod164.z.string(),
+  main_html_content: import_zod164.z.string().optional(),
+  button_text: import_zod164.z.string().max(100).optional(),
+  button_url: import_zod164.z.url().optional(),
+  secondary_text: import_zod164.z.string().optional(),
+  status: import_zod164.z.nativeEnum(NewsletterCampaignStatus),
+  created_at: import_zod164.z.iso.datetime(),
+  sent_at: import_zod164.z.iso.datetime().nullable(),
+  recipient_count: import_zod164.z.int()
 });
 
-// src/cfg/generated/_utils/schemas/OTPErrorResponse.schema.ts
+// src/cfg/generated/_utils/schemas/NewsletterCampaignRequest.schema.ts
 var import_zod165 = require("zod");
-var OTPErrorResponseSchema = import_zod165.z.object({
-  error: import_zod165.z.string()
+var NewsletterCampaignRequestSchema = import_zod165.z.object({
+  newsletter: import_zod165.z.int(),
+  subject: import_zod165.z.string().min(1).max(255),
+  email_title: import_zod165.z.string().min(1).max(255),
+  main_text: import_zod165.z.string().min(1),
+  main_html_content: import_zod165.z.string().optional(),
+  button_text: import_zod165.z.string().max(100).optional(),
+  button_url: import_zod165.z.url().optional(),
+  secondary_text: import_zod165.z.string().optional()
 });
 
-// src/cfg/generated/_utils/schemas/OTPRequestRequest.schema.ts
+// src/cfg/generated/_utils/schemas/NewsletterSubscription.schema.ts
 var import_zod166 = require("zod");
-var OTPRequestRequestSchema = import_zod166.z.object({
-  identifier: import_zod166.z.string().min(1),
-  channel: import_zod166.z.nativeEnum(OTPRequestRequestChannel).optional(),
-  source_url: import_zod166.z.url().optional()
+var NewsletterSubscriptionSchema = import_zod166.z.object({
+  id: import_zod166.z.int(),
+  newsletter: import_zod166.z.int(),
+  newsletter_title: import_zod166.z.string(),
+  user: import_zod166.z.int().nullable().optional(),
+  user_email: import_zod166.z.string(),
+  email: import_zod166.z.email(),
+  is_active: import_zod166.z.boolean().optional(),
+  subscribed_at: import_zod166.z.iso.datetime(),
+  unsubscribed_at: import_zod166.z.iso.datetime().nullable()
 });
 
-// src/cfg/generated/_utils/schemas/OTPRequestResponse.schema.ts
+// src/cfg/generated/_utils/schemas/OTPErrorResponse.schema.ts
 var import_zod167 = require("zod");
-var OTPRequestResponseSchema = import_zod167.z.object({
-  message: import_zod167.z.string()
+var OTPErrorResponseSchema = import_zod167.z.object({
+  error: import_zod167.z.string()
 });
 
-// src/cfg/generated/_utils/schemas/OTPVerifyRequest.schema.ts
+// src/cfg/generated/_utils/schemas/OTPRequestRequest.schema.ts
 var import_zod168 = require("zod");
-var OTPVerifyRequestSchema = import_zod168.z.object({
+var OTPRequestRequestSchema = import_zod168.z.object({
   identifier: import_zod168.z.string().min(1),
-  otp: import_zod168.z.string().min(6).max(6),
-  channel: import_zod168.z.nativeEnum(OTPVerifyRequestChannel).optional(),
+  channel: import_zod168.z.nativeEnum(OTPRequestRequestChannel).optional(),
   source_url: import_zod168.z.url().optional()
 });
 
-// src/cfg/generated/_utils/schemas/OTPVerifyResponse.schema.ts
+// src/cfg/generated/_utils/schemas/OTPRequestResponse.schema.ts
+var import_zod169 = require("zod");
+var OTPRequestResponseSchema = import_zod169.z.object({
+  message: import_zod169.z.string()
+});
+
+// src/cfg/generated/_utils/schemas/OTPVerifyRequest.schema.ts
 var import_zod170 = require("zod");
+var OTPVerifyRequestSchema = import_zod170.z.object({
+  identifier: import_zod170.z.string().min(1),
+  otp: import_zod170.z.string().min(6).max(6),
+  channel: import_zod170.z.nativeEnum(OTPVerifyRequestChannel).optional(),
+  source_url: import_zod170.z.url().optional()
+});
+
+// src/cfg/generated/_utils/schemas/OTPVerifyResponse.schema.ts
+var import_zod172 = require("zod");
 
 // src/cfg/generated/_utils/schemas/User.schema.ts
-var import_zod169 = require("zod");
-var UserSchema = import_zod169.z.object({
-  id: import_zod169.z.int(),
-  email: import_zod169.z.email(),
-  first_name: import_zod169.z.string().max(50).optional(),
-  last_name: import_zod169.z.string().max(50).optional(),
-  full_name: import_zod169.z.string(),
-  initials: import_zod169.z.string(),
-  display_username: import_zod169.z.string(),
-  company: import_zod169.z.string().max(100).optional(),
-  phone: import_zod169.z.string().max(20).optional(),
-  position: import_zod169.z.string().max(100).optional(),
-  avatar: import_zod169.z.url().nullable(),
-  is_staff: import_zod169.z.boolean(),
-  is_superuser: import_zod169.z.boolean(),
-  date_joined: import_zod169.z.iso.datetime(),
-  last_login: import_zod169.z.iso.datetime().nullable(),
-  unanswered_messages_count: import_zod169.z.int(),
+var import_zod171 = require("zod");
+var UserSchema = import_zod171.z.object({
+  id: import_zod171.z.int(),
+  email: import_zod171.z.email(),
+  first_name: import_zod171.z.string().max(50).optional(),
+  last_name: import_zod171.z.string().max(50).optional(),
+  full_name: import_zod171.z.string(),
+  initials: import_zod171.z.string(),
+  display_username: import_zod171.z.string(),
+  company: import_zod171.z.string().max(100).optional(),
+  phone: import_zod171.z.string().max(20).optional(),
+  position: import_zod171.z.string().max(100).optional(),
+  avatar: import_zod171.z.url().nullable(),
+  is_staff: import_zod171.z.boolean(),
+  is_superuser: import_zod171.z.boolean(),
+  date_joined: import_zod171.z.iso.datetime(),
+  last_login: import_zod171.z.iso.datetime().nullable(),
+  unanswered_messages_count: import_zod171.z.int(),
   centrifugo: CentrifugoTokenSchema.nullable()
 });
 
 // src/cfg/generated/_utils/schemas/OTPVerifyResponse.schema.ts
-var OTPVerifyResponseSchema = import_zod170.z.object({
-  refresh: import_zod170.z.string(),
-  access: import_zod170.z.string(),
+var OTPVerifyResponseSchema = import_zod172.z.object({
+  refresh: import_zod172.z.string(),
+  access: import_zod172.z.string(),
   user: UserSchema
 });
 
 // src/cfg/generated/_utils/schemas/PaginatedApiKeyList.schema.ts
-var import_zod171 = require("zod");
-var PaginatedApiKeyListSchema = import_zod171.z.object({
-  count: import_zod171.z.int(),
-  page: import_zod171.z.int(),
-  pages: import_zod171.z.int(),
-  page_size: import_zod171.z.int(),
-  has_next: import_zod171.z.boolean(),
-  has_previous: import_zod171.z.boolean(),
-  next_page: import_zod171.z.int().nullable().optional(),
-  previous_page: import_zod171.z.int().nullable().optional(),
-  results: import_zod171.z.array(ApiKeySchema)
-});
-
-// src/cfg/generated/_utils/schemas/PaginatedArchiveItemChunkList.schema.ts
-var import_zod172 = require("zod");
-var PaginatedArchiveItemChunkListSchema = import_zod172.z.object({
-  count: import_zod172.z.int(),
-  page: import_zod172.z.int(),
-  pages: import_zod172.z.int(),
-  page_size: import_zod172.z.int(),
-  has_next: import_zod172.z.boolean(),
-  has_previous: import_zod172.z.boolean(),
-  next_page: import_zod172.z.int().nullable().optional(),
-  previous_page: import_zod172.z.int().nullable().optional(),
-  results: import_zod172.z.array(ArchiveItemChunkSchema)
-});
-
-// src/cfg/generated/_utils/schemas/PaginatedArchiveItemList.schema.ts
 var import_zod173 = require("zod");
-var PaginatedArchiveItemListSchema = import_zod173.z.object({
+var PaginatedApiKeyListSchema = import_zod173.z.object({
   count: import_zod173.z.int(),
   page: import_zod173.z.int(),
   pages: import_zod173.z.int(),
@@ -6263,12 +6261,12 @@ var PaginatedArchiveItemListSchema = import_zod173.z.object({
   has_previous: import_zod173.z.boolean(),
   next_page: import_zod173.z.int().nullable().optional(),
   previous_page: import_zod173.z.int().nullable().optional(),
-  results: import_zod173.z.array(ArchiveItemSchema)
+  results: import_zod173.z.array(ApiKeySchema)
 });
 
-// src/cfg/generated/_utils/schemas/PaginatedArchiveSearchResultList.schema.ts
+// src/cfg/generated/_utils/schemas/PaginatedArchiveItemChunkList.schema.ts
 var import_zod174 = require("zod");
-var PaginatedArchiveSearchResultListSchema = import_zod174.z.object({
+var PaginatedArchiveItemChunkListSchema = import_zod174.z.object({
   count: import_zod174.z.int(),
   page: import_zod174.z.int(),
   pages: import_zod174.z.int(),
@@ -6277,12 +6275,12 @@ var PaginatedArchiveSearchResultListSchema = import_zod174.z.object({
   has_previous: import_zod174.z.boolean(),
   next_page: import_zod174.z.int().nullable().optional(),
   previous_page: import_zod174.z.int().nullable().optional(),
-  results: import_zod174.z.array(ArchiveSearchResultSchema)
+  results: import_zod174.z.array(ArchiveItemChunkSchema)
 });
 
-// src/cfg/generated/_utils/schemas/PaginatedChatResponseList.schema.ts
+// src/cfg/generated/_utils/schemas/PaginatedArchiveItemList.schema.ts
 var import_zod175 = require("zod");
-var PaginatedChatResponseListSchema = import_zod175.z.object({
+var PaginatedArchiveItemListSchema = import_zod175.z.object({
   count: import_zod175.z.int(),
   page: import_zod175.z.int(),
   pages: import_zod175.z.int(),
@@ -6291,12 +6289,12 @@ var PaginatedChatResponseListSchema = import_zod175.z.object({
   has_previous: import_zod175.z.boolean(),
   next_page: import_zod175.z.int().nullable().optional(),
   previous_page: import_zod175.z.int().nullable().optional(),
-  results: import_zod175.z.array(ChatResponseSchema)
+  results: import_zod175.z.array(ArchiveItemSchema)
 });
 
-// src/cfg/generated/_utils/schemas/PaginatedChatSessionList.schema.ts
+// src/cfg/generated/_utils/schemas/PaginatedArchiveSearchResultList.schema.ts
 var import_zod176 = require("zod");
-var PaginatedChatSessionListSchema = import_zod176.z.object({
+var PaginatedArchiveSearchResultListSchema = import_zod176.z.object({
   count: import_zod176.z.int(),
   page: import_zod176.z.int(),
   pages: import_zod176.z.int(),
@@ -6305,12 +6303,12 @@ var PaginatedChatSessionListSchema = import_zod176.z.object({
   has_previous: import_zod176.z.boolean(),
   next_page: import_zod176.z.int().nullable().optional(),
   previous_page: import_zod176.z.int().nullable().optional(),
-  results: import_zod176.z.array(ChatSessionSchema)
+  results: import_zod176.z.array(ArchiveSearchResultSchema)
 });
 
-// src/cfg/generated/_utils/schemas/PaginatedDocumentArchiveListList.schema.ts
+// src/cfg/generated/_utils/schemas/PaginatedChatResponseList.schema.ts
 var import_zod177 = require("zod");
-var PaginatedDocumentArchiveListListSchema = import_zod177.z.object({
+var PaginatedChatResponseListSchema = import_zod177.z.object({
   count: import_zod177.z.int(),
   page: import_zod177.z.int(),
   pages: import_zod177.z.int(),
@@ -6319,12 +6317,12 @@ var PaginatedDocumentArchiveListListSchema = import_zod177.z.object({
   has_previous: import_zod177.z.boolean(),
   next_page: import_zod177.z.int().nullable().optional(),
   previous_page: import_zod177.z.int().nullable().optional(),
-  results: import_zod177.z.array(DocumentArchiveListSchema)
+  results: import_zod177.z.array(ChatResponseSchema)
 });
 
-// src/cfg/generated/_utils/schemas/PaginatedDocumentList.schema.ts
+// src/cfg/generated/_utils/schemas/PaginatedChatSessionList.schema.ts
 var import_zod178 = require("zod");
-var PaginatedDocumentListSchema = import_zod178.z.object({
+var PaginatedChatSessionListSchema = import_zod178.z.object({
   count: import_zod178.z.int(),
   page: import_zod178.z.int(),
   pages: import_zod178.z.int(),
@@ -6333,12 +6331,12 @@ var PaginatedDocumentListSchema = import_zod178.z.object({
   has_previous: import_zod178.z.boolean(),
   next_page: import_zod178.z.int().nullable().optional(),
   previous_page: import_zod178.z.int().nullable().optional(),
-  results: import_zod178.z.array(DocumentSchema)
+  results: import_zod178.z.array(ChatSessionSchema)
 });
 
-// src/cfg/generated/_utils/schemas/PaginatedEmailLogList.schema.ts
+// src/cfg/generated/_utils/schemas/PaginatedDocumentArchiveListList.schema.ts
 var import_zod179 = require("zod");
-var PaginatedEmailLogListSchema = import_zod179.z.object({
+var PaginatedDocumentArchiveListListSchema = import_zod179.z.object({
   count: import_zod179.z.int(),
   page: import_zod179.z.int(),
   pages: import_zod179.z.int(),
@@ -6347,12 +6345,12 @@ var PaginatedEmailLogListSchema = import_zod179.z.object({
   has_previous: import_zod179.z.boolean(),
   next_page: import_zod179.z.int().nullable().optional(),
   previous_page: import_zod179.z.int().nullable().optional(),
-  results: import_zod179.z.array(EmailLogSchema)
+  results: import_zod179.z.array(DocumentArchiveListSchema)
 });
 
-// src/cfg/generated/_utils/schemas/PaginatedGRPCTestLogList.schema.ts
+// src/cfg/generated/_utils/schemas/PaginatedDocumentList.schema.ts
 var import_zod180 = require("zod");
-var PaginatedGRPCTestLogListSchema = import_zod180.z.object({
+var PaginatedDocumentListSchema = import_zod180.z.object({
   count: import_zod180.z.int(),
   page: import_zod180.z.int(),
   pages: import_zod180.z.int(),
@@ -6361,12 +6359,12 @@ var PaginatedGRPCTestLogListSchema = import_zod180.z.object({
   has_previous: import_zod180.z.boolean(),
   next_page: import_zod180.z.int().nullable().optional(),
   previous_page: import_zod180.z.int().nullable().optional(),
-  results: import_zod180.z.array(GRPCTestLogSchema)
+  results: import_zod180.z.array(DocumentSchema)
 });
 
-// src/cfg/generated/_utils/schemas/PaginatedJobListList.schema.ts
+// src/cfg/generated/_utils/schemas/PaginatedEmailLogList.schema.ts
 var import_zod181 = require("zod");
-var PaginatedJobListListSchema = import_zod181.z.object({
+var PaginatedEmailLogListSchema = import_zod181.z.object({
   count: import_zod181.z.int(),
   page: import_zod181.z.int(),
   pages: import_zod181.z.int(),
@@ -6375,12 +6373,12 @@ var PaginatedJobListListSchema = import_zod181.z.object({
   has_previous: import_zod181.z.boolean(),
   next_page: import_zod181.z.int().nullable().optional(),
   previous_page: import_zod181.z.int().nullable().optional(),
-  results: import_zod181.z.array(JobListSchema)
+  results: import_zod181.z.array(EmailLogSchema)
 });
 
-// src/cfg/generated/_utils/schemas/PaginatedLeadSubmissionList.schema.ts
+// src/cfg/generated/_utils/schemas/PaginatedGRPCTestLogList.schema.ts
 var import_zod182 = require("zod");
-var PaginatedLeadSubmissionListSchema = import_zod182.z.object({
+var PaginatedGRPCTestLogListSchema = import_zod182.z.object({
   count: import_zod182.z.int(),
   page: import_zod182.z.int(),
   pages: import_zod182.z.int(),
@@ -6389,12 +6387,12 @@ var PaginatedLeadSubmissionListSchema = import_zod182.z.object({
   has_previous: import_zod182.z.boolean(),
   next_page: import_zod182.z.int().nullable().optional(),
   previous_page: import_zod182.z.int().nullable().optional(),
-  results: import_zod182.z.array(LeadSubmissionSchema)
+  results: import_zod182.z.array(GRPCTestLogSchema)
 });
 
-// src/cfg/generated/_utils/schemas/PaginatedMessageList.schema.ts
+// src/cfg/generated/_utils/schemas/PaginatedJobListList.schema.ts
 var import_zod183 = require("zod");
-var PaginatedMessageListSchema = import_zod183.z.object({
+var PaginatedJobListListSchema = import_zod183.z.object({
   count: import_zod183.z.int(),
   page: import_zod183.z.int(),
   pages: import_zod183.z.int(),
@@ -6403,12 +6401,12 @@ var PaginatedMessageListSchema = import_zod183.z.object({
   has_previous: import_zod183.z.boolean(),
   next_page: import_zod183.z.int().nullable().optional(),
   previous_page: import_zod183.z.int().nullable().optional(),
-  results: import_zod183.z.array(MessageSchema)
+  results: import_zod183.z.array(JobListSchema)
 });
 
-// src/cfg/generated/_utils/schemas/PaginatedNewsletterCampaignList.schema.ts
+// src/cfg/generated/_utils/schemas/PaginatedLeadSubmissionList.schema.ts
 var import_zod184 = require("zod");
-var PaginatedNewsletterCampaignListSchema = import_zod184.z.object({
+var PaginatedLeadSubmissionListSchema = import_zod184.z.object({
   count: import_zod184.z.int(),
   page: import_zod184.z.int(),
   pages: import_zod184.z.int(),
@@ -6417,12 +6415,12 @@ var PaginatedNewsletterCampaignListSchema = import_zod184.z.object({
   has_previous: import_zod184.z.boolean(),
   next_page: import_zod184.z.int().nullable().optional(),
   previous_page: import_zod184.z.int().nullable().optional(),
-  results: import_zod184.z.array(NewsletterCampaignSchema)
+  results: import_zod184.z.array(LeadSubmissionSchema)
 });
 
-// src/cfg/generated/_utils/schemas/PaginatedNewsletterList.schema.ts
+// src/cfg/generated/_utils/schemas/PaginatedMessageList.schema.ts
 var import_zod185 = require("zod");
-var PaginatedNewsletterListSchema = import_zod185.z.object({
+var PaginatedMessageListSchema = import_zod185.z.object({
   count: import_zod185.z.int(),
   page: import_zod185.z.int(),
   pages: import_zod185.z.int(),
@@ -6431,12 +6429,12 @@ var PaginatedNewsletterListSchema = import_zod185.z.object({
   has_previous: import_zod185.z.boolean(),
   next_page: import_zod185.z.int().nullable().optional(),
   previous_page: import_zod185.z.int().nullable().optional(),
-  results: import_zod185.z.array(NewsletterSchema)
+  results: import_zod185.z.array(MessageSchema)
 });
 
-// src/cfg/generated/_utils/schemas/PaginatedNewsletterSubscriptionList.schema.ts
+// src/cfg/generated/_utils/schemas/PaginatedNewsletterCampaignList.schema.ts
 var import_zod186 = require("zod");
-var PaginatedNewsletterSubscriptionListSchema = import_zod186.z.object({
+var PaginatedNewsletterCampaignListSchema = import_zod186.z.object({
   count: import_zod186.z.int(),
   page: import_zod186.z.int(),
   pages: import_zod186.z.int(),
@@ -6445,28 +6443,26 @@ var PaginatedNewsletterSubscriptionListSchema = import_zod186.z.object({
   has_previous: import_zod186.z.boolean(),
   next_page: import_zod186.z.int().nullable().optional(),
   previous_page: import_zod186.z.int().nullable().optional(),
-  results: import_zod186.z.array(NewsletterSubscriptionSchema)
+  results: import_zod186.z.array(NewsletterCampaignSchema)
 });
 
-// src/cfg/generated/_utils/schemas/PaginatedPaymentListList.schema.ts
-var import_zod188 = require("zod");
-
-// src/cfg/generated/_utils/schemas/PaymentList.schema.ts
+// src/cfg/generated/_utils/schemas/PaginatedNewsletterList.schema.ts
 var import_zod187 = require("zod");
-var PaymentListSchema = import_zod187.z.object({
-  id: import_zod187.z.uuid(),
-  internal_payment_id: import_zod187.z.string(),
-  amount_usd: import_zod187.z.string(),
-  currency_code: import_zod187.z.string(),
-  currency_token: import_zod187.z.string(),
-  status: import_zod187.z.nativeEnum(PaymentListStatus),
-  status_display: import_zod187.z.string(),
-  created_at: import_zod187.z.iso.datetime(),
-  completed_at: import_zod187.z.iso.datetime().nullable()
+var PaginatedNewsletterListSchema = import_zod187.z.object({
+  count: import_zod187.z.int(),
+  page: import_zod187.z.int(),
+  pages: import_zod187.z.int(),
+  page_size: import_zod187.z.int(),
+  has_next: import_zod187.z.boolean(),
+  has_previous: import_zod187.z.boolean(),
+  next_page: import_zod187.z.int().nullable().optional(),
+  previous_page: import_zod187.z.int().nullable().optional(),
+  results: import_zod187.z.array(NewsletterSchema)
 });
 
-// src/cfg/generated/_utils/schemas/PaginatedPaymentListList.schema.ts
-var PaginatedPaymentListListSchema = import_zod188.z.object({
+// src/cfg/generated/_utils/schemas/PaginatedNewsletterSubscriptionList.schema.ts
+var import_zod188 = require("zod");
+var PaginatedNewsletterSubscriptionListSchema = import_zod188.z.object({
   count: import_zod188.z.int(),
   page: import_zod188.z.int(),
   pages: import_zod188.z.int(),
@@ -6475,22 +6471,28 @@ var PaginatedPaymentListListSchema = import_zod188.z.object({
   has_previous: import_zod188.z.boolean(),
   next_page: import_zod188.z.int().nullable().optional(),
   previous_page: import_zod188.z.int().nullable().optional(),
-  results: import_zod188.z.array(PaymentListSchema)
+  results: import_zod188.z.array(NewsletterSubscriptionSchema)
 });
 
-// src/cfg/generated/_utils/schemas/PaginatedPublicCategoryList.schema.ts
+// src/cfg/generated/_utils/schemas/PaginatedPaymentListList.schema.ts
 var import_zod190 = require("zod");
 
-// src/cfg/generated/_utils/schemas/PublicCategory.schema.ts
+// src/cfg/generated/_utils/schemas/PaymentList.schema.ts
 var import_zod189 = require("zod");
-var PublicCategorySchema = import_zod189.z.object({
+var PaymentListSchema = import_zod189.z.object({
   id: import_zod189.z.uuid(),
-  name: import_zod189.z.string().max(255),
-  description: import_zod189.z.string().optional()
+  internal_payment_id: import_zod189.z.string(),
+  amount_usd: import_zod189.z.string(),
+  currency_code: import_zod189.z.string(),
+  currency_token: import_zod189.z.string(),
+  status: import_zod189.z.nativeEnum(PaymentListStatus),
+  status_display: import_zod189.z.string(),
+  created_at: import_zod189.z.iso.datetime(),
+  completed_at: import_zod189.z.iso.datetime().nullable()
 });
 
-// src/cfg/generated/_utils/schemas/PaginatedPublicCategoryList.schema.ts
-var PaginatedPublicCategoryListSchema = import_zod190.z.object({
+// src/cfg/generated/_utils/schemas/PaginatedPaymentListList.schema.ts
+var PaginatedPaymentListListSchema = import_zod190.z.object({
   count: import_zod190.z.int(),
   page: import_zod190.z.int(),
   pages: import_zod190.z.int(),
@@ -6499,24 +6501,22 @@ var PaginatedPublicCategoryListSchema = import_zod190.z.object({
   has_previous: import_zod190.z.boolean(),
   next_page: import_zod190.z.int().nullable().optional(),
   previous_page: import_zod190.z.int().nullable().optional(),
-  results: import_zod190.z.array(PublicCategorySchema)
+  results: import_zod190.z.array(PaymentListSchema)
 });
 
-// src/cfg/generated/_utils/schemas/PaginatedPublicDocumentListList.schema.ts
+// src/cfg/generated/_utils/schemas/PaginatedPublicCategoryList.schema.ts
 var import_zod192 = require("zod");
 
-// src/cfg/generated/_utils/schemas/PublicDocumentList.schema.ts
+// src/cfg/generated/_utils/schemas/PublicCategory.schema.ts
 var import_zod191 = require("zod");
-var PublicDocumentListSchema = import_zod191.z.object({
+var PublicCategorySchema = import_zod191.z.object({
   id: import_zod191.z.uuid(),
-  title: import_zod191.z.string().max(512),
-  category: PublicCategorySchema,
-  created_at: import_zod191.z.iso.datetime(),
-  updated_at: import_zod191.z.iso.datetime()
+  name: import_zod191.z.string().max(255),
+  description: import_zod191.z.string().optional()
 });
 
-// src/cfg/generated/_utils/schemas/PaginatedPublicDocumentListList.schema.ts
-var PaginatedPublicDocumentListListSchema = import_zod192.z.object({
+// src/cfg/generated/_utils/schemas/PaginatedPublicCategoryList.schema.ts
+var PaginatedPublicCategoryListSchema = import_zod192.z.object({
   count: import_zod192.z.int(),
   page: import_zod192.z.int(),
   pages: import_zod192.z.int(),
@@ -6525,30 +6525,24 @@ var PaginatedPublicDocumentListListSchema = import_zod192.z.object({
   has_previous: import_zod192.z.boolean(),
   next_page: import_zod192.z.int().nullable().optional(),
   previous_page: import_zod192.z.int().nullable().optional(),
-  results: import_zod192.z.array(PublicDocumentListSchema)
+  results: import_zod192.z.array(PublicCategorySchema)
 });
 
-// src/cfg/generated/_utils/schemas/PaginatedPublishList.schema.ts
+// src/cfg/generated/_utils/schemas/PaginatedPublicDocumentListList.schema.ts
 var import_zod194 = require("zod");
 
-// src/cfg/generated/_utils/schemas/Publish.schema.ts
+// src/cfg/generated/_utils/schemas/PublicDocumentList.schema.ts
 var import_zod193 = require("zod");
-var PublishSchema = import_zod193.z.object({
-  message_id: import_zod193.z.string(),
-  channel: import_zod193.z.string(),
-  status: import_zod193.z.string(),
-  wait_for_ack: import_zod193.z.boolean(),
-  acks_received: import_zod193.z.int(),
-  acks_expected: import_zod193.z.int().nullable(),
-  duration_ms: import_zod193.z.number().nullable(),
+var PublicDocumentListSchema = import_zod193.z.object({
+  id: import_zod193.z.uuid(),
+  title: import_zod193.z.string().max(512),
+  category: PublicCategorySchema,
   created_at: import_zod193.z.iso.datetime(),
-  completed_at: import_zod193.z.iso.datetime().nullable(),
-  error_code: import_zod193.z.string().nullable(),
-  error_message: import_zod193.z.string().nullable()
+  updated_at: import_zod193.z.iso.datetime()
 });
 
-// src/cfg/generated/_utils/schemas/PaginatedPublishList.schema.ts
-var PaginatedPublishListSchema = import_zod194.z.object({
+// src/cfg/generated/_utils/schemas/PaginatedPublicDocumentListList.schema.ts
+var PaginatedPublicDocumentListListSchema = import_zod194.z.object({
   count: import_zod194.z.int(),
   page: import_zod194.z.int(),
   pages: import_zod194.z.int(),
@@ -6557,34 +6551,30 @@ var PaginatedPublishListSchema = import_zod194.z.object({
   has_previous: import_zod194.z.boolean(),
   next_page: import_zod194.z.int().nullable().optional(),
   previous_page: import_zod194.z.int().nullable().optional(),
-  results: import_zod194.z.array(PublishSchema)
+  results: import_zod194.z.array(PublicDocumentListSchema)
 });
 
-// src/cfg/generated/_utils/schemas/PaginatedRecentRequestList.schema.ts
+// src/cfg/generated/_utils/schemas/PaginatedPublishList.schema.ts
 var import_zod196 = require("zod");
 
-// src/cfg/generated/_utils/schemas/RecentRequest.schema.ts
+// src/cfg/generated/_utils/schemas/Publish.schema.ts
 var import_zod195 = require("zod");
-var RecentRequestSchema = import_zod195.z.object({
-  id: import_zod195.z.int(),
-  request_id: import_zod195.z.string(),
-  service_name: import_zod195.z.string(),
-  method_name: import_zod195.z.string(),
+var PublishSchema = import_zod195.z.object({
+  message_id: import_zod195.z.string(),
+  channel: import_zod195.z.string(),
   status: import_zod195.z.string(),
-  duration_ms: import_zod195.z.int().optional(),
-  grpc_status_code: import_zod195.z.string().optional(),
-  error_message: import_zod195.z.string().optional(),
-  created_at: import_zod195.z.string(),
-  client_ip: import_zod195.z.string().optional(),
-  user_id: import_zod195.z.int().nullable().optional(),
-  username: import_zod195.z.string().nullable().optional(),
-  is_authenticated: import_zod195.z.boolean().optional(),
-  api_key_id: import_zod195.z.int().nullable().optional(),
-  api_key_name: import_zod195.z.string().nullable().optional()
+  wait_for_ack: import_zod195.z.boolean(),
+  acks_received: import_zod195.z.int(),
+  acks_expected: import_zod195.z.int().nullable(),
+  duration_ms: import_zod195.z.number().nullable(),
+  created_at: import_zod195.z.iso.datetime(),
+  completed_at: import_zod195.z.iso.datetime().nullable(),
+  error_code: import_zod195.z.string().nullable(),
+  error_message: import_zod195.z.string().nullable()
 });
 
-// src/cfg/generated/_utils/schemas/PaginatedRecentRequestList.schema.ts
-var PaginatedRecentRequestListSchema = import_zod196.z.object({
+// src/cfg/generated/_utils/schemas/PaginatedPublishList.schema.ts
+var PaginatedPublishListSchema = import_zod196.z.object({
   count: import_zod196.z.int(),
   page: import_zod196.z.int(),
   pages: import_zod196.z.int(),
@@ -6593,33 +6583,34 @@ var PaginatedRecentRequestListSchema = import_zod196.z.object({
   has_previous: import_zod196.z.boolean(),
   next_page: import_zod196.z.int().nullable().optional(),
   previous_page: import_zod196.z.int().nullable().optional(),
-  results: import_zod196.z.array(RecentRequestSchema)
+  results: import_zod196.z.array(PublishSchema)
 });
 
-// src/cfg/generated/_utils/schemas/PaginatedScheduledJobList.schema.ts
+// src/cfg/generated/_utils/schemas/PaginatedRecentRequestList.schema.ts
 var import_zod198 = require("zod");
 
-// src/cfg/generated/_utils/schemas/ScheduledJob.schema.ts
+// src/cfg/generated/_utils/schemas/RecentRequest.schema.ts
 var import_zod197 = require("zod");
-var ScheduledJobSchema = import_zod197.z.object({
-  id: import_zod197.z.string(),
-  func: import_zod197.z.string(),
-  args: import_zod197.z.array(import_zod197.z.record(import_zod197.z.string(), import_zod197.z.any())).optional(),
-  kwargs: import_zod197.z.record(import_zod197.z.string(), import_zod197.z.any()).optional(),
-  queue_name: import_zod197.z.string(),
-  scheduled_time: import_zod197.z.iso.datetime().nullable().optional(),
-  interval: import_zod197.z.int().nullable().optional(),
-  cron: import_zod197.z.string().nullable().optional(),
-  timeout: import_zod197.z.int().nullable().optional(),
-  result_ttl: import_zod197.z.int().nullable().optional(),
-  repeat: import_zod197.z.int().nullable().optional(),
-  description: import_zod197.z.string().nullable().optional(),
-  created_at: import_zod197.z.iso.datetime().nullable().optional(),
-  meta: import_zod197.z.record(import_zod197.z.string(), import_zod197.z.any()).optional()
+var RecentRequestSchema = import_zod197.z.object({
+  id: import_zod197.z.int(),
+  request_id: import_zod197.z.string(),
+  service_name: import_zod197.z.string(),
+  method_name: import_zod197.z.string(),
+  status: import_zod197.z.string(),
+  duration_ms: import_zod197.z.int().optional(),
+  grpc_status_code: import_zod197.z.string().optional(),
+  error_message: import_zod197.z.string().optional(),
+  created_at: import_zod197.z.string(),
+  client_ip: import_zod197.z.string().optional(),
+  user_id: import_zod197.z.int().nullable().optional(),
+  username: import_zod197.z.string().nullable().optional(),
+  is_authenticated: import_zod197.z.boolean().optional(),
+  api_key_id: import_zod197.z.int().nullable().optional(),
+  api_key_name: import_zod197.z.string().nullable().optional()
 });
 
-// src/cfg/generated/_utils/schemas/PaginatedScheduledJobList.schema.ts
-var PaginatedScheduledJobListSchema = import_zod198.z.object({
+// src/cfg/generated/_utils/schemas/PaginatedRecentRequestList.schema.ts
+var PaginatedRecentRequestListSchema = import_zod198.z.object({
   count: import_zod198.z.int(),
   page: import_zod198.z.int(),
   pages: import_zod198.z.int(),
@@ -6628,27 +6619,33 @@ var PaginatedScheduledJobListSchema = import_zod198.z.object({
   has_previous: import_zod198.z.boolean(),
   next_page: import_zod198.z.int().nullable().optional(),
   previous_page: import_zod198.z.int().nullable().optional(),
-  results: import_zod198.z.array(ScheduledJobSchema)
+  results: import_zod198.z.array(RecentRequestSchema)
 });
 
-// src/cfg/generated/_utils/schemas/PaginatedServiceSummaryList.schema.ts
+// src/cfg/generated/_utils/schemas/PaginatedScheduledJobList.schema.ts
 var import_zod200 = require("zod");
 
-// src/cfg/generated/_utils/schemas/ServiceSummary.schema.ts
+// src/cfg/generated/_utils/schemas/ScheduledJob.schema.ts
 var import_zod199 = require("zod");
-var ServiceSummarySchema = import_zod199.z.object({
-  name: import_zod199.z.string(),
-  full_name: import_zod199.z.string(),
-  package: import_zod199.z.string(),
-  methods_count: import_zod199.z.int(),
-  total_requests: import_zod199.z.int().optional(),
-  success_rate: import_zod199.z.number().optional(),
-  avg_duration_ms: import_zod199.z.number().optional(),
-  last_activity_at: import_zod199.z.string().nullable().optional()
+var ScheduledJobSchema = import_zod199.z.object({
+  id: import_zod199.z.string(),
+  func: import_zod199.z.string(),
+  args: import_zod199.z.array(import_zod199.z.record(import_zod199.z.string(), import_zod199.z.any())).optional(),
+  kwargs: import_zod199.z.record(import_zod199.z.string(), import_zod199.z.any()).optional(),
+  queue_name: import_zod199.z.string(),
+  scheduled_time: import_zod199.z.iso.datetime().nullable().optional(),
+  interval: import_zod199.z.int().nullable().optional(),
+  cron: import_zod199.z.string().nullable().optional(),
+  timeout: import_zod199.z.int().nullable().optional(),
+  result_ttl: import_zod199.z.int().nullable().optional(),
+  repeat: import_zod199.z.int().nullable().optional(),
+  description: import_zod199.z.string().nullable().optional(),
+  created_at: import_zod199.z.iso.datetime().nullable().optional(),
+  meta: import_zod199.z.record(import_zod199.z.string(), import_zod199.z.any()).optional()
 });
 
-// src/cfg/generated/_utils/schemas/PaginatedServiceSummaryList.schema.ts
-var PaginatedServiceSummaryListSchema = import_zod200.z.object({
+// src/cfg/generated/_utils/schemas/PaginatedScheduledJobList.schema.ts
+var PaginatedScheduledJobListSchema = import_zod200.z.object({
   count: import_zod200.z.int(),
   page: import_zod200.z.int(),
   pages: import_zod200.z.int(),
@@ -6657,25 +6654,27 @@ var PaginatedServiceSummaryListSchema = import_zod200.z.object({
   has_previous: import_zod200.z.boolean(),
   next_page: import_zod200.z.int().nullable().optional(),
   previous_page: import_zod200.z.int().nullable().optional(),
-  results: import_zod200.z.array(ServiceSummarySchema)
+  results: import_zod200.z.array(ScheduledJobSchema)
 });
 
-// src/cfg/generated/_utils/schemas/PaginatedTicketList.schema.ts
+// src/cfg/generated/_utils/schemas/PaginatedServiceSummaryList.schema.ts
 var import_zod202 = require("zod");
 
-// src/cfg/generated/_utils/schemas/Ticket.schema.ts
+// src/cfg/generated/_utils/schemas/ServiceSummary.schema.ts
 var import_zod201 = require("zod");
-var TicketSchema = import_zod201.z.object({
-  uuid: import_zod201.z.uuid(),
-  user: import_zod201.z.int(),
-  subject: import_zod201.z.string().max(255),
-  status: import_zod201.z.nativeEnum(TicketStatus).optional(),
-  created_at: import_zod201.z.iso.datetime(),
-  unanswered_messages_count: import_zod201.z.int()
+var ServiceSummarySchema = import_zod201.z.object({
+  name: import_zod201.z.string(),
+  full_name: import_zod201.z.string(),
+  package: import_zod201.z.string(),
+  methods_count: import_zod201.z.int(),
+  total_requests: import_zod201.z.int().optional(),
+  success_rate: import_zod201.z.number().optional(),
+  avg_duration_ms: import_zod201.z.number().optional(),
+  last_activity_at: import_zod201.z.string().nullable().optional()
 });
 
-// src/cfg/generated/_utils/schemas/PaginatedTicketList.schema.ts
-var PaginatedTicketListSchema = import_zod202.z.object({
+// src/cfg/generated/_utils/schemas/PaginatedServiceSummaryList.schema.ts
+var PaginatedServiceSummaryListSchema = import_zod202.z.object({
   count: import_zod202.z.int(),
   page: import_zod202.z.int(),
   pages: import_zod202.z.int(),
@@ -6684,641 +6683,682 @@ var PaginatedTicketListSchema = import_zod202.z.object({
   has_previous: import_zod202.z.boolean(),
   next_page: import_zod202.z.int().nullable().optional(),
   previous_page: import_zod202.z.int().nullable().optional(),
-  results: import_zod202.z.array(TicketSchema)
+  results: import_zod202.z.array(ServiceSummarySchema)
 });
 
-// src/cfg/generated/_utils/schemas/PatchedArchiveItemChunkRequest.schema.ts
+// src/cfg/generated/_utils/schemas/PaginatedTicketList.schema.ts
+var import_zod204 = require("zod");
+
+// src/cfg/generated/_utils/schemas/Ticket.schema.ts
 var import_zod203 = require("zod");
-var PatchedArchiveItemChunkRequestSchema = import_zod203.z.object({
-  content: import_zod203.z.string().min(1).optional(),
-  chunk_index: import_zod203.z.int().min(0).max(2147483647).optional(),
-  chunk_type: import_zod203.z.nativeEnum(PatchedArchiveItemChunkRequestChunkType).optional()
+var TicketSchema = import_zod203.z.object({
+  uuid: import_zod203.z.uuid(),
+  user: import_zod203.z.int(),
+  subject: import_zod203.z.string().max(255),
+  status: import_zod203.z.nativeEnum(TicketStatus).optional(),
+  created_at: import_zod203.z.iso.datetime(),
+  unanswered_messages_count: import_zod203.z.int()
 });
 
-// src/cfg/generated/_utils/schemas/PatchedArchiveItemRequest.schema.ts
-var import_zod204 = require("zod");
-var PatchedArchiveItemRequestSchema = import_zod204.z.object({
-  relative_path: import_zod204.z.string().min(1).max(1024).optional(),
-  item_name: import_zod204.z.string().min(1).max(255).optional(),
-  item_type: import_zod204.z.string().min(1).max(100).optional(),
-  file_size: import_zod204.z.int().min(0).max(2147483647).optional()
+// src/cfg/generated/_utils/schemas/PaginatedTicketList.schema.ts
+var PaginatedTicketListSchema = import_zod204.z.object({
+  count: import_zod204.z.int(),
+  page: import_zod204.z.int(),
+  pages: import_zod204.z.int(),
+  page_size: import_zod204.z.int(),
+  has_next: import_zod204.z.boolean(),
+  has_previous: import_zod204.z.boolean(),
+  next_page: import_zod204.z.int().nullable().optional(),
+  previous_page: import_zod204.z.int().nullable().optional(),
+  results: import_zod204.z.array(TicketSchema)
 });
 
-// src/cfg/generated/_utils/schemas/PatchedChatResponseRequest.schema.ts
+// src/cfg/generated/_utils/schemas/PatchedArchiveItemChunkRequest.schema.ts
 var import_zod205 = require("zod");
-var PatchedChatResponseRequestSchema = import_zod205.z.object({
-  message_id: import_zod205.z.uuid().optional(),
+var PatchedArchiveItemChunkRequestSchema = import_zod205.z.object({
   content: import_zod205.z.string().min(1).optional(),
-  tokens_used: import_zod205.z.int().optional(),
-  cost_usd: import_zod205.z.number().optional(),
-  processing_time_ms: import_zod205.z.int().optional(),
-  model_used: import_zod205.z.string().min(1).optional(),
-  sources: import_zod205.z.array(ChatSourceRequestSchema).nullable().optional()
+  chunk_index: import_zod205.z.int().min(0).max(2147483647).optional(),
+  chunk_type: import_zod205.z.nativeEnum(PatchedArchiveItemChunkRequestChunkType).optional()
 });
 
-// src/cfg/generated/_utils/schemas/PatchedChatSessionRequest.schema.ts
+// src/cfg/generated/_utils/schemas/PatchedArchiveItemRequest.schema.ts
 var import_zod206 = require("zod");
-var PatchedChatSessionRequestSchema = import_zod206.z.object({
-  title: import_zod206.z.string().max(255).optional(),
-  is_active: import_zod206.z.boolean().optional(),
-  messages_count: import_zod206.z.int().min(0).max(2147483647).optional(),
-  total_tokens_used: import_zod206.z.int().min(0).max(2147483647).optional(),
-  model_name: import_zod206.z.string().min(1).max(100).optional(),
-  temperature: import_zod206.z.number().optional(),
-  max_context_chunks: import_zod206.z.int().min(0).max(2147483647).optional()
+var PatchedArchiveItemRequestSchema = import_zod206.z.object({
+  relative_path: import_zod206.z.string().min(1).max(1024).optional(),
+  item_name: import_zod206.z.string().min(1).max(255).optional(),
+  item_type: import_zod206.z.string().min(1).max(100).optional(),
+  file_size: import_zod206.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_zod207 = require("zod");
-var PatchedDocumentArchiveRequestSchema = import_zod207.z.object({
-  title: import_zod207.z.string().min(1).max(512).optional(),
-  description: import_zod207.z.string().optional(),
-  is_public: import_zod207.z.boolean().optional()
+var PatchedChatResponseRequestSchema = import_zod207.z.object({
+  message_id: import_zod207.z.uuid().optional(),
+  content: import_zod207.z.string().min(1).optional(),
+  tokens_used: import_zod207.z.int().optional(),
+  cost_usd: import_zod207.z.number().optional(),
+  processing_time_ms: import_zod207.z.int().optional(),
+  model_used: import_zod207.z.string().min(1).optional(),
+  sources: import_zod207.z.array(ChatSourceRequestSchema).nullable().optional()
 });
 
-// src/cfg/generated/_utils/schemas/PatchedDocumentRequest.schema.ts
+// src/cfg/generated/_utils/schemas/PatchedChatSessionRequest.schema.ts
 var import_zod208 = require("zod");
-var PatchedDocumentRequestSchema = import_zod208.z.object({
-  title: import_zod208.z.string().min(1).max(512).optional(),
-  file_type: import_zod208.z.string().min(1).max(100).optional(),
-  file_size: import_zod208.z.int().min(0).max(2147483647).optional(),
-  metadata: import_zod208.z.record(import_zod208.z.string(), import_zod208.z.any()).nullable().optional()
+var PatchedChatSessionRequestSchema = import_zod208.z.object({
+  title: import_zod208.z.string().max(255).optional(),
+  is_active: import_zod208.z.boolean().optional(),
+  messages_count: import_zod208.z.int().min(0).max(2147483647).optional(),
+  total_tokens_used: import_zod208.z.int().min(0).max(2147483647).optional(),
+  model_name: import_zod208.z.string().min(1).max(100).optional(),
+  temperature: import_zod208.z.number().optional(),
+  max_context_chunks: import_zod208.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_zod209 = require("zod");
-var PatchedLeadSubmissionRequestSchema = import_zod209.z.object({
-  name: import_zod209.z.string().min(1).max(200).optional(),
-  email: import_zod209.z.email().optional(),
-  company: import_zod209.z.string().max(200).nullable().optional(),
-  company_site: import_zod209.z.string().max(200).nullable().optional(),
-  contact_type: import_zod209.z.nativeEnum(PatchedLeadSubmissionRequestContactType).optional(),
-  contact_value: import_zod209.z.string().max(200).nullable().optional(),
-  subject: import_zod209.z.string().max(200).nullable().optional(),
-  message: import_zod209.z.string().min(1).optional(),
-  extra: import_zod209.z.record(import_zod209.z.string(), import_zod209.z.any()).nullable().optional(),
-  site_url: import_zod209.z.url().optional()
+var PatchedDocumentArchiveRequestSchema = import_zod209.z.object({
+  title: import_zod209.z.string().min(1).max(512).optional(),
+  description: import_zod209.z.string().optional(),
+  is_public: import_zod209.z.boolean().optional()
 });
 
-// src/cfg/generated/_utils/schemas/PatchedMessageRequest.schema.ts
+// src/cfg/generated/_utils/schemas/PatchedDocumentRequest.schema.ts
 var import_zod210 = require("zod");
-var PatchedMessageRequestSchema = import_zod210.z.object({
-  text: import_zod210.z.string().min(1).optional()
+var PatchedDocumentRequestSchema = import_zod210.z.object({
+  title: import_zod210.z.string().min(1).max(512).optional(),
+  file_type: import_zod210.z.string().min(1).max(100).optional(),
+  file_size: import_zod210.z.int().min(0).max(2147483647).optional(),
+  metadata: import_zod210.z.record(import_zod210.z.string(), import_zod210.z.any()).nullable().optional()
 });
 
-// src/cfg/generated/_utils/schemas/PatchedNewsletterCampaignRequest.schema.ts
+// src/cfg/generated/_utils/schemas/PatchedLeadSubmissionRequest.schema.ts
 var import_zod211 = require("zod");
-var PatchedNewsletterCampaignRequestSchema = import_zod211.z.object({
-  newsletter: import_zod211.z.int().optional(),
-  subject: import_zod211.z.string().min(1).max(255).optional(),
-  email_title: import_zod211.z.string().min(1).max(255).optional(),
-  main_text: import_zod211.z.string().min(1).optional(),
-  main_html_content: import_zod211.z.string().optional(),
-  button_text: import_zod211.z.string().max(100).optional(),
-  button_url: import_zod211.z.url().optional(),
-  secondary_text: import_zod211.z.string().optional()
+var PatchedLeadSubmissionRequestSchema = import_zod211.z.object({
+  name: import_zod211.z.string().min(1).max(200).optional(),
+  email: import_zod211.z.email().optional(),
+  company: import_zod211.z.string().max(200).nullable().optional(),
+  company_site: import_zod211.z.string().max(200).nullable().optional(),
+  contact_type: import_zod211.z.nativeEnum(PatchedLeadSubmissionRequestContactType).optional(),
+  contact_value: import_zod211.z.string().max(200).nullable().optional(),
+  subject: import_zod211.z.string().max(200).nullable().optional(),
+  message: import_zod211.z.string().min(1).optional(),
+  extra: import_zod211.z.record(import_zod211.z.string(), import_zod211.z.any()).nullable().optional(),
+  site_url: import_zod211.z.url().optional()
 });
 
-// src/cfg/generated/_utils/schemas/PatchedTicketRequest.schema.ts
+// src/cfg/generated/_utils/schemas/PatchedMessageRequest.schema.ts
 var import_zod212 = require("zod");
-var PatchedTicketRequestSchema = import_zod212.z.object({
-  user: import_zod212.z.int().optional(),
-  subject: import_zod212.z.string().min(1).max(255).optional(),
-  status: import_zod212.z.nativeEnum(PatchedTicketRequestStatus).optional()
+var PatchedMessageRequestSchema = import_zod212.z.object({
+  text: import_zod212.z.string().min(1).optional()
 });
 
-// src/cfg/generated/_utils/schemas/PatchedUnsubscribeRequest.schema.ts
+// src/cfg/generated/_utils/schemas/PatchedNewsletterCampaignRequest.schema.ts
 var import_zod213 = require("zod");
-var PatchedUnsubscribeRequestSchema = import_zod213.z.object({
-  subscription_id: import_zod213.z.int().optional()
+var PatchedNewsletterCampaignRequestSchema = import_zod213.z.object({
+  newsletter: import_zod213.z.int().optional(),
+  subject: import_zod213.z.string().min(1).max(255).optional(),
+  email_title: import_zod213.z.string().min(1).max(255).optional(),
+  main_text: import_zod213.z.string().min(1).optional(),
+  main_html_content: import_zod213.z.string().optional(),
+  button_text: import_zod213.z.string().max(100).optional(),
+  button_url: import_zod213.z.url().optional(),
+  secondary_text: import_zod213.z.string().optional()
 });
 
-// src/cfg/generated/_utils/schemas/PatchedUserProfileUpdateRequest.schema.ts
+// src/cfg/generated/_utils/schemas/PatchedTicketRequest.schema.ts
 var import_zod214 = require("zod");
-var PatchedUserProfileUpdateRequestSchema = import_zod214.z.object({
-  first_name: import_zod214.z.string().max(50).optional(),
-  last_name: import_zod214.z.string().max(50).optional(),
-  company: import_zod214.z.string().max(100).optional(),
-  phone: import_zod214.z.string().max(20).optional(),
-  position: import_zod214.z.string().max(100).optional()
+var PatchedTicketRequestSchema = import_zod214.z.object({
+  user: import_zod214.z.int().optional(),
+  subject: import_zod214.z.string().min(1).max(255).optional(),
+  status: import_zod214.z.nativeEnum(PatchedTicketRequestStatus).optional()
 });
 
-// src/cfg/generated/_utils/schemas/PaymentDetail.schema.ts
+// src/cfg/generated/_utils/schemas/PatchedUnsubscribeRequest.schema.ts
 var import_zod215 = require("zod");
-var PaymentDetailSchema = import_zod215.z.object({
-  id: import_zod215.z.uuid(),
-  internal_payment_id: import_zod215.z.string(),
-  amount_usd: import_zod215.z.string(),
-  currency_code: import_zod215.z.string(),
-  currency_name: import_zod215.z.string(),
-  currency_token: import_zod215.z.string(),
-  currency_network: import_zod215.z.string(),
-  pay_amount: import_zod215.z.string().nullable(),
-  actual_amount: import_zod215.z.string().nullable(),
-  actual_amount_usd: import_zod215.z.string().nullable(),
-  status: import_zod215.z.nativeEnum(PaymentDetailStatus),
-  status_display: import_zod215.z.string(),
-  pay_address: import_zod215.z.string().nullable(),
-  qr_code_url: import_zod215.z.string().nullable(),
-  payment_url: import_zod215.z.url().nullable(),
-  transaction_hash: import_zod215.z.string().nullable(),
-  explorer_link: import_zod215.z.string().nullable(),
-  confirmations_count: import_zod215.z.int(),
-  expires_at: import_zod215.z.iso.datetime().nullable(),
-  completed_at: import_zod215.z.iso.datetime().nullable(),
-  created_at: import_zod215.z.iso.datetime(),
-  is_completed: import_zod215.z.boolean(),
-  is_failed: import_zod215.z.boolean(),
-  is_expired: import_zod215.z.boolean(),
-  description: import_zod215.z.string()
+var PatchedUnsubscribeRequestSchema = import_zod215.z.object({
+  subscription_id: import_zod215.z.int().optional()
 });
 
-// src/cfg/generated/_utils/schemas/ProtoFileDetail.schema.ts
+// src/cfg/generated/_utils/schemas/PatchedUserProfileUpdateRequest.schema.ts
 var import_zod216 = require("zod");
-var ProtoFileDetailSchema = import_zod216.z.object({
-  app_label: import_zod216.z.string(),
-  filename: import_zod216.z.string(),
-  size_bytes: import_zod216.z.int(),
-  package: import_zod216.z.string(),
-  messages_count: import_zod216.z.int(),
-  services_count: import_zod216.z.int(),
-  created_at: import_zod216.z.number(),
-  modified_at: import_zod216.z.number(),
-  download_url: import_zod216.z.string().optional()
+var PatchedUserProfileUpdateRequestSchema = import_zod216.z.object({
+  first_name: import_zod216.z.string().max(50).optional(),
+  last_name: import_zod216.z.string().max(50).optional(),
+  company: import_zod216.z.string().max(100).optional(),
+  phone: import_zod216.z.string().max(20).optional(),
+  position: import_zod216.z.string().max(100).optional()
 });
 
-// src/cfg/generated/_utils/schemas/ProtoFileList.schema.ts
+// src/cfg/generated/_utils/schemas/PaymentDetail.schema.ts
 var import_zod217 = require("zod");
-var ProtoFileListSchema = import_zod217.z.object({
-  files: import_zod217.z.array(ProtoFileDetailSchema),
-  total_files: import_zod217.z.int(),
-  proto_dir: import_zod217.z.string(),
-  download_all_url: import_zod217.z.string().optional()
+var PaymentDetailSchema = import_zod217.z.object({
+  id: import_zod217.z.uuid(),
+  internal_payment_id: import_zod217.z.string(),
+  amount_usd: import_zod217.z.string(),
+  currency_code: import_zod217.z.string(),
+  currency_name: import_zod217.z.string(),
+  currency_token: import_zod217.z.string(),
+  currency_network: import_zod217.z.string(),
+  pay_amount: import_zod217.z.string().nullable(),
+  actual_amount: import_zod217.z.string().nullable(),
+  actual_amount_usd: import_zod217.z.string().nullable(),
+  status: import_zod217.z.nativeEnum(PaymentDetailStatus),
+  status_display: import_zod217.z.string(),
+  pay_address: import_zod217.z.string().nullable(),
+  qr_code_url: import_zod217.z.string().nullable(),
+  payment_url: import_zod217.z.url().nullable(),
+  transaction_hash: import_zod217.z.string().nullable(),
+  explorer_link: import_zod217.z.string().nullable(),
+  confirmations_count: import_zod217.z.int(),
+  expires_at: import_zod217.z.iso.datetime().nullable(),
+  completed_at: import_zod217.z.iso.datetime().nullable(),
+  created_at: import_zod217.z.iso.datetime(),
+  is_completed: import_zod217.z.boolean(),
+  is_failed: import_zod217.z.boolean(),
+  is_expired: import_zod217.z.boolean(),
+  description: import_zod217.z.string()
 });
 
-// src/cfg/generated/_utils/schemas/ProtoGenerateError.schema.ts
+// src/cfg/generated/_utils/schemas/ProtoFileDetail.schema.ts
 var import_zod218 = require("zod");
-var ProtoGenerateErrorSchema = import_zod218.z.object({
-  app: import_zod218.z.string(),
-  error: import_zod218.z.string()
+var ProtoFileDetailSchema = import_zod218.z.object({
+  app_label: import_zod218.z.string(),
+  filename: import_zod218.z.string(),
+  size_bytes: import_zod218.z.int(),
+  package: import_zod218.z.string(),
+  messages_count: import_zod218.z.int(),
+  services_count: import_zod218.z.int(),
+  created_at: import_zod218.z.number(),
+  modified_at: import_zod218.z.number(),
+  download_url: import_zod218.z.string().optional()
 });
 
-// src/cfg/generated/_utils/schemas/ProtoGenerateRequestRequest.schema.ts
+// src/cfg/generated/_utils/schemas/ProtoFileList.schema.ts
 var import_zod219 = require("zod");
-var ProtoGenerateRequestRequestSchema = import_zod219.z.object({
-  apps: import_zod219.z.array(import_zod219.z.string().min(1)).optional(),
-  force: import_zod219.z.boolean().optional()
+var ProtoFileListSchema = import_zod219.z.object({
+  files: import_zod219.z.array(ProtoFileDetailSchema),
+  total_files: import_zod219.z.int(),
+  proto_dir: import_zod219.z.string(),
+  download_all_url: import_zod219.z.string().optional()
 });
 
-// src/cfg/generated/_utils/schemas/ProtoGenerateResponse.schema.ts
+// src/cfg/generated/_utils/schemas/ProtoGenerateError.schema.ts
 var import_zod220 = require("zod");
-var ProtoGenerateResponseSchema = import_zod220.z.object({
-  status: import_zod220.z.string(),
-  generated: import_zod220.z.array(import_zod220.z.string()),
-  generated_count: import_zod220.z.int(),
-  errors: import_zod220.z.array(ProtoGenerateErrorSchema),
-  proto_dir: import_zod220.z.string()
+var ProtoGenerateErrorSchema = import_zod220.z.object({
+  app: import_zod220.z.string(),
+  error: import_zod220.z.string()
 });
 
-// src/cfg/generated/_utils/schemas/PublicDocument.schema.ts
+// src/cfg/generated/_utils/schemas/ProtoGenerateRequestRequest.schema.ts
 var import_zod221 = require("zod");
-var PublicDocumentSchema = import_zod221.z.object({
-  id: import_zod221.z.uuid(),
-  title: import_zod221.z.string().max(512),
-  content: import_zod221.z.string(),
+var ProtoGenerateRequestRequestSchema = import_zod221.z.object({
+  apps: import_zod221.z.array(import_zod221.z.string().min(1)).optional(),
+  force: import_zod221.z.boolean().optional()
+});
+
+// src/cfg/generated/_utils/schemas/ProtoGenerateResponse.schema.ts
+var import_zod222 = require("zod");
+var ProtoGenerateResponseSchema = import_zod222.z.object({
+  status: import_zod222.z.string(),
+  generated: import_zod222.z.array(import_zod222.z.string()),
+  generated_count: import_zod222.z.int(),
+  errors: import_zod222.z.array(ProtoGenerateErrorSchema),
+  proto_dir: import_zod222.z.string()
+});
+
+// src/cfg/generated/_utils/schemas/PublicDocument.schema.ts
+var import_zod223 = require("zod");
+var PublicDocumentSchema = import_zod223.z.object({
+  id: import_zod223.z.uuid(),
+  title: import_zod223.z.string().max(512),
+  content: import_zod223.z.string(),
   category: PublicCategorySchema,
-  created_at: import_zod221.z.iso.datetime(),
-  updated_at: import_zod221.z.iso.datetime()
+  created_at: import_zod223.z.iso.datetime(),
+  updated_at: import_zod223.z.iso.datetime()
 });
 
 // src/cfg/generated/_utils/schemas/PublishTestRequestRequest.schema.ts
-var import_zod222 = require("zod");
-var PublishTestRequestRequestSchema = import_zod222.z.object({
-  channel: import_zod222.z.string(),
-  data: import_zod222.z.record(import_zod222.z.string(), import_zod222.z.any()),
-  wait_for_ack: import_zod222.z.boolean().optional(),
-  ack_timeout: import_zod222.z.int().min(1).max(60).optional()
+var import_zod224 = require("zod");
+var PublishTestRequestRequestSchema = import_zod224.z.object({
+  channel: import_zod224.z.string(),
+  data: import_zod224.z.record(import_zod224.z.string(), import_zod224.z.any()),
+  wait_for_ack: import_zod224.z.boolean().optional(),
+  ack_timeout: import_zod224.z.int().min(1).max(60).optional()
 });
 
 // src/cfg/generated/_utils/schemas/PublishTestResponse.schema.ts
-var import_zod223 = require("zod");
-var PublishTestResponseSchema = import_zod223.z.object({
-  success: import_zod223.z.boolean(),
-  message_id: import_zod223.z.string(),
-  channel: import_zod223.z.string(),
-  acks_received: import_zod223.z.int().optional(),
-  delivered: import_zod223.z.boolean().optional(),
-  error: import_zod223.z.string().nullable().optional()
+var import_zod225 = require("zod");
+var PublishTestResponseSchema = import_zod225.z.object({
+  success: import_zod225.z.boolean(),
+  message_id: import_zod225.z.string(),
+  channel: import_zod225.z.string(),
+  acks_received: import_zod225.z.int().optional(),
+  delivered: import_zod225.z.boolean().optional(),
+  error: import_zod225.z.string().nullable().optional()
 });
 
 // src/cfg/generated/_utils/schemas/QueueDetail.schema.ts
-var import_zod224 = require("zod");
-var QueueDetailSchema = import_zod224.z.object({
-  name: import_zod224.z.string(),
-  count: import_zod224.z.int(),
-  queued_jobs: import_zod224.z.int().optional(),
-  started_jobs: import_zod224.z.int().optional(),
-  finished_jobs: import_zod224.z.int().optional(),
-  failed_jobs: import_zod224.z.int().optional(),
-  deferred_jobs: import_zod224.z.int().optional(),
-  scheduled_jobs: import_zod224.z.int().optional(),
-  workers: import_zod224.z.int().optional(),
-  oldest_job_timestamp: import_zod224.z.iso.datetime().nullable().optional(),
-  connection_kwargs: import_zod224.z.record(import_zod224.z.string(), import_zod224.z.any()).optional(),
-  is_async: import_zod224.z.boolean().optional()
+var import_zod226 = require("zod");
+var QueueDetailSchema = import_zod226.z.object({
+  name: import_zod226.z.string(),
+  count: import_zod226.z.int(),
+  queued_jobs: import_zod226.z.int().optional(),
+  started_jobs: import_zod226.z.int().optional(),
+  finished_jobs: import_zod226.z.int().optional(),
+  failed_jobs: import_zod226.z.int().optional(),
+  deferred_jobs: import_zod226.z.int().optional(),
+  scheduled_jobs: import_zod226.z.int().optional(),
+  workers: import_zod226.z.int().optional(),
+  oldest_job_timestamp: import_zod226.z.iso.datetime().nullable().optional(),
+  connection_kwargs: import_zod226.z.record(import_zod226.z.string(), import_zod226.z.any()).optional(),
+  is_async: import_zod226.z.boolean().optional()
 });
 
 // src/cfg/generated/_utils/schemas/QueueStats.schema.ts
-var import_zod225 = require("zod");
-var QueueStatsSchema = import_zod225.z.object({
-  name: import_zod225.z.string(),
-  count: import_zod225.z.int(),
-  queued_jobs: import_zod225.z.int().optional(),
-  started_jobs: import_zod225.z.int().optional(),
-  finished_jobs: import_zod225.z.int().optional(),
-  failed_jobs: import_zod225.z.int().optional(),
-  deferred_jobs: import_zod225.z.int().optional(),
-  scheduled_jobs: import_zod225.z.int().optional(),
-  workers: import_zod225.z.int().optional()
+var import_zod227 = require("zod");
+var QueueStatsSchema = import_zod227.z.object({
+  name: import_zod227.z.string(),
+  count: import_zod227.z.int(),
+  queued_jobs: import_zod227.z.int().optional(),
+  started_jobs: import_zod227.z.int().optional(),
+  finished_jobs: import_zod227.z.int().optional(),
+  failed_jobs: import_zod227.z.int().optional(),
+  deferred_jobs: import_zod227.z.int().optional(),
+  scheduled_jobs: import_zod227.z.int().optional(),
+  workers: import_zod227.z.int().optional()
 });
 
 // src/cfg/generated/_utils/schemas/QuickHealth.schema.ts
-var import_zod226 = require("zod");
-var QuickHealthSchema = import_zod226.z.object({
-  status: import_zod226.z.string(),
-  timestamp: import_zod226.z.iso.datetime(),
-  error: import_zod226.z.string().optional()
+var import_zod228 = require("zod");
+var QuickHealthSchema = import_zod228.z.object({
+  status: import_zod228.z.string(),
+  timestamp: import_zod228.z.iso.datetime(),
+  error: import_zod228.z.string().optional()
 });
 
 // src/cfg/generated/_utils/schemas/RQConfig.schema.ts
-var import_zod228 = require("zod");
+var import_zod230 = require("zod");
 
 // src/cfg/generated/_utils/schemas/ScheduleInfo.schema.ts
-var import_zod227 = require("zod");
-var ScheduleInfoSchema = import_zod227.z.object({
-  func: import_zod227.z.string(),
-  queue: import_zod227.z.string(),
-  cron: import_zod227.z.string().nullable().optional(),
-  interval: import_zod227.z.int().nullable().optional(),
-  scheduled_time: import_zod227.z.iso.datetime().nullable().optional(),
-  description: import_zod227.z.string().nullable().optional(),
-  timeout: import_zod227.z.int().nullable().optional(),
-  result_ttl: import_zod227.z.int().nullable().optional(),
-  repeat: import_zod227.z.int().nullable().optional()
+var import_zod229 = require("zod");
+var ScheduleInfoSchema = import_zod229.z.object({
+  func: import_zod229.z.string(),
+  queue: import_zod229.z.string(),
+  cron: import_zod229.z.string().nullable().optional(),
+  interval: import_zod229.z.int().nullable().optional(),
+  scheduled_time: import_zod229.z.iso.datetime().nullable().optional(),
+  description: import_zod229.z.string().nullable().optional(),
+  timeout: import_zod229.z.int().nullable().optional(),
+  result_ttl: import_zod229.z.int().nullable().optional(),
+  repeat: import_zod229.z.int().nullable().optional()
 });
 
 // src/cfg/generated/_utils/schemas/RQConfig.schema.ts
-var RQConfigSchema = import_zod228.z.object({
-  enabled: import_zod228.z.boolean(),
-  queues: import_zod228.z.record(import_zod228.z.string(), import_zod228.z.any()),
-  async_mode: import_zod228.z.boolean().optional(),
-  show_admin_link: import_zod228.z.boolean().optional(),
-  prometheus_enabled: import_zod228.z.boolean().optional(),
-  api_token_configured: import_zod228.z.boolean().optional(),
-  schedules: import_zod228.z.array(ScheduleInfoSchema).optional()
+var RQConfigSchema = import_zod230.z.object({
+  enabled: import_zod230.z.boolean(),
+  queues: import_zod230.z.record(import_zod230.z.string(), import_zod230.z.any()),
+  async_mode: import_zod230.z.boolean().optional(),
+  show_admin_link: import_zod230.z.boolean().optional(),
+  prometheus_enabled: import_zod230.z.boolean().optional(),
+  api_token_configured: import_zod230.z.boolean().optional(),
+  schedules: import_zod230.z.array(ScheduleInfoSchema).optional()
+});
+
+// src/cfg/generated/_utils/schemas/RQHealthCheck.schema.ts
+var import_zod231 = require("zod");
+var RQHealthCheckSchema = import_zod231.z.object({
+  status: import_zod231.z.string(),
+  worker_count: import_zod231.z.int(),
+  queue_count: import_zod231.z.int(),
+  total_jobs: import_zod231.z.int(),
+  timestamp: import_zod231.z.iso.datetime(),
+  enabled: import_zod231.z.boolean(),
+  redis_connected: import_zod231.z.boolean(),
+  wrapper_url: import_zod231.z.string().optional(),
+  has_api_key: import_zod231.z.boolean().optional()
 });
 
 // src/cfg/generated/_utils/schemas/RecentError.schema.ts
-var import_zod229 = require("zod");
-var RecentErrorSchema = import_zod229.z.object({
-  method: import_zod229.z.string(),
-  error_message: import_zod229.z.string(),
-  grpc_status_code: import_zod229.z.string(),
-  occurred_at: import_zod229.z.string()
+var import_zod232 = require("zod");
+var RecentErrorSchema = import_zod232.z.object({
+  method: import_zod232.z.string(),
+  error_message: import_zod232.z.string(),
+  grpc_status_code: import_zod232.z.string(),
+  occurred_at: import_zod232.z.string()
 });
 
 // src/cfg/generated/_utils/schemas/RecentUser.schema.ts
-var import_zod230 = require("zod");
-var RecentUserSchema = import_zod230.z.object({
-  id: import_zod230.z.int(),
-  username: import_zod230.z.string(),
-  email: import_zod230.z.email(),
-  date_joined: import_zod230.z.string(),
-  is_active: import_zod230.z.boolean(),
-  is_staff: import_zod230.z.boolean(),
-  is_superuser: import_zod230.z.boolean(),
-  last_login: import_zod230.z.string().nullable()
+var import_zod233 = require("zod");
+var RecentUserSchema = import_zod233.z.object({
+  id: import_zod233.z.int(),
+  username: import_zod233.z.string(),
+  email: import_zod233.z.email(),
+  date_joined: import_zod233.z.string(),
+  is_active: import_zod233.z.boolean(),
+  is_staff: import_zod233.z.boolean(),
+  is_superuser: import_zod233.z.boolean(),
+  last_login: import_zod233.z.string().nullable()
 });
 
 // src/cfg/generated/_utils/schemas/RunDemoRequestRequest.schema.ts
-var import_zod231 = require("zod");
-var RunDemoRequestRequestSchema = import_zod231.z.object({
-  scenario: import_zod231.z.nativeEnum(RunDemoRequestRequestScenario),
-  queue: import_zod231.z.string().min(1).optional(),
-  args: import_zod231.z.array(import_zod231.z.record(import_zod231.z.string(), import_zod231.z.any())).optional(),
-  kwargs: import_zod231.z.record(import_zod231.z.string(), import_zod231.z.any()).optional(),
-  timeout: import_zod231.z.int().nullable().optional()
+var import_zod234 = require("zod");
+var RunDemoRequestRequestSchema = import_zod234.z.object({
+  scenario: import_zod234.z.nativeEnum(RunDemoRequestRequestScenario),
+  queue: import_zod234.z.string().min(1).optional(),
+  args: import_zod234.z.array(import_zod234.z.record(import_zod234.z.string(), import_zod234.z.any())).optional(),
+  kwargs: import_zod234.z.record(import_zod234.z.string(), import_zod234.z.any()).optional(),
+  timeout: import_zod234.z.int().nullable().optional()
 });
 
 // src/cfg/generated/_utils/schemas/ScheduleActionResponse.schema.ts
-var import_zod232 = require("zod");
-var ScheduleActionResponseSchema = import_zod232.z.object({
-  success: import_zod232.z.boolean(),
-  message: import_zod232.z.string(),
-  job_id: import_zod232.z.string().nullable().optional(),
-  action: import_zod232.z.string()
+var import_zod235 = require("zod");
+var ScheduleActionResponseSchema = import_zod235.z.object({
+  success: import_zod235.z.boolean(),
+  message: import_zod235.z.string(),
+  job_id: import_zod235.z.string().nullable().optional(),
+  action: import_zod235.z.string()
 });
 
 // src/cfg/generated/_utils/schemas/ScheduleCreateRequest.schema.ts
-var import_zod233 = require("zod");
-var ScheduleCreateRequestSchema = import_zod233.z.object({
-  func: import_zod233.z.string().min(1),
-  args: import_zod233.z.array(import_zod233.z.record(import_zod233.z.string(), import_zod233.z.any())).optional(),
-  kwargs: import_zod233.z.record(import_zod233.z.string(), import_zod233.z.any()).optional(),
-  queue_name: import_zod233.z.string().min(1).optional(),
-  scheduled_time: import_zod233.z.iso.datetime().nullable().optional(),
-  interval: import_zod233.z.int().min(1).nullable().optional(),
-  cron: import_zod233.z.string().min(1).nullable().optional(),
-  timeout: import_zod233.z.int().nullable().optional(),
-  result_ttl: import_zod233.z.int().nullable().optional(),
-  repeat: import_zod233.z.int().nullable().optional(),
-  description: import_zod233.z.string().min(1).max(255).nullable().optional()
+var import_zod236 = require("zod");
+var ScheduleCreateRequestSchema = import_zod236.z.object({
+  func: import_zod236.z.string().min(1),
+  args: import_zod236.z.array(import_zod236.z.record(import_zod236.z.string(), import_zod236.z.any())).optional(),
+  kwargs: import_zod236.z.record(import_zod236.z.string(), import_zod236.z.any()).optional(),
+  queue_name: import_zod236.z.string().min(1).optional(),
+  scheduled_time: import_zod236.z.iso.datetime().nullable().optional(),
+  interval: import_zod236.z.int().min(1).nullable().optional(),
+  cron: import_zod236.z.string().min(1).nullable().optional(),
+  timeout: import_zod236.z.int().nullable().optional(),
+  result_ttl: import_zod236.z.int().nullable().optional(),
+  repeat: import_zod236.z.int().nullable().optional(),
+  description: import_zod236.z.string().min(1).max(255).nullable().optional()
 });
 
 // src/cfg/generated/_utils/schemas/SendCampaignRequest.schema.ts
-var import_zod234 = require("zod");
-var SendCampaignRequestSchema = import_zod234.z.object({
-  campaign_id: import_zod234.z.int()
+var import_zod237 = require("zod");
+var SendCampaignRequestSchema = import_zod237.z.object({
+  campaign_id: import_zod237.z.int()
 });
 
 // src/cfg/generated/_utils/schemas/SendCampaignResponse.schema.ts
-var import_zod235 = require("zod");
-var SendCampaignResponseSchema = import_zod235.z.object({
-  success: import_zod235.z.boolean(),
-  message: import_zod235.z.string().optional(),
-  sent_count: import_zod235.z.int().optional(),
-  error: import_zod235.z.string().optional()
+var import_zod238 = require("zod");
+var SendCampaignResponseSchema = import_zod238.z.object({
+  success: import_zod238.z.boolean(),
+  message: import_zod238.z.string().optional(),
+  sent_count: import_zod238.z.int().optional(),
+  error: import_zod238.z.string().optional()
 });
 
 // src/cfg/generated/_utils/schemas/ServerLifecycleChart.schema.ts
-var import_zod237 = require("zod");
+var import_zod240 = require("zod");
 
 // src/cfg/generated/_utils/schemas/ServerLifecycleEvent.schema.ts
-var import_zod236 = require("zod");
-var ServerLifecycleEventSchema = import_zod236.z.object({
-  timestamp: import_zod236.z.string(),
-  event_type: import_zod236.z.string(),
-  server_address: import_zod236.z.string(),
-  server_pid: import_zod236.z.int(),
-  uptime_seconds: import_zod236.z.int().nullable().optional(),
-  error_message: import_zod236.z.string().nullable().optional()
+var import_zod239 = require("zod");
+var ServerLifecycleEventSchema = import_zod239.z.object({
+  timestamp: import_zod239.z.string(),
+  event_type: import_zod239.z.string(),
+  server_address: import_zod239.z.string(),
+  server_pid: import_zod239.z.int(),
+  uptime_seconds: import_zod239.z.int().nullable().optional(),
+  error_message: import_zod239.z.string().nullable().optional()
 });
 
 // src/cfg/generated/_utils/schemas/ServerLifecycleChart.schema.ts
-var ServerLifecycleChartSchema = import_zod237.z.object({
-  title: import_zod237.z.string().optional(),
-  events: import_zod237.z.array(ServerLifecycleEventSchema).optional(),
-  period_hours: import_zod237.z.int(),
-  total_events: import_zod237.z.int(),
-  restart_count: import_zod237.z.int(),
-  error_count: import_zod237.z.int()
+var ServerLifecycleChartSchema = import_zod240.z.object({
+  title: import_zod240.z.string().optional(),
+  events: import_zod240.z.array(ServerLifecycleEventSchema).optional(),
+  period_hours: import_zod240.z.int(),
+  total_events: import_zod240.z.int(),
+  restart_count: import_zod240.z.int(),
+  error_count: import_zod240.z.int()
 });
 
 // src/cfg/generated/_utils/schemas/ServiceDetail.schema.ts
-var import_zod239 = require("zod");
+var import_zod242 = require("zod");
 
 // src/cfg/generated/_utils/schemas/ServiceStats.schema.ts
-var import_zod238 = require("zod");
-var ServiceStatsSchema = import_zod238.z.object({
-  total_requests: import_zod238.z.int().optional(),
-  successful: import_zod238.z.int().optional(),
-  errors: import_zod238.z.int().optional(),
-  success_rate: import_zod238.z.number().optional(),
-  avg_duration_ms: import_zod238.z.number().optional(),
-  last_24h_requests: import_zod238.z.int().optional()
+var import_zod241 = require("zod");
+var ServiceStatsSchema = import_zod241.z.object({
+  total_requests: import_zod241.z.int().optional(),
+  successful: import_zod241.z.int().optional(),
+  errors: import_zod241.z.int().optional(),
+  success_rate: import_zod241.z.number().optional(),
+  avg_duration_ms: import_zod241.z.number().optional(),
+  last_24h_requests: import_zod241.z.int().optional()
 });
 
 // src/cfg/generated/_utils/schemas/ServiceDetail.schema.ts
-var ServiceDetailSchema = import_zod239.z.object({
-  name: import_zod239.z.string(),
-  full_name: import_zod239.z.string(),
-  package: import_zod239.z.string(),
-  description: import_zod239.z.string().optional(),
-  file_path: import_zod239.z.string().optional(),
-  class_name: import_zod239.z.string(),
-  base_class: import_zod239.z.string().optional(),
-  methods: import_zod239.z.array(MethodInfoSchema).optional(),
+var ServiceDetailSchema = import_zod242.z.object({
+  name: import_zod242.z.string(),
+  full_name: import_zod242.z.string(),
+  package: import_zod242.z.string(),
+  description: import_zod242.z.string().optional(),
+  file_path: import_zod242.z.string().optional(),
+  class_name: import_zod242.z.string(),
+  base_class: import_zod242.z.string().optional(),
+  methods: import_zod242.z.array(MethodInfoSchema).optional(),
   stats: ServiceStatsSchema,
-  recent_errors: import_zod239.z.array(RecentErrorSchema).optional()
+  recent_errors: import_zod242.z.array(RecentErrorSchema).optional()
 });
 
 // src/cfg/generated/_utils/schemas/ServiceMethods.schema.ts
-var import_zod240 = require("zod");
-var ServiceMethodsSchema = import_zod240.z.object({
-  service_name: import_zod240.z.string(),
-  methods: import_zod240.z.array(MethodSummarySchema).optional(),
-  total_methods: import_zod240.z.int()
+var import_zod243 = require("zod");
+var ServiceMethodsSchema = import_zod243.z.object({
+  service_name: import_zod243.z.string(),
+  methods: import_zod243.z.array(MethodSummarySchema).optional(),
+  total_methods: import_zod243.z.int()
 });
 
 // src/cfg/generated/_utils/schemas/StressTestRequestRequest.schema.ts
-var import_zod241 = require("zod");
-var StressTestRequestRequestSchema = import_zod241.z.object({
-  num_jobs: import_zod241.z.int().min(1).max(1e3).optional(),
-  queue: import_zod241.z.string().min(1).optional(),
-  scenario: import_zod241.z.nativeEnum(StressTestRequestRequestScenario).optional(),
-  duration: import_zod241.z.int().min(1).max(60).optional()
+var import_zod244 = require("zod");
+var StressTestRequestRequestSchema = import_zod244.z.object({
+  num_jobs: import_zod244.z.int().min(1).max(1e3).optional(),
+  queue: import_zod244.z.string().min(1).optional(),
+  scenario: import_zod244.z.nativeEnum(StressTestRequestRequestScenario).optional(),
+  duration: import_zod244.z.int().min(1).max(60).optional()
 });
 
 // src/cfg/generated/_utils/schemas/SubscribeRequest.schema.ts
-var import_zod242 = require("zod");
-var SubscribeRequestSchema = import_zod242.z.object({
-  newsletter_id: import_zod242.z.int(),
-  email: import_zod242.z.email()
+var import_zod245 = require("zod");
+var SubscribeRequestSchema = import_zod245.z.object({
+  newsletter_id: import_zod245.z.int(),
+  email: import_zod245.z.email()
 });
 
 // src/cfg/generated/_utils/schemas/SubscribeResponse.schema.ts
-var import_zod243 = require("zod");
-var SubscribeResponseSchema = import_zod243.z.object({
-  success: import_zod243.z.boolean(),
-  message: import_zod243.z.string(),
-  subscription_id: import_zod243.z.int().optional()
+var import_zod246 = require("zod");
+var SubscribeResponseSchema = import_zod246.z.object({
+  success: import_zod246.z.boolean(),
+  message: import_zod246.z.string(),
+  subscription_id: import_zod246.z.int().optional()
 });
 
 // src/cfg/generated/_utils/schemas/SuccessResponse.schema.ts
-var import_zod244 = require("zod");
-var SuccessResponseSchema = import_zod244.z.object({
-  success: import_zod244.z.boolean(),
-  message: import_zod244.z.string()
+var import_zod247 = require("zod");
+var SuccessResponseSchema = import_zod247.z.object({
+  success: import_zod247.z.boolean(),
+  message: import_zod247.z.string()
 });
 
 // src/cfg/generated/_utils/schemas/TestEmailRequest.schema.ts
-var import_zod245 = require("zod");
-var TestEmailRequestSchema = import_zod245.z.object({
-  email: import_zod245.z.email(),
-  subject: import_zod245.z.string().min(1).max(255).optional(),
-  message: import_zod245.z.string().min(1).optional()
+var import_zod248 = require("zod");
+var TestEmailRequestSchema = import_zod248.z.object({
+  email: import_zod248.z.email(),
+  subject: import_zod248.z.string().min(1).max(255).optional(),
+  message: import_zod248.z.string().min(1).optional()
 });
 
 // src/cfg/generated/_utils/schemas/TestScenario.schema.ts
-var import_zod246 = require("zod");
-var TestScenarioSchema = import_zod246.z.object({
-  id: import_zod246.z.string(),
-  name: import_zod246.z.string(),
-  description: import_zod246.z.string(),
-  task_func: import_zod246.z.string(),
-  default_args: import_zod246.z.array(import_zod246.z.record(import_zod246.z.string(), import_zod246.z.any())).optional(),
-  default_kwargs: import_zod246.z.record(import_zod246.z.string(), import_zod246.z.any()).optional(),
-  estimated_duration: import_zod246.z.int().nullable().optional()
+var import_zod249 = require("zod");
+var TestScenarioSchema = import_zod249.z.object({
+  id: import_zod249.z.string(),
+  name: import_zod249.z.string(),
+  description: import_zod249.z.string(),
+  task_func: import_zod249.z.string(),
+  default_args: import_zod249.z.array(import_zod249.z.record(import_zod249.z.string(), import_zod249.z.any())).optional(),
+  default_kwargs: import_zod249.z.record(import_zod249.z.string(), import_zod249.z.any()).optional(),
+  estimated_duration: import_zod249.z.int().nullable().optional()
 });
 
 // src/cfg/generated/_utils/schemas/TestingActionResponse.schema.ts
-var import_zod247 = require("zod");
-var TestingActionResponseSchema = import_zod247.z.object({
-  success: import_zod247.z.boolean(),
-  message: import_zod247.z.string(),
-  job_ids: import_zod247.z.array(import_zod247.z.string()).optional(),
-  count: import_zod247.z.int().nullable().optional(),
-  metadata: import_zod247.z.record(import_zod247.z.string(), import_zod247.z.any()).optional()
+var import_zod250 = require("zod");
+var TestingActionResponseSchema = import_zod250.z.object({
+  success: import_zod250.z.boolean(),
+  message: import_zod250.z.string(),
+  job_ids: import_zod250.z.array(import_zod250.z.string()).optional(),
+  count: import_zod250.z.int().nullable().optional(),
+  metadata: import_zod250.z.record(import_zod250.z.string(), import_zod250.z.any()).optional()
 });
 
 // src/cfg/generated/_utils/schemas/TicketRequest.schema.ts
-var import_zod248 = require("zod");
-var TicketRequestSchema = import_zod248.z.object({
-  user: import_zod248.z.int(),
-  subject: import_zod248.z.string().min(1).max(255),
-  status: import_zod248.z.nativeEnum(TicketRequestStatus).optional()
+var import_zod251 = require("zod");
+var TicketRequestSchema = import_zod251.z.object({
+  user: import_zod251.z.int(),
+  subject: import_zod251.z.string().min(1).max(255),
+  status: import_zod251.z.nativeEnum(TicketRequestStatus).optional()
 });
 
 // src/cfg/generated/_utils/schemas/TimelineItem.schema.ts
-var import_zod249 = require("zod");
-var TimelineItemSchema = import_zod249.z.object({
-  timestamp: import_zod249.z.string(),
-  count: import_zod249.z.int(),
-  successful: import_zod249.z.int(),
-  failed: import_zod249.z.int(),
-  timeout: import_zod249.z.int()
+var import_zod252 = require("zod");
+var TimelineItemSchema = import_zod252.z.object({
+  timestamp: import_zod252.z.string(),
+  count: import_zod252.z.int(),
+  successful: import_zod252.z.int(),
+  failed: import_zod252.z.int(),
+  timeout: import_zod252.z.int()
 });
 
 // src/cfg/generated/_utils/schemas/TimelineResponse.schema.ts
-var import_zod250 = require("zod");
-var TimelineResponseSchema = import_zod250.z.object({
-  timeline: import_zod250.z.array(TimelineItemSchema),
-  period_hours: import_zod250.z.int(),
-  interval: import_zod250.z.string()
+var import_zod253 = require("zod");
+var TimelineResponseSchema = import_zod253.z.object({
+  timeline: import_zod253.z.array(TimelineItemSchema),
+  period_hours: import_zod253.z.int(),
+  interval: import_zod253.z.string()
 });
 
 // src/cfg/generated/_utils/schemas/TokenRefresh.schema.ts
-var import_zod251 = require("zod");
-var TokenRefreshSchema = import_zod251.z.object({
-  access: import_zod251.z.string(),
-  refresh: import_zod251.z.string()
+var import_zod254 = require("zod");
+var TokenRefreshSchema = import_zod254.z.object({
+  access: import_zod254.z.string(),
+  refresh: import_zod254.z.string()
 });
 
 // src/cfg/generated/_utils/schemas/TokenRefreshRequest.schema.ts
-var import_zod252 = require("zod");
-var TokenRefreshRequestSchema = import_zod252.z.object({
-  refresh: import_zod252.z.string().min(1)
+var import_zod255 = require("zod");
+var TokenRefreshRequestSchema = import_zod255.z.object({
+  refresh: import_zod255.z.string().min(1)
 });
 
 // src/cfg/generated/_utils/schemas/Transaction.schema.ts
-var import_zod253 = require("zod");
-var TransactionSchema = import_zod253.z.object({
-  id: import_zod253.z.uuid(),
-  transaction_type: import_zod253.z.nativeEnum(TransactionTransactionType),
-  type_display: import_zod253.z.string(),
-  amount_usd: import_zod253.z.string(),
-  amount_display: import_zod253.z.string(),
-  balance_after: import_zod253.z.string(),
-  payment_id: import_zod253.z.string().nullable(),
-  description: import_zod253.z.string(),
-  created_at: import_zod253.z.iso.datetime()
+var import_zod256 = require("zod");
+var TransactionSchema = import_zod256.z.object({
+  id: import_zod256.z.uuid(),
+  transaction_type: import_zod256.z.nativeEnum(TransactionTransactionType),
+  type_display: import_zod256.z.string(),
+  amount_usd: import_zod256.z.string(),
+  amount_display: import_zod256.z.string(),
+  balance_after: import_zod256.z.string(),
+  payment_id: import_zod256.z.string().nullable(),
+  description: import_zod256.z.string(),
+  created_at: import_zod256.z.iso.datetime()
 });
 
 // src/cfg/generated/_utils/schemas/URLPattern.schema.ts
-var import_zod254 = require("zod");
-var URLPatternSchema = import_zod254.z.object({
-  pattern: import_zod254.z.string(),
-  name: import_zod254.z.string().nullable().optional(),
-  full_name: import_zod254.z.string().nullable().optional(),
-  namespace: import_zod254.z.string().nullable().optional(),
-  view: import_zod254.z.string().nullable().optional(),
-  view_class: import_zod254.z.string().nullable().optional(),
-  methods: import_zod254.z.array(import_zod254.z.string()).optional(),
-  module: import_zod254.z.string().nullable().optional()
+var import_zod257 = require("zod");
+var URLPatternSchema = import_zod257.z.object({
+  pattern: import_zod257.z.string(),
+  name: import_zod257.z.string().nullable().optional(),
+  full_name: import_zod257.z.string().nullable().optional(),
+  namespace: import_zod257.z.string().nullable().optional(),
+  view: import_zod257.z.string().nullable().optional(),
+  view_class: import_zod257.z.string().nullable().optional(),
+  methods: import_zod257.z.array(import_zod257.z.string()).optional(),
+  module: import_zod257.z.string().nullable().optional()
 });
 
 // src/cfg/generated/_utils/schemas/URLsList.schema.ts
-var import_zod255 = require("zod");
-var URLsListSchema = import_zod255.z.object({
-  status: import_zod255.z.string(),
-  service: import_zod255.z.string(),
-  version: import_zod255.z.string(),
-  base_url: import_zod255.z.string(),
-  total_urls: import_zod255.z.int(),
-  urls: import_zod255.z.array(URLPatternSchema)
+var import_zod258 = require("zod");
+var URLsListSchema = import_zod258.z.object({
+  status: import_zod258.z.string(),
+  service: import_zod258.z.string(),
+  version: import_zod258.z.string(),
+  base_url: import_zod258.z.string(),
+  total_urls: import_zod258.z.int(),
+  urls: import_zod258.z.array(URLPatternSchema)
 });
 
 // src/cfg/generated/_utils/schemas/Unsubscribe.schema.ts
-var import_zod256 = require("zod");
-var UnsubscribeSchema = import_zod256.z.object({
-  subscription_id: import_zod256.z.int()
+var import_zod259 = require("zod");
+var UnsubscribeSchema = import_zod259.z.object({
+  subscription_id: import_zod259.z.int()
 });
 
 // src/cfg/generated/_utils/schemas/UnsubscribeRequest.schema.ts
-var import_zod257 = require("zod");
-var UnsubscribeRequestSchema = import_zod257.z.object({
-  subscription_id: import_zod257.z.int()
+var import_zod260 = require("zod");
+var UnsubscribeRequestSchema = import_zod260.z.object({
+  subscription_id: import_zod260.z.int()
 });
 
 // src/cfg/generated/_utils/schemas/UserProfileUpdateRequest.schema.ts
-var import_zod258 = require("zod");
-var UserProfileUpdateRequestSchema = import_zod258.z.object({
-  first_name: import_zod258.z.string().max(50).optional(),
-  last_name: import_zod258.z.string().max(50).optional(),
-  company: import_zod258.z.string().max(100).optional(),
-  phone: import_zod258.z.string().max(20).optional(),
-  position: import_zod258.z.string().max(100).optional()
+var import_zod261 = require("zod");
+var UserProfileUpdateRequestSchema = import_zod261.z.object({
+  first_name: import_zod261.z.string().max(50).optional(),
+  last_name: import_zod261.z.string().max(50).optional(),
+  company: import_zod261.z.string().max(100).optional(),
+  phone: import_zod261.z.string().max(20).optional(),
+  position: import_zod261.z.string().max(100).optional()
 });
 
 // src/cfg/generated/_utils/schemas/VectorizationResult.schema.ts
-var import_zod259 = require("zod");
-var VectorizationResultSchema = import_zod259.z.object({
-  vectorized_count: import_zod259.z.int(),
-  failed_count: import_zod259.z.int(),
-  total_tokens: import_zod259.z.int(),
-  total_cost: import_zod259.z.number(),
-  success_rate: import_zod259.z.number(),
-  errors: import_zod259.z.array(import_zod259.z.string())
+var import_zod262 = require("zod");
+var VectorizationResultSchema = import_zod262.z.object({
+  vectorized_count: import_zod262.z.int(),
+  failed_count: import_zod262.z.int(),
+  total_tokens: import_zod262.z.int(),
+  total_cost: import_zod262.z.number(),
+  success_rate: import_zod262.z.number(),
+  errors: import_zod262.z.array(import_zod262.z.string())
 });
 
 // src/cfg/generated/_utils/schemas/VectorizationStatistics.schema.ts
-var import_zod260 = require("zod");
-var VectorizationStatisticsSchema = import_zod260.z.object({
-  total_chunks: import_zod260.z.int(),
-  vectorized_chunks: import_zod260.z.int(),
-  pending_chunks: import_zod260.z.int(),
-  vectorization_rate: import_zod260.z.number(),
-  total_tokens: import_zod260.z.int(),
-  total_cost: import_zod260.z.number(),
-  avg_tokens_per_chunk: import_zod260.z.number(),
-  avg_cost_per_chunk: import_zod260.z.number()
+var import_zod263 = require("zod");
+var VectorizationStatisticsSchema = import_zod263.z.object({
+  total_chunks: import_zod263.z.int(),
+  vectorized_chunks: import_zod263.z.int(),
+  pending_chunks: import_zod263.z.int(),
+  vectorization_rate: import_zod263.z.number(),
+  total_tokens: import_zod263.z.int(),
+  total_cost: import_zod263.z.number(),
+  avg_tokens_per_chunk: import_zod263.z.number(),
+  avg_cost_per_chunk: import_zod263.z.number()
 });
 
 // src/cfg/generated/_utils/schemas/Worker.schema.ts
-var import_zod261 = require("zod");
-var WorkerSchema = import_zod261.z.object({
-  name: import_zod261.z.string(),
-  queues: import_zod261.z.array(import_zod261.z.string()).optional(),
-  state: import_zod261.z.string(),
-  current_job: import_zod261.z.string().nullable().optional(),
-  birth: import_zod261.z.iso.datetime(),
-  last_heartbeat: import_zod261.z.iso.datetime(),
-  successful_job_count: import_zod261.z.int().optional(),
-  failed_job_count: import_zod261.z.int().optional(),
-  total_working_time: import_zod261.z.number().optional()
+var import_zod264 = require("zod");
+var WorkerSchema = import_zod264.z.object({
+  name: import_zod264.z.string(),
+  queues: import_zod264.z.array(import_zod264.z.string()).optional(),
+  state: import_zod264.z.string(),
+  current_job: import_zod264.z.string().nullable().optional(),
+  birth: import_zod264.z.iso.datetime(),
+  last_heartbeat: import_zod264.z.iso.datetime(),
+  successful_job_count: import_zod264.z.int().optional(),
+  failed_job_count: import_zod264.z.int().optional(),
+  total_working_time: import_zod264.z.number().optional()
 });
 
 // src/cfg/generated/_utils/schemas/WorkerStats.schema.ts
-var import_zod262 = require("zod");
-var WorkerStatsSchema = import_zod262.z.object({
-  total_workers: import_zod262.z.int(),
-  busy_workers: import_zod262.z.int().optional(),
-  idle_workers: import_zod262.z.int().optional(),
-  suspended_workers: import_zod262.z.int().optional(),
-  total_successful_jobs: import_zod262.z.int().optional(),
-  total_failed_jobs: import_zod262.z.int().optional(),
-  total_working_time: import_zod262.z.number().optional(),
-  workers: import_zod262.z.array(WorkerSchema).optional()
+var import_zod265 = require("zod");
+var WorkerStatsSchema = import_zod265.z.object({
+  total_workers: import_zod265.z.int(),
+  busy_workers: import_zod265.z.int().optional(),
+  idle_workers: import_zod265.z.int().optional(),
+  suspended_workers: import_zod265.z.int().optional(),
+  total_successful_jobs: import_zod265.z.int().optional(),
+  total_failed_jobs: import_zod265.z.int().optional(),
+  total_working_time: import_zod265.z.number().optional(),
+  workers: import_zod265.z.array(WorkerSchema).optional()
 });
 
 // src/cfg/generated/validation-events.ts
@@ -8416,7 +8456,7 @@ async function getCentrifugoMonitorHealthRetrieve(client) {
   const api2 = client || getAPIInstance();
   const response = await api2.cfg_centrifugo_monitoring.centrifugoMonitorHealthRetrieve();
   try {
-    return HealthCheckSchema.parse(response);
+    return CentrifugoHealthCheckSchema.parse(response);
   } catch (error) {
     import_consola7.consola.error("\u274C Zod Validation Failed");
     import_consola7.consola.box({
@@ -10555,7 +10595,7 @@ async function getHealthDrfRetrieve(client) {
   const api2 = client || getAPIInstance();
   const response = await api2.cfg_health.drfRetrieve();
   try {
-    return HealthCheckSchema.parse(response);
+    return DRFHealthCheckSchema.parse(response);
   } catch (error) {
     import_consola24.consola.error("\u274C Zod Validation Failed");
     import_consola24.consola.box({
@@ -14734,7 +14774,7 @@ async function getRqMonitorHealthRetrieve(client) {
   const api2 = client || getAPIInstance();
   const response = await api2.cfg_rq_monitoring.rqMonitorHealthRetrieve();
   try {
-    return HealthCheckSchema.parse(response);
+    return RQHealthCheckSchema.parse(response);
   } catch (error) {
     import_consola37.consola.error("\u274C Zod Validation Failed");
     import_consola37.consola.box({