@djangocfg/api 2.1.55 → 2.1.57

package/dist/index.mjs

@@ -982,7 +982,7 @@ __export(schemas_exports, {
 import { z } from "zod";
 var CentrifugoTokenSchema = z.object({
   token: z.string(),
-  centrifugo_url: z.url(),
+  centrifugo_url: z.union([z.url(), z.literal("")]),
   expires_at: z.iso.datetime(),
   channels: z.array(z.string())
 });
@@ -990,14 +990,14 @@ var CentrifugoTokenSchema = z.object({
 // 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()
+  redirect_uri: z2.union([z2.url(), z2.literal("")]).optional(),
+  source_url: z2.union([z2.url(), z2.literal("")]).optional()
 });
 
 // src/generated/cfg_accounts/_utils/schemas/OAuthAuthorizeResponse.schema.ts
 import { z as z3 } from "zod";
 var OAuthAuthorizeResponseSchema = z3.object({
-  authorization_url: z3.url(),
+  authorization_url: z3.union([z3.url(), z3.literal("")]),
   state: z3.string()
 });
 
@@ -1006,7 +1006,7 @@ 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()
+  redirect_uri: z4.union([z4.url(), z4.literal("")]).optional()
 });
 
 // src/generated/cfg_accounts/_utils/schemas/OAuthConnection.schema.ts
@@ -1017,7 +1017,7 @@ var OAuthConnectionSchema = z5.object({
   provider_display: z5.string(),
   provider_username: z5.string(),
   provider_email: z5.email(),
-  provider_avatar_url: z5.url(),
+  provider_avatar_url: z5.union([z5.url(), z5.literal("")]),
   connected_at: z5.iso.datetime(),
   last_login_at: z5.iso.datetime()
 });
@@ -1038,7 +1038,7 @@ var OAuthErrorSchema = z7.object({
 // 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())))
+  providers: z8.array(z8.record(z8.string(), z8.any()))
 });
 
 // src/generated/cfg_accounts/_utils/schemas/OAuthTokenResponse.schema.ts
@@ -1046,7 +1046,7 @@ 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())),
+  user: z9.record(z9.string(), z9.any()),
   is_new_user: z9.boolean(),
   is_new_connection: z9.boolean()
 });
@@ -1062,7 +1062,7 @@ 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()
+  source_url: z11.union([z11.url(), z11.literal("")]).optional()
 });
 
 // src/generated/cfg_accounts/_utils/schemas/OTPRequestResponse.schema.ts
@@ -1077,7 +1077,7 @@ 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()
+  source_url: z13.union([z13.url(), z13.literal("")]).optional()
 });
 
 // src/generated/cfg_accounts/_utils/schemas/OTPVerifyResponse.schema.ts
@@ -1096,7 +1096,7 @@ var UserSchema = z14.object({
   company: z14.string().max(100).optional(),
   phone: z14.string().max(20).optional(),
   position: z14.string().max(100).optional(),
-  avatar: z14.url().nullable(),
+  avatar: z14.union([z14.url(), z14.literal("")]).nullable(),
   is_staff: z14.boolean(),
   is_superuser: z14.boolean(),
   date_joined: z14.iso.datetime(),
@@ -1218,16 +1218,30 @@ import { consola } from "consola";
 
 // src/generated/cfg_accounts/api-instance.ts
 var globalAPI = null;
+var autoConfigAttempted = false;
+function tryAutoConfigureFromEnv() {
+  if (autoConfigAttempted) return;
+  autoConfigAttempted = true;
+  if (globalAPI) return;
+  if (typeof process === "undefined" || !process.env) return;
+  const baseUrl = process.env.NEXT_PUBLIC_API_URL || process.env.VITE_API_URL || process.env.REACT_APP_API_URL || process.env.API_URL;
+  if (baseUrl) {
+    globalAPI = new API(baseUrl);
+  }
+}
+__name(tryAutoConfigureFromEnv, "tryAutoConfigureFromEnv");
 function getAPIInstance() {
+  tryAutoConfigureFromEnv();
   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" })'
+      '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" })\n\nOr set environment variable: NEXT_PUBLIC_API_URL, VITE_API_URL, or REACT_APP_API_URL'
     );
   }
   return globalAPI;
 }
 __name(getAPIInstance, "getAPIInstance");
 function isAPIConfigured() {
+  tryAutoConfigureFromEnv();
   return globalAPI !== null;
 }
 __name(isAPIConfigured, "isAPIConfigured");
@@ -1930,6 +1944,360 @@ var API = class {
 };
 var cfg_accounts_default = API;
 
+// 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 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_centrifugo/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_centrifugo/logger.ts
 import { createConsola as createConsola2 } from "consola";
 var DEFAULT_CONFIG2 = {
@@ -2040,52 +2408,354 @@ var APILogger2 = class {
       });
     }
   }
