@djangocfg/api 2.1.99 → 2.1.101

package/dist/auth.cjs

@@ -56,6 +56,7 @@ __export(auth_exports, {
   useAuthValidation: () => useAuthValidation,
   useAutoAuth: () => useAutoAuth,
   useBase64: () => useBase64,
+  useDeleteAccount: () => useDeleteAccount,
   useGithubAuth: () => useGithubAuth,
   useLocalStorage: () => useLocalStorage2,
   useSessionStorage: () => useSessionStorage,
@@ -176,6 +177,19 @@ var UserProfile = class {
     const response = await this.client.request("POST", "/cfg/accounts/profile/avatar/", { formData });
     return response;
   }
+  /**
+   * Delete user account
+   * 
+   * Permanently delete the current user's account. This operation: -
+   * Deactivates the account (user cannot log in) - Anonymizes personal data
+   * (GDPR compliance) - Frees up the email address for re-registration -
+   * Preserves audit trail The account can be restored by an administrator if
+   * needed.
+   */
+  async accountsProfileDeleteCreate() {
+    const response = await this.client.request("POST", "/cfg/accounts/profile/delete/");
+    return response;
+  }
   /**
    * Partial update user profile
    * 
@@ -892,183 +906,190 @@ var OTPVerifyRequestChannel = /* @__PURE__ */ ((OTPVerifyRequestChannel2) => {
   return OTPVerifyRequestChannel2;
 })(OTPVerifyRequestChannel || {});
 
-// src/generated/cfg_accounts/_utils/schemas/CentrifugoToken.schema.ts
+// src/generated/cfg_accounts/_utils/schemas/AccountDeleteResponse.schema.ts
 var import_zod = require("zod");
-var CentrifugoTokenSchema = import_zod.z.object({
-  token: import_zod.z.string(),
-  centrifugo_url: import_zod.z.union([import_zod.z.url(), import_zod.z.literal("")]),
-  expires_at: import_zod.z.iso.datetime(),
-  channels: import_zod.z.array(import_zod.z.string())
+var AccountDeleteResponseSchema = import_zod.z.object({
+  success: import_zod.z.boolean(),
+  message: import_zod.z.string()
 });
 
-// src/generated/cfg_accounts/_utils/schemas/CfgAccountsProfileAvatarCreateRequest.schema.ts
+// src/generated/cfg_accounts/_utils/schemas/CentrifugoToken.schema.ts
 var import_zod2 = require("zod");
-var CfgAccountsProfileAvatarCreateRequestSchema = import_zod2.z.object({
-  avatar: import_zod2.z.union([import_zod2.z.instanceof(File), import_zod2.z.instanceof(Blob)])
+var CentrifugoTokenSchema = import_zod2.z.object({
+  token: import_zod2.z.string(),
+  centrifugo_url: import_zod2.z.union([import_zod2.z.url(), import_zod2.z.literal("")]),
+  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
+// src/generated/cfg_accounts/_utils/schemas/CfgAccountsProfileAvatarCreateRequest.schema.ts
 var import_zod3 = require("zod");
-var OAuthAuthorizeRequestRequestSchema = import_zod3.z.object({
-  redirect_uri: import_zod3.z.union([import_zod3.z.url(), import_zod3.z.literal("")]).optional(),
-  source_url: import_zod3.z.union([import_zod3.z.url(), import_zod3.z.literal("")]).optional()
+var CfgAccountsProfileAvatarCreateRequestSchema = import_zod3.z.object({
+  avatar: import_zod3.z.union([import_zod3.z.instanceof(File), import_zod3.z.instanceof(Blob)])
 });
 
-// src/generated/cfg_accounts/_utils/schemas/OAuthAuthorizeResponse.schema.ts
+// src/generated/cfg_accounts/_utils/schemas/OAuthAuthorizeRequestRequest.schema.ts
 var import_zod4 = require("zod");
-var OAuthAuthorizeResponseSchema = import_zod4.z.object({
-  authorization_url: import_zod4.z.union([import_zod4.z.url(), import_zod4.z.literal("")]),
-  state: import_zod4.z.string()
+var OAuthAuthorizeRequestRequestSchema = import_zod4.z.object({
+  redirect_uri: import_zod4.z.union([import_zod4.z.url(), import_zod4.z.literal("")]).optional(),
+  source_url: import_zod4.z.union([import_zod4.z.url(), import_zod4.z.literal("")]).optional()
 });
 
-// src/generated/cfg_accounts/_utils/schemas/OAuthCallbackRequestRequest.schema.ts
+// src/generated/cfg_accounts/_utils/schemas/OAuthAuthorizeResponse.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.union([import_zod5.z.url(), import_zod5.z.literal("")]).optional()
+var OAuthAuthorizeResponseSchema = import_zod5.z.object({
+  authorization_url: import_zod5.z.union([import_zod5.z.url(), import_zod5.z.literal("")]),
+  state: import_zod5.z.string()
 });
 
-// src/generated/cfg_accounts/_utils/schemas/OAuthConnection.schema.ts
+// src/generated/cfg_accounts/_utils/schemas/OAuthCallbackRequestRequest.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.union([import_zod6.z.url(), import_zod6.z.literal("")]),
-  connected_at: import_zod6.z.iso.datetime(),
-  last_login_at: import_zod6.z.iso.datetime()
+var OAuthCallbackRequestRequestSchema = import_zod6.z.object({
+  code: import_zod6.z.string().min(10).max(500),
+  state: import_zod6.z.string().min(20).max(100),
+  redirect_uri: import_zod6.z.union([import_zod6.z.url(), import_zod6.z.literal("")]).optional()
 });
 
-// src/generated/cfg_accounts/_utils/schemas/OAuthDisconnectRequestRequest.schema.ts
+// src/generated/cfg_accounts/_utils/schemas/OAuthConnection.schema.ts
 var import_zod7 = require("zod");
-var OAuthDisconnectRequestRequestSchema = import_zod7.z.object({
-  provider: import_zod7.z.nativeEnum(OAuthDisconnectRequestRequestProvider)
+var OAuthConnectionSchema = import_zod7.z.object({
+  id: import_zod7.z.int(),
+  provider: import_zod7.z.nativeEnum(OAuthConnectionProvider),
+  provider_display: import_zod7.z.string(),
+  provider_username: import_zod7.z.string(),
+  provider_email: import_zod7.z.email(),
+  provider_avatar_url: import_zod7.z.union([import_zod7.z.url(), import_zod7.z.literal("")]),
+  connected_at: import_zod7.z.iso.datetime(),
+  last_login_at: import_zod7.z.iso.datetime()
 });
 
-// src/generated/cfg_accounts/_utils/schemas/OAuthError.schema.ts
+// src/generated/cfg_accounts/_utils/schemas/OAuthDisconnectRequestRequest.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()
+var OAuthDisconnectRequestRequestSchema = import_zod8.z.object({
+  provider: import_zod8.z.nativeEnum(OAuthDisconnectRequestRequestProvider)
 });
 
-// src/generated/cfg_accounts/_utils/schemas/OAuthProvidersResponse.schema.ts
+// src/generated/cfg_accounts/_utils/schemas/OAuthError.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.any()))
+var OAuthErrorSchema = import_zod9.z.object({
+  error: import_zod9.z.string(),
+  error_description: import_zod9.z.string().optional()
 });
 
-// src/generated/cfg_accounts/_utils/schemas/OAuthTokenResponse.schema.ts
+// src/generated/cfg_accounts/_utils/schemas/OAuthProvidersResponse.schema.ts
 var import_zod10 = require("zod");
-var OAuthTokenResponseSchema = import_zod10.z.object({
-  requires_2fa: import_zod10.z.boolean().optional(),
-  session_id: import_zod10.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_zod10.z.string().nullable().optional(),
-  refresh: import_zod10.z.string().nullable().optional(),
-  user: import_zod10.z.record(import_zod10.z.string(), import_zod10.z.any()).nullable().optional(),
-  is_new_user: import_zod10.z.boolean(),
-  is_new_connection: import_zod10.z.boolean(),
-  should_prompt_2fa: import_zod10.z.boolean().optional()
+var OAuthProvidersResponseSchema = import_zod10.z.object({
+  providers: import_zod10.z.array(import_zod10.z.record(import_zod10.z.string(), import_zod10.z.any()))
 });
 
-// src/generated/cfg_accounts/_utils/schemas/OTPErrorResponse.schema.ts
+// src/generated/cfg_accounts/_utils/schemas/OAuthTokenResponse.schema.ts
 var import_zod11 = require("zod");
-var OTPErrorResponseSchema = import_zod11.z.object({
-  error: import_zod11.z.string()
+var OAuthTokenResponseSchema = import_zod11.z.object({
+  requires_2fa: import_zod11.z.boolean().optional(),
+  session_id: import_zod11.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_zod11.z.string().nullable().optional(),
+  refresh: import_zod11.z.string().nullable().optional(),
+  user: import_zod11.z.record(import_zod11.z.string(), import_zod11.z.any()).nullable().optional(),
+  is_new_user: import_zod11.z.boolean(),
+  is_new_connection: import_zod11.z.boolean(),
+  should_prompt_2fa: import_zod11.z.boolean().optional()
 });
 
-// src/generated/cfg_accounts/_utils/schemas/OTPRequestRequest.schema.ts
+// src/generated/cfg_accounts/_utils/schemas/OTPErrorResponse.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.union([import_zod12.z.url(), import_zod12.z.literal("")]).optional()
+var OTPErrorResponseSchema = import_zod12.z.object({
+  error: import_zod12.z.string()
 });
 
-// src/generated/cfg_accounts/_utils/schemas/OTPRequestResponse.schema.ts
+// src/generated/cfg_accounts/_utils/schemas/OTPRequestRequest.schema.ts
 var import_zod13 = require("zod");
-var OTPRequestResponseSchema = import_zod13.z.object({
-  message: import_zod13.z.string()
+var OTPRequestRequestSchema = import_zod13.z.object({
+  identifier: import_zod13.z.string().min(1),
+  channel: import_zod13.z.nativeEnum(OTPRequestRequestChannel).optional(),
+  source_url: import_zod13.z.union([import_zod13.z.url(), import_zod13.z.literal("")]).optional()
 });
 
-// src/generated/cfg_accounts/_utils/schemas/OTPVerifyRequest.schema.ts
+// src/generated/cfg_accounts/_utils/schemas/OTPRequestResponse.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.union([import_zod14.z.url(), import_zod14.z.literal("")]).optional()
+var OTPRequestResponseSchema = import_zod14.z.object({
+  message: import_zod14.z.string()
+});
+
+// src/generated/cfg_accounts/_utils/schemas/OTPVerifyRequest.schema.ts
+var import_zod15 = require("zod");
+var OTPVerifyRequestSchema = import_zod15.z.object({
+  identifier: import_zod15.z.string().min(1),
+  otp: import_zod15.z.string().min(6).max(6),
+  channel: import_zod15.z.nativeEnum(OTPVerifyRequestChannel).optional(),
+  source_url: import_zod15.z.union([import_zod15.z.url(), import_zod15.z.literal("")]).optional()
 });
 
 // src/generated/cfg_accounts/_utils/schemas/OTPVerifyResponse.schema.ts
-var import_zod16 = require("zod");
+var import_zod17 = 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.union([import_zod15.z.url(), import_zod15.z.literal("")]).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(),
+var import_zod16 = require("zod");
+var UserSchema = import_zod16.z.object({
+  id: import_zod16.z.int(),
+  email: import_zod16.z.email(),
+  first_name: import_zod16.z.string().max(50).optional(),
+  last_name: import_zod16.z.string().max(50).optional(),
+  full_name: import_zod16.z.string(),
+  initials: import_zod16.z.string(),
+  display_username: import_zod16.z.string(),
+  company: import_zod16.z.string().max(100).optional(),
+  phone: import_zod16.z.string().max(20).optional(),
+  position: import_zod16.z.string().max(100).optional(),
+  avatar: import_zod16.z.union([import_zod16.z.url(), import_zod16.z.literal("")]).nullable(),
+  is_staff: import_zod16.z.boolean(),
+  is_superuser: import_zod16.z.boolean(),
+  date_joined: import_zod16.z.iso.datetime(),
+  last_login: import_zod16.z.iso.datetime().nullable(),
+  unanswered_messages_count: import_zod16.z.int(),
   centrifugo: CentrifugoTokenSchema.nullable()
 });
 
 // src/generated/cfg_accounts/_utils/schemas/OTPVerifyResponse.schema.ts
-var OTPVerifyResponseSchema = import_zod16.z.object({
-  requires_2fa: import_zod16.z.boolean().optional(),
-  session_id: import_zod16.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_zod16.z.string().nullable().optional(),
-  access: import_zod16.z.string().nullable().optional(),
+var OTPVerifyResponseSchema = import_zod17.z.object({
+  requires_2fa: import_zod17.z.boolean().optional(),
+  session_id: import_zod17.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_zod17.z.string().nullable().optional(),
+  access: import_zod17.z.string().nullable().optional(),
   user: UserSchema.nullable().optional(),
-  should_prompt_2fa: import_zod16.z.boolean().optional()
+  should_prompt_2fa: import_zod17.z.boolean().optional()
 });
 
 // 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()
+var import_zod18 = require("zod");
+var PatchedUserProfileUpdateRequestSchema = import_zod18.z.object({
+  first_name: import_zod18.z.string().max(50).optional(),
+  last_name: import_zod18.z.string().max(50).optional(),
+  company: import_zod18.z.string().max(100).optional(),
+  phone: import_zod18.z.string().max(20).optional(),
+  position: import_zod18.z.string().max(100).optional()
 });
 
 // src/generated/cfg_accounts/_utils/schemas/TokenRefresh.schema.ts
-var import_zod18 = require("zod");
-var TokenRefreshSchema = import_zod18.z.object({
-  access: import_zod18.z.string(),
-  refresh: import_zod18.z.string()
+var import_zod19 = require("zod");
+var TokenRefreshSchema = import_zod19.z.object({
+  access: import_zod19.z.string(),
+  refresh: import_zod19.z.string()
 });
 
 // src/generated/cfg_accounts/_utils/schemas/TokenRefreshRequest.schema.ts
-var import_zod19 = require("zod");
-var TokenRefreshRequestSchema = import_zod19.z.object({
-  refresh: import_zod19.z.string().min(1)
+var import_zod20 = require("zod");
+var TokenRefreshRequestSchema = import_zod20.z.object({
+  refresh: import_zod20.z.string().min(1)
 });
 
 // src/generated/cfg_accounts/_utils/schemas/UserProfileUpdateRequest.schema.ts
-var import_zod20 = require("zod");
-var UserProfileUpdateRequestSchema = import_zod20.z.object({
-  first_name: import_zod20.z.string().max(50).optional(),
-  last_name: import_zod20.z.string().max(50).optional(),
-  company: import_zod20.z.string().max(100).optional(),
-  phone: import_zod20.z.string().max(20).optional(),
-  position: import_zod20.z.string().max(100).optional()
+var import_zod21 = require("zod");
+var UserProfileUpdateRequestSchema = import_zod21.z.object({
+  first_name: import_zod21.z.string().max(50).optional(),
+  last_name: import_zod21.z.string().max(50).optional(),
+  company: import_zod21.z.string().max(100).optional(),
+  phone: import_zod21.z.string().max(20).optional(),
+  position: import_zod21.z.string().max(100).optional()
 });
 
 // src/generated/cfg_accounts/_utils/fetchers/accounts.ts
@@ -2373,320 +2394,320 @@ var LocalStorageAdapter2 = class {
 };
 
 // src/generated/cfg_centrifugo/_utils/schemas/CentrifugoChannelInfo.schema.ts
-var import_zod21 = require("zod");
-var CentrifugoChannelInfoSchema = import_zod21.z.object({
-  num_clients: import_zod21.z.int()
+var import_zod22 = require("zod");
+var CentrifugoChannelInfoSchema = import_zod22.z.object({
+  num_clients: import_zod22.z.int()
 });
 
 // src/generated/cfg_centrifugo/_utils/schemas/CentrifugoChannelsRequestRequest.schema.ts
-var import_zod22 = require("zod");
-var CentrifugoChannelsRequestRequestSchema = import_zod22.z.object({
-  pattern: import_zod22.z.string().nullable().optional()
+var import_zod23 = require("zod");
+var CentrifugoChannelsRequestRequestSchema = import_zod23.z.object({
+  pattern: import_zod23.z.string().nullable().optional()
 });
 
 // src/generated/cfg_centrifugo/_utils/schemas/CentrifugoChannelsResponse.schema.ts
-var import_zod25 = require("zod");
+var import_zod26 = require("zod");
 
 // src/generated/cfg_centrifugo/_utils/schemas/CentrifugoChannelsResult.schema.ts
-var import_zod23 = require("zod");
-var CentrifugoChannelsResultSchema = import_zod23.z.object({
-  channels: import_zod23.z.record(import_zod23.z.string(), CentrifugoChannelInfoSchema)
+var import_zod24 = require("zod");
+var CentrifugoChannelsResultSchema = import_zod24.z.object({
+  channels: import_zod24.z.record(import_zod24.z.string(), CentrifugoChannelInfoSchema)
 });
 
 // src/generated/cfg_centrifugo/_utils/schemas/CentrifugoError.schema.ts
-var import_zod24 = require("zod");
-var CentrifugoErrorSchema = import_zod24.z.object({
-  code: import_zod24.z.int().optional(),
-  message: import_zod24.z.string().optional()
+var import_zod25 = require("zod");
+var CentrifugoErrorSchema = import_zod25.z.object({
+  code: import_zod25.z.int().optional(),
+  message: import_zod25.z.string().optional()
 });
 
 // src/generated/cfg_centrifugo/_utils/schemas/CentrifugoChannelsResponse.schema.ts
-var CentrifugoChannelsResponseSchema = import_zod25.z.object({
+var CentrifugoChannelsResponseSchema = import_zod26.z.object({
   error: CentrifugoErrorSchema.optional(),
   result: CentrifugoChannelsResultSchema.optional()
 });
 
 // src/generated/cfg_centrifugo/_utils/schemas/CentrifugoClientInfo.schema.ts
-var import_zod26 = require("zod");
-var CentrifugoClientInfoSchema = import_zod26.z.object({
-  user: import_zod26.z.string(),
-  client: import_zod26.z.string(),
-  conn_info: import_zod26.z.record(import_zod26.z.string(), import_zod26.z.any()).nullable().optional(),
-  chan_info: import_zod26.z.record(import_zod26.z.string(), import_zod26.z.any()).nullable().optional()
+var import_zod27 = require("zod");
+var CentrifugoClientInfoSchema = import_zod27.z.object({
+  user: import_zod27.z.string(),
+  client: import_zod27.z.string(),
+  conn_info: import_zod27.z.record(import_zod27.z.string(), import_zod27.z.any()).nullable().optional(),
+  chan_info: import_zod27.z.record(import_zod27.z.string(), import_zod27.z.any()).nullable().optional()
 });
 
 // src/generated/cfg_centrifugo/_utils/schemas/CentrifugoHealthCheck.schema.ts
-var import_zod27 = require("zod");
-var CentrifugoHealthCheckSchema = import_zod27.z.object({
-  status: import_zod27.z.string(),
-  wrapper_url: import_zod27.z.string(),
-  has_api_key: import_zod27.z.boolean(),
-  timestamp: import_zod27.z.string()
+var import_zod28 = require("zod");
+var CentrifugoHealthCheckSchema = import_zod28.z.object({
+  status: import_zod28.z.string(),
+  wrapper_url: import_zod28.z.string(),
+  has_api_key: import_zod28.z.boolean(),
+  timestamp: import_zod28.z.string()
 });
 
 // src/generated/cfg_centrifugo/_utils/schemas/CentrifugoHistoryRequestRequest.schema.ts
-var import_zod29 = require("zod");
+var import_zod30 = require("zod");
 
 // src/generated/cfg_centrifugo/_utils/schemas/CentrifugoStreamPosition.schema.ts
-var import_zod28 = require("zod");
-var CentrifugoStreamPositionSchema = import_zod28.z.object({
-  offset: import_zod28.z.int(),
-  epoch: import_zod28.z.string()
+var import_zod29 = require("zod");
+var CentrifugoStreamPositionSchema = import_zod29.z.object({
+  offset: import_zod29.z.int(),
+  epoch: import_zod29.z.string()
 });
 
 // src/generated/cfg_centrifugo/_utils/schemas/CentrifugoHistoryRequestRequest.schema.ts
-var CentrifugoHistoryRequestRequestSchema = import_zod29.z.object({
-  channel: import_zod29.z.string(),
-  limit: import_zod29.z.int().nullable().optional(),
+var CentrifugoHistoryRequestRequestSchema = import_zod30.z.object({
+  channel: import_zod30.z.string(),
+  limit: import_zod30.z.int().nullable().optional(),
   since: CentrifugoStreamPositionSchema.optional(),
-  reverse: import_zod29.z.boolean().nullable().optional()
+  reverse: import_zod30.z.boolean().nullable().optional()
 });
 
 // src/generated/cfg_centrifugo/_utils/schemas/CentrifugoHistoryResponse.schema.ts
-var import_zod32 = require("zod");
+var import_zod33 = require("zod");
 
 // src/generated/cfg_centrifugo/_utils/schemas/CentrifugoHistoryResult.schema.ts
-var import_zod31 = require("zod");
+var import_zod32 = require("zod");
 
 // src/generated/cfg_centrifugo/_utils/schemas/CentrifugoPublication.schema.ts
-var import_zod30 = require("zod");
-var CentrifugoPublicationSchema = import_zod30.z.object({
-  data: import_zod30.z.record(import_zod30.z.string(), import_zod30.z.any()),
+var import_zod31 = require("zod");
+var CentrifugoPublicationSchema = import_zod31.z.object({
+  data: import_zod31.z.record(import_zod31.z.string(), import_zod31.z.any()),
   info: CentrifugoClientInfoSchema.optional(),
-  offset: import_zod30.z.int(),
-  tags: import_zod30.z.record(import_zod30.z.string(), import_zod30.z.any()).nullable().optional()
+  offset: import_zod31.z.int(),
+  tags: import_zod31.z.record(import_zod31.z.string(), import_zod31.z.any()).nullable().optional()
 });
 
 // src/generated/cfg_centrifugo/_utils/schemas/CentrifugoHistoryResult.schema.ts
-var CentrifugoHistoryResultSchema = import_zod31.z.object({
-  publications: import_zod31.z.array(CentrifugoPublicationSchema),
-  epoch: import_zod31.z.string(),
-  offset: import_zod31.z.int()
+var CentrifugoHistoryResultSchema = import_zod32.z.object({
+  publications: import_zod32.z.array(CentrifugoPublicationSchema),
+  epoch: import_zod32.z.string(),
+  offset: import_zod32.z.int()
 });
 
 // src/generated/cfg_centrifugo/_utils/schemas/CentrifugoHistoryResponse.schema.ts
-var CentrifugoHistoryResponseSchema = import_zod32.z.object({
+var CentrifugoHistoryResponseSchema = import_zod33.z.object({
   error: CentrifugoErrorSchema.optional(),
   result: CentrifugoHistoryResultSchema.optional()
 });
 
 // src/generated/cfg_centrifugo/_utils/schemas/CentrifugoInfoResponse.schema.ts
-var import_zod37 = require("zod");
+var import_zod38 = require("zod");
 
 // src/generated/cfg_centrifugo/_utils/schemas/CentrifugoInfoResult.schema.ts
-var import_zod36 = require("zod");
+var import_zod37 = require("zod");
 
 // src/generated/cfg_centrifugo/_utils/schemas/CentrifugoNodeInfo.schema.ts
-var import_zod35 = require("zod");
+var import_zod36 = require("zod");
 
 // src/generated/cfg_centrifugo/_utils/schemas/CentrifugoMetrics.schema.ts
-var import_zod33 = require("zod");
-var CentrifugoMetricsSchema = import_zod33.z.object({
-  interval: import_zod33.z.number(),
-  items: import_zod33.z.record(import_zod33.z.string(), import_zod33.z.number())
+var import_zod34 = require("zod");
+var CentrifugoMetricsSchema = import_zod34.z.object({
+  interval: import_zod34.z.number(),
+  items: import_zod34.z.record(import_zod34.z.string(), import_zod34.z.number())
 });
 
 // src/generated/cfg_centrifugo/_utils/schemas/CentrifugoProcess.schema.ts
-var import_zod34 = require("zod");
-var CentrifugoProcessSchema = import_zod34.z.object({
-  cpu: import_zod34.z.number(),
-  rss: import_zod34.z.int()
+var import_zod35 = require("zod");
+var CentrifugoProcessSchema = import_zod35.z.object({
+  cpu: import_zod35.z.number(),
+  rss: import_zod35.z.int()
 });
 
 // src/generated/cfg_centrifugo/_utils/schemas/CentrifugoNodeInfo.schema.ts
-var CentrifugoNodeInfoSchema = import_zod35.z.object({
-  uid: import_zod35.z.string(),
-  name: import_zod35.z.string(),
-  version: import_zod35.z.string(),
-  num_clients: import_zod35.z.int(),
-  num_users: import_zod35.z.int(),
-  num_channels: import_zod35.z.int(),
-  uptime: import_zod35.z.int(),
-  num_subs: import_zod35.z.int(),
+var CentrifugoNodeInfoSchema = import_zod36.z.object({
+  uid: import_zod36.z.string(),
+  name: import_zod36.z.string(),
+  version: import_zod36.z.string(),
+  num_clients: import_zod36.z.int(),
+  num_users: import_zod36.z.int(),
+  num_channels: import_zod36.z.int(),
+  uptime: import_zod36.z.int(),
+  num_subs: import_zod36.z.int(),
   metrics: CentrifugoMetricsSchema.optional(),
   process: CentrifugoProcessSchema.optional()
 });
 
 // src/generated/cfg_centrifugo/_utils/schemas/CentrifugoInfoResult.schema.ts
-var CentrifugoInfoResultSchema = import_zod36.z.object({
-  nodes: import_zod36.z.array(CentrifugoNodeInfoSchema)
+var CentrifugoInfoResultSchema = import_zod37.z.object({
+  nodes: import_zod37.z.array(CentrifugoNodeInfoSchema)
 });
 
 // src/generated/cfg_centrifugo/_utils/schemas/CentrifugoInfoResponse.schema.ts
-var CentrifugoInfoResponseSchema = import_zod37.z.object({
+var CentrifugoInfoResponseSchema = import_zod38.z.object({
   error: CentrifugoErrorSchema.optional(),
   result: CentrifugoInfoResultSchema.optional()
 });
 
 // src/generated/cfg_centrifugo/_utils/schemas/CentrifugoOverviewStats.schema.ts
-var import_zod38 = require("zod");
-var CentrifugoOverviewStatsSchema = import_zod38.z.object({
-  total: import_zod38.z.int(),
-  successful: import_zod38.z.int(),
-  failed: import_zod38.z.int(),
-  timeout: import_zod38.z.int(),
-  success_rate: import_zod38.z.number(),
-  avg_duration_ms: import_zod38.z.number(),
-  avg_acks_received: import_zod38.z.number(),
-  period_hours: import_zod38.z.int()
+var import_zod39 = require("zod");
+var CentrifugoOverviewStatsSchema = import_zod39.z.object({
+  total: import_zod39.z.int(),
+  successful: import_zod39.z.int(),
+  failed: import_zod39.z.int(),
+  timeout: import_zod39.z.int(),
+  success_rate: import_zod39.z.number(),
+  avg_duration_ms: import_zod39.z.number(),
+  avg_acks_received: import_zod39.z.number(),
+  period_hours: import_zod39.z.int()
 });
 
 // src/generated/cfg_centrifugo/_utils/schemas/CentrifugoPresenceRequestRequest.schema.ts
-var import_zod39 = require("zod");
-var CentrifugoPresenceRequestRequestSchema = import_zod39.z.object({
-  channel: import_zod39.z.string()
+var import_zod40 = require("zod");
+var CentrifugoPresenceRequestRequestSchema = import_zod40.z.object({
+  channel: import_zod40.z.string()
 });
 
 // src/generated/cfg_centrifugo/_utils/schemas/CentrifugoPresenceResponse.schema.ts
-var import_zod41 = require("zod");
+var import_zod42 = require("zod");
 
 // src/generated/cfg_centrifugo/_utils/schemas/CentrifugoPresenceResult.schema.ts
-var import_zod40 = require("zod");
-var CentrifugoPresenceResultSchema = import_zod40.z.object({
-  presence: import_zod40.z.record(import_zod40.z.string(), CentrifugoClientInfoSchema)
+var import_zod41 = require("zod");
+var CentrifugoPresenceResultSchema = import_zod41.z.object({
+  presence: import_zod41.z.record(import_zod41.z.string(), CentrifugoClientInfoSchema)
 });
 
 // src/generated/cfg_centrifugo/_utils/schemas/CentrifugoPresenceResponse.schema.ts
-var CentrifugoPresenceResponseSchema = import_zod41.z.object({
+var CentrifugoPresenceResponseSchema = import_zod42.z.object({
   error: CentrifugoErrorSchema.optional(),
   result: CentrifugoPresenceResultSchema.optional()
 });
 
 // src/generated/cfg_centrifugo/_utils/schemas/CentrifugoPresenceStatsRequestRequest.schema.ts
-var import_zod42 = require("zod");
-var CentrifugoPresenceStatsRequestRequestSchema = import_zod42.z.object({
-  channel: import_zod42.z.string()
+var import_zod43 = require("zod");
+var CentrifugoPresenceStatsRequestRequestSchema = import_zod43.z.object({
+  channel: import_zod43.z.string()
 });
 
 // src/generated/cfg_centrifugo/_utils/schemas/CentrifugoPresenceStatsResponse.schema.ts
-var import_zod44 = require("zod");
+var import_zod45 = require("zod");
 
 // src/generated/cfg_centrifugo/_utils/schemas/CentrifugoPresenceStatsResult.schema.ts
-var import_zod43 = require("zod");
-var CentrifugoPresenceStatsResultSchema = import_zod43.z.object({
-  num_clients: import_zod43.z.int(),
-  num_users: import_zod43.z.int()
+var import_zod44 = require("zod");
+var CentrifugoPresenceStatsResultSchema = import_zod44.z.object({
+  num_clients: import_zod44.z.int(),
+  num_users: import_zod44.z.int()
 });
 
 // src/generated/cfg_centrifugo/_utils/schemas/CentrifugoPresenceStatsResponse.schema.ts
-var CentrifugoPresenceStatsResponseSchema = import_zod44.z.object({
+var CentrifugoPresenceStatsResponseSchema = import_zod45.z.object({
   error: CentrifugoErrorSchema.optional(),
   result: CentrifugoPresenceStatsResultSchema.optional()
 });
 
 // src/generated/cfg_centrifugo/_utils/schemas/ChannelList.schema.ts
-var import_zod46 = require("zod");
+var import_zod47 = require("zod");
 
 // src/generated/cfg_centrifugo/_utils/schemas/ChannelStats.schema.ts
-var import_zod45 = require("zod");
-var ChannelStatsSchema = import_zod45.z.object({
-  channel: import_zod45.z.string(),
-  total: import_zod45.z.int(),
-  successful: import_zod45.z.int(),
-  failed: import_zod45.z.int(),
-  avg_duration_ms: import_zod45.z.number(),
-  avg_acks: import_zod45.z.number(),
-  last_activity_at: import_zod45.z.string().nullable()
+var import_zod46 = require("zod");
+var ChannelStatsSchema = import_zod46.z.object({
+  channel: import_zod46.z.string(),
+  total: import_zod46.z.int(),
+  successful: import_zod46.z.int(),
+  failed: import_zod46.z.int(),
+  avg_duration_ms: import_zod46.z.number(),
+  avg_acks: import_zod46.z.number(),
+  last_activity_at: import_zod46.z.string().nullable()
 });
 
 // src/generated/cfg_centrifugo/_utils/schemas/ChannelList.schema.ts
-var ChannelListSchema = import_zod46.z.object({
-  channels: import_zod46.z.array(ChannelStatsSchema),
-  total_channels: import_zod46.z.int()
+var ChannelListSchema = import_zod47.z.object({
+  channels: import_zod47.z.array(ChannelStatsSchema),
+  total_channels: import_zod47.z.int()
 });
 
 // src/generated/cfg_centrifugo/_utils/schemas/ConnectionTokenResponse.schema.ts
-var import_zod47 = require("zod");
-var ConnectionTokenResponseSchema = import_zod47.z.object({
-  token: import_zod47.z.string(),
-  centrifugo_url: import_zod47.z.string(),
-  expires_at: import_zod47.z.string(),
-  channels: import_zod47.z.array(import_zod47.z.string())
+var import_zod48 = require("zod");
+var ConnectionTokenResponseSchema = import_zod48.z.object({
+  token: import_zod48.z.string(),
+  centrifugo_url: import_zod48.z.string(),
+  expires_at: import_zod48.z.string(),
+  channels: import_zod48.z.array(import_zod48.z.string())
 });
 
 // src/generated/cfg_centrifugo/_utils/schemas/ManualAckRequestRequest.schema.ts
-var import_zod48 = require("zod");
-var ManualAckRequestRequestSchema = import_zod48.z.object({
-  message_id: import_zod48.z.string(),
-  client_id: import_zod48.z.string()
+var import_zod49 = require("zod");
+var ManualAckRequestRequestSchema = import_zod49.z.object({
+  message_id: import_zod49.z.string(),
+  client_id: import_zod49.z.string()
 });
 
 // src/generated/cfg_centrifugo/_utils/schemas/ManualAckResponse.schema.ts
-var import_zod49 = require("zod");
-var ManualAckResponseSchema = import_zod49.z.object({
-  success: import_zod49.z.boolean(),
-  message_id: import_zod49.z.string(),
-  error: import_zod49.z.string().nullable().optional()
+var import_zod50 = require("zod");
+var ManualAckResponseSchema = import_zod50.z.object({
+  success: import_zod50.z.boolean(),
+  message_id: import_zod50.z.string(),
+  error: import_zod50.z.string().nullable().optional()
 });
 
 // src/generated/cfg_centrifugo/_utils/schemas/PaginatedPublishList.schema.ts
-var import_zod51 = require("zod");
+var import_zod52 = require("zod");
 
 // src/generated/cfg_centrifugo/_utils/schemas/Publish.schema.ts
-var import_zod50 = require("zod");
-var PublishSchema = import_zod50.z.object({
-  message_id: import_zod50.z.string(),
-  channel: import_zod50.z.string(),
-  status: import_zod50.z.string(),
-  wait_for_ack: import_zod50.z.boolean(),
-  acks_received: import_zod50.z.int(),
-  acks_expected: import_zod50.z.int().nullable(),
-  duration_ms: import_zod50.z.number().nullable(),
-  created_at: import_zod50.z.iso.datetime(),
-  completed_at: import_zod50.z.iso.datetime().nullable(),
-  error_code: import_zod50.z.string().nullable(),
-  error_message: import_zod50.z.string().nullable()
+var import_zod51 = require("zod");
+var PublishSchema = import_zod51.z.object({
+  message_id: import_zod51.z.string(),
+  channel: import_zod51.z.string(),
+  status: import_zod51.z.string(),
+  wait_for_ack: import_zod51.z.boolean(),
+  acks_received: import_zod51.z.int(),
+  acks_expected: import_zod51.z.int().nullable(),
+  duration_ms: import_zod51.z.number().nullable(),
+  created_at: import_zod51.z.iso.datetime(),
+  completed_at: import_zod51.z.iso.datetime().nullable(),
+  error_code: import_zod51.z.string().nullable(),
+  error_message: import_zod51.z.string().nullable()
 });
 
 // src/generated/cfg_centrifugo/_utils/schemas/PaginatedPublishList.schema.ts
-var PaginatedPublishListSchema = import_zod51.z.object({
-  count: import_zod51.z.int(),
-  page: import_zod51.z.int(),
-  pages: import_zod51.z.int(),
-  page_size: import_zod51.z.int(),
-  has_next: import_zod51.z.boolean(),
-  has_previous: import_zod51.z.boolean(),
-  next_page: import_zod51.z.int().nullable().optional(),
-  previous_page: import_zod51.z.int().nullable().optional(),
-  results: import_zod51.z.array(PublishSchema)
+var PaginatedPublishListSchema = import_zod52.z.object({
+  count: import_zod52.z.int(),
+  page: import_zod52.z.int(),
+  pages: import_zod52.z.int(),
+  page_size: import_zod52.z.int(),
+  has_next: import_zod52.z.boolean(),
+  has_previous: import_zod52.z.boolean(),
+  next_page: import_zod52.z.int().nullable().optional(),
+  previous_page: import_zod52.z.int().nullable().optional(),
+  results: import_zod52.z.array(PublishSchema)
 });
 
 // src/generated/cfg_centrifugo/_utils/schemas/PublishTestRequestRequest.schema.ts
-var import_zod52 = require("zod");
-var PublishTestRequestRequestSchema = import_zod52.z.object({
-  channel: import_zod52.z.string(),
-  data: import_zod52.z.record(import_zod52.z.string(), import_zod52.z.any()),
-  wait_for_ack: import_zod52.z.boolean().optional(),
-  ack_timeout: import_zod52.z.int().min(1).max(60).optional()
+var import_zod53 = require("zod");
+var PublishTestRequestRequestSchema = import_zod53.z.object({
+  channel: import_zod53.z.string(),
+  data: import_zod53.z.record(import_zod53.z.string(), import_zod53.z.any()),
+  wait_for_ack: import_zod53.z.boolean().optional(),
+  ack_timeout: import_zod53.z.int().min(1).max(60).optional()
 });
 
 // src/generated/cfg_centrifugo/_utils/schemas/PublishTestResponse.schema.ts
-var import_zod53 = require("zod");
-var PublishTestResponseSchema = import_zod53.z.object({
-  success: import_zod53.z.boolean(),
-  message_id: import_zod53.z.string(),
-  channel: import_zod53.z.string(),
-  acks_received: import_zod53.z.int().optional(),
-  delivered: import_zod53.z.boolean().optional(),
-  error: import_zod53.z.string().nullable().optional()
+var import_zod54 = require("zod");
+var PublishTestResponseSchema = import_zod54.z.object({
+  success: import_zod54.z.boolean(),
+  message_id: import_zod54.z.string(),
+  channel: import_zod54.z.string(),
+  acks_received: import_zod54.z.int().optional(),
+  delivered: import_zod54.z.boolean().optional(),
+  error: import_zod54.z.string().nullable().optional()
 });
 
 // src/generated/cfg_centrifugo/_utils/schemas/TimelineItem.schema.ts
-var import_zod54 = require("zod");
-var TimelineItemSchema = import_zod54.z.object({
-  timestamp: import_zod54.z.string(),
-  count: import_zod54.z.int(),
-  successful: import_zod54.z.int(),
-  failed: import_zod54.z.int(),
-  timeout: import_zod54.z.int()
+var import_zod55 = require("zod");
+var TimelineItemSchema = import_zod55.z.object({
+  timestamp: import_zod55.z.string(),
+  count: import_zod55.z.int(),
+  successful: import_zod55.z.int(),
+  failed: import_zod55.z.int(),
+  timeout: import_zod55.z.int()
 });
 
 // src/generated/cfg_centrifugo/_utils/schemas/TimelineResponse.schema.ts
-var import_zod55 = require("zod");
-var TimelineResponseSchema = import_zod55.z.object({
-  timeline: import_zod55.z.array(TimelineItemSchema),
-  period_hours: import_zod55.z.int(),
-  interval: import_zod55.z.string()
+var import_zod56 = require("zod");
+var TimelineResponseSchema = import_zod56.z.object({
+  timeline: import_zod56.z.array(TimelineItemSchema),
+  period_hours: import_zod56.z.int(),
+  interval: import_zod56.z.string()
 });
 
 // src/generated/cfg_centrifugo/_utils/fetchers/centrifugo__centrifugo_admin_api.ts
@@ -3488,40 +3509,40 @@ var LocalStorageAdapter3 = class {
 };
 
 // src/generated/cfg_webpush/_utils/schemas/SendPushRequestRequest.schema.ts
-var import_zod56 = require("zod");
-var SendPushRequestRequestSchema = import_zod56.z.object({
-  title: import_zod56.z.string().min(1).max(255),
-  body: import_zod56.z.string().min(1),
-  icon: import_zod56.z.union([import_zod56.z.url(), import_zod56.z.literal("")]).nullable().optional(),
-  url: import_zod56.z.union([import_zod56.z.url(), import_zod56.z.literal("")]).nullable().optional()
+var import_zod57 = require("zod");
+var SendPushRequestRequestSchema = import_zod57.z.object({
+  title: import_zod57.z.string().min(1).max(255),
+  body: import_zod57.z.string().min(1),
+  icon: import_zod57.z.union([import_zod57.z.url(), import_zod57.z.literal("")]).nullable().optional(),
+  url: import_zod57.z.union([import_zod57.z.url(), import_zod57.z.literal("")]).nullable().optional()
 });
 
 // src/generated/cfg_webpush/_utils/schemas/SendPushResponse.schema.ts
-var import_zod57 = require("zod");
-var SendPushResponseSchema = import_zod57.z.object({
-  success: import_zod57.z.boolean(),
-  sent_to: import_zod57.z.int()
+var import_zod58 = require("zod");
+var SendPushResponseSchema = import_zod58.z.object({
+  success: import_zod58.z.boolean(),
+  sent_to: import_zod58.z.int()
 });
 
 // src/generated/cfg_webpush/_utils/schemas/SubscribeRequestRequest.schema.ts
-var import_zod58 = require("zod");
-var SubscribeRequestRequestSchema = import_zod58.z.object({
-  endpoint: import_zod58.z.union([import_zod58.z.url(), import_zod58.z.literal("")]),
-  keys: import_zod58.z.record(import_zod58.z.string(), import_zod58.z.string().min(1))
+var import_zod59 = require("zod");
+var SubscribeRequestRequestSchema = import_zod59.z.object({
+  endpoint: import_zod59.z.union([import_zod59.z.url(), import_zod59.z.literal("")]),
+  keys: import_zod59.z.record(import_zod59.z.string(), import_zod59.z.string().min(1))
 });
 
 // src/generated/cfg_webpush/_utils/schemas/SubscribeResponse.schema.ts
-var import_zod59 = require("zod");
-var SubscribeResponseSchema = import_zod59.z.object({
-  success: import_zod59.z.boolean(),
-  subscription_id: import_zod59.z.int(),
-  created: import_zod59.z.boolean()
+var import_zod60 = require("zod");
+var SubscribeResponseSchema = import_zod60.z.object({
+  success: import_zod60.z.boolean(),
+  subscription_id: import_zod60.z.int(),
+  created: import_zod60.z.boolean()
 });
 
 // src/generated/cfg_webpush/_utils/schemas/VapidPublicKeyResponse.schema.ts
-var import_zod60 = require("zod");
-var VapidPublicKeyResponseSchema = import_zod60.z.object({
-  publicKey: import_zod60.z.string()
+var import_zod61 = require("zod");
+var VapidPublicKeyResponseSchema = import_zod61.z.object({
+  publicKey: import_zod61.z.string()
 });
 
 // src/generated/cfg_webpush/_utils/fetchers/webpush__web_push.ts
@@ -4709,6 +4730,20 @@ var AuthProviderInternal = /* @__PURE__ */ __name(({ children, config }) => {
   const isAdminUser = (0, import_react4.useMemo)(() => {
     return Boolean(user?.is_staff || user?.is_superuser);
   }, [user]);
+  const updateProfile = (0, import_react4.useCallback)(
+    async (data) => {
+      const result = await accounts.partialUpdateProfile(data);
+      return result;
+    },
+    [accounts]
+  );
+  const uploadAvatar = (0, import_react4.useCallback)(
+    async (avatar) => {
+      const result = await accounts.uploadAvatar(avatar);
+      return result;
+    },
+    [accounts]
+  );
   const value = (0, import_react4.useMemo)(
     () => ({
       user,
@@ -4734,7 +4769,10 @@ var AuthProviderInternal = /* @__PURE__ */ __name(({ children, config }) => {
       saveRedirectUrl: redirectManager.setRedirect,
       getRedirectUrl: redirectManager.getFinalRedirectUrl,
       clearRedirectUrl: redirectManager.clearRedirect,
-      hasRedirectUrl: redirectManager.hasRedirect
+      hasRedirectUrl: redirectManager.hasRedirect,
+      // Profile management
+      updateProfile,
+      uploadAvatar
     }),
     [
       user,
@@ -4752,7 +4790,9 @@ var AuthProviderInternal = /* @__PURE__ */ __name(({ children, config }) => {
       verifyOTP,
       refreshToken,
       logout,
-      redirectManager
+      redirectManager,
+      updateProfile,
+      uploadAvatar
     ]
   );
   return /* @__PURE__ */ (0, import_jsx_runtime2.jsx)(AuthContext.Provider, { value, children });
@@ -4805,7 +4845,15 @@ var defaultAuthState = {
   getRedirectUrl: /* @__PURE__ */ __name(() => null, "getRedirectUrl"),
   clearRedirectUrl: /* @__PURE__ */ __name(() => {
   }, "clearRedirectUrl"),
-  hasRedirectUrl: /* @__PURE__ */ __name(() => false, "hasRedirectUrl")
+  hasRedirectUrl: /* @__PURE__ */ __name(() => false, "hasRedirectUrl"),
+  updateProfile: /* @__PURE__ */ __name(async () => {
+    authLogger.warn("useAuth: updateProfile called outside AuthProvider");
+    return {};
+  }, "updateProfile"),
+  uploadAvatar: /* @__PURE__ */ __name(async () => {
+    authLogger.warn("useAuth: uploadAvatar called outside AuthProvider");
+    return {};
+  }, "uploadAvatar")
 };
 var useAuth = /* @__PURE__ */ __name(() => {
   const context = (0, import_react4.useContext)(AuthContext);
@@ -5705,112 +5753,112 @@ var DeviceListStatus = /* @__PURE__ */ ((DeviceListStatus2) => {
 })(DeviceListStatus || {});
 
 // src/generated/cfg_totp/_utils/schemas/BackupCodesRegenerateRequest.schema.ts
-var import_zod61 = require("zod");
-var BackupCodesRegenerateRequestSchema = import_zod61.z.object({
-  code: import_zod61.z.string().min(6).max(6)
+var import_zod62 = require("zod");
+var BackupCodesRegenerateRequestSchema = import_zod62.z.object({
+  code: import_zod62.z.string().min(6).max(6)
 });
 
 // src/generated/cfg_totp/_utils/schemas/BackupCodesRegenerateResponse.schema.ts
-var import_zod62 = require("zod");
-var BackupCodesRegenerateResponseSchema = import_zod62.z.object({
-  backup_codes: import_zod62.z.array(import_zod62.z.string()),
-  warning: import_zod62.z.string()
+var import_zod63 = require("zod");
+var BackupCodesRegenerateResponseSchema = import_zod63.z.object({
+  backup_codes: import_zod63.z.array(import_zod63.z.string()),
+  warning: import_zod63.z.string()
 });
 
 // src/generated/cfg_totp/_utils/schemas/BackupCodesStatus.schema.ts
-var import_zod63 = require("zod");
-var BackupCodesStatusSchema = import_zod63.z.object({
-  remaining_count: import_zod63.z.int(),
-  total_generated: import_zod63.z.int(),
-  warning: import_zod63.z.string().nullable().optional()
+var import_zod64 = require("zod");
+var BackupCodesStatusSchema = import_zod64.z.object({
+  remaining_count: import_zod64.z.int(),
+  total_generated: import_zod64.z.int(),
+  warning: import_zod64.z.string().nullable().optional()
 });
 
 // src/generated/cfg_totp/_utils/schemas/ConfirmSetupRequest.schema.ts
-var import_zod64 = require("zod");
-var ConfirmSetupRequestSchema = 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),
-  code: import_zod64.z.string().min(6).max(6)
+var import_zod65 = require("zod");
+var ConfirmSetupRequestSchema = import_zod65.z.object({
+  device_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),
+  code: import_zod65.z.string().min(6).max(6)
 });
 
 // src/generated/cfg_totp/_utils/schemas/ConfirmSetupResponse.schema.ts
-var import_zod65 = require("zod");
-var ConfirmSetupResponseSchema = import_zod65.z.object({
-  message: import_zod65.z.string(),
-  backup_codes: import_zod65.z.array(import_zod65.z.string()),
-  backup_codes_warning: import_zod65.z.string()
+var import_zod66 = require("zod");
+var ConfirmSetupResponseSchema = import_zod66.z.object({
+  message: import_zod66.z.string(),
+  backup_codes: import_zod66.z.array(import_zod66.z.string()),
+  backup_codes_warning: import_zod66.z.string()
 });
 
 // src/generated/cfg_totp/_utils/schemas/DeviceList.schema.ts
-var import_zod66 = require("zod");
-var DeviceListSchema = import_zod66.z.object({
-  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),
-  name: import_zod66.z.string(),
-  is_primary: import_zod66.z.boolean(),
-  status: import_zod66.z.nativeEnum(DeviceListStatus),
-  created_at: import_zod66.z.iso.datetime(),
-  confirmed_at: import_zod66.z.iso.datetime().nullable(),
-  last_used_at: import_zod66.z.iso.datetime().nullable()
+var import_zod67 = require("zod");
+var DeviceListSchema = import_zod67.z.object({
+  id: import_zod67.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_zod67.z.string(),
+  is_primary: import_zod67.z.boolean(),
+  status: import_zod67.z.nativeEnum(DeviceListStatus),
+  created_at: import_zod67.z.iso.datetime(),
+  confirmed_at: import_zod67.z.iso.datetime().nullable(),
+  last_used_at: import_zod67.z.iso.datetime().nullable()
 });
 
 // src/generated/cfg_totp/_utils/schemas/DisableRequest.schema.ts
-var import_zod67 = require("zod");
-var DisableRequestSchema = import_zod67.z.object({
-  code: import_zod67.z.string().min(6).max(6)
+var import_zod68 = require("zod");
+var DisableRequestSchema = import_zod68.z.object({
+  code: import_zod68.z.string().min(6).max(6)
 });
 
 // src/generated/cfg_totp/_utils/schemas/PaginatedDeviceListList.schema.ts
-var import_zod68 = require("zod");
-var PaginatedDeviceListListSchema = import_zod68.z.object({
-  count: import_zod68.z.int(),
-  page: import_zod68.z.int(),
-  pages: import_zod68.z.int(),
-  page_size: import_zod68.z.int(),
-  has_next: import_zod68.z.boolean(),
-  has_previous: import_zod68.z.boolean(),
-  next_page: import_zod68.z.int().nullable().optional(),
-  previous_page: import_zod68.z.int().nullable().optional(),
-  results: import_zod68.z.array(DeviceListSchema)
+var import_zod69 = require("zod");
+var PaginatedDeviceListListSchema = import_zod69.z.object({
+  count: import_zod69.z.int(),
+  page: import_zod69.z.int(),
+  pages: import_zod69.z.int(),
+  page_size: import_zod69.z.int(),
+  has_next: import_zod69.z.boolean(),
+  has_previous: import_zod69.z.boolean(),
+  next_page: import_zod69.z.int().nullable().optional(),
+  previous_page: import_zod69.z.int().nullable().optional(),
+  results: import_zod69.z.array(DeviceListSchema)
 });
 
 // src/generated/cfg_totp/_utils/schemas/SetupRequest.schema.ts
-var import_zod69 = require("zod");
-var SetupRequestSchema = import_zod69.z.object({
-  device_name: import_zod69.z.string().min(1).max(100).optional()
+var import_zod70 = require("zod");
+var SetupRequestSchema = import_zod70.z.object({
+  device_name: import_zod70.z.string().min(1).max(100).optional()
 });
 
 // src/generated/cfg_totp/_utils/schemas/SetupResponse.schema.ts
-var import_zod70 = require("zod");
-var SetupResponseSchema = import_zod70.z.object({
-  device_id: import_zod70.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_zod70.z.string(),
-  provisioning_uri: import_zod70.z.string(),
-  qr_code_base64: import_zod70.z.string(),
-  expires_in: import_zod70.z.int()
+var import_zod71 = require("zod");
+var SetupResponseSchema = import_zod71.z.object({
+  device_id: import_zod71.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_zod71.z.string(),
+  provisioning_uri: import_zod71.z.string(),
+  qr_code_base64: import_zod71.z.string(),
+  expires_in: import_zod71.z.int()
 });
 
 // src/generated/cfg_totp/_utils/schemas/VerifyBackupRequest.schema.ts
-var import_zod71 = require("zod");
-var VerifyBackupRequestSchema = import_zod71.z.object({
-  session_id: import_zod71.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_zod71.z.string().min(8).max(8)
+var import_zod72 = require("zod");
+var VerifyBackupRequestSchema = import_zod72.z.object({
+  session_id: import_zod72.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_zod72.z.string().min(8).max(8)
 });
 
 // src/generated/cfg_totp/_utils/schemas/VerifyRequest.schema.ts
-var import_zod72 = require("zod");
-var VerifyRequestSchema = import_zod72.z.object({
-  session_id: import_zod72.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_zod72.z.string().min(6).max(6)
+var import_zod73 = require("zod");
+var VerifyRequestSchema = import_zod73.z.object({
+  session_id: import_zod73.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_zod73.z.string().min(6).max(6)
 });
 
 // src/generated/cfg_totp/_utils/schemas/VerifyResponse.schema.ts
-var import_zod73 = require("zod");
-var VerifyResponseSchema = import_zod73.z.object({
-  message: import_zod73.z.string(),
-  access_token: import_zod73.z.string(),
-  refresh_token: import_zod73.z.string(),
-  user: import_zod73.z.record(import_zod73.z.string(), import_zod73.z.any()),
-  remaining_backup_codes: import_zod73.z.int().optional(),
-  warning: import_zod73.z.string().optional()
+var import_zod74 = require("zod");
+var VerifyResponseSchema = import_zod74.z.object({
+  message: import_zod74.z.string(),
+  access_token: import_zod74.z.string(),
+  refresh_token: import_zod74.z.string(),
+  user: import_zod74.z.record(import_zod74.z.string(), import_zod74.z.any()),
+  remaining_backup_codes: import_zod74.z.int().optional(),
+  warning: import_zod74.z.string().optional()
 });
 
 // src/generated/cfg_totp/_utils/fetchers/totp__backup_codes.ts
@@ -6892,6 +6940,43 @@ function useLocalStorage2(key, initialValue) {
 }
 __name(useLocalStorage2, "useLocalStorage");
 
+// src/auth/hooks/useDeleteAccount.ts
+var import_react15 = require("react");
+var useDeleteAccount = /* @__PURE__ */ __name(() => {
+  const [isLoading, setIsLoading] = (0, import_react15.useState)(false);
+  const [error, setError] = (0, import_react15.useState)(null);
+  const { logout } = useAuth();
+  const clearError = (0, import_react15.useCallback)(() => {
+    setError(null);
+  }, []);
+  const deleteAccount = (0, import_react15.useCallback)(async () => {
+    setIsLoading(true);
+    setError(null);
+    try {
+      authLogger.info("Deleting account...");
+      const response = await apiAccounts.user_profile.accountsProfileDeleteCreate();
+      if (!response.success) {
+        authLogger.error("Failed to delete account:", response.message);
+        setError(response.message);
+        throw new Error(response.message);
+      }
+    } catch (error2) {
+      authLogger.error("Failed to delete account:", error2);
+      throw error2;
+    } finally {
+      setIsLoading(false);
+    }
+    await logout();
+    return { success: true, message: "Account deleted successfully" };
+  }, []);
+  return {
+    isLoading,
+    error,
+    deleteAccount,
+    clearError
+  };
+}, "useDeleteAccount");
+
 // src/auth/utils/validation.ts
 var validateEmail = /* @__PURE__ */ __name((email) => {
   const emailRegex = /^[^\s@]+@[^\s@]+\.[^\s@]+$/;