@djangocfg/api 2.1.42 → 2.1.44

package/dist/clients.cjs

@@ -31,11 +31,11 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 var clients_exports = {};
 __export(clients_exports, {
   AccountsAPI: () => API,
-  CentrifugoAPI: () => API3,
-  CentrifugoFetchers: () => fetchers_exports3,
+  CentrifugoAPI: () => API2,
+  CentrifugoFetchers: () => fetchers_exports2,
   CentrifugoHooks: () => hooks_exports2,
   CentrifugoTokenSchema: () => CentrifugoTokenSchema,
-  CentrifugoTypes: () => schemas_exports3,
+  CentrifugoTypes: () => schemas_exports2,
   Enums: () => enums_exports,
   OAuthAuthorizeRequestRequestSchema: () => OAuthAuthorizeRequestRequestSchema,
   OAuthAuthorizeResponseSchema: () => OAuthAuthorizeResponseSchema,
@@ -55,10 +55,10 @@ __export(clients_exports, {
   TokenRefreshSchema: () => TokenRefreshSchema,
   UserProfileUpdateRequestSchema: () => UserProfileUpdateRequestSchema,
   UserSchema: () => UserSchema,
-  WebPushAPI: () => API2,
-  WebPushFetchers: () => fetchers_exports2,
+  WebPushAPI: () => API3,
+  WebPushFetchers: () => fetchers_exports3,
   WebPushHooks: () => hooks_exports,
-  WebPushTypes: () => schemas_exports2,
+  WebPushTypes: () => schemas_exports3,
   apiAccounts: () => apiAccounts,
   apiCentrifugo: () => apiCentrifugo,
   apiWebPush: () => apiWebPush,
@@ -1736,45 +1736,217 @@ var API = class {
   }
 };
 
-// src/generated/cfg_webpush/webpush__web_push/client.ts
-var WebPush = class {
+// src/generated/cfg_centrifugo/centrifugo__centrifugo_admin_api/client.ts
+var CentrifugoAdminApi = class {
   static {
-    __name(this, "WebPush");
+    __name(this, "CentrifugoAdminApi");
   }
   constructor(client) {
     this.client = client;
   }
   /**
-   * Send push notification
+   * Get connection token for dashboard
    * 
-   * Send push notification to all active subscriptions for the authenticated
-   * user.
+   * Returns JWT token and config for WebSocket connection to Centrifugo.
    */
-  async webpushSendCreate(data) {
-    const response = await this.client.request("POST", "/cfg/webpush/send/", { body: data });
+  async centrifugoServerAuthTokenCreate() {
+    const response = await this.client.request("POST", "/cfg/centrifugo/server/auth/token/");
     return response;
   }
   /**
-   * Subscribe to push notifications
+   * List active channels
    * 
-   * Save push subscription from browser for the authenticated user.
+   * Returns list of active channels with optional pattern filter.
    */
-  async webpushSubscribeCreate(data) {
-    const response = await this.client.request("POST", "/cfg/webpush/subscribe/", { body: data });
+  async centrifugoServerChannelsCreate(data) {
+    const response = await this.client.request("POST", "/cfg/centrifugo/server/channels/", { body: data });
     return response;
   }
   /**
-   * Get VAPID public key
+   * Get channel history
    * 
-   * Get VAPID public key for client subscription.
+   * Returns message history for a channel.
    */
-  async webpushVapidRetrieve() {
-    const response = await this.client.request("GET", "/cfg/webpush/vapid/");
+  async centrifugoServerHistoryCreate(data) {
+    const response = await this.client.request("POST", "/cfg/centrifugo/server/history/", { body: data });
+    return response;
+  }
+  /**
+   * Get Centrifugo server info
+   * 
+   * Returns server information including node count, version, and uptime.
+   */
+  async centrifugoServerInfoCreate() {
+    const response = await this.client.request("POST", "/cfg/centrifugo/server/info/");
+    return response;
+  }
+  /**
+   * Get channel presence
+   * 
+   * Returns list of clients currently subscribed to a channel.
+   */
+  async centrifugoServerPresenceCreate(data) {
+    const response = await this.client.request("POST", "/cfg/centrifugo/server/presence/", { body: data });
+    return response;
+  }
+  /**
+   * Get channel presence statistics
+   * 
+   * Returns quick statistics about channel presence (num_clients,
+   * num_users).
+   */
+  async centrifugoServerPresenceStatsCreate(data) {
+    const response = await this.client.request("POST", "/cfg/centrifugo/server/presence-stats/", { body: data });
     return response;
   }
 };
 
-// src/generated/cfg_webpush/http.ts
+// src/generated/cfg_centrifugo/centrifugo__centrifugo_auth/client.ts
+var CentrifugoAuth = class {
+  static {
+    __name(this, "CentrifugoAuth");
+  }
+  constructor(client) {
+    this.client = client;
+  }
+  /**
+   * Get Centrifugo connection token
+   * 
+   * Generate JWT token for WebSocket connection to Centrifugo. Token
+   * includes user's allowed channels based on their permissions. Requires
+   * authentication.
+   */
+  async tokenRetrieve() {
+    const response = await this.client.request("GET", "/cfg/centrifugo/auth/token/");
+    return response;
+  }
+};
+
+// src/generated/cfg_centrifugo/centrifugo__centrifugo_monitoring/client.ts
+var CentrifugoMonitoring = class {
+  static {
+    __name(this, "CentrifugoMonitoring");
+  }
+  constructor(client) {
+    this.client = client;
+  }
+  /**
+   * Get channel statistics
+   * 
+   * Returns statistics grouped by channel.
+   */
+  async centrifugoMonitorChannelsRetrieve(...args) {
+    const isParamsObject = args.length === 1 && typeof args[0] === "object" && args[0] !== null && !Array.isArray(args[0]);
+    let params;
+    if (isParamsObject) {
+      params = args[0];
+    } else {
+      params = { hours: args[0] };
+    }
+    const response = await this.client.request("GET", "/cfg/centrifugo/monitor/channels/", { params });
+    return response.results || response;
+  }
+  /**
+   * Get Centrifugo health status
+   * 
+   * Returns the current health status of the Centrifugo client.
+   */
+  async centrifugoMonitorHealthRetrieve() {
+    const response = await this.client.request("GET", "/cfg/centrifugo/monitor/health/");
+    return response;
+  }
+  /**
+   * Get overview statistics
+   * 
+   * Returns overview statistics for Centrifugo publishes.
+   */
+  async centrifugoMonitorOverviewRetrieve(...args) {
+    const isParamsObject = args.length === 1 && typeof args[0] === "object" && args[0] !== null && !Array.isArray(args[0]);
+    let params;
+    if (isParamsObject) {
+      params = args[0];
+    } else {
+      params = { hours: args[0] };
+    }
+    const response = await this.client.request("GET", "/cfg/centrifugo/monitor/overview/", { params });
+    return response;
+  }
+  /**
+   * Get recent publishes
+   * 
+   * Returns a paginated list of recent Centrifugo publishes with their
+   * details. Uses standard DRF pagination.
+   */
+  async centrifugoMonitorPublishesList(...args) {
+    const isParamsObject = args.length === 1 && typeof args[0] === "object" && args[0] !== null && !Array.isArray(args[0]);
+    let params;
+    if (isParamsObject) {
+      params = args[0];
+    } else {
+      params = { channel: args[0], page: args[1], page_size: args[2], status: args[3] };
+    }
+    const response = await this.client.request("GET", "/cfg/centrifugo/monitor/publishes/", { params });
+    return response;
+  }
+  /**
+   * Get publish timeline
+   * 
+   * Returns hourly or daily breakdown of publish counts for charts.
+   */
+  async centrifugoMonitorTimelineRetrieve(...args) {
+    const isParamsObject = args.length === 1 && typeof args[0] === "object" && args[0] !== null && !Array.isArray(args[0]);
+    let params;
+    if (isParamsObject) {
+      params = args[0];
+    } else {
+      params = { hours: args[0], interval: args[1] };
+    }
+    const response = await this.client.request("GET", "/cfg/centrifugo/monitor/timeline/", { params });
+    return response;
+  }
+};
+
+// src/generated/cfg_centrifugo/centrifugo__centrifugo_testing/client.ts
+var CentrifugoTesting = class {
+  static {
+    __name(this, "CentrifugoTesting");
+  }
+  constructor(client) {
+    this.client = client;
+  }
+  /**
+   * Publish test message
+   * 
+   * Publish test message to Centrifugo via wrapper with optional ACK
+   * tracking.
+   */
+  async publishTestCreate(data) {
+    const response = await this.client.request("POST", "/cfg/centrifugo/testing/publish-test/", { body: data });
+    return response;
+  }
+  /**
+   * Publish with database logging
+   * 
+   * Publish message using CentrifugoClient with database logging. This will
+   * create CentrifugoLog records.
+   */
+  async publishWithLoggingCreate(data) {
+    const response = await this.client.request("POST", "/cfg/centrifugo/testing/publish-with-logging/", { body: data });
+    return response;
+  }
+  /**
+   * Send manual ACK
+   * 
+   * Manually send ACK for a message to the wrapper. Pass message_id in
+   * request body.
+   */
+  async sendAckCreate(data) {
+    const response = await this.client.request("POST", "/cfg/centrifugo/testing/send-ack/", { body: data });
+    return response;
+  }
+};
+
+// src/generated/cfg_centrifugo/http.ts
 var FetchAdapter2 = class {
   static {
     __name(this, "FetchAdapter");
@@ -1829,7 +2001,7 @@ var FetchAdapter2 = class {
   }
 };
 
-// src/generated/cfg_webpush/errors.ts
+// src/generated/cfg_centrifugo/errors.ts
 var APIError2 = class extends Error {
   constructor(statusCode, statusText, response, url, message) {
     super(message || `HTTP ${statusCode}: ${statusText}`);
@@ -1918,7 +2090,7 @@ var NetworkError2 = class extends Error {
   }
 };
 
-// src/generated/cfg_webpush/logger.ts
+// src/generated/cfg_centrifugo/logger.ts
 var import_consola6 = require("consola");
 var DEFAULT_CONFIG2 = {
   enabled: process.env.NODE_ENV !== "production",
@@ -2072,7 +2244,7 @@ var APILogger2 = class {
 };
 var defaultLogger2 = new APILogger2();
 
-// src/generated/cfg_webpush/retry.ts
+// src/generated/cfg_centrifugo/retry.ts
 var import_p_retry2 = __toESM(require("p-retry"), 1);
 var DEFAULT_RETRY_CONFIG2 = {
   retries: 3,
@@ -2132,7 +2304,7 @@ async function withRetry2(fn, config) {
 }
 __name(withRetry2, "withRetry");
 
-// src/generated/cfg_webpush/client.ts
+// src/generated/cfg_centrifugo/client.ts
 var APIClient2 = class {
   constructor(baseUrl, options) {
     this.logger = null;
@@ -2145,7 +2317,10 @@ var APIClient2 = class {
     if (options?.retryConfig !== void 0) {
       this.retryConfig = options.retryConfig;
     }
-    this.web_push = new WebPush(this);
+    this.centrifugo_admin_api = new CentrifugoAdminApi(this);
+    this.centrifugo_auth = new CentrifugoAuth(this);
+    this.centrifugo_monitoring = new CentrifugoMonitoring(this);
+    this.centrifugo_testing = new CentrifugoTesting(this);
   }
   static {
     __name(this, "APIClient");
@@ -2327,7 +2502,7 @@ var APIClient2 = class {
   }
 };
 
-// src/generated/cfg_webpush/storage.ts
+// src/generated/cfg_centrifugo/storage.ts
 var LocalStorageAdapter2 = class {
   static {
     __name(this, "LocalStorageAdapter");
@@ -2374,65 +2549,387 @@ var LocalStorageAdapter2 = class {
   }
 };
 
-// src/generated/cfg_webpush/_utils/schemas/index.ts
+// src/generated/cfg_centrifugo/_utils/schemas/index.ts
 var schemas_exports2 = {};
 __export(schemas_exports2, {
-  SendPushRequestRequestSchema: () => SendPushRequestRequestSchema,
-  SendPushResponseSchema: () => SendPushResponseSchema,
-  SubscribeRequestRequestSchema: () => SubscribeRequestRequestSchema,
-  SubscribeResponseSchema: () => SubscribeResponseSchema,
-  VapidPublicKeyResponseSchema: () => VapidPublicKeyResponseSchema
-});
-
-// src/generated/cfg_webpush/_utils/schemas/SendPushRequestRequest.schema.ts
-var import_zod20 = require("zod");
-var SendPushRequestRequestSchema = import_zod20.z.object({
-  title: import_zod20.z.string().min(1).max(255),
-  body: import_zod20.z.string().min(1),
-  icon: import_zod20.z.url().nullable().optional(),
-  url: import_zod20.z.url().nullable().optional()
-});
-
-// src/generated/cfg_webpush/_utils/schemas/SendPushResponse.schema.ts
-var import_zod21 = require("zod");
-var SendPushResponseSchema = import_zod21.z.object({
-  success: import_zod21.z.boolean(),
-  sent_to: import_zod21.z.int()
-});
-
-// src/generated/cfg_webpush/_utils/schemas/SubscribeRequestRequest.schema.ts
-var import_zod22 = require("zod");
-var SubscribeRequestRequestSchema = import_zod22.z.object({
-  endpoint: import_zod22.z.url(),
-  keys: import_zod22.z.record(import_zod22.z.string(), import_zod22.z.string().min(1))
-});
-
-// src/generated/cfg_webpush/_utils/schemas/SubscribeResponse.schema.ts
-var import_zod23 = require("zod");
-var SubscribeResponseSchema = import_zod23.z.object({
-  success: import_zod23.z.boolean(),
-  subscription_id: import_zod23.z.int(),
-  created: import_zod23.z.boolean()
-});
-
-// src/generated/cfg_webpush/_utils/schemas/VapidPublicKeyResponse.schema.ts
-var import_zod24 = require("zod");
-var VapidPublicKeyResponseSchema = import_zod24.z.object({
-  publicKey: import_zod24.z.string()
-});
-
-// src/generated/cfg_webpush/_utils/fetchers/index.ts
-var fetchers_exports2 = {};
-__export(fetchers_exports2, {
-  createWebpushSendCreate: () => createWebpushSendCreate,
-  createWebpushSubscribeCreate: () => createWebpushSubscribeCreate,
-  getWebpushVapidRetrieve: () => getWebpushVapidRetrieve
+  CentrifugoChannelInfoSchema: () => CentrifugoChannelInfoSchema,
+  CentrifugoChannelsRequestRequestSchema: () => CentrifugoChannelsRequestRequestSchema,
+  CentrifugoChannelsResponseSchema: () => CentrifugoChannelsResponseSchema,
+  CentrifugoChannelsResultSchema: () => CentrifugoChannelsResultSchema,
+  CentrifugoClientInfoSchema: () => CentrifugoClientInfoSchema,
+  CentrifugoErrorSchema: () => CentrifugoErrorSchema,
+  CentrifugoHealthCheckSchema: () => CentrifugoHealthCheckSchema,
+  CentrifugoHistoryRequestRequestSchema: () => CentrifugoHistoryRequestRequestSchema,
+  CentrifugoHistoryResponseSchema: () => CentrifugoHistoryResponseSchema,
+  CentrifugoHistoryResultSchema: () => CentrifugoHistoryResultSchema,
+  CentrifugoInfoResponseSchema: () => CentrifugoInfoResponseSchema,
+  CentrifugoInfoResultSchema: () => CentrifugoInfoResultSchema,
+  CentrifugoMetricsSchema: () => CentrifugoMetricsSchema,
+  CentrifugoNodeInfoSchema: () => CentrifugoNodeInfoSchema,
+  CentrifugoOverviewStatsSchema: () => CentrifugoOverviewStatsSchema,
+  CentrifugoPresenceRequestRequestSchema: () => CentrifugoPresenceRequestRequestSchema,
+  CentrifugoPresenceResponseSchema: () => CentrifugoPresenceResponseSchema,
+  CentrifugoPresenceResultSchema: () => CentrifugoPresenceResultSchema,
+  CentrifugoPresenceStatsRequestRequestSchema: () => CentrifugoPresenceStatsRequestRequestSchema,
+  CentrifugoPresenceStatsResponseSchema: () => CentrifugoPresenceStatsResponseSchema,
+  CentrifugoPresenceStatsResultSchema: () => CentrifugoPresenceStatsResultSchema,
+  CentrifugoProcessSchema: () => CentrifugoProcessSchema,
+  CentrifugoPublicationSchema: () => CentrifugoPublicationSchema,
+  CentrifugoStreamPositionSchema: () => CentrifugoStreamPositionSchema,
+  ChannelListSchema: () => ChannelListSchema,
+  ChannelStatsSchema: () => ChannelStatsSchema,
+  ConnectionTokenResponseSchema: () => ConnectionTokenResponseSchema,
+  ManualAckRequestRequestSchema: () => ManualAckRequestRequestSchema,
+  ManualAckResponseSchema: () => ManualAckResponseSchema,
+  PaginatedPublishListSchema: () => PaginatedPublishListSchema,
+  PublishSchema: () => PublishSchema,
+  PublishTestRequestRequestSchema: () => PublishTestRequestRequestSchema,
+  PublishTestResponseSchema: () => PublishTestResponseSchema,
+  TimelineItemSchema: () => TimelineItemSchema,
+  TimelineResponseSchema: () => TimelineResponseSchema
 });
 
-// src/generated/cfg_webpush/_utils/fetchers/webpush__web_push.ts
+// src/generated/cfg_centrifugo/_utils/schemas/CentrifugoChannelInfo.schema.ts
+var import_zod20 = require("zod");
+var CentrifugoChannelInfoSchema = import_zod20.z.object({
+  num_clients: import_zod20.z.int()
+});
+
+// src/generated/cfg_centrifugo/_utils/schemas/CentrifugoChannelsRequestRequest.schema.ts
+var import_zod21 = require("zod");
+var CentrifugoChannelsRequestRequestSchema = import_zod21.z.object({
+  pattern: import_zod21.z.string().nullable().optional()
+});
+
+// src/generated/cfg_centrifugo/_utils/schemas/CentrifugoChannelsResponse.schema.ts
+var import_zod24 = require("zod");
+
+// src/generated/cfg_centrifugo/_utils/schemas/CentrifugoChannelsResult.schema.ts
+var import_zod22 = require("zod");
+var CentrifugoChannelsResultSchema = import_zod22.z.object({
+  channels: import_zod22.z.record(import_zod22.z.string(), CentrifugoChannelInfoSchema)
+});
+
+// src/generated/cfg_centrifugo/_utils/schemas/CentrifugoError.schema.ts
+var import_zod23 = require("zod");
+var CentrifugoErrorSchema = import_zod23.z.object({
+  code: import_zod23.z.int().optional(),
+  message: import_zod23.z.string().optional()
+});
+
+// src/generated/cfg_centrifugo/_utils/schemas/CentrifugoChannelsResponse.schema.ts
+var CentrifugoChannelsResponseSchema = import_zod24.z.object({
+  error: CentrifugoErrorSchema.optional(),
+  result: CentrifugoChannelsResultSchema.optional()
+});
+
+// src/generated/cfg_centrifugo/_utils/schemas/CentrifugoClientInfo.schema.ts
+var import_zod25 = require("zod");
+var CentrifugoClientInfoSchema = import_zod25.z.object({
+  user: import_zod25.z.string(),
+  client: import_zod25.z.string(),
+  conn_info: import_zod25.z.record(import_zod25.z.string(), import_zod25.z.any()).nullable().optional(),
+  chan_info: import_zod25.z.record(import_zod25.z.string(), import_zod25.z.any()).nullable().optional()
+});
+
+// src/generated/cfg_centrifugo/_utils/schemas/CentrifugoHealthCheck.schema.ts
+var import_zod26 = require("zod");
+var CentrifugoHealthCheckSchema = import_zod26.z.object({
+  status: import_zod26.z.string(),
+  wrapper_url: import_zod26.z.string(),
+  has_api_key: import_zod26.z.boolean(),
+  timestamp: import_zod26.z.string()
+});
+
+// src/generated/cfg_centrifugo/_utils/schemas/CentrifugoHistoryRequestRequest.schema.ts
+var import_zod28 = require("zod");
+
+// src/generated/cfg_centrifugo/_utils/schemas/CentrifugoStreamPosition.schema.ts
+var import_zod27 = require("zod");
+var CentrifugoStreamPositionSchema = import_zod27.z.object({
+  offset: import_zod27.z.int(),
+  epoch: import_zod27.z.string()
+});
+
+// src/generated/cfg_centrifugo/_utils/schemas/CentrifugoHistoryRequestRequest.schema.ts
+var CentrifugoHistoryRequestRequestSchema = import_zod28.z.object({
+  channel: import_zod28.z.string(),
+  limit: import_zod28.z.int().nullable().optional(),
+  since: CentrifugoStreamPositionSchema.optional(),
+  reverse: import_zod28.z.boolean().nullable().optional()
+});
+
+// src/generated/cfg_centrifugo/_utils/schemas/CentrifugoHistoryResponse.schema.ts
+var import_zod31 = require("zod");
+
+// src/generated/cfg_centrifugo/_utils/schemas/CentrifugoHistoryResult.schema.ts
+var import_zod30 = require("zod");
+
+// src/generated/cfg_centrifugo/_utils/schemas/CentrifugoPublication.schema.ts
+var import_zod29 = require("zod");
+var CentrifugoPublicationSchema = import_zod29.z.object({
+  data: import_zod29.z.record(import_zod29.z.string(), import_zod29.z.any()),
+  info: CentrifugoClientInfoSchema.optional(),
+  offset: import_zod29.z.int(),
+  tags: import_zod29.z.record(import_zod29.z.string(), import_zod29.z.any()).nullable().optional()
+});
+
+// src/generated/cfg_centrifugo/_utils/schemas/CentrifugoHistoryResult.schema.ts
+var CentrifugoHistoryResultSchema = import_zod30.z.object({
+  publications: import_zod30.z.array(CentrifugoPublicationSchema),
+  epoch: import_zod30.z.string(),
+  offset: import_zod30.z.int()
+});
+
+// src/generated/cfg_centrifugo/_utils/schemas/CentrifugoHistoryResponse.schema.ts
+var CentrifugoHistoryResponseSchema = import_zod31.z.object({
+  error: CentrifugoErrorSchema.optional(),
+  result: CentrifugoHistoryResultSchema.optional()
+});
+
+// src/generated/cfg_centrifugo/_utils/schemas/CentrifugoInfoResponse.schema.ts
+var import_zod36 = require("zod");
+
+// src/generated/cfg_centrifugo/_utils/schemas/CentrifugoInfoResult.schema.ts
+var import_zod35 = require("zod");
+
+// src/generated/cfg_centrifugo/_utils/schemas/CentrifugoNodeInfo.schema.ts
+var import_zod34 = require("zod");
+
+// src/generated/cfg_centrifugo/_utils/schemas/CentrifugoMetrics.schema.ts
+var import_zod32 = require("zod");
+var CentrifugoMetricsSchema = import_zod32.z.object({
+  interval: import_zod32.z.number(),
+  items: import_zod32.z.record(import_zod32.z.string(), import_zod32.z.number())
+});
+
+// src/generated/cfg_centrifugo/_utils/schemas/CentrifugoProcess.schema.ts
+var import_zod33 = require("zod");
+var CentrifugoProcessSchema = import_zod33.z.object({
+  cpu: import_zod33.z.number(),
+  rss: import_zod33.z.int()
+});
+
+// src/generated/cfg_centrifugo/_utils/schemas/CentrifugoNodeInfo.schema.ts
+var CentrifugoNodeInfoSchema = import_zod34.z.object({
+  uid: import_zod34.z.string(),
+  name: import_zod34.z.string(),
+  version: import_zod34.z.string(),
+  num_clients: import_zod34.z.int(),
+  num_users: import_zod34.z.int(),
+  num_channels: import_zod34.z.int(),
+  uptime: import_zod34.z.int(),
+  num_subs: import_zod34.z.int(),
+  metrics: CentrifugoMetricsSchema.optional(),
+  process: CentrifugoProcessSchema.optional()
+});
+
+// src/generated/cfg_centrifugo/_utils/schemas/CentrifugoInfoResult.schema.ts
+var CentrifugoInfoResultSchema = import_zod35.z.object({
+  nodes: import_zod35.z.array(CentrifugoNodeInfoSchema)
+});
+
+// src/generated/cfg_centrifugo/_utils/schemas/CentrifugoInfoResponse.schema.ts
+var CentrifugoInfoResponseSchema = import_zod36.z.object({
+  error: CentrifugoErrorSchema.optional(),
+  result: CentrifugoInfoResultSchema.optional()
+});
+
+// src/generated/cfg_centrifugo/_utils/schemas/CentrifugoOverviewStats.schema.ts
+var import_zod37 = require("zod");
+var CentrifugoOverviewStatsSchema = import_zod37.z.object({
+  total: import_zod37.z.int(),
+  successful: import_zod37.z.int(),
+  failed: import_zod37.z.int(),
+  timeout: import_zod37.z.int(),
+  success_rate: import_zod37.z.number(),
+  avg_duration_ms: import_zod37.z.number(),
+  avg_acks_received: import_zod37.z.number(),
+  period_hours: import_zod37.z.int()
+});
+
+// src/generated/cfg_centrifugo/_utils/schemas/CentrifugoPresenceRequestRequest.schema.ts
+var import_zod38 = require("zod");
+var CentrifugoPresenceRequestRequestSchema = import_zod38.z.object({
+  channel: import_zod38.z.string()
+});
+
+// src/generated/cfg_centrifugo/_utils/schemas/CentrifugoPresenceResponse.schema.ts
+var import_zod40 = require("zod");
+
+// src/generated/cfg_centrifugo/_utils/schemas/CentrifugoPresenceResult.schema.ts
+var import_zod39 = require("zod");
+var CentrifugoPresenceResultSchema = import_zod39.z.object({
+  presence: import_zod39.z.record(import_zod39.z.string(), CentrifugoClientInfoSchema)
+});
+
+// src/generated/cfg_centrifugo/_utils/schemas/CentrifugoPresenceResponse.schema.ts
+var CentrifugoPresenceResponseSchema = import_zod40.z.object({
+  error: CentrifugoErrorSchema.optional(),
+  result: CentrifugoPresenceResultSchema.optional()
+});
+
+// src/generated/cfg_centrifugo/_utils/schemas/CentrifugoPresenceStatsRequestRequest.schema.ts
+var import_zod41 = require("zod");
+var CentrifugoPresenceStatsRequestRequestSchema = import_zod41.z.object({
+  channel: import_zod41.z.string()
+});
+
+// src/generated/cfg_centrifugo/_utils/schemas/CentrifugoPresenceStatsResponse.schema.ts
+var import_zod43 = require("zod");
+
+// src/generated/cfg_centrifugo/_utils/schemas/CentrifugoPresenceStatsResult.schema.ts
+var import_zod42 = require("zod");
+var CentrifugoPresenceStatsResultSchema = import_zod42.z.object({
+  num_clients: import_zod42.z.int(),
+  num_users: import_zod42.z.int()
+});
+
+// src/generated/cfg_centrifugo/_utils/schemas/CentrifugoPresenceStatsResponse.schema.ts
+var CentrifugoPresenceStatsResponseSchema = import_zod43.z.object({
+  error: CentrifugoErrorSchema.optional(),
+  result: CentrifugoPresenceStatsResultSchema.optional()
+});
+
+// src/generated/cfg_centrifugo/_utils/schemas/ChannelList.schema.ts
+var import_zod45 = require("zod");
+
+// src/generated/cfg_centrifugo/_utils/schemas/ChannelStats.schema.ts
+var import_zod44 = require("zod");
+var ChannelStatsSchema = import_zod44.z.object({
+  channel: import_zod44.z.string(),
+  total: import_zod44.z.int(),
+  successful: import_zod44.z.int(),
+  failed: import_zod44.z.int(),
+  avg_duration_ms: import_zod44.z.number(),
+  avg_acks: import_zod44.z.number(),
+  last_activity_at: import_zod44.z.string().nullable()
+});
+
+// src/generated/cfg_centrifugo/_utils/schemas/ChannelList.schema.ts
+var ChannelListSchema = import_zod45.z.object({
+  channels: import_zod45.z.array(ChannelStatsSchema),
+  total_channels: import_zod45.z.int()
+});
+
+// src/generated/cfg_centrifugo/_utils/schemas/ConnectionTokenResponse.schema.ts
+var import_zod46 = require("zod");
+var ConnectionTokenResponseSchema = import_zod46.z.object({
+  token: import_zod46.z.string(),
+  centrifugo_url: import_zod46.z.string(),
+  expires_at: import_zod46.z.string(),
+  channels: import_zod46.z.array(import_zod46.z.string())
+});
+
+// src/generated/cfg_centrifugo/_utils/schemas/ManualAckRequestRequest.schema.ts
+var import_zod47 = require("zod");
+var ManualAckRequestRequestSchema = import_zod47.z.object({
+  message_id: import_zod47.z.string(),
+  client_id: import_zod47.z.string()
+});
+
+// src/generated/cfg_centrifugo/_utils/schemas/ManualAckResponse.schema.ts
+var import_zod48 = require("zod");
+var ManualAckResponseSchema = import_zod48.z.object({
+  success: import_zod48.z.boolean(),
+  message_id: import_zod48.z.string(),
+  error: import_zod48.z.string().nullable().optional()
+});
+
+// src/generated/cfg_centrifugo/_utils/schemas/PaginatedPublishList.schema.ts
+var import_zod50 = require("zod");
+
+// src/generated/cfg_centrifugo/_utils/schemas/Publish.schema.ts
+var import_zod49 = require("zod");
+var PublishSchema = import_zod49.z.object({
+  message_id: import_zod49.z.string(),
+  channel: import_zod49.z.string(),
+  status: import_zod49.z.string(),
+  wait_for_ack: import_zod49.z.boolean(),
+  acks_received: import_zod49.z.int(),
+  acks_expected: import_zod49.z.int().nullable(),
+  duration_ms: import_zod49.z.number().nullable(),
+  created_at: import_zod49.z.iso.datetime(),
+  completed_at: import_zod49.z.iso.datetime().nullable(),
+  error_code: import_zod49.z.string().nullable(),
+  error_message: import_zod49.z.string().nullable()
+});
+
+// src/generated/cfg_centrifugo/_utils/schemas/PaginatedPublishList.schema.ts
+var PaginatedPublishListSchema = import_zod50.z.object({
+  count: import_zod50.z.int(),
+  page: import_zod50.z.int(),
+  pages: import_zod50.z.int(),
+  page_size: import_zod50.z.int(),
+  has_next: import_zod50.z.boolean(),
+  has_previous: import_zod50.z.boolean(),
+  next_page: import_zod50.z.int().nullable().optional(),
+  previous_page: import_zod50.z.int().nullable().optional(),
+  results: import_zod50.z.array(PublishSchema)
+});
+
+// src/generated/cfg_centrifugo/_utils/schemas/PublishTestRequestRequest.schema.ts
+var import_zod51 = require("zod");
+var PublishTestRequestRequestSchema = import_zod51.z.object({
+  channel: import_zod51.z.string(),
+  data: import_zod51.z.record(import_zod51.z.string(), import_zod51.z.any()),
+  wait_for_ack: import_zod51.z.boolean().optional(),
+  ack_timeout: import_zod51.z.int().min(1).max(60).optional()
+});
+
+// src/generated/cfg_centrifugo/_utils/schemas/PublishTestResponse.schema.ts
+var import_zod52 = require("zod");
+var PublishTestResponseSchema = import_zod52.z.object({
+  success: import_zod52.z.boolean(),
+  message_id: import_zod52.z.string(),
+  channel: import_zod52.z.string(),
+  acks_received: import_zod52.z.int().optional(),
+  delivered: import_zod52.z.boolean().optional(),
+  error: import_zod52.z.string().nullable().optional()
+});
+
+// src/generated/cfg_centrifugo/_utils/schemas/TimelineItem.schema.ts
+var import_zod53 = require("zod");
+var TimelineItemSchema = import_zod53.z.object({
+  timestamp: import_zod53.z.string(),
+  count: import_zod53.z.int(),
+  successful: import_zod53.z.int(),
+  failed: import_zod53.z.int(),
+  timeout: import_zod53.z.int()
+});
+
+// src/generated/cfg_centrifugo/_utils/schemas/TimelineResponse.schema.ts
+var import_zod54 = require("zod");
+var TimelineResponseSchema = import_zod54.z.object({
+  timeline: import_zod54.z.array(TimelineItemSchema),
+  period_hours: import_zod54.z.int(),
+  interval: import_zod54.z.string()
+});
+
+// src/generated/cfg_centrifugo/_utils/fetchers/index.ts
+var fetchers_exports2 = {};
+__export(fetchers_exports2, {
+  createCentrifugoServerAuthTokenCreate: () => createCentrifugoServerAuthTokenCreate,
+  createCentrifugoServerChannelsCreate: () => createCentrifugoServerChannelsCreate,
+  createCentrifugoServerHistoryCreate: () => createCentrifugoServerHistoryCreate,
+  createCentrifugoServerInfoCreate: () => createCentrifugoServerInfoCreate,
+  createCentrifugoServerPresenceCreate: () => createCentrifugoServerPresenceCreate,
+  createCentrifugoServerPresenceStatsCreate: () => createCentrifugoServerPresenceStatsCreate,
+  createCentrifugoTestingPublishTestCreate: () => createCentrifugoTestingPublishTestCreate,
+  createCentrifugoTestingPublishWithLoggingCreate: () => createCentrifugoTestingPublishWithLoggingCreate,
+  createCentrifugoTestingSendAckCreate: () => createCentrifugoTestingSendAckCreate,
+  getCentrifugoAuthTokenRetrieve: () => getCentrifugoAuthTokenRetrieve,
+  getCentrifugoMonitorChannelsRetrieve: () => getCentrifugoMonitorChannelsRetrieve,
+  getCentrifugoMonitorHealthRetrieve: () => getCentrifugoMonitorHealthRetrieve,
+  getCentrifugoMonitorOverviewRetrieve: () => getCentrifugoMonitorOverviewRetrieve,
+  getCentrifugoMonitorPublishesList: () => getCentrifugoMonitorPublishesList,
+  getCentrifugoMonitorTimelineRetrieve: () => getCentrifugoMonitorTimelineRetrieve
+});
+
+// src/generated/cfg_centrifugo/_utils/fetchers/centrifugo__centrifugo_admin_api.ts
 var import_consola7 = require("consola");
 
-// src/generated/cfg_webpush/api-instance.ts
+// src/generated/cfg_centrifugo/api-instance.ts
 var globalAPI2 = null;
 function getAPIInstance2() {
   if (!globalAPI2) {
@@ -2444,16 +2941,22 @@ function getAPIInstance2() {
 }
 __name(getAPIInstance2, "getAPIInstance");
 
-// src/generated/cfg_webpush/_utils/fetchers/webpush__web_push.ts
-async function createWebpushSendCreate(data, client) {
+// src/generated/cfg_centrifugo/_utils/fetchers/centrifugo__centrifugo_admin_api.ts
+async function createCentrifugoServerAuthTokenCreate(client) {
   const api = client || getAPIInstance2();
-  const response = await api.web_push.webpushSendCreate(data);
+  const response = await api.centrifugo_admin_api.centrifugoServerAuthTokenCreate();
+  return response;
+}
+__name(createCentrifugoServerAuthTokenCreate, "createCentrifugoServerAuthTokenCreate");
+async function createCentrifugoServerChannelsCreate(data, client) {
+  const api = client || getAPIInstance2();
+  const response = await api.centrifugo_admin_api.centrifugoServerChannelsCreate(data);
   try {
-    return SendPushResponseSchema.parse(response);
+    return CentrifugoChannelsResponseSchema.parse(response);
   } catch (error) {
     import_consola7.consola.error("\u274C Zod Validation Failed");
-    import_consola7.consola.box(`createWebpushSendCreate
-Path: /cfg/webpush/send/
+    import_consola7.consola.box(`createCentrifugoServerChannelsCreate
+Path: /cfg/centrifugo/server/channels/
 Method: POST`);
     if (error instanceof Error && "issues" in error && Array.isArray(error.issues)) {
       import_consola7.consola.error("Validation Issues:");
@@ -2469,9 +2972,9 @@ Method: POST`);
       try {
         const event = new CustomEvent("zod-validation-error", {
           detail: {
-            operation: "createWebpushSendCreate",
-            path: "/cfg/webpush/send/",
-            method: "POST",
+            operation: "createCentrifugoServerChannelsCreate",
+            path: "/cfg/centrifugo/server/channels/",
+            method: "POST",
             error,
             response,
             timestamp: /* @__PURE__ */ new Date()
@@ -2487,16 +2990,16 @@ Method: POST`);
     throw error;
   }
 }
-__name(createWebpushSendCreate, "createWebpushSendCreate");
-async function createWebpushSubscribeCreate(data, client) {
+__name(createCentrifugoServerChannelsCreate, "createCentrifugoServerChannelsCreate");
+async function createCentrifugoServerHistoryCreate(data, client) {
   const api = client || getAPIInstance2();
-  const response = await api.web_push.webpushSubscribeCreate(data);
+  const response = await api.centrifugo_admin_api.centrifugoServerHistoryCreate(data);
   try {
-    return SubscribeResponseSchema.parse(response);
+    return CentrifugoHistoryResponseSchema.parse(response);
   } catch (error) {
     import_consola7.consola.error("\u274C Zod Validation Failed");
-    import_consola7.consola.box(`createWebpushSubscribeCreate
-Path: /cfg/webpush/subscribe/
+    import_consola7.consola.box(`createCentrifugoServerHistoryCreate
+Path: /cfg/centrifugo/server/history/
 Method: POST`);
     if (error instanceof Error && "issues" in error && Array.isArray(error.issues)) {
       import_consola7.consola.error("Validation Issues:");
@@ -2512,8 +3015,8 @@ Method: POST`);
       try {
         const event = new CustomEvent("zod-validation-error", {
           detail: {
-            operation: "createWebpushSubscribeCreate",
-            path: "/cfg/webpush/subscribe/",
+            operation: "createCentrifugoServerHistoryCreate",
+            path: "/cfg/centrifugo/server/history/",
             method: "POST",
             error,
             response,
@@ -2530,17 +3033,17 @@ Method: POST`);
     throw error;
   }
 }
-__name(createWebpushSubscribeCreate, "createWebpushSubscribeCreate");
-async function getWebpushVapidRetrieve(client) {
+__name(createCentrifugoServerHistoryCreate, "createCentrifugoServerHistoryCreate");
+async function createCentrifugoServerInfoCreate(client) {
   const api = client || getAPIInstance2();
-  const response = await api.web_push.webpushVapidRetrieve();
+  const response = await api.centrifugo_admin_api.centrifugoServerInfoCreate();
   try {
-    return VapidPublicKeyResponseSchema.parse(response);
+    return CentrifugoInfoResponseSchema.parse(response);
   } catch (error) {
     import_consola7.consola.error("\u274C Zod Validation Failed");
-    import_consola7.consola.box(`getWebpushVapidRetrieve
-Path: /cfg/webpush/vapid/
-Method: GET`);
+    import_consola7.consola.box(`createCentrifugoServerInfoCreate
+Path: /cfg/centrifugo/server/info/
+Method: POST`);
     if (error instanceof Error && "issues" in error && Array.isArray(error.issues)) {
       import_consola7.consola.error("Validation Issues:");
       error.issues.forEach((issue, index) => {
@@ -2555,9 +3058,9 @@ Method: GET`);
       try {
         const event = new CustomEvent("zod-validation-error", {
           detail: {
-            operation: "getWebpushVapidRetrieve",
-            path: "/cfg/webpush/vapid/",
-            method: "GET",
+            operation: "createCentrifugoServerInfoCreate",
+            path: "/cfg/centrifugo/server/info/",
+            method: "POST",
             error,
             response,
             timestamp: /* @__PURE__ */ new Date()
@@ -2573,1832 +3076,1335 @@ Method: GET`);
     throw error;
   }
 }
-__name(getWebpushVapidRetrieve, "getWebpushVapidRetrieve");
-
-// src/generated/cfg_webpush/index.ts
-var TOKEN_KEY2 = "auth_token";
-var REFRESH_TOKEN_KEY2 = "refresh_token";
-var API2 = class {
-  constructor(baseUrl, options) {
-    this._token = null;
-    this._refreshToken = null;
-    this.baseUrl = baseUrl;
-    this.options = options;
-    const logger = options?.loggerConfig ? new APILogger2(options.loggerConfig) : void 0;
-    this.storage = options?.storage || new LocalStorageAdapter2(logger);
-    this._loadTokensFromStorage();
-    this._client = new APIClient2(this.baseUrl, {
-      retryConfig: this.options?.retryConfig,
-      loggerConfig: this.options?.loggerConfig
-    });
-    this._injectAuthHeader();
-    this.web_push = this._client.web_push;
-  }
-  static {
-    __name(this, "API");
-  }
-  _loadTokensFromStorage() {
-    this._token = this.storage.getItem(TOKEN_KEY2);
-    this._refreshToken = this.storage.getItem(REFRESH_TOKEN_KEY2);
-  }
-  _reinitClients() {
-    this._client = new APIClient2(this.baseUrl, {
-      retryConfig: this.options?.retryConfig,
-      loggerConfig: this.options?.loggerConfig
-    });
-    this._injectAuthHeader();
-    this.web_push = this._client.web_push;
-  }
-  _injectAuthHeader() {
-    const originalRequest = this._client.request.bind(this._client);
-    this._client.request = async (method, path, options) => {
-      const token = this.getToken();
-      const mergedOptions = {
-        ...options,
-        headers: {
-          ...options?.headers || {},
-          ...token ? { "Authorization": `Bearer ${token}` } : {}
-        }
-      };
-      return originalRequest(method, path, mergedOptions);
-    };
-  }
-  /**
-   * Get current JWT token
-   */
-  getToken() {
-    return this.storage.getItem(TOKEN_KEY2);
-  }
-  /**
-   * Get current refresh token
-   */
-  getRefreshToken() {
-    return this.storage.getItem(REFRESH_TOKEN_KEY2);
-  }
-  /**
-   * Set JWT token and refresh token
-   * @param token - JWT access token
-   * @param refreshToken - JWT refresh token (optional)
-   */
-  setToken(token, refreshToken) {
-    this._token = token;
-    this.storage.setItem(TOKEN_KEY2, token);
-    if (refreshToken) {
-      this._refreshToken = refreshToken;
-      this.storage.setItem(REFRESH_TOKEN_KEY2, refreshToken);
+__name(createCentrifugoServerInfoCreate, "createCentrifugoServerInfoCreate");
+async function createCentrifugoServerPresenceCreate(data, client) {
+  const api = client || getAPIInstance2();
+  const response = await api.centrifugo_admin_api.centrifugoServerPresenceCreate(data);
+  try {
+    return CentrifugoPresenceResponseSchema.parse(response);
+  } catch (error) {
+    import_consola7.consola.error("\u274C Zod Validation Failed");
+    import_consola7.consola.box(`createCentrifugoServerPresenceCreate
+Path: /cfg/centrifugo/server/presence/
+Method: POST`);
+    if (error instanceof Error && "issues" in error && Array.isArray(error.issues)) {
+      import_consola7.consola.error("Validation Issues:");
+      error.issues.forEach((issue, index) => {
+        import_consola7.consola.error(`  ${index + 1}. ${issue.path.join(".") || "root"}`);
+        import_consola7.consola.error(`     \u251C\u2500 Message: ${issue.message}`);
+        if (issue.expected) import_consola7.consola.error(`     \u251C\u2500 Expected: ${issue.expected}`);
+        if (issue.received) import_consola7.consola.error(`     \u2514\u2500 Received: ${issue.received}`);
+      });
     }
-    this._reinitClients();
-  }
-  /**
-   * Clear all tokens
-   */
-  clearTokens() {
-    this._token = null;
-    this._refreshToken = null;
-    this.storage.removeItem(TOKEN_KEY2);
-    this.storage.removeItem(REFRESH_TOKEN_KEY2);
-    this._reinitClients();
-  }
-  /**
-   * Check if user is authenticated
-   */
-  isAuthenticated() {
-    return !!this.getToken();
-  }
-  /**
-   * Update base URL and reinitialize clients
-   * @param url - New base URL
-   */
-  setBaseUrl(url) {
-    this.baseUrl = url;
-    this._reinitClients();
-  }
-  /**
-   * Get current base URL
-   */
-  getBaseUrl() {
-    return this.baseUrl;
+    import_consola7.consola.error("Response data:", response);
+    if (typeof window !== "undefined" && error instanceof Error && "issues" in error) {
+      try {
+        const event = new CustomEvent("zod-validation-error", {
+          detail: {
+            operation: "createCentrifugoServerPresenceCreate",
+            path: "/cfg/centrifugo/server/presence/",
+            method: "POST",
+            error,
+            response,
+            timestamp: /* @__PURE__ */ new Date()
+          },
+          bubbles: true,
+          cancelable: false
+        });
+        window.dispatchEvent(event);
+      } catch (eventError) {
+        import_consola7.consola.warn("Failed to dispatch validation error event:", eventError);
+      }
+    }
+    throw error;
   }
-  /**
-   * Get OpenAPI schema path
-   * @returns Path to the OpenAPI schema JSON file
-   *
-   * Note: The OpenAPI schema is available in the schema.json file.
-   * You can load it dynamically using:
-   * ```typescript
-   * const schema = await fetch('./schema.json').then(r => r.json());
-   * // or using fs in Node.js:
-   * // const schema = JSON.parse(fs.readFileSync('./schema.json', 'utf-8'));
-   * ```
-   */
-  getSchemaPath() {
-    return "./schema.json";
+}
+__name(createCentrifugoServerPresenceCreate, "createCentrifugoServerPresenceCreate");
+async function createCentrifugoServerPresenceStatsCreate(data, client) {
+  const api = client || getAPIInstance2();
+  const response = await api.centrifugo_admin_api.centrifugoServerPresenceStatsCreate(data);
+  try {
+    return CentrifugoPresenceStatsResponseSchema.parse(response);
+  } catch (error) {
+    import_consola7.consola.error("\u274C Zod Validation Failed");
+    import_consola7.consola.box(`createCentrifugoServerPresenceStatsCreate
+Path: /cfg/centrifugo/server/presence-stats/
+Method: POST`);
+    if (error instanceof Error && "issues" in error && Array.isArray(error.issues)) {
+      import_consola7.consola.error("Validation Issues:");
+      error.issues.forEach((issue, index) => {
+        import_consola7.consola.error(`  ${index + 1}. ${issue.path.join(".") || "root"}`);
+        import_consola7.consola.error(`     \u251C\u2500 Message: ${issue.message}`);
+        if (issue.expected) import_consola7.consola.error(`     \u251C\u2500 Expected: ${issue.expected}`);
+        if (issue.received) import_consola7.consola.error(`     \u2514\u2500 Received: ${issue.received}`);
+      });
+    }
+    import_consola7.consola.error("Response data:", response);
+    if (typeof window !== "undefined" && error instanceof Error && "issues" in error) {
+      try {
+        const event = new CustomEvent("zod-validation-error", {
+          detail: {
+            operation: "createCentrifugoServerPresenceStatsCreate",
+            path: "/cfg/centrifugo/server/presence-stats/",
+            method: "POST",
+            error,
+            response,
+            timestamp: /* @__PURE__ */ new Date()
+          },
+          bubbles: true,
+          cancelable: false
+        });
+        window.dispatchEvent(event);
+      } catch (eventError) {
+        import_consola7.consola.warn("Failed to dispatch validation error event:", eventError);
+      }
+    }
+    throw error;
   }
-};
+}
+__name(createCentrifugoServerPresenceStatsCreate, "createCentrifugoServerPresenceStatsCreate");
 
-// src/generated/cfg_centrifugo/centrifugo__centrifugo_admin_api/client.ts
-var CentrifugoAdminApi = class {
-  static {
-    __name(this, "CentrifugoAdminApi");
-  }
-  constructor(client) {
-    this.client = client;
-  }
-  /**
-   * Get connection token for dashboard
-   * 
-   * Returns JWT token and config for WebSocket connection to Centrifugo.
-   */
-  async centrifugoServerAuthTokenCreate() {
-    const response = await this.client.request("POST", "/cfg/centrifugo/server/auth/token/");
-    return response;
-  }
-  /**
-   * List active channels
-   * 
-   * Returns list of active channels with optional pattern filter.
-   */
-  async centrifugoServerChannelsCreate(data) {
-    const response = await this.client.request("POST", "/cfg/centrifugo/server/channels/", { body: data });
-    return response;
-  }
-  /**
-   * Get channel history
-   * 
-   * Returns message history for a channel.
-   */
-  async centrifugoServerHistoryCreate(data) {
-    const response = await this.client.request("POST", "/cfg/centrifugo/server/history/", { body: data });
-    return response;
-  }
-  /**
-   * Get Centrifugo server info
-   * 
-   * Returns server information including node count, version, and uptime.
-   */
-  async centrifugoServerInfoCreate() {
-    const response = await this.client.request("POST", "/cfg/centrifugo/server/info/");
-    return response;
-  }
-  /**
-   * Get channel presence
-   * 
-   * Returns list of clients currently subscribed to a channel.
-   */
-  async centrifugoServerPresenceCreate(data) {
-    const response = await this.client.request("POST", "/cfg/centrifugo/server/presence/", { body: data });
-    return response;
-  }
-  /**
-   * Get channel presence statistics
-   * 
-   * Returns quick statistics about channel presence (num_clients,
-   * num_users).
-   */
-  async centrifugoServerPresenceStatsCreate(data) {
-    const response = await this.client.request("POST", "/cfg/centrifugo/server/presence-stats/", { body: data });
-    return response;
-  }
-};
-
-// src/generated/cfg_centrifugo/centrifugo__centrifugo_auth/client.ts
-var CentrifugoAuth = class {
-  static {
-    __name(this, "CentrifugoAuth");
-  }
-  constructor(client) {
-    this.client = client;
-  }
-  /**
-   * Get Centrifugo connection token
-   * 
-   * Generate JWT token for WebSocket connection to Centrifugo. Token
-   * includes user's allowed channels based on their permissions. Requires
-   * authentication.
-   */
-  async tokenRetrieve() {
-    const response = await this.client.request("GET", "/cfg/centrifugo/auth/token/");
-    return response;
+// src/generated/cfg_centrifugo/_utils/fetchers/centrifugo__centrifugo_auth.ts
+var import_consola8 = require("consola");
+async function getCentrifugoAuthTokenRetrieve(client) {
+  const api = client || getAPIInstance2();
+  const response = await api.centrifugo_auth.tokenRetrieve();
+  try {
+    return ConnectionTokenResponseSchema.parse(response);
+  } catch (error) {
+    import_consola8.consola.error("\u274C Zod Validation Failed");
+    import_consola8.consola.box(`getCentrifugoAuthTokenRetrieve
+Path: /cfg/centrifugo/auth/token/
+Method: GET`);
+    if (error instanceof Error && "issues" in error && Array.isArray(error.issues)) {
+      import_consola8.consola.error("Validation Issues:");
+      error.issues.forEach((issue, index) => {
+        import_consola8.consola.error(`  ${index + 1}. ${issue.path.join(".") || "root"}`);
+        import_consola8.consola.error(`     \u251C\u2500 Message: ${issue.message}`);
+        if (issue.expected) import_consola8.consola.error(`     \u251C\u2500 Expected: ${issue.expected}`);
+        if (issue.received) import_consola8.consola.error(`     \u2514\u2500 Received: ${issue.received}`);
+      });
+    }
+    import_consola8.consola.error("Response data:", response);
+    if (typeof window !== "undefined" && error instanceof Error && "issues" in error) {
+      try {
+        const event = new CustomEvent("zod-validation-error", {
+          detail: {
+            operation: "getCentrifugoAuthTokenRetrieve",
+            path: "/cfg/centrifugo/auth/token/",
+            method: "GET",
+            error,
+            response,
+            timestamp: /* @__PURE__ */ new Date()
+          },
+          bubbles: true,
+          cancelable: false
+        });
+        window.dispatchEvent(event);
+      } catch (eventError) {
+        import_consola8.consola.warn("Failed to dispatch validation error event:", eventError);
+      }
+    }
+    throw error;
   }
-};
+}
+__name(getCentrifugoAuthTokenRetrieve, "getCentrifugoAuthTokenRetrieve");
 
-// src/generated/cfg_centrifugo/centrifugo__centrifugo_monitoring/client.ts
-var CentrifugoMonitoring = class {
-  static {
-    __name(this, "CentrifugoMonitoring");
-  }
-  constructor(client) {
-    this.client = client;
-  }
-  /**
-   * Get channel statistics
-   * 
-   * Returns statistics grouped by channel.
-   */
-  async centrifugoMonitorChannelsRetrieve(...args) {
-    const isParamsObject = args.length === 1 && typeof args[0] === "object" && args[0] !== null && !Array.isArray(args[0]);
-    let params;
-    if (isParamsObject) {
-      params = args[0];
-    } else {
-      params = { hours: args[0] };
+// src/generated/cfg_centrifugo/_utils/fetchers/centrifugo__centrifugo_monitoring.ts
+var import_consola9 = require("consola");
+async function getCentrifugoMonitorChannelsRetrieve(params, client) {
+  const api = client || getAPIInstance2();
+  const response = await api.centrifugo_monitoring.centrifugoMonitorChannelsRetrieve(params?.hours);
+  try {
+    return ChannelListSchema.parse(response);
+  } catch (error) {
+    import_consola9.consola.error("\u274C Zod Validation Failed");
+    import_consola9.consola.box(`getCentrifugoMonitorChannelsRetrieve
+Path: /cfg/centrifugo/monitor/channels/
+Method: GET`);
+    if (error instanceof Error && "issues" in error && Array.isArray(error.issues)) {
+      import_consola9.consola.error("Validation Issues:");
+      error.issues.forEach((issue, index) => {
+        import_consola9.consola.error(`  ${index + 1}. ${issue.path.join(".") || "root"}`);
+        import_consola9.consola.error(`     \u251C\u2500 Message: ${issue.message}`);
+        if (issue.expected) import_consola9.consola.error(`     \u251C\u2500 Expected: ${issue.expected}`);
+        if (issue.received) import_consola9.consola.error(`     \u2514\u2500 Received: ${issue.received}`);
+      });
     }
-    const response = await this.client.request("GET", "/cfg/centrifugo/monitor/channels/", { params });
-    return response.results || response;
-  }
-  /**
-   * Get Centrifugo health status
-   * 
-   * Returns the current health status of the Centrifugo client.
-   */
-  async centrifugoMonitorHealthRetrieve() {
-    const response = await this.client.request("GET", "/cfg/centrifugo/monitor/health/");
-    return response;
-  }
-  /**
-   * Get overview statistics
-   * 
-   * Returns overview statistics for Centrifugo publishes.
-   */
-  async centrifugoMonitorOverviewRetrieve(...args) {
-    const isParamsObject = args.length === 1 && typeof args[0] === "object" && args[0] !== null && !Array.isArray(args[0]);
-    let params;
-    if (isParamsObject) {
-      params = args[0];
-    } else {
-      params = { hours: args[0] };
+    import_consola9.consola.error("Response data:", response);
+    if (typeof window !== "undefined" && error instanceof Error && "issues" in error) {
+      try {
+        const event = new CustomEvent("zod-validation-error", {
+          detail: {
+            operation: "getCentrifugoMonitorChannelsRetrieve",
+            path: "/cfg/centrifugo/monitor/channels/",
+            method: "GET",
+            error,
+            response,
+            timestamp: /* @__PURE__ */ new Date()
+          },
+          bubbles: true,
+          cancelable: false
+        });
+        window.dispatchEvent(event);
+      } catch (eventError) {
+        import_consola9.consola.warn("Failed to dispatch validation error event:", eventError);
+      }
     }
-    const response = await this.client.request("GET", "/cfg/centrifugo/monitor/overview/", { params });
-    return response;
+    throw error;
   }
-  /**
-   * Get recent publishes
-   * 
-   * Returns a paginated list of recent Centrifugo publishes with their
-   * details. Uses standard DRF pagination.
-   */
-  async centrifugoMonitorPublishesList(...args) {
-    const isParamsObject = args.length === 1 && typeof args[0] === "object" && args[0] !== null && !Array.isArray(args[0]);
-    let params;
-    if (isParamsObject) {
-      params = args[0];
-    } else {
-      params = { channel: args[0], page: args[1], page_size: args[2], status: args[3] };
+}
+__name(getCentrifugoMonitorChannelsRetrieve, "getCentrifugoMonitorChannelsRetrieve");
+async function getCentrifugoMonitorHealthRetrieve(client) {
+  const api = client || getAPIInstance2();
+  const response = await api.centrifugo_monitoring.centrifugoMonitorHealthRetrieve();
+  try {
+    return CentrifugoHealthCheckSchema.parse(response);
+  } catch (error) {
+    import_consola9.consola.error("\u274C Zod Validation Failed");
+    import_consola9.consola.box(`getCentrifugoMonitorHealthRetrieve
+Path: /cfg/centrifugo/monitor/health/
+Method: GET`);
+    if (error instanceof Error && "issues" in error && Array.isArray(error.issues)) {
+      import_consola9.consola.error("Validation Issues:");
+      error.issues.forEach((issue, index) => {
+        import_consola9.consola.error(`  ${index + 1}. ${issue.path.join(".") || "root"}`);
+        import_consola9.consola.error(`     \u251C\u2500 Message: ${issue.message}`);
+        if (issue.expected) import_consola9.consola.error(`     \u251C\u2500 Expected: ${issue.expected}`);
+        if (issue.received) import_consola9.consola.error(`     \u2514\u2500 Received: ${issue.received}`);
+      });
     }
-    const response = await this.client.request("GET", "/cfg/centrifugo/monitor/publishes/", { params });
-    return response;
-  }
-  /**
-   * Get publish timeline
-   * 
-   * Returns hourly or daily breakdown of publish counts for charts.
-   */
-  async centrifugoMonitorTimelineRetrieve(...args) {
-    const isParamsObject = args.length === 1 && typeof args[0] === "object" && args[0] !== null && !Array.isArray(args[0]);
-    let params;
-    if (isParamsObject) {
-      params = args[0];
-    } else {
-      params = { hours: args[0], interval: args[1] };
+    import_consola9.consola.error("Response data:", response);
+    if (typeof window !== "undefined" && error instanceof Error && "issues" in error) {
+      try {
+        const event = new CustomEvent("zod-validation-error", {
+          detail: {
+            operation: "getCentrifugoMonitorHealthRetrieve",
+            path: "/cfg/centrifugo/monitor/health/",
+            method: "GET",
+            error,
+            response,
+            timestamp: /* @__PURE__ */ new Date()
+          },
+          bubbles: true,
+          cancelable: false
+        });
+        window.dispatchEvent(event);
+      } catch (eventError) {
+        import_consola9.consola.warn("Failed to dispatch validation error event:", eventError);
+      }
     }
-    const response = await this.client.request("GET", "/cfg/centrifugo/monitor/timeline/", { params });
-    return response;
+    throw error;
   }
-};
-
-// src/generated/cfg_centrifugo/centrifugo__centrifugo_testing/client.ts
-var CentrifugoTesting = class {
-  static {
-    __name(this, "CentrifugoTesting");
-  }
-  constructor(client) {
-    this.client = client;
-  }
-  /**
-   * Publish test message
-   * 
-   * Publish test message to Centrifugo via wrapper with optional ACK
-   * tracking.
-   */
-  async publishTestCreate(data) {
-    const response = await this.client.request("POST", "/cfg/centrifugo/testing/publish-test/", { body: data });
-    return response;
-  }
-  /**
-   * Publish with database logging
-   * 
-   * Publish message using CentrifugoClient with database logging. This will
-   * create CentrifugoLog records.
-   */
-  async publishWithLoggingCreate(data) {
-    const response = await this.client.request("POST", "/cfg/centrifugo/testing/publish-with-logging/", { body: data });
-    return response;
-  }
-  /**
-   * Send manual ACK
-   * 
-   * Manually send ACK for a message to the wrapper. Pass message_id in
-   * request body.
-   */
-  async sendAckCreate(data) {
-    const response = await this.client.request("POST", "/cfg/centrifugo/testing/send-ack/", { body: data });
-    return response;
-  }
-};
-
-// src/generated/cfg_centrifugo/http.ts
-var FetchAdapter3 = class {
-  static {
-    __name(this, "FetchAdapter");
-  }
-  async request(request) {
-    const { method, url, headers, body, params, formData } = request;
-    let finalUrl = url;
-    if (params) {
-      const searchParams = new URLSearchParams();
-      Object.entries(params).forEach(([key, value]) => {
-        if (value !== null && value !== void 0) {
-          searchParams.append(key, String(value));
-        }
+}
+__name(getCentrifugoMonitorHealthRetrieve, "getCentrifugoMonitorHealthRetrieve");
+async function getCentrifugoMonitorOverviewRetrieve(params, client) {
+  const api = client || getAPIInstance2();
+  const response = await api.centrifugo_monitoring.centrifugoMonitorOverviewRetrieve(params?.hours);
+  try {
+    return CentrifugoOverviewStatsSchema.parse(response);
+  } catch (error) {
+    import_consola9.consola.error("\u274C Zod Validation Failed");
+    import_consola9.consola.box(`getCentrifugoMonitorOverviewRetrieve
+Path: /cfg/centrifugo/monitor/overview/
+Method: GET`);
+    if (error instanceof Error && "issues" in error && Array.isArray(error.issues)) {
+      import_consola9.consola.error("Validation Issues:");
+      error.issues.forEach((issue, index) => {
+        import_consola9.consola.error(`  ${index + 1}. ${issue.path.join(".") || "root"}`);
+        import_consola9.consola.error(`     \u251C\u2500 Message: ${issue.message}`);
+        if (issue.expected) import_consola9.consola.error(`     \u251C\u2500 Expected: ${issue.expected}`);
+        if (issue.received) import_consola9.consola.error(`     \u2514\u2500 Received: ${issue.received}`);
       });
-      const queryString = searchParams.toString();
-      if (queryString) {
-        finalUrl = url.includes("?") ? `${url}&${queryString}` : `${url}?${queryString}`;
-      }
-    }
-    const finalHeaders = { ...headers };
-    let requestBody;
-    if (formData) {
-      requestBody = formData;
-    } else if (body) {
-      finalHeaders["Content-Type"] = "application/json";
-      requestBody = JSON.stringify(body);
     }
-    const response = await fetch(finalUrl, {
-      method,
-      headers: finalHeaders,
-      body: requestBody,
-      credentials: "include"
-      // Include Django session cookies
-    });
-    let data = null;
-    const contentType = response.headers.get("content-type");
-    if (response.status !== 204 && contentType?.includes("application/json")) {
-      data = await response.json();
-    } else if (response.status !== 204) {
-      data = await response.text();
+    import_consola9.consola.error("Response data:", response);
+    if (typeof window !== "undefined" && error instanceof Error && "issues" in error) {
+      try {
+        const event = new CustomEvent("zod-validation-error", {
+          detail: {
+            operation: "getCentrifugoMonitorOverviewRetrieve",
+            path: "/cfg/centrifugo/monitor/overview/",
+            method: "GET",
+            error,
+            response,
+            timestamp: /* @__PURE__ */ new Date()
+          },
+          bubbles: true,
+          cancelable: false
+        });
+        window.dispatchEvent(event);
+      } catch (eventError) {
+        import_consola9.consola.warn("Failed to dispatch validation error event:", eventError);
+      }
     }
-    const responseHeaders = {};
-    response.headers.forEach((value, key) => {
-      responseHeaders[key] = value;
-    });
-    return {
-      data,
-      status: response.status,
-      statusText: response.statusText,
-      headers: responseHeaders
-    };
-  }
-};
-
-// src/generated/cfg_centrifugo/errors.ts
-var APIError3 = class extends Error {
-  constructor(statusCode, statusText, response, url, message) {
-    super(message || `HTTP ${statusCode}: ${statusText}`);
-    this.statusCode = statusCode;
-    this.statusText = statusText;
-    this.response = response;
-    this.url = url;
-    this.name = "APIError";
-  }
-  static {
-    __name(this, "APIError");
+    throw error;
   }
-  /**
-   * Get error details from response.
-   * DRF typically returns: { "detail": "Error message" } or { "field": ["error1", "error2"] }
-   */
-  get details() {
-    if (typeof this.response === "object" && this.response !== null) {
-      return this.response;
+}
+__name(getCentrifugoMonitorOverviewRetrieve, "getCentrifugoMonitorOverviewRetrieve");
+async function getCentrifugoMonitorPublishesList(params, client) {
+  const api = client || getAPIInstance2();
+  const response = await api.centrifugo_monitoring.centrifugoMonitorPublishesList(params?.channel, params?.page, params?.page_size, params?.status);
+  try {
+    return PaginatedPublishListSchema.parse(response);
+  } catch (error) {
+    import_consola9.consola.error("\u274C Zod Validation Failed");
+    import_consola9.consola.box(`getCentrifugoMonitorPublishesList
+Path: /cfg/centrifugo/monitor/publishes/
+Method: GET`);
+    if (error instanceof Error && "issues" in error && Array.isArray(error.issues)) {
+      import_consola9.consola.error("Validation Issues:");
+      error.issues.forEach((issue, index) => {
+        import_consola9.consola.error(`  ${index + 1}. ${issue.path.join(".") || "root"}`);
+        import_consola9.consola.error(`     \u251C\u2500 Message: ${issue.message}`);
+        if (issue.expected) import_consola9.consola.error(`     \u251C\u2500 Expected: ${issue.expected}`);
+        if (issue.received) import_consola9.consola.error(`     \u2514\u2500 Received: ${issue.received}`);
+      });
     }
-    return null;
-  }
-  /**
-   * Get field-specific validation errors from DRF.
-   * Returns: { "field_name": ["error1", "error2"], ... }
-   */
-  get fieldErrors() {
-    const details = this.details;
-    if (!details) return null;
-    const fieldErrors = {};
-    for (const [key, value] of Object.entries(details)) {
-      if (Array.isArray(value)) {
-        fieldErrors[key] = value;
+    import_consola9.consola.error("Response data:", response);
+    if (typeof window !== "undefined" && error instanceof Error && "issues" in error) {
+      try {
+        const event = new CustomEvent("zod-validation-error", {
+          detail: {
+            operation: "getCentrifugoMonitorPublishesList",
+            path: "/cfg/centrifugo/monitor/publishes/",
+            method: "GET",
+            error,
+            response,
+            timestamp: /* @__PURE__ */ new Date()
+          },
+          bubbles: true,
+          cancelable: false
+        });
+        window.dispatchEvent(event);
+      } catch (eventError) {
+        import_consola9.consola.warn("Failed to dispatch validation error event:", eventError);
       }
     }
-    return Object.keys(fieldErrors).length > 0 ? fieldErrors : null;
+    throw error;
   }
-  /**
-   * Get single error message from DRF.
-   * Checks for "detail", "message", or first field error.
-   */
-  get errorMessage() {
-    const details = this.details;
-    if (!details) return this.message;
-    if (details.detail) {
-      return Array.isArray(details.detail) ? details.detail.join(", ") : String(details.detail);
-    }
-    if (details.message) {
-      return String(details.message);
+}
+__name(getCentrifugoMonitorPublishesList, "getCentrifugoMonitorPublishesList");
+async function getCentrifugoMonitorTimelineRetrieve(params, client) {
+  const api = client || getAPIInstance2();
+  const response = await api.centrifugo_monitoring.centrifugoMonitorTimelineRetrieve(params?.hours, params?.interval);
+  try {
+    return TimelineResponseSchema.parse(response);
+  } catch (error) {
+    import_consola9.consola.error("\u274C Zod Validation Failed");
+    import_consola9.consola.box(`getCentrifugoMonitorTimelineRetrieve
+Path: /cfg/centrifugo/monitor/timeline/
+Method: GET`);
+    if (error instanceof Error && "issues" in error && Array.isArray(error.issues)) {
+      import_consola9.consola.error("Validation Issues:");
+      error.issues.forEach((issue, index) => {
+        import_consola9.consola.error(`  ${index + 1}. ${issue.path.join(".") || "root"}`);
+        import_consola9.consola.error(`     \u251C\u2500 Message: ${issue.message}`);
+        if (issue.expected) import_consola9.consola.error(`     \u251C\u2500 Expected: ${issue.expected}`);
+        if (issue.received) import_consola9.consola.error(`     \u2514\u2500 Received: ${issue.received}`);
+      });
     }
-    const fieldErrors = this.fieldErrors;
-    if (fieldErrors) {
-      const firstField = Object.keys(fieldErrors)[0];
-      if (firstField) {
-        return `${firstField}: ${fieldErrors[firstField]?.join(", ")}`;
+    import_consola9.consola.error("Response data:", response);
+    if (typeof window !== "undefined" && error instanceof Error && "issues" in error) {
+      try {
+        const event = new CustomEvent("zod-validation-error", {
+          detail: {
+            operation: "getCentrifugoMonitorTimelineRetrieve",
+            path: "/cfg/centrifugo/monitor/timeline/",
+            method: "GET",
+            error,
+            response,
+            timestamp: /* @__PURE__ */ new Date()
+          },
+          bubbles: true,
+          cancelable: false
+        });
+        window.dispatchEvent(event);
+      } catch (eventError) {
+        import_consola9.consola.warn("Failed to dispatch validation error event:", eventError);
       }
     }
-    return this.message;
+    throw error;
   }
-  // Helper methods for common HTTP status codes
-  get isValidationError() {
-    return this.statusCode === 400;
-  }
-  get isAuthError() {
-    return this.statusCode === 401;
-  }
-  get isPermissionError() {
-    return this.statusCode === 403;
+}
+__name(getCentrifugoMonitorTimelineRetrieve, "getCentrifugoMonitorTimelineRetrieve");
+
+// src/generated/cfg_centrifugo/_utils/fetchers/centrifugo__centrifugo_testing.ts
+var import_consola10 = require("consola");
+async function createCentrifugoTestingPublishTestCreate(data, client) {
+  const api = client || getAPIInstance2();
+  const response = await api.centrifugo_testing.publishTestCreate(data);
+  try {
+    return PublishTestResponseSchema.parse(response);
+  } catch (error) {
+    import_consola10.consola.error("\u274C Zod Validation Failed");
+    import_consola10.consola.box(`createCentrifugoTestingPublishTestCreate
+Path: /cfg/centrifugo/testing/publish-test/
+Method: POST`);
+    if (error instanceof Error && "issues" in error && Array.isArray(error.issues)) {
+      import_consola10.consola.error("Validation Issues:");
+      error.issues.forEach((issue, index) => {
+        import_consola10.consola.error(`  ${index + 1}. ${issue.path.join(".") || "root"}`);
+        import_consola10.consola.error(`     \u251C\u2500 Message: ${issue.message}`);
+        if (issue.expected) import_consola10.consola.error(`     \u251C\u2500 Expected: ${issue.expected}`);
+        if (issue.received) import_consola10.consola.error(`     \u2514\u2500 Received: ${issue.received}`);
+      });
+    }
+    import_consola10.consola.error("Response data:", response);
+    if (typeof window !== "undefined" && error instanceof Error && "issues" in error) {
+      try {
+        const event = new CustomEvent("zod-validation-error", {
+          detail: {
+            operation: "createCentrifugoTestingPublishTestCreate",
+            path: "/cfg/centrifugo/testing/publish-test/",
+            method: "POST",
+            error,
+            response,
+            timestamp: /* @__PURE__ */ new Date()
+          },
+          bubbles: true,
+          cancelable: false
+        });
+        window.dispatchEvent(event);
+      } catch (eventError) {
+        import_consola10.consola.warn("Failed to dispatch validation error event:", eventError);
+      }
+    }
+    throw error;
   }
-  get isNotFoundError() {
-    return this.statusCode === 404;
+}
+__name(createCentrifugoTestingPublishTestCreate, "createCentrifugoTestingPublishTestCreate");
+async function createCentrifugoTestingPublishWithLoggingCreate(data, client) {
+  const api = client || getAPIInstance2();
+  const response = await api.centrifugo_testing.publishWithLoggingCreate(data);
+  try {
+    return PublishTestResponseSchema.parse(response);
+  } catch (error) {
+    import_consola10.consola.error("\u274C Zod Validation Failed");
+    import_consola10.consola.box(`createCentrifugoTestingPublishWithLoggingCreate
+Path: /cfg/centrifugo/testing/publish-with-logging/
+Method: POST`);
+    if (error instanceof Error && "issues" in error && Array.isArray(error.issues)) {
+      import_consola10.consola.error("Validation Issues:");
+      error.issues.forEach((issue, index) => {
+        import_consola10.consola.error(`  ${index + 1}. ${issue.path.join(".") || "root"}`);
+        import_consola10.consola.error(`     \u251C\u2500 Message: ${issue.message}`);
+        if (issue.expected) import_consola10.consola.error(`     \u251C\u2500 Expected: ${issue.expected}`);
+        if (issue.received) import_consola10.consola.error(`     \u2514\u2500 Received: ${issue.received}`);
+      });
+    }
+    import_consola10.consola.error("Response data:", response);
+    if (typeof window !== "undefined" && error instanceof Error && "issues" in error) {
+      try {
+        const event = new CustomEvent("zod-validation-error", {
+          detail: {
+            operation: "createCentrifugoTestingPublishWithLoggingCreate",
+            path: "/cfg/centrifugo/testing/publish-with-logging/",
+            method: "POST",
+            error,
+            response,
+            timestamp: /* @__PURE__ */ new Date()
+          },
+          bubbles: true,
+          cancelable: false
+        });
+        window.dispatchEvent(event);
+      } catch (eventError) {
+        import_consola10.consola.warn("Failed to dispatch validation error event:", eventError);
+      }
+    }
+    throw error;
   }
-  get isServerError() {
-    return this.statusCode >= 500 && this.statusCode < 600;
+}
+__name(createCentrifugoTestingPublishWithLoggingCreate, "createCentrifugoTestingPublishWithLoggingCreate");
+async function createCentrifugoTestingSendAckCreate(data, client) {
+  const api = client || getAPIInstance2();
+  const response = await api.centrifugo_testing.sendAckCreate(data);
+  try {
+    return ManualAckResponseSchema.parse(response);
+  } catch (error) {
+    import_consola10.consola.error("\u274C Zod Validation Failed");
+    import_consola10.consola.box(`createCentrifugoTestingSendAckCreate
+Path: /cfg/centrifugo/testing/send-ack/
+Method: POST`);
+    if (error instanceof Error && "issues" in error && Array.isArray(error.issues)) {
+      import_consola10.consola.error("Validation Issues:");
+      error.issues.forEach((issue, index) => {
+        import_consola10.consola.error(`  ${index + 1}. ${issue.path.join(".") || "root"}`);
+        import_consola10.consola.error(`     \u251C\u2500 Message: ${issue.message}`);
+        if (issue.expected) import_consola10.consola.error(`     \u251C\u2500 Expected: ${issue.expected}`);
+        if (issue.received) import_consola10.consola.error(`     \u2514\u2500 Received: ${issue.received}`);
+      });
+    }
+    import_consola10.consola.error("Response data:", response);
+    if (typeof window !== "undefined" && error instanceof Error && "issues" in error) {
+      try {
+        const event = new CustomEvent("zod-validation-error", {
+          detail: {
+            operation: "createCentrifugoTestingSendAckCreate",
+            path: "/cfg/centrifugo/testing/send-ack/",
+            method: "POST",
+            error,
+            response,
+            timestamp: /* @__PURE__ */ new Date()
+          },
+          bubbles: true,
+          cancelable: false
+        });
+        window.dispatchEvent(event);
+      } catch (eventError) {
+        import_consola10.consola.warn("Failed to dispatch validation error event:", eventError);
+      }
+    }
+    throw error;
   }
-};
-var NetworkError3 = class extends Error {
-  constructor(message, url, originalError) {
-    super(message);
-    this.url = url;
-    this.originalError = originalError;
-    this.name = "NetworkError";
+}
+__name(createCentrifugoTestingSendAckCreate, "createCentrifugoTestingSendAckCreate");
+
+// src/generated/cfg_centrifugo/index.ts
+var TOKEN_KEY2 = "auth_token";
+var REFRESH_TOKEN_KEY2 = "refresh_token";
+var API2 = class {
+  constructor(baseUrl, options) {
+    this._token = null;
+    this._refreshToken = null;
+    this.baseUrl = baseUrl;
+    this.options = options;
+    const logger = options?.loggerConfig ? new APILogger2(options.loggerConfig) : void 0;
+    this.storage = options?.storage || new LocalStorageAdapter2(logger);
+    this._loadTokensFromStorage();
+    this._client = new APIClient2(this.baseUrl, {
+      retryConfig: this.options?.retryConfig,
+      loggerConfig: this.options?.loggerConfig
+    });
+    this._injectAuthHeader();
+    this.centrifugo_admin_api = this._client.centrifugo_admin_api;
+    this.centrifugo_auth = this._client.centrifugo_auth;
+    this.centrifugo_monitoring = this._client.centrifugo_monitoring;
+    this.centrifugo_testing = this._client.centrifugo_testing;
   }
   static {
-    __name(this, "NetworkError");
+    __name(this, "API");
   }
-};
-
-// src/generated/cfg_centrifugo/logger.ts
-var import_consola8 = require("consola");
-var DEFAULT_CONFIG3 = {
-  enabled: process.env.NODE_ENV !== "production",
-  logRequests: true,
-  logResponses: true,
-  logErrors: true,
-  logBodies: true,
-  logHeaders: false
-};
-var SENSITIVE_HEADERS3 = [
-  "authorization",
-  "cookie",
-  "set-cookie",
-  "x-api-key",
-  "x-csrf-token"
-];
-var APILogger3 = class {
-  static {
-    __name(this, "APILogger");
+  _loadTokensFromStorage() {
+    this._token = this.storage.getItem(TOKEN_KEY2);
+    this._refreshToken = this.storage.getItem(REFRESH_TOKEN_KEY2);
   }
-  constructor(config = {}) {
-    this.config = { ...DEFAULT_CONFIG3, ...config };
-    this.consola = config.consola || (0, import_consola8.createConsola)({
-      level: this.config.enabled ? 4 : 0
+  _reinitClients() {
+    this._client = new APIClient2(this.baseUrl, {
+      retryConfig: this.options?.retryConfig,
+      loggerConfig: this.options?.loggerConfig
     });
+    this._injectAuthHeader();
+    this.centrifugo_admin_api = this._client.centrifugo_admin_api;
+    this.centrifugo_auth = this._client.centrifugo_auth;
+    this.centrifugo_monitoring = this._client.centrifugo_monitoring;
+    this.centrifugo_testing = this._client.centrifugo_testing;
+  }
+  _injectAuthHeader() {
+    const originalRequest = this._client.request.bind(this._client);
+    this._client.request = async (method, path, options) => {
+      const token = this.getToken();
+      const mergedOptions = {
+        ...options,
+        headers: {
+          ...options?.headers || {},
+          ...token ? { "Authorization": `Bearer ${token}` } : {}
+        }
+      };
+      return originalRequest(method, path, mergedOptions);
+    };
   }
   /**
-   * Enable logging
+   * Get current JWT token
    */
-  enable() {
-    this.config.enabled = true;
+  getToken() {
+    return this.storage.getItem(TOKEN_KEY2);
   }
   /**
-   * Disable logging
+   * Get current refresh token
    */
-  disable() {
-    this.config.enabled = false;
+  getRefreshToken() {
+    return this.storage.getItem(REFRESH_TOKEN_KEY2);
   }
   /**
-   * Update configuration
+   * Set JWT token and refresh token
+   * @param token - JWT access token
+   * @param refreshToken - JWT refresh token (optional)
    */
-  setConfig(config) {
-    this.config = { ...this.config, ...config };
+  setToken(token, refreshToken) {
+    this._token = token;
+    this.storage.setItem(TOKEN_KEY2, token);
+    if (refreshToken) {
+      this._refreshToken = refreshToken;
+      this.storage.setItem(REFRESH_TOKEN_KEY2, refreshToken);
+    }
+    this._reinitClients();
   }
   /**
-   * Filter sensitive headers
+   * Clear all tokens
    */
-  filterHeaders(headers) {
-    if (!headers) return {};
-    const filtered = {};
-    Object.keys(headers).forEach((key) => {
-      const lowerKey = key.toLowerCase();
-      if (SENSITIVE_HEADERS3.includes(lowerKey)) {
-        filtered[key] = "***";
-      } else {
-        filtered[key] = headers[key] || "";
-      }
-    });
-    return filtered;
+  clearTokens() {
+    this._token = null;
+    this._refreshToken = null;
+    this.storage.removeItem(TOKEN_KEY2);
+    this.storage.removeItem(REFRESH_TOKEN_KEY2);
+    this._reinitClients();
   }
   /**
-   * Log request
+   * Check if user is authenticated
    */
-  logRequest(request) {
-    if (!this.config.enabled || !this.config.logRequests) return;
-    const { method, url, headers, body } = request;
-    this.consola.start(`${method} ${url}`);
-    if (this.config.logHeaders && headers) {
-      this.consola.debug("Headers:", this.filterHeaders(headers));
-    }
-    if (this.config.logBodies && body) {
-      this.consola.debug("Body:", body);
-    }
+  isAuthenticated() {
+    return !!this.getToken();
   }
   /**
-   * Log response
+   * Update base URL and reinitialize clients
+   * @param url - New base URL
    */
-  logResponse(request, response) {
-    if (!this.config.enabled || !this.config.logResponses) return;
-    const { method, url } = request;
-    const { status, statusText, data, duration } = response;
-    const statusColor = status >= 500 ? "red" : status >= 400 ? "yellow" : status >= 300 ? "cyan" : "green";
-    this.consola.success(
-      `${method} ${url} ${status} ${statusText} (${duration}ms)`
-    );
-    if (this.config.logBodies && data) {
-      this.consola.debug("Response:", data);
-    }
+  setBaseUrl(url) {
+    this.baseUrl = url;
+    this._reinitClients();
   }
   /**
-   * Log error
+   * Get current base URL
    */
-  logError(request, error) {
-    if (!this.config.enabled || !this.config.logErrors) return;
-    const { method, url } = request;
-    const { message, statusCode, fieldErrors, duration } = error;
-    this.consola.error(
-      `${method} ${url} ${statusCode || "Network"} Error (${duration}ms)`
-    );
-    this.consola.error("Message:", message);
-    if (fieldErrors && Object.keys(fieldErrors).length > 0) {
-      this.consola.error("Field Errors:");
-      Object.entries(fieldErrors).forEach(([field, errors]) => {
-        errors.forEach((err) => {
-          this.consola.error(`  \u2022 ${field}: ${err}`);
-        });
-      });
-    }
+  getBaseUrl() {
+    return this.baseUrl;
   }
   /**
-   * Log general info
+   * Get OpenAPI schema path
+   * @returns Path to the OpenAPI schema JSON file
+   *
+   * Note: The OpenAPI schema is available in the schema.json file.
+   * You can load it dynamically using:
+   * ```typescript
+   * const schema = await fetch('./schema.json').then(r => r.json());
+   * // or using fs in Node.js:
+   * // const schema = JSON.parse(fs.readFileSync('./schema.json', 'utf-8'));
+   * ```
    */
-  info(message, ...args) {
-    if (!this.config.enabled) return;
-    this.consola.info(message, ...args);
+  getSchemaPath() {
+    return "./schema.json";
   }
-  /**
-   * Log warning
-   */
-  warn(message, ...args) {
-    if (!this.config.enabled) return;
-    this.consola.warn(message, ...args);
+};
+
+// src/generated/cfg_webpush/webpush__web_push/client.ts
+var WebPush = class {
+  static {
+    __name(this, "WebPush");
   }
-  /**
-   * Log error
-   */
-  error(message, ...args) {
-    if (!this.config.enabled) return;
-    this.consola.error(message, ...args);
+  constructor(client) {
+    this.client = client;
   }
   /**
-   * Log debug
+   * Send push notification
+   * 
+   * Send push notification to all active subscriptions for the authenticated
+   * user.
    */
-  debug(message, ...args) {
-    if (!this.config.enabled) return;
-    this.consola.debug(message, ...args);
+  async webpushSendCreate(data) {
+    const response = await this.client.request("POST", "/cfg/webpush/send/", { body: data });
+    return response;
   }
   /**
-   * Log success
+   * Subscribe to push notifications
+   * 
+   * Save push subscription from browser for the authenticated user.
    */
-  success(message, ...args) {
-    if (!this.config.enabled) return;
-    this.consola.success(message, ...args);
+  async webpushSubscribeCreate(data) {
+    const response = await this.client.request("POST", "/cfg/webpush/subscribe/", { body: data });
+    return response;
   }
   /**
-   * Create a sub-logger with prefix
+   * Get VAPID public key
+   * 
+   * Get VAPID public key for client subscription.
    */
-  withTag(tag) {
-    return this.consola.withTag(tag);
+  async webpushVapidRetrieve() {
+    const response = await this.client.request("GET", "/cfg/webpush/vapid/");
+    return response;
   }
 };
-var defaultLogger3 = new APILogger3();
 
-// src/generated/cfg_centrifugo/retry.ts
-var import_p_retry3 = __toESM(require("p-retry"), 1);
-var DEFAULT_RETRY_CONFIG3 = {
-  retries: 3,
-  factor: 2,
-  minTimeout: 1e3,
-  maxTimeout: 6e4,
-  randomize: true,
-  onFailedAttempt: /* @__PURE__ */ __name(() => {
-  }, "onFailedAttempt")
-};
-function shouldRetry3(error) {
-  if (error instanceof NetworkError3) {
-    return true;
-  }
-  if (error instanceof APIError3) {
-    const status = error.statusCode;
-    if (status >= 500 && status < 600) {
-      return true;
-    }
-    if (status === 429) {
-      return true;
-    }
-    return false;
+// src/generated/cfg_webpush/http.ts
+var FetchAdapter3 = class {
+  static {
+    __name(this, "FetchAdapter");
   }
-  return true;
-}
-__name(shouldRetry3, "shouldRetry");
-async function withRetry3(fn, config) {
-  const finalConfig = { ...DEFAULT_RETRY_CONFIG3, ...config };
-  return (0, import_p_retry3.default)(
-    async () => {
-      try {
-        return await fn();
-      } catch (error) {
-        if (!shouldRetry3(error)) {
-          throw new import_p_retry3.AbortError(error);
+  async request(request) {
+    const { method, url, headers, body, params, formData } = request;
+    let finalUrl = url;
+    if (params) {
+      const searchParams = new URLSearchParams();
+      Object.entries(params).forEach(([key, value]) => {
+        if (value !== null && value !== void 0) {
+          searchParams.append(key, String(value));
         }
-        throw error;
+      });
+      const queryString = searchParams.toString();
+      if (queryString) {
+        finalUrl = url.includes("?") ? `${url}&${queryString}` : `${url}?${queryString}`;
       }
-    },
-    {
-      retries: finalConfig.retries,
-      factor: finalConfig.factor,
-      minTimeout: finalConfig.minTimeout,
-      maxTimeout: finalConfig.maxTimeout,
-      randomize: finalConfig.randomize,
-      onFailedAttempt: finalConfig.onFailedAttempt ? (error) => {
-        const pRetryError = error;
-        finalConfig.onFailedAttempt({
-          error: pRetryError,
-          attemptNumber: pRetryError.attemptNumber,
-          retriesLeft: pRetryError.retriesLeft
-        });
-      } : void 0
-    }
-  );
-}
-__name(withRetry3, "withRetry");
-
-// src/generated/cfg_centrifugo/client.ts
-var APIClient3 = class {
-  constructor(baseUrl, options) {
-    this.logger = null;
-    this.retryConfig = null;
-    this.baseUrl = baseUrl.replace(/\/$/, "");
-    this.httpClient = options?.httpClient || new FetchAdapter3();
-    if (options?.loggerConfig !== void 0) {
-      this.logger = new APILogger3(options.loggerConfig);
-    }
-    if (options?.retryConfig !== void 0) {
-      this.retryConfig = options.retryConfig;
     }
-    this.centrifugo_admin_api = new CentrifugoAdminApi(this);
-    this.centrifugo_auth = new CentrifugoAuth(this);
-    this.centrifugo_monitoring = new CentrifugoMonitoring(this);
-    this.centrifugo_testing = new CentrifugoTesting(this);
-  }
-  static {
-    __name(this, "APIClient");
-  }
-  /**
-   * Get CSRF token from cookies (for SessionAuthentication).
-   *
-   * Returns null if cookie doesn't exist (JWT-only auth).
-   */
-  getCsrfToken() {
-    const name = "csrftoken";
-    const value = `; ${document.cookie}`;
-    const parts = value.split(`; ${name}=`);
-    if (parts.length === 2) {
-      return parts.pop()?.split(";").shift() || null;
+    const finalHeaders = { ...headers };
+    let requestBody;
+    if (formData) {
+      requestBody = formData;
+    } else if (body) {
+      finalHeaders["Content-Type"] = "application/json";
+      requestBody = JSON.stringify(body);
     }
-    return null;
-  }
-  /**
-   * Make HTTP request with Django CSRF and session handling.
-   * Automatically retries on network errors and 5xx server errors.
-   */
-  async request(method, path, options) {
-    if (this.retryConfig) {
-      return withRetry3(() => this._makeRequest(method, path, options), {
-        ...this.retryConfig,
-        onFailedAttempt: /* @__PURE__ */ __name((info) => {
-          if (this.logger) {
-            this.logger.warn(
-              `Retry attempt ${info.attemptNumber}/${info.retriesLeft + info.attemptNumber} for ${method} ${path}: ${info.error.message}`
-            );
-          }
-          this.retryConfig?.onFailedAttempt?.(info);
-        }, "onFailedAttempt")
-      });
-    }
-    return this._makeRequest(method, path, options);
-  }
-  /**
-   * Internal request method (without retry wrapper).
-   * Used by request() method with optional retry logic.
-   */
-  async _makeRequest(method, path, options) {
-    const url = this.baseUrl ? `${this.baseUrl}${path}` : path;
-    const startTime = Date.now();
-    const headers = {
-      ...options?.headers || {}
-    };
-    if (!options?.formData && !headers["Content-Type"]) {
-      headers["Content-Type"] = "application/json";
-    }
-    if (this.logger) {
-      this.logger.logRequest({
-        method,
-        url,
-        headers,
-        body: options?.formData || options?.body,
-        timestamp: startTime
-      });
-    }
-    try {
-      const response = await this.httpClient.request({
-        method,
-        url,
-        headers,
-        params: options?.params,
-        body: options?.body,
-        formData: options?.formData
-      });
-      const duration = Date.now() - startTime;
-      if (response.status >= 400) {
-        const error = new APIError3(
-          response.status,
-          response.statusText,
-          response.data,
-          url
-        );
-        if (this.logger) {
-          this.logger.logError(
-            {
-              method,
-              url,
-              headers,
-              body: options?.formData || options?.body,
-              timestamp: startTime
-            },
-            {
-              message: error.message,
-              statusCode: response.status,
-              duration,
-              timestamp: Date.now()
-            }
-          );
-        }
-        throw error;
-      }
-      if (this.logger) {
-        this.logger.logResponse(
-          {
-            method,
-            url,
-            headers,
-            body: options?.formData || options?.body,
-            timestamp: startTime
-          },
-          {
-            status: response.status,
-            statusText: response.statusText,
-            data: response.data,
-            duration,
-            timestamp: Date.now()
-          }
-        );
-      }
-      return response.data;
-    } catch (error) {
-      const duration = Date.now() - startTime;
-      if (error instanceof APIError3) {
-        throw error;
-      }
-      const isCORSError = error instanceof TypeError && (error.message.toLowerCase().includes("cors") || error.message.toLowerCase().includes("failed to fetch") || error.message.toLowerCase().includes("network request failed"));
-      if (this.logger) {
-        if (isCORSError) {
-          this.logger.error(`\u{1F6AB} CORS Error: ${method} ${url}`);
-          this.logger.error(`  \u2192 ${error instanceof Error ? error.message : String(error)}`);
-          this.logger.error(`  \u2192 Configure security_domains parameter on the server`);
-        } else {
-          this.logger.error(`\u26A0\uFE0F  Network Error: ${method} ${url}`);
-          this.logger.error(`  \u2192 ${error instanceof Error ? error.message : String(error)}`);
-        }
-      }
-      if (typeof window !== "undefined") {
-        try {
-          if (isCORSError) {
-            window.dispatchEvent(new CustomEvent("cors-error", {
-              detail: {
-                url,
-                method,
-                error: error instanceof Error ? error.message : String(error),
-                timestamp: /* @__PURE__ */ new Date()
-              },
-              bubbles: true,
-              cancelable: false
-            }));
-          } else {
-            window.dispatchEvent(new CustomEvent("network-error", {
-              detail: {
-                url,
-                method,
-                error: error instanceof Error ? error.message : String(error),
-                timestamp: /* @__PURE__ */ new Date()
-              },
-              bubbles: true,
-              cancelable: false
-            }));
-          }
-        } catch (eventError) {
-        }
-      }
-      const networkError = error instanceof Error ? new NetworkError3(error.message, url, error) : new NetworkError3("Unknown error", url);
-      if (this.logger) {
-        this.logger.logError(
-          {
-            method,
-            url,
-            headers,
-            body: options?.formData || options?.body,
-            timestamp: startTime
-          },
-          {
-            message: networkError.message,
-            duration,
-            timestamp: Date.now()
-          }
-        );
-      }
-      throw networkError;
-    }
-  }
-};
-
-// src/generated/cfg_centrifugo/storage.ts
-var LocalStorageAdapter3 = class {
-  static {
-    __name(this, "LocalStorageAdapter");
-  }
-  constructor(logger) {
-    this.logger = logger;
-  }
-  getItem(key) {
-    try {
-      if (typeof window !== "undefined" && window.localStorage) {
-        const value = localStorage.getItem(key);
-        this.logger?.debug(`LocalStorage.getItem("${key}"): ${value ? "found" : "not found"}`);
-        return value;
-      }
-      this.logger?.warn("LocalStorage not available: window.localStorage is undefined");
-    } catch (error) {
-      this.logger?.error("LocalStorage.getItem failed:", error);
-    }
-    return null;
-  }
-  setItem(key, value) {
-    try {
-      if (typeof window !== "undefined" && window.localStorage) {
-        localStorage.setItem(key, value);
-        this.logger?.debug(`LocalStorage.setItem("${key}"): success`);
-      } else {
-        this.logger?.warn("LocalStorage not available: window.localStorage is undefined");
-      }
-    } catch (error) {
-      this.logger?.error("LocalStorage.setItem failed:", error);
-    }
-  }
-  removeItem(key) {
-    try {
-      if (typeof window !== "undefined" && window.localStorage) {
-        localStorage.removeItem(key);
-        this.logger?.debug(`LocalStorage.removeItem("${key}"): success`);
-      } else {
-        this.logger?.warn("LocalStorage not available: window.localStorage is undefined");
-      }
-    } catch (error) {
-      this.logger?.error("LocalStorage.removeItem failed:", error);
-    }
-  }
-};
-
-// src/generated/cfg_centrifugo/_utils/schemas/index.ts
-var schemas_exports3 = {};
-__export(schemas_exports3, {
-  CentrifugoChannelInfoSchema: () => CentrifugoChannelInfoSchema,
-  CentrifugoChannelsRequestRequestSchema: () => CentrifugoChannelsRequestRequestSchema,
-  CentrifugoChannelsResponseSchema: () => CentrifugoChannelsResponseSchema,
-  CentrifugoChannelsResultSchema: () => CentrifugoChannelsResultSchema,
-  CentrifugoClientInfoSchema: () => CentrifugoClientInfoSchema,
-  CentrifugoErrorSchema: () => CentrifugoErrorSchema,
-  CentrifugoHealthCheckSchema: () => CentrifugoHealthCheckSchema,
-  CentrifugoHistoryRequestRequestSchema: () => CentrifugoHistoryRequestRequestSchema,
-  CentrifugoHistoryResponseSchema: () => CentrifugoHistoryResponseSchema,
-  CentrifugoHistoryResultSchema: () => CentrifugoHistoryResultSchema,
-  CentrifugoInfoResponseSchema: () => CentrifugoInfoResponseSchema,
-  CentrifugoInfoResultSchema: () => CentrifugoInfoResultSchema,
-  CentrifugoMetricsSchema: () => CentrifugoMetricsSchema,
-  CentrifugoNodeInfoSchema: () => CentrifugoNodeInfoSchema,
-  CentrifugoOverviewStatsSchema: () => CentrifugoOverviewStatsSchema,
-  CentrifugoPresenceRequestRequestSchema: () => CentrifugoPresenceRequestRequestSchema,
-  CentrifugoPresenceResponseSchema: () => CentrifugoPresenceResponseSchema,
-  CentrifugoPresenceResultSchema: () => CentrifugoPresenceResultSchema,
-  CentrifugoPresenceStatsRequestRequestSchema: () => CentrifugoPresenceStatsRequestRequestSchema,
-  CentrifugoPresenceStatsResponseSchema: () => CentrifugoPresenceStatsResponseSchema,
-  CentrifugoPresenceStatsResultSchema: () => CentrifugoPresenceStatsResultSchema,
-  CentrifugoProcessSchema: () => CentrifugoProcessSchema,
-  CentrifugoPublicationSchema: () => CentrifugoPublicationSchema,
-  CentrifugoStreamPositionSchema: () => CentrifugoStreamPositionSchema,
-  ChannelListSchema: () => ChannelListSchema,
-  ChannelStatsSchema: () => ChannelStatsSchema,
-  ConnectionTokenResponseSchema: () => ConnectionTokenResponseSchema,
-  ManualAckRequestRequestSchema: () => ManualAckRequestRequestSchema,
-  ManualAckResponseSchema: () => ManualAckResponseSchema,
-  PaginatedPublishListSchema: () => PaginatedPublishListSchema,
-  PublishSchema: () => PublishSchema,
-  PublishTestRequestRequestSchema: () => PublishTestRequestRequestSchema,
-  PublishTestResponseSchema: () => PublishTestResponseSchema,
-  TimelineItemSchema: () => TimelineItemSchema,
-  TimelineResponseSchema: () => TimelineResponseSchema
-});
-
-// src/generated/cfg_centrifugo/_utils/schemas/CentrifugoChannelInfo.schema.ts
-var import_zod25 = require("zod");
-var CentrifugoChannelInfoSchema = import_zod25.z.object({
-  num_clients: import_zod25.z.int()
-});
-
-// src/generated/cfg_centrifugo/_utils/schemas/CentrifugoChannelsRequestRequest.schema.ts
-var import_zod26 = require("zod");
-var CentrifugoChannelsRequestRequestSchema = import_zod26.z.object({
-  pattern: import_zod26.z.string().nullable().optional()
-});
-
-// src/generated/cfg_centrifugo/_utils/schemas/CentrifugoChannelsResponse.schema.ts
-var import_zod29 = require("zod");
-
-// src/generated/cfg_centrifugo/_utils/schemas/CentrifugoChannelsResult.schema.ts
-var import_zod27 = require("zod");
-var CentrifugoChannelsResultSchema = import_zod27.z.object({
-  channels: import_zod27.z.record(import_zod27.z.string(), CentrifugoChannelInfoSchema)
-});
-
-// src/generated/cfg_centrifugo/_utils/schemas/CentrifugoError.schema.ts
-var import_zod28 = require("zod");
-var CentrifugoErrorSchema = import_zod28.z.object({
-  code: import_zod28.z.int().optional(),
-  message: import_zod28.z.string().optional()
-});
-
-// src/generated/cfg_centrifugo/_utils/schemas/CentrifugoChannelsResponse.schema.ts
-var CentrifugoChannelsResponseSchema = import_zod29.z.object({
-  error: CentrifugoErrorSchema.optional(),
-  result: CentrifugoChannelsResultSchema.optional()
-});
-
-// src/generated/cfg_centrifugo/_utils/schemas/CentrifugoClientInfo.schema.ts
-var import_zod30 = require("zod");
-var CentrifugoClientInfoSchema = import_zod30.z.object({
-  user: import_zod30.z.string(),
-  client: import_zod30.z.string(),
-  conn_info: import_zod30.z.record(import_zod30.z.string(), import_zod30.z.any()).nullable().optional(),
-  chan_info: import_zod30.z.record(import_zod30.z.string(), import_zod30.z.any()).nullable().optional()
-});
-
-// src/generated/cfg_centrifugo/_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/generated/cfg_centrifugo/_utils/schemas/CentrifugoHistoryRequestRequest.schema.ts
-var import_zod33 = require("zod");
-
-// src/generated/cfg_centrifugo/_utils/schemas/CentrifugoStreamPosition.schema.ts
-var import_zod32 = require("zod");
-var CentrifugoStreamPositionSchema = import_zod32.z.object({
-  offset: import_zod32.z.int(),
-  epoch: import_zod32.z.string()
-});
-
-// src/generated/cfg_centrifugo/_utils/schemas/CentrifugoHistoryRequestRequest.schema.ts
-var CentrifugoHistoryRequestRequestSchema = import_zod33.z.object({
-  channel: import_zod33.z.string(),
-  limit: import_zod33.z.int().nullable().optional(),
-  since: CentrifugoStreamPositionSchema.optional(),
-  reverse: import_zod33.z.boolean().nullable().optional()
-});
-
-// src/generated/cfg_centrifugo/_utils/schemas/CentrifugoHistoryResponse.schema.ts
-var import_zod36 = require("zod");
-
-// src/generated/cfg_centrifugo/_utils/schemas/CentrifugoHistoryResult.schema.ts
-var import_zod35 = require("zod");
-
-// src/generated/cfg_centrifugo/_utils/schemas/CentrifugoPublication.schema.ts
-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_zod34.z.int(),
-  tags: import_zod34.z.record(import_zod34.z.string(), import_zod34.z.any()).nullable().optional()
-});
-
-// src/generated/cfg_centrifugo/_utils/schemas/CentrifugoHistoryResult.schema.ts
-var CentrifugoHistoryResultSchema = import_zod35.z.object({
-  publications: import_zod35.z.array(CentrifugoPublicationSchema),
-  epoch: import_zod35.z.string(),
-  offset: import_zod35.z.int()
-});
-
-// src/generated/cfg_centrifugo/_utils/schemas/CentrifugoHistoryResponse.schema.ts
-var CentrifugoHistoryResponseSchema = import_zod36.z.object({
-  error: CentrifugoErrorSchema.optional(),
-  result: CentrifugoHistoryResultSchema.optional()
-});
-
-// src/generated/cfg_centrifugo/_utils/schemas/CentrifugoInfoResponse.schema.ts
-var import_zod41 = require("zod");
-
-// src/generated/cfg_centrifugo/_utils/schemas/CentrifugoInfoResult.schema.ts
-var import_zod40 = require("zod");
-
-// src/generated/cfg_centrifugo/_utils/schemas/CentrifugoNodeInfo.schema.ts
-var import_zod39 = require("zod");
-
-// src/generated/cfg_centrifugo/_utils/schemas/CentrifugoMetrics.schema.ts
-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/generated/cfg_centrifugo/_utils/schemas/CentrifugoProcess.schema.ts
-var import_zod38 = require("zod");
-var CentrifugoProcessSchema = import_zod38.z.object({
-  cpu: import_zod38.z.number(),
-  rss: import_zod38.z.int()
-});
-
-// src/generated/cfg_centrifugo/_utils/schemas/CentrifugoNodeInfo.schema.ts
-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/generated/cfg_centrifugo/_utils/schemas/CentrifugoInfoResult.schema.ts
-var CentrifugoInfoResultSchema = import_zod40.z.object({
-  nodes: import_zod40.z.array(CentrifugoNodeInfoSchema)
-});
-
-// src/generated/cfg_centrifugo/_utils/schemas/CentrifugoInfoResponse.schema.ts
-var CentrifugoInfoResponseSchema = import_zod41.z.object({
-  error: CentrifugoErrorSchema.optional(),
-  result: CentrifugoInfoResultSchema.optional()
-});
-
-// src/generated/cfg_centrifugo/_utils/schemas/CentrifugoOverviewStats.schema.ts
-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/generated/cfg_centrifugo/_utils/schemas/CentrifugoPresenceRequestRequest.schema.ts
-var import_zod43 = require("zod");
-var CentrifugoPresenceRequestRequestSchema = import_zod43.z.object({
-  channel: import_zod43.z.string()
-});
-
-// src/generated/cfg_centrifugo/_utils/schemas/CentrifugoPresenceResponse.schema.ts
-var import_zod45 = require("zod");
-
-// src/generated/cfg_centrifugo/_utils/schemas/CentrifugoPresenceResult.schema.ts
-var import_zod44 = require("zod");
-var CentrifugoPresenceResultSchema = import_zod44.z.object({
-  presence: import_zod44.z.record(import_zod44.z.string(), CentrifugoClientInfoSchema)
-});
-
-// src/generated/cfg_centrifugo/_utils/schemas/CentrifugoPresenceResponse.schema.ts
-var CentrifugoPresenceResponseSchema = import_zod45.z.object({
-  error: CentrifugoErrorSchema.optional(),
-  result: CentrifugoPresenceResultSchema.optional()
-});
-
-// src/generated/cfg_centrifugo/_utils/schemas/CentrifugoPresenceStatsRequestRequest.schema.ts
-var import_zod46 = require("zod");
-var CentrifugoPresenceStatsRequestRequestSchema = import_zod46.z.object({
-  channel: import_zod46.z.string()
-});
-
-// src/generated/cfg_centrifugo/_utils/schemas/CentrifugoPresenceStatsResponse.schema.ts
-var import_zod48 = require("zod");
-
-// src/generated/cfg_centrifugo/_utils/schemas/CentrifugoPresenceStatsResult.schema.ts
-var import_zod47 = require("zod");
-var CentrifugoPresenceStatsResultSchema = import_zod47.z.object({
-  num_clients: import_zod47.z.int(),
-  num_users: import_zod47.z.int()
-});
-
-// src/generated/cfg_centrifugo/_utils/schemas/CentrifugoPresenceStatsResponse.schema.ts
-var CentrifugoPresenceStatsResponseSchema = import_zod48.z.object({
-  error: CentrifugoErrorSchema.optional(),
-  result: CentrifugoPresenceStatsResultSchema.optional()
-});
-
-// src/generated/cfg_centrifugo/_utils/schemas/ChannelList.schema.ts
-var import_zod50 = require("zod");
-
-// src/generated/cfg_centrifugo/_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()
-});
-
-// src/generated/cfg_centrifugo/_utils/schemas/ChannelList.schema.ts
-var ChannelListSchema = import_zod50.z.object({
-  channels: import_zod50.z.array(ChannelStatsSchema),
-  total_channels: import_zod50.z.int()
-});
-
-// src/generated/cfg_centrifugo/_utils/schemas/ConnectionTokenResponse.schema.ts
-var import_zod51 = require("zod");
-var ConnectionTokenResponseSchema = import_zod51.z.object({
-  token: import_zod51.z.string(),
-  centrifugo_url: import_zod51.z.string(),
-  expires_at: import_zod51.z.string(),
-  channels: import_zod51.z.array(import_zod51.z.string())
-});
-
-// src/generated/cfg_centrifugo/_utils/schemas/ManualAckRequestRequest.schema.ts
-var import_zod52 = require("zod");
-var ManualAckRequestRequestSchema = import_zod52.z.object({
-  message_id: import_zod52.z.string(),
-  client_id: import_zod52.z.string()
-});
-
-// src/generated/cfg_centrifugo/_utils/schemas/ManualAckResponse.schema.ts
-var import_zod53 = require("zod");
-var ManualAckResponseSchema = import_zod53.z.object({
-  success: import_zod53.z.boolean(),
-  message_id: import_zod53.z.string(),
-  error: import_zod53.z.string().nullable().optional()
-});
-
-// src/generated/cfg_centrifugo/_utils/schemas/PaginatedPublishList.schema.ts
-var import_zod55 = require("zod");
-
-// src/generated/cfg_centrifugo/_utils/schemas/Publish.schema.ts
-var import_zod54 = require("zod");
-var PublishSchema = import_zod54.z.object({
-  message_id: import_zod54.z.string(),
-  channel: import_zod54.z.string(),
-  status: import_zod54.z.string(),
-  wait_for_ack: import_zod54.z.boolean(),
-  acks_received: import_zod54.z.int(),
-  acks_expected: import_zod54.z.int().nullable(),
-  duration_ms: import_zod54.z.number().nullable(),
-  created_at: import_zod54.z.iso.datetime(),
-  completed_at: import_zod54.z.iso.datetime().nullable(),
-  error_code: import_zod54.z.string().nullable(),
-  error_message: import_zod54.z.string().nullable()
-});
-
-// src/generated/cfg_centrifugo/_utils/schemas/PaginatedPublishList.schema.ts
-var PaginatedPublishListSchema = import_zod55.z.object({
-  count: import_zod55.z.int(),
-  page: import_zod55.z.int(),
-  pages: import_zod55.z.int(),
-  page_size: import_zod55.z.int(),
-  has_next: import_zod55.z.boolean(),
-  has_previous: import_zod55.z.boolean(),
-  next_page: import_zod55.z.int().nullable().optional(),
-  previous_page: import_zod55.z.int().nullable().optional(),
-  results: import_zod55.z.array(PublishSchema)
-});
-
-// src/generated/cfg_centrifugo/_utils/schemas/PublishTestRequestRequest.schema.ts
-var import_zod56 = require("zod");
-var PublishTestRequestRequestSchema = import_zod56.z.object({
-  channel: import_zod56.z.string(),
-  data: import_zod56.z.record(import_zod56.z.string(), import_zod56.z.any()),
-  wait_for_ack: import_zod56.z.boolean().optional(),
-  ack_timeout: import_zod56.z.int().min(1).max(60).optional()
-});
-
-// src/generated/cfg_centrifugo/_utils/schemas/PublishTestResponse.schema.ts
-var import_zod57 = require("zod");
-var PublishTestResponseSchema = import_zod57.z.object({
-  success: import_zod57.z.boolean(),
-  message_id: import_zod57.z.string(),
-  channel: import_zod57.z.string(),
-  acks_received: import_zod57.z.int().optional(),
-  delivered: import_zod57.z.boolean().optional(),
-  error: import_zod57.z.string().nullable().optional()
-});
-
-// src/generated/cfg_centrifugo/_utils/schemas/TimelineItem.schema.ts
-var import_zod58 = require("zod");
-var TimelineItemSchema = import_zod58.z.object({
-  timestamp: import_zod58.z.string(),
-  count: import_zod58.z.int(),
-  successful: import_zod58.z.int(),
-  failed: import_zod58.z.int(),
-  timeout: import_zod58.z.int()
-});
-
-// src/generated/cfg_centrifugo/_utils/schemas/TimelineResponse.schema.ts
-var import_zod59 = require("zod");
-var TimelineResponseSchema = import_zod59.z.object({
-  timeline: import_zod59.z.array(TimelineItemSchema),
-  period_hours: import_zod59.z.int(),
-  interval: import_zod59.z.string()
-});
-
-// src/generated/cfg_centrifugo/_utils/fetchers/index.ts
-var fetchers_exports3 = {};
-__export(fetchers_exports3, {
-  createCentrifugoServerAuthTokenCreate: () => createCentrifugoServerAuthTokenCreate,
-  createCentrifugoServerChannelsCreate: () => createCentrifugoServerChannelsCreate,
-  createCentrifugoServerHistoryCreate: () => createCentrifugoServerHistoryCreate,
-  createCentrifugoServerInfoCreate: () => createCentrifugoServerInfoCreate,
-  createCentrifugoServerPresenceCreate: () => createCentrifugoServerPresenceCreate,
-  createCentrifugoServerPresenceStatsCreate: () => createCentrifugoServerPresenceStatsCreate,
-  createCentrifugoTestingPublishTestCreate: () => createCentrifugoTestingPublishTestCreate,
-  createCentrifugoTestingPublishWithLoggingCreate: () => createCentrifugoTestingPublishWithLoggingCreate,
-  createCentrifugoTestingSendAckCreate: () => createCentrifugoTestingSendAckCreate,
-  getCentrifugoAuthTokenRetrieve: () => getCentrifugoAuthTokenRetrieve,
-  getCentrifugoMonitorChannelsRetrieve: () => getCentrifugoMonitorChannelsRetrieve,
-  getCentrifugoMonitorHealthRetrieve: () => getCentrifugoMonitorHealthRetrieve,
-  getCentrifugoMonitorOverviewRetrieve: () => getCentrifugoMonitorOverviewRetrieve,
-  getCentrifugoMonitorPublishesList: () => getCentrifugoMonitorPublishesList,
-  getCentrifugoMonitorTimelineRetrieve: () => getCentrifugoMonitorTimelineRetrieve
-});
-
-// src/generated/cfg_centrifugo/_utils/fetchers/centrifugo__centrifugo_admin_api.ts
-var import_consola9 = require("consola");
-
-// src/generated/cfg_centrifugo/api-instance.ts
-var globalAPI3 = null;
-function getAPIInstance3() {
-  if (!globalAPI3) {
-    throw new Error(
-      'API not configured. Call configureAPI() with your base URL before using fetchers or hooks.\n\nExample:\n  import { configureAPI } from "./api-instance"\n  configureAPI({ baseUrl: "https://api.example.com" })'
-    );
+    const response = await fetch(finalUrl, {
+      method,
+      headers: finalHeaders,
+      body: requestBody,
+      credentials: "include"
+      // Include Django session cookies
+    });
+    let data = null;
+    const contentType = response.headers.get("content-type");
+    if (response.status !== 204 && contentType?.includes("application/json")) {
+      data = await response.json();
+    } else if (response.status !== 204) {
+      data = await response.text();
+    }
+    const responseHeaders = {};
+    response.headers.forEach((value, key) => {
+      responseHeaders[key] = value;
+    });
+    return {
+      data,
+      status: response.status,
+      statusText: response.statusText,
+      headers: responseHeaders
+    };
   }
-  return globalAPI3;
-}
-__name(getAPIInstance3, "getAPIInstance");
+};
 
-// src/generated/cfg_centrifugo/_utils/fetchers/centrifugo__centrifugo_admin_api.ts
-async function createCentrifugoServerAuthTokenCreate(client) {
-  const api = client || getAPIInstance3();
-  const response = await api.centrifugo_admin_api.centrifugoServerAuthTokenCreate();
-  return response;
-}
-__name(createCentrifugoServerAuthTokenCreate, "createCentrifugoServerAuthTokenCreate");
-async function createCentrifugoServerChannelsCreate(data, client) {
-  const api = client || getAPIInstance3();
-  const response = await api.centrifugo_admin_api.centrifugoServerChannelsCreate(data);
-  try {
-    return CentrifugoChannelsResponseSchema.parse(response);
-  } catch (error) {
-    import_consola9.consola.error("\u274C Zod Validation Failed");
-    import_consola9.consola.box(`createCentrifugoServerChannelsCreate
-Path: /cfg/centrifugo/server/channels/
-Method: POST`);
-    if (error instanceof Error && "issues" in error && Array.isArray(error.issues)) {
-      import_consola9.consola.error("Validation Issues:");
-      error.issues.forEach((issue, index) => {
-        import_consola9.consola.error(`  ${index + 1}. ${issue.path.join(".") || "root"}`);
-        import_consola9.consola.error(`     \u251C\u2500 Message: ${issue.message}`);
-        if (issue.expected) import_consola9.consola.error(`     \u251C\u2500 Expected: ${issue.expected}`);
-        if (issue.received) import_consola9.consola.error(`     \u2514\u2500 Received: ${issue.received}`);
-      });
+// src/generated/cfg_webpush/errors.ts
+var APIError3 = class extends Error {
+  constructor(statusCode, statusText, response, url, message) {
+    super(message || `HTTP ${statusCode}: ${statusText}`);
+    this.statusCode = statusCode;
+    this.statusText = statusText;
+    this.response = response;
+    this.url = url;
+    this.name = "APIError";
+  }
+  static {
+    __name(this, "APIError");
+  }
+  /**
+   * Get error details from response.
+   * DRF typically returns: { "detail": "Error message" } or { "field": ["error1", "error2"] }
+   */
+  get details() {
+    if (typeof this.response === "object" && this.response !== null) {
+      return this.response;
     }
-    import_consola9.consola.error("Response data:", response);
-    if (typeof window !== "undefined" && error instanceof Error && "issues" in error) {
-      try {
-        const event = new CustomEvent("zod-validation-error", {
-          detail: {
-            operation: "createCentrifugoServerChannelsCreate",
-            path: "/cfg/centrifugo/server/channels/",
-            method: "POST",
-            error,
-            response,
-            timestamp: /* @__PURE__ */ new Date()
-          },
-          bubbles: true,
-          cancelable: false
-        });
-        window.dispatchEvent(event);
-      } catch (eventError) {
-        import_consola9.consola.warn("Failed to dispatch validation error event:", eventError);
+    return null;
+  }
+  /**
+   * Get field-specific validation errors from DRF.
+   * Returns: { "field_name": ["error1", "error2"], ... }
+   */
+  get fieldErrors() {
+    const details = this.details;
+    if (!details) return null;
+    const fieldErrors = {};
+    for (const [key, value] of Object.entries(details)) {
+      if (Array.isArray(value)) {
+        fieldErrors[key] = value;
       }
     }
-    throw error;
+    return Object.keys(fieldErrors).length > 0 ? fieldErrors : null;
   }
-}
-__name(createCentrifugoServerChannelsCreate, "createCentrifugoServerChannelsCreate");
-async function createCentrifugoServerHistoryCreate(data, client) {
-  const api = client || getAPIInstance3();
-  const response = await api.centrifugo_admin_api.centrifugoServerHistoryCreate(data);
-  try {
-    return CentrifugoHistoryResponseSchema.parse(response);
-  } catch (error) {
-    import_consola9.consola.error("\u274C Zod Validation Failed");
-    import_consola9.consola.box(`createCentrifugoServerHistoryCreate
-Path: /cfg/centrifugo/server/history/
-Method: POST`);
-    if (error instanceof Error && "issues" in error && Array.isArray(error.issues)) {
-      import_consola9.consola.error("Validation Issues:");
-      error.issues.forEach((issue, index) => {
-        import_consola9.consola.error(`  ${index + 1}. ${issue.path.join(".") || "root"}`);
-        import_consola9.consola.error(`     \u251C\u2500 Message: ${issue.message}`);
-        if (issue.expected) import_consola9.consola.error(`     \u251C\u2500 Expected: ${issue.expected}`);
-        if (issue.received) import_consola9.consola.error(`     \u2514\u2500 Received: ${issue.received}`);
-      });
+  /**
+   * Get single error message from DRF.
+   * Checks for "detail", "message", or first field error.
+   */
+  get errorMessage() {
+    const details = this.details;
+    if (!details) return this.message;
+    if (details.detail) {
+      return Array.isArray(details.detail) ? details.detail.join(", ") : String(details.detail);
     }
-    import_consola9.consola.error("Response data:", response);
-    if (typeof window !== "undefined" && error instanceof Error && "issues" in error) {
-      try {
-        const event = new CustomEvent("zod-validation-error", {
-          detail: {
-            operation: "createCentrifugoServerHistoryCreate",
-            path: "/cfg/centrifugo/server/history/",
-            method: "POST",
-            error,
-            response,
-            timestamp: /* @__PURE__ */ new Date()
-          },
-          bubbles: true,
-          cancelable: false
-        });
-        window.dispatchEvent(event);
-      } catch (eventError) {
-        import_consola9.consola.warn("Failed to dispatch validation error event:", eventError);
+    if (details.message) {
+      return String(details.message);
+    }
+    const fieldErrors = this.fieldErrors;
+    if (fieldErrors) {
+      const firstField = Object.keys(fieldErrors)[0];
+      if (firstField) {
+        return `${firstField}: ${fieldErrors[firstField]?.join(", ")}`;
       }
     }
-    throw error;
+    return this.message;
   }
-}
-__name(createCentrifugoServerHistoryCreate, "createCentrifugoServerHistoryCreate");
-async function createCentrifugoServerInfoCreate(client) {
-  const api = client || getAPIInstance3();
-  const response = await api.centrifugo_admin_api.centrifugoServerInfoCreate();
-  try {
-    return CentrifugoInfoResponseSchema.parse(response);
-  } catch (error) {
-    import_consola9.consola.error("\u274C Zod Validation Failed");
-    import_consola9.consola.box(`createCentrifugoServerInfoCreate
-Path: /cfg/centrifugo/server/info/
-Method: POST`);
-    if (error instanceof Error && "issues" in error && Array.isArray(error.issues)) {
-      import_consola9.consola.error("Validation Issues:");
-      error.issues.forEach((issue, index) => {
-        import_consola9.consola.error(`  ${index + 1}. ${issue.path.join(".") || "root"}`);
-        import_consola9.consola.error(`     \u251C\u2500 Message: ${issue.message}`);
-        if (issue.expected) import_consola9.consola.error(`     \u251C\u2500 Expected: ${issue.expected}`);
-        if (issue.received) import_consola9.consola.error(`     \u2514\u2500 Received: ${issue.received}`);
-      });
-    }
-    import_consola9.consola.error("Response data:", response);
-    if (typeof window !== "undefined" && error instanceof Error && "issues" in error) {
-      try {
-        const event = new CustomEvent("zod-validation-error", {
-          detail: {
-            operation: "createCentrifugoServerInfoCreate",
-            path: "/cfg/centrifugo/server/info/",
-            method: "POST",
-            error,
-            response,
-            timestamp: /* @__PURE__ */ new Date()
-          },
-          bubbles: true,
-          cancelable: false
-        });
-        window.dispatchEvent(event);
-      } catch (eventError) {
-        import_consola9.consola.warn("Failed to dispatch validation error event:", eventError);
+  // Helper methods for common HTTP status codes
+  get isValidationError() {
+    return this.statusCode === 400;
+  }
+  get isAuthError() {
+    return this.statusCode === 401;
+  }
+  get isPermissionError() {
+    return this.statusCode === 403;
+  }
+  get isNotFoundError() {
+    return this.statusCode === 404;
+  }
+  get isServerError() {
+    return this.statusCode >= 500 && this.statusCode < 600;
+  }
+};
+var NetworkError3 = class extends Error {
+  constructor(message, url, originalError) {
+    super(message);
+    this.url = url;
+    this.originalError = originalError;
+    this.name = "NetworkError";
+  }
+  static {
+    __name(this, "NetworkError");
+  }
+};
+
+// src/generated/cfg_webpush/logger.ts
+var import_consola11 = require("consola");
+var DEFAULT_CONFIG3 = {
+  enabled: process.env.NODE_ENV !== "production",
+  logRequests: true,
+  logResponses: true,
+  logErrors: true,
+  logBodies: true,
+  logHeaders: false
+};
+var SENSITIVE_HEADERS3 = [
+  "authorization",
+  "cookie",
+  "set-cookie",
+  "x-api-key",
+  "x-csrf-token"
+];
+var APILogger3 = class {
+  static {
+    __name(this, "APILogger");
+  }
+  constructor(config = {}) {
+    this.config = { ...DEFAULT_CONFIG3, ...config };
+    this.consola = config.consola || (0, import_consola11.createConsola)({
+      level: this.config.enabled ? 4 : 0
+    });
+  }
+  /**
+   * Enable logging
+   */
+  enable() {
+    this.config.enabled = true;
+  }
+  /**
+   * Disable logging
+   */
+  disable() {
+    this.config.enabled = false;
+  }
+  /**
+   * Update configuration
+   */
+  setConfig(config) {
+    this.config = { ...this.config, ...config };
+  }
+  /**
+   * Filter sensitive headers
+   */
+  filterHeaders(headers) {
+    if (!headers) return {};
+    const filtered = {};
+    Object.keys(headers).forEach((key) => {
+      const lowerKey = key.toLowerCase();
+      if (SENSITIVE_HEADERS3.includes(lowerKey)) {
+        filtered[key] = "***";
+      } else {
+        filtered[key] = headers[key] || "";
       }
-    }
-    throw error;
+    });
+    return filtered;
   }
-}
-__name(createCentrifugoServerInfoCreate, "createCentrifugoServerInfoCreate");
-async function createCentrifugoServerPresenceCreate(data, client) {
-  const api = client || getAPIInstance3();
-  const response = await api.centrifugo_admin_api.centrifugoServerPresenceCreate(data);
-  try {
-    return CentrifugoPresenceResponseSchema.parse(response);
-  } catch (error) {
-    import_consola9.consola.error("\u274C Zod Validation Failed");
-    import_consola9.consola.box(`createCentrifugoServerPresenceCreate
-Path: /cfg/centrifugo/server/presence/
-Method: POST`);
-    if (error instanceof Error && "issues" in error && Array.isArray(error.issues)) {
-      import_consola9.consola.error("Validation Issues:");
-      error.issues.forEach((issue, index) => {
-        import_consola9.consola.error(`  ${index + 1}. ${issue.path.join(".") || "root"}`);
-        import_consola9.consola.error(`     \u251C\u2500 Message: ${issue.message}`);
-        if (issue.expected) import_consola9.consola.error(`     \u251C\u2500 Expected: ${issue.expected}`);
-        if (issue.received) import_consola9.consola.error(`     \u2514\u2500 Received: ${issue.received}`);
-      });
+  /**
+   * Log request
+   */
+  logRequest(request) {
+    if (!this.config.enabled || !this.config.logRequests) return;
+    const { method, url, headers, body } = request;
+    this.consola.start(`${method} ${url}`);
+    if (this.config.logHeaders && headers) {
+      this.consola.debug("Headers:", this.filterHeaders(headers));
     }
-    import_consola9.consola.error("Response data:", response);
-    if (typeof window !== "undefined" && error instanceof Error && "issues" in error) {
-      try {
-        const event = new CustomEvent("zod-validation-error", {
-          detail: {
-            operation: "createCentrifugoServerPresenceCreate",
-            path: "/cfg/centrifugo/server/presence/",
-            method: "POST",
-            error,
-            response,
-            timestamp: /* @__PURE__ */ new Date()
-          },
-          bubbles: true,
-          cancelable: false
-        });
-        window.dispatchEvent(event);
-      } catch (eventError) {
-        import_consola9.consola.warn("Failed to dispatch validation error event:", eventError);
-      }
+    if (this.config.logBodies && body) {
+      this.consola.debug("Body:", body);
     }
-    throw error;
   }
-}
-__name(createCentrifugoServerPresenceCreate, "createCentrifugoServerPresenceCreate");
-async function createCentrifugoServerPresenceStatsCreate(data, client) {
-  const api = client || getAPIInstance3();
-  const response = await api.centrifugo_admin_api.centrifugoServerPresenceStatsCreate(data);
-  try {
-    return CentrifugoPresenceStatsResponseSchema.parse(response);
-  } catch (error) {
-    import_consola9.consola.error("\u274C Zod Validation Failed");
-    import_consola9.consola.box(`createCentrifugoServerPresenceStatsCreate
-Path: /cfg/centrifugo/server/presence-stats/
-Method: POST`);
-    if (error instanceof Error && "issues" in error && Array.isArray(error.issues)) {
-      import_consola9.consola.error("Validation Issues:");
-      error.issues.forEach((issue, index) => {
-        import_consola9.consola.error(`  ${index + 1}. ${issue.path.join(".") || "root"}`);
-        import_consola9.consola.error(`     \u251C\u2500 Message: ${issue.message}`);
-        if (issue.expected) import_consola9.consola.error(`     \u251C\u2500 Expected: ${issue.expected}`);
-        if (issue.received) import_consola9.consola.error(`     \u2514\u2500 Received: ${issue.received}`);
-      });
+  /**
+   * Log response
+   */
+  logResponse(request, response) {
+    if (!this.config.enabled || !this.config.logResponses) return;
+    const { method, url } = request;
+    const { status, statusText, data, duration } = response;
+    const statusColor = status >= 500 ? "red" : status >= 400 ? "yellow" : status >= 300 ? "cyan" : "green";
+    this.consola.success(
+      `${method} ${url} ${status} ${statusText} (${duration}ms)`
+    );
+    if (this.config.logBodies && data) {
+      this.consola.debug("Response:", data);
     }
-    import_consola9.consola.error("Response data:", response);
-    if (typeof window !== "undefined" && error instanceof Error && "issues" in error) {
-      try {
-        const event = new CustomEvent("zod-validation-error", {
-          detail: {
-            operation: "createCentrifugoServerPresenceStatsCreate",
-            path: "/cfg/centrifugo/server/presence-stats/",
-            method: "POST",
-            error,
-            response,
-            timestamp: /* @__PURE__ */ new Date()
-          },
-          bubbles: true,
-          cancelable: false
+  }
+  /**
+   * Log error
+   */
+  logError(request, error) {
+    if (!this.config.enabled || !this.config.logErrors) return;
+    const { method, url } = request;
+    const { message, statusCode, fieldErrors, duration } = error;
+    this.consola.error(
+      `${method} ${url} ${statusCode || "Network"} Error (${duration}ms)`
+    );
+    this.consola.error("Message:", message);
+    if (fieldErrors && Object.keys(fieldErrors).length > 0) {
+      this.consola.error("Field Errors:");
+      Object.entries(fieldErrors).forEach(([field, errors]) => {
+        errors.forEach((err) => {
+          this.consola.error(`  \u2022 ${field}: ${err}`);
         });
-        window.dispatchEvent(event);
-      } catch (eventError) {
-        import_consola9.consola.warn("Failed to dispatch validation error event:", eventError);
-      }
+      });
     }
-    throw error;
   }
-}
-__name(createCentrifugoServerPresenceStatsCreate, "createCentrifugoServerPresenceStatsCreate");
+  /**
+   * Log general info
+   */
+  info(message, ...args) {
+    if (!this.config.enabled) return;
+    this.consola.info(message, ...args);
+  }
+  /**
+   * Log warning
+   */
+  warn(message, ...args) {
+    if (!this.config.enabled) return;
+    this.consola.warn(message, ...args);
+  }
+  /**
+   * Log error
+   */
+  error(message, ...args) {
+    if (!this.config.enabled) return;
+    this.consola.error(message, ...args);
+  }
+  /**
+   * Log debug
+   */
+  debug(message, ...args) {
+    if (!this.config.enabled) return;
+    this.consola.debug(message, ...args);
+  }
+  /**
+   * Log success
+   */
+  success(message, ...args) {
+    if (!this.config.enabled) return;
+    this.consola.success(message, ...args);
+  }
+  /**
+   * Create a sub-logger with prefix
+   */
+  withTag(tag) {
+    return this.consola.withTag(tag);
+  }
+};
+var defaultLogger3 = new APILogger3();
 
-// src/generated/cfg_centrifugo/_utils/fetchers/centrifugo__centrifugo_auth.ts
-var import_consola10 = require("consola");
-async function getCentrifugoAuthTokenRetrieve(client) {
-  const api = client || getAPIInstance3();
-  const response = await api.centrifugo_auth.tokenRetrieve();
-  try {
-    return ConnectionTokenResponseSchema.parse(response);
-  } catch (error) {
-    import_consola10.consola.error("\u274C Zod Validation Failed");
-    import_consola10.consola.box(`getCentrifugoAuthTokenRetrieve
-Path: /cfg/centrifugo/auth/token/
-Method: GET`);
-    if (error instanceof Error && "issues" in error && Array.isArray(error.issues)) {
-      import_consola10.consola.error("Validation Issues:");
-      error.issues.forEach((issue, index) => {
-        import_consola10.consola.error(`  ${index + 1}. ${issue.path.join(".") || "root"}`);
-        import_consola10.consola.error(`     \u251C\u2500 Message: ${issue.message}`);
-        if (issue.expected) import_consola10.consola.error(`     \u251C\u2500 Expected: ${issue.expected}`);
-        if (issue.received) import_consola10.consola.error(`     \u2514\u2500 Received: ${issue.received}`);
-      });
+// src/generated/cfg_webpush/retry.ts
+var import_p_retry3 = __toESM(require("p-retry"), 1);
+var DEFAULT_RETRY_CONFIG3 = {
+  retries: 3,
+  factor: 2,
+  minTimeout: 1e3,
+  maxTimeout: 6e4,
+  randomize: true,
+  onFailedAttempt: /* @__PURE__ */ __name(() => {
+  }, "onFailedAttempt")
+};
+function shouldRetry3(error) {
+  if (error instanceof NetworkError3) {
+    return true;
+  }
+  if (error instanceof APIError3) {
+    const status = error.statusCode;
+    if (status >= 500 && status < 600) {
+      return true;
     }
-    import_consola10.consola.error("Response data:", response);
-    if (typeof window !== "undefined" && error instanceof Error && "issues" in error) {
+    if (status === 429) {
+      return true;
+    }
+    return false;
+  }
+  return true;
+}
+__name(shouldRetry3, "shouldRetry");
+async function withRetry3(fn, config) {
+  const finalConfig = { ...DEFAULT_RETRY_CONFIG3, ...config };
+  return (0, import_p_retry3.default)(
+    async () => {
       try {
-        const event = new CustomEvent("zod-validation-error", {
-          detail: {
-            operation: "getCentrifugoAuthTokenRetrieve",
-            path: "/cfg/centrifugo/auth/token/",
-            method: "GET",
-            error,
-            response,
-            timestamp: /* @__PURE__ */ new Date()
-          },
-          bubbles: true,
-          cancelable: false
-        });
-        window.dispatchEvent(event);
-      } catch (eventError) {
-        import_consola10.consola.warn("Failed to dispatch validation error event:", eventError);
+        return await fn();
+      } catch (error) {
+        if (!shouldRetry3(error)) {
+          throw new import_p_retry3.AbortError(error);
+        }
+        throw error;
       }
+    },
+    {
+      retries: finalConfig.retries,
+      factor: finalConfig.factor,
+      minTimeout: finalConfig.minTimeout,
+      maxTimeout: finalConfig.maxTimeout,
+      randomize: finalConfig.randomize,
+      onFailedAttempt: finalConfig.onFailedAttempt ? (error) => {
+        const pRetryError = error;
+        finalConfig.onFailedAttempt({
+          error: pRetryError,
+          attemptNumber: pRetryError.attemptNumber,
+          retriesLeft: pRetryError.retriesLeft
+        });
+      } : void 0
     }
-    throw error;
-  }
+  );
 }
-__name(getCentrifugoAuthTokenRetrieve, "getCentrifugoAuthTokenRetrieve");
+__name(withRetry3, "withRetry");
 
-// src/generated/cfg_centrifugo/_utils/fetchers/centrifugo__centrifugo_monitoring.ts
-var import_consola11 = require("consola");
-async function getCentrifugoMonitorChannelsRetrieve(params, client) {
-  const api = client || getAPIInstance3();
-  const response = await api.centrifugo_monitoring.centrifugoMonitorChannelsRetrieve(params?.hours);
-  try {
-    return ChannelListSchema.parse(response);
-  } catch (error) {
-    import_consola11.consola.error("\u274C Zod Validation Failed");
-    import_consola11.consola.box(`getCentrifugoMonitorChannelsRetrieve
-Path: /cfg/centrifugo/monitor/channels/
-Method: GET`);
-    if (error instanceof Error && "issues" in error && Array.isArray(error.issues)) {
-      import_consola11.consola.error("Validation Issues:");
-      error.issues.forEach((issue, index) => {
-        import_consola11.consola.error(`  ${index + 1}. ${issue.path.join(".") || "root"}`);
-        import_consola11.consola.error(`     \u251C\u2500 Message: ${issue.message}`);
-        if (issue.expected) import_consola11.consola.error(`     \u251C\u2500 Expected: ${issue.expected}`);
-        if (issue.received) import_consola11.consola.error(`     \u2514\u2500 Received: ${issue.received}`);
-      });
+// src/generated/cfg_webpush/client.ts
+var APIClient3 = class {
+  constructor(baseUrl, options) {
+    this.logger = null;
+    this.retryConfig = null;
+    this.baseUrl = baseUrl.replace(/\/$/, "");
+    this.httpClient = options?.httpClient || new FetchAdapter3();
+    if (options?.loggerConfig !== void 0) {
+      this.logger = new APILogger3(options.loggerConfig);
     }
-    import_consola11.consola.error("Response data:", response);
-    if (typeof window !== "undefined" && error instanceof Error && "issues" in error) {
-      try {
-        const event = new CustomEvent("zod-validation-error", {
-          detail: {
-            operation: "getCentrifugoMonitorChannelsRetrieve",
-            path: "/cfg/centrifugo/monitor/channels/",
-            method: "GET",
-            error,
-            response,
-            timestamp: /* @__PURE__ */ new Date()
-          },
-          bubbles: true,
-          cancelable: false
-        });
-        window.dispatchEvent(event);
-      } catch (eventError) {
-        import_consola11.consola.warn("Failed to dispatch validation error event:", eventError);
-      }
+    if (options?.retryConfig !== void 0) {
+      this.retryConfig = options.retryConfig;
     }
-    throw error;
+    this.web_push = new WebPush(this);
   }
-}
-__name(getCentrifugoMonitorChannelsRetrieve, "getCentrifugoMonitorChannelsRetrieve");
-async function getCentrifugoMonitorHealthRetrieve(client) {
-  const api = client || getAPIInstance3();
-  const response = await api.centrifugo_monitoring.centrifugoMonitorHealthRetrieve();
-  try {
-    return CentrifugoHealthCheckSchema.parse(response);
-  } catch (error) {
-    import_consola11.consola.error("\u274C Zod Validation Failed");
-    import_consola11.consola.box(`getCentrifugoMonitorHealthRetrieve
-Path: /cfg/centrifugo/monitor/health/
-Method: GET`);
-    if (error instanceof Error && "issues" in error && Array.isArray(error.issues)) {
-      import_consola11.consola.error("Validation Issues:");
-      error.issues.forEach((issue, index) => {
-        import_consola11.consola.error(`  ${index + 1}. ${issue.path.join(".") || "root"}`);
-        import_consola11.consola.error(`     \u251C\u2500 Message: ${issue.message}`);
-        if (issue.expected) import_consola11.consola.error(`     \u251C\u2500 Expected: ${issue.expected}`);
-        if (issue.received) import_consola11.consola.error(`     \u2514\u2500 Received: ${issue.received}`);
+  static {
+    __name(this, "APIClient");
+  }
+  /**
+   * Get CSRF token from cookies (for SessionAuthentication).
+   *
+   * Returns null if cookie doesn't exist (JWT-only auth).
+   */
+  getCsrfToken() {
+    const name = "csrftoken";
+    const value = `; ${document.cookie}`;
+    const parts = value.split(`; ${name}=`);
+    if (parts.length === 2) {
+      return parts.pop()?.split(";").shift() || null;
+    }
+    return null;
+  }
+  /**
+   * Make HTTP request with Django CSRF and session handling.
+   * Automatically retries on network errors and 5xx server errors.
+   */
+  async request(method, path, options) {
+    if (this.retryConfig) {
+      return withRetry3(() => this._makeRequest(method, path, options), {
+        ...this.retryConfig,
+        onFailedAttempt: /* @__PURE__ */ __name((info) => {
+          if (this.logger) {
+            this.logger.warn(
+              `Retry attempt ${info.attemptNumber}/${info.retriesLeft + info.attemptNumber} for ${method} ${path}: ${info.error.message}`
+            );
+          }
+          this.retryConfig?.onFailedAttempt?.(info);
+        }, "onFailedAttempt")
       });
     }
-    import_consola11.consola.error("Response data:", response);
-    if (typeof window !== "undefined" && error instanceof Error && "issues" in error) {
-      try {
-        const event = new CustomEvent("zod-validation-error", {
-          detail: {
-            operation: "getCentrifugoMonitorHealthRetrieve",
-            path: "/cfg/centrifugo/monitor/health/",
-            method: "GET",
-            error,
-            response,
-            timestamp: /* @__PURE__ */ new Date()
+    return this._makeRequest(method, path, options);
+  }
+  /**
+   * Internal request method (without retry wrapper).
+   * Used by request() method with optional retry logic.
+   */
+  async _makeRequest(method, path, options) {
+    const url = this.baseUrl ? `${this.baseUrl}${path}` : path;
+    const startTime = Date.now();
+    const headers = {
+      ...options?.headers || {}
+    };
+    if (!options?.formData && !headers["Content-Type"]) {
+      headers["Content-Type"] = "application/json";
+    }
+    if (this.logger) {
+      this.logger.logRequest({
+        method,
+        url,
+        headers,
+        body: options?.formData || options?.body,
+        timestamp: startTime
+      });
+    }
+    try {
+      const response = await this.httpClient.request({
+        method,
+        url,
+        headers,
+        params: options?.params,
+        body: options?.body,
+        formData: options?.formData
+      });
+      const duration = Date.now() - startTime;
+      if (response.status >= 400) {
+        const error = new APIError3(
+          response.status,
+          response.statusText,
+          response.data,
+          url
+        );
+        if (this.logger) {
+          this.logger.logError(
+            {
+              method,
+              url,
+              headers,
+              body: options?.formData || options?.body,
+              timestamp: startTime
+            },
+            {
+              message: error.message,
+              statusCode: response.status,
+              duration,
+              timestamp: Date.now()
+            }
+          );
+        }
+        throw error;
+      }
+      if (this.logger) {
+        this.logger.logResponse(
+          {
+            method,
+            url,
+            headers,
+            body: options?.formData || options?.body,
+            timestamp: startTime
           },
-          bubbles: true,
-          cancelable: false
-        });
-        window.dispatchEvent(event);
-      } catch (eventError) {
-        import_consola11.consola.warn("Failed to dispatch validation error event:", eventError);
+          {
+            status: response.status,
+            statusText: response.statusText,
+            data: response.data,
+            duration,
+            timestamp: Date.now()
+          }
+        );
+      }
+      return response.data;
+    } catch (error) {
+      const duration = Date.now() - startTime;
+      if (error instanceof APIError3) {
+        throw error;
+      }
+      const isCORSError = error instanceof TypeError && (error.message.toLowerCase().includes("cors") || error.message.toLowerCase().includes("failed to fetch") || error.message.toLowerCase().includes("network request failed"));
+      if (this.logger) {
+        if (isCORSError) {
+          this.logger.error(`\u{1F6AB} CORS Error: ${method} ${url}`);
+          this.logger.error(`  \u2192 ${error instanceof Error ? error.message : String(error)}`);
+          this.logger.error(`  \u2192 Configure security_domains parameter on the server`);
+        } else {
+          this.logger.error(`\u26A0\uFE0F  Network Error: ${method} ${url}`);
+          this.logger.error(`  \u2192 ${error instanceof Error ? error.message : String(error)}`);
+        }
+      }
+      if (typeof window !== "undefined") {
+        try {
+          if (isCORSError) {
+            window.dispatchEvent(new CustomEvent("cors-error", {
+              detail: {
+                url,
+                method,
+                error: error instanceof Error ? error.message : String(error),
+                timestamp: /* @__PURE__ */ new Date()
+              },
+              bubbles: true,
+              cancelable: false
+            }));
+          } else {
+            window.dispatchEvent(new CustomEvent("network-error", {
+              detail: {
+                url,
+                method,
+                error: error instanceof Error ? error.message : String(error),
+                timestamp: /* @__PURE__ */ new Date()
+              },
+              bubbles: true,
+              cancelable: false
+            }));
+          }
+        } catch (eventError) {
+        }
+      }
+      const networkError = error instanceof Error ? new NetworkError3(error.message, url, error) : new NetworkError3("Unknown error", url);
+      if (this.logger) {
+        this.logger.logError(
+          {
+            method,
+            url,
+            headers,
+            body: options?.formData || options?.body,
+            timestamp: startTime
+          },
+          {
+            message: networkError.message,
+            duration,
+            timestamp: Date.now()
+          }
+        );
       }
+      throw networkError;
     }
-    throw error;
   }
-}
-__name(getCentrifugoMonitorHealthRetrieve, "getCentrifugoMonitorHealthRetrieve");
-async function getCentrifugoMonitorOverviewRetrieve(params, client) {
-  const api = client || getAPIInstance3();
-  const response = await api.centrifugo_monitoring.centrifugoMonitorOverviewRetrieve(params?.hours);
-  try {
-    return CentrifugoOverviewStatsSchema.parse(response);
-  } catch (error) {
-    import_consola11.consola.error("\u274C Zod Validation Failed");
-    import_consola11.consola.box(`getCentrifugoMonitorOverviewRetrieve
-Path: /cfg/centrifugo/monitor/overview/
-Method: GET`);
-    if (error instanceof Error && "issues" in error && Array.isArray(error.issues)) {
-      import_consola11.consola.error("Validation Issues:");
-      error.issues.forEach((issue, index) => {
-        import_consola11.consola.error(`  ${index + 1}. ${issue.path.join(".") || "root"}`);
-        import_consola11.consola.error(`     \u251C\u2500 Message: ${issue.message}`);
-        if (issue.expected) import_consola11.consola.error(`     \u251C\u2500 Expected: ${issue.expected}`);
-        if (issue.received) import_consola11.consola.error(`     \u2514\u2500 Received: ${issue.received}`);
-      });
-    }
-    import_consola11.consola.error("Response data:", response);
-    if (typeof window !== "undefined" && error instanceof Error && "issues" in error) {
-      try {
-        const event = new CustomEvent("zod-validation-error", {
-          detail: {
-            operation: "getCentrifugoMonitorOverviewRetrieve",
-            path: "/cfg/centrifugo/monitor/overview/",
-            method: "GET",
-            error,
-            response,
-            timestamp: /* @__PURE__ */ new Date()
-          },
-          bubbles: true,
-          cancelable: false
-        });
-        window.dispatchEvent(event);
-      } catch (eventError) {
-        import_consola11.consola.warn("Failed to dispatch validation error event:", eventError);
+};
+
+// src/generated/cfg_webpush/storage.ts
+var LocalStorageAdapter3 = class {
+  static {
+    __name(this, "LocalStorageAdapter");
+  }
+  constructor(logger) {
+    this.logger = logger;
+  }
+  getItem(key) {
+    try {
+      if (typeof window !== "undefined" && window.localStorage) {
+        const value = localStorage.getItem(key);
+        this.logger?.debug(`LocalStorage.getItem("${key}"): ${value ? "found" : "not found"}`);
+        return value;
       }
+      this.logger?.warn("LocalStorage not available: window.localStorage is undefined");
+    } catch (error) {
+      this.logger?.error("LocalStorage.getItem failed:", error);
     }
-    throw error;
+    return null;
   }
-}
-__name(getCentrifugoMonitorOverviewRetrieve, "getCentrifugoMonitorOverviewRetrieve");
-async function getCentrifugoMonitorPublishesList(params, client) {
-  const api = client || getAPIInstance3();
-  const response = await api.centrifugo_monitoring.centrifugoMonitorPublishesList(params?.channel, params?.page, params?.page_size, params?.status);
-  try {
-    return PaginatedPublishListSchema.parse(response);
-  } catch (error) {
-    import_consola11.consola.error("\u274C Zod Validation Failed");
-    import_consola11.consola.box(`getCentrifugoMonitorPublishesList
-Path: /cfg/centrifugo/monitor/publishes/
-Method: GET`);
-    if (error instanceof Error && "issues" in error && Array.isArray(error.issues)) {
-      import_consola11.consola.error("Validation Issues:");
-      error.issues.forEach((issue, index) => {
-        import_consola11.consola.error(`  ${index + 1}. ${issue.path.join(".") || "root"}`);
-        import_consola11.consola.error(`     \u251C\u2500 Message: ${issue.message}`);
-        if (issue.expected) import_consola11.consola.error(`     \u251C\u2500 Expected: ${issue.expected}`);
-        if (issue.received) import_consola11.consola.error(`     \u2514\u2500 Received: ${issue.received}`);
-      });
-    }
-    import_consola11.consola.error("Response data:", response);
-    if (typeof window !== "undefined" && error instanceof Error && "issues" in error) {
-      try {
-        const event = new CustomEvent("zod-validation-error", {
-          detail: {
-            operation: "getCentrifugoMonitorPublishesList",
-            path: "/cfg/centrifugo/monitor/publishes/",
-            method: "GET",
-            error,
-            response,
-            timestamp: /* @__PURE__ */ new Date()
-          },
-          bubbles: true,
-          cancelable: false
-        });
-        window.dispatchEvent(event);
-      } catch (eventError) {
-        import_consola11.consola.warn("Failed to dispatch validation error event:", eventError);
+  setItem(key, value) {
+    try {
+      if (typeof window !== "undefined" && window.localStorage) {
+        localStorage.setItem(key, value);
+        this.logger?.debug(`LocalStorage.setItem("${key}"): success`);
+      } else {
+        this.logger?.warn("LocalStorage not available: window.localStorage is undefined");
       }
+    } catch (error) {
+      this.logger?.error("LocalStorage.setItem failed:", error);
     }
-    throw error;
   }
-}
-__name(getCentrifugoMonitorPublishesList, "getCentrifugoMonitorPublishesList");
-async function getCentrifugoMonitorTimelineRetrieve(params, client) {
-  const api = client || getAPIInstance3();
-  const response = await api.centrifugo_monitoring.centrifugoMonitorTimelineRetrieve(params?.hours, params?.interval);
-  try {
-    return TimelineResponseSchema.parse(response);
-  } catch (error) {
-    import_consola11.consola.error("\u274C Zod Validation Failed");
-    import_consola11.consola.box(`getCentrifugoMonitorTimelineRetrieve
-Path: /cfg/centrifugo/monitor/timeline/
-Method: GET`);
-    if (error instanceof Error && "issues" in error && Array.isArray(error.issues)) {
-      import_consola11.consola.error("Validation Issues:");
-      error.issues.forEach((issue, index) => {
-        import_consola11.consola.error(`  ${index + 1}. ${issue.path.join(".") || "root"}`);
-        import_consola11.consola.error(`     \u251C\u2500 Message: ${issue.message}`);
-        if (issue.expected) import_consola11.consola.error(`     \u251C\u2500 Expected: ${issue.expected}`);
-        if (issue.received) import_consola11.consola.error(`     \u2514\u2500 Received: ${issue.received}`);
-      });
-    }
-    import_consola11.consola.error("Response data:", response);
-    if (typeof window !== "undefined" && error instanceof Error && "issues" in error) {
-      try {
-        const event = new CustomEvent("zod-validation-error", {
-          detail: {
-            operation: "getCentrifugoMonitorTimelineRetrieve",
-            path: "/cfg/centrifugo/monitor/timeline/",
-            method: "GET",
-            error,
-            response,
-            timestamp: /* @__PURE__ */ new Date()
-          },
-          bubbles: true,
-          cancelable: false
-        });
-        window.dispatchEvent(event);
-      } catch (eventError) {
-        import_consola11.consola.warn("Failed to dispatch validation error event:", eventError);
+  removeItem(key) {
+    try {
+      if (typeof window !== "undefined" && window.localStorage) {
+        localStorage.removeItem(key);
+        this.logger?.debug(`LocalStorage.removeItem("${key}"): success`);
+      } else {
+        this.logger?.warn("LocalStorage not available: window.localStorage is undefined");
       }
+    } catch (error) {
+      this.logger?.error("LocalStorage.removeItem failed:", error);
     }
-    throw error;
   }
-}
-__name(getCentrifugoMonitorTimelineRetrieve, "getCentrifugoMonitorTimelineRetrieve");
+};
 
-// src/generated/cfg_centrifugo/_utils/fetchers/centrifugo__centrifugo_testing.ts
+// src/generated/cfg_webpush/_utils/schemas/index.ts
+var schemas_exports3 = {};
+__export(schemas_exports3, {
+  SendPushRequestRequestSchema: () => SendPushRequestRequestSchema,
+  SendPushResponseSchema: () => SendPushResponseSchema,
+  SubscribeRequestRequestSchema: () => SubscribeRequestRequestSchema,
+  SubscribeResponseSchema: () => SubscribeResponseSchema,
+  VapidPublicKeyResponseSchema: () => VapidPublicKeyResponseSchema
+});
+
+// src/generated/cfg_webpush/_utils/schemas/SendPushRequestRequest.schema.ts
+var import_zod55 = require("zod");
+var SendPushRequestRequestSchema = import_zod55.z.object({
+  title: import_zod55.z.string().min(1).max(255),
+  body: import_zod55.z.string().min(1),
+  icon: import_zod55.z.url().nullable().optional(),
+  url: import_zod55.z.url().nullable().optional()
+});
+
+// src/generated/cfg_webpush/_utils/schemas/SendPushResponse.schema.ts
+var import_zod56 = require("zod");
+var SendPushResponseSchema = import_zod56.z.object({
+  success: import_zod56.z.boolean(),
+  sent_to: import_zod56.z.int()
+});
+
+// src/generated/cfg_webpush/_utils/schemas/SubscribeRequestRequest.schema.ts
+var import_zod57 = require("zod");
+var SubscribeRequestRequestSchema = import_zod57.z.object({
+  endpoint: import_zod57.z.url(),
+  keys: import_zod57.z.record(import_zod57.z.string(), import_zod57.z.string().min(1))
+});
+
+// src/generated/cfg_webpush/_utils/schemas/SubscribeResponse.schema.ts
+var import_zod58 = require("zod");
+var SubscribeResponseSchema = import_zod58.z.object({
+  success: import_zod58.z.boolean(),
+  subscription_id: import_zod58.z.int(),
+  created: import_zod58.z.boolean()
+});
+
+// src/generated/cfg_webpush/_utils/schemas/VapidPublicKeyResponse.schema.ts
+var import_zod59 = require("zod");
+var VapidPublicKeyResponseSchema = import_zod59.z.object({
+  publicKey: import_zod59.z.string()
+});
+
+// src/generated/cfg_webpush/_utils/fetchers/index.ts
+var fetchers_exports3 = {};
+__export(fetchers_exports3, {
+  createWebpushSendCreate: () => createWebpushSendCreate,
+  createWebpushSubscribeCreate: () => createWebpushSubscribeCreate,
+  getWebpushVapidRetrieve: () => getWebpushVapidRetrieve
+});
+
+// src/generated/cfg_webpush/_utils/fetchers/webpush__web_push.ts
 var import_consola12 = require("consola");
-async function createCentrifugoTestingPublishTestCreate(data, client) {
+
+// src/generated/cfg_webpush/api-instance.ts
+var globalAPI3 = null;
+function getAPIInstance3() {
+  if (!globalAPI3) {
+    throw new Error(
+      'API not configured. Call configureAPI() with your base URL before using fetchers or hooks.\n\nExample:\n  import { configureAPI } from "./api-instance"\n  configureAPI({ baseUrl: "https://api.example.com" })'
+    );
+  }
+  return globalAPI3;
+}
+__name(getAPIInstance3, "getAPIInstance");
+
+// src/generated/cfg_webpush/_utils/fetchers/webpush__web_push.ts
+async function createWebpushSendCreate(data, client) {
   const api = client || getAPIInstance3();
-  const response = await api.centrifugo_testing.publishTestCreate(data);
+  const response = await api.web_push.webpushSendCreate(data);
   try {
-    return PublishTestResponseSchema.parse(response);
+    return SendPushResponseSchema.parse(response);
   } catch (error) {
     import_consola12.consola.error("\u274C Zod Validation Failed");
-    import_consola12.consola.box(`createCentrifugoTestingPublishTestCreate
-Path: /cfg/centrifugo/testing/publish-test/
+    import_consola12.consola.box(`createWebpushSendCreate
+Path: /cfg/webpush/send/
 Method: POST`);
     if (error instanceof Error && "issues" in error && Array.isArray(error.issues)) {
       import_consola12.consola.error("Validation Issues:");
@@ -4414,8 +4420,8 @@ Method: POST`);
       try {
         const event = new CustomEvent("zod-validation-error", {
           detail: {
-            operation: "createCentrifugoTestingPublishTestCreate",
-            path: "/cfg/centrifugo/testing/publish-test/",
+            operation: "createWebpushSendCreate",
+            path: "/cfg/webpush/send/",
             method: "POST",
             error,
             response,
@@ -4432,16 +4438,16 @@ Method: POST`);
     throw error;
   }
 }
-__name(createCentrifugoTestingPublishTestCreate, "createCentrifugoTestingPublishTestCreate");
-async function createCentrifugoTestingPublishWithLoggingCreate(data, client) {
+__name(createWebpushSendCreate, "createWebpushSendCreate");
+async function createWebpushSubscribeCreate(data, client) {
   const api = client || getAPIInstance3();
-  const response = await api.centrifugo_testing.publishWithLoggingCreate(data);
+  const response = await api.web_push.webpushSubscribeCreate(data);
   try {
-    return PublishTestResponseSchema.parse(response);
+    return SubscribeResponseSchema.parse(response);
   } catch (error) {
     import_consola12.consola.error("\u274C Zod Validation Failed");
-    import_consola12.consola.box(`createCentrifugoTestingPublishWithLoggingCreate
-Path: /cfg/centrifugo/testing/publish-with-logging/
+    import_consola12.consola.box(`createWebpushSubscribeCreate
+Path: /cfg/webpush/subscribe/
 Method: POST`);
     if (error instanceof Error && "issues" in error && Array.isArray(error.issues)) {
       import_consola12.consola.error("Validation Issues:");
@@ -4457,8 +4463,8 @@ Method: POST`);
       try {
         const event = new CustomEvent("zod-validation-error", {
           detail: {
-            operation: "createCentrifugoTestingPublishWithLoggingCreate",
-            path: "/cfg/centrifugo/testing/publish-with-logging/",
+            operation: "createWebpushSubscribeCreate",
+            path: "/cfg/webpush/subscribe/",
             method: "POST",
             error,
             response,
@@ -4475,17 +4481,17 @@ Method: POST`);
     throw error;
   }
 }
-__name(createCentrifugoTestingPublishWithLoggingCreate, "createCentrifugoTestingPublishWithLoggingCreate");
-async function createCentrifugoTestingSendAckCreate(data, client) {
+__name(createWebpushSubscribeCreate, "createWebpushSubscribeCreate");
+async function getWebpushVapidRetrieve(client) {
   const api = client || getAPIInstance3();
-  const response = await api.centrifugo_testing.sendAckCreate(data);
+  const response = await api.web_push.webpushVapidRetrieve();
   try {
-    return ManualAckResponseSchema.parse(response);
+    return VapidPublicKeyResponseSchema.parse(response);
   } catch (error) {
     import_consola12.consola.error("\u274C Zod Validation Failed");
-    import_consola12.consola.box(`createCentrifugoTestingSendAckCreate
-Path: /cfg/centrifugo/testing/send-ack/
-Method: POST`);
+    import_consola12.consola.box(`getWebpushVapidRetrieve
+Path: /cfg/webpush/vapid/
+Method: GET`);
     if (error instanceof Error && "issues" in error && Array.isArray(error.issues)) {
       import_consola12.consola.error("Validation Issues:");
       error.issues.forEach((issue, index) => {
@@ -4500,9 +4506,9 @@ Method: POST`);
       try {
         const event = new CustomEvent("zod-validation-error", {
           detail: {
-            operation: "createCentrifugoTestingSendAckCreate",
-            path: "/cfg/centrifugo/testing/send-ack/",
-            method: "POST",
+            operation: "getWebpushVapidRetrieve",
+            path: "/cfg/webpush/vapid/",
+            method: "GET",
             error,
             response,
             timestamp: /* @__PURE__ */ new Date()
@@ -4518,9 +4524,9 @@ Method: POST`);
     throw error;
   }
 }
-__name(createCentrifugoTestingSendAckCreate, "createCentrifugoTestingSendAckCreate");
+__name(getWebpushVapidRetrieve, "getWebpushVapidRetrieve");
 
-// src/generated/cfg_centrifugo/index.ts
+// src/generated/cfg_webpush/index.ts
 var TOKEN_KEY3 = "auth_token";
 var REFRESH_TOKEN_KEY3 = "refresh_token";
 var API3 = class {
@@ -4537,10 +4543,7 @@ var API3 = class {
       loggerConfig: this.options?.loggerConfig
     });
     this._injectAuthHeader();
-    this.centrifugo_admin_api = this._client.centrifugo_admin_api;
-    this.centrifugo_auth = this._client.centrifugo_auth;
-    this.centrifugo_monitoring = this._client.centrifugo_monitoring;
-    this.centrifugo_testing = this._client.centrifugo_testing;
+    this.web_push = this._client.web_push;
   }
   static {
     __name(this, "API");
@@ -4555,10 +4558,7 @@ var API3 = class {
       loggerConfig: this.options?.loggerConfig
     });
     this._injectAuthHeader();
-    this.centrifugo_admin_api = this._client.centrifugo_admin_api;
-    this.centrifugo_auth = this._client.centrifugo_auth;
-    this.centrifugo_monitoring = this._client.centrifugo_monitoring;
-    this.centrifugo_testing = this._client.centrifugo_testing;
+    this.web_push = this._client.web_push;
   }
   _injectAuthHeader() {
     const originalRequest = this._client.request.bind(this._client);
@@ -4978,6 +4978,6 @@ var isStaticBuild = process.env.NEXT_PUBLIC_STATIC_BUILD === "true";
 var apiUrl = isStaticBuild ? "" : process.env.NEXT_PUBLIC_API_URL || "";
 var storage = new LocalStorageAdapter();
 var apiAccounts = new API(apiUrl, { storage });
-var apiWebPush = new API2(apiUrl, { storage });
-var apiCentrifugo = new API3(apiUrl, { storage });
+var apiWebPush = new API3(apiUrl, { storage });
+var apiCentrifugo = new API2(apiUrl, { storage });
 //# sourceMappingURL=clients.cjs.map