@djangocfg/api 2.1.36 → 2.1.38

package/dist/hooks.cjs

@@ -1 +1,1084 @@
+"use client";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/hooks/index.ts
+var hooks_exports = {};
+__export(hooks_exports, {
+  useAccountsOauthConnectionsList: () => useAccountsOauthConnectionsList,
+  useAccountsOauthProvidersRetrieve: () => useAccountsOauthProvidersRetrieve,
+  useAccountsProfileRetrieve: () => useAccountsProfileRetrieve,
+  useCreateAccountsOauthDisconnectCreate: () => useCreateAccountsOauthDisconnectCreate,
+  useCreateAccountsOauthGithubAuthorizeCreate: () => useCreateAccountsOauthGithubAuthorizeCreate,
+  useCreateAccountsOauthGithubCallbackCreate: () => useCreateAccountsOauthGithubCallbackCreate,
+  useCreateAccountsOtpRequestCreate: () => useCreateAccountsOtpRequestCreate,
+  useCreateAccountsOtpVerifyCreate: () => useCreateAccountsOtpVerifyCreate,
+  useCreateAccountsProfileAvatarCreate: () => useCreateAccountsProfileAvatarCreate,
+  useCreateAccountsTokenRefreshCreate: () => useCreateAccountsTokenRefreshCreate,
+  usePartialUpdateAccountsProfilePartialPartialUpdate: () => usePartialUpdateAccountsProfilePartialPartialUpdate,
+  usePartialUpdateAccountsProfilePartialUpdate: () => usePartialUpdateAccountsProfilePartialUpdate,
+  usePartialUpdateAccountsProfileUpdatePartialUpdate: () => usePartialUpdateAccountsProfileUpdatePartialUpdate,
+  useUpdateAccountsProfileUpdateUpdate: () => useUpdateAccountsProfileUpdateUpdate
+});
+module.exports = __toCommonJS(hooks_exports);
+
+// src/generated/cfg_accounts/_utils/hooks/accounts__auth.ts
+var import_swr = require("swr");
+
+// src/generated/cfg_accounts/_utils/fetchers/accounts__auth.ts
+var import_consola5 = require("consola");
+
+// src/generated/cfg_accounts/_utils/schemas/TokenRefresh.schema.ts
+var import_zod = require("zod");
+var TokenRefreshSchema = import_zod.z.object({
+  access: import_zod.z.string(),
+  refresh: import_zod.z.string()
+});
+
+// src/generated/cfg_accounts/logger.ts
+var import_consola = require("consola");
+var DEFAULT_CONFIG = {
+  enabled: process.env.NODE_ENV !== "production",
+  logRequests: true,
+  logResponses: true,
+  logErrors: true,
+  logBodies: true,
+  logHeaders: false
+};
+var SENSITIVE_HEADERS = [
+  "authorization",
+  "cookie",
+  "set-cookie",
+  "x-api-key",
+  "x-csrf-token"
+];
+var APILogger = class {
+  static {
+    __name(this, "APILogger");
+  }
+  constructor(config = {}) {
+    this.config = { ...DEFAULT_CONFIG, ...config };
+    this.consola = config.consola || (0, import_consola.createConsola)({
+      level: this.config.enabled ? 4 : 0
+    });
+  }
+  /**
+   * Enable logging
+   */
+  enable() {
+    this.config.enabled = true;
+  }
+  /**
+   * Disable logging
+   */
+  disable() {
+    this.config.enabled = false;
+  }
+  /**
+   * Update configuration
+   */
+  setConfig(config) {
+    this.config = { ...this.config, ...config };
+  }
+  /**
+   * Filter sensitive headers
+   */
+  filterHeaders(headers) {
+    if (!headers) return {};
+    const filtered = {};
+    Object.keys(headers).forEach((key) => {
+      const lowerKey = key.toLowerCase();
+      if (SENSITIVE_HEADERS.includes(lowerKey)) {
+        filtered[key] = "***";
+      } else {
+        filtered[key] = headers[key] || "";
+      }
+    });
+    return filtered;
+  }
+  /**
+   * Log request
+   */
+  logRequest(request) {
+    if (!this.config.enabled || !this.config.logRequests) return;
+    const { method, url, headers, body } = request;
+    this.consola.start(`${method} ${url}`);
+    if (this.config.logHeaders && headers) {
+      this.consola.debug("Headers:", this.filterHeaders(headers));
+    }
+    if (this.config.logBodies && body) {
+      this.consola.debug("Body:", body);
+    }
+  }
+  /**
+   * Log response
+   */
+  logResponse(request, response) {
+    if (!this.config.enabled || !this.config.logResponses) return;
+    const { method, url } = request;
+    const { status, statusText, data, duration } = response;
+    const statusColor = status >= 500 ? "red" : status >= 400 ? "yellow" : status >= 300 ? "cyan" : "green";
+    this.consola.success(
+      `${method} ${url} ${status} ${statusText} (${duration}ms)`
+    );
+    if (this.config.logBodies && data) {
+      this.consola.debug("Response:", data);
+    }
+  }
+  /**
+   * Log error
+   */
+  logError(request, error) {
+    if (!this.config.enabled || !this.config.logErrors) return;
+    const { method, url } = request;
+    const { message, statusCode, fieldErrors, duration } = error;
+    this.consola.error(
+      `${method} ${url} ${statusCode || "Network"} Error (${duration}ms)`
+    );
+    this.consola.error("Message:", message);
+    if (fieldErrors && Object.keys(fieldErrors).length > 0) {
+      this.consola.error("Field Errors:");
+      Object.entries(fieldErrors).forEach(([field, errors]) => {
+        errors.forEach((err) => {
+          this.consola.error(`  \u2022 ${field}: ${err}`);
+        });
+      });
+    }
+  }
+  /**
+   * Log general info
+   */
+  info(message, ...args) {
+    if (!this.config.enabled) return;
+    this.consola.info(message, ...args);
+  }
+  /**
+   * Log warning
+   */
+  warn(message, ...args) {
+    if (!this.config.enabled) return;
+    this.consola.warn(message, ...args);
+  }
+  /**
+   * Log error
+   */
+  error(message, ...args) {
+    if (!this.config.enabled) return;
+    this.consola.error(message, ...args);
+  }
+  /**
+   * Log debug
+   */
+  debug(message, ...args) {
+    if (!this.config.enabled) return;
+    this.consola.debug(message, ...args);
+  }
+  /**
+   * Log success
+   */
+  success(message, ...args) {
+    if (!this.config.enabled) return;
+    this.consola.success(message, ...args);
+  }
+  /**
+   * Create a sub-logger with prefix
+   */
+  withTag(tag) {
+    return this.consola.withTag(tag);
+  }
+};
+var defaultLogger = new APILogger();
+
+// src/generated/cfg_accounts/retry.ts
+var import_p_retry = __toESM(require("p-retry"), 1);
+
+// src/generated/cfg_accounts/enums.ts
+var OAuthConnectionProvider = /* @__PURE__ */ ((OAuthConnectionProvider2) => {
+  OAuthConnectionProvider2["GITHUB"] = "github";
+  return OAuthConnectionProvider2;
+})(OAuthConnectionProvider || {});
+var OAuthDisconnectRequestRequestProvider = /* @__PURE__ */ ((OAuthDisconnectRequestRequestProvider2) => {
+  OAuthDisconnectRequestRequestProvider2["GITHUB"] = "github";
+  return OAuthDisconnectRequestRequestProvider2;
+})(OAuthDisconnectRequestRequestProvider || {});
+var OTPRequestRequestChannel = /* @__PURE__ */ ((OTPRequestRequestChannel2) => {
+  OTPRequestRequestChannel2["EMAIL"] = "email";
+  OTPRequestRequestChannel2["PHONE"] = "phone";
+  return OTPRequestRequestChannel2;
+})(OTPRequestRequestChannel || {});
+var OTPVerifyRequestChannel = /* @__PURE__ */ ((OTPVerifyRequestChannel2) => {
+  OTPVerifyRequestChannel2["EMAIL"] = "email";
+  OTPVerifyRequestChannel2["PHONE"] = "phone";
+  return OTPVerifyRequestChannel2;
+})(OTPVerifyRequestChannel || {});
+
+// src/generated/cfg_accounts/_utils/schemas/CentrifugoToken.schema.ts
+var import_zod2 = require("zod");
+var CentrifugoTokenSchema = import_zod2.z.object({
+  token: import_zod2.z.string(),
+  centrifugo_url: import_zod2.z.url(),
+  expires_at: import_zod2.z.iso.datetime(),
+  channels: import_zod2.z.array(import_zod2.z.string())
+});
+
+// src/generated/cfg_accounts/_utils/schemas/OAuthAuthorizeRequestRequest.schema.ts
+var import_zod3 = require("zod");
+var OAuthAuthorizeRequestRequestSchema = import_zod3.z.object({
+  redirect_uri: import_zod3.z.url().optional(),
+  source_url: import_zod3.z.url().optional()
+});
+
+// src/generated/cfg_accounts/_utils/schemas/OAuthAuthorizeResponse.schema.ts
+var import_zod4 = require("zod");
+var OAuthAuthorizeResponseSchema = import_zod4.z.object({
+  authorization_url: import_zod4.z.url(),
+  state: import_zod4.z.string()
+});
+
+// src/generated/cfg_accounts/_utils/schemas/OAuthCallbackRequestRequest.schema.ts
+var import_zod5 = require("zod");
+var OAuthCallbackRequestRequestSchema = import_zod5.z.object({
+  code: import_zod5.z.string().min(10).max(500),
+  state: import_zod5.z.string().min(20).max(100),
+  redirect_uri: import_zod5.z.url().optional()
+});
+
+// src/generated/cfg_accounts/_utils/schemas/OAuthConnection.schema.ts
+var import_zod6 = require("zod");
+var OAuthConnectionSchema = import_zod6.z.object({
+  id: import_zod6.z.int(),
+  provider: import_zod6.z.nativeEnum(OAuthConnectionProvider),
+  provider_display: import_zod6.z.string(),
+  provider_username: import_zod6.z.string(),
+  provider_email: import_zod6.z.email(),
+  provider_avatar_url: import_zod6.z.url(),
+  connected_at: import_zod6.z.iso.datetime(),
+  last_login_at: import_zod6.z.iso.datetime()
+});
+
+// src/generated/cfg_accounts/_utils/schemas/OAuthDisconnectRequestRequest.schema.ts
+var import_zod7 = require("zod");
+var OAuthDisconnectRequestRequestSchema = import_zod7.z.object({
+  provider: import_zod7.z.nativeEnum(OAuthDisconnectRequestRequestProvider)
+});
+
+// src/generated/cfg_accounts/_utils/schemas/OAuthError.schema.ts
+var import_zod8 = require("zod");
+var OAuthErrorSchema = import_zod8.z.object({
+  error: import_zod8.z.string(),
+  error_description: import_zod8.z.string().optional()
+});
+
+// src/generated/cfg_accounts/_utils/schemas/OAuthProvidersResponse.schema.ts
+var import_zod9 = require("zod");
+var OAuthProvidersResponseSchema = import_zod9.z.object({
+  providers: import_zod9.z.array(import_zod9.z.record(import_zod9.z.string(), import_zod9.z.record(import_zod9.z.string(), import_zod9.z.any())))
+});
+
+// src/generated/cfg_accounts/_utils/schemas/OAuthTokenResponse.schema.ts
+var import_zod10 = require("zod");
+var OAuthTokenResponseSchema = import_zod10.z.object({
+  access: import_zod10.z.string(),
+  refresh: import_zod10.z.string(),
+  user: import_zod10.z.record(import_zod10.z.string(), import_zod10.z.record(import_zod10.z.string(), import_zod10.z.any())),
+  is_new_user: import_zod10.z.boolean(),
+  is_new_connection: import_zod10.z.boolean()
+});
+
+// src/generated/cfg_accounts/_utils/schemas/OTPErrorResponse.schema.ts
+var import_zod11 = require("zod");
+var OTPErrorResponseSchema = import_zod11.z.object({
+  error: import_zod11.z.string()
+});
+
+// src/generated/cfg_accounts/_utils/schemas/OTPRequestRequest.schema.ts
+var import_zod12 = require("zod");
+var OTPRequestRequestSchema = import_zod12.z.object({
+  identifier: import_zod12.z.string().min(1),
+  channel: import_zod12.z.nativeEnum(OTPRequestRequestChannel).optional(),
+  source_url: import_zod12.z.url().optional()
+});
+
+// src/generated/cfg_accounts/_utils/schemas/OTPRequestResponse.schema.ts
+var import_zod13 = require("zod");
+var OTPRequestResponseSchema = import_zod13.z.object({
+  message: import_zod13.z.string()
+});
+
+// src/generated/cfg_accounts/_utils/schemas/OTPVerifyRequest.schema.ts
+var import_zod14 = require("zod");
+var OTPVerifyRequestSchema = import_zod14.z.object({
+  identifier: import_zod14.z.string().min(1),
+  otp: import_zod14.z.string().min(6).max(6),
+  channel: import_zod14.z.nativeEnum(OTPVerifyRequestChannel).optional(),
+  source_url: import_zod14.z.url().optional()
+});
+
+// src/generated/cfg_accounts/_utils/schemas/OTPVerifyResponse.schema.ts
+var import_zod16 = require("zod");
+
+// src/generated/cfg_accounts/_utils/schemas/User.schema.ts
+var import_zod15 = require("zod");
+var UserSchema = import_zod15.z.object({
+  id: import_zod15.z.int(),
+  email: import_zod15.z.email(),
+  first_name: import_zod15.z.string().max(50).optional(),
+  last_name: import_zod15.z.string().max(50).optional(),
+  full_name: import_zod15.z.string(),
+  initials: import_zod15.z.string(),
+  display_username: import_zod15.z.string(),
+  company: import_zod15.z.string().max(100).optional(),
+  phone: import_zod15.z.string().max(20).optional(),
+  position: import_zod15.z.string().max(100).optional(),
+  avatar: import_zod15.z.url().nullable(),
+  is_staff: import_zod15.z.boolean(),
+  is_superuser: import_zod15.z.boolean(),
+  date_joined: import_zod15.z.iso.datetime(),
+  last_login: import_zod15.z.iso.datetime().nullable(),
+  unanswered_messages_count: import_zod15.z.int(),
+  centrifugo: CentrifugoTokenSchema.nullable()
+});
+
+// src/generated/cfg_accounts/_utils/schemas/OTPVerifyResponse.schema.ts
+var OTPVerifyResponseSchema = import_zod16.z.object({
+  refresh: import_zod16.z.string(),
+  access: import_zod16.z.string(),
+  user: UserSchema
+});
+
+// src/generated/cfg_accounts/_utils/schemas/PatchedUserProfileUpdateRequest.schema.ts
+var import_zod17 = require("zod");
+var PatchedUserProfileUpdateRequestSchema = import_zod17.z.object({
+  first_name: import_zod17.z.string().max(50).optional(),
+  last_name: import_zod17.z.string().max(50).optional(),
+  company: import_zod17.z.string().max(100).optional(),
+  phone: import_zod17.z.string().max(20).optional(),
+  position: import_zod17.z.string().max(100).optional()
+});
+
+// src/generated/cfg_accounts/_utils/schemas/TokenRefreshRequest.schema.ts
+var import_zod18 = require("zod");
+var TokenRefreshRequestSchema = import_zod18.z.object({
+  refresh: import_zod18.z.string().min(1)
+});
+
+// src/generated/cfg_accounts/_utils/schemas/UserProfileUpdateRequest.schema.ts
+var import_zod19 = require("zod");
+var UserProfileUpdateRequestSchema = import_zod19.z.object({
+  first_name: import_zod19.z.string().max(50).optional(),
+  last_name: import_zod19.z.string().max(50).optional(),
+  company: import_zod19.z.string().max(100).optional(),
+  phone: import_zod19.z.string().max(20).optional(),
+  position: import_zod19.z.string().max(100).optional()
+});
+
+// src/generated/cfg_accounts/_utils/fetchers/accounts.ts
+var import_consola2 = require("consola");
+async function createAccountsOtpRequestCreate(data, client) {
+  const api = client || getAPIInstance();
+  const response = await api.accounts.otpRequestCreate(data);
+  try {
+    return OTPRequestResponseSchema.parse(response);
+  } catch (error) {
+    import_consola2.consola.error("\u274C Zod Validation Failed");
+    import_consola2.consola.box(`createAccountsOtpRequestCreate
+Path: /cfg/accounts/otp/request/
+Method: POST`);
+    if (error instanceof Error && "issues" in error && Array.isArray(error.issues)) {
+      import_consola2.consola.error("Validation Issues:");
+      error.issues.forEach((issue, index) => {
+        import_consola2.consola.error(`  ${index + 1}. ${issue.path.join(".") || "root"}`);
+        import_consola2.consola.error(`     \u251C\u2500 Message: ${issue.message}`);
+        if (issue.expected) import_consola2.consola.error(`     \u251C\u2500 Expected: ${issue.expected}`);
+        if (issue.received) import_consola2.consola.error(`     \u2514\u2500 Received: ${issue.received}`);
+      });
+    }
+    import_consola2.consola.error("Response data:", response);
+    if (typeof window !== "undefined" && error instanceof Error && "issues" in error) {
+      try {
+        const event = new CustomEvent("zod-validation-error", {
+          detail: {
+            operation: "createAccountsOtpRequestCreate",
+            path: "/cfg/accounts/otp/request/",
+            method: "POST",
+            error,
+            response,
+            timestamp: /* @__PURE__ */ new Date()
+          },
+          bubbles: true,
+          cancelable: false
+        });
+        window.dispatchEvent(event);
+      } catch (eventError) {
+        import_consola2.consola.warn("Failed to dispatch validation error event:", eventError);
+      }
+    }
+    throw error;
+  }
+}
+__name(createAccountsOtpRequestCreate, "createAccountsOtpRequestCreate");
+async function createAccountsOtpVerifyCreate(data, client) {
+  const api = client || getAPIInstance();
+  const response = await api.accounts.otpVerifyCreate(data);
+  try {
+    return OTPVerifyResponseSchema.parse(response);
+  } catch (error) {
+    import_consola2.consola.error("\u274C Zod Validation Failed");
+    import_consola2.consola.box(`createAccountsOtpVerifyCreate
+Path: /cfg/accounts/otp/verify/
+Method: POST`);
+    if (error instanceof Error && "issues" in error && Array.isArray(error.issues)) {
+      import_consola2.consola.error("Validation Issues:");
+      error.issues.forEach((issue, index) => {
+        import_consola2.consola.error(`  ${index + 1}. ${issue.path.join(".") || "root"}`);
+        import_consola2.consola.error(`     \u251C\u2500 Message: ${issue.message}`);
+        if (issue.expected) import_consola2.consola.error(`     \u251C\u2500 Expected: ${issue.expected}`);
+        if (issue.received) import_consola2.consola.error(`     \u2514\u2500 Received: ${issue.received}`);
+      });
+    }
+    import_consola2.consola.error("Response data:", response);
+    if (typeof window !== "undefined" && error instanceof Error && "issues" in error) {
+      try {
+        const event = new CustomEvent("zod-validation-error", {
+          detail: {
+            operation: "createAccountsOtpVerifyCreate",
+            path: "/cfg/accounts/otp/verify/",
+            method: "POST",
+            error,
+            response,
+            timestamp: /* @__PURE__ */ new Date()
+          },
+          bubbles: true,
+          cancelable: false
+        });
+        window.dispatchEvent(event);
+      } catch (eventError) {
+        import_consola2.consola.warn("Failed to dispatch validation error event:", eventError);
+      }
+    }
+    throw error;
+  }
+}
+__name(createAccountsOtpVerifyCreate, "createAccountsOtpVerifyCreate");
+
+// src/generated/cfg_accounts/_utils/fetchers/accounts__oauth.ts
+var import_consola3 = require("consola");
+async function getAccountsOauthConnectionsList(client) {
+  const api = client || getAPIInstance();
+  const response = await api.oauth.accountsOauthConnectionsList();
+  return response;
+}
+__name(getAccountsOauthConnectionsList, "getAccountsOauthConnectionsList");
+async function createAccountsOauthDisconnectCreate(data, client) {
+  const api = client || getAPIInstance();
+  const response = await api.oauth.accountsOauthDisconnectCreate(data);
+  return response;
+}
+__name(createAccountsOauthDisconnectCreate, "createAccountsOauthDisconnectCreate");
+async function createAccountsOauthGithubAuthorizeCreate(data, client) {
+  const api = client || getAPIInstance();
+  const response = await api.oauth.accountsOauthGithubAuthorizeCreate(data);
+  try {
+    return OAuthAuthorizeResponseSchema.parse(response);
+  } catch (error) {
+    import_consola3.consola.error("\u274C Zod Validation Failed");
+    import_consola3.consola.box(`createAccountsOauthGithubAuthorizeCreate
+Path: /cfg/accounts/oauth/github/authorize/
+Method: POST`);
+    if (error instanceof Error && "issues" in error && Array.isArray(error.issues)) {
+      import_consola3.consola.error("Validation Issues:");
+      error.issues.forEach((issue, index) => {
+        import_consola3.consola.error(`  ${index + 1}. ${issue.path.join(".") || "root"}`);
+        import_consola3.consola.error(`     \u251C\u2500 Message: ${issue.message}`);
+        if (issue.expected) import_consola3.consola.error(`     \u251C\u2500 Expected: ${issue.expected}`);
+        if (issue.received) import_consola3.consola.error(`     \u2514\u2500 Received: ${issue.received}`);
+      });
+    }
+    import_consola3.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: "createAccountsOauthGithubAuthorizeCreate",
+            path: "/cfg/accounts/oauth/github/authorize/",
+            method: "POST",
+            error,
+            response,
+            timestamp: /* @__PURE__ */ new Date()
+          },
+          bubbles: true,
+          cancelable: false
+        });
+        window.dispatchEvent(event);
+      } catch (eventError) {
+        import_consola3.consola.warn("Failed to dispatch validation error event:", eventError);
+      }
+    }
+    throw error;
+  }
+}
+__name(createAccountsOauthGithubAuthorizeCreate, "createAccountsOauthGithubAuthorizeCreate");
+async function createAccountsOauthGithubCallbackCreate(data, client) {
+  const api = client || getAPIInstance();
+  const response = await api.oauth.accountsOauthGithubCallbackCreate(data);
+  try {
+    return OAuthTokenResponseSchema.parse(response);
+  } catch (error) {
+    import_consola3.consola.error("\u274C Zod Validation Failed");
+    import_consola3.consola.box(`createAccountsOauthGithubCallbackCreate
+Path: /cfg/accounts/oauth/github/callback/
+Method: POST`);
+    if (error instanceof Error && "issues" in error && Array.isArray(error.issues)) {
+      import_consola3.consola.error("Validation Issues:");
+      error.issues.forEach((issue, index) => {
+        import_consola3.consola.error(`  ${index + 1}. ${issue.path.join(".") || "root"}`);
+        import_consola3.consola.error(`     \u251C\u2500 Message: ${issue.message}`);
+        if (issue.expected) import_consola3.consola.error(`     \u251C\u2500 Expected: ${issue.expected}`);
+        if (issue.received) import_consola3.consola.error(`     \u2514\u2500 Received: ${issue.received}`);
+      });
+    }
+    import_consola3.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: "createAccountsOauthGithubCallbackCreate",
+            path: "/cfg/accounts/oauth/github/callback/",
+            method: "POST",
+            error,
+            response,
+            timestamp: /* @__PURE__ */ new Date()
+          },
+          bubbles: true,
+          cancelable: false
+        });
+        window.dispatchEvent(event);
+      } catch (eventError) {
+        import_consola3.consola.warn("Failed to dispatch validation error event:", eventError);
+      }
+    }
+    throw error;
+  }
+}
+__name(createAccountsOauthGithubCallbackCreate, "createAccountsOauthGithubCallbackCreate");
+async function getAccountsOauthProvidersRetrieve(client) {
+  const api = client || getAPIInstance();
+  const response = await api.oauth.accountsOauthProvidersRetrieve();
+  try {
+    return OAuthProvidersResponseSchema.parse(response);
+  } catch (error) {
+    import_consola3.consola.error("\u274C Zod Validation Failed");
+    import_consola3.consola.box(`getAccountsOauthProvidersRetrieve
+Path: /cfg/accounts/oauth/providers/
+Method: GET`);
+    if (error instanceof Error && "issues" in error && Array.isArray(error.issues)) {
+      import_consola3.consola.error("Validation Issues:");
+      error.issues.forEach((issue, index) => {
+        import_consola3.consola.error(`  ${index + 1}. ${issue.path.join(".") || "root"}`);
+        import_consola3.consola.error(`     \u251C\u2500 Message: ${issue.message}`);
+        if (issue.expected) import_consola3.consola.error(`     \u251C\u2500 Expected: ${issue.expected}`);
+        if (issue.received) import_consola3.consola.error(`     \u2514\u2500 Received: ${issue.received}`);
+      });
+    }
+    import_consola3.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: "getAccountsOauthProvidersRetrieve",
+            path: "/cfg/accounts/oauth/providers/",
+            method: "GET",
+            error,
+            response,
+            timestamp: /* @__PURE__ */ new Date()
+          },
+          bubbles: true,
+          cancelable: false
+        });
+        window.dispatchEvent(event);
+      } catch (eventError) {
+        import_consola3.consola.warn("Failed to dispatch validation error event:", eventError);
+      }
+    }
+    throw error;
+  }
+}
+__name(getAccountsOauthProvidersRetrieve, "getAccountsOauthProvidersRetrieve");
+
+// src/generated/cfg_accounts/_utils/fetchers/accounts__user_profile.ts
+var import_consola4 = require("consola");
+async function getAccountsProfileRetrieve(client) {
+  const api = client || getAPIInstance();
+  const response = await api.user_profile.accountsProfileRetrieve();
+  try {
+    return UserSchema.parse(response);
+  } catch (error) {
+    import_consola4.consola.error("\u274C Zod Validation Failed");
+    import_consola4.consola.box(`getAccountsProfileRetrieve
+Path: /cfg/accounts/profile/
+Method: GET`);
+    if (error instanceof Error && "issues" in error && Array.isArray(error.issues)) {
+      import_consola4.consola.error("Validation Issues:");
+      error.issues.forEach((issue, index) => {
+        import_consola4.consola.error(`  ${index + 1}. ${issue.path.join(".") || "root"}`);
+        import_consola4.consola.error(`     \u251C\u2500 Message: ${issue.message}`);
+        if (issue.expected) import_consola4.consola.error(`     \u251C\u2500 Expected: ${issue.expected}`);
+        if (issue.received) import_consola4.consola.error(`     \u2514\u2500 Received: ${issue.received}`);
+      });
+    }
+    import_consola4.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: "getAccountsProfileRetrieve",
+            path: "/cfg/accounts/profile/",
+            method: "GET",
+            error,
+            response,
+            timestamp: /* @__PURE__ */ new Date()
+          },
+          bubbles: true,
+          cancelable: false
+        });
+        window.dispatchEvent(event);
+      } catch (eventError) {
+        import_consola4.consola.warn("Failed to dispatch validation error event:", eventError);
+      }
+    }
+    throw error;
+  }
+}
+__name(getAccountsProfileRetrieve, "getAccountsProfileRetrieve");
+async function createAccountsProfileAvatarCreate(data, client) {
+  const api = client || getAPIInstance();
+  const response = await api.user_profile.accountsProfileAvatarCreate(data);
+  try {
+    return UserSchema.parse(response);
+  } catch (error) {
+    import_consola4.consola.error("\u274C Zod Validation Failed");
+    import_consola4.consola.box(`createAccountsProfileAvatarCreate
+Path: /cfg/accounts/profile/avatar/
+Method: POST`);
+    if (error instanceof Error && "issues" in error && Array.isArray(error.issues)) {
+      import_consola4.consola.error("Validation Issues:");
+      error.issues.forEach((issue, index) => {
+        import_consola4.consola.error(`  ${index + 1}. ${issue.path.join(".") || "root"}`);
+        import_consola4.consola.error(`     \u251C\u2500 Message: ${issue.message}`);
+        if (issue.expected) import_consola4.consola.error(`     \u251C\u2500 Expected: ${issue.expected}`);
+        if (issue.received) import_consola4.consola.error(`     \u2514\u2500 Received: ${issue.received}`);
+      });
+    }
+    import_consola4.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: "createAccountsProfileAvatarCreate",
+            path: "/cfg/accounts/profile/avatar/",
+            method: "POST",
+            error,
+            response,
+            timestamp: /* @__PURE__ */ new Date()
+          },
+          bubbles: true,
+          cancelable: false
+        });
+        window.dispatchEvent(event);
+      } catch (eventError) {
+        import_consola4.consola.warn("Failed to dispatch validation error event:", eventError);
+      }
+    }
+    throw error;
+  }
+}
+__name(createAccountsProfileAvatarCreate, "createAccountsProfileAvatarCreate");
+async function partialUpdateAccountsProfilePartialUpdate(data, client) {
+  const api = client || getAPIInstance();
+  const response = await api.user_profile.accountsProfilePartialUpdate(data);
+  try {
+    return UserSchema.parse(response);
+  } catch (error) {
+    import_consola4.consola.error("\u274C Zod Validation Failed");
+    import_consola4.consola.box(`partialUpdateAccountsProfilePartialUpdate
+Path: /cfg/accounts/profile/partial/
+Method: PUT`);
+    if (error instanceof Error && "issues" in error && Array.isArray(error.issues)) {
+      import_consola4.consola.error("Validation Issues:");
+      error.issues.forEach((issue, index) => {
+        import_consola4.consola.error(`  ${index + 1}. ${issue.path.join(".") || "root"}`);
+        import_consola4.consola.error(`     \u251C\u2500 Message: ${issue.message}`);
+        if (issue.expected) import_consola4.consola.error(`     \u251C\u2500 Expected: ${issue.expected}`);
+        if (issue.received) import_consola4.consola.error(`     \u2514\u2500 Received: ${issue.received}`);
+      });
+    }
+    import_consola4.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: "partialUpdateAccountsProfilePartialUpdate",
+            path: "/cfg/accounts/profile/partial/",
+            method: "PUT",
+            error,
+            response,
+            timestamp: /* @__PURE__ */ new Date()
+          },
+          bubbles: true,
+          cancelable: false
+        });
+        window.dispatchEvent(event);
+      } catch (eventError) {
+        import_consola4.consola.warn("Failed to dispatch validation error event:", eventError);
+      }
+    }
+    throw error;
+  }
+}
+__name(partialUpdateAccountsProfilePartialUpdate, "partialUpdateAccountsProfilePartialUpdate");
+async function partialUpdateAccountsProfilePartialPartialUpdate(data, client) {
+  const api = client || getAPIInstance();
+  const response = await api.user_profile.accountsProfilePartialPartialUpdate(data);
+  try {
+    return UserSchema.parse(response);
+  } catch (error) {
+    import_consola4.consola.error("\u274C Zod Validation Failed");
+    import_consola4.consola.box(`partialUpdateAccountsProfilePartialPartialUpdate
+Path: /cfg/accounts/profile/partial/
+Method: PATCH`);
+    if (error instanceof Error && "issues" in error && Array.isArray(error.issues)) {
+      import_consola4.consola.error("Validation Issues:");
+      error.issues.forEach((issue, index) => {
+        import_consola4.consola.error(`  ${index + 1}. ${issue.path.join(".") || "root"}`);
+        import_consola4.consola.error(`     \u251C\u2500 Message: ${issue.message}`);
+        if (issue.expected) import_consola4.consola.error(`     \u251C\u2500 Expected: ${issue.expected}`);
+        if (issue.received) import_consola4.consola.error(`     \u2514\u2500 Received: ${issue.received}`);
+      });
+    }
+    import_consola4.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: "partialUpdateAccountsProfilePartialPartialUpdate",
+            path: "/cfg/accounts/profile/partial/",
+            method: "PATCH",
+            error,
+            response,
+            timestamp: /* @__PURE__ */ new Date()
+          },
+          bubbles: true,
+          cancelable: false
+        });
+        window.dispatchEvent(event);
+      } catch (eventError) {
+        import_consola4.consola.warn("Failed to dispatch validation error event:", eventError);
+      }
+    }
+    throw error;
+  }
+}
+__name(partialUpdateAccountsProfilePartialPartialUpdate, "partialUpdateAccountsProfilePartialPartialUpdate");
+async function updateAccountsProfileUpdateUpdate(data, client) {
+  const api = client || getAPIInstance();
+  const response = await api.user_profile.accountsProfileUpdateUpdate(data);
+  try {
+    return UserSchema.parse(response);
+  } catch (error) {
+    import_consola4.consola.error("\u274C Zod Validation Failed");
+    import_consola4.consola.box(`updateAccountsProfileUpdateUpdate
+Path: /cfg/accounts/profile/update/
+Method: PUT`);
+    if (error instanceof Error && "issues" in error && Array.isArray(error.issues)) {
+      import_consola4.consola.error("Validation Issues:");
+      error.issues.forEach((issue, index) => {
+        import_consola4.consola.error(`  ${index + 1}. ${issue.path.join(".") || "root"}`);
+        import_consola4.consola.error(`     \u251C\u2500 Message: ${issue.message}`);
+        if (issue.expected) import_consola4.consola.error(`     \u251C\u2500 Expected: ${issue.expected}`);
+        if (issue.received) import_consola4.consola.error(`     \u2514\u2500 Received: ${issue.received}`);
+      });
+    }
+    import_consola4.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: "updateAccountsProfileUpdateUpdate",
+            path: "/cfg/accounts/profile/update/",
+            method: "PUT",
+            error,
+            response,
+            timestamp: /* @__PURE__ */ new Date()
+          },
+          bubbles: true,
+          cancelable: false
+        });
+        window.dispatchEvent(event);
+      } catch (eventError) {
+        import_consola4.consola.warn("Failed to dispatch validation error event:", eventError);
+      }
+    }
+    throw error;
+  }
+}
+__name(updateAccountsProfileUpdateUpdate, "updateAccountsProfileUpdateUpdate");
+async function partialUpdateAccountsProfileUpdatePartialUpdate(data, client) {
+  const api = client || getAPIInstance();
+  const response = await api.user_profile.accountsProfileUpdatePartialUpdate(data);
+  try {
+    return UserSchema.parse(response);
+  } catch (error) {
+    import_consola4.consola.error("\u274C Zod Validation Failed");
+    import_consola4.consola.box(`partialUpdateAccountsProfileUpdatePartialUpdate
+Path: /cfg/accounts/profile/update/
+Method: PATCH`);
+    if (error instanceof Error && "issues" in error && Array.isArray(error.issues)) {
+      import_consola4.consola.error("Validation Issues:");
+      error.issues.forEach((issue, index) => {
+        import_consola4.consola.error(`  ${index + 1}. ${issue.path.join(".") || "root"}`);
+        import_consola4.consola.error(`     \u251C\u2500 Message: ${issue.message}`);
+        if (issue.expected) import_consola4.consola.error(`     \u251C\u2500 Expected: ${issue.expected}`);
+        if (issue.received) import_consola4.consola.error(`     \u2514\u2500 Received: ${issue.received}`);
+      });
+    }
+    import_consola4.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: "partialUpdateAccountsProfileUpdatePartialUpdate",
+            path: "/cfg/accounts/profile/update/",
+            method: "PATCH",
+            error,
+            response,
+            timestamp: /* @__PURE__ */ new Date()
+          },
+          bubbles: true,
+          cancelable: false
+        });
+        window.dispatchEvent(event);
+      } catch (eventError) {
+        import_consola4.consola.warn("Failed to dispatch validation error event:", eventError);
+      }
+    }
+    throw error;
+  }
+}
+__name(partialUpdateAccountsProfileUpdatePartialUpdate, "partialUpdateAccountsProfileUpdatePartialUpdate");
+
+// src/generated/cfg_accounts/api-instance.ts
+var globalAPI = null;
+function getAPIInstance() {
+  if (!globalAPI) {
+    throw new Error(
+      'API not configured. Call configureAPI() with your base URL before using fetchers or hooks.\n\nExample:\n  import { configureAPI } from "./api-instance"\n  configureAPI({ baseUrl: "https://api.example.com" })'
+    );
+  }
+  return globalAPI;
+}
+__name(getAPIInstance, "getAPIInstance");
+
+// src/generated/cfg_accounts/_utils/fetchers/accounts__auth.ts
+async function createAccountsTokenRefreshCreate(data, client) {
+  const api = client || getAPIInstance();
+  const response = await api.auth.accountsTokenRefreshCreate(data);
+  try {
+    return TokenRefreshSchema.parse(response);
+  } catch (error) {
+    import_consola5.consola.error("\u274C Zod Validation Failed");
+    import_consola5.consola.box(`createAccountsTokenRefreshCreate
+Path: /cfg/accounts/token/refresh/
+Method: POST`);
+    if (error instanceof Error && "issues" in error && Array.isArray(error.issues)) {
+      import_consola5.consola.error("Validation Issues:");
+      error.issues.forEach((issue, index) => {
+        import_consola5.consola.error(`  ${index + 1}. ${issue.path.join(".") || "root"}`);
+        import_consola5.consola.error(`     \u251C\u2500 Message: ${issue.message}`);
+        if (issue.expected) import_consola5.consola.error(`     \u251C\u2500 Expected: ${issue.expected}`);
+        if (issue.received) import_consola5.consola.error(`     \u2514\u2500 Received: ${issue.received}`);
+      });
+    }
+    import_consola5.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: "createAccountsTokenRefreshCreate",
+            path: "/cfg/accounts/token/refresh/",
+            method: "POST",
+            error,
+            response,
+            timestamp: /* @__PURE__ */ new Date()
+          },
+          bubbles: true,
+          cancelable: false
+        });
+        window.dispatchEvent(event);
+      } catch (eventError) {
+        import_consola5.consola.warn("Failed to dispatch validation error event:", eventError);
+      }
+    }
+    throw error;
+  }
+}
+__name(createAccountsTokenRefreshCreate, "createAccountsTokenRefreshCreate");
+
+// src/generated/cfg_accounts/_utils/hooks/accounts__auth.ts
+function useCreateAccountsTokenRefreshCreate() {
+  const { mutate } = (0, import_swr.useSWRConfig)();
+  return async (data, client) => {
+    const result = await createAccountsTokenRefreshCreate(data, client);
+    mutate("cfg-accounts-token-refresh");
+    return result;
+  };
+}
+__name(useCreateAccountsTokenRefreshCreate, "useCreateAccountsTokenRefreshCreate");
+
+// src/generated/cfg_accounts/_utils/hooks/accounts__oauth.ts
+var import_swr2 = __toESM(require("swr"), 1);
+var import_swr3 = require("swr");
+function useAccountsOauthConnectionsList(client) {
+  return (0, import_swr2.default)(
+    "cfg-accounts-oauth-connections",
+    () => getAccountsOauthConnectionsList(client)
+  );
+}
+__name(useAccountsOauthConnectionsList, "useAccountsOauthConnectionsList");
+function useCreateAccountsOauthDisconnectCreate() {
+  const { mutate } = (0, import_swr3.useSWRConfig)();
+  return async (data, client) => {
+    const result = await createAccountsOauthDisconnectCreate(data, client);
+    mutate("cfg-accounts-oauth-disconnect");
+    return result;
+  };
+}
+__name(useCreateAccountsOauthDisconnectCreate, "useCreateAccountsOauthDisconnectCreate");
+function useCreateAccountsOauthGithubAuthorizeCreate() {
+  const { mutate } = (0, import_swr3.useSWRConfig)();
+  return async (data, client) => {
+    const result = await createAccountsOauthGithubAuthorizeCreate(data, client);
+    mutate("cfg-accounts-oauth-github-authorize");
+    return result;
+  };
+}
+__name(useCreateAccountsOauthGithubAuthorizeCreate, "useCreateAccountsOauthGithubAuthorizeCreate");
+function useCreateAccountsOauthGithubCallbackCreate() {
+  const { mutate } = (0, import_swr3.useSWRConfig)();
+  return async (data, client) => {
+    const result = await createAccountsOauthGithubCallbackCreate(data, client);
+    mutate("cfg-accounts-oauth-github-callback");
+    return result;
+  };
+}
+__name(useCreateAccountsOauthGithubCallbackCreate, "useCreateAccountsOauthGithubCallbackCreate");
+function useAccountsOauthProvidersRetrieve(client) {
+  return (0, import_swr2.default)(
+    "cfg-accounts-oauth-provider",
+    () => getAccountsOauthProvidersRetrieve(client)
+  );
+}
+__name(useAccountsOauthProvidersRetrieve, "useAccountsOauthProvidersRetrieve");
+
+// src/generated/cfg_accounts/_utils/hooks/accounts__user_profile.ts
+var import_swr4 = __toESM(require("swr"), 1);
+var import_swr5 = require("swr");
+function useAccountsProfileRetrieve(client) {
+  return (0, import_swr4.default)(
+    "cfg-accounts-profile",
+    () => getAccountsProfileRetrieve(client)
+  );
+}
+__name(useAccountsProfileRetrieve, "useAccountsProfileRetrieve");
+function useCreateAccountsProfileAvatarCreate() {
+  const { mutate } = (0, import_swr5.useSWRConfig)();
+  return async (data, client) => {
+    const result = await createAccountsProfileAvatarCreate(data, client);
+    mutate("cfg-accounts-profile-avatar");
+    return result;
+  };
+}
+__name(useCreateAccountsProfileAvatarCreate, "useCreateAccountsProfileAvatarCreate");
+function usePartialUpdateAccountsProfilePartialUpdate() {
+  const { mutate } = (0, import_swr5.useSWRConfig)();
+  return async (data, client) => {
+    const result = await partialUpdateAccountsProfilePartialUpdate(data, client);
+    mutate("cfg-accounts-profile-partial");
+    return result;
+  };
+}
+__name(usePartialUpdateAccountsProfilePartialUpdate, "usePartialUpdateAccountsProfilePartialUpdate");
+function usePartialUpdateAccountsProfilePartialPartialUpdate() {
+  const { mutate } = (0, import_swr5.useSWRConfig)();
+  return async (data, client) => {
+    const result = await partialUpdateAccountsProfilePartialPartialUpdate(data, client);
+    mutate("cfg-accounts-profile-partial-partial");
+    return result;
+  };
+}
+__name(usePartialUpdateAccountsProfilePartialPartialUpdate, "usePartialUpdateAccountsProfilePartialPartialUpdate");
+function useUpdateAccountsProfileUpdateUpdate() {
+  const { mutate } = (0, import_swr5.useSWRConfig)();
+  return async (data, client) => {
+    const result = await updateAccountsProfileUpdateUpdate(data, client);
+    mutate("cfg-accounts-profile");
+    return result;
+  };
+}
+__name(useUpdateAccountsProfileUpdateUpdate, "useUpdateAccountsProfileUpdateUpdate");
+function usePartialUpdateAccountsProfileUpdatePartialUpdate() {
+  const { mutate } = (0, import_swr5.useSWRConfig)();
+  return async (data, client) => {
+    const result = await partialUpdateAccountsProfileUpdatePartialUpdate(data, client);
+    mutate("cfg-accounts-profile-partial");
+    return result;
+  };
+}
+__name(usePartialUpdateAccountsProfileUpdatePartialUpdate, "usePartialUpdateAccountsProfileUpdatePartialUpdate");
+
+// src/generated/cfg_accounts/_utils/hooks/accounts.ts
+var import_swr6 = require("swr");
+function useCreateAccountsOtpRequestCreate() {
+  const { mutate } = (0, import_swr6.useSWRConfig)();
+  return async (data, client) => {
+    const result = await createAccountsOtpRequestCreate(data, client);
+    mutate("cfg-accounts-otp-request");
+    return result;
+  };
+}
+__name(useCreateAccountsOtpRequestCreate, "useCreateAccountsOtpRequestCreate");
+function useCreateAccountsOtpVerifyCreate() {
+  const { mutate } = (0, import_swr6.useSWRConfig)();
+  return async (data, client) => {
+    const result = await createAccountsOtpVerifyCreate(data, client);
+    mutate("cfg-accounts-otp-verify");
+    return result;
+  };
+}
+__name(useCreateAccountsOtpVerifyCreate, "useCreateAccountsOtpVerifyCreate");
 //# sourceMappingURL=hooks.cjs.map