@djangocfg/api 2.1.56 → 2.1.58

package/dist/clients.cjs

@@ -53,14 +53,19 @@ __export(clients_exports, {
   PatchedUserProfileUpdateRequestSchema: () => PatchedUserProfileUpdateRequestSchema,
   TokenRefreshRequestSchema: () => TokenRefreshRequestSchema,
   TokenRefreshSchema: () => TokenRefreshSchema,
+  TotpAPI: () => API3,
+  TotpFetchers: () => fetchers_exports3,
+  TotpHooks: () => hooks_exports3,
+  TotpTypes: () => schemas_exports3,
   UserProfileUpdateRequestSchema: () => UserProfileUpdateRequestSchema,
   UserSchema: () => UserSchema,
-  WebPushAPI: () => API3,
-  WebPushFetchers: () => fetchers_exports3,
+  WebPushAPI: () => API4,
+  WebPushFetchers: () => fetchers_exports4,
   WebPushHooks: () => hooks_exports,
-  WebPushTypes: () => schemas_exports3,
+  WebPushTypes: () => schemas_exports4,
   apiAccounts: () => apiAccounts,
   apiCentrifugo: () => apiCentrifugo,
+  apiTotp: () => apiTotp,
   apiWebPush: () => apiWebPush,
   createAccountsOauthDisconnectCreate: () => createAccountsOauthDisconnectCreate,
   createAccountsOauthGithubAuthorizeCreate: () => createAccountsOauthGithubAuthorizeCreate,
@@ -250,7 +255,10 @@ var Accounts = class {
     return response;
   }
   /**
-   * Verify OTP code and return JWT tokens.
+   * Verify OTP code and return JWT tokens or 2FA session. If user has 2FA
+   * enabled: - Returns requires_2fa=True with session_id - Client must
+   * complete 2FA verification at /cfg/totp/verify/ If user has no 2FA: -
+   * Returns JWT tokens and user data directly
    */
   async otpVerifyCreate(data) {
     const response = await this.client.request("POST", "/cfg/accounts/otp/verify/", { body: data });
@@ -264,7 +272,7 @@ var FetchAdapter = class {
     __name(this, "FetchAdapter");
   }
   async request(request) {
-    const { method, url, headers, body, params, formData } = request;
+    const { method, url, headers, body, params, formData, binaryBody } = request;
     let finalUrl = url;
     if (params) {
       const searchParams = new URLSearchParams();
@@ -282,6 +290,9 @@ var FetchAdapter = class {
     let requestBody;
     if (formData) {
       requestBody = formData;
+    } else if (binaryBody) {
+      finalHeaders["Content-Type"] = "application/octet-stream";
+      requestBody = binaryBody;
     } else if (body) {
       finalHeaders["Content-Type"] = "application/json";
       requestBody = JSON.stringify(body);
@@ -681,7 +692,7 @@ var APIClient = class {
     const headers = {
       ...options?.headers || {}
     };
-    if (!options?.formData && !headers["Content-Type"]) {
+    if (!options?.formData && !options?.binaryBody && !headers["Content-Type"]) {
       headers["Content-Type"] = "application/json";
     }
     if (this.logger) {
@@ -700,7 +711,8 @@ var APIClient = class {
         headers,
         params: options?.params,
         body: options?.body,
-        formData: options?.formData
+        formData: options?.formData,
+        binaryBody: options?.binaryBody
       });
       const duration = Date.now() - startTime;
       if (response.status >= 400) {
@@ -954,11 +966,14 @@ var OAuthProvidersResponseSchema = import_zod8.z.object({
 // src/generated/cfg_accounts/_utils/schemas/OAuthTokenResponse.schema.ts
 var import_zod9 = require("zod");
 var OAuthTokenResponseSchema = import_zod9.z.object({
-  access: import_zod9.z.string(),
-  refresh: import_zod9.z.string(),
-  user: import_zod9.z.record(import_zod9.z.string(), import_zod9.z.any()),
+  requires_2fa: import_zod9.z.boolean().optional(),
+  session_id: import_zod9.z.string().regex(/^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i).nullable().optional(),
+  access: import_zod9.z.string().nullable().optional(),
+  refresh: import_zod9.z.string().nullable().optional(),
+  user: import_zod9.z.record(import_zod9.z.string(), import_zod9.z.any()).nullable().optional(),
   is_new_user: import_zod9.z.boolean(),
-  is_new_connection: import_zod9.z.boolean()
+  is_new_connection: import_zod9.z.boolean(),
+  should_prompt_2fa: import_zod9.z.boolean().optional()
 });
 
 // src/generated/cfg_accounts/_utils/schemas/OTPErrorResponse.schema.ts
@@ -1017,9 +1032,12 @@ var UserSchema = import_zod14.z.object({
 
 // src/generated/cfg_accounts/_utils/schemas/OTPVerifyResponse.schema.ts
 var OTPVerifyResponseSchema = import_zod15.z.object({
-  refresh: import_zod15.z.string(),
-  access: import_zod15.z.string(),
-  user: UserSchema
+  requires_2fa: import_zod15.z.boolean().optional(),
+  session_id: import_zod15.z.string().regex(/^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i).nullable().optional(),
+  refresh: import_zod15.z.string().nullable().optional(),
+  access: import_zod15.z.string().nullable().optional(),
+  user: UserSchema.nullable().optional(),
+  should_prompt_2fa: import_zod15.z.boolean().optional()
 });
 
 // src/generated/cfg_accounts/_utils/schemas/PatchedUserProfileUpdateRequest.schema.ts
@@ -1965,7 +1983,7 @@ var FetchAdapter2 = class {
     __name(this, "FetchAdapter");
   }
   async request(request) {
-    const { method, url, headers, body, params, formData } = request;
+    const { method, url, headers, body, params, formData, binaryBody } = request;
     let finalUrl = url;
     if (params) {
       const searchParams = new URLSearchParams();
@@ -1983,6 +2001,9 @@ var FetchAdapter2 = class {
     let requestBody;
     if (formData) {
       requestBody = formData;
+    } else if (binaryBody) {
+      finalHeaders["Content-Type"] = "application/octet-stream";
+      requestBody = binaryBody;
     } else if (body) {
       finalHeaders["Content-Type"] = "application/json";
       requestBody = JSON.stringify(body);
@@ -2382,7 +2403,7 @@ var APIClient2 = class {
     const headers = {
       ...options?.headers || {}
     };
-    if (!options?.formData && !headers["Content-Type"]) {
+    if (!options?.formData && !options?.binaryBody && !headers["Content-Type"]) {
       headers["Content-Type"] = "application/json";
     }
     if (this.logger) {
@@ -2401,7 +2422,8 @@ var APIClient2 = class {
         headers,
         params: options?.params,
         body: options?.body,
-        formData: options?.formData
+        formData: options?.formData,
+        binaryBody: options?.binaryBody
       });
       const duration = Date.now() - startTime;
       if (response.status >= 400) {
@@ -3713,6 +3735,1370 @@ var API2 = class {
   }
 };
 
+// src/generated/cfg_totp/totp__backup_codes/client.ts
+var BackupCodes = class {
+  static {
+    __name(this, "BackupCodes");
+  }
+  constructor(client) {
+    this.client = client;
+  }
+  /**
+   * Get backup codes status for user.
+   */
+  async totpBackupCodesRetrieve() {
+    const response = await this.client.request("GET", "/cfg/totp/backup-codes/");
+    return response;
+  }
+  /**
+   * Regenerate backup codes. Requires TOTP code for verification.
+   * Invalidates all existing codes.
+   */
+  async totpBackupCodesRegenerateCreate(data) {
+    const response = await this.client.request("POST", "/cfg/totp/backup-codes/regenerate/", { body: data });
+    return response;
+  }
+};
+
+// src/generated/cfg_totp/totp__totp_management/client.ts
+var TotpManagement = class {
+  static {
+    __name(this, "TotpManagement");
+  }
+  constructor(client) {
+    this.client = client;
+  }
+  /**
+   * List all TOTP devices for user.
+   */
+  async totpDevicesList(...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 = { page: args[0], page_size: args[1] };
+    }
+    const response = await this.client.request("GET", "/cfg/totp/devices/", { params });
+    return response;
+  }
+  /**
+   * Completely disable 2FA for account. Requires verification code.
+   */
+  async totpDisableCreate(data) {
+    const response = await this.client.request("POST", "/cfg/totp/disable/", { body: data });
+    return response;
+  }
+};
+
+// src/generated/cfg_totp/totp__totp_setup/client.ts
+var TotpSetup = class {
+  static {
+    __name(this, "TotpSetup");
+  }
+  constructor(client) {
+    this.client = client;
+  }
+  /**
+   * Start 2FA setup process. Creates a new TOTP device and returns QR code
+   * for scanning.
+   */
+  async create(data) {
+    const response = await this.client.request("POST", "/cfg/totp/setup/", { body: data });
+    return response;
+  }
+  /**
+   * Confirm 2FA setup with first valid code. Activates the device and
+   * generates backup codes.
+   */
+  async confirmCreate(data) {
+    const response = await this.client.request("POST", "/cfg/totp/setup/confirm/", { body: data });
+    return response;
+  }
+};
+
+// src/generated/cfg_totp/totp__totp_verification/client.ts
+var TotpVerification = class {
+  static {
+    __name(this, "TotpVerification");
+  }
+  constructor(client) {
+    this.client = client;
+  }
+  /**
+   * Verify TOTP code for 2FA session. Completes authentication and returns
+   * JWT tokens on success.
+   */
+  async totpVerifyCreate(data) {
+    const response = await this.client.request("POST", "/cfg/totp/verify/", { body: data });
+    return response;
+  }
+  /**
+   * Verify backup recovery code for 2FA session. Alternative verification
+   * method when TOTP device unavailable.
+   */
+  async totpVerifyBackupCreate(data) {
+    const response = await this.client.request("POST", "/cfg/totp/verify/backup/", { body: data });
+    return response;
+  }
+};
+
+// src/generated/cfg_totp/totp/client.ts
+var Totp = class {
+  static {
+    __name(this, "Totp");
+  }
+  constructor(client) {
+    this.client = client;
+  }
+  /**
+   * Delete a TOTP device. Requires verification code if removing the
+   * last/primary device.
+   */
+  async devicesDestroy(id) {
+    const response = await this.client.request("DELETE", `/cfg/totp/devices/${id}/`);
+    return;
+  }
+};
+
+// src/generated/cfg_totp/http.ts
+var FetchAdapter3 = class {
+  static {
+    __name(this, "FetchAdapter");
+  }
+  async request(request) {
+    const { method, url, headers, body, params, formData, binaryBody } = 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 (binaryBody) {
+      finalHeaders["Content-Type"] = "application/octet-stream";
+      requestBody = binaryBody;
+    } 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_totp/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_totp/logger.ts
+var import_consola11 = require("consola");
+var DEFAULT_CONFIG3 = {
+  enabled: process.env.NODE_ENV !== "production",
+  logRequests: true,
+  logResponses: true,
+  logErrors: true,
+  logBodies: true,
+  logHeaders: false
+};
+var SENSITIVE_HEADERS3 = [
+  "authorization",
+  "cookie",
+  "set-cookie",
+  "x-api-key",
+  "x-csrf-token"
+];
+var APILogger3 = class {
+  static {
+    __name(this, "APILogger");
+  }
+  constructor(config = {}) {
+    this.config = { ...DEFAULT_CONFIG3, ...config };
+    this.consola = config.consola || (0, import_consola11.createConsola)({
+      level: this.config.enabled ? 4 : 0
+    });
+  }
+  /**
+   * Enable logging
+   */
+  enable() {
+    this.config.enabled = true;
+  }
+  /**
+   * Disable logging
+   */
+  disable() {
+    this.config.enabled = false;
+  }
+  /**
+   * Update configuration
+   */
+  setConfig(config) {
+    this.config = { ...this.config, ...config };
+  }
+  /**
+   * Filter sensitive headers
+   */
+  filterHeaders(headers) {
+    if (!headers) return {};
+    const filtered = {};
+    Object.keys(headers).forEach((key) => {
+      const lowerKey = key.toLowerCase();
+      if (SENSITIVE_HEADERS3.includes(lowerKey)) {
+        filtered[key] = "***";
+      } else {
+        filtered[key] = headers[key] || "";
+      }
+    });
+    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_totp/retry.ts
+var import_p_retry3 = __toESM(require("p-retry"), 1);
+var DEFAULT_RETRY_CONFIG3 = {
+  retries: 3,
+  factor: 2,
+  minTimeout: 1e3,
+  maxTimeout: 6e4,
+  randomize: true,
+  onFailedAttempt: /* @__PURE__ */ __name(() => {
+  }, "onFailedAttempt")
+};
+function shouldRetry3(error) {
+  if (error instanceof NetworkError3) {
+    return true;
+  }
+  if (error instanceof APIError3) {
+    const status = error.statusCode;
+    if (status >= 500 && status < 600) {
+      return true;
+    }
+    if (status === 429) {
+      return true;
+    }
+    return false;
+  }
+  return true;
+}
+__name(shouldRetry3, "shouldRetry");
+async function withRetry3(fn, config) {
+  const finalConfig = { ...DEFAULT_RETRY_CONFIG3, ...config };
+  return (0, import_p_retry3.default)(
+    async () => {
+      try {
+        return await fn();
+      } catch (error) {
+        if (!shouldRetry3(error)) {
+          throw new import_p_retry3.AbortError(error);
+        }
+        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_totp/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.backup_codes = new BackupCodes(this);
+    this.totp_management = new TotpManagement(this);
+    this.totp_setup = new TotpSetup(this);
+    this.totp_verification = new TotpVerification(this);
+    this.totp = new Totp(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 && !options?.binaryBody && !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,
+        binaryBody: options?.binaryBody
+      });
+      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_totp/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_totp/enums.ts
+var DeviceListStatus = /* @__PURE__ */ ((DeviceListStatus2) => {
+  DeviceListStatus2["PENDING"] = "pending";
+  DeviceListStatus2["ACTIVE"] = "active";
+  DeviceListStatus2["DISABLED"] = "disabled";
+  return DeviceListStatus2;
+})(DeviceListStatus || {});
+
+// src/generated/cfg_totp/_utils/schemas/index.ts
+var schemas_exports3 = {};
+__export(schemas_exports3, {
+  BackupCodesRegenerateRequestSchema: () => BackupCodesRegenerateRequestSchema,
+  BackupCodesRegenerateResponseSchema: () => BackupCodesRegenerateResponseSchema,
+  BackupCodesStatusSchema: () => BackupCodesStatusSchema,
+  ConfirmSetupRequestSchema: () => ConfirmSetupRequestSchema,
+  ConfirmSetupResponseSchema: () => ConfirmSetupResponseSchema,
+  DeviceListSchema: () => DeviceListSchema,
+  DisableRequestSchema: () => DisableRequestSchema,
+  PaginatedDeviceListListSchema: () => PaginatedDeviceListListSchema,
+  SetupRequestSchema: () => SetupRequestSchema,
+  SetupResponseSchema: () => SetupResponseSchema,
+  VerifyBackupRequestSchema: () => VerifyBackupRequestSchema,
+  VerifyRequestSchema: () => VerifyRequestSchema,
+  VerifyResponseSchema: () => VerifyResponseSchema
+});
+
+// src/generated/cfg_totp/_utils/schemas/BackupCodesRegenerateRequest.schema.ts
+var import_zod55 = require("zod");
+var BackupCodesRegenerateRequestSchema = import_zod55.z.object({
+  code: import_zod55.z.string().min(6).max(6)
+});
+
+// src/generated/cfg_totp/_utils/schemas/BackupCodesRegenerateResponse.schema.ts
+var import_zod56 = require("zod");
+var BackupCodesRegenerateResponseSchema = import_zod56.z.object({
+  backup_codes: import_zod56.z.array(import_zod56.z.string()),
+  warning: import_zod56.z.string()
+});
+
+// src/generated/cfg_totp/_utils/schemas/BackupCodesStatus.schema.ts
+var import_zod57 = require("zod");
+var BackupCodesStatusSchema = import_zod57.z.object({
+  remaining_count: import_zod57.z.int(),
+  total_generated: import_zod57.z.int(),
+  warning: import_zod57.z.string().nullable().optional()
+});
+
+// src/generated/cfg_totp/_utils/schemas/ConfirmSetupRequest.schema.ts
+var import_zod58 = require("zod");
+var ConfirmSetupRequestSchema = import_zod58.z.object({
+  device_id: import_zod58.z.string().regex(/^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i),
+  code: import_zod58.z.string().min(6).max(6)
+});
+
+// src/generated/cfg_totp/_utils/schemas/ConfirmSetupResponse.schema.ts
+var import_zod59 = require("zod");
+var ConfirmSetupResponseSchema = import_zod59.z.object({
+  message: import_zod59.z.string(),
+  backup_codes: import_zod59.z.array(import_zod59.z.string()),
+  backup_codes_warning: import_zod59.z.string()
+});
+
+// src/generated/cfg_totp/_utils/schemas/DeviceList.schema.ts
+var import_zod60 = require("zod");
+var DeviceListSchema = import_zod60.z.object({
+  id: import_zod60.z.string().regex(/^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i),
+  name: import_zod60.z.string(),
+  is_primary: import_zod60.z.boolean(),
+  status: import_zod60.z.nativeEnum(DeviceListStatus),
+  created_at: import_zod60.z.iso.datetime(),
+  confirmed_at: import_zod60.z.iso.datetime().nullable(),
+  last_used_at: import_zod60.z.iso.datetime().nullable()
+});
+
+// src/generated/cfg_totp/_utils/schemas/DisableRequest.schema.ts
+var import_zod61 = require("zod");
+var DisableRequestSchema = import_zod61.z.object({
+  code: import_zod61.z.string().min(6).max(6)
+});
+
+// src/generated/cfg_totp/_utils/schemas/PaginatedDeviceListList.schema.ts
+var import_zod62 = require("zod");
+var PaginatedDeviceListListSchema = import_zod62.z.object({
+  count: import_zod62.z.int(),
+  page: import_zod62.z.int(),
+  pages: import_zod62.z.int(),
+  page_size: import_zod62.z.int(),
+  has_next: import_zod62.z.boolean(),
+  has_previous: import_zod62.z.boolean(),
+  next_page: import_zod62.z.int().nullable().optional(),
+  previous_page: import_zod62.z.int().nullable().optional(),
+  results: import_zod62.z.array(DeviceListSchema)
+});
+
+// src/generated/cfg_totp/_utils/schemas/SetupRequest.schema.ts
+var import_zod63 = require("zod");
+var SetupRequestSchema = import_zod63.z.object({
+  device_name: import_zod63.z.string().min(1).max(100).optional()
+});
+
+// src/generated/cfg_totp/_utils/schemas/SetupResponse.schema.ts
+var import_zod64 = require("zod");
+var SetupResponseSchema = import_zod64.z.object({
+  device_id: import_zod64.z.string().regex(/^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i),
+  secret: import_zod64.z.string(),
+  provisioning_uri: import_zod64.z.string(),
+  qr_code_base64: import_zod64.z.string(),
+  expires_in: import_zod64.z.int()
+});
+
+// src/generated/cfg_totp/_utils/schemas/VerifyBackupRequest.schema.ts
+var import_zod65 = require("zod");
+var VerifyBackupRequestSchema = import_zod65.z.object({
+  session_id: import_zod65.z.string().regex(/^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i),
+  backup_code: import_zod65.z.string().min(8).max(8)
+});
+
+// src/generated/cfg_totp/_utils/schemas/VerifyRequest.schema.ts
+var import_zod66 = require("zod");
+var VerifyRequestSchema = import_zod66.z.object({
+  session_id: import_zod66.z.string().regex(/^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i),
+  code: import_zod66.z.string().min(6).max(6)
+});
+
+// src/generated/cfg_totp/_utils/schemas/VerifyResponse.schema.ts
+var import_zod67 = require("zod");
+var VerifyResponseSchema = import_zod67.z.object({
+  message: import_zod67.z.string(),
+  access_token: import_zod67.z.string(),
+  refresh_token: import_zod67.z.string(),
+  user: import_zod67.z.record(import_zod67.z.string(), import_zod67.z.any()),
+  remaining_backup_codes: import_zod67.z.int().optional(),
+  warning: import_zod67.z.string().optional()
+});
+
+// src/generated/cfg_totp/_utils/fetchers/index.ts
+var fetchers_exports3 = {};
+__export(fetchers_exports3, {
+  createTotpBackupCodesRegenerateCreate: () => createTotpBackupCodesRegenerateCreate,
+  createTotpDisableCreate: () => createTotpDisableCreate,
+  createTotpSetupConfirmCreate: () => createTotpSetupConfirmCreate,
+  createTotpSetupCreate: () => createTotpSetupCreate,
+  createTotpVerifyBackupCreate: () => createTotpVerifyBackupCreate,
+  createTotpVerifyCreate: () => createTotpVerifyCreate,
+  deleteTotpDevicesDestroy: () => deleteTotpDevicesDestroy,
+  getTotpBackupCodesRetrieve: () => getTotpBackupCodesRetrieve,
+  getTotpDevicesList: () => getTotpDevicesList
+});
+
+// src/generated/cfg_totp/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" })\n\nOr set environment variable: NEXT_PUBLIC_API_URL, VITE_API_URL, or REACT_APP_API_URL'
+    );
+  }
+  return globalAPI3;
+}
+__name(getAPIInstance3, "getAPIInstance");
+
+// src/generated/cfg_totp/_utils/fetchers/totp.ts
+async function deleteTotpDevicesDestroy(id, client) {
+  const api = client || getAPIInstance3();
+  const response = await api.totp.devicesDestroy(id);
+  return response;
+}
+__name(deleteTotpDevicesDestroy, "deleteTotpDevicesDestroy");
+
+// src/generated/cfg_totp/_utils/fetchers/totp__backup_codes.ts
+var import_consola12 = require("consola");
+async function getTotpBackupCodesRetrieve(client) {
+  const api = client || getAPIInstance3();
+  const response = await api.backup_codes.totpBackupCodesRetrieve();
+  try {
+    return BackupCodesStatusSchema.parse(response);
+  } catch (error) {
+    import_consola12.consola.error("\u274C Zod Validation Failed");
+    import_consola12.consola.box(`getTotpBackupCodesRetrieve
+Path: /cfg/totp/backup-codes/
+Method: GET`);
+    if (error instanceof Error && "issues" in error && Array.isArray(error.issues)) {
+      import_consola12.consola.error("Validation Issues:");
+      error.issues.forEach((issue, index) => {
+        import_consola12.consola.error(`  ${index + 1}. ${issue.path.join(".") || "root"}`);
+        import_consola12.consola.error(`     \u251C\u2500 Message: ${issue.message}`);
+        if (issue.expected) import_consola12.consola.error(`     \u251C\u2500 Expected: ${issue.expected}`);
+        if (issue.received) import_consola12.consola.error(`     \u2514\u2500 Received: ${issue.received}`);
+      });
+    }
+    import_consola12.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: "getTotpBackupCodesRetrieve",
+            path: "/cfg/totp/backup-codes/",
+            method: "GET",
+            error,
+            response,
+            timestamp: /* @__PURE__ */ new Date()
+          },
+          bubbles: true,
+          cancelable: false
+        });
+        window.dispatchEvent(event);
+      } catch (eventError) {
+        import_consola12.consola.warn("Failed to dispatch validation error event:", eventError);
+      }
+    }
+    throw error;
+  }
+}
+__name(getTotpBackupCodesRetrieve, "getTotpBackupCodesRetrieve");
+async function createTotpBackupCodesRegenerateCreate(data, client) {
+  const api = client || getAPIInstance3();
+  const response = await api.backup_codes.totpBackupCodesRegenerateCreate(data);
+  try {
+    return BackupCodesRegenerateResponseSchema.parse(response);
+  } catch (error) {
+    import_consola12.consola.error("\u274C Zod Validation Failed");
+    import_consola12.consola.box(`createTotpBackupCodesRegenerateCreate
+Path: /cfg/totp/backup-codes/regenerate/
+Method: POST`);
+    if (error instanceof Error && "issues" in error && Array.isArray(error.issues)) {
+      import_consola12.consola.error("Validation Issues:");
+      error.issues.forEach((issue, index) => {
+        import_consola12.consola.error(`  ${index + 1}. ${issue.path.join(".") || "root"}`);
+        import_consola12.consola.error(`     \u251C\u2500 Message: ${issue.message}`);
+        if (issue.expected) import_consola12.consola.error(`     \u251C\u2500 Expected: ${issue.expected}`);
+        if (issue.received) import_consola12.consola.error(`     \u2514\u2500 Received: ${issue.received}`);
+      });
+    }
+    import_consola12.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: "createTotpBackupCodesRegenerateCreate",
+            path: "/cfg/totp/backup-codes/regenerate/",
+            method: "POST",
+            error,
+            response,
+            timestamp: /* @__PURE__ */ new Date()
+          },
+          bubbles: true,
+          cancelable: false
+        });
+        window.dispatchEvent(event);
+      } catch (eventError) {
+        import_consola12.consola.warn("Failed to dispatch validation error event:", eventError);
+      }
+    }
+    throw error;
+  }
+}
+__name(createTotpBackupCodesRegenerateCreate, "createTotpBackupCodesRegenerateCreate");
+
+// src/generated/cfg_totp/_utils/fetchers/totp__totp_management.ts
+var import_consola13 = require("consola");
+async function getTotpDevicesList(params, client) {
+  const api = client || getAPIInstance3();
+  const response = await api.totp_management.totpDevicesList(params?.page, params?.page_size);
+  try {
+    return PaginatedDeviceListListSchema.parse(response);
+  } catch (error) {
+    import_consola13.consola.error("\u274C Zod Validation Failed");
+    import_consola13.consola.box(`getTotpDevicesList
+Path: /cfg/totp/devices/
+Method: GET`);
+    if (error instanceof Error && "issues" in error && Array.isArray(error.issues)) {
+      import_consola13.consola.error("Validation Issues:");
+      error.issues.forEach((issue, index) => {
+        import_consola13.consola.error(`  ${index + 1}. ${issue.path.join(".") || "root"}`);
+        import_consola13.consola.error(`     \u251C\u2500 Message: ${issue.message}`);
+        if (issue.expected) import_consola13.consola.error(`     \u251C\u2500 Expected: ${issue.expected}`);
+        if (issue.received) import_consola13.consola.error(`     \u2514\u2500 Received: ${issue.received}`);
+      });
+    }
+    import_consola13.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: "getTotpDevicesList",
+            path: "/cfg/totp/devices/",
+            method: "GET",
+            error,
+            response,
+            timestamp: /* @__PURE__ */ new Date()
+          },
+          bubbles: true,
+          cancelable: false
+        });
+        window.dispatchEvent(event);
+      } catch (eventError) {
+        import_consola13.consola.warn("Failed to dispatch validation error event:", eventError);
+      }
+    }
+    throw error;
+  }
+}
+__name(getTotpDevicesList, "getTotpDevicesList");
+async function createTotpDisableCreate(data, client) {
+  const api = client || getAPIInstance3();
+  const response = await api.totp_management.totpDisableCreate(data);
+  return response;
+}
+__name(createTotpDisableCreate, "createTotpDisableCreate");
+
+// src/generated/cfg_totp/_utils/fetchers/totp__totp_setup.ts
+var import_consola14 = require("consola");
+async function createTotpSetupCreate(data, client) {
+  const api = client || getAPIInstance3();
+  const response = await api.totp_setup.create(data);
+  try {
+    return SetupResponseSchema.parse(response);
+  } catch (error) {
+    import_consola14.consola.error("\u274C Zod Validation Failed");
+    import_consola14.consola.box(`createTotpSetupCreate
+Path: /cfg/totp/setup/
+Method: POST`);
+    if (error instanceof Error && "issues" in error && Array.isArray(error.issues)) {
+      import_consola14.consola.error("Validation Issues:");
+      error.issues.forEach((issue, index) => {
+        import_consola14.consola.error(`  ${index + 1}. ${issue.path.join(".") || "root"}`);
+        import_consola14.consola.error(`     \u251C\u2500 Message: ${issue.message}`);
+        if (issue.expected) import_consola14.consola.error(`     \u251C\u2500 Expected: ${issue.expected}`);
+        if (issue.received) import_consola14.consola.error(`     \u2514\u2500 Received: ${issue.received}`);
+      });
+    }
+    import_consola14.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: "createTotpSetupCreate",
+            path: "/cfg/totp/setup/",
+            method: "POST",
+            error,
+            response,
+            timestamp: /* @__PURE__ */ new Date()
+          },
+          bubbles: true,
+          cancelable: false
+        });
+        window.dispatchEvent(event);
+      } catch (eventError) {
+        import_consola14.consola.warn("Failed to dispatch validation error event:", eventError);
+      }
+    }
+    throw error;
+  }
+}
+__name(createTotpSetupCreate, "createTotpSetupCreate");
+async function createTotpSetupConfirmCreate(data, client) {
+  const api = client || getAPIInstance3();
+  const response = await api.totp_setup.confirmCreate(data);
+  try {
+    return ConfirmSetupResponseSchema.parse(response);
+  } catch (error) {
+    import_consola14.consola.error("\u274C Zod Validation Failed");
+    import_consola14.consola.box(`createTotpSetupConfirmCreate
+Path: /cfg/totp/setup/confirm/
+Method: POST`);
+    if (error instanceof Error && "issues" in error && Array.isArray(error.issues)) {
+      import_consola14.consola.error("Validation Issues:");
+      error.issues.forEach((issue, index) => {
+        import_consola14.consola.error(`  ${index + 1}. ${issue.path.join(".") || "root"}`);
+        import_consola14.consola.error(`     \u251C\u2500 Message: ${issue.message}`);
+        if (issue.expected) import_consola14.consola.error(`     \u251C\u2500 Expected: ${issue.expected}`);
+        if (issue.received) import_consola14.consola.error(`     \u2514\u2500 Received: ${issue.received}`);
+      });
+    }
+    import_consola14.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: "createTotpSetupConfirmCreate",
+            path: "/cfg/totp/setup/confirm/",
+            method: "POST",
+            error,
+            response,
+            timestamp: /* @__PURE__ */ new Date()
+          },
+          bubbles: true,
+          cancelable: false
+        });
+        window.dispatchEvent(event);
+      } catch (eventError) {
+        import_consola14.consola.warn("Failed to dispatch validation error event:", eventError);
+      }
+    }
+    throw error;
+  }
+}
+__name(createTotpSetupConfirmCreate, "createTotpSetupConfirmCreate");
+
+// src/generated/cfg_totp/_utils/fetchers/totp__totp_verification.ts
+var import_consola15 = require("consola");
+async function createTotpVerifyCreate(data, client) {
+  const api = client || getAPIInstance3();
+  const response = await api.totp_verification.totpVerifyCreate(data);
+  try {
+    return VerifyResponseSchema.parse(response);
+  } catch (error) {
+    import_consola15.consola.error("\u274C Zod Validation Failed");
+    import_consola15.consola.box(`createTotpVerifyCreate
+Path: /cfg/totp/verify/
+Method: POST`);
+    if (error instanceof Error && "issues" in error && Array.isArray(error.issues)) {
+      import_consola15.consola.error("Validation Issues:");
+      error.issues.forEach((issue, index) => {
+        import_consola15.consola.error(`  ${index + 1}. ${issue.path.join(".") || "root"}`);
+        import_consola15.consola.error(`     \u251C\u2500 Message: ${issue.message}`);
+        if (issue.expected) import_consola15.consola.error(`     \u251C\u2500 Expected: ${issue.expected}`);
+        if (issue.received) import_consola15.consola.error(`     \u2514\u2500 Received: ${issue.received}`);
+      });
+    }
+    import_consola15.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: "createTotpVerifyCreate",
+            path: "/cfg/totp/verify/",
+            method: "POST",
+            error,
+            response,
+            timestamp: /* @__PURE__ */ new Date()
+          },
+          bubbles: true,
+          cancelable: false
+        });
+        window.dispatchEvent(event);
+      } catch (eventError) {
+        import_consola15.consola.warn("Failed to dispatch validation error event:", eventError);
+      }
+    }
+    throw error;
+  }
+}
+__name(createTotpVerifyCreate, "createTotpVerifyCreate");
+async function createTotpVerifyBackupCreate(data, client) {
+  const api = client || getAPIInstance3();
+  const response = await api.totp_verification.totpVerifyBackupCreate(data);
+  try {
+    return VerifyResponseSchema.parse(response);
+  } catch (error) {
+    import_consola15.consola.error("\u274C Zod Validation Failed");
+    import_consola15.consola.box(`createTotpVerifyBackupCreate
+Path: /cfg/totp/verify/backup/
+Method: POST`);
+    if (error instanceof Error && "issues" in error && Array.isArray(error.issues)) {
+      import_consola15.consola.error("Validation Issues:");
+      error.issues.forEach((issue, index) => {
+        import_consola15.consola.error(`  ${index + 1}. ${issue.path.join(".") || "root"}`);
+        import_consola15.consola.error(`     \u251C\u2500 Message: ${issue.message}`);
+        if (issue.expected) import_consola15.consola.error(`     \u251C\u2500 Expected: ${issue.expected}`);
+        if (issue.received) import_consola15.consola.error(`     \u2514\u2500 Received: ${issue.received}`);
+      });
+    }
+    import_consola15.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: "createTotpVerifyBackupCreate",
+            path: "/cfg/totp/verify/backup/",
+            method: "POST",
+            error,
+            response,
+            timestamp: /* @__PURE__ */ new Date()
+          },
+          bubbles: true,
+          cancelable: false
+        });
+        window.dispatchEvent(event);
+      } catch (eventError) {
+        import_consola15.consola.warn("Failed to dispatch validation error event:", eventError);
+      }
+    }
+    throw error;
+  }
+}
+__name(createTotpVerifyBackupCreate, "createTotpVerifyBackupCreate");
+
+// src/generated/cfg_totp/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.backup_codes = this._client.backup_codes;
+    this.totp_management = this._client.totp_management;
+    this.totp_setup = this._client.totp_setup;
+    this.totp_verification = this._client.totp_verification;
+    this.totp = this._client.totp;
+  }
+  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.backup_codes = this._client.backup_codes;
+    this.totp_management = this._client.totp_management;
+    this.totp_setup = this._client.totp_setup;
+    this.totp_verification = this._client.totp_verification;
+    this.totp = this._client.totp;
+  }
+  _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_webpush/webpush__web_push/client.ts
 var WebPush = class {
   static {
@@ -3752,12 +5138,12 @@ var WebPush = class {
 };
 
 // src/generated/cfg_webpush/http.ts
-var FetchAdapter3 = class {
+var FetchAdapter4 = class {
   static {
     __name(this, "FetchAdapter");
   }
   async request(request) {
-    const { method, url, headers, body, params, formData } = request;
+    const { method, url, headers, body, params, formData, binaryBody } = request;
     let finalUrl = url;
     if (params) {
       const searchParams = new URLSearchParams();
@@ -3775,6 +5161,9 @@ var FetchAdapter3 = class {
     let requestBody;
     if (formData) {
       requestBody = formData;
+    } else if (binaryBody) {
+      finalHeaders["Content-Type"] = "application/octet-stream";
+      requestBody = binaryBody;
     } else if (body) {
       finalHeaders["Content-Type"] = "application/json";
       requestBody = JSON.stringify(body);
@@ -3807,7 +5196,7 @@ var FetchAdapter3 = class {
 };
 
 // src/generated/cfg_webpush/errors.ts
-var APIError3 = class extends Error {
+var APIError4 = class extends Error {
   constructor(statusCode, statusText, response, url, message) {
     super(message || `HTTP ${statusCode}: ${statusText}`);
     this.statusCode = statusCode;
@@ -3883,7 +5272,7 @@ var APIError3 = class extends Error {
     return this.statusCode >= 500 && this.statusCode < 600;
   }
 };
-var NetworkError3 = class extends Error {
+var NetworkError4 = class extends Error {
   constructor(message, url, originalError) {
     super(message);
     this.url = url;
@@ -3896,8 +5285,8 @@ var NetworkError3 = class extends Error {
 };
 
 // src/generated/cfg_webpush/logger.ts
-var import_consola11 = require("consola");
-var DEFAULT_CONFIG3 = {
+var import_consola16 = require("consola");
+var DEFAULT_CONFIG4 = {
   enabled: process.env.NODE_ENV !== "production",
   logRequests: true,
   logResponses: true,
@@ -3905,20 +5294,20 @@ var DEFAULT_CONFIG3 = {
   logBodies: true,
   logHeaders: false
 };
-var SENSITIVE_HEADERS3 = [
+var SENSITIVE_HEADERS4 = [
   "authorization",
   "cookie",
   "set-cookie",
   "x-api-key",
   "x-csrf-token"
 ];
-var APILogger3 = class {
+var APILogger4 = class {
   static {
     __name(this, "APILogger");
   }
   constructor(config = {}) {
-    this.config = { ...DEFAULT_CONFIG3, ...config };
-    this.consola = config.consola || (0, import_consola11.createConsola)({
+    this.config = { ...DEFAULT_CONFIG4, ...config };
+    this.consola = config.consola || (0, import_consola16.createConsola)({
       level: this.config.enabled ? 4 : 0
     });
   }
@@ -3948,7 +5337,7 @@ var APILogger3 = class {
     const filtered = {};
     Object.keys(headers).forEach((key) => {
       const lowerKey = key.toLowerCase();
-      if (SENSITIVE_HEADERS3.includes(lowerKey)) {
+      if (SENSITIVE_HEADERS4.includes(lowerKey)) {
         filtered[key] = "***";
       } else {
         filtered[key] = headers[key] || "";
@@ -4047,11 +5436,11 @@ var APILogger3 = class {
     return this.consola.withTag(tag);
   }
 };
-var defaultLogger3 = new APILogger3();
+var defaultLogger4 = new APILogger4();
 
 // src/generated/cfg_webpush/retry.ts
-var import_p_retry3 = __toESM(require("p-retry"), 1);
-var DEFAULT_RETRY_CONFIG3 = {
+var import_p_retry4 = __toESM(require("p-retry"), 1);
+var DEFAULT_RETRY_CONFIG4 = {
   retries: 3,
   factor: 2,
   minTimeout: 1e3,
@@ -4060,11 +5449,11 @@ var DEFAULT_RETRY_CONFIG3 = {
   onFailedAttempt: /* @__PURE__ */ __name(() => {
   }, "onFailedAttempt")
 };
-function shouldRetry3(error) {
-  if (error instanceof NetworkError3) {
+function shouldRetry4(error) {
+  if (error instanceof NetworkError4) {
     return true;
   }
-  if (error instanceof APIError3) {
+  if (error instanceof APIError4) {
     const status = error.statusCode;
     if (status >= 500 && status < 600) {
       return true;
@@ -4076,16 +5465,16 @@ function shouldRetry3(error) {
   }
   return true;
 }
-__name(shouldRetry3, "shouldRetry");
-async function withRetry3(fn, config) {
-  const finalConfig = { ...DEFAULT_RETRY_CONFIG3, ...config };
-  return (0, import_p_retry3.default)(
+__name(shouldRetry4, "shouldRetry");
+async function withRetry4(fn, config) {
+  const finalConfig = { ...DEFAULT_RETRY_CONFIG4, ...config };
+  return (0, import_p_retry4.default)(
     async () => {
       try {
         return await fn();
       } catch (error) {
-        if (!shouldRetry3(error)) {
-          throw new import_p_retry3.AbortError(error);
+        if (!shouldRetry4(error)) {
+          throw new import_p_retry4.AbortError(error);
         }
         throw error;
       }
@@ -4107,17 +5496,17 @@ async function withRetry3(fn, config) {
     }
   );
 }
-__name(withRetry3, "withRetry");
+__name(withRetry4, "withRetry");
 
 // src/generated/cfg_webpush/client.ts
-var APIClient3 = class {
+var APIClient4 = class {
   constructor(baseUrl, options) {
     this.logger = null;
     this.retryConfig = null;
     this.baseUrl = baseUrl.replace(/\/$/, "");
-    this.httpClient = options?.httpClient || new FetchAdapter3();
+    this.httpClient = options?.httpClient || new FetchAdapter4();
     if (options?.loggerConfig !== void 0) {
-      this.logger = new APILogger3(options.loggerConfig);
+      this.logger = new APILogger4(options.loggerConfig);
     }
     if (options?.retryConfig !== void 0) {
       this.retryConfig = options.retryConfig;
@@ -4147,7 +5536,7 @@ var APIClient3 = class {
    */
   async request(method, path, options) {
     if (this.retryConfig) {
-      return withRetry3(() => this._makeRequest(method, path, options), {
+      return withRetry4(() => this._makeRequest(method, path, options), {
         ...this.retryConfig,
         onFailedAttempt: /* @__PURE__ */ __name((info) => {
           if (this.logger) {
@@ -4171,7 +5560,7 @@ var APIClient3 = class {
     const headers = {
       ...options?.headers || {}
     };
-    if (!options?.formData && !headers["Content-Type"]) {
+    if (!options?.formData && !options?.binaryBody && !headers["Content-Type"]) {
       headers["Content-Type"] = "application/json";
     }
     if (this.logger) {
@@ -4190,11 +5579,12 @@ var APIClient3 = class {
         headers,
         params: options?.params,
         body: options?.body,
-        formData: options?.formData
+        formData: options?.formData,
+        binaryBody: options?.binaryBody
       });
       const duration = Date.now() - startTime;
       if (response.status >= 400) {
-        const error = new APIError3(
+        const error = new APIError4(
           response.status,
           response.statusText,
           response.data,
@@ -4240,7 +5630,7 @@ var APIClient3 = class {
       return response.data;
     } catch (error) {
       const duration = Date.now() - startTime;
-      if (error instanceof APIError3) {
+      if (error instanceof APIError4) {
         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"));
@@ -4282,7 +5672,7 @@ var APIClient3 = class {
         } catch (eventError) {
         }
       }
-      const networkError = error instanceof Error ? new NetworkError3(error.message, url, error) : new NetworkError3("Unknown error", url);
+      const networkError = error instanceof Error ? new NetworkError4(error.message, url, error) : new NetworkError4("Unknown error", url);
       if (this.logger) {
         this.logger.logError(
           {
@@ -4305,7 +5695,7 @@ var APIClient3 = class {
 };
 
 // src/generated/cfg_webpush/storage.ts
-var LocalStorageAdapter3 = class {
+var LocalStorageAdapter4 = class {
   static {
     __name(this, "LocalStorageAdapter");
   }
@@ -4352,8 +5742,8 @@ var LocalStorageAdapter3 = class {
 };
 
 // src/generated/cfg_webpush/_utils/schemas/index.ts
-var schemas_exports3 = {};
-__export(schemas_exports3, {
+var schemas_exports4 = {};
+__export(schemas_exports4, {
   SendPushRequestRequestSchema: () => SendPushRequestRequestSchema,
   SendPushResponseSchema: () => SendPushResponseSchema,
   SubscribeRequestRequestSchema: () => SubscribeRequestRequestSchema,
@@ -4362,99 +5752,99 @@ __export(schemas_exports3, {
 });
 
 // src/generated/cfg_webpush/_utils/schemas/SendPushRequestRequest.schema.ts
-var import_zod55 = require("zod");
-var SendPushRequestRequestSchema = import_zod55.z.object({
-  title: import_zod55.z.string().min(1).max(255),
-  body: import_zod55.z.string().min(1),
-  icon: import_zod55.z.union([import_zod55.z.url(), import_zod55.z.literal("")]).nullable().optional(),
-  url: import_zod55.z.union([import_zod55.z.url(), import_zod55.z.literal("")]).nullable().optional()
+var import_zod68 = require("zod");
+var SendPushRequestRequestSchema = import_zod68.z.object({
+  title: import_zod68.z.string().min(1).max(255),
+  body: import_zod68.z.string().min(1),
+  icon: import_zod68.z.union([import_zod68.z.url(), import_zod68.z.literal("")]).nullable().optional(),
+  url: import_zod68.z.union([import_zod68.z.url(), import_zod68.z.literal("")]).nullable().optional()
 });
 
 // src/generated/cfg_webpush/_utils/schemas/SendPushResponse.schema.ts
-var import_zod56 = require("zod");
-var SendPushResponseSchema = import_zod56.z.object({
-  success: import_zod56.z.boolean(),
-  sent_to: import_zod56.z.int()
+var import_zod69 = require("zod");
+var SendPushResponseSchema = import_zod69.z.object({
+  success: import_zod69.z.boolean(),
+  sent_to: import_zod69.z.int()
 });
 
 // src/generated/cfg_webpush/_utils/schemas/SubscribeRequestRequest.schema.ts
-var import_zod57 = require("zod");
-var SubscribeRequestRequestSchema = import_zod57.z.object({
-  endpoint: import_zod57.z.union([import_zod57.z.url(), import_zod57.z.literal("")]),
-  keys: import_zod57.z.record(import_zod57.z.string(), import_zod57.z.string().min(1))
+var import_zod70 = require("zod");
+var SubscribeRequestRequestSchema = import_zod70.z.object({
+  endpoint: import_zod70.z.union([import_zod70.z.url(), import_zod70.z.literal("")]),
+  keys: import_zod70.z.record(import_zod70.z.string(), import_zod70.z.string().min(1))
 });
 
 // src/generated/cfg_webpush/_utils/schemas/SubscribeResponse.schema.ts
-var import_zod58 = require("zod");
-var SubscribeResponseSchema = import_zod58.z.object({
-  success: import_zod58.z.boolean(),
-  subscription_id: import_zod58.z.int(),
-  created: import_zod58.z.boolean()
+var import_zod71 = require("zod");
+var SubscribeResponseSchema = import_zod71.z.object({
+  success: import_zod71.z.boolean(),
+  subscription_id: import_zod71.z.int(),
+  created: import_zod71.z.boolean()
 });
 
 // src/generated/cfg_webpush/_utils/schemas/VapidPublicKeyResponse.schema.ts
-var import_zod59 = require("zod");
-var VapidPublicKeyResponseSchema = import_zod59.z.object({
-  publicKey: import_zod59.z.string()
+var import_zod72 = require("zod");
+var VapidPublicKeyResponseSchema = import_zod72.z.object({
+  publicKey: import_zod72.z.string()
 });
 
 // src/generated/cfg_webpush/_utils/fetchers/index.ts
-var fetchers_exports3 = {};
-__export(fetchers_exports3, {
+var fetchers_exports4 = {};
+__export(fetchers_exports4, {
   createWebpushSendCreate: () => createWebpushSendCreate,
   createWebpushSubscribeCreate: () => createWebpushSubscribeCreate,
   getWebpushVapidRetrieve: () => getWebpushVapidRetrieve
 });
 
 // src/generated/cfg_webpush/_utils/fetchers/webpush__web_push.ts
-var import_consola12 = require("consola");
+var import_consola17 = require("consola");
 
 // src/generated/cfg_webpush/api-instance.ts
-var globalAPI3 = null;
-var autoConfigAttempted3 = false;
-function tryAutoConfigureFromEnv3() {
-  if (autoConfigAttempted3) return;
-  autoConfigAttempted3 = true;
-  if (globalAPI3) return;
+var globalAPI4 = null;
+var autoConfigAttempted4 = false;
+function tryAutoConfigureFromEnv4() {
+  if (autoConfigAttempted4) return;
+  autoConfigAttempted4 = true;
+  if (globalAPI4) 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);
+    globalAPI4 = new API4(baseUrl);
   }
 }
-__name(tryAutoConfigureFromEnv3, "tryAutoConfigureFromEnv");
-function getAPIInstance3() {
-  tryAutoConfigureFromEnv3();
-  if (!globalAPI3) {
+__name(tryAutoConfigureFromEnv4, "tryAutoConfigureFromEnv");
+function getAPIInstance4() {
+  tryAutoConfigureFromEnv4();
+  if (!globalAPI4) {
     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" })\n\nOr set environment variable: NEXT_PUBLIC_API_URL, VITE_API_URL, or REACT_APP_API_URL'
     );
   }
-  return globalAPI3;
+  return globalAPI4;
 }
-__name(getAPIInstance3, "getAPIInstance");
+__name(getAPIInstance4, "getAPIInstance");
 
 // src/generated/cfg_webpush/_utils/fetchers/webpush__web_push.ts
 async function createWebpushSendCreate(data, client) {
-  const api = client || getAPIInstance3();
+  const api = client || getAPIInstance4();
   const response = await api.web_push.webpushSendCreate(data);
   try {
     return SendPushResponseSchema.parse(response);
   } catch (error) {
-    import_consola12.consola.error("\u274C Zod Validation Failed");
-    import_consola12.consola.box(`createWebpushSendCreate
+    import_consola17.consola.error("\u274C Zod Validation Failed");
+    import_consola17.consola.box(`createWebpushSendCreate
 Path: /cfg/webpush/send/
 Method: POST`);
     if (error instanceof Error && "issues" in error && Array.isArray(error.issues)) {
-      import_consola12.consola.error("Validation Issues:");
+      import_consola17.consola.error("Validation Issues:");
       error.issues.forEach((issue, index) => {
-        import_consola12.consola.error(`  ${index + 1}. ${issue.path.join(".") || "root"}`);
-        import_consola12.consola.error(`     \u251C\u2500 Message: ${issue.message}`);
-        if (issue.expected) import_consola12.consola.error(`     \u251C\u2500 Expected: ${issue.expected}`);
-        if (issue.received) import_consola12.consola.error(`     \u2514\u2500 Received: ${issue.received}`);
+        import_consola17.consola.error(`  ${index + 1}. ${issue.path.join(".") || "root"}`);
+        import_consola17.consola.error(`     \u251C\u2500 Message: ${issue.message}`);
+        if (issue.expected) import_consola17.consola.error(`     \u251C\u2500 Expected: ${issue.expected}`);
+        if (issue.received) import_consola17.consola.error(`     \u2514\u2500 Received: ${issue.received}`);
       });
     }
-    import_consola12.consola.error("Response data:", response);
+    import_consola17.consola.error("Response data:", response);
     if (typeof window !== "undefined" && error instanceof Error && "issues" in error) {
       try {
         const event = new CustomEvent("zod-validation-error", {
@@ -4471,7 +5861,7 @@ Method: POST`);
         });
         window.dispatchEvent(event);
       } catch (eventError) {
-        import_consola12.consola.warn("Failed to dispatch validation error event:", eventError);
+        import_consola17.consola.warn("Failed to dispatch validation error event:", eventError);
       }
     }
     throw error;
@@ -4479,25 +5869,25 @@ Method: POST`);
 }
 __name(createWebpushSendCreate, "createWebpushSendCreate");
 async function createWebpushSubscribeCreate(data, client) {
-  const api = client || getAPIInstance3();
+  const api = client || getAPIInstance4();
   const response = await api.web_push.webpushSubscribeCreate(data);
   try {
     return SubscribeResponseSchema.parse(response);
   } catch (error) {
-    import_consola12.consola.error("\u274C Zod Validation Failed");
-    import_consola12.consola.box(`createWebpushSubscribeCreate
+    import_consola17.consola.error("\u274C Zod Validation Failed");
+    import_consola17.consola.box(`createWebpushSubscribeCreate
 Path: /cfg/webpush/subscribe/
 Method: POST`);
     if (error instanceof Error && "issues" in error && Array.isArray(error.issues)) {
-      import_consola12.consola.error("Validation Issues:");
+      import_consola17.consola.error("Validation Issues:");
       error.issues.forEach((issue, index) => {
-        import_consola12.consola.error(`  ${index + 1}. ${issue.path.join(".") || "root"}`);
-        import_consola12.consola.error(`     \u251C\u2500 Message: ${issue.message}`);
-        if (issue.expected) import_consola12.consola.error(`     \u251C\u2500 Expected: ${issue.expected}`);
-        if (issue.received) import_consola12.consola.error(`     \u2514\u2500 Received: ${issue.received}`);
+        import_consola17.consola.error(`  ${index + 1}. ${issue.path.join(".") || "root"}`);
+        import_consola17.consola.error(`     \u251C\u2500 Message: ${issue.message}`);
+        if (issue.expected) import_consola17.consola.error(`     \u251C\u2500 Expected: ${issue.expected}`);
+        if (issue.received) import_consola17.consola.error(`     \u2514\u2500 Received: ${issue.received}`);
       });
     }
-    import_consola12.consola.error("Response data:", response);
+    import_consola17.consola.error("Response data:", response);
     if (typeof window !== "undefined" && error instanceof Error && "issues" in error) {
       try {
         const event = new CustomEvent("zod-validation-error", {
@@ -4514,7 +5904,7 @@ Method: POST`);
         });
         window.dispatchEvent(event);
       } catch (eventError) {
-        import_consola12.consola.warn("Failed to dispatch validation error event:", eventError);
+        import_consola17.consola.warn("Failed to dispatch validation error event:", eventError);
       }
     }
     throw error;
@@ -4522,25 +5912,25 @@ Method: POST`);
 }
 __name(createWebpushSubscribeCreate, "createWebpushSubscribeCreate");
 async function getWebpushVapidRetrieve(client) {
-  const api = client || getAPIInstance3();
+  const api = client || getAPIInstance4();
   const response = await api.web_push.webpushVapidRetrieve();
   try {
     return VapidPublicKeyResponseSchema.parse(response);
   } catch (error) {
-    import_consola12.consola.error("\u274C Zod Validation Failed");
-    import_consola12.consola.box(`getWebpushVapidRetrieve
+    import_consola17.consola.error("\u274C Zod Validation Failed");
+    import_consola17.consola.box(`getWebpushVapidRetrieve
 Path: /cfg/webpush/vapid/
 Method: GET`);
     if (error instanceof Error && "issues" in error && Array.isArray(error.issues)) {
-      import_consola12.consola.error("Validation Issues:");
+      import_consola17.consola.error("Validation Issues:");
       error.issues.forEach((issue, index) => {
-        import_consola12.consola.error(`  ${index + 1}. ${issue.path.join(".") || "root"}`);
-        import_consola12.consola.error(`     \u251C\u2500 Message: ${issue.message}`);
-        if (issue.expected) import_consola12.consola.error(`     \u251C\u2500 Expected: ${issue.expected}`);
-        if (issue.received) import_consola12.consola.error(`     \u2514\u2500 Received: ${issue.received}`);
+        import_consola17.consola.error(`  ${index + 1}. ${issue.path.join(".") || "root"}`);
+        import_consola17.consola.error(`     \u251C\u2500 Message: ${issue.message}`);
+        if (issue.expected) import_consola17.consola.error(`     \u251C\u2500 Expected: ${issue.expected}`);
+        if (issue.received) import_consola17.consola.error(`     \u2514\u2500 Received: ${issue.received}`);
       });
     }
-    import_consola12.consola.error("Response data:", response);
+    import_consola17.consola.error("Response data:", response);
     if (typeof window !== "undefined" && error instanceof Error && "issues" in error) {
       try {
         const event = new CustomEvent("zod-validation-error", {
@@ -4557,7 +5947,7 @@ Method: GET`);
         });
         window.dispatchEvent(event);
       } catch (eventError) {
-        import_consola12.consola.warn("Failed to dispatch validation error event:", eventError);
+        import_consola17.consola.warn("Failed to dispatch validation error event:", eventError);
       }
     }
     throw error;
@@ -4566,18 +5956,18 @@ Method: GET`);
 __name(getWebpushVapidRetrieve, "getWebpushVapidRetrieve");
 
 // src/generated/cfg_webpush/index.ts
-var TOKEN_KEY3 = "auth_token";
-var REFRESH_TOKEN_KEY3 = "refresh_token";
-var API3 = class {
+var TOKEN_KEY4 = "auth_token";
+var REFRESH_TOKEN_KEY4 = "refresh_token";
+var API4 = 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);
+    const logger = options?.loggerConfig ? new APILogger4(options.loggerConfig) : void 0;
+    this.storage = options?.storage || new LocalStorageAdapter4(logger);
     this._loadTokensFromStorage();
-    this._client = new APIClient3(this.baseUrl, {
+    this._client = new APIClient4(this.baseUrl, {
       retryConfig: this.options?.retryConfig,
       loggerConfig: this.options?.loggerConfig
     });
@@ -4588,11 +5978,11 @@ var API3 = class {
     __name(this, "API");
   }
   _loadTokensFromStorage() {
-    this._token = this.storage.getItem(TOKEN_KEY3);
-    this._refreshToken = this.storage.getItem(REFRESH_TOKEN_KEY3);
+    this._token = this.storage.getItem(TOKEN_KEY4);
+    this._refreshToken = this.storage.getItem(REFRESH_TOKEN_KEY4);
   }
   _reinitClients() {
-    this._client = new APIClient3(this.baseUrl, {
+    this._client = new APIClient4(this.baseUrl, {
       retryConfig: this.options?.retryConfig,
       loggerConfig: this.options?.loggerConfig
     });
@@ -4617,13 +6007,13 @@ var API3 = class {
    * Get current JWT token
    */
   getToken() {
-    return this.storage.getItem(TOKEN_KEY3);
+    return this.storage.getItem(TOKEN_KEY4);
   }
   /**
    * Get current refresh token
    */
   getRefreshToken() {
-    return this.storage.getItem(REFRESH_TOKEN_KEY3);
+    return this.storage.getItem(REFRESH_TOKEN_KEY4);
   }
   /**
    * Set JWT token and refresh token
@@ -4632,10 +6022,10 @@ var API3 = class {
    */
   setToken(token, refreshToken) {
     this._token = token;
-    this.storage.setItem(TOKEN_KEY3, token);
+    this.storage.setItem(TOKEN_KEY4, token);
     if (refreshToken) {
       this._refreshToken = refreshToken;
-      this.storage.setItem(REFRESH_TOKEN_KEY3, refreshToken);
+      this.storage.setItem(REFRESH_TOKEN_KEY4, refreshToken);
     }
     this._reinitClients();
   }
@@ -4645,8 +6035,8 @@ var API3 = class {
   clearTokens() {
     this._token = null;
     this._refreshToken = null;
-    this.storage.removeItem(TOKEN_KEY3);
-    this.storage.removeItem(REFRESH_TOKEN_KEY3);
+    this.storage.removeItem(TOKEN_KEY4);
+    this.storage.removeItem(REFRESH_TOKEN_KEY4);
     this._reinitClients();
   }
   /**
@@ -5012,11 +6402,121 @@ function useCreateCentrifugoTestingSendAckCreate() {
 }
 __name(useCreateCentrifugoTestingSendAckCreate, "useCreateCentrifugoTestingSendAckCreate");
 
+// src/generated/cfg_totp/_utils/hooks/index.ts
+var hooks_exports3 = {};
+__export(hooks_exports3, {
+  useCreateTotpBackupCodesRegenerateCreate: () => useCreateTotpBackupCodesRegenerateCreate,
+  useCreateTotpDisableCreate: () => useCreateTotpDisableCreate,
+  useCreateTotpSetupConfirmCreate: () => useCreateTotpSetupConfirmCreate,
+  useCreateTotpSetupCreate: () => useCreateTotpSetupCreate,
+  useCreateTotpVerifyBackupCreate: () => useCreateTotpVerifyBackupCreate,
+  useCreateTotpVerifyCreate: () => useCreateTotpVerifyCreate,
+  useDeleteTotpDevicesDestroy: () => useDeleteTotpDevicesDestroy,
+  useTotpBackupCodesRetrieve: () => useTotpBackupCodesRetrieve,
+  useTotpDevicesList: () => useTotpDevicesList
+});
+
+// src/generated/cfg_totp/_utils/hooks/totp__backup_codes.ts
+var import_swr13 = __toESM(require("swr"), 1);
+var import_swr14 = require("swr");
+function useTotpBackupCodesRetrieve(client) {
+  return (0, import_swr13.default)(
+    "cfg-totp-backup-code",
+    () => getTotpBackupCodesRetrieve(client)
+  );
+}
+__name(useTotpBackupCodesRetrieve, "useTotpBackupCodesRetrieve");
+function useCreateTotpBackupCodesRegenerateCreate() {
+  const { mutate } = (0, import_swr14.useSWRConfig)();
+  return async (data, client) => {
+    const result = await createTotpBackupCodesRegenerateCreate(data, client);
+    mutate("cfg-totp-backup-codes-regenerate");
+    return result;
+  };
+}
+__name(useCreateTotpBackupCodesRegenerateCreate, "useCreateTotpBackupCodesRegenerateCreate");
+
+// src/generated/cfg_totp/_utils/hooks/totp__totp_management.ts
+var import_swr15 = __toESM(require("swr"), 1);
+var import_swr16 = require("swr");
+function useTotpDevicesList(params, client) {
+  return (0, import_swr15.default)(
+    params ? ["cfg-totp-devices", params] : "cfg-totp-devices",
+    () => getTotpDevicesList(params, client)
+  );
+}
+__name(useTotpDevicesList, "useTotpDevicesList");
+function useCreateTotpDisableCreate() {
+  const { mutate } = (0, import_swr16.useSWRConfig)();
+  return async (data, client) => {
+    const result = await createTotpDisableCreate(data, client);
+    mutate("cfg-totp-disable");
+    return result;
+  };
+}
+__name(useCreateTotpDisableCreate, "useCreateTotpDisableCreate");
+
+// src/generated/cfg_totp/_utils/hooks/totp__totp_setup.ts
+var import_swr17 = require("swr");
+function useCreateTotpSetupCreate() {
+  const { mutate } = (0, import_swr17.useSWRConfig)();
+  return async (data, client) => {
+    const result = await createTotpSetupCreate(data, client);
+    mutate("cfg-totp-setup");
+    return result;
+  };
+}
+__name(useCreateTotpSetupCreate, "useCreateTotpSetupCreate");
+function useCreateTotpSetupConfirmCreate() {
+  const { mutate } = (0, import_swr17.useSWRConfig)();
+  return async (data, client) => {
+    const result = await createTotpSetupConfirmCreate(data, client);
+    mutate("cfg-totp-setup-confirm");
+    return result;
+  };
+}
+__name(useCreateTotpSetupConfirmCreate, "useCreateTotpSetupConfirmCreate");
+
+// src/generated/cfg_totp/_utils/hooks/totp__totp_verification.ts
+var import_swr18 = require("swr");
+function useCreateTotpVerifyCreate() {
+  const { mutate } = (0, import_swr18.useSWRConfig)();
+  return async (data, client) => {
+    const result = await createTotpVerifyCreate(data, client);
+    mutate("cfg-totp-verify");
+    return result;
+  };
+}
+__name(useCreateTotpVerifyCreate, "useCreateTotpVerifyCreate");
+function useCreateTotpVerifyBackupCreate() {
+  const { mutate } = (0, import_swr18.useSWRConfig)();
+  return async (data, client) => {
+    const result = await createTotpVerifyBackupCreate(data, client);
+    mutate("cfg-totp-verify-backup");
+    return result;
+  };
+}
+__name(useCreateTotpVerifyBackupCreate, "useCreateTotpVerifyBackupCreate");
+
+// src/generated/cfg_totp/_utils/hooks/totp.ts
+var import_swr19 = require("swr");
+function useDeleteTotpDevicesDestroy() {
+  const { mutate } = (0, import_swr19.useSWRConfig)();
+  return async (id, client) => {
+    const result = await deleteTotpDevicesDestroy(id, client);
+    mutate("cfg-totp-devices");
+    mutate("cfg-totp-device");
+    return result;
+  };
+}
+__name(useDeleteTotpDevicesDestroy, "useDeleteTotpDevicesDestroy");
+
 // 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 API3(apiUrl, { storage });
+var apiTotp = new API3(apiUrl, { storage });
+var apiWebPush = new API4(apiUrl, { storage });
 var apiCentrifugo = new API2(apiUrl, { storage });
 //# sourceMappingURL=clients.cjs.map