-  /**
-   * 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 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_centrifugo/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_centrifugo/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.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 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_centrifugo/storage.ts
+var LocalStorageAdapter2 = class {
+  static {
+    __name(this, "LocalStorageAdapter");
   }
-  /**
-   * Log error
-   */
-  error(message, ...args) {
-    if (!this.config.enabled) return;
-    this.consola.error(message, ...args);
+  constructor(logger) {
+    this.logger = logger;
   }
-  /**
-   * Log debug
-   */
-  debug(message, ...args) {
-    if (!this.config.enabled) return;
-    this.consola.debug(message, ...args);
+  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;
   }
-  /**
-   * Log success
-   */
-  success(message, ...args) {
-    if (!this.config.enabled) return;
-    this.consola.success(message, ...args);
+  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);
+    }
   }
-  /**
-   * Create a sub-logger with prefix
-   */
-  withTag(tag) {
-    return this.consola.withTag(tag);
+  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);
+    }
   }
 };
-var defaultLogger2 = new APILogger2();
-
-// src/generated/cfg_centrifugo/retry.ts
-import pRetry2, { AbortError as AbortError2 } from "p-retry";
 
 // src/generated/cfg_centrifugo/_utils/schemas/CentrifugoChannelInfo.schema.ts
 import { z as z20 } from "zod";
@@ -2409,10 +3079,23 @@ import { consola as consola5 } from "consola";
 
 // src/generated/cfg_centrifugo/api-instance.ts
 var globalAPI2 = null;
+var autoConfigAttempted2 = false;
+function tryAutoConfigureFromEnv2() {
+  if (autoConfigAttempted2) return;
+  autoConfigAttempted2 = true;
+  if (globalAPI2) return;
+  if (typeof process === "undefined" || !process.env) return;
+  const baseUrl = process.env.NEXT_PUBLIC_API_URL || process.env.VITE_API_URL || process.env.REACT_APP_API_URL || process.env.API_URL;
+  if (baseUrl) {
+    globalAPI2 = new API2(baseUrl);
+  }
+}
+__name(tryAutoConfigureFromEnv2, "tryAutoConfigureFromEnv");
 function getAPIInstance2() {
+  tryAutoConfigureFromEnv2();
   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" })'
+      '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" })\n\nOr set environment variable: NEXT_PUBLIC_API_URL, VITE_API_URL, or REACT_APP_API_URL'
     );
   }
   return globalAPI2;
@@ -2471,6 +3154,133 @@ import { consola as consola7 } from "consola";
 // src/generated/cfg_centrifugo/_utils/fetchers/centrifugo__centrifugo_testing.ts
 import { consola as consola8 } from "consola";
 
