@djangocfg/api 2.1.99 → 2.1.101

package/dist/auth.mjs

@@ -121,6 +121,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
    * 
@@ -837,183 +850,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
 import { z } from "zod";
-var CentrifugoTokenSchema = z.object({
-  token: z.string(),
-  centrifugo_url: z.union([z.url(), z.literal("")]),
-  expires_at: z.iso.datetime(),
-  channels: z.array(z.string())
+var AccountDeleteResponseSchema = z.object({
+  success: z.boolean(),
+  message: z.string()
 });
 
-// src/generated/cfg_accounts/_utils/schemas/CfgAccountsProfileAvatarCreateRequest.schema.ts
+// src/generated/cfg_accounts/_utils/schemas/CentrifugoToken.schema.ts
 import { z as z2 } from "zod";
-var CfgAccountsProfileAvatarCreateRequestSchema = z2.object({
-  avatar: z2.union([z2.instanceof(File), z2.instanceof(Blob)])
+var CentrifugoTokenSchema = z2.object({
+  token: z2.string(),
+  centrifugo_url: z2.union([z2.url(), z2.literal("")]),
+  expires_at: z2.iso.datetime(),
+  channels: z2.array(z2.string())
 });
 
-// src/generated/cfg_accounts/_utils/schemas/OAuthAuthorizeRequestRequest.schema.ts
+// src/generated/cfg_accounts/_utils/schemas/CfgAccountsProfileAvatarCreateRequest.schema.ts
 import { z as z3 } from "zod";
-var OAuthAuthorizeRequestRequestSchema = z3.object({
-  redirect_uri: z3.union([z3.url(), z3.literal("")]).optional(),
-  source_url: z3.union([z3.url(), z3.literal("")]).optional()
+var CfgAccountsProfileAvatarCreateRequestSchema = z3.object({
+  avatar: z3.union([z3.instanceof(File), z3.instanceof(Blob)])
 });
 
-// src/generated/cfg_accounts/_utils/schemas/OAuthAuthorizeResponse.schema.ts
+// src/generated/cfg_accounts/_utils/schemas/OAuthAuthorizeRequestRequest.schema.ts
 import { z as z4 } from "zod";
-var OAuthAuthorizeResponseSchema = z4.object({
-  authorization_url: z4.union([z4.url(), z4.literal("")]),
-  state: z4.string()
+var OAuthAuthorizeRequestRequestSchema = z4.object({
+  redirect_uri: z4.union([z4.url(), z4.literal("")]).optional(),
+  source_url: z4.union([z4.url(), z4.literal("")]).optional()
 });
 
-// src/generated/cfg_accounts/_utils/schemas/OAuthCallbackRequestRequest.schema.ts
+// src/generated/cfg_accounts/_utils/schemas/OAuthAuthorizeResponse.schema.ts
 import { z as z5 } from "zod";
-var OAuthCallbackRequestRequestSchema = z5.object({
-  code: z5.string().min(10).max(500),
-  state: z5.string().min(20).max(100),
-  redirect_uri: z5.union([z5.url(), z5.literal("")]).optional()
+var OAuthAuthorizeResponseSchema = z5.object({
+  authorization_url: z5.union([z5.url(), z5.literal("")]),
+  state: z5.string()
 });
 
-// src/generated/cfg_accounts/_utils/schemas/OAuthConnection.schema.ts
+// src/generated/cfg_accounts/_utils/schemas/OAuthCallbackRequestRequest.schema.ts
 import { z as z6 } from "zod";
-var OAuthConnectionSchema = z6.object({
-  id: z6.int(),
-  provider: z6.nativeEnum(OAuthConnectionProvider),
-  provider_display: z6.string(),
-  provider_username: z6.string(),
-  provider_email: z6.email(),
-  provider_avatar_url: z6.union([z6.url(), z6.literal("")]),
-  connected_at: z6.iso.datetime(),
-  last_login_at: z6.iso.datetime()
+var OAuthCallbackRequestRequestSchema = z6.object({
+  code: z6.string().min(10).max(500),
+  state: z6.string().min(20).max(100),
+  redirect_uri: z6.union([z6.url(), z6.literal("")]).optional()
 });
 
-// src/generated/cfg_accounts/_utils/schemas/OAuthDisconnectRequestRequest.schema.ts
+// src/generated/cfg_accounts/_utils/schemas/OAuthConnection.schema.ts
 import { z as z7 } from "zod";
-var OAuthDisconnectRequestRequestSchema = z7.object({
-  provider: z7.nativeEnum(OAuthDisconnectRequestRequestProvider)
+var OAuthConnectionSchema = z7.object({
+  id: z7.int(),
+  provider: z7.nativeEnum(OAuthConnectionProvider),
+  provider_display: z7.string(),
+  provider_username: z7.string(),
+  provider_email: z7.email(),
+  provider_avatar_url: z7.union([z7.url(), z7.literal("")]),
+  connected_at: z7.iso.datetime(),
+  last_login_at: z7.iso.datetime()
 });
 
-// src/generated/cfg_accounts/_utils/schemas/OAuthError.schema.ts
+// src/generated/cfg_accounts/_utils/schemas/OAuthDisconnectRequestRequest.schema.ts
 import { z as z8 } from "zod";
-var OAuthErrorSchema = z8.object({
-  error: z8.string(),
-  error_description: z8.string().optional()
+var OAuthDisconnectRequestRequestSchema = z8.object({
+  provider: z8.nativeEnum(OAuthDisconnectRequestRequestProvider)
 });
 
-// src/generated/cfg_accounts/_utils/schemas/OAuthProvidersResponse.schema.ts
+// src/generated/cfg_accounts/_utils/schemas/OAuthError.schema.ts
 import { z as z9 } from "zod";
-var OAuthProvidersResponseSchema = z9.object({
-  providers: z9.array(z9.record(z9.string(), z9.any()))
+var OAuthErrorSchema = z9.object({
+  error: z9.string(),
+  error_description: z9.string().optional()
 });
 
-// src/generated/cfg_accounts/_utils/schemas/OAuthTokenResponse.schema.ts
+// src/generated/cfg_accounts/_utils/schemas/OAuthProvidersResponse.schema.ts
 import { z as z10 } from "zod";
-var OAuthTokenResponseSchema = z10.object({
-  requires_2fa: z10.boolean().optional(),
-  session_id: z10.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: z10.string().nullable().optional(),
-  refresh: z10.string().nullable().optional(),
-  user: z10.record(z10.string(), z10.any()).nullable().optional(),
-  is_new_user: z10.boolean(),
-  is_new_connection: z10.boolean(),
-  should_prompt_2fa: z10.boolean().optional()
+var OAuthProvidersResponseSchema = z10.object({
+  providers: z10.array(z10.record(z10.string(), z10.any()))
 });
 
-// src/generated/cfg_accounts/_utils/schemas/OTPErrorResponse.schema.ts
+// src/generated/cfg_accounts/_utils/schemas/OAuthTokenResponse.schema.ts
 import { z as z11 } from "zod";
-var OTPErrorResponseSchema = z11.object({
-  error: z11.string()
+var OAuthTokenResponseSchema = z11.object({
+  requires_2fa: z11.boolean().optional(),
+  session_id: z11.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: z11.string().nullable().optional(),
+  refresh: z11.string().nullable().optional(),
+  user: z11.record(z11.string(), z11.any()).nullable().optional(),
+  is_new_user: z11.boolean(),
+  is_new_connection: z11.boolean(),
+  should_prompt_2fa: z11.boolean().optional()
 });
 
-// src/generated/cfg_accounts/_utils/schemas/OTPRequestRequest.schema.ts
+// src/generated/cfg_accounts/_utils/schemas/OTPErrorResponse.schema.ts
 import { z as z12 } from "zod";
-var OTPRequestRequestSchema = z12.object({
-  identifier: z12.string().min(1),
-  channel: z12.nativeEnum(OTPRequestRequestChannel).optional(),
-  source_url: z12.union([z12.url(), z12.literal("")]).optional()
+var OTPErrorResponseSchema = z12.object({
+  error: z12.string()
 });
 
-// src/generated/cfg_accounts/_utils/schemas/OTPRequestResponse.schema.ts
+// src/generated/cfg_accounts/_utils/schemas/OTPRequestRequest.schema.ts
 import { z as z13 } from "zod";
-var OTPRequestResponseSchema = z13.object({
-  message: z13.string()
+var OTPRequestRequestSchema = z13.object({
+  identifier: z13.string().min(1),
+  channel: z13.nativeEnum(OTPRequestRequestChannel).optional(),
+  source_url: z13.union([z13.url(), z13.literal("")]).optional()
 });
 
-// src/generated/cfg_accounts/_utils/schemas/OTPVerifyRequest.schema.ts
+// src/generated/cfg_accounts/_utils/schemas/OTPRequestResponse.schema.ts
 import { z as z14 } from "zod";
-var OTPVerifyRequestSchema = z14.object({
-  identifier: z14.string().min(1),
-  otp: z14.string().min(6).max(6),
-  channel: z14.nativeEnum(OTPVerifyRequestChannel).optional(),
-  source_url: z14.union([z14.url(), z14.literal("")]).optional()
+var OTPRequestResponseSchema = z14.object({
+  message: z14.string()
+});
+
+// src/generated/cfg_accounts/_utils/schemas/OTPVerifyRequest.schema.ts
+import { z as z15 } from "zod";
+var OTPVerifyRequestSchema = z15.object({
+  identifier: z15.string().min(1),
+  otp: z15.string().min(6).max(6),
+  channel: z15.nativeEnum(OTPVerifyRequestChannel).optional(),
+  source_url: z15.union([z15.url(), z15.literal("")]).optional()
 });
 
 // src/generated/cfg_accounts/_utils/schemas/OTPVerifyResponse.schema.ts
-import { z as z16 } from "zod";
+import { z as z17 } from "zod";
 
 // src/generated/cfg_accounts/_utils/schemas/User.schema.ts
-import { z as z15 } from "zod";
-var UserSchema = z15.object({
-  id: z15.int(),
-  email: z15.email(),
-  first_name: z15.string().max(50).optional(),
-  last_name: z15.string().max(50).optional(),
-  full_name: z15.string(),
-  initials: z15.string(),
-  display_username: z15.string(),
-  company: z15.string().max(100).optional(),
-  phone: z15.string().max(20).optional(),
-  position: z15.string().max(100).optional(),
-  avatar: z15.union([z15.url(), z15.literal("")]).nullable(),
-  is_staff: z15.boolean(),
-  is_superuser: z15.boolean(),
-  date_joined: z15.iso.datetime(),
-  last_login: z15.iso.datetime().nullable(),
-  unanswered_messages_count: z15.int(),
+import { z as z16 } from "zod";
+var UserSchema = z16.object({
+  id: z16.int(),
+  email: z16.email(),
+  first_name: z16.string().max(50).optional(),
+  last_name: z16.string().max(50).optional(),
+  full_name: z16.string(),
+  initials: z16.string(),
+  display_username: z16.string(),
+  company: z16.string().max(100).optional(),
+  phone: z16.string().max(20).optional(),
+  position: z16.string().max(100).optional(),
+  avatar: z16.union([z16.url(), z16.literal("")]).nullable(),
+  is_staff: z16.boolean(),
+  is_superuser: z16.boolean(),
+  date_joined: z16.iso.datetime(),
+  last_login: z16.iso.datetime().nullable(),
+  unanswered_messages_count: z16.int(),
   centrifugo: CentrifugoTokenSchema.nullable()
 });
 
 // src/generated/cfg_accounts/_utils/schemas/OTPVerifyResponse.schema.ts
-var OTPVerifyResponseSchema = z16.object({
-  requires_2fa: z16.boolean().optional(),
-  session_id: z16.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: z16.string().nullable().optional(),
-  access: z16.string().nullable().optional(),
+var OTPVerifyResponseSchema = z17.object({
+  requires_2fa: z17.boolean().optional(),
+  session_id: z17.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: z17.string().nullable().optional(),
+  access: z17.string().nullable().optional(),
   user: UserSchema.nullable().optional(),
-  should_prompt_2fa: z16.boolean().optional()
+  should_prompt_2fa: z17.boolean().optional()
 });
 
 // src/generated/cfg_accounts/_utils/schemas/PatchedUserProfileUpdateRequest.schema.ts
-import { z as z17 } from "zod";
-var PatchedUserProfileUpdateRequestSchema = z17.object({
-  first_name: z17.string().max(50).optional(),
-  last_name: z17.string().max(50).optional(),
-  company: z17.string().max(100).optional(),
-  phone: z17.string().max(20).optional(),
-  position: z17.string().max(100).optional()
+import { z as z18 } from "zod";
+var PatchedUserProfileUpdateRequestSchema = z18.object({
+  first_name: z18.string().max(50).optional(),
+  last_name: z18.string().max(50).optional(),
+  company: z18.string().max(100).optional(),
+  phone: z18.string().max(20).optional(),
+  position: z18.string().max(100).optional()
 });
 
 // src/generated/cfg_accounts/_utils/schemas/TokenRefresh.schema.ts
-import { z as z18 } from "zod";
-var TokenRefreshSchema = z18.object({
-  access: z18.string(),
-  refresh: z18.string()
+import { z as z19 } from "zod";
+var TokenRefreshSchema = z19.object({
+  access: z19.string(),
+  refresh: z19.string()
 });
 
 // src/generated/cfg_accounts/_utils/schemas/TokenRefreshRequest.schema.ts
-import { z as z19 } from "zod";
-var TokenRefreshRequestSchema = z19.object({
-  refresh: z19.string().min(1)
+import { z as z20 } from "zod";
+var TokenRefreshRequestSchema = z20.object({
+  refresh: z20.string().min(1)
 });
 
 // src/generated/cfg_accounts/_utils/schemas/UserProfileUpdateRequest.schema.ts
-import { z as z20 } from "zod";
-var UserProfileUpdateRequestSchema = z20.object({
-  first_name: z20.string().max(50).optional(),
-  last_name: z20.string().max(50).optional(),
-  company: z20.string().max(100).optional(),
-  phone: z20.string().max(20).optional(),
-  position: z20.string().max(100).optional()
+import { z as z21 } from "zod";
+var UserProfileUpdateRequestSchema = z21.object({
+  first_name: z21.string().max(50).optional(),
+  last_name: z21.string().max(50).optional(),
+  company: z21.string().max(100).optional(),
+  phone: z21.string().max(20).optional(),
+  position: z21.string().max(100).optional()
 });
 
 // src/generated/cfg_accounts/_utils/fetchers/accounts.ts
@@ -2318,320 +2338,320 @@ var LocalStorageAdapter2 = class {
 };
 
 // src/generated/cfg_centrifugo/_utils/schemas/CentrifugoChannelInfo.schema.ts
-import { z as z21 } from "zod";
-var CentrifugoChannelInfoSchema = z21.object({
-  num_clients: z21.int()
+import { z as z22 } from "zod";
+var CentrifugoChannelInfoSchema = z22.object({
+  num_clients: z22.int()
 });
 
 // src/generated/cfg_centrifugo/_utils/schemas/CentrifugoChannelsRequestRequest.schema.ts
-import { z as z22 } from "zod";
-var CentrifugoChannelsRequestRequestSchema = z22.object({
-  pattern: z22.string().nullable().optional()
+import { z as z23 } from "zod";
+var CentrifugoChannelsRequestRequestSchema = z23.object({
+  pattern: z23.string().nullable().optional()
 });
 
 // src/generated/cfg_centrifugo/_utils/schemas/CentrifugoChannelsResponse.schema.ts
-import { z as z25 } from "zod";
+import { z as z26 } from "zod";
 
 // src/generated/cfg_centrifugo/_utils/schemas/CentrifugoChannelsResult.schema.ts
-import { z as z23 } from "zod";
-var CentrifugoChannelsResultSchema = z23.object({
-  channels: z23.record(z23.string(), CentrifugoChannelInfoSchema)
+import { z as z24 } from "zod";
+var CentrifugoChannelsResultSchema = z24.object({
+  channels: z24.record(z24.string(), CentrifugoChannelInfoSchema)
 });
 
 // src/generated/cfg_centrifugo/_utils/schemas/CentrifugoError.schema.ts
-import { z as z24 } from "zod";
-var CentrifugoErrorSchema = z24.object({
-  code: z24.int().optional(),
-  message: z24.string().optional()
+import { z as z25 } from "zod";
+var CentrifugoErrorSchema = z25.object({
+  code: z25.int().optional(),
+  message: z25.string().optional()
 });
 
 // src/generated/cfg_centrifugo/_utils/schemas/CentrifugoChannelsResponse.schema.ts
-var CentrifugoChannelsResponseSchema = z25.object({
+var CentrifugoChannelsResponseSchema = z26.object({
   error: CentrifugoErrorSchema.optional(),
   result: CentrifugoChannelsResultSchema.optional()
 });
 
 // src/generated/cfg_centrifugo/_utils/schemas/CentrifugoClientInfo.schema.ts
-import { z as z26 } from "zod";
-var CentrifugoClientInfoSchema = z26.object({
-  user: z26.string(),
-  client: z26.string(),
-  conn_info: z26.record(z26.string(), z26.any()).nullable().optional(),
-  chan_info: z26.record(z26.string(), z26.any()).nullable().optional()
+import { z as z27 } from "zod";
+var CentrifugoClientInfoSchema = z27.object({
+  user: z27.string(),
+  client: z27.string(),
+  conn_info: z27.record(z27.string(), z27.any()).nullable().optional(),
+  chan_info: z27.record(z27.string(), z27.any()).nullable().optional()
 });
 
 // src/generated/cfg_centrifugo/_utils/schemas/CentrifugoHealthCheck.schema.ts
-import { z as z27 } from "zod";
-var CentrifugoHealthCheckSchema = z27.object({
-  status: z27.string(),
-  wrapper_url: z27.string(),
-  has_api_key: z27.boolean(),
-  timestamp: z27.string()
+import { z as z28 } from "zod";
+var CentrifugoHealthCheckSchema = z28.object({
+  status: z28.string(),
+  wrapper_url: z28.string(),
+  has_api_key: z28.boolean(),
+  timestamp: z28.string()
 });
 
 // src/generated/cfg_centrifugo/_utils/schemas/CentrifugoHistoryRequestRequest.schema.ts
-import { z as z29 } from "zod";
+import { z as z30 } from "zod";
 
 // src/generated/cfg_centrifugo/_utils/schemas/CentrifugoStreamPosition.schema.ts
-import { z as z28 } from "zod";
-var CentrifugoStreamPositionSchema = z28.object({
-  offset: z28.int(),
-  epoch: z28.string()
+import { z as z29 } from "zod";
+var CentrifugoStreamPositionSchema = z29.object({
+  offset: z29.int(),
+  epoch: z29.string()
 });
 
 // src/generated/cfg_centrifugo/_utils/schemas/CentrifugoHistoryRequestRequest.schema.ts
-var CentrifugoHistoryRequestRequestSchema = z29.object({
-  channel: z29.string(),
-  limit: z29.int().nullable().optional(),
+var CentrifugoHistoryRequestRequestSchema = z30.object({
+  channel: z30.string(),
+  limit: z30.int().nullable().optional(),
   since: CentrifugoStreamPositionSchema.optional(),
-  reverse: z29.boolean().nullable().optional()
+  reverse: z30.boolean().nullable().optional()
 });
 
 // src/generated/cfg_centrifugo/_utils/schemas/CentrifugoHistoryResponse.schema.ts
-import { z as z32 } from "zod";
+import { z as z33 } from "zod";
 
 // src/generated/cfg_centrifugo/_utils/schemas/CentrifugoHistoryResult.schema.ts
-import { z as z31 } from "zod";
+import { z as z32 } from "zod";
 
 // src/generated/cfg_centrifugo/_utils/schemas/CentrifugoPublication.schema.ts
-import { z as z30 } from "zod";
-var CentrifugoPublicationSchema = z30.object({
-  data: z30.record(z30.string(), z30.any()),
+import { z as z31 } from "zod";
+var CentrifugoPublicationSchema = z31.object({
+  data: z31.record(z31.string(), z31.any()),
   info: CentrifugoClientInfoSchema.optional(),
-  offset: z30.int(),
-  tags: z30.record(z30.string(), z30.any()).nullable().optional()
+  offset: z31.int(),
+  tags: z31.record(z31.string(), z31.any()).nullable().optional()
 });
 
 // src/generated/cfg_centrifugo/_utils/schemas/CentrifugoHistoryResult.schema.ts
-var CentrifugoHistoryResultSchema = z31.object({
-  publications: z31.array(CentrifugoPublicationSchema),
-  epoch: z31.string(),
-  offset: z31.int()
+var CentrifugoHistoryResultSchema = z32.object({
+  publications: z32.array(CentrifugoPublicationSchema),
+  epoch: z32.string(),
+  offset: z32.int()
 });
 
 // src/generated/cfg_centrifugo/_utils/schemas/CentrifugoHistoryResponse.schema.ts
-var CentrifugoHistoryResponseSchema = z32.object({
+var CentrifugoHistoryResponseSchema = z33.object({
   error: CentrifugoErrorSchema.optional(),
   result: CentrifugoHistoryResultSchema.optional()
 });
 
 // src/generated/cfg_centrifugo/_utils/schemas/CentrifugoInfoResponse.schema.ts
-import { z as z37 } from "zod";
+import { z as z38 } from "zod";
 
 // src/generated/cfg_centrifugo/_utils/schemas/CentrifugoInfoResult.schema.ts
-import { z as z36 } from "zod";
+import { z as z37 } from "zod";
 
 // src/generated/cfg_centrifugo/_utils/schemas/CentrifugoNodeInfo.schema.ts
-import { z as z35 } from "zod";
+import { z as z36 } from "zod";
 
 // src/generated/cfg_centrifugo/_utils/schemas/CentrifugoMetrics.schema.ts
-import { z as z33 } from "zod";
-var CentrifugoMetricsSchema = z33.object({
-  interval: z33.number(),
-  items: z33.record(z33.string(), z33.number())
+import { z as z34 } from "zod";
+var CentrifugoMetricsSchema = z34.object({
+  interval: z34.number(),
+  items: z34.record(z34.string(), z34.number())
 });
 
 // src/generated/cfg_centrifugo/_utils/schemas/CentrifugoProcess.schema.ts
-import { z as z34 } from "zod";
-var CentrifugoProcessSchema = z34.object({
-  cpu: z34.number(),
-  rss: z34.int()
+import { z as z35 } from "zod";
+var CentrifugoProcessSchema = z35.object({
+  cpu: z35.number(),
+  rss: z35.int()
 });
 
 // src/generated/cfg_centrifugo/_utils/schemas/CentrifugoNodeInfo.schema.ts
-var CentrifugoNodeInfoSchema = z35.object({
-  uid: z35.string(),
-  name: z35.string(),
-  version: z35.string(),
-  num_clients: z35.int(),
-  num_users: z35.int(),
-  num_channels: z35.int(),
-  uptime: z35.int(),
-  num_subs: z35.int(),
+var CentrifugoNodeInfoSchema = z36.object({
+  uid: z36.string(),
+  name: z36.string(),
+  version: z36.string(),
+  num_clients: z36.int(),
+  num_users: z36.int(),
+  num_channels: z36.int(),
+  uptime: z36.int(),
+  num_subs: z36.int(),
   metrics: CentrifugoMetricsSchema.optional(),
   process: CentrifugoProcessSchema.optional()
 });
 
 // src/generated/cfg_centrifugo/_utils/schemas/CentrifugoInfoResult.schema.ts
-var CentrifugoInfoResultSchema = z36.object({
-  nodes: z36.array(CentrifugoNodeInfoSchema)
+var CentrifugoInfoResultSchema = z37.object({
+  nodes: z37.array(CentrifugoNodeInfoSchema)
 });
 
 // src/generated/cfg_centrifugo/_utils/schemas/CentrifugoInfoResponse.schema.ts
-var CentrifugoInfoResponseSchema = z37.object({
+var CentrifugoInfoResponseSchema = z38.object({
   error: CentrifugoErrorSchema.optional(),
   result: CentrifugoInfoResultSchema.optional()
 });
 
 // src/generated/cfg_centrifugo/_utils/schemas/CentrifugoOverviewStats.schema.ts
-import { z as z38 } from "zod";
-var CentrifugoOverviewStatsSchema = z38.object({
-  total: z38.int(),
-  successful: z38.int(),
-  failed: z38.int(),
-  timeout: z38.int(),
-  success_rate: z38.number(),
-  avg_duration_ms: z38.number(),
-  avg_acks_received: z38.number(),
-  period_hours: z38.int()
+import { z as z39 } from "zod";
+var CentrifugoOverviewStatsSchema = z39.object({
+  total: z39.int(),
+  successful: z39.int(),
+  failed: z39.int(),
+  timeout: z39.int(),
+  success_rate: z39.number(),
+  avg_duration_ms: z39.number(),
+  avg_acks_received: z39.number(),
+  period_hours: z39.int()
 });
 
 // src/generated/cfg_centrifugo/_utils/schemas/CentrifugoPresenceRequestRequest.schema.ts
-import { z as z39 } from "zod";
-var CentrifugoPresenceRequestRequestSchema = z39.object({
-  channel: z39.string()
+import { z as z40 } from "zod";
+var CentrifugoPresenceRequestRequestSchema = z40.object({
+  channel: z40.string()
 });
 
 // src/generated/cfg_centrifugo/_utils/schemas/CentrifugoPresenceResponse.schema.ts
-import { z as z41 } from "zod";
+import { z as z42 } from "zod";
 
 // src/generated/cfg_centrifugo/_utils/schemas/CentrifugoPresenceResult.schema.ts
-import { z as z40 } from "zod";
-var CentrifugoPresenceResultSchema = z40.object({
-  presence: z40.record(z40.string(), CentrifugoClientInfoSchema)
+import { z as z41 } from "zod";
+var CentrifugoPresenceResultSchema = z41.object({
+  presence: z41.record(z41.string(), CentrifugoClientInfoSchema)
 });
 
 // src/generated/cfg_centrifugo/_utils/schemas/CentrifugoPresenceResponse.schema.ts
-var CentrifugoPresenceResponseSchema = z41.object({
+var CentrifugoPresenceResponseSchema = z42.object({
   error: CentrifugoErrorSchema.optional(),
   result: CentrifugoPresenceResultSchema.optional()
 });
 
 // src/generated/cfg_centrifugo/_utils/schemas/CentrifugoPresenceStatsRequestRequest.schema.ts
-import { z as z42 } from "zod";
-var CentrifugoPresenceStatsRequestRequestSchema = z42.object({
-  channel: z42.string()
+import { z as z43 } from "zod";
+var CentrifugoPresenceStatsRequestRequestSchema = z43.object({
+  channel: z43.string()
 });
 
 // src/generated/cfg_centrifugo/_utils/schemas/CentrifugoPresenceStatsResponse.schema.ts
-import { z as z44 } from "zod";
+import { z as z45 } from "zod";
 
 // src/generated/cfg_centrifugo/_utils/schemas/CentrifugoPresenceStatsResult.schema.ts
-import { z as z43 } from "zod";
-var CentrifugoPresenceStatsResultSchema = z43.object({
-  num_clients: z43.int(),
-  num_users: z43.int()
+import { z as z44 } from "zod";
+var CentrifugoPresenceStatsResultSchema = z44.object({
+  num_clients: z44.int(),
+  num_users: z44.int()
 });
 
 // src/generated/cfg_centrifugo/_utils/schemas/CentrifugoPresenceStatsResponse.schema.ts
-var CentrifugoPresenceStatsResponseSchema = z44.object({
+var CentrifugoPresenceStatsResponseSchema = z45.object({
   error: CentrifugoErrorSchema.optional(),
   result: CentrifugoPresenceStatsResultSchema.optional()
 });
 
 // src/generated/cfg_centrifugo/_utils/schemas/ChannelList.schema.ts
-import { z as z46 } from "zod";
+import { z as z47 } from "zod";
 
 // src/generated/cfg_centrifugo/_utils/schemas/ChannelStats.schema.ts
-import { z as z45 } from "zod";
-var ChannelStatsSchema = z45.object({
-  channel: z45.string(),
-  total: z45.int(),
-  successful: z45.int(),
-  failed: z45.int(),
-  avg_duration_ms: z45.number(),
-  avg_acks: z45.number(),
-  last_activity_at: z45.string().nullable()
+import { z as z46 } from "zod";
+var ChannelStatsSchema = z46.object({
+  channel: z46.string(),
+  total: z46.int(),
+  successful: z46.int(),
+  failed: z46.int(),
+  avg_duration_ms: z46.number(),
+  avg_acks: z46.number(),
+  last_activity_at: z46.string().nullable()
 });
 
 // src/generated/cfg_centrifugo/_utils/schemas/ChannelList.schema.ts
-var ChannelListSchema = z46.object({
-  channels: z46.array(ChannelStatsSchema),
-  total_channels: z46.int()
+var ChannelListSchema = z47.object({
+  channels: z47.array(ChannelStatsSchema),
+  total_channels: z47.int()
 });
 
 // src/generated/cfg_centrifugo/_utils/schemas/ConnectionTokenResponse.schema.ts
-import { z as z47 } from "zod";
-var ConnectionTokenResponseSchema = z47.object({
-  token: z47.string(),
-  centrifugo_url: z47.string(),
-  expires_at: z47.string(),
-  channels: z47.array(z47.string())
+import { z as z48 } from "zod";
+var ConnectionTokenResponseSchema = z48.object({
+  token: z48.string(),
+  centrifugo_url: z48.string(),
+  expires_at: z48.string(),
+  channels: z48.array(z48.string())
 });
 
 // src/generated/cfg_centrifugo/_utils/schemas/ManualAckRequestRequest.schema.ts
-import { z as z48 } from "zod";
-var ManualAckRequestRequestSchema = z48.object({
-  message_id: z48.string(),
-  client_id: z48.string()
+import { z as z49 } from "zod";
+var ManualAckRequestRequestSchema = z49.object({
+  message_id: z49.string(),
+  client_id: z49.string()
 });
 
 // src/generated/cfg_centrifugo/_utils/schemas/ManualAckResponse.schema.ts
-import { z as z49 } from "zod";
-var ManualAckResponseSchema = z49.object({
-  success: z49.boolean(),
-  message_id: z49.string(),
-  error: z49.string().nullable().optional()
+import { z as z50 } from "zod";
+var ManualAckResponseSchema = z50.object({
+  success: z50.boolean(),
+  message_id: z50.string(),
+  error: z50.string().nullable().optional()
 });
 
 // src/generated/cfg_centrifugo/_utils/schemas/PaginatedPublishList.schema.ts
-import { z as z51 } from "zod";
+import { z as z52 } from "zod";
 
 // src/generated/cfg_centrifugo/_utils/schemas/Publish.schema.ts
-import { z as z50 } from "zod";
-var PublishSchema = z50.object({
-  message_id: z50.string(),
-  channel: z50.string(),
-  status: z50.string(),
-  wait_for_ack: z50.boolean(),
-  acks_received: z50.int(),
-  acks_expected: z50.int().nullable(),
-  duration_ms: z50.number().nullable(),
-  created_at: z50.iso.datetime(),
-  completed_at: z50.iso.datetime().nullable(),
-  error_code: z50.string().nullable(),
-  error_message: z50.string().nullable()
+import { z as z51 } from "zod";
+var PublishSchema = z51.object({
+  message_id: z51.string(),
+  channel: z51.string(),
+  status: z51.string(),
+  wait_for_ack: z51.boolean(),
+  acks_received: z51.int(),
+  acks_expected: z51.int().nullable(),
+  duration_ms: z51.number().nullable(),
+  created_at: z51.iso.datetime(),
+  completed_at: z51.iso.datetime().nullable(),
+  error_code: z51.string().nullable(),
+  error_message: z51.string().nullable()
 });
 
 // src/generated/cfg_centrifugo/_utils/schemas/PaginatedPublishList.schema.ts
-var PaginatedPublishListSchema = z51.object({
-  count: z51.int(),
-  page: z51.int(),
-  pages: z51.int(),
-  page_size: z51.int(),
-  has_next: z51.boolean(),
-  has_previous: z51.boolean(),
-  next_page: z51.int().nullable().optional(),
-  previous_page: z51.int().nullable().optional(),
-  results: z51.array(PublishSchema)
+var PaginatedPublishListSchema = z52.object({
+  count: z52.int(),
+  page: z52.int(),
+  pages: z52.int(),
+  page_size: z52.int(),
+  has_next: z52.boolean(),
+  has_previous: z52.boolean(),
+  next_page: z52.int().nullable().optional(),
+  previous_page: z52.int().nullable().optional(),
+  results: z52.array(PublishSchema)
 });
 
 // src/generated/cfg_centrifugo/_utils/schemas/PublishTestRequestRequest.schema.ts
-import { z as z52 } from "zod";
-var PublishTestRequestRequestSchema = z52.object({
-  channel: z52.string(),
-  data: z52.record(z52.string(), z52.any()),
-  wait_for_ack: z52.boolean().optional(),
-  ack_timeout: z52.int().min(1).max(60).optional()
+import { z as z53 } from "zod";
+var PublishTestRequestRequestSchema = z53.object({
+  channel: z53.string(),
+  data: z53.record(z53.string(), z53.any()),
+  wait_for_ack: z53.boolean().optional(),
+  ack_timeout: z53.int().min(1).max(60).optional()
 });
 
 // src/generated/cfg_centrifugo/_utils/schemas/PublishTestResponse.schema.ts
-import { z as z53 } from "zod";
-var PublishTestResponseSchema = z53.object({
-  success: z53.boolean(),
-  message_id: z53.string(),
-  channel: z53.string(),
-  acks_received: z53.int().optional(),
-  delivered: z53.boolean().optional(),
-  error: z53.string().nullable().optional()
+import { z as z54 } from "zod";
+var PublishTestResponseSchema = z54.object({
+  success: z54.boolean(),
+  message_id: z54.string(),
+  channel: z54.string(),
+  acks_received: z54.int().optional(),
+  delivered: z54.boolean().optional(),
+  error: z54.string().nullable().optional()
 });
 
 // src/generated/cfg_centrifugo/_utils/schemas/TimelineItem.schema.ts
-import { z as z54 } from "zod";
-var TimelineItemSchema = z54.object({
-  timestamp: z54.string(),
-  count: z54.int(),
-  successful: z54.int(),
-  failed: z54.int(),
-  timeout: z54.int()
+import { z as z55 } from "zod";
+var TimelineItemSchema = z55.object({
+  timestamp: z55.string(),
+  count: z55.int(),
+  successful: z55.int(),
+  failed: z55.int(),
+  timeout: z55.int()
 });
 
 // src/generated/cfg_centrifugo/_utils/schemas/TimelineResponse.schema.ts
-import { z as z55 } from "zod";
-var TimelineResponseSchema = z55.object({
-  timeline: z55.array(TimelineItemSchema),
-  period_hours: z55.int(),
-  interval: z55.string()
+import { z as z56 } from "zod";
+var TimelineResponseSchema = z56.object({
+  timeline: z56.array(TimelineItemSchema),
+  period_hours: z56.int(),
+  interval: z56.string()
 });
 
 // src/generated/cfg_centrifugo/_utils/fetchers/centrifugo__centrifugo_admin_api.ts
@@ -3433,40 +3453,40 @@ var LocalStorageAdapter3 = class {
 };
 
 // src/generated/cfg_webpush/_utils/schemas/SendPushRequestRequest.schema.ts
-import { z as z56 } from "zod";
-var SendPushRequestRequestSchema = z56.object({
-  title: z56.string().min(1).max(255),
-  body: z56.string().min(1),
-  icon: z56.union([z56.url(), z56.literal("")]).nullable().optional(),
-  url: z56.union([z56.url(), z56.literal("")]).nullable().optional()
+import { z as z57 } from "zod";
+var SendPushRequestRequestSchema = z57.object({
+  title: z57.string().min(1).max(255),
+  body: z57.string().min(1),
+  icon: z57.union([z57.url(), z57.literal("")]).nullable().optional(),
+  url: z57.union([z57.url(), z57.literal("")]).nullable().optional()
 });
 
 // src/generated/cfg_webpush/_utils/schemas/SendPushResponse.schema.ts
-import { z as z57 } from "zod";
-var SendPushResponseSchema = z57.object({
-  success: z57.boolean(),
-  sent_to: z57.int()
+import { z as z58 } from "zod";
+var SendPushResponseSchema = z58.object({
+  success: z58.boolean(),
+  sent_to: z58.int()
 });
 
 // src/generated/cfg_webpush/_utils/schemas/SubscribeRequestRequest.schema.ts
-import { z as z58 } from "zod";
-var SubscribeRequestRequestSchema = z58.object({
-  endpoint: z58.union([z58.url(), z58.literal("")]),
-  keys: z58.record(z58.string(), z58.string().min(1))
+import { z as z59 } from "zod";
+var SubscribeRequestRequestSchema = z59.object({
+  endpoint: z59.union([z59.url(), z59.literal("")]),
+  keys: z59.record(z59.string(), z59.string().min(1))
 });
 
 // src/generated/cfg_webpush/_utils/schemas/SubscribeResponse.schema.ts
-import { z as z59 } from "zod";
-var SubscribeResponseSchema = z59.object({
-  success: z59.boolean(),
-  subscription_id: z59.int(),
-  created: z59.boolean()
+import { z as z60 } from "zod";
+var SubscribeResponseSchema = z60.object({
+  success: z60.boolean(),
+  subscription_id: z60.int(),
+  created: z60.boolean()
 });
 
 // src/generated/cfg_webpush/_utils/schemas/VapidPublicKeyResponse.schema.ts
-import { z as z60 } from "zod";
-var VapidPublicKeyResponseSchema = z60.object({
-  publicKey: z60.string()
+import { z as z61 } from "zod";
+var VapidPublicKeyResponseSchema = z61.object({
+  publicKey: z61.string()
 });
 
 // src/generated/cfg_webpush/_utils/fetchers/webpush__web_push.ts
@@ -4661,6 +4681,20 @@ var AuthProviderInternal = /* @__PURE__ */ __name(({ children, config }) => {
   const isAdminUser = useMemo(() => {
     return Boolean(user?.is_staff || user?.is_superuser);
   }, [user]);
+  const updateProfile = useCallback3(
+    async (data) => {
+      const result = await accounts.partialUpdateProfile(data);
+      return result;
+    },
+    [accounts]
+  );
+  const uploadAvatar = useCallback3(
+    async (avatar) => {
+      const result = await accounts.uploadAvatar(avatar);
+      return result;
+    },
+    [accounts]
+  );
   const value = useMemo(
     () => ({
       user,
@@ -4686,7 +4720,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,
@@ -4704,7 +4741,9 @@ var AuthProviderInternal = /* @__PURE__ */ __name(({ children, config }) => {
       verifyOTP,
       refreshToken,
       logout,
-      redirectManager
+      redirectManager,
+      updateProfile,
+      uploadAvatar
     ]
   );
   return /* @__PURE__ */ jsx2(AuthContext.Provider, { value, children });
@@ -4757,7 +4796,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 = useContext2(AuthContext);
@@ -5657,112 +5704,112 @@ var DeviceListStatus = /* @__PURE__ */ ((DeviceListStatus2) => {
 })(DeviceListStatus || {});
 
 // src/generated/cfg_totp/_utils/schemas/BackupCodesRegenerateRequest.schema.ts
-import { z as z61 } from "zod";
-var BackupCodesRegenerateRequestSchema = z61.object({
-  code: z61.string().min(6).max(6)
+import { z as z62 } from "zod";
+var BackupCodesRegenerateRequestSchema = z62.object({
+  code: z62.string().min(6).max(6)
 });
 
 // src/generated/cfg_totp/_utils/schemas/BackupCodesRegenerateResponse.schema.ts
-import { z as z62 } from "zod";
-var BackupCodesRegenerateResponseSchema = z62.object({
-  backup_codes: z62.array(z62.string()),
-  warning: z62.string()
+import { z as z63 } from "zod";
+var BackupCodesRegenerateResponseSchema = z63.object({
+  backup_codes: z63.array(z63.string()),
+  warning: z63.string()
 });
 
 // src/generated/cfg_totp/_utils/schemas/BackupCodesStatus.schema.ts
-import { z as z63 } from "zod";
-var BackupCodesStatusSchema = z63.object({
-  remaining_count: z63.int(),
-  total_generated: z63.int(),
-  warning: z63.string().nullable().optional()
+import { z as z64 } from "zod";
+var BackupCodesStatusSchema = z64.object({
+  remaining_count: z64.int(),
+  total_generated: z64.int(),
+  warning: z64.string().nullable().optional()
 });
 
 // src/generated/cfg_totp/_utils/schemas/ConfirmSetupRequest.schema.ts
-import { z as z64 } from "zod";
-var ConfirmSetupRequestSchema = z64.object({
-  device_id: z64.string().regex(/^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i),
-  code: z64.string().min(6).max(6)
+import { z as z65 } from "zod";
+var ConfirmSetupRequestSchema = z65.object({
+  device_id: z65.string().regex(/^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i),
+  code: z65.string().min(6).max(6)
 });
 
 // src/generated/cfg_totp/_utils/schemas/ConfirmSetupResponse.schema.ts
-import { z as z65 } from "zod";
-var ConfirmSetupResponseSchema = z65.object({
-  message: z65.string(),
-  backup_codes: z65.array(z65.string()),
-  backup_codes_warning: z65.string()
+import { z as z66 } from "zod";
+var ConfirmSetupResponseSchema = z66.object({
+  message: z66.string(),
+  backup_codes: z66.array(z66.string()),
+  backup_codes_warning: z66.string()
 });
 
 // src/generated/cfg_totp/_utils/schemas/DeviceList.schema.ts
-import { z as z66 } from "zod";
-var DeviceListSchema = z66.object({
-  id: z66.string().regex(/^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i),
-  name: z66.string(),
-  is_primary: z66.boolean(),
-  status: z66.nativeEnum(DeviceListStatus),
-  created_at: z66.iso.datetime(),
-  confirmed_at: z66.iso.datetime().nullable(),
-  last_used_at: z66.iso.datetime().nullable()
+import { z as z67 } from "zod";
+var DeviceListSchema = z67.object({
+  id: z67.string().regex(/^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i),
+  name: z67.string(),
+  is_primary: z67.boolean(),
+  status: z67.nativeEnum(DeviceListStatus),
+  created_at: z67.iso.datetime(),
+  confirmed_at: z67.iso.datetime().nullable(),
+  last_used_at: z67.iso.datetime().nullable()
 });
 
 // src/generated/cfg_totp/_utils/schemas/DisableRequest.schema.ts
-import { z as z67 } from "zod";
-var DisableRequestSchema = z67.object({
-  code: z67.string().min(6).max(6)
+import { z as z68 } from "zod";
+var DisableRequestSchema = z68.object({
+  code: z68.string().min(6).max(6)
 });
 
 // src/generated/cfg_totp/_utils/schemas/PaginatedDeviceListList.schema.ts
-import { z as z68 } from "zod";
-var PaginatedDeviceListListSchema = z68.object({
-  count: z68.int(),
-  page: z68.int(),
-  pages: z68.int(),
-  page_size: z68.int(),
-  has_next: z68.boolean(),
-  has_previous: z68.boolean(),
-  next_page: z68.int().nullable().optional(),
-  previous_page: z68.int().nullable().optional(),
-  results: z68.array(DeviceListSchema)
+import { z as z69 } from "zod";
+var PaginatedDeviceListListSchema = z69.object({
+  count: z69.int(),
+  page: z69.int(),
+  pages: z69.int(),
+  page_size: z69.int(),
+  has_next: z69.boolean(),
+  has_previous: z69.boolean(),
+  next_page: z69.int().nullable().optional(),
+  previous_page: z69.int().nullable().optional(),
+  results: z69.array(DeviceListSchema)
 });
 
 // src/generated/cfg_totp/_utils/schemas/SetupRequest.schema.ts
-import { z as z69 } from "zod";
-var SetupRequestSchema = z69.object({
-  device_name: z69.string().min(1).max(100).optional()
+import { z as z70 } from "zod";
+var SetupRequestSchema = z70.object({
+  device_name: z70.string().min(1).max(100).optional()
 });
 
 // src/generated/cfg_totp/_utils/schemas/SetupResponse.schema.ts
-import { z as z70 } from "zod";
-var SetupResponseSchema = z70.object({
-  device_id: z70.string().regex(/^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i),
-  secret: z70.string(),
-  provisioning_uri: z70.string(),
-  qr_code_base64: z70.string(),
-  expires_in: z70.int()
+import { z as z71 } from "zod";
+var SetupResponseSchema = z71.object({
+  device_id: z71.string().regex(/^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i),
+  secret: z71.string(),
+  provisioning_uri: z71.string(),
+  qr_code_base64: z71.string(),
+  expires_in: z71.int()
 });
 
 // src/generated/cfg_totp/_utils/schemas/VerifyBackupRequest.schema.ts
-import { z as z71 } from "zod";
-var VerifyBackupRequestSchema = z71.object({
-  session_id: z71.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: z71.string().min(8).max(8)
+import { z as z72 } from "zod";
+var VerifyBackupRequestSchema = z72.object({
+  session_id: z72.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: z72.string().min(8).max(8)
 });
 
 // src/generated/cfg_totp/_utils/schemas/VerifyRequest.schema.ts
-import { z as z72 } from "zod";
-var VerifyRequestSchema = z72.object({
-  session_id: z72.string().regex(/^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i),
-  code: z72.string().min(6).max(6)
+import { z as z73 } from "zod";
+var VerifyRequestSchema = z73.object({
+  session_id: z73.string().regex(/^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i),
+  code: z73.string().min(6).max(6)
 });
 
 // src/generated/cfg_totp/_utils/schemas/VerifyResponse.schema.ts
-import { z as z73 } from "zod";
-var VerifyResponseSchema = z73.object({
-  message: z73.string(),
-  access_token: z73.string(),
-  refresh_token: z73.string(),
-  user: z73.record(z73.string(), z73.any()),
-  remaining_backup_codes: z73.int().optional(),
-  warning: z73.string().optional()
+import { z as z74 } from "zod";
+var VerifyResponseSchema = z74.object({
+  message: z74.string(),
+  access_token: z74.string(),
+  refresh_token: z74.string(),
+  user: z74.record(z74.string(), z74.any()),
+  remaining_backup_codes: z74.int().optional(),
+  warning: z74.string().optional()
 });
 
 // src/generated/cfg_totp/_utils/fetchers/totp__backup_codes.ts
@@ -6844,6 +6891,43 @@ function useLocalStorage2(key, initialValue) {
 }
 __name(useLocalStorage2, "useLocalStorage");
 
+// src/auth/hooks/useDeleteAccount.ts
+import { useCallback as useCallback11, useState as useState11 } from "react";
+var useDeleteAccount = /* @__PURE__ */ __name(() => {
+  const [isLoading, setIsLoading] = useState11(false);
+  const [error, setError] = useState11(null);
+  const { logout } = useAuth();
+  const clearError = useCallback11(() => {
+    setError(null);
+  }, []);
+  const deleteAccount = useCallback11(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@]+$/;
@@ -6893,6 +6977,7 @@ export {
   useAuthValidation,
   useAutoAuth,
   useBase64,
+  useDeleteAccount,
   useGithubAuth,
   useLocalStorage2 as useLocalStorage,
   useSessionStorage,