@djangocfg/api 2.1.36 → 2.1.37

package/dist/clients.mjs

@@ -0,0 +1,4957 @@
+var __defProp = Object.defineProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+
+// src/generated/cfg_accounts/accounts__auth/client.ts
+var Auth = class {
+  static {
+    __name(this, "Auth");
+  }
+  constructor(client) {
+    this.client = client;
+  }
+  /**
+   * Refresh JWT token.
+   */
+  async accountsTokenRefreshCreate(data) {
+    const response = await this.client.request("POST", "/cfg/accounts/token/refresh/", { body: data });
+    return response;
+  }
+};
+
+// src/generated/cfg_accounts/accounts__oauth/client.ts
+var Oauth = class {
+  static {
+    __name(this, "Oauth");
+  }
+  constructor(client) {
+    this.client = client;
+  }
+  /**
+   * List OAuth connections
+   * 
+   * Get all OAuth connections for the current user.
+   */
+  async accountsOauthConnectionsList() {
+    const response = await this.client.request("GET", "/cfg/accounts/oauth/connections/");
+    return response;
+  }
+  /**
+   * Disconnect OAuth provider
+   * 
+   * Remove OAuth connection for the specified provider.
+   */
+  async accountsOauthDisconnectCreate(data) {
+    const response = await this.client.request("POST", "/cfg/accounts/oauth/disconnect/", { body: data });
+    return response;
+  }
+  /**
+   * Start GitHub OAuth
+   * 
+   * Generate GitHub OAuth authorization URL. Redirect user to this URL to
+   * start authentication.
+   */
+  async accountsOauthGithubAuthorizeCreate(data) {
+    const response = await this.client.request("POST", "/cfg/accounts/oauth/github/authorize/", { body: data });
+    return response;
+  }
+  /**
+   * Complete GitHub OAuth
+   * 
+   * Exchange authorization code for JWT tokens. Call this after GitHub
+   * redirects back with code.
+   */
+  async accountsOauthGithubCallbackCreate(data) {
+    const response = await this.client.request("POST", "/cfg/accounts/oauth/github/callback/", { body: data });
+    return response;
+  }
+  /**
+   * List OAuth providers
+   * 
+   * Get list of available OAuth providers for authentication.
+   */
+  async accountsOauthProvidersRetrieve() {
+    const response = await this.client.request("GET", "/cfg/accounts/oauth/providers/");
+    return response;
+  }
+};
+
+// src/generated/cfg_accounts/accounts__user_profile/client.ts
+var UserProfile = class {
+  static {
+    __name(this, "UserProfile");
+  }
+  constructor(client) {
+    this.client = client;
+  }
+  /**
+   * Get current user profile
+   * 
+   * Retrieve the current authenticated user's profile information.
+   */
+  async accountsProfileRetrieve() {
+    const response = await this.client.request("GET", "/cfg/accounts/profile/");
+    return response;
+  }
+  /**
+   * Upload user avatar
+   * 
+   * Upload avatar image for the current authenticated user. Accepts
+   * multipart/form-data with 'avatar' field.
+   */
+  async accountsProfileAvatarCreate(data) {
+    const response = await this.client.request("POST", "/cfg/accounts/profile/avatar/", { formData: data });
+    return response;
+  }
+  /**
+   * Partial update user profile
+   * 
+   * Partially update the current authenticated user's profile information.
+   * Supports avatar upload.
+   */
+  async accountsProfilePartialUpdate(data) {
+    const response = await this.client.request("PUT", "/cfg/accounts/profile/partial/", { body: data });
+    return response;
+  }
+  /**
+   * Partial update user profile
+   * 
+   * Partially update the current authenticated user's profile information.
+   * Supports avatar upload.
+   */
+  async accountsProfilePartialPartialUpdate(data) {
+    const response = await this.client.request("PATCH", "/cfg/accounts/profile/partial/", { body: data });
+    return response;
+  }
+  /**
+   * Update user profile
+   * 
+   * Update the current authenticated user's profile information.
+   */
+  async accountsProfileUpdateUpdate(data) {
+    const response = await this.client.request("PUT", "/cfg/accounts/profile/update/", { body: data });
+    return response;
+  }
+  /**
+   * Update user profile
+   * 
+   * Update the current authenticated user's profile information.
+   */
+  async accountsProfileUpdatePartialUpdate(data) {
+    const response = await this.client.request("PATCH", "/cfg/accounts/profile/update/", { body: data });
+    return response;
+  }
+};
+
+// src/generated/cfg_accounts/accounts/client.ts
+var Accounts = class {
+  static {
+    __name(this, "Accounts");
+  }
+  constructor(client) {
+    this.client = client;
+  }
+  /**
+   * Request OTP code to email or phone.
+   */
+  async otpRequestCreate(data) {
+    const response = await this.client.request("POST", "/cfg/accounts/otp/request/", { body: data });
+    return response;
+  }
+  /**
+   * Verify OTP code and return JWT tokens.
+   */
+  async otpVerifyCreate(data) {
+    const response = await this.client.request("POST", "/cfg/accounts/otp/verify/", { body: data });
+    return response;
+  }
+};
+
+// src/generated/cfg_accounts/http.ts
+var FetchAdapter = 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));
+        }
+      });
+      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();
+    }
+    const responseHeaders = {};
+    response.headers.forEach((value, key) => {
+      responseHeaders[key] = value;
+    });
+    return {
+      data,
+      status: response.status,
+      statusText: response.statusText,
+      headers: responseHeaders
+    };
+  }
+};
+
+// src/generated/cfg_accounts/errors.ts
+var APIError = 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;
+    }
+    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;
+      }
+    }
+    return Object.keys(fieldErrors).length > 0 ? fieldErrors : null;
+  }
+  /**
+   * 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);
+    }
+    const fieldErrors = this.fieldErrors;
+    if (fieldErrors) {
+      const firstField = Object.keys(fieldErrors)[0];
+      if (firstField) {
+        return `${firstField}: ${fieldErrors[firstField]?.join(", ")}`;
+      }
+    }
+    return this.message;
+  }
+  // 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 NetworkError = 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_accounts/logger.ts
+import { createConsola } from "consola";
+var DEFAULT_CONFIG = {
+  enabled: process.env.NODE_ENV !== "production",
+  logRequests: true,
+  logResponses: true,
+  logErrors: true,
+  logBodies: true,
+  logHeaders: false
+};
+var SENSITIVE_HEADERS = [
+  "authorization",
+  "cookie",
+  "set-cookie",
+  "x-api-key",
+  "x-csrf-token"
+];
+var APILogger = class {
+  static {
+    __name(this, "APILogger");
+  }
+  constructor(config = {}) {
+    this.config = { ...DEFAULT_CONFIG, ...config };
+    this.consola = config.consola || 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_HEADERS.includes(lowerKey)) {
+        filtered[key] = "***";
+      } else {
+        filtered[key] = headers[key] || "";
+      }
+    });
+    return filtered;
+  }
+  /**
+   * 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));
+    }
+    if (this.config.logBodies && body) {
+      this.consola.debug("Body:", body);
+    }
+  }
+  /**
+   * 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);
+    }
+  }
+  /**
+   * 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}`);
+        });
+      });
+    }
+  }
+  /**
+   * 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 defaultLogger = new APILogger();
+
+// src/generated/cfg_accounts/retry.ts
+import pRetry, { AbortError } from "p-retry";
+var DEFAULT_RETRY_CONFIG = {
+  retries: 3,
+  factor: 2,
+  minTimeout: 1e3,
+  maxTimeout: 6e4,
+  randomize: true,
+  onFailedAttempt: /* @__PURE__ */ __name(() => {
+  }, "onFailedAttempt")
+};
+function shouldRetry(error) {
+  if (error instanceof NetworkError) {
+    return true;
+  }
+  if (error instanceof APIError) {
+    const status = error.statusCode;
+    if (status >= 500 && status < 600) {
+      return true;
+    }
+    if (status === 429) {
+      return true;
+    }
+    return false;
+  }
+  return true;
+}
+__name(shouldRetry, "shouldRetry");
+async function withRetry(fn, config) {
+  const finalConfig = { ...DEFAULT_RETRY_CONFIG, ...config };
+  return pRetry(
+    async () => {
+      try {
+        return await fn();
+      } catch (error) {
+        if (!shouldRetry(error)) {
+          throw new 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
+    }
+  );
+}
+__name(withRetry, "withRetry");
+
+// src/generated/cfg_accounts/client.ts
+var APIClient = class {
+  constructor(baseUrl, options) {
+    this.logger = null;
+    this.retryConfig = null;
+    this.baseUrl = baseUrl.replace(/\/$/, "");
+    this.httpClient = options?.httpClient || new FetchAdapter();
+    if (options?.loggerConfig !== void 0) {
+      this.logger = new APILogger(options.loggerConfig);
+    }
+    if (options?.retryConfig !== void 0) {
+      this.retryConfig = options.retryConfig;
+    }
+    this.auth = new Auth(this);
+    this.oauth = new Oauth(this);
+    this.user_profile = new UserProfile(this);
+    this.accounts = new Accounts(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;
+    }
+    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 withRetry(() => 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 APIError(
+          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 APIError) {
+        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 NetworkError(error.message, url, error) : new NetworkError("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_accounts/storage.ts
+var LocalStorageAdapter = 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_accounts/enums.ts
+var enums_exports = {};
+__export(enums_exports, {
+  OAuthConnectionProvider: () => OAuthConnectionProvider,
+  OAuthDisconnectRequestRequestProvider: () => OAuthDisconnectRequestRequestProvider,
+  OTPRequestRequestChannel: () => OTPRequestRequestChannel,
+  OTPVerifyRequestChannel: () => OTPVerifyRequestChannel
+});
+var OAuthConnectionProvider = /* @__PURE__ */ ((OAuthConnectionProvider2) => {
+  OAuthConnectionProvider2["GITHUB"] = "github";
+  return OAuthConnectionProvider2;
+})(OAuthConnectionProvider || {});
+var OAuthDisconnectRequestRequestProvider = /* @__PURE__ */ ((OAuthDisconnectRequestRequestProvider2) => {
+  OAuthDisconnectRequestRequestProvider2["GITHUB"] = "github";
+  return OAuthDisconnectRequestRequestProvider2;
+})(OAuthDisconnectRequestRequestProvider || {});
+var OTPRequestRequestChannel = /* @__PURE__ */ ((OTPRequestRequestChannel2) => {
+  OTPRequestRequestChannel2["EMAIL"] = "email";
+  OTPRequestRequestChannel2["PHONE"] = "phone";
+  return OTPRequestRequestChannel2;
+})(OTPRequestRequestChannel || {});
+var OTPVerifyRequestChannel = /* @__PURE__ */ ((OTPVerifyRequestChannel2) => {
+  OTPVerifyRequestChannel2["EMAIL"] = "email";
+  OTPVerifyRequestChannel2["PHONE"] = "phone";
+  return OTPVerifyRequestChannel2;
+})(OTPVerifyRequestChannel || {});
+
+// src/generated/cfg_accounts/_utils/schemas/CentrifugoToken.schema.ts
+import { z } from "zod";
+var CentrifugoTokenSchema = z.object({
+  token: z.string(),
+  centrifugo_url: z.url(),
+  expires_at: z.iso.datetime(),
+  channels: z.array(z.string())
+});
+
+// src/generated/cfg_accounts/_utils/schemas/OAuthAuthorizeRequestRequest.schema.ts
+import { z as z2 } from "zod";
+var OAuthAuthorizeRequestRequestSchema = z2.object({
+  redirect_uri: z2.url().optional(),
+  source_url: z2.url().optional()
+});
+
+// src/generated/cfg_accounts/_utils/schemas/OAuthAuthorizeResponse.schema.ts
+import { z as z3 } from "zod";
+var OAuthAuthorizeResponseSchema = z3.object({
+  authorization_url: z3.url(),
+  state: z3.string()
+});
+
+// src/generated/cfg_accounts/_utils/schemas/OAuthCallbackRequestRequest.schema.ts
+import { z as z4 } from "zod";
+var OAuthCallbackRequestRequestSchema = z4.object({
+  code: z4.string().min(10).max(500),
+  state: z4.string().min(20).max(100),
+  redirect_uri: z4.url().optional()
+});
+
+// src/generated/cfg_accounts/_utils/schemas/OAuthConnection.schema.ts
+import { z as z5 } from "zod";
+var OAuthConnectionSchema = z5.object({
+  id: z5.int(),
+  provider: z5.nativeEnum(OAuthConnectionProvider),
+  provider_display: z5.string(),
+  provider_username: z5.string(),
+  provider_email: z5.email(),
+  provider_avatar_url: z5.url(),
+  connected_at: z5.iso.datetime(),
+  last_login_at: z5.iso.datetime()
+});
+
+// src/generated/cfg_accounts/_utils/schemas/OAuthDisconnectRequestRequest.schema.ts
+import { z as z6 } from "zod";
+var OAuthDisconnectRequestRequestSchema = z6.object({
+  provider: z6.nativeEnum(OAuthDisconnectRequestRequestProvider)
+});
+
+// src/generated/cfg_accounts/_utils/schemas/OAuthError.schema.ts
+import { z as z7 } from "zod";
+var OAuthErrorSchema = z7.object({
+  error: z7.string(),
+  error_description: z7.string().optional()
+});
+
+// src/generated/cfg_accounts/_utils/schemas/OAuthProvidersResponse.schema.ts
+import { z as z8 } from "zod";
+var OAuthProvidersResponseSchema = z8.object({
+  providers: z8.array(z8.record(z8.string(), z8.record(z8.string(), z8.any())))
+});
+
+// src/generated/cfg_accounts/_utils/schemas/OAuthTokenResponse.schema.ts
+import { z as z9 } from "zod";
+var OAuthTokenResponseSchema = z9.object({
+  access: z9.string(),
+  refresh: z9.string(),
+  user: z9.record(z9.string(), z9.record(z9.string(), z9.any())),
+  is_new_user: z9.boolean(),
+  is_new_connection: z9.boolean()
+});
+
+// src/generated/cfg_accounts/_utils/schemas/OTPErrorResponse.schema.ts
+import { z as z10 } from "zod";
+var OTPErrorResponseSchema = z10.object({
+  error: z10.string()
+});
+
+// src/generated/cfg_accounts/_utils/schemas/OTPRequestRequest.schema.ts
+import { z as z11 } from "zod";
+var OTPRequestRequestSchema = z11.object({
+  identifier: z11.string().min(1),
+  channel: z11.nativeEnum(OTPRequestRequestChannel).optional(),
+  source_url: z11.url().optional()
+});
+
+// src/generated/cfg_accounts/_utils/schemas/OTPRequestResponse.schema.ts
+import { z as z12 } from "zod";
+var OTPRequestResponseSchema = z12.object({
+  message: z12.string()
+});
+
+// src/generated/cfg_accounts/_utils/schemas/OTPVerifyRequest.schema.ts
+import { z as z13 } from "zod";
+var OTPVerifyRequestSchema = z13.object({
+  identifier: z13.string().min(1),
+  otp: z13.string().min(6).max(6),
+  channel: z13.nativeEnum(OTPVerifyRequestChannel).optional(),
+  source_url: z13.url().optional()
+});
+
+// src/generated/cfg_accounts/_utils/schemas/OTPVerifyResponse.schema.ts
+import { z as z15 } from "zod";
+
+// src/generated/cfg_accounts/_utils/schemas/User.schema.ts
+import { z as z14 } from "zod";
+var UserSchema = z14.object({
+  id: z14.int(),
+  email: z14.email(),
+  first_name: z14.string().max(50).optional(),
+  last_name: z14.string().max(50).optional(),
+  full_name: z14.string(),
+  initials: z14.string(),
+  display_username: z14.string(),
+  company: z14.string().max(100).optional(),
+  phone: z14.string().max(20).optional(),
+  position: z14.string().max(100).optional(),
+  avatar: z14.url().nullable(),
+  is_staff: z14.boolean(),
+  is_superuser: z14.boolean(),
+  date_joined: z14.iso.datetime(),
+  last_login: z14.iso.datetime().nullable(),
+  unanswered_messages_count: z14.int(),
+  centrifugo: CentrifugoTokenSchema.nullable()
+});
+
+// src/generated/cfg_accounts/_utils/schemas/OTPVerifyResponse.schema.ts
+var OTPVerifyResponseSchema = z15.object({
+  refresh: z15.string(),
+  access: z15.string(),
+  user: UserSchema
+});
+
+// src/generated/cfg_accounts/_utils/schemas/PatchedUserProfileUpdateRequest.schema.ts
+import { z as z16 } from "zod";
+var PatchedUserProfileUpdateRequestSchema = z16.object({
+  first_name: z16.string().max(50).optional(),
+  last_name: z16.string().max(50).optional(),
+  company: z16.string().max(100).optional(),
+  phone: z16.string().max(20).optional(),
+  position: z16.string().max(100).optional()
+});
+
+// src/generated/cfg_accounts/_utils/schemas/TokenRefresh.schema.ts
+import { z as z17 } from "zod";
+var TokenRefreshSchema = z17.object({
+  access: z17.string(),
+  refresh: z17.string()
+});
+
+// src/generated/cfg_accounts/_utils/schemas/TokenRefreshRequest.schema.ts
+import { z as z18 } from "zod";
+var TokenRefreshRequestSchema = z18.object({
+  refresh: z18.string().min(1)
+});
+
+// src/generated/cfg_accounts/_utils/schemas/UserProfileUpdateRequest.schema.ts
+import { z as z19 } from "zod";
+var UserProfileUpdateRequestSchema = z19.object({
+  first_name: z19.string().max(50).optional(),
+  last_name: z19.string().max(50).optional(),
+  company: z19.string().max(100).optional(),
+  phone: z19.string().max(20).optional(),
+  position: z19.string().max(100).optional()
+});
+
+// src/generated/cfg_accounts/_utils/fetchers/accounts.ts
+import { consola } from "consola";
+
+// src/generated/cfg_accounts/api-instance.ts
+var globalAPI = null;
+function getAPIInstance() {
+  if (!globalAPI) {
+    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 globalAPI;
+}
+__name(getAPIInstance, "getAPIInstance");
+
+// src/generated/cfg_accounts/_utils/fetchers/accounts.ts
+async function createAccountsOtpRequestCreate(data, client) {
+  const api = client || getAPIInstance();
+  const response = await api.accounts.otpRequestCreate(data);
+  try {
+    return OTPRequestResponseSchema.parse(response);
+  } catch (error) {
+    consola.error("\u274C Zod Validation Failed");
+    consola.box(`createAccountsOtpRequestCreate
+Path: /cfg/accounts/otp/request/
+Method: POST`);
+    if (error instanceof Error && "issues" in error && Array.isArray(error.issues)) {
+      consola.error("Validation Issues:");
+      error.issues.forEach((issue, index) => {
+        consola.error(`  ${index + 1}. ${issue.path.join(".") || "root"}`);
+        consola.error(`     \u251C\u2500 Message: ${issue.message}`);
+        if (issue.expected) consola.error(`     \u251C\u2500 Expected: ${issue.expected}`);
+        if (issue.received) consola.error(`     \u2514\u2500 Received: ${issue.received}`);
+      });
+    }
+    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: "createAccountsOtpRequestCreate",
+            path: "/cfg/accounts/otp/request/",
+            method: "POST",
+            error,
+            response,
+            timestamp: /* @__PURE__ */ new Date()
+          },
+          bubbles: true,
+          cancelable: false
+        });
+        window.dispatchEvent(event);
+      } catch (eventError) {
+        consola.warn("Failed to dispatch validation error event:", eventError);
+      }
+    }
+    throw error;
+  }
+}
+__name(createAccountsOtpRequestCreate, "createAccountsOtpRequestCreate");
+async function createAccountsOtpVerifyCreate(data, client) {
+  const api = client || getAPIInstance();
+  const response = await api.accounts.otpVerifyCreate(data);
+  try {
+    return OTPVerifyResponseSchema.parse(response);
+  } catch (error) {
+    consola.error("\u274C Zod Validation Failed");
+    consola.box(`createAccountsOtpVerifyCreate
+Path: /cfg/accounts/otp/verify/
+Method: POST`);
+    if (error instanceof Error && "issues" in error && Array.isArray(error.issues)) {
+      consola.error("Validation Issues:");
+      error.issues.forEach((issue, index) => {
+        consola.error(`  ${index + 1}. ${issue.path.join(".") || "root"}`);
+        consola.error(`     \u251C\u2500 Message: ${issue.message}`);
+        if (issue.expected) consola.error(`     \u251C\u2500 Expected: ${issue.expected}`);
+        if (issue.received) consola.error(`     \u2514\u2500 Received: ${issue.received}`);
+      });
+    }
+    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: "createAccountsOtpVerifyCreate",
+            path: "/cfg/accounts/otp/verify/",
+            method: "POST",
+            error,
+            response,
+            timestamp: /* @__PURE__ */ new Date()
+          },
+          bubbles: true,
+          cancelable: false
+        });
+        window.dispatchEvent(event);
+      } catch (eventError) {
+        consola.warn("Failed to dispatch validation error event:", eventError);
+      }
+    }
+    throw error;
+  }
+}
+__name(createAccountsOtpVerifyCreate, "createAccountsOtpVerifyCreate");
+
+// src/generated/cfg_accounts/_utils/fetchers/accounts__auth.ts
+import { consola as consola2 } from "consola";
+async function createAccountsTokenRefreshCreate(data, client) {
+  const api = client || getAPIInstance();
+  const response = await api.auth.accountsTokenRefreshCreate(data);
+  try {
+    return TokenRefreshSchema.parse(response);
+  } catch (error) {
+    consola2.error("\u274C Zod Validation Failed");
+    consola2.box(`createAccountsTokenRefreshCreate
+Path: /cfg/accounts/token/refresh/
+Method: POST`);
+    if (error instanceof Error && "issues" in error && Array.isArray(error.issues)) {
+      consola2.error("Validation Issues:");
+      error.issues.forEach((issue, index) => {
+        consola2.error(`  ${index + 1}. ${issue.path.join(".") || "root"}`);
+        consola2.error(`     \u251C\u2500 Message: ${issue.message}`);
+        if (issue.expected) consola2.error(`     \u251C\u2500 Expected: ${issue.expected}`);
+        if (issue.received) consola2.error(`     \u2514\u2500 Received: ${issue.received}`);
+      });
+    }
+    consola2.error("Response data:", response);
+    if (typeof window !== "undefined" && error instanceof Error && "issues" in error) {
+      try {
+        const event = new CustomEvent("zod-validation-error", {
+          detail: {
+            operation: "createAccountsTokenRefreshCreate",
+            path: "/cfg/accounts/token/refresh/",
+            method: "POST",
+            error,
+            response,
+            timestamp: /* @__PURE__ */ new Date()
+          },
+          bubbles: true,
+          cancelable: false
+        });
+        window.dispatchEvent(event);
+      } catch (eventError) {
+        consola2.warn("Failed to dispatch validation error event:", eventError);
+      }
+    }
+    throw error;
+  }
+}
+__name(createAccountsTokenRefreshCreate, "createAccountsTokenRefreshCreate");
+
+// src/generated/cfg_accounts/_utils/fetchers/accounts__oauth.ts
+import { consola as consola3 } from "consola";
+async function getAccountsOauthConnectionsList(client) {
+  const api = client || getAPIInstance();
+  const response = await api.oauth.accountsOauthConnectionsList();
+  return response;
+}
+__name(getAccountsOauthConnectionsList, "getAccountsOauthConnectionsList");
+async function createAccountsOauthDisconnectCreate(data, client) {
+  const api = client || getAPIInstance();
+  const response = await api.oauth.accountsOauthDisconnectCreate(data);
+  return response;
+}
+__name(createAccountsOauthDisconnectCreate, "createAccountsOauthDisconnectCreate");
+async function createAccountsOauthGithubAuthorizeCreate(data, client) {
+  const api = client || getAPIInstance();
+  const response = await api.oauth.accountsOauthGithubAuthorizeCreate(data);
+  try {
+    return OAuthAuthorizeResponseSchema.parse(response);
+  } catch (error) {
+    consola3.error("\u274C Zod Validation Failed");
+    consola3.box(`createAccountsOauthGithubAuthorizeCreate
+Path: /cfg/accounts/oauth/github/authorize/
+Method: POST`);
+    if (error instanceof Error && "issues" in error && Array.isArray(error.issues)) {
+      consola3.error("Validation Issues:");
+      error.issues.forEach((issue, index) => {
+        consola3.error(`  ${index + 1}. ${issue.path.join(".") || "root"}`);
+        consola3.error(`     \u251C\u2500 Message: ${issue.message}`);
+        if (issue.expected) consola3.error(`     \u251C\u2500 Expected: ${issue.expected}`);
+        if (issue.received) consola3.error(`     \u2514\u2500 Received: ${issue.received}`);
+      });
+    }
+    consola3.error("Response data:", response);
+    if (typeof window !== "undefined" && error instanceof Error && "issues" in error) {
+      try {
+        const event = new CustomEvent("zod-validation-error", {
+          detail: {
+            operation: "createAccountsOauthGithubAuthorizeCreate",
+            path: "/cfg/accounts/oauth/github/authorize/",
+            method: "POST",
+            error,
+            response,
+            timestamp: /* @__PURE__ */ new Date()
+          },
+          bubbles: true,
+          cancelable: false
+        });
+        window.dispatchEvent(event);
+      } catch (eventError) {
+        consola3.warn("Failed to dispatch validation error event:", eventError);
+      }
+    }
+    throw error;
+  }
+}
+__name(createAccountsOauthGithubAuthorizeCreate, "createAccountsOauthGithubAuthorizeCreate");
+async function createAccountsOauthGithubCallbackCreate(data, client) {
+  const api = client || getAPIInstance();
+  const response = await api.oauth.accountsOauthGithubCallbackCreate(data);
+  try {
+    return OAuthTokenResponseSchema.parse(response);
+  } catch (error) {
+    consola3.error("\u274C Zod Validation Failed");
+    consola3.box(`createAccountsOauthGithubCallbackCreate
+Path: /cfg/accounts/oauth/github/callback/
+Method: POST`);
+    if (error instanceof Error && "issues" in error && Array.isArray(error.issues)) {
+      consola3.error("Validation Issues:");
+      error.issues.forEach((issue, index) => {
+        consola3.error(`  ${index + 1}. ${issue.path.join(".") || "root"}`);
+        consola3.error(`     \u251C\u2500 Message: ${issue.message}`);
+        if (issue.expected) consola3.error(`     \u251C\u2500 Expected: ${issue.expected}`);
+        if (issue.received) consola3.error(`     \u2514\u2500 Received: ${issue.received}`);
+      });
+    }
+    consola3.error("Response data:", response);
+    if (typeof window !== "undefined" && error instanceof Error && "issues" in error) {
+      try {
+        const event = new CustomEvent("zod-validation-error", {
+          detail: {
+            operation: "createAccountsOauthGithubCallbackCreate",
+            path: "/cfg/accounts/oauth/github/callback/",
+            method: "POST",
+            error,
+            response,
+            timestamp: /* @__PURE__ */ new Date()
+          },
+          bubbles: true,
+          cancelable: false
+        });
+        window.dispatchEvent(event);
+      } catch (eventError) {
+        consola3.warn("Failed to dispatch validation error event:", eventError);
+      }
+    }
+    throw error;
+  }
+}
+__name(createAccountsOauthGithubCallbackCreate, "createAccountsOauthGithubCallbackCreate");
+async function getAccountsOauthProvidersRetrieve(client) {
+  const api = client || getAPIInstance();
+  const response = await api.oauth.accountsOauthProvidersRetrieve();
+  try {
+    return OAuthProvidersResponseSchema.parse(response);
+  } catch (error) {
+    consola3.error("\u274C Zod Validation Failed");
+    consola3.box(`getAccountsOauthProvidersRetrieve
+Path: /cfg/accounts/oauth/providers/
+Method: GET`);
+    if (error instanceof Error && "issues" in error && Array.isArray(error.issues)) {
+      consola3.error("Validation Issues:");
+      error.issues.forEach((issue, index) => {
+        consola3.error(`  ${index + 1}. ${issue.path.join(".") || "root"}`);
+        consola3.error(`     \u251C\u2500 Message: ${issue.message}`);
+        if (issue.expected) consola3.error(`     \u251C\u2500 Expected: ${issue.expected}`);
+        if (issue.received) consola3.error(`     \u2514\u2500 Received: ${issue.received}`);
+      });
+    }
+    consola3.error("Response data:", response);
+    if (typeof window !== "undefined" && error instanceof Error && "issues" in error) {
+      try {
+        const event = new CustomEvent("zod-validation-error", {
+          detail: {
+            operation: "getAccountsOauthProvidersRetrieve",
+            path: "/cfg/accounts/oauth/providers/",
+            method: "GET",
+            error,
+            response,
+            timestamp: /* @__PURE__ */ new Date()
+          },
+          bubbles: true,
+          cancelable: false
+        });
+        window.dispatchEvent(event);
+      } catch (eventError) {
+        consola3.warn("Failed to dispatch validation error event:", eventError);
+      }
+    }
+    throw error;
+  }
+}
+__name(getAccountsOauthProvidersRetrieve, "getAccountsOauthProvidersRetrieve");
+
+// src/generated/cfg_accounts/_utils/fetchers/accounts__user_profile.ts
+import { consola as consola4 } from "consola";
+async function getAccountsProfileRetrieve(client) {
+  const api = client || getAPIInstance();
+  const response = await api.user_profile.accountsProfileRetrieve();
+  try {
+    return UserSchema.parse(response);
+  } catch (error) {
+    consola4.error("\u274C Zod Validation Failed");
+    consola4.box(`getAccountsProfileRetrieve
+Path: /cfg/accounts/profile/
+Method: GET`);
+    if (error instanceof Error && "issues" in error && Array.isArray(error.issues)) {
+      consola4.error("Validation Issues:");
+      error.issues.forEach((issue, index) => {
+        consola4.error(`  ${index + 1}. ${issue.path.join(".") || "root"}`);
+        consola4.error(`     \u251C\u2500 Message: ${issue.message}`);
+        if (issue.expected) consola4.error(`     \u251C\u2500 Expected: ${issue.expected}`);
+        if (issue.received) consola4.error(`     \u2514\u2500 Received: ${issue.received}`);
+      });
+    }
+    consola4.error("Response data:", response);
+    if (typeof window !== "undefined" && error instanceof Error && "issues" in error) {
+      try {
+        const event = new CustomEvent("zod-validation-error", {
+          detail: {
+            operation: "getAccountsProfileRetrieve",
+            path: "/cfg/accounts/profile/",
+            method: "GET",
+            error,
+            response,
+            timestamp: /* @__PURE__ */ new Date()
+          },
+          bubbles: true,
+          cancelable: false
+        });
+        window.dispatchEvent(event);
+      } catch (eventError) {
+        consola4.warn("Failed to dispatch validation error event:", eventError);
+      }
+    }
+    throw error;
+  }
+}
+__name(getAccountsProfileRetrieve, "getAccountsProfileRetrieve");
+async function createAccountsProfileAvatarCreate(data, client) {
+  const api = client || getAPIInstance();
+  const response = await api.user_profile.accountsProfileAvatarCreate(data);
+  try {
+    return UserSchema.parse(response);
+  } catch (error) {
+    consola4.error("\u274C Zod Validation Failed");
+    consola4.box(`createAccountsProfileAvatarCreate
+Path: /cfg/accounts/profile/avatar/
+Method: POST`);
+    if (error instanceof Error && "issues" in error && Array.isArray(error.issues)) {
+      consola4.error("Validation Issues:");
+      error.issues.forEach((issue, index) => {
+        consola4.error(`  ${index + 1}. ${issue.path.join(".") || "root"}`);
+        consola4.error(`     \u251C\u2500 Message: ${issue.message}`);
+        if (issue.expected) consola4.error(`     \u251C\u2500 Expected: ${issue.expected}`);
+        if (issue.received) consola4.error(`     \u2514\u2500 Received: ${issue.received}`);
+      });
+    }
+    consola4.error("Response data:", response);
+    if (typeof window !== "undefined" && error instanceof Error && "issues" in error) {
+      try {
+        const event = new CustomEvent("zod-validation-error", {
+          detail: {
+            operation: "createAccountsProfileAvatarCreate",
+            path: "/cfg/accounts/profile/avatar/",
+            method: "POST",
+            error,
+            response,
+            timestamp: /* @__PURE__ */ new Date()
+          },
+          bubbles: true,
+          cancelable: false
+        });
+        window.dispatchEvent(event);
+      } catch (eventError) {
+        consola4.warn("Failed to dispatch validation error event:", eventError);
+      }
+    }
+    throw error;
+  }
+}
+__name(createAccountsProfileAvatarCreate, "createAccountsProfileAvatarCreate");
+async function partialUpdateAccountsProfilePartialUpdate(data, client) {
+  const api = client || getAPIInstance();
+  const response = await api.user_profile.accountsProfilePartialUpdate(data);
+  try {
+    return UserSchema.parse(response);
+  } catch (error) {
+    consola4.error("\u274C Zod Validation Failed");
+    consola4.box(`partialUpdateAccountsProfilePartialUpdate
+Path: /cfg/accounts/profile/partial/
+Method: PUT`);
+    if (error instanceof Error && "issues" in error && Array.isArray(error.issues)) {
+      consola4.error("Validation Issues:");
+      error.issues.forEach((issue, index) => {
+        consola4.error(`  ${index + 1}. ${issue.path.join(".") || "root"}`);
+        consola4.error(`     \u251C\u2500 Message: ${issue.message}`);
+        if (issue.expected) consola4.error(`     \u251C\u2500 Expected: ${issue.expected}`);
+        if (issue.received) consola4.error(`     \u2514\u2500 Received: ${issue.received}`);
+      });
+    }
+    consola4.error("Response data:", response);
+    if (typeof window !== "undefined" && error instanceof Error && "issues" in error) {
+      try {
+        const event = new CustomEvent("zod-validation-error", {
+          detail: {
+            operation: "partialUpdateAccountsProfilePartialUpdate",
+            path: "/cfg/accounts/profile/partial/",
+            method: "PUT",
+            error,
+            response,
+            timestamp: /* @__PURE__ */ new Date()
+          },
+          bubbles: true,
+          cancelable: false
+        });
+        window.dispatchEvent(event);
+      } catch (eventError) {
+        consola4.warn("Failed to dispatch validation error event:", eventError);
+      }
+    }
+    throw error;
+  }
+}
+__name(partialUpdateAccountsProfilePartialUpdate, "partialUpdateAccountsProfilePartialUpdate");
+async function partialUpdateAccountsProfilePartialPartialUpdate(data, client) {
+  const api = client || getAPIInstance();
+  const response = await api.user_profile.accountsProfilePartialPartialUpdate(data);
+  try {
+    return UserSchema.parse(response);
+  } catch (error) {
+    consola4.error("\u274C Zod Validation Failed");
+    consola4.box(`partialUpdateAccountsProfilePartialPartialUpdate
+Path: /cfg/accounts/profile/partial/
+Method: PATCH`);
+    if (error instanceof Error && "issues" in error && Array.isArray(error.issues)) {
+      consola4.error("Validation Issues:");
+      error.issues.forEach((issue, index) => {
+        consola4.error(`  ${index + 1}. ${issue.path.join(".") || "root"}`);
+        consola4.error(`     \u251C\u2500 Message: ${issue.message}`);
+        if (issue.expected) consola4.error(`     \u251C\u2500 Expected: ${issue.expected}`);
+        if (issue.received) consola4.error(`     \u2514\u2500 Received: ${issue.received}`);
+      });
+    }
+    consola4.error("Response data:", response);
+    if (typeof window !== "undefined" && error instanceof Error && "issues" in error) {
+      try {
+        const event = new CustomEvent("zod-validation-error", {
+          detail: {
+            operation: "partialUpdateAccountsProfilePartialPartialUpdate",
+            path: "/cfg/accounts/profile/partial/",
+            method: "PATCH",
+            error,
+            response,
+            timestamp: /* @__PURE__ */ new Date()
+          },
+          bubbles: true,
+          cancelable: false
+        });
+        window.dispatchEvent(event);
+      } catch (eventError) {
+        consola4.warn("Failed to dispatch validation error event:", eventError);
+      }
+    }
+    throw error;
+  }
+}
+__name(partialUpdateAccountsProfilePartialPartialUpdate, "partialUpdateAccountsProfilePartialPartialUpdate");
+async function updateAccountsProfileUpdateUpdate(data, client) {
+  const api = client || getAPIInstance();
+  const response = await api.user_profile.accountsProfileUpdateUpdate(data);
+  try {
+    return UserSchema.parse(response);
+  } catch (error) {
+    consola4.error("\u274C Zod Validation Failed");
+    consola4.box(`updateAccountsProfileUpdateUpdate
+Path: /cfg/accounts/profile/update/
+Method: PUT`);
+    if (error instanceof Error && "issues" in error && Array.isArray(error.issues)) {
+      consola4.error("Validation Issues:");
+      error.issues.forEach((issue, index) => {
+        consola4.error(`  ${index + 1}. ${issue.path.join(".") || "root"}`);
+        consola4.error(`     \u251C\u2500 Message: ${issue.message}`);
+        if (issue.expected) consola4.error(`     \u251C\u2500 Expected: ${issue.expected}`);
+        if (issue.received) consola4.error(`     \u2514\u2500 Received: ${issue.received}`);
+      });
+    }
+    consola4.error("Response data:", response);
+    if (typeof window !== "undefined" && error instanceof Error && "issues" in error) {
+      try {
+        const event = new CustomEvent("zod-validation-error", {
+          detail: {
+            operation: "updateAccountsProfileUpdateUpdate",
+            path: "/cfg/accounts/profile/update/",
+            method: "PUT",
+            error,
+            response,
+            timestamp: /* @__PURE__ */ new Date()
+          },
+          bubbles: true,
+          cancelable: false
+        });
+        window.dispatchEvent(event);
+      } catch (eventError) {
+        consola4.warn("Failed to dispatch validation error event:", eventError);
+      }
+    }
+    throw error;
+  }
+}
+__name(updateAccountsProfileUpdateUpdate, "updateAccountsProfileUpdateUpdate");
+async function partialUpdateAccountsProfileUpdatePartialUpdate(data, client) {
+  const api = client || getAPIInstance();
+  const response = await api.user_profile.accountsProfileUpdatePartialUpdate(data);
+  try {
+    return UserSchema.parse(response);
+  } catch (error) {
+    consola4.error("\u274C Zod Validation Failed");
+    consola4.box(`partialUpdateAccountsProfileUpdatePartialUpdate
+Path: /cfg/accounts/profile/update/
+Method: PATCH`);
+    if (error instanceof Error && "issues" in error && Array.isArray(error.issues)) {
+      consola4.error("Validation Issues:");
+      error.issues.forEach((issue, index) => {
+        consola4.error(`  ${index + 1}. ${issue.path.join(".") || "root"}`);
+        consola4.error(`     \u251C\u2500 Message: ${issue.message}`);
+        if (issue.expected) consola4.error(`     \u251C\u2500 Expected: ${issue.expected}`);
+        if (issue.received) consola4.error(`     \u2514\u2500 Received: ${issue.received}`);
+      });
+    }
+    consola4.error("Response data:", response);
+    if (typeof window !== "undefined" && error instanceof Error && "issues" in error) {
+      try {
+        const event = new CustomEvent("zod-validation-error", {
+          detail: {
+            operation: "partialUpdateAccountsProfileUpdatePartialUpdate",
+            path: "/cfg/accounts/profile/update/",
+            method: "PATCH",
+            error,
+            response,
+            timestamp: /* @__PURE__ */ new Date()
+          },
+          bubbles: true,
+          cancelable: false
+        });
+        window.dispatchEvent(event);
+      } catch (eventError) {
+        consola4.warn("Failed to dispatch validation error event:", eventError);
+      }
+    }
+    throw error;
+  }
+}
+__name(partialUpdateAccountsProfileUpdatePartialUpdate, "partialUpdateAccountsProfileUpdatePartialUpdate");
+
+// src/generated/cfg_accounts/index.ts
+var TOKEN_KEY = "auth_token";
+var REFRESH_TOKEN_KEY = "refresh_token";
+var API = class {
+  constructor(baseUrl, options) {
+    this._token = null;
+    this._refreshToken = null;
+    this.baseUrl = baseUrl;
+    this.options = options;
+    const logger = options?.loggerConfig ? new APILogger(options.loggerConfig) : void 0;
+    this.storage = options?.storage || new LocalStorageAdapter(logger);
+    this._loadTokensFromStorage();
+    this._client = new APIClient(this.baseUrl, {
+      retryConfig: this.options?.retryConfig,
+      loggerConfig: this.options?.loggerConfig
+    });
+    this._injectAuthHeader();
+    this.auth = this._client.auth;
+    this.oauth = this._client.oauth;
+    this.user_profile = this._client.user_profile;
+    this.accounts = this._client.accounts;
+  }
+  static {
+    __name(this, "API");
+  }
+  _loadTokensFromStorage() {
+    this._token = this.storage.getItem(TOKEN_KEY);
+    this._refreshToken = this.storage.getItem(REFRESH_TOKEN_KEY);
+  }
+  _reinitClients() {
+    this._client = new APIClient(this.baseUrl, {
+      retryConfig: this.options?.retryConfig,
+      loggerConfig: this.options?.loggerConfig
+    });
+    this._injectAuthHeader();
+    this.auth = this._client.auth;
+    this.oauth = this._client.oauth;
+    this.user_profile = this._client.user_profile;
+    this.accounts = this._client.accounts;
+  }
+  _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_KEY);
+  }
+  /**
+   * Get current refresh token
+   */
+  getRefreshToken() {
+    return this.storage.getItem(REFRESH_TOKEN_KEY);
+  }
+  /**
+   * 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_KEY, token);
+    if (refreshToken) {
+      this._refreshToken = refreshToken;
+      this.storage.setItem(REFRESH_TOKEN_KEY, refreshToken);
+    }
+    this._reinitClients();
+  }
+  /**
+   * Clear all tokens
+   */
+  clearTokens() {
+    this._token = null;
+    this._refreshToken = null;
+    this.storage.removeItem(TOKEN_KEY);
+    this.storage.removeItem(REFRESH_TOKEN_KEY);
+    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;
+  }
+  /**
+   * 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";
+  }
+};
+
+// src/generated/cfg_webpush/webpush__web_push/client.ts
+var WebPush = class {
+  static {
+    __name(this, "WebPush");
+  }
+  constructor(client) {
+    this.client = client;
+  }
+  /**
+   * Send push notification
+   * 
+   * Send push notification to all active subscriptions for the authenticated
+   * user.
+   */
+  async webpushSendCreate(data) {
+    const response = await this.client.request("POST", "/cfg/webpush/send/", { body: data });
+    return response;
+  }
+  /**
+   * Subscribe to push notifications
+   * 
+   * Save push subscription from browser for the authenticated user.
+   */
+  async webpushSubscribeCreate(data) {
+    const response = await this.client.request("POST", "/cfg/webpush/subscribe/", { body: data });
+    return response;
+  }
+  /**
+   * Get VAPID public key
+   * 
+   * Get VAPID public key for client subscription.
+   */
+  async webpushVapidRetrieve() {
+    const response = await this.client.request("GET", "/cfg/webpush/vapid/");
+    return response;
+  }
+};
+
+// src/generated/cfg_webpush/http.ts
+var FetchAdapter2 = 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));
+        }
+      });
+      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();
+    }
+    const responseHeaders = {};
+    response.headers.forEach((value, key) => {
+      responseHeaders[key] = value;
+    });
+    return {
+      data,
+      status: response.status,
+      statusText: response.statusText,
+      headers: responseHeaders
+    };
+  }
+};
+
+// src/generated/cfg_webpush/errors.ts
+var APIError2 = 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;
+    }
+    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;
+      }
+    }
+    return Object.keys(fieldErrors).length > 0 ? fieldErrors : null;
+  }
+  /**
+   * 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);
+    }
+    const fieldErrors = this.fieldErrors;
+    if (fieldErrors) {
+      const firstField = Object.keys(fieldErrors)[0];
+      if (firstField) {
+        return `${firstField}: ${fieldErrors[firstField]?.join(", ")}`;
+      }
+    }
+    return this.message;
+  }
+  // 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 NetworkError2 = 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
+import { createConsola as createConsola2 } from "consola";
+var DEFAULT_CONFIG2 = {
+  enabled: process.env.NODE_ENV !== "production",
+  logRequests: true,
+  logResponses: true,
+  logErrors: true,
+  logBodies: true,
+  logHeaders: false
+};
+var SENSITIVE_HEADERS2 = [
+  "authorization",
+  "cookie",
+  "set-cookie",
+  "x-api-key",
+  "x-csrf-token"
+];
+var APILogger2 = class {
+  static {
+    __name(this, "APILogger");
+  }
+  constructor(config = {}) {
+    this.config = { ...DEFAULT_CONFIG2, ...config };
+    this.consola = config.consola || createConsola2({
+      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_HEADERS2.includes(lowerKey)) {
+        filtered[key] = "***";
+      } else {
+        filtered[key] = headers[key] || "";
+      }
+    });
+    return filtered;
+  }
+  /**
+   * 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));
+    }
+    if (this.config.logBodies && body) {
+      this.consola.debug("Body:", body);
+    }
+  }
+  /**
+   * 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);
+    }
+  }
+  /**
+   * 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}`);
+        });
+      });
+    }
+  }
+  /**
+   * 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 defaultLogger2 = new APILogger2();
+
+// src/generated/cfg_webpush/retry.ts
+import pRetry2, { AbortError as AbortError2 } from "p-retry";
+var DEFAULT_RETRY_CONFIG2 = {
+  retries: 3,
+  factor: 2,
+  minTimeout: 1e3,
+  maxTimeout: 6e4,
+  randomize: true,
+  onFailedAttempt: /* @__PURE__ */ __name(() => {
+  }, "onFailedAttempt")
+};
+function shouldRetry2(error) {
+  if (error instanceof NetworkError2) {
+    return true;
+  }
+  if (error instanceof APIError2) {
+    const status = error.statusCode;
+    if (status >= 500 && status < 600) {
+      return true;
+    }
+    if (status === 429) {
+      return true;
+    }
+    return false;
+  }
+  return true;
+}
+__name(shouldRetry2, "shouldRetry");
+async function withRetry2(fn, config) {
+  const finalConfig = { ...DEFAULT_RETRY_CONFIG2, ...config };
+  return pRetry2(
+    async () => {
+      try {
+        return await fn();
+      } catch (error) {
+        if (!shouldRetry2(error)) {
+          throw new AbortError2(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
+    }
+  );
+}
+__name(withRetry2, "withRetry");
+
+// src/generated/cfg_webpush/client.ts
+var APIClient2 = class {
+  constructor(baseUrl, options) {
+    this.logger = null;
+    this.retryConfig = null;
+    this.baseUrl = baseUrl.replace(/\/$/, "");
+    this.httpClient = options?.httpClient || new FetchAdapter2();
+    if (options?.loggerConfig !== void 0) {
+      this.logger = new APILogger2(options.loggerConfig);
+    }
+    if (options?.retryConfig !== void 0) {
+      this.retryConfig = options.retryConfig;
+    }
+    this.web_push = new WebPush(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;
+    }
+    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 withRetry2(() => 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 APIError2(
+          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 APIError2) {
+        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 NetworkError2(error.message, url, error) : new NetworkError2("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_webpush/storage.ts
+var LocalStorageAdapter2 = 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_webpush/_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
+import { z as z20 } from "zod";
+var SendPushRequestRequestSchema = z20.object({
+  title: z20.string().min(1).max(255),
+  body: z20.string().min(1),
+  icon: z20.url().nullable().optional(),
+  url: z20.url().nullable().optional()
+});
+
+// src/generated/cfg_webpush/_utils/schemas/SendPushResponse.schema.ts
+import { z as z21 } from "zod";
+var SendPushResponseSchema = z21.object({
+  success: z21.boolean(),
+  sent_to: z21.int()
+});
+
+// src/generated/cfg_webpush/_utils/schemas/SubscribeRequestRequest.schema.ts
+import { z as z22 } from "zod";
+var SubscribeRequestRequestSchema = z22.object({
+  endpoint: z22.url(),
+  keys: z22.record(z22.string(), z22.string().min(1))
+});
+
+// src/generated/cfg_webpush/_utils/schemas/SubscribeResponse.schema.ts
+import { z as z23 } from "zod";
+var SubscribeResponseSchema = z23.object({
+  success: z23.boolean(),
+  subscription_id: z23.int(),
+  created: z23.boolean()
+});
+
+// src/generated/cfg_webpush/_utils/schemas/VapidPublicKeyResponse.schema.ts
+import { z as z24 } from "zod";
+var VapidPublicKeyResponseSchema = z24.object({
+  publicKey: z24.string()
+});
+
+// src/generated/cfg_webpush/_utils/fetchers/index.ts
+var fetchers_exports2 = {};
+__export(fetchers_exports2, {
+  createWebpushSendCreate: () => createWebpushSendCreate,
+  createWebpushSubscribeCreate: () => createWebpushSubscribeCreate,
+  getWebpushVapidRetrieve: () => getWebpushVapidRetrieve
+});
+
+// src/generated/cfg_webpush/_utils/fetchers/webpush__web_push.ts
+import { consola as consola5 } from "consola";
+
+// src/generated/cfg_webpush/api-instance.ts
+var globalAPI2 = null;
+function getAPIInstance2() {
+  if (!globalAPI2) {
+    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 globalAPI2;
+}
+__name(getAPIInstance2, "getAPIInstance");
+
+// src/generated/cfg_webpush/_utils/fetchers/webpush__web_push.ts
+async function createWebpushSendCreate(data, client) {
+  const api = client || getAPIInstance2();
+  const response = await api.web_push.webpushSendCreate(data);
+  try {
+    return SendPushResponseSchema.parse(response);
+  } catch (error) {
+    consola5.error("\u274C Zod Validation Failed");
+    consola5.box(`createWebpushSendCreate
+Path: /cfg/webpush/send/
+Method: POST`);
+    if (error instanceof Error && "issues" in error && Array.isArray(error.issues)) {
+      consola5.error("Validation Issues:");
+      error.issues.forEach((issue, index) => {
+        consola5.error(`  ${index + 1}. ${issue.path.join(".") || "root"}`);
+        consola5.error(`     \u251C\u2500 Message: ${issue.message}`);
+        if (issue.expected) consola5.error(`     \u251C\u2500 Expected: ${issue.expected}`);
+        if (issue.received) consola5.error(`     \u2514\u2500 Received: ${issue.received}`);
+      });
+    }
+    consola5.error("Response data:", response);
+    if (typeof window !== "undefined" && error instanceof Error && "issues" in error) {
+      try {
+        const event = new CustomEvent("zod-validation-error", {
+          detail: {
+            operation: "createWebpushSendCreate",
+            path: "/cfg/webpush/send/",
+            method: "POST",
+            error,
+            response,
+            timestamp: /* @__PURE__ */ new Date()
+          },
+          bubbles: true,
+          cancelable: false
+        });
+        window.dispatchEvent(event);
+      } catch (eventError) {
+        consola5.warn("Failed to dispatch validation error event:", eventError);
+      }
+    }
+    throw error;
+  }
+}
+__name(createWebpushSendCreate, "createWebpushSendCreate");
+async function createWebpushSubscribeCreate(data, client) {
+  const api = client || getAPIInstance2();
+  const response = await api.web_push.webpushSubscribeCreate(data);
+  try {
+    return SubscribeResponseSchema.parse(response);
+  } catch (error) {
+    consola5.error("\u274C Zod Validation Failed");
+    consola5.box(`createWebpushSubscribeCreate
+Path: /cfg/webpush/subscribe/
+Method: POST`);
+    if (error instanceof Error && "issues" in error && Array.isArray(error.issues)) {
+      consola5.error("Validation Issues:");
+      error.issues.forEach((issue, index) => {
+        consola5.error(`  ${index + 1}. ${issue.path.join(".") || "root"}`);
+        consola5.error(`     \u251C\u2500 Message: ${issue.message}`);
+        if (issue.expected) consola5.error(`     \u251C\u2500 Expected: ${issue.expected}`);
+        if (issue.received) consola5.error(`     \u2514\u2500 Received: ${issue.received}`);
+      });
+    }
+    consola5.error("Response data:", response);
+    if (typeof window !== "undefined" && error instanceof Error && "issues" in error) {
+      try {
+        const event = new CustomEvent("zod-validation-error", {
+          detail: {
+            operation: "createWebpushSubscribeCreate",
+            path: "/cfg/webpush/subscribe/",
+            method: "POST",
+            error,
+            response,
+            timestamp: /* @__PURE__ */ new Date()
+          },
+          bubbles: true,
+          cancelable: false
+        });
+        window.dispatchEvent(event);
+      } catch (eventError) {
+        consola5.warn("Failed to dispatch validation error event:", eventError);
+      }
+    }
+    throw error;
+  }
+}
+__name(createWebpushSubscribeCreate, "createWebpushSubscribeCreate");
+async function getWebpushVapidRetrieve(client) {
+  const api = client || getAPIInstance2();
+  const response = await api.web_push.webpushVapidRetrieve();
+  try {
+    return VapidPublicKeyResponseSchema.parse(response);
+  } catch (error) {
+    consola5.error("\u274C Zod Validation Failed");
+    consola5.box(`getWebpushVapidRetrieve
+Path: /cfg/webpush/vapid/
+Method: GET`);
+    if (error instanceof Error && "issues" in error && Array.isArray(error.issues)) {
+      consola5.error("Validation Issues:");
+      error.issues.forEach((issue, index) => {
+        consola5.error(`  ${index + 1}. ${issue.path.join(".") || "root"}`);
+        consola5.error(`     \u251C\u2500 Message: ${issue.message}`);
+        if (issue.expected) consola5.error(`     \u251C\u2500 Expected: ${issue.expected}`);
+        if (issue.received) consola5.error(`     \u2514\u2500 Received: ${issue.received}`);
+      });
+    }
+    consola5.error("Response data:", response);
+    if (typeof window !== "undefined" && error instanceof Error && "issues" in error) {
+      try {
+        const event = new CustomEvent("zod-validation-error", {
+          detail: {
+            operation: "getWebpushVapidRetrieve",
+            path: "/cfg/webpush/vapid/",
+            method: "GET",
+            error,
+            response,
+            timestamp: /* @__PURE__ */ new Date()
+          },
+          bubbles: true,
+          cancelable: false
+        });
+        window.dispatchEvent(event);
+      } catch (eventError) {
+        consola5.warn("Failed to dispatch validation error event:", eventError);
+      }
+    }
+    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);
+    }
+    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;
+  }
+  /**
+   * 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";
+  }
+};
+
+// 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/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 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));
+        }
+      });
+      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();
+    }
+    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");
+  }
+  /**
+   * 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;
+    }
+    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;
+      }
+    }
+    return Object.keys(fieldErrors).length > 0 ? fieldErrors : null;
+  }
+  /**
+   * 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);
+    }
+    const fieldErrors = this.fieldErrors;
+    if (fieldErrors) {
+      const firstField = Object.keys(fieldErrors)[0];
+      if (firstField) {
+        return `${firstField}: ${fieldErrors[firstField]?.join(", ")}`;
+      }
+    }
+    return this.message;
+  }
+  // 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_centrifugo/logger.ts
+import { createConsola as createConsola3 } from "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 || createConsola3({
+      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] || "";
+      }
+    });
+    return filtered;
+  }
+  /**
+   * 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));
+    }
+    if (this.config.logBodies && body) {
+      this.consola.debug("Body:", body);
+    }
+  }
+  /**
+   * 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);
+    }
+  }
+  /**
+   * 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}`);
+        });
+      });
+    }
+  }
+  /**
+   * 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/retry.ts
+import pRetry3, { AbortError as AbortError3 } from "p-retry";
+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;
+  }
+  return true;
+}
+__name(shouldRetry3, "shouldRetry");
+async function withRetry3(fn, config) {
+  const finalConfig = { ...DEFAULT_RETRY_CONFIG3, ...config };
+  return pRetry3(
+    async () => {
+      try {
+        return await fn();
+      } catch (error) {
+        if (!shouldRetry3(error)) {
+          throw new AbortError3(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
+    }
+  );
+}
+__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;
+    }
+    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
+import { z as z25 } from "zod";
+var CentrifugoChannelInfoSchema = z25.object({
+  num_clients: z25.int()
+});
+
+// src/generated/cfg_centrifugo/_utils/schemas/CentrifugoChannelsRequestRequest.schema.ts
+import { z as z26 } from "zod";
+var CentrifugoChannelsRequestRequestSchema = z26.object({
+  pattern: z26.string().nullable().optional()
+});
+
+// src/generated/cfg_centrifugo/_utils/schemas/CentrifugoChannelsResponse.schema.ts
+import { z as z29 } from "zod";
+
+// src/generated/cfg_centrifugo/_utils/schemas/CentrifugoChannelsResult.schema.ts
+import { z as z27 } from "zod";
+var CentrifugoChannelsResultSchema = z27.object({
+  channels: z27.record(z27.string(), CentrifugoChannelInfoSchema)
+});
+
+// src/generated/cfg_centrifugo/_utils/schemas/CentrifugoError.schema.ts
+import { z as z28 } from "zod";
+var CentrifugoErrorSchema = z28.object({
+  code: z28.int().optional(),
+  message: z28.string().optional()
+});
+
+// src/generated/cfg_centrifugo/_utils/schemas/CentrifugoChannelsResponse.schema.ts
+var CentrifugoChannelsResponseSchema = z29.object({
+  error: CentrifugoErrorSchema.optional(),
+  result: CentrifugoChannelsResultSchema.optional()
+});
+
+// src/generated/cfg_centrifugo/_utils/schemas/CentrifugoClientInfo.schema.ts
+import { z as z30 } from "zod";
+var CentrifugoClientInfoSchema = z30.object({
+  user: z30.string(),
+  client: z30.string(),
+  conn_info: z30.record(z30.string(), z30.any()).nullable().optional(),
+  chan_info: z30.record(z30.string(), z30.any()).nullable().optional()
+});
+
+// src/generated/cfg_centrifugo/_utils/schemas/CentrifugoHealthCheck.schema.ts
+import { z as z31 } from "zod";
+var CentrifugoHealthCheckSchema = z31.object({
+  status: z31.string(),
+  wrapper_url: z31.string(),
+  has_api_key: z31.boolean(),
+  timestamp: z31.string()
+});
+
+// src/generated/cfg_centrifugo/_utils/schemas/CentrifugoHistoryRequestRequest.schema.ts
+import { z as z33 } from "zod";
+
+// src/generated/cfg_centrifugo/_utils/schemas/CentrifugoStreamPosition.schema.ts
+import { z as z32 } from "zod";
+var CentrifugoStreamPositionSchema = z32.object({
+  offset: z32.int(),
+  epoch: z32.string()
+});
+
+// src/generated/cfg_centrifugo/_utils/schemas/CentrifugoHistoryRequestRequest.schema.ts
+var CentrifugoHistoryRequestRequestSchema = z33.object({
+  channel: z33.string(),
+  limit: z33.int().nullable().optional(),
+  since: CentrifugoStreamPositionSchema.optional(),
+  reverse: z33.boolean().nullable().optional()
+});
+
+// src/generated/cfg_centrifugo/_utils/schemas/CentrifugoHistoryResponse.schema.ts
+import { z as z36 } from "zod";
+
+// src/generated/cfg_centrifugo/_utils/schemas/CentrifugoHistoryResult.schema.ts
+import { z as z35 } from "zod";
+
+// src/generated/cfg_centrifugo/_utils/schemas/CentrifugoPublication.schema.ts
+import { z as z34 } from "zod";
+var CentrifugoPublicationSchema = z34.object({
+  data: z34.record(z34.string(), z34.any()),
+  info: CentrifugoClientInfoSchema.optional(),
+  offset: z34.int(),
+  tags: z34.record(z34.string(), z34.any()).nullable().optional()
+});
+
+// src/generated/cfg_centrifugo/_utils/schemas/CentrifugoHistoryResult.schema.ts
+var CentrifugoHistoryResultSchema = z35.object({
+  publications: z35.array(CentrifugoPublicationSchema),
+  epoch: z35.string(),
+  offset: z35.int()
+});
+
+// src/generated/cfg_centrifugo/_utils/schemas/CentrifugoHistoryResponse.schema.ts
+var CentrifugoHistoryResponseSchema = z36.object({
+  error: CentrifugoErrorSchema.optional(),
+  result: CentrifugoHistoryResultSchema.optional()
+});
+
+// src/generated/cfg_centrifugo/_utils/schemas/CentrifugoInfoResponse.schema.ts
+import { z as z41 } from "zod";
+
+// src/generated/cfg_centrifugo/_utils/schemas/CentrifugoInfoResult.schema.ts
+import { z as z40 } from "zod";
+
+// src/generated/cfg_centrifugo/_utils/schemas/CentrifugoNodeInfo.schema.ts
+import { z as z39 } from "zod";
+
+// src/generated/cfg_centrifugo/_utils/schemas/CentrifugoMetrics.schema.ts
+import { z as z37 } from "zod";
+var CentrifugoMetricsSchema = z37.object({
+  interval: z37.number(),
+  items: z37.record(z37.string(), z37.number())
+});
+
+// src/generated/cfg_centrifugo/_utils/schemas/CentrifugoProcess.schema.ts
+import { z as z38 } from "zod";
+var CentrifugoProcessSchema = z38.object({
+  cpu: z38.number(),
+  rss: z38.int()
+});
+
+// src/generated/cfg_centrifugo/_utils/schemas/CentrifugoNodeInfo.schema.ts
+var CentrifugoNodeInfoSchema = z39.object({
+  uid: z39.string(),
+  name: z39.string(),
+  version: z39.string(),
+  num_clients: z39.int(),
+  num_users: z39.int(),
+  num_channels: z39.int(),
+  uptime: z39.int(),
+  num_subs: z39.int(),
+  metrics: CentrifugoMetricsSchema.optional(),
+  process: CentrifugoProcessSchema.optional()
+});
+
+// src/generated/cfg_centrifugo/_utils/schemas/CentrifugoInfoResult.schema.ts
+var CentrifugoInfoResultSchema = z40.object({
+  nodes: z40.array(CentrifugoNodeInfoSchema)
+});
+
+// src/generated/cfg_centrifugo/_utils/schemas/CentrifugoInfoResponse.schema.ts
+var CentrifugoInfoResponseSchema = z41.object({
+  error: CentrifugoErrorSchema.optional(),
+  result: CentrifugoInfoResultSchema.optional()
+});
+
+// src/generated/cfg_centrifugo/_utils/schemas/CentrifugoOverviewStats.schema.ts
+import { z as z42 } from "zod";
+var CentrifugoOverviewStatsSchema = z42.object({
+  total: z42.int(),
+  successful: z42.int(),
+  failed: z42.int(),
+  timeout: z42.int(),
+  success_rate: z42.number(),
+  avg_duration_ms: z42.number(),
+  avg_acks_received: z42.number(),
+  period_hours: z42.int()
+});
+
+// src/generated/cfg_centrifugo/_utils/schemas/CentrifugoPresenceRequestRequest.schema.ts
+import { z as z43 } from "zod";
+var CentrifugoPresenceRequestRequestSchema = z43.object({
+  channel: z43.string()
+});
+
+// src/generated/cfg_centrifugo/_utils/schemas/CentrifugoPresenceResponse.schema.ts
+import { z as z45 } from "zod";
+
+// src/generated/cfg_centrifugo/_utils/schemas/CentrifugoPresenceResult.schema.ts
+import { z as z44 } from "zod";
+var CentrifugoPresenceResultSchema = z44.object({
+  presence: z44.record(z44.string(), CentrifugoClientInfoSchema)
+});
+
+// src/generated/cfg_centrifugo/_utils/schemas/CentrifugoPresenceResponse.schema.ts
+var CentrifugoPresenceResponseSchema = z45.object({
+  error: CentrifugoErrorSchema.optional(),
+  result: CentrifugoPresenceResultSchema.optional()
+});
+
+// src/generated/cfg_centrifugo/_utils/schemas/CentrifugoPresenceStatsRequestRequest.schema.ts
+import { z as z46 } from "zod";
+var CentrifugoPresenceStatsRequestRequestSchema = z46.object({
+  channel: z46.string()
+});
+
+// src/generated/cfg_centrifugo/_utils/schemas/CentrifugoPresenceStatsResponse.schema.ts
+import { z as z48 } from "zod";
+
+// src/generated/cfg_centrifugo/_utils/schemas/CentrifugoPresenceStatsResult.schema.ts
+import { z as z47 } from "zod";
+var CentrifugoPresenceStatsResultSchema = z47.object({
+  num_clients: z47.int(),
+  num_users: z47.int()
+});
+
+// src/generated/cfg_centrifugo/_utils/schemas/CentrifugoPresenceStatsResponse.schema.ts
+var CentrifugoPresenceStatsResponseSchema = z48.object({
+  error: CentrifugoErrorSchema.optional(),
+  result: CentrifugoPresenceStatsResultSchema.optional()
+});
+
+// src/generated/cfg_centrifugo/_utils/schemas/ChannelList.schema.ts
+import { z as z50 } from "zod";
+
+// src/generated/cfg_centrifugo/_utils/schemas/ChannelStats.schema.ts
+import { z as z49 } from "zod";
+var ChannelStatsSchema = z49.object({
+  channel: z49.string(),
+  total: z49.int(),
+  successful: z49.int(),
+  failed: z49.int(),
+  avg_duration_ms: z49.number(),
+  avg_acks: z49.number(),
+  last_activity_at: z49.string().nullable()
+});
+
+// src/generated/cfg_centrifugo/_utils/schemas/ChannelList.schema.ts
+var ChannelListSchema = z50.object({
+  channels: z50.array(ChannelStatsSchema),
+  total_channels: z50.int()
+});
+
+// src/generated/cfg_centrifugo/_utils/schemas/ConnectionTokenResponse.schema.ts
+import { z as z51 } from "zod";
+var ConnectionTokenResponseSchema = z51.object({
+  token: z51.string(),
+  centrifugo_url: z51.string(),
+  expires_at: z51.string(),
+  channels: z51.array(z51.string())
+});
+
+// src/generated/cfg_centrifugo/_utils/schemas/ManualAckRequestRequest.schema.ts
+import { z as z52 } from "zod";
+var ManualAckRequestRequestSchema = z52.object({
+  message_id: z52.string(),
+  client_id: z52.string()
+});
+
+// src/generated/cfg_centrifugo/_utils/schemas/ManualAckResponse.schema.ts
+import { z as z53 } from "zod";
+var ManualAckResponseSchema = z53.object({
+  success: z53.boolean(),
+  message_id: z53.string(),
+  error: z53.string().nullable().optional()
+});
+
+// src/generated/cfg_centrifugo/_utils/schemas/PaginatedPublishList.schema.ts
+import { z as z55 } from "zod";
+
+// src/generated/cfg_centrifugo/_utils/schemas/Publish.schema.ts
+import { z as z54 } from "zod";
+var PublishSchema = z54.object({
+  message_id: z54.string(),
+  channel: z54.string(),
+  status: z54.string(),
+  wait_for_ack: z54.boolean(),
+  acks_received: z54.int(),
+  acks_expected: z54.int().nullable(),
+  duration_ms: z54.number().nullable(),
+  created_at: z54.iso.datetime(),
+  completed_at: z54.iso.datetime().nullable(),
+  error_code: z54.string().nullable(),
+  error_message: z54.string().nullable()
+});
+
+// src/generated/cfg_centrifugo/_utils/schemas/PaginatedPublishList.schema.ts
+var PaginatedPublishListSchema = z55.object({
+  count: z55.int(),
+  page: z55.int(),
+  pages: z55.int(),
+  page_size: z55.int(),
+  has_next: z55.boolean(),
+  has_previous: z55.boolean(),
+  next_page: z55.int().nullable().optional(),
+  previous_page: z55.int().nullable().optional(),
+  results: z55.array(PublishSchema)
+});
+
+// src/generated/cfg_centrifugo/_utils/schemas/PublishTestRequestRequest.schema.ts
+import { z as z56 } from "zod";
+var PublishTestRequestRequestSchema = z56.object({
+  channel: z56.string(),
+  data: z56.record(z56.string(), z56.any()),
+  wait_for_ack: z56.boolean().optional(),
+  ack_timeout: z56.int().min(1).max(60).optional()
+});
+
+// src/generated/cfg_centrifugo/_utils/schemas/PublishTestResponse.schema.ts
+import { z as z57 } from "zod";
+var PublishTestResponseSchema = z57.object({
+  success: z57.boolean(),
+  message_id: z57.string(),
+  channel: z57.string(),
+  acks_received: z57.int().optional(),
+  delivered: z57.boolean().optional(),
+  error: z57.string().nullable().optional()
+});
+
+// src/generated/cfg_centrifugo/_utils/schemas/TimelineItem.schema.ts
+import { z as z58 } from "zod";
+var TimelineItemSchema = z58.object({
+  timestamp: z58.string(),
+  count: z58.int(),
+  successful: z58.int(),
+  failed: z58.int(),
+  timeout: z58.int()
+});
+
+// src/generated/cfg_centrifugo/_utils/schemas/TimelineResponse.schema.ts
+import { z as z59 } from "zod";
+var TimelineResponseSchema = z59.object({
+  timeline: z59.array(TimelineItemSchema),
+  period_hours: z59.int(),
+  interval: z59.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
+import { consola as consola6 } from "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" })'
+    );
+  }
+  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) {
+    consola6.error("\u274C Zod Validation Failed");
+    consola6.box(`createCentrifugoServerChannelsCreate
+Path: /cfg/centrifugo/server/channels/
+Method: POST`);
+    if (error instanceof Error && "issues" in error && Array.isArray(error.issues)) {
+      consola6.error("Validation Issues:");
+      error.issues.forEach((issue, index) => {
+        consola6.error(`  ${index + 1}. ${issue.path.join(".") || "root"}`);
+        consola6.error(`     \u251C\u2500 Message: ${issue.message}`);
+        if (issue.expected) consola6.error(`     \u251C\u2500 Expected: ${issue.expected}`);
+        if (issue.received) consola6.error(`     \u2514\u2500 Received: ${issue.received}`);
+      });
+    }
+    consola6.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) {
+        consola6.warn("Failed to dispatch validation error event:", eventError);
+      }
+    }
+    throw error;
+  }
+}
+__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) {
+    consola6.error("\u274C Zod Validation Failed");
+    consola6.box(`createCentrifugoServerHistoryCreate
+Path: /cfg/centrifugo/server/history/
+Method: POST`);
+    if (error instanceof Error && "issues" in error && Array.isArray(error.issues)) {
+      consola6.error("Validation Issues:");
+      error.issues.forEach((issue, index) => {
+        consola6.error(`  ${index + 1}. ${issue.path.join(".") || "root"}`);
+        consola6.error(`     \u251C\u2500 Message: ${issue.message}`);
+        if (issue.expected) consola6.error(`     \u251C\u2500 Expected: ${issue.expected}`);
+        if (issue.received) consola6.error(`     \u2514\u2500 Received: ${issue.received}`);
+      });
+    }
+    consola6.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) {
+        consola6.warn("Failed to dispatch validation error event:", eventError);
+      }
+    }
+    throw error;
+  }
+}
+__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) {
+    consola6.error("\u274C Zod Validation Failed");
+    consola6.box(`createCentrifugoServerInfoCreate
+Path: /cfg/centrifugo/server/info/
+Method: POST`);
+    if (error instanceof Error && "issues" in error && Array.isArray(error.issues)) {
+      consola6.error("Validation Issues:");
+      error.issues.forEach((issue, index) => {
+        consola6.error(`  ${index + 1}. ${issue.path.join(".") || "root"}`);
+        consola6.error(`     \u251C\u2500 Message: ${issue.message}`);
+        if (issue.expected) consola6.error(`     \u251C\u2500 Expected: ${issue.expected}`);
+        if (issue.received) consola6.error(`     \u2514\u2500 Received: ${issue.received}`);
+      });
+    }
+    consola6.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) {
+        consola6.warn("Failed to dispatch validation error event:", eventError);
+      }
+    }
+    throw error;
+  }
+}
+__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) {
+    consola6.error("\u274C Zod Validation Failed");
+    consola6.box(`createCentrifugoServerPresenceCreate
+Path: /cfg/centrifugo/server/presence/
+Method: POST`);
+    if (error instanceof Error && "issues" in error && Array.isArray(error.issues)) {
+      consola6.error("Validation Issues:");
+      error.issues.forEach((issue, index) => {
+        consola6.error(`  ${index + 1}. ${issue.path.join(".") || "root"}`);
+        consola6.error(`     \u251C\u2500 Message: ${issue.message}`);
+        if (issue.expected) consola6.error(`     \u251C\u2500 Expected: ${issue.expected}`);
+        if (issue.received) consola6.error(`     \u2514\u2500 Received: ${issue.received}`);
+      });
+    }
+    consola6.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) {
+        consola6.warn("Failed to dispatch validation error event:", eventError);
+      }
+    }
+    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) {
+    consola6.error("\u274C Zod Validation Failed");
+    consola6.box(`createCentrifugoServerPresenceStatsCreate
+Path: /cfg/centrifugo/server/presence-stats/
+Method: POST`);
+    if (error instanceof Error && "issues" in error && Array.isArray(error.issues)) {
+      consola6.error("Validation Issues:");
+      error.issues.forEach((issue, index) => {
+        consola6.error(`  ${index + 1}. ${issue.path.join(".") || "root"}`);
+        consola6.error(`     \u251C\u2500 Message: ${issue.message}`);
+        if (issue.expected) consola6.error(`     \u251C\u2500 Expected: ${issue.expected}`);
+        if (issue.received) consola6.error(`     \u2514\u2500 Received: ${issue.received}`);
+      });
+    }
+    consola6.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) {
+        consola6.warn("Failed to dispatch validation error event:", eventError);
+      }
+    }
+    throw error;
+  }
+}
+__name(createCentrifugoServerPresenceStatsCreate, "createCentrifugoServerPresenceStatsCreate");
+
+// src/generated/cfg_centrifugo/_utils/fetchers/centrifugo__centrifugo_auth.ts
+import { consola as consola7 } from "consola";
+async function getCentrifugoAuthTokenRetrieve(client) {
+  const api = client || getAPIInstance3();
+  const response = await api.centrifugo_auth.tokenRetrieve();
+  try {
+    return ConnectionTokenResponseSchema.parse(response);
+  } catch (error) {
+    consola7.error("\u274C Zod Validation Failed");
+    consola7.box(`getCentrifugoAuthTokenRetrieve
+Path: /cfg/centrifugo/auth/token/
+Method: GET`);
+    if (error instanceof Error && "issues" in error && Array.isArray(error.issues)) {
+      consola7.error("Validation Issues:");
+      error.issues.forEach((issue, index) => {
+        consola7.error(`  ${index + 1}. ${issue.path.join(".") || "root"}`);
+        consola7.error(`     \u251C\u2500 Message: ${issue.message}`);
+        if (issue.expected) consola7.error(`     \u251C\u2500 Expected: ${issue.expected}`);
+        if (issue.received) consola7.error(`     \u2514\u2500 Received: ${issue.received}`);
+      });
+    }
+    consola7.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) {
+        consola7.warn("Failed to dispatch validation error event:", eventError);
+      }
+    }
+    throw error;
+  }
+}
+__name(getCentrifugoAuthTokenRetrieve, "getCentrifugoAuthTokenRetrieve");
+
+// src/generated/cfg_centrifugo/_utils/fetchers/centrifugo__centrifugo_monitoring.ts
+import { consola as consola8 } from "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) {
+    consola8.error("\u274C Zod Validation Failed");
+    consola8.box(`getCentrifugoMonitorChannelsRetrieve
+Path: /cfg/centrifugo/monitor/channels/
+Method: GET`);
+    if (error instanceof Error && "issues" in error && Array.isArray(error.issues)) {
+      consola8.error("Validation Issues:");
+      error.issues.forEach((issue, index) => {
+        consola8.error(`  ${index + 1}. ${issue.path.join(".") || "root"}`);
+        consola8.error(`     \u251C\u2500 Message: ${issue.message}`);
+        if (issue.expected) consola8.error(`     \u251C\u2500 Expected: ${issue.expected}`);
+        if (issue.received) consola8.error(`     \u2514\u2500 Received: ${issue.received}`);
+      });
+    }
+    consola8.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) {
+        consola8.warn("Failed to dispatch validation error event:", eventError);
+      }
+    }
+    throw error;
+  }
+}
+__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) {
+    consola8.error("\u274C Zod Validation Failed");
+    consola8.box(`getCentrifugoMonitorHealthRetrieve
+Path: /cfg/centrifugo/monitor/health/
+Method: GET`);
+    if (error instanceof Error && "issues" in error && Array.isArray(error.issues)) {
+      consola8.error("Validation Issues:");
+      error.issues.forEach((issue, index) => {
+        consola8.error(`  ${index + 1}. ${issue.path.join(".") || "root"}`);
+        consola8.error(`     \u251C\u2500 Message: ${issue.message}`);
+        if (issue.expected) consola8.error(`     \u251C\u2500 Expected: ${issue.expected}`);
+        if (issue.received) consola8.error(`     \u2514\u2500 Received: ${issue.received}`);
+      });
+    }
+    consola8.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) {
+        consola8.warn("Failed to dispatch validation error event:", eventError);
+      }
+    }
+    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) {
+    consola8.error("\u274C Zod Validation Failed");
+    consola8.box(`getCentrifugoMonitorOverviewRetrieve
+Path: /cfg/centrifugo/monitor/overview/
+Method: GET`);
+    if (error instanceof Error && "issues" in error && Array.isArray(error.issues)) {
+      consola8.error("Validation Issues:");
+      error.issues.forEach((issue, index) => {
+        consola8.error(`  ${index + 1}. ${issue.path.join(".") || "root"}`);
+        consola8.error(`     \u251C\u2500 Message: ${issue.message}`);
+        if (issue.expected) consola8.error(`     \u251C\u2500 Expected: ${issue.expected}`);
+        if (issue.received) consola8.error(`     \u2514\u2500 Received: ${issue.received}`);
+      });
+    }
+    consola8.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) {
+        consola8.warn("Failed to dispatch validation error event:", eventError);
+      }
+    }
+    throw error;
+  }
+}
+__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) {
+    consola8.error("\u274C Zod Validation Failed");
+    consola8.box(`getCentrifugoMonitorPublishesList
+Path: /cfg/centrifugo/monitor/publishes/
+Method: GET`);
+    if (error instanceof Error && "issues" in error && Array.isArray(error.issues)) {
+      consola8.error("Validation Issues:");
+      error.issues.forEach((issue, index) => {
+        consola8.error(`  ${index + 1}. ${issue.path.join(".") || "root"}`);
+        consola8.error(`     \u251C\u2500 Message: ${issue.message}`);
+        if (issue.expected) consola8.error(`     \u251C\u2500 Expected: ${issue.expected}`);
+        if (issue.received) consola8.error(`     \u2514\u2500 Received: ${issue.received}`);
+      });
+    }
+    consola8.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) {
+        consola8.warn("Failed to dispatch validation error event:", eventError);
+      }
+    }
+    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) {
+    consola8.error("\u274C Zod Validation Failed");
+    consola8.box(`getCentrifugoMonitorTimelineRetrieve
+Path: /cfg/centrifugo/monitor/timeline/
+Method: GET`);
+    if (error instanceof Error && "issues" in error && Array.isArray(error.issues)) {
+      consola8.error("Validation Issues:");
+      error.issues.forEach((issue, index) => {
+        consola8.error(`  ${index + 1}. ${issue.path.join(".") || "root"}`);
+        consola8.error(`     \u251C\u2500 Message: ${issue.message}`);
+        if (issue.expected) consola8.error(`     \u251C\u2500 Expected: ${issue.expected}`);
+        if (issue.received) consola8.error(`     \u2514\u2500 Received: ${issue.received}`);
+      });
+    }
+    consola8.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) {
+        consola8.warn("Failed to dispatch validation error event:", eventError);
+      }
+    }
+    throw error;
+  }
+}
+__name(getCentrifugoMonitorTimelineRetrieve, "getCentrifugoMonitorTimelineRetrieve");
+
+// src/generated/cfg_centrifugo/_utils/fetchers/centrifugo__centrifugo_testing.ts
+import { consola as consola9 } from "consola";
+async function createCentrifugoTestingPublishTestCreate(data, client) {
+  const api = client || getAPIInstance3();
+  const response = await api.centrifugo_testing.publishTestCreate(data);
+  try {
+    return PublishTestResponseSchema.parse(response);
+  } catch (error) {
+    consola9.error("\u274C Zod Validation Failed");
+    consola9.box(`createCentrifugoTestingPublishTestCreate
+Path: /cfg/centrifugo/testing/publish-test/
+Method: POST`);
+    if (error instanceof Error && "issues" in error && Array.isArray(error.issues)) {
+      consola9.error("Validation Issues:");
+      error.issues.forEach((issue, index) => {
+        consola9.error(`  ${index + 1}. ${issue.path.join(".") || "root"}`);
+        consola9.error(`     \u251C\u2500 Message: ${issue.message}`);
+        if (issue.expected) consola9.error(`     \u251C\u2500 Expected: ${issue.expected}`);
+        if (issue.received) consola9.error(`     \u2514\u2500 Received: ${issue.received}`);
+      });
+    }
+    consola9.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) {
+        consola9.warn("Failed to dispatch validation error event:", eventError);
+      }
+    }
+    throw error;
+  }
+}
+__name(createCentrifugoTestingPublishTestCreate, "createCentrifugoTestingPublishTestCreate");
+async function createCentrifugoTestingPublishWithLoggingCreate(data, client) {
+  const api = client || getAPIInstance3();
+  const response = await api.centrifugo_testing.publishWithLoggingCreate(data);
+  try {
+    return PublishTestResponseSchema.parse(response);
+  } catch (error) {
+    consola9.error("\u274C Zod Validation Failed");
+    consola9.box(`createCentrifugoTestingPublishWithLoggingCreate
+Path: /cfg/centrifugo/testing/publish-with-logging/
+Method: POST`);
+    if (error instanceof Error && "issues" in error && Array.isArray(error.issues)) {
+      consola9.error("Validation Issues:");
+      error.issues.forEach((issue, index) => {
+        consola9.error(`  ${index + 1}. ${issue.path.join(".") || "root"}`);
+        consola9.error(`     \u251C\u2500 Message: ${issue.message}`);
+        if (issue.expected) consola9.error(`     \u251C\u2500 Expected: ${issue.expected}`);
+        if (issue.received) consola9.error(`     \u2514\u2500 Received: ${issue.received}`);
+      });
+    }
+    consola9.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) {
+        consola9.warn("Failed to dispatch validation error event:", eventError);
+      }
+    }
+    throw error;
+  }
+}
+__name(createCentrifugoTestingPublishWithLoggingCreate, "createCentrifugoTestingPublishWithLoggingCreate");
+async function createCentrifugoTestingSendAckCreate(data, client) {
+  const api = client || getAPIInstance3();
+  const response = await api.centrifugo_testing.sendAckCreate(data);
+  try {
+    return ManualAckResponseSchema.parse(response);
+  } catch (error) {
+    consola9.error("\u274C Zod Validation Failed");
+    consola9.box(`createCentrifugoTestingSendAckCreate
+Path: /cfg/centrifugo/testing/send-ack/
+Method: POST`);
+    if (error instanceof Error && "issues" in error && Array.isArray(error.issues)) {
+      consola9.error("Validation Issues:");
+      error.issues.forEach((issue, index) => {
+        consola9.error(`  ${index + 1}. ${issue.path.join(".") || "root"}`);
+        consola9.error(`     \u251C\u2500 Message: ${issue.message}`);
+        if (issue.expected) consola9.error(`     \u251C\u2500 Expected: ${issue.expected}`);
+        if (issue.received) consola9.error(`     \u2514\u2500 Received: ${issue.received}`);
+      });
+    }
+    consola9.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) {
+        consola9.warn("Failed to dispatch validation error event:", eventError);
+      }
+    }
+    throw error;
+  }
+}
+__name(createCentrifugoTestingSendAckCreate, "createCentrifugoTestingSendAckCreate");
+
+// src/generated/cfg_centrifugo/index.ts
+var TOKEN_KEY3 = "auth_token";
+var REFRESH_TOKEN_KEY3 = "refresh_token";
+var API3 = class {
+  constructor(baseUrl, options) {
+    this._token = null;
+    this._refreshToken = null;
+    this.baseUrl = baseUrl;
+    this.options = options;
+    const logger = options?.loggerConfig ? new APILogger3(options.loggerConfig) : void 0;
+    this.storage = options?.storage || new LocalStorageAdapter3(logger);
+    this._loadTokensFromStorage();
+    this._client = new APIClient3(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, "API");
+  }
+  _loadTokensFromStorage() {
+    this._token = this.storage.getItem(TOKEN_KEY3);
+    this._refreshToken = this.storage.getItem(REFRESH_TOKEN_KEY3);
+  }
+  _reinitClients() {
+    this._client = new APIClient3(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);
+    };
+  }
+  /**
+   * Get current JWT token
+   */
+  getToken() {
+    return this.storage.getItem(TOKEN_KEY3);
+  }
+  /**
+   * Get current refresh token
+   */
+  getRefreshToken() {
+    return this.storage.getItem(REFRESH_TOKEN_KEY3);
+  }
+  /**
+   * 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_KEY3, token);
+    if (refreshToken) {
+      this._refreshToken = refreshToken;
+      this.storage.setItem(REFRESH_TOKEN_KEY3, refreshToken);
+    }
+    this._reinitClients();
+  }
+  /**
+   * Clear all tokens
+   */
+  clearTokens() {
+    this._token = null;
+    this._refreshToken = null;
+    this.storage.removeItem(TOKEN_KEY3);
+    this.storage.removeItem(REFRESH_TOKEN_KEY3);
+    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;
+  }
+  /**
+   * 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";
+  }
+};
+
+// src/generated/cfg_accounts/_utils/hooks/accounts__auth.ts
+import { useSWRConfig } from "swr";
+function useCreateAccountsTokenRefreshCreate() {
+  const { mutate } = useSWRConfig();
+  return async (data, client) => {
+    const result = await createAccountsTokenRefreshCreate(data, client);
+    mutate("cfg-accounts-token-refresh");
+    return result;
+  };
+}
+__name(useCreateAccountsTokenRefreshCreate, "useCreateAccountsTokenRefreshCreate");
+
+// src/generated/cfg_accounts/_utils/hooks/accounts__oauth.ts
+import useSWR from "swr";
+import { useSWRConfig as useSWRConfig2 } from "swr";
+function useAccountsOauthConnectionsList(client) {
+  return useSWR(
+    "cfg-accounts-oauth-connections",
+    () => getAccountsOauthConnectionsList(client)
+  );
+}
+__name(useAccountsOauthConnectionsList, "useAccountsOauthConnectionsList");
+function useCreateAccountsOauthDisconnectCreate() {
+  const { mutate } = useSWRConfig2();
+  return async (data, client) => {
+    const result = await createAccountsOauthDisconnectCreate(data, client);
+    mutate("cfg-accounts-oauth-disconnect");
+    return result;
+  };
+}
+__name(useCreateAccountsOauthDisconnectCreate, "useCreateAccountsOauthDisconnectCreate");
+function useCreateAccountsOauthGithubAuthorizeCreate() {
+  const { mutate } = useSWRConfig2();
+  return async (data, client) => {
+    const result = await createAccountsOauthGithubAuthorizeCreate(data, client);
+    mutate("cfg-accounts-oauth-github-authorize");
+    return result;
+  };
+}
+__name(useCreateAccountsOauthGithubAuthorizeCreate, "useCreateAccountsOauthGithubAuthorizeCreate");
+function useCreateAccountsOauthGithubCallbackCreate() {
+  const { mutate } = useSWRConfig2();
+  return async (data, client) => {
+    const result = await createAccountsOauthGithubCallbackCreate(data, client);
+    mutate("cfg-accounts-oauth-github-callback");
+    return result;
+  };
+}
+__name(useCreateAccountsOauthGithubCallbackCreate, "useCreateAccountsOauthGithubCallbackCreate");
+function useAccountsOauthProvidersRetrieve(client) {
+  return useSWR(
+    "cfg-accounts-oauth-provider",
+    () => getAccountsOauthProvidersRetrieve(client)
+  );
+}
+__name(useAccountsOauthProvidersRetrieve, "useAccountsOauthProvidersRetrieve");
+
+// src/generated/cfg_accounts/_utils/hooks/accounts__user_profile.ts
+import useSWR2 from "swr";
+import { useSWRConfig as useSWRConfig3 } from "swr";
+function useAccountsProfileRetrieve(client) {
+  return useSWR2(
+    "cfg-accounts-profile",
+    () => getAccountsProfileRetrieve(client)
+  );
+}
+__name(useAccountsProfileRetrieve, "useAccountsProfileRetrieve");
+function useCreateAccountsProfileAvatarCreate() {
+  const { mutate } = useSWRConfig3();
+  return async (data, client) => {
+    const result = await createAccountsProfileAvatarCreate(data, client);
+    mutate("cfg-accounts-profile-avatar");
+    return result;
+  };
+}
+__name(useCreateAccountsProfileAvatarCreate, "useCreateAccountsProfileAvatarCreate");
+function usePartialUpdateAccountsProfilePartialUpdate() {
+  const { mutate } = useSWRConfig3();
+  return async (data, client) => {
+    const result = await partialUpdateAccountsProfilePartialUpdate(data, client);
+    mutate("cfg-accounts-profile-partial");
+    return result;
+  };
+}
+__name(usePartialUpdateAccountsProfilePartialUpdate, "usePartialUpdateAccountsProfilePartialUpdate");
+function usePartialUpdateAccountsProfilePartialPartialUpdate() {
+  const { mutate } = useSWRConfig3();
+  return async (data, client) => {
+    const result = await partialUpdateAccountsProfilePartialPartialUpdate(data, client);
+    mutate("cfg-accounts-profile-partial-partial");
+    return result;
+  };
+}
+__name(usePartialUpdateAccountsProfilePartialPartialUpdate, "usePartialUpdateAccountsProfilePartialPartialUpdate");
+function useUpdateAccountsProfileUpdateUpdate() {
+  const { mutate } = useSWRConfig3();
+  return async (data, client) => {
+    const result = await updateAccountsProfileUpdateUpdate(data, client);
+    mutate("cfg-accounts-profile");
+    return result;
+  };
+}
+__name(useUpdateAccountsProfileUpdateUpdate, "useUpdateAccountsProfileUpdateUpdate");
+function usePartialUpdateAccountsProfileUpdatePartialUpdate() {
+  const { mutate } = useSWRConfig3();
+  return async (data, client) => {
+    const result = await partialUpdateAccountsProfileUpdatePartialUpdate(data, client);
+    mutate("cfg-accounts-profile-partial");
+    return result;
+  };
+}
+__name(usePartialUpdateAccountsProfileUpdatePartialUpdate, "usePartialUpdateAccountsProfileUpdatePartialUpdate");
+
+// src/generated/cfg_accounts/_utils/hooks/accounts.ts
+import { useSWRConfig as useSWRConfig4 } from "swr";
+function useCreateAccountsOtpRequestCreate() {
+  const { mutate } = useSWRConfig4();
+  return async (data, client) => {
+    const result = await createAccountsOtpRequestCreate(data, client);
+    mutate("cfg-accounts-otp-request");
+    return result;
+  };
+}
+__name(useCreateAccountsOtpRequestCreate, "useCreateAccountsOtpRequestCreate");
+function useCreateAccountsOtpVerifyCreate() {
+  const { mutate } = useSWRConfig4();
+  return async (data, client) => {
+    const result = await createAccountsOtpVerifyCreate(data, client);
+    mutate("cfg-accounts-otp-verify");
+    return result;
+  };
+}
+__name(useCreateAccountsOtpVerifyCreate, "useCreateAccountsOtpVerifyCreate");
+
+// src/generated/cfg_webpush/_utils/hooks/index.ts
+var hooks_exports = {};
+__export(hooks_exports, {
+  useCreateWebpushSendCreate: () => useCreateWebpushSendCreate,
+  useCreateWebpushSubscribeCreate: () => useCreateWebpushSubscribeCreate,
+  useWebpushVapidRetrieve: () => useWebpushVapidRetrieve
+});
+
+// src/generated/cfg_webpush/_utils/hooks/webpush__web_push.ts
+import useSWR3 from "swr";
+import { useSWRConfig as useSWRConfig5 } from "swr";
+function useCreateWebpushSendCreate() {
+  const { mutate } = useSWRConfig5();
+  return async (data, client) => {
+    const result = await createWebpushSendCreate(data, client);
+    mutate("cfg-webpush-send");
+    return result;
+  };
+}
+__name(useCreateWebpushSendCreate, "useCreateWebpushSendCreate");
+function useCreateWebpushSubscribeCreate() {
+  const { mutate } = useSWRConfig5();
+  return async (data, client) => {
+    const result = await createWebpushSubscribeCreate(data, client);
+    mutate("cfg-webpush-subscribe");
+    return result;
+  };
+}
+__name(useCreateWebpushSubscribeCreate, "useCreateWebpushSubscribeCreate");
+function useWebpushVapidRetrieve(client) {
+  return useSWR3(
+    "cfg-webpush-vapid",
+    () => getWebpushVapidRetrieve(client)
+  );
+}
+__name(useWebpushVapidRetrieve, "useWebpushVapidRetrieve");
+
+// src/generated/cfg_centrifugo/_utils/hooks/index.ts
+var hooks_exports2 = {};
+__export(hooks_exports2, {
+  useCentrifugoAuthTokenRetrieve: () => useCentrifugoAuthTokenRetrieve,
+  useCentrifugoMonitorChannelsRetrieve: () => useCentrifugoMonitorChannelsRetrieve,
+  useCentrifugoMonitorHealthRetrieve: () => useCentrifugoMonitorHealthRetrieve,
+  useCentrifugoMonitorOverviewRetrieve: () => useCentrifugoMonitorOverviewRetrieve,
+  useCentrifugoMonitorPublishesList: () => useCentrifugoMonitorPublishesList,
+  useCentrifugoMonitorTimelineRetrieve: () => useCentrifugoMonitorTimelineRetrieve,
+  useCreateCentrifugoServerAuthTokenCreate: () => useCreateCentrifugoServerAuthTokenCreate,
+  useCreateCentrifugoServerChannelsCreate: () => useCreateCentrifugoServerChannelsCreate,
+  useCreateCentrifugoServerHistoryCreate: () => useCreateCentrifugoServerHistoryCreate,
+  useCreateCentrifugoServerInfoCreate: () => useCreateCentrifugoServerInfoCreate,
+  useCreateCentrifugoServerPresenceCreate: () => useCreateCentrifugoServerPresenceCreate,
+  useCreateCentrifugoServerPresenceStatsCreate: () => useCreateCentrifugoServerPresenceStatsCreate,
+  useCreateCentrifugoTestingPublishTestCreate: () => useCreateCentrifugoTestingPublishTestCreate,
+  useCreateCentrifugoTestingPublishWithLoggingCreate: () => useCreateCentrifugoTestingPublishWithLoggingCreate,
+  useCreateCentrifugoTestingSendAckCreate: () => useCreateCentrifugoTestingSendAckCreate
+});
+
+// src/generated/cfg_centrifugo/_utils/hooks/centrifugo__centrifugo_admin_api.ts
+import { useSWRConfig as useSWRConfig6 } from "swr";
+function useCreateCentrifugoServerAuthTokenCreate() {
+  const { mutate } = useSWRConfig6();
+  return async (client) => {
+    const result = await createCentrifugoServerAuthTokenCreate(client);
+    mutate("cfg-centrifugo-server-auth-token");
+    return result;
+  };
+}
+__name(useCreateCentrifugoServerAuthTokenCreate, "useCreateCentrifugoServerAuthTokenCreate");
+function useCreateCentrifugoServerChannelsCreate() {
+  const { mutate } = useSWRConfig6();
+  return async (data, client) => {
+    const result = await createCentrifugoServerChannelsCreate(data, client);
+    mutate("cfg-centrifugo-server-channels");
+    return result;
+  };
+}
+__name(useCreateCentrifugoServerChannelsCreate, "useCreateCentrifugoServerChannelsCreate");
+function useCreateCentrifugoServerHistoryCreate() {
+  const { mutate } = useSWRConfig6();
+  return async (data, client) => {
+    const result = await createCentrifugoServerHistoryCreate(data, client);
+    mutate("cfg-centrifugo-server-history");
+    return result;
+  };
+}
+__name(useCreateCentrifugoServerHistoryCreate, "useCreateCentrifugoServerHistoryCreate");
+function useCreateCentrifugoServerInfoCreate() {
+  const { mutate } = useSWRConfig6();
+  return async (client) => {
+    const result = await createCentrifugoServerInfoCreate(client);
+    mutate("cfg-centrifugo-server-info");
+    return result;
+  };
+}
+__name(useCreateCentrifugoServerInfoCreate, "useCreateCentrifugoServerInfoCreate");
+function useCreateCentrifugoServerPresenceCreate() {
+  const { mutate } = useSWRConfig6();
+  return async (data, client) => {
+    const result = await createCentrifugoServerPresenceCreate(data, client);
+    mutate("cfg-centrifugo-server-presence");
+    return result;
+  };
+}
+__name(useCreateCentrifugoServerPresenceCreate, "useCreateCentrifugoServerPresenceCreate");
+function useCreateCentrifugoServerPresenceStatsCreate() {
+  const { mutate } = useSWRConfig6();
+  return async (data, client) => {
+    const result = await createCentrifugoServerPresenceStatsCreate(data, client);
+    mutate("cfg-centrifugo-server-presence-stats");
+    return result;
+  };
+}
+__name(useCreateCentrifugoServerPresenceStatsCreate, "useCreateCentrifugoServerPresenceStatsCreate");
+
+// src/generated/cfg_centrifugo/_utils/hooks/centrifugo__centrifugo_auth.ts
+import useSWR4 from "swr";
+function useCentrifugoAuthTokenRetrieve(client) {
+  return useSWR4(
+    "cfg-centrifugo-auth-token",
+    () => getCentrifugoAuthTokenRetrieve(client)
+  );
+}
+__name(useCentrifugoAuthTokenRetrieve, "useCentrifugoAuthTokenRetrieve");
+
+// src/generated/cfg_centrifugo/_utils/hooks/centrifugo__centrifugo_monitoring.ts
+import useSWR5 from "swr";
+function useCentrifugoMonitorChannelsRetrieve(params, client) {
+  return useSWR5(
+    params ? ["cfg-centrifugo-monitor-channel", params] : "cfg-centrifugo-monitor-channel",
+    () => getCentrifugoMonitorChannelsRetrieve(params, client)
+  );
+}
+__name(useCentrifugoMonitorChannelsRetrieve, "useCentrifugoMonitorChannelsRetrieve");
+function useCentrifugoMonitorHealthRetrieve(client) {
+  return useSWR5(
+    "cfg-centrifugo-monitor-health",
+    () => getCentrifugoMonitorHealthRetrieve(client)
+  );
+}
+__name(useCentrifugoMonitorHealthRetrieve, "useCentrifugoMonitorHealthRetrieve");
+function useCentrifugoMonitorOverviewRetrieve(params, client) {
+  return useSWR5(
+    params ? ["cfg-centrifugo-monitor-overview", params] : "cfg-centrifugo-monitor-overview",
+    () => getCentrifugoMonitorOverviewRetrieve(params, client)
+  );
+}
+__name(useCentrifugoMonitorOverviewRetrieve, "useCentrifugoMonitorOverviewRetrieve");
+function useCentrifugoMonitorPublishesList(params, client) {
+  return useSWR5(
+    params ? ["cfg-centrifugo-monitor-publishes", params] : "cfg-centrifugo-monitor-publishes",
+    () => getCentrifugoMonitorPublishesList(params, client)
+  );
+}
+__name(useCentrifugoMonitorPublishesList, "useCentrifugoMonitorPublishesList");
+function useCentrifugoMonitorTimelineRetrieve(params, client) {
+  return useSWR5(
+    params ? ["cfg-centrifugo-monitor-timeline", params] : "cfg-centrifugo-monitor-timeline",
+    () => getCentrifugoMonitorTimelineRetrieve(params, client)
+  );
+}
+__name(useCentrifugoMonitorTimelineRetrieve, "useCentrifugoMonitorTimelineRetrieve");
+
+// src/generated/cfg_centrifugo/_utils/hooks/centrifugo__centrifugo_testing.ts
+import { useSWRConfig as useSWRConfig7 } from "swr";
+function useCreateCentrifugoTestingPublishTestCreate() {
+  const { mutate } = useSWRConfig7();
+  return async (data, client) => {
+    const result = await createCentrifugoTestingPublishTestCreate(data, client);
+    mutate("cfg-centrifugo-testing-publish-test");
+    return result;
+  };
+}
+__name(useCreateCentrifugoTestingPublishTestCreate, "useCreateCentrifugoTestingPublishTestCreate");
+function useCreateCentrifugoTestingPublishWithLoggingCreate() {
+  const { mutate } = useSWRConfig7();
+  return async (data, client) => {
+    const result = await createCentrifugoTestingPublishWithLoggingCreate(data, client);
+    mutate("cfg-centrifugo-testing-publish-with-logging");
+    return result;
+  };
+}
+__name(useCreateCentrifugoTestingPublishWithLoggingCreate, "useCreateCentrifugoTestingPublishWithLoggingCreate");
+function useCreateCentrifugoTestingSendAckCreate() {
+  const { mutate } = useSWRConfig7();
+  return async (data, client) => {
+    const result = await createCentrifugoTestingSendAckCreate(data, client);
+    mutate("cfg-centrifugo-testing-send-ack");
+    return result;
+  };
+}
+__name(useCreateCentrifugoTestingSendAckCreate, "useCreateCentrifugoTestingSendAckCreate");
+
+// src/clients.ts
+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 });
+export {
+  API as AccountsAPI,
+  API3 as CentrifugoAPI,
+  fetchers_exports3 as CentrifugoFetchers,
+  hooks_exports2 as CentrifugoHooks,
+  CentrifugoTokenSchema,
+  schemas_exports3 as CentrifugoTypes,
+  enums_exports as Enums,
+  OAuthAuthorizeRequestRequestSchema,
+  OAuthAuthorizeResponseSchema,
+  OAuthCallbackRequestRequestSchema,
+  OAuthConnectionSchema,
+  OAuthDisconnectRequestRequestSchema,
+  OAuthErrorSchema,
+  OAuthProvidersResponseSchema,
+  OAuthTokenResponseSchema,
+  OTPErrorResponseSchema,
+  OTPRequestRequestSchema,
+  OTPRequestResponseSchema,
+  OTPVerifyRequestSchema,
+  OTPVerifyResponseSchema,
+  PatchedUserProfileUpdateRequestSchema,
+  TokenRefreshRequestSchema,
+  TokenRefreshSchema,
+  UserProfileUpdateRequestSchema,
+  UserSchema,
+  API2 as WebPushAPI,
+  fetchers_exports2 as WebPushFetchers,
+  hooks_exports as WebPushHooks,
+  schemas_exports2 as WebPushTypes,
+  apiAccounts,
+  apiCentrifugo,
+  apiWebPush,
+  createAccountsOauthDisconnectCreate,
+  createAccountsOauthGithubAuthorizeCreate,
+  createAccountsOauthGithubCallbackCreate,
+  createAccountsOtpRequestCreate,
+  createAccountsOtpVerifyCreate,
+  createAccountsProfileAvatarCreate,
+  createAccountsTokenRefreshCreate,
+  getAccountsOauthConnectionsList,
+  getAccountsOauthProvidersRetrieve,
+  getAccountsProfileRetrieve,
+  partialUpdateAccountsProfilePartialPartialUpdate,
+  partialUpdateAccountsProfilePartialUpdate,
+  partialUpdateAccountsProfileUpdatePartialUpdate,
+  updateAccountsProfileUpdateUpdate,
+  useAccountsOauthConnectionsList,
+  useAccountsOauthProvidersRetrieve,
+  useAccountsProfileRetrieve,
+  useCreateAccountsOauthDisconnectCreate,
+  useCreateAccountsOauthGithubAuthorizeCreate,
+  useCreateAccountsOauthGithubCallbackCreate,
+  useCreateAccountsOtpRequestCreate,
+  useCreateAccountsOtpVerifyCreate,
+  useCreateAccountsProfileAvatarCreate,
+  useCreateAccountsTokenRefreshCreate,
+  usePartialUpdateAccountsProfilePartialPartialUpdate,
+  usePartialUpdateAccountsProfilePartialUpdate,
+  usePartialUpdateAccountsProfileUpdatePartialUpdate,
+  useUpdateAccountsProfileUpdateUpdate
+};
+//# sourceMappingURL=clients.mjs.map