@djangocfg/api 2.1.99 → 2.1.100

package/dist/hooks.cjs

@@ -40,6 +40,7 @@ __export(hooks_exports, {
   useCreateAccountsOtpRequestCreate: () => useCreateAccountsOtpRequestCreate,
   useCreateAccountsOtpVerifyCreate: () => useCreateAccountsOtpVerifyCreate,
   useCreateAccountsProfileAvatarCreate: () => useCreateAccountsProfileAvatarCreate,
+  useCreateAccountsProfileDeleteCreate: () => useCreateAccountsProfileDeleteCreate,
   useCreateAccountsTokenRefreshCreate: () => useCreateAccountsTokenRefreshCreate,
   usePartialUpdateAccountsProfilePartialPartialUpdate: () => usePartialUpdateAccountsProfilePartialPartialUpdate,
   usePartialUpdateAccountsProfilePartialUpdate: () => usePartialUpdateAccountsProfilePartialUpdate,
@@ -164,6 +165,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
    * 
@@ -873,176 +887,183 @@ 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_zod2 = require("zod");
-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())
+var AccountDeleteResponseSchema = import_zod2.z.object({
+  success: import_zod2.z.boolean(),
+  message: import_zod2.z.string()
 });
 
-// src/generated/cfg_accounts/_utils/schemas/CfgAccountsProfileAvatarCreateRequest.schema.ts
+// src/generated/cfg_accounts/_utils/schemas/CentrifugoToken.schema.ts
 var import_zod3 = require("zod");
-var CfgAccountsProfileAvatarCreateRequestSchema = import_zod3.z.object({
-  avatar: import_zod3.z.union([import_zod3.z.instanceof(File), import_zod3.z.instanceof(Blob)])
+var CentrifugoTokenSchema = import_zod3.z.object({
+  token: import_zod3.z.string(),
+  centrifugo_url: import_zod3.z.union([import_zod3.z.url(), import_zod3.z.literal("")]),
+  expires_at: import_zod3.z.iso.datetime(),
+  channels: import_zod3.z.array(import_zod3.z.string())
 });
 
-// src/generated/cfg_accounts/_utils/schemas/OAuthAuthorizeRequestRequest.schema.ts
+// src/generated/cfg_accounts/_utils/schemas/CfgAccountsProfileAvatarCreateRequest.schema.ts
 var import_zod4 = require("zod");
-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()
+var CfgAccountsProfileAvatarCreateRequestSchema = import_zod4.z.object({
+  avatar: import_zod4.z.union([import_zod4.z.instanceof(File), import_zod4.z.instanceof(Blob)])
 });
 
-// src/generated/cfg_accounts/_utils/schemas/OAuthAuthorizeResponse.schema.ts
+// src/generated/cfg_accounts/_utils/schemas/OAuthAuthorizeRequestRequest.schema.ts
 var import_zod5 = require("zod");
-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()
+var OAuthAuthorizeRequestRequestSchema = import_zod5.z.object({
+  redirect_uri: import_zod5.z.union([import_zod5.z.url(), import_zod5.z.literal("")]).optional(),
+  source_url: import_zod5.z.union([import_zod5.z.url(), import_zod5.z.literal("")]).optional()
 });
 
-// src/generated/cfg_accounts/_utils/schemas/OAuthCallbackRequestRequest.schema.ts
+// src/generated/cfg_accounts/_utils/schemas/OAuthAuthorizeResponse.schema.ts
 var import_zod6 = require("zod");
-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()
+var OAuthAuthorizeResponseSchema = import_zod6.z.object({
+  authorization_url: import_zod6.z.union([import_zod6.z.url(), import_zod6.z.literal("")]),
+  state: import_zod6.z.string()
 });
 
-// src/generated/cfg_accounts/_utils/schemas/OAuthConnection.schema.ts
+// src/generated/cfg_accounts/_utils/schemas/OAuthCallbackRequestRequest.schema.ts
 var import_zod7 = require("zod");
-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()
+var OAuthCallbackRequestRequestSchema = import_zod7.z.object({
+  code: import_zod7.z.string().min(10).max(500),
+  state: import_zod7.z.string().min(20).max(100),
+  redirect_uri: import_zod7.z.union([import_zod7.z.url(), import_zod7.z.literal("")]).optional()
 });
 
-// src/generated/cfg_accounts/_utils/schemas/OAuthDisconnectRequestRequest.schema.ts
+// src/generated/cfg_accounts/_utils/schemas/OAuthConnection.schema.ts
 var import_zod8 = require("zod");
-var OAuthDisconnectRequestRequestSchema = import_zod8.z.object({
-  provider: import_zod8.z.nativeEnum(OAuthDisconnectRequestRequestProvider)
+var OAuthConnectionSchema = import_zod8.z.object({
+  id: import_zod8.z.int(),
+  provider: import_zod8.z.nativeEnum(OAuthConnectionProvider),
+  provider_display: import_zod8.z.string(),
+  provider_username: import_zod8.z.string(),
+  provider_email: import_zod8.z.email(),
+  provider_avatar_url: import_zod8.z.union([import_zod8.z.url(), import_zod8.z.literal("")]),
+  connected_at: import_zod8.z.iso.datetime(),
+  last_login_at: import_zod8.z.iso.datetime()
 });
 
-// src/generated/cfg_accounts/_utils/schemas/OAuthError.schema.ts
+// src/generated/cfg_accounts/_utils/schemas/OAuthDisconnectRequestRequest.schema.ts
 var import_zod9 = require("zod");
-var OAuthErrorSchema = import_zod9.z.object({
-  error: import_zod9.z.string(),
-  error_description: import_zod9.z.string().optional()
+var OAuthDisconnectRequestRequestSchema = import_zod9.z.object({
+  provider: import_zod9.z.nativeEnum(OAuthDisconnectRequestRequestProvider)
 });
 
-// src/generated/cfg_accounts/_utils/schemas/OAuthProvidersResponse.schema.ts
+// src/generated/cfg_accounts/_utils/schemas/OAuthError.schema.ts
 var import_zod10 = require("zod");
-var OAuthProvidersResponseSchema = import_zod10.z.object({
-  providers: import_zod10.z.array(import_zod10.z.record(import_zod10.z.string(), import_zod10.z.any()))
+var OAuthErrorSchema = import_zod10.z.object({
+  error: import_zod10.z.string(),
+  error_description: import_zod10.z.string().optional()
 });
 
-// src/generated/cfg_accounts/_utils/schemas/OAuthTokenResponse.schema.ts
+// src/generated/cfg_accounts/_utils/schemas/OAuthProvidersResponse.schema.ts
 var import_zod11 = require("zod");
-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()
+var OAuthProvidersResponseSchema = import_zod11.z.object({
+  providers: import_zod11.z.array(import_zod11.z.record(import_zod11.z.string(), import_zod11.z.any()))
 });
 
-// src/generated/cfg_accounts/_utils/schemas/OTPErrorResponse.schema.ts
+// src/generated/cfg_accounts/_utils/schemas/OAuthTokenResponse.schema.ts
 var import_zod12 = require("zod");
-var OTPErrorResponseSchema = import_zod12.z.object({
-  error: import_zod12.z.string()
+var OAuthTokenResponseSchema = import_zod12.z.object({
+  requires_2fa: import_zod12.z.boolean().optional(),
+  session_id: import_zod12.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_zod12.z.string().nullable().optional(),
+  refresh: import_zod12.z.string().nullable().optional(),
+  user: import_zod12.z.record(import_zod12.z.string(), import_zod12.z.any()).nullable().optional(),
+  is_new_user: import_zod12.z.boolean(),
+  is_new_connection: import_zod12.z.boolean(),
+  should_prompt_2fa: import_zod12.z.boolean().optional()
 });
 
-// src/generated/cfg_accounts/_utils/schemas/OTPRequestRequest.schema.ts
+// src/generated/cfg_accounts/_utils/schemas/OTPErrorResponse.schema.ts
 var import_zod13 = require("zod");
-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()
+var OTPErrorResponseSchema = import_zod13.z.object({
+  error: import_zod13.z.string()
 });
 
-// src/generated/cfg_accounts/_utils/schemas/OTPRequestResponse.schema.ts
+// src/generated/cfg_accounts/_utils/schemas/OTPRequestRequest.schema.ts
 var import_zod14 = require("zod");
-var OTPRequestResponseSchema = import_zod14.z.object({
-  message: import_zod14.z.string()
+var OTPRequestRequestSchema = import_zod14.z.object({
+  identifier: import_zod14.z.string().min(1),
+  channel: import_zod14.z.nativeEnum(OTPRequestRequestChannel).optional(),
+  source_url: import_zod14.z.union([import_zod14.z.url(), import_zod14.z.literal("")]).optional()
 });
 
-// src/generated/cfg_accounts/_utils/schemas/OTPVerifyRequest.schema.ts
+// src/generated/cfg_accounts/_utils/schemas/OTPRequestResponse.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()
+var OTPRequestResponseSchema = import_zod15.z.object({
+  message: import_zod15.z.string()
+});
+
+// src/generated/cfg_accounts/_utils/schemas/OTPVerifyRequest.schema.ts
+var import_zod16 = require("zod");
+var OTPVerifyRequestSchema = import_zod16.z.object({
+  identifier: import_zod16.z.string().min(1),
+  otp: import_zod16.z.string().min(6).max(6),
+  channel: import_zod16.z.nativeEnum(OTPVerifyRequestChannel).optional(),
+  source_url: import_zod16.z.union([import_zod16.z.url(), import_zod16.z.literal("")]).optional()
 });
 
 // src/generated/cfg_accounts/_utils/schemas/OTPVerifyResponse.schema.ts
-var import_zod17 = require("zod");
+var import_zod18 = require("zod");
 
 // src/generated/cfg_accounts/_utils/schemas/User.schema.ts
-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(),
+var import_zod17 = require("zod");
+var UserSchema = import_zod17.z.object({
+  id: import_zod17.z.int(),
+  email: import_zod17.z.email(),
+  first_name: import_zod17.z.string().max(50).optional(),
+  last_name: import_zod17.z.string().max(50).optional(),
+  full_name: import_zod17.z.string(),
+  initials: import_zod17.z.string(),
+  display_username: import_zod17.z.string(),
+  company: import_zod17.z.string().max(100).optional(),
+  phone: import_zod17.z.string().max(20).optional(),
+  position: import_zod17.z.string().max(100).optional(),
+  avatar: import_zod17.z.union([import_zod17.z.url(), import_zod17.z.literal("")]).nullable(),
+  is_staff: import_zod17.z.boolean(),
+  is_superuser: import_zod17.z.boolean(),
+  date_joined: import_zod17.z.iso.datetime(),
+  last_login: import_zod17.z.iso.datetime().nullable(),
+  unanswered_messages_count: import_zod17.z.int(),
   centrifugo: CentrifugoTokenSchema.nullable()
 });
 
 // src/generated/cfg_accounts/_utils/schemas/OTPVerifyResponse.schema.ts
-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(),
+var OTPVerifyResponseSchema = import_zod18.z.object({
+  requires_2fa: import_zod18.z.boolean().optional(),
+  session_id: import_zod18.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_zod18.z.string().nullable().optional(),
+  access: import_zod18.z.string().nullable().optional(),
   user: UserSchema.nullable().optional(),
-  should_prompt_2fa: import_zod17.z.boolean().optional()
+  should_prompt_2fa: import_zod18.z.boolean().optional()
 });
 
 // src/generated/cfg_accounts/_utils/schemas/PatchedUserProfileUpdateRequest.schema.ts
-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()
+var import_zod19 = require("zod");
+var PatchedUserProfileUpdateRequestSchema = import_zod19.z.object({
+  first_name: import_zod19.z.string().max(50).optional(),
+  last_name: import_zod19.z.string().max(50).optional(),
+  company: import_zod19.z.string().max(100).optional(),
+  phone: import_zod19.z.string().max(20).optional(),
+  position: import_zod19.z.string().max(100).optional()
 });
 
 // src/generated/cfg_accounts/_utils/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
@@ -1366,6 +1387,49 @@ Method: POST`);
   }
 }
 __name(createAccountsProfileAvatarCreate, "createAccountsProfileAvatarCreate");
+async function createAccountsProfileDeleteCreate(client) {
+  const api = client || getAPIInstance();
+  const response = await api.user_profile.accountsProfileDeleteCreate();
+  try {
+    return AccountDeleteResponseSchema.parse(response);
+  } catch (error) {
+    import_consola4.consola.error("\u274C Zod Validation Failed");
+    import_consola4.consola.box(`createAccountsProfileDeleteCreate
+Path: /cfg/accounts/profile/delete/
+Method: POST`);
+    if (error instanceof Error && "issues" in error && Array.isArray(error.issues)) {
+      import_consola4.consola.error("Validation Issues:");
+      error.issues.forEach((issue, index) => {
+        import_consola4.consola.error(`  ${index + 1}. ${issue.path.join(".") || "root"}`);
+        import_consola4.consola.error(`     \u251C\u2500 Message: ${issue.message}`);
+        if (issue.expected) import_consola4.consola.error(`     \u251C\u2500 Expected: ${issue.expected}`);
+        if (issue.received) import_consola4.consola.error(`     \u2514\u2500 Received: ${issue.received}`);
+      });
+    }
+    import_consola4.consola.error("Response data:", response);
+    if (typeof window !== "undefined" && error instanceof Error && "issues" in error) {
+      try {
+        const event = new CustomEvent("zod-validation-error", {
+          detail: {
+            operation: "createAccountsProfileDeleteCreate",
+            path: "/cfg/accounts/profile/delete/",
+            method: "POST",
+            error,
+            response,
+            timestamp: /* @__PURE__ */ new Date()
+          },
+          bubbles: true,
+          cancelable: false
+        });
+        window.dispatchEvent(event);
+      } catch (eventError) {
+        import_consola4.consola.warn("Failed to dispatch validation error event:", eventError);
+      }
+    }
+    throw error;
+  }
+}
+__name(createAccountsProfileDeleteCreate, "createAccountsProfileDeleteCreate");
 async function partialUpdateAccountsProfilePartialUpdate(data, client) {
   const api = client || getAPIInstance();
   const response = await api.user_profile.accountsProfilePartialUpdate(data);
@@ -1813,6 +1877,15 @@ function useCreateAccountsProfileAvatarCreate() {
   };
 }
 __name(useCreateAccountsProfileAvatarCreate, "useCreateAccountsProfileAvatarCreate");
+function useCreateAccountsProfileDeleteCreate() {
+  const { mutate } = (0, import_swr5.useSWRConfig)();
+  return async (client) => {
+    const result = await createAccountsProfileDeleteCreate(client);
+    mutate("cfg-accounts-profile-delete");
+    return result;
+  };
+}
+__name(useCreateAccountsProfileDeleteCreate, "useCreateAccountsProfileDeleteCreate");
 function usePartialUpdateAccountsProfilePartialUpdate() {
   const { mutate } = (0, import_swr5.useSWRConfig)();
   return async (data, client) => {