+// src/generated/cfg_centrifugo/index.ts
+var TOKEN_KEY2 = "auth_token";
+var REFRESH_TOKEN_KEY2 = "refresh_token";
+var API2 = class {
+  constructor(baseUrl, options) {
+    this._token = null;
+    this._refreshToken = null;
+    this.baseUrl = baseUrl;
+    this.options = options;
+    const logger = options?.loggerConfig ? new APILogger2(options.loggerConfig) : void 0;
+    this.storage = options?.storage || new LocalStorageAdapter2(logger);
+    this._loadTokensFromStorage();
+    this._client = new APIClient2(this.baseUrl, {
+      retryConfig: this.options?.retryConfig,
+      loggerConfig: this.options?.loggerConfig
+    });
+    this._injectAuthHeader();
+    this.centrifugo_admin_api = this._client.centrifugo_admin_api;
+    this.centrifugo_auth = this._client.centrifugo_auth;
+    this.centrifugo_monitoring = this._client.centrifugo_monitoring;
+    this.centrifugo_testing = this._client.centrifugo_testing;
+  }
+  static {
+    __name(this, "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.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_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_webpush/index.ts
 var cfg_webpush_exports = {};
 __export(cfg_webpush_exports, {
@@ -2485,13 +3295,13 @@ __export(cfg_webpush_exports, {
   LocalStorageAdapter: () => LocalStorageAdapter3,
   MemoryStorageAdapter: () => MemoryStorageAdapter3,
   NetworkError: () => NetworkError3,
-  REFRESH_TOKEN_KEY: () => REFRESH_TOKEN_KEY2,
+  REFRESH_TOKEN_KEY: () => REFRESH_TOKEN_KEY3,
   Schemas: () => schemas_exports3,
   SendPushRequestRequestSchema: () => SendPushRequestRequestSchema,
   SendPushResponseSchema: () => SendPushResponseSchema,
   SubscribeRequestRequestSchema: () => SubscribeRequestRequestSchema,
   SubscribeResponseSchema: () => SubscribeResponseSchema,
-  TOKEN_KEY: () => TOKEN_KEY2,
+  TOKEN_KEY: () => TOKEN_KEY3,
   VapidPublicKeyResponseSchema: () => VapidPublicKeyResponseSchema,
   WebPushTypes: () => models_exports9,
   clearAPITokens: () => clearAPITokens3,
@@ -3240,8 +4050,8 @@ import { z as z55 } from "zod";
 var SendPushRequestRequestSchema = z55.object({
   title: z55.string().min(1).max(255),
   body: z55.string().min(1),
-  icon: z55.url().nullable().optional(),
-  url: z55.url().nullable().optional()
+  icon: z55.union([z55.url(), z55.literal("")]).nullable().optional(),
+  url: z55.union([z55.url(), z55.literal("")]).nullable().optional()
 });
 
 // src/generated/cfg_webpush/_utils/schemas/SendPushResponse.schema.ts
@@ -3254,7 +4064,7 @@ var SendPushResponseSchema = z56.object({
 // src/generated/cfg_webpush/_utils/schemas/SubscribeRequestRequest.schema.ts
 import { z as z57 } from "zod";
 var SubscribeRequestRequestSchema = z57.object({
-  endpoint: z57.url(),
+  endpoint: z57.union([z57.url(), z57.literal("")]),
   keys: z57.record(z57.string(), z57.string().min(1))
 });
 
@@ -3334,16 +4144,30 @@ import { consola as consola9 } from "consola";
 
 // src/generated/cfg_webpush/api-instance.ts
 var globalAPI3 = null;
+var autoConfigAttempted3 = false;
+function tryAutoConfigureFromEnv3() {
+  if (autoConfigAttempted3) return;
+  autoConfigAttempted3 = true;
+  if (globalAPI3) return;
+  if (typeof process === "undefined" || !process.env) return;
+  const baseUrl = process.env.NEXT_PUBLIC_API_URL || process.env.VITE_API_URL || process.env.REACT_APP_API_URL || process.env.API_URL;
+  if (baseUrl) {
+    globalAPI3 = new API3(baseUrl);
+  }
+}
+__name(tryAutoConfigureFromEnv3, "tryAutoConfigureFromEnv");
 function getAPIInstance3() {
+  tryAutoConfigureFromEnv3();
   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" })'
+      '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" })\n\nOr set environment variable: NEXT_PUBLIC_API_URL, VITE_API_URL, or REACT_APP_API_URL'
     );
   }
   return globalAPI3;
 }
 __name(getAPIInstance3, "getAPIInstance");
 function isAPIConfigured3() {
+  tryAutoConfigureFromEnv3();
   return globalAPI3 !== null;
 }
 __name(isAPIConfigured3, "isAPIConfigured");
@@ -3511,8 +4335,8 @@ Method: GET`);
 __name(getWebpushVapidRetrieve, "getWebpushVapidRetrieve");
 
 // src/generated/cfg_webpush/index.ts
-var TOKEN_KEY2 = "auth_token";
-var REFRESH_TOKEN_KEY2 = "refresh_token";
+var TOKEN_KEY3 = "auth_token";
+var REFRESH_TOKEN_KEY3 = "refresh_token";
 var API3 = class {
   constructor(baseUrl, options) {
     this._token = null;
@@ -3533,8 +4357,8 @@ var API3 = class {
     __name(this, "API");
   }
   _loadTokensFromStorage() {
-    this._token = this.storage.getItem(TOKEN_KEY2);
-    this._refreshToken = this.storage.getItem(REFRESH_TOKEN_KEY2);
+    this._token = this.storage.getItem(TOKEN_KEY3);
+    this._refreshToken = this.storage.getItem(REFRESH_TOKEN_KEY3);
   }
   _reinitClients() {
     this._client = new APIClient3(this.baseUrl, {
@@ -3562,13 +4386,13 @@ var API3 = class {
    * Get current JWT token
    */
   getToken() {
-    return this.storage.getItem(TOKEN_KEY2);
+    return this.storage.getItem(TOKEN_KEY3);
   }
   /**
    * Get current refresh token
    */
   getRefreshToken() {
-    return this.storage.getItem(REFRESH_TOKEN_KEY2);
+    return this.storage.getItem(REFRESH_TOKEN_KEY3);
   }
   /**
    * Set JWT token and refresh token
@@ -3577,10 +4401,10 @@ var API3 = class {
    */
   setToken(token, refreshToken) {
     this._token = token;
-    this.storage.setItem(TOKEN_KEY2, token);
+    this.storage.setItem(TOKEN_KEY3, token);
     if (refreshToken) {
       this._refreshToken = refreshToken;
-      this.storage.setItem(REFRESH_TOKEN_KEY2, refreshToken);
+      this.storage.setItem(REFRESH_TOKEN_KEY3, refreshToken);
     }
     this._reinitClients();
   }
@@ -3590,8 +4414,8 @@ var API3 = class {
   clearTokens() {
     this._token = null;
     this._refreshToken = null;
-    this.storage.removeItem(TOKEN_KEY2);
-    this.storage.removeItem(REFRESH_TOKEN_KEY2);
+    this.storage.removeItem(TOKEN_KEY3);
+    this.storage.removeItem(REFRESH_TOKEN_KEY3);
     this._reinitClients();
   }
   /**