@djangocfg/api 2.1.572 → 2.1.573

package/dist/auth.cjs

@@ -7,6 +7,9 @@ var __getOwnPropNames = Object.getOwnPropertyNames;
 var __getProtoOf = Object.getPrototypeOf;
 var __hasOwnProp = Object.prototype.hasOwnProperty;
 var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+var __esm = (fn, res) => function __init() {
+  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+};
 var __export = (target, all) => {
   for (var name in all)
     __defProp(target, name, { get: all[name], enumerable: true });
@@ -29,6 +32,332 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
 ));
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 
+// src/_api/generated/_cfg_accounts/schemas/WebmailLinkProviderEnum.ts
+var import_zod, WebmailLinkProviderEnumSchema;
+var init_WebmailLinkProviderEnum = __esm({
+  "src/_api/generated/_cfg_accounts/schemas/WebmailLinkProviderEnum.ts"() {
+    "use strict";
+    import_zod = require("zod");
+    WebmailLinkProviderEnumSchema = import_zod.z.enum(["gmail", "outlook", "yahoo", "icloud", "proton", "zoho", "aol", "fastmail", "gmx", "mailcom", "mail_ru", "yandex", "rambler", "qq", "netease", "sina", "aliyun", "naver", "daum", "web_de", "tonline", "seznam", "wp_pl", "o2_pl", "interia", "libero", "virgilio", "orange", "laposte", "free_fr", "sfr"]);
+  }
+});
+
+// src/_api/generated/_cfg_accounts/schemas/WebmailLink.ts
+var import_zod2, WebmailLinkSchema;
+var init_WebmailLink = __esm({
+  "src/_api/generated/_cfg_accounts/schemas/WebmailLink.ts"() {
+    "use strict";
+    import_zod2 = require("zod");
+    init_WebmailLinkProviderEnum();
+    WebmailLinkSchema = import_zod2.z.object({
+      provider: WebmailLinkProviderEnumSchema,
+      provider_name: import_zod2.z.string(),
+      url: import_zod2.z.url().or(import_zod2.z.literal("")),
+      is_search: import_zod2.z.boolean()
+    });
+  }
+});
+
+// src/_api/generated/_cfg_accounts/schemas/OTPRequestResponse.ts
+var OTPRequestResponse_exports = {};
+__export(OTPRequestResponse_exports, {
+  OTPRequestResponseSchema: () => OTPRequestResponseSchema
+});
+var import_zod3, OTPRequestResponseSchema;
+var init_OTPRequestResponse = __esm({
+  "src/_api/generated/_cfg_accounts/schemas/OTPRequestResponse.ts"() {
+    "use strict";
+    import_zod3 = require("zod");
+    init_WebmailLink();
+    OTPRequestResponseSchema = import_zod3.z.object({
+      message: import_zod3.z.string(),
+      webmail: WebmailLinkSchema.nullable().optional()
+    });
+  }
+});
+
+// src/_api/generated/_cfg_accounts/schemas/User.ts
+var User_exports = {};
+__export(User_exports, {
+  UserSchema: () => UserSchema
+});
+var import_zod4, UserSchema;
+var init_User = __esm({
+  "src/_api/generated/_cfg_accounts/schemas/User.ts"() {
+    "use strict";
+    import_zod4 = require("zod");
+    UserSchema = import_zod4.z.object({
+      id: import_zod4.z.number().int(),
+      email: import_zod4.z.email().or(import_zod4.z.literal("")),
+      first_name: import_zod4.z.string().max(50).nullable().optional(),
+      last_name: import_zod4.z.string().max(50).nullable().optional(),
+      full_name: import_zod4.z.string(),
+      initials: import_zod4.z.string(),
+      display_username: import_zod4.z.string(),
+      company: import_zod4.z.string().max(100).nullable().optional(),
+      phone: import_zod4.z.string().max(20).nullable().optional(),
+      position: import_zod4.z.string().max(100).nullable().optional(),
+      language: import_zod4.z.string().max(10).nullable().optional(),
+      timezone: import_zod4.z.string().max(64).nullable().optional(),
+      avatar: import_zod4.z.url().or(import_zod4.z.literal("")).nullable(),
+      is_staff: import_zod4.z.boolean(),
+      is_superuser: import_zod4.z.boolean(),
+      date_joined: import_zod4.z.string().datetime({ offset: true }),
+      last_login: import_zod4.z.string().datetime({ offset: true }).nullable(),
+      unanswered_messages_count: import_zod4.z.number().int().default(0),
+      api_key: import_zod4.z.string().nullable()
+    });
+  }
+});
+
+// src/_api/generated/_cfg_accounts/schemas/OTPVerifyResponse.ts
+var OTPVerifyResponse_exports = {};
+__export(OTPVerifyResponse_exports, {
+  OTPVerifyResponseSchema: () => OTPVerifyResponseSchema
+});
+var import_zod5, OTPVerifyResponseSchema;
+var init_OTPVerifyResponse = __esm({
+  "src/_api/generated/_cfg_accounts/schemas/OTPVerifyResponse.ts"() {
+    "use strict";
+    import_zod5 = require("zod");
+    init_User();
+    OTPVerifyResponseSchema = import_zod5.z.object({
+      requires_2fa: import_zod5.z.boolean().default(false).optional(),
+      session_id: import_zod5.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_zod5.z.string().nullable().optional(),
+      access: import_zod5.z.string().nullable().optional(),
+      user: UserSchema.nullable().optional(),
+      should_prompt_2fa: import_zod5.z.boolean().optional(),
+      persistent_session: import_zod5.z.boolean().optional()
+    });
+  }
+});
+
+// src/_api/generated/_cfg_accounts/schemas/PasswordLoginResponse.ts
+var PasswordLoginResponse_exports = {};
+__export(PasswordLoginResponse_exports, {
+  PasswordLoginResponseSchema: () => PasswordLoginResponseSchema
+});
+var import_zod6, PasswordLoginResponseSchema;
+var init_PasswordLoginResponse = __esm({
+  "src/_api/generated/_cfg_accounts/schemas/PasswordLoginResponse.ts"() {
+    "use strict";
+    import_zod6 = require("zod");
+    init_User();
+    PasswordLoginResponseSchema = import_zod6.z.object({
+      requires_2fa: import_zod6.z.boolean().default(false).optional(),
+      session_id: import_zod6.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_zod6.z.string().nullable().optional(),
+      access: import_zod6.z.string().nullable().optional(),
+      user: UserSchema.nullable().optional(),
+      should_prompt_2fa: import_zod6.z.boolean().optional(),
+      persistent_session: import_zod6.z.boolean().optional()
+    });
+  }
+});
+
+// src/_api/generated/_cfg_accounts/schemas/APIKey.ts
+var import_zod7, APIKeySchema;
+var init_APIKey = __esm({
+  "src/_api/generated/_cfg_accounts/schemas/APIKey.ts"() {
+    "use strict";
+    import_zod7 = require("zod");
+    APIKeySchema = import_zod7.z.object({
+      key: import_zod7.z.string(),
+      reissued_at: import_zod7.z.string().datetime({ offset: true }).nullable(),
+      created_at: import_zod7.z.string().datetime({ offset: true })
+    });
+  }
+});
+
+// src/_api/generated/_cfg_accounts/schemas/APIKeyRegenerate.ts
+var import_zod8, APIKeyRegenerateSchema;
+var init_APIKeyRegenerate = __esm({
+  "src/_api/generated/_cfg_accounts/schemas/APIKeyRegenerate.ts"() {
+    "use strict";
+    import_zod8 = require("zod");
+    APIKeyRegenerateSchema = import_zod8.z.object({
+      key: import_zod8.z.string(),
+      reissued_at: import_zod8.z.string().datetime({ offset: true })
+    });
+  }
+});
+
+// src/_api/generated/_cfg_accounts/schemas/APIKeyReveal.ts
+var import_zod10, APIKeyRevealSchema;
+var init_APIKeyReveal = __esm({
+  "src/_api/generated/_cfg_accounts/schemas/APIKeyReveal.ts"() {
+    "use strict";
+    import_zod10 = require("zod");
+    APIKeyRevealSchema = import_zod10.z.object({
+      key: import_zod10.z.string(),
+      created_at: import_zod10.z.string().datetime({ offset: true }),
+      reissued_at: import_zod10.z.string().datetime({ offset: true }).nullable()
+    });
+  }
+});
+
+// src/_api/generated/_cfg_accounts/schemas/APIKeyTestResult.ts
+var import_zod12, APIKeyTestResultSchema;
+var init_APIKeyTestResult = __esm({
+  "src/_api/generated/_cfg_accounts/schemas/APIKeyTestResult.ts"() {
+    "use strict";
+    import_zod12 = require("zod");
+    APIKeyTestResultSchema = import_zod12.z.object({
+      valid: import_zod12.z.boolean(),
+      user_id: import_zod12.z.string().nullable()
+    });
+  }
+});
+
+// src/_api/generated/_cfg_accounts/schemas/AccountDeleteResponse.ts
+var import_zod13, AccountDeleteResponseSchema;
+var init_AccountDeleteResponse = __esm({
+  "src/_api/generated/_cfg_accounts/schemas/AccountDeleteResponse.ts"() {
+    "use strict";
+    import_zod13 = require("zod");
+    AccountDeleteResponseSchema = import_zod13.z.object({
+      success: import_zod13.z.boolean(),
+      message: import_zod13.z.string()
+    });
+  }
+});
+
+// src/_api/generated/_cfg_accounts/schemas/MarketingConsentDefaultEnum.ts
+var import_zod15, MarketingConsentDefaultEnumSchema;
+var init_MarketingConsentDefaultEnum = __esm({
+  "src/_api/generated/_cfg_accounts/schemas/MarketingConsentDefaultEnum.ts"() {
+    "use strict";
+    import_zod15 = require("zod");
+    MarketingConsentDefaultEnumSchema = import_zod15.z.enum(["checked", "unchecked"]);
+  }
+});
+
+// src/_api/generated/_cfg_accounts/schemas/ConsentPolicy.ts
+var import_zod16, ConsentPolicySchema;
+var init_ConsentPolicy = __esm({
+  "src/_api/generated/_cfg_accounts/schemas/ConsentPolicy.ts"() {
+    "use strict";
+    import_zod16 = require("zod");
+    init_MarketingConsentDefaultEnum();
+    ConsentPolicySchema = import_zod16.z.object({
+      country: import_zod16.z.string(),
+      marketing_consent_default: MarketingConsentDefaultEnumSchema
+    });
+  }
+});
+
+// src/_api/generated/_cfg_accounts/schemas/OAuthAuthorizeResponse.ts
+var import_zod18, OAuthAuthorizeResponseSchema;
+var init_OAuthAuthorizeResponse = __esm({
+  "src/_api/generated/_cfg_accounts/schemas/OAuthAuthorizeResponse.ts"() {
+    "use strict";
+    import_zod18 = require("zod");
+    OAuthAuthorizeResponseSchema = import_zod18.z.object({
+      authorization_url: import_zod18.z.url().or(import_zod18.z.literal("")),
+      state: import_zod18.z.string()
+    });
+  }
+});
+
+// src/_api/generated/_cfg_accounts/schemas/OAuthProviderEnum.ts
+var import_zod20, OAuthProviderEnumSchema;
+var init_OAuthProviderEnum = __esm({
+  "src/_api/generated/_cfg_accounts/schemas/OAuthProviderEnum.ts"() {
+    "use strict";
+    import_zod20 = require("zod");
+    OAuthProviderEnumSchema = import_zod20.z.enum(["github"]);
+  }
+});
+
+// src/_api/generated/_cfg_accounts/schemas/OAuthConnection.ts
+var import_zod21, OAuthConnectionSchema;
+var init_OAuthConnection = __esm({
+  "src/_api/generated/_cfg_accounts/schemas/OAuthConnection.ts"() {
+    "use strict";
+    import_zod21 = require("zod");
+    init_OAuthProviderEnum();
+    OAuthConnectionSchema = import_zod21.z.object({
+      id: import_zod21.z.number().int(),
+      provider: OAuthProviderEnumSchema,
+      provider_display: import_zod21.z.string(),
+      provider_username: import_zod21.z.string(),
+      provider_email: import_zod21.z.email().or(import_zod21.z.literal("")),
+      provider_avatar_url: import_zod21.z.url().or(import_zod21.z.literal("")),
+      connected_at: import_zod21.z.string().datetime({ offset: true }),
+      last_login_at: import_zod21.z.string().datetime({ offset: true })
+    });
+  }
+});
+
+// src/_api/generated/_cfg_accounts/schemas/OAuthProvidersResponse.ts
+var import_zod24, OAuthProvidersResponseSchema;
+var init_OAuthProvidersResponse = __esm({
+  "src/_api/generated/_cfg_accounts/schemas/OAuthProvidersResponse.ts"() {
+    "use strict";
+    import_zod24 = require("zod");
+    OAuthProvidersResponseSchema = import_zod24.z.object({
+      providers: import_zod24.z.array(import_zod24.z.object({}).passthrough())
+    });
+  }
+});
+
+// src/_api/generated/_cfg_accounts/schemas/OAuthTokenResponse.ts
+var import_zod25, OAuthTokenResponseSchema;
+var init_OAuthTokenResponse = __esm({
+  "src/_api/generated/_cfg_accounts/schemas/OAuthTokenResponse.ts"() {
+    "use strict";
+    import_zod25 = require("zod");
+    OAuthTokenResponseSchema = import_zod25.z.object({
+      requires_2fa: import_zod25.z.boolean().default(false).optional(),
+      session_id: import_zod25.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_zod25.z.string().nullable().optional(),
+      refresh: import_zod25.z.string().nullable().optional(),
+      user: import_zod25.z.object({}).passthrough().nullable().optional(),
+      is_new_user: import_zod25.z.boolean().default(false).optional(),
+      is_new_connection: import_zod25.z.boolean().default(false).optional(),
+      should_prompt_2fa: import_zod25.z.boolean().optional(),
+      persistent_session: import_zod25.z.boolean().optional()
+    });
+  }
+});
+
+// src/_api/generated/_cfg_accounts/schemas/TokenRefresh.ts
+var import_zod33, TokenRefreshSchema;
+var init_TokenRefresh = __esm({
+  "src/_api/generated/_cfg_accounts/schemas/TokenRefresh.ts"() {
+    "use strict";
+    import_zod33 = require("zod");
+    TokenRefreshSchema = import_zod33.z.object({
+      access: import_zod33.z.string(),
+      refresh: import_zod33.z.string()
+    });
+  }
+});
+
+// src/_api/generated/_cfg_accounts/schemas/cfg_accounts_oauth_connections_response_200_AutoRef.ts
+var import_zod35, cfg_accounts_oauth_connections_response_200_AutoRefSchema;
+var init_cfg_accounts_oauth_connections_response_200_AutoRef = __esm({
+  "src/_api/generated/_cfg_accounts/schemas/cfg_accounts_oauth_connections_response_200_AutoRef.ts"() {
+    "use strict";
+    import_zod35 = require("zod");
+    init_OAuthConnection();
+    cfg_accounts_oauth_connections_response_200_AutoRefSchema = import_zod35.z.array(OAuthConnectionSchema);
+  }
+});
+
+// src/_api/generated/_cfg_accounts/schemas/cfg_accounts_oauth_disconnect_response_200_AutoRef.ts
+var import_zod36, cfg_accounts_oauth_disconnect_response_200_AutoRefSchema;
+var init_cfg_accounts_oauth_disconnect_response_200_AutoRef = __esm({
+  "src/_api/generated/_cfg_accounts/schemas/cfg_accounts_oauth_disconnect_response_200_AutoRef.ts"() {
+    "use strict";
+    import_zod36 = require("zod");
+    cfg_accounts_oauth_disconnect_response_200_AutoRefSchema = import_zod36.z.object({
+      message: import_zod36.z.string().optional()
+    });
+  }
+});
+
 // src/auth/index.ts
 var auth_exports = {};
 __export(auth_exports, {
@@ -3991,170 +4320,44 @@ var import_react15 = require("react");
 // src/_api/generated/_cfg_accounts/hooks/useCfgAccountsApiKeyRegenerateCreate.ts
 var import_mutation = __toESM(require("swr/mutation"), 1);
 
-// src/_api/generated/_cfg_accounts/schemas/APIKeyRegenerate.ts
-var import_zod = require("zod");
-var APIKeyRegenerateSchema = import_zod.z.object({
-  key: import_zod.z.string(),
-  reissued_at: import_zod.z.string().datetime({ offset: true })
-});
-
 // src/_api/generated/_cfg_accounts/hooks/useCfgAccountsApiKeyRetrieve.ts
 var import_swr = __toESM(require("swr"), 1);
 
-// src/_api/generated/_cfg_accounts/schemas/APIKey.ts
-var import_zod2 = require("zod");
-var APIKeySchema = import_zod2.z.object({
-  key: import_zod2.z.string(),
-  reissued_at: import_zod2.z.string().datetime({ offset: true }).nullable(),
-  created_at: import_zod2.z.string().datetime({ offset: true })
-});
-
 // src/_api/generated/_cfg_accounts/hooks/useCfgAccountsApiKeyRevealCreate.ts
 var import_mutation2 = __toESM(require("swr/mutation"), 1);
 
-// src/_api/generated/_cfg_accounts/schemas/APIKeyReveal.ts
-var import_zod3 = require("zod");
-var APIKeyRevealSchema = import_zod3.z.object({
-  key: import_zod3.z.string(),
-  created_at: import_zod3.z.string().datetime({ offset: true }),
-  reissued_at: import_zod3.z.string().datetime({ offset: true }).nullable()
-});
-
 // src/_api/generated/_cfg_accounts/hooks/useCfgAccountsApiKeyTestCreate.ts
 var import_mutation3 = __toESM(require("swr/mutation"), 1);
 
-// src/_api/generated/_cfg_accounts/schemas/APIKeyTestResult.ts
-var import_zod4 = require("zod");
-var APIKeyTestResultSchema = import_zod4.z.object({
-  valid: import_zod4.z.boolean(),
-  user_id: import_zod4.z.string().nullable()
-});
-
 // src/_api/generated/_cfg_accounts/hooks/useCfgAccountsOauthConnectionsList.ts
 var import_swr2 = __toESM(require("swr"), 1);
 
-// src/_api/generated/_cfg_accounts/schemas/cfg_accounts_oauth_connections_response_200_AutoRef.ts
-var import_zod7 = require("zod");
-
-// src/_api/generated/_cfg_accounts/schemas/OAuthConnection.ts
-var import_zod6 = require("zod");
-
-// src/_api/generated/_cfg_accounts/schemas/OAuthProviderEnum.ts
-var import_zod5 = require("zod");
-var OAuthProviderEnumSchema = import_zod5.z.enum(["github"]);
-
-// src/_api/generated/_cfg_accounts/schemas/OAuthConnection.ts
-var OAuthConnectionSchema = import_zod6.z.object({
-  id: import_zod6.z.number().int(),
-  provider: OAuthProviderEnumSchema,
-  provider_display: import_zod6.z.string(),
-  provider_username: import_zod6.z.string(),
-  provider_email: import_zod6.z.email().or(import_zod6.z.literal("")),
-  provider_avatar_url: import_zod6.z.url().or(import_zod6.z.literal("")),
-  connected_at: import_zod6.z.string().datetime({ offset: true }),
-  last_login_at: import_zod6.z.string().datetime({ offset: true })
-});
-
-// src/_api/generated/_cfg_accounts/schemas/cfg_accounts_oauth_connections_response_200_AutoRef.ts
-var cfg_accounts_oauth_connections_response_200_AutoRefSchema = import_zod7.z.array(OAuthConnectionSchema);
-
 // src/_api/generated/_cfg_accounts/hooks/useCfgAccountsOauthDisconnectCreate.ts
 var import_mutation4 = __toESM(require("swr/mutation"), 1);
 
-// src/_api/generated/_cfg_accounts/schemas/cfg_accounts_oauth_disconnect_response_200_AutoRef.ts
-var import_zod8 = require("zod");
-var cfg_accounts_oauth_disconnect_response_200_AutoRefSchema = import_zod8.z.object({
-  message: import_zod8.z.string().optional()
-});
-
 // src/_api/generated/_cfg_accounts/hooks/useCfgAccountsOauthGithubAuthorizeCreate.ts
 var import_mutation5 = __toESM(require("swr/mutation"), 1);
 
-// src/_api/generated/_cfg_accounts/schemas/OAuthAuthorizeResponse.ts
-var import_zod9 = require("zod");
-var OAuthAuthorizeResponseSchema = import_zod9.z.object({
-  authorization_url: import_zod9.z.url().or(import_zod9.z.literal("")),
-  state: import_zod9.z.string()
-});
-
 // src/_api/generated/_cfg_accounts/hooks/useCfgAccountsOauthGithubCallbackCreate.ts
 var import_mutation6 = __toESM(require("swr/mutation"), 1);
 
-// src/_api/generated/_cfg_accounts/schemas/OAuthTokenResponse.ts
-var import_zod10 = require("zod");
-var OAuthTokenResponseSchema = import_zod10.z.object({
-  requires_2fa: import_zod10.z.boolean().default(false).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.object({}).passthrough().nullable().optional(),
-  is_new_user: import_zod10.z.boolean().default(false).optional(),
-  is_new_connection: import_zod10.z.boolean().default(false).optional(),
-  should_prompt_2fa: import_zod10.z.boolean().optional(),
-  persistent_session: import_zod10.z.boolean().optional()
-});
-
 // src/_api/generated/_cfg_accounts/hooks/useCfgAccountsOauthProvidersRetrieve.ts
 var import_swr3 = __toESM(require("swr"), 1);
 
-// src/_api/generated/_cfg_accounts/schemas/OAuthProvidersResponse.ts
-var import_zod11 = require("zod");
-var OAuthProvidersResponseSchema = import_zod11.z.object({
-  providers: import_zod11.z.array(import_zod11.z.object({}).passthrough())
-});
-
 // src/_api/generated/_cfg_accounts/hooks/useCfgAccountsOtpConsentPolicyRetrieve.ts
 var import_swr4 = __toESM(require("swr"), 1);
 
-// src/_api/generated/_cfg_accounts/schemas/ConsentPolicy.ts
-var import_zod13 = require("zod");
-
-// src/_api/generated/_cfg_accounts/schemas/MarketingConsentDefaultEnum.ts
-var import_zod12 = require("zod");
-var MarketingConsentDefaultEnumSchema = import_zod12.z.enum(["checked", "unchecked"]);
-
-// src/_api/generated/_cfg_accounts/schemas/ConsentPolicy.ts
-var ConsentPolicySchema = import_zod13.z.object({
-  country: import_zod13.z.string(),
-  marketing_consent_default: MarketingConsentDefaultEnumSchema
-});
-
 // src/_api/generated/_cfg_accounts/hooks/useCfgAccountsOtpRequestCreate.ts
 var import_mutation7 = __toESM(require("swr/mutation"), 1);
-
-// src/_api/generated/_cfg_accounts/schemas/OTPRequestResponse.ts
-var import_zod16 = require("zod");
-
-// src/_api/generated/_cfg_accounts/schemas/WebmailLink.ts
-var import_zod15 = require("zod");
-
-// src/_api/generated/_cfg_accounts/schemas/WebmailLinkProviderEnum.ts
-var import_zod14 = require("zod");
-var WebmailLinkProviderEnumSchema = import_zod14.z.enum(["gmail", "outlook", "yahoo", "icloud", "proton", "zoho", "aol", "fastmail", "gmx", "mailcom", "mail_ru", "yandex", "rambler", "qq", "netease", "sina", "aliyun", "naver", "daum", "web_de", "tonline", "seznam", "wp_pl", "o2_pl", "interia", "libero", "virgilio", "orange", "laposte", "free_fr", "sfr"]);
-
-// src/_api/generated/_cfg_accounts/schemas/WebmailLink.ts
-var WebmailLinkSchema = import_zod15.z.object({
-  provider: WebmailLinkProviderEnumSchema,
-  provider_name: import_zod15.z.string(),
-  url: import_zod15.z.url().or(import_zod15.z.literal("")),
-  is_search: import_zod15.z.boolean()
-});
-
-// src/_api/generated/_cfg_accounts/schemas/OTPRequestResponse.ts
-var OTPRequestResponseSchema = import_zod16.z.object({
-  message: import_zod16.z.string(),
-  webmail: WebmailLinkSchema.nullable().optional()
-});
-
-// src/_api/generated/_cfg_accounts/hooks/useCfgAccountsOtpRequestCreate.ts
 function useCfgAccountsOtpRequestCreate(config) {
   return (0, import_mutation7.default)(
     ["cfg_accounts_otp_request_create"],
     async (_key, { arg }) => {
       const res = await CfgAccountsOtp.cfgAccountsOtpRequestCreate({ ...arg, throwOnError: true });
       const data = res.data;
-      const parsed = OTPRequestResponseSchema.safeParse(data);
-      if (!parsed.success) {
+      void Promise.resolve().then(() => (init_OTPRequestResponse(), OTPRequestResponse_exports)).then(({ OTPRequestResponseSchema: OTPRequestResponseSchema2 }) => {
+        const parsed = OTPRequestResponseSchema2.safeParse(data);
+        if (parsed.success) return;
         console.warn(
           "[zod] response did not match schema",
           {
@@ -4184,9 +4387,9 @@ function useCfgAccountsOtpRequestCreate(config) {
           } catch {
           }
         }
-        return data;
-      }
-      return parsed.data;
+      }).catch(() => {
+      });
+      return data;
     },
     config
   );
@@ -4195,54 +4398,15 @@ __name(useCfgAccountsOtpRequestCreate, "useCfgAccountsOtpRequestCreate");
 
 // src/_api/generated/_cfg_accounts/hooks/useCfgAccountsOtpVerifyCreate.ts
 var import_mutation8 = __toESM(require("swr/mutation"), 1);
-
-// src/_api/generated/_cfg_accounts/schemas/OTPVerifyResponse.ts
-var import_zod18 = require("zod");
-
-// src/_api/generated/_cfg_accounts/schemas/User.ts
-var import_zod17 = require("zod");
-var UserSchema = import_zod17.z.object({
-  id: import_zod17.z.number().int(),
-  email: import_zod17.z.email().or(import_zod17.z.literal("")),
-  first_name: import_zod17.z.string().max(50).nullable().optional(),
-  last_name: import_zod17.z.string().max(50).nullable().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).nullable().optional(),
-  phone: import_zod17.z.string().max(20).nullable().optional(),
-  position: import_zod17.z.string().max(100).nullable().optional(),
-  language: import_zod17.z.string().max(10).nullable().optional(),
-  timezone: import_zod17.z.string().max(64).nullable().optional(),
-  avatar: import_zod17.z.url().or(import_zod17.z.literal("")).nullable(),
-  is_staff: import_zod17.z.boolean(),
-  is_superuser: import_zod17.z.boolean(),
-  date_joined: import_zod17.z.string().datetime({ offset: true }),
-  last_login: import_zod17.z.string().datetime({ offset: true }).nullable(),
-  unanswered_messages_count: import_zod17.z.number().int().default(0),
-  api_key: import_zod17.z.string().nullable()
-});
-
-// src/_api/generated/_cfg_accounts/schemas/OTPVerifyResponse.ts
-var OTPVerifyResponseSchema = import_zod18.z.object({
-  requires_2fa: import_zod18.z.boolean().default(false).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_zod18.z.boolean().optional(),
-  persistent_session: import_zod18.z.boolean().optional()
-});
-
-// src/_api/generated/_cfg_accounts/hooks/useCfgAccountsOtpVerifyCreate.ts
 function useCfgAccountsOtpVerifyCreate(config) {
   return (0, import_mutation8.default)(
     ["cfg_accounts_otp_verify_create"],
     async (_key, { arg }) => {
       const res = await CfgAccountsOtp.cfgAccountsOtpVerifyCreate({ ...arg, throwOnError: true });
       const data = res.data;
-      const parsed = OTPVerifyResponseSchema.safeParse(data);
-      if (!parsed.success) {
+      void Promise.resolve().then(() => (init_OTPVerifyResponse(), OTPVerifyResponse_exports)).then(({ OTPVerifyResponseSchema: OTPVerifyResponseSchema2 }) => {
+        const parsed = OTPVerifyResponseSchema2.safeParse(data);
+        if (parsed.success) return;
         console.warn(
           "[zod] response did not match schema",
           {
@@ -4272,9 +4436,9 @@ function useCfgAccountsOtpVerifyCreate(config) {
           } catch {
           }
         }
-        return data;
-      }
-      return parsed.data;
+      }).catch(() => {
+      });
+      return data;
     },
     config
   );
@@ -4289,8 +4453,9 @@ function useCfgAccountsProfileAvatarCreate(config) {
     async (_key, { arg }) => {
       const res = await CfgAccountsProfile.cfgAccountsProfileAvatarCreate({ ...arg, throwOnError: true });
       const data = res.data;
-      const parsed = UserSchema.safeParse(data);
-      if (!parsed.success) {
+      void Promise.resolve().then(() => (init_User(), User_exports)).then(({ UserSchema: UserSchema2 }) => {
+        const parsed = UserSchema2.safeParse(data);
+        if (parsed.success) return;
         console.warn(
           "[zod] response did not match schema",
           {
@@ -4320,9 +4485,9 @@ function useCfgAccountsProfileAvatarCreate(config) {
           } catch {
           }
         }
-        return data;
-      }
-      return parsed.data;
+      }).catch(() => {
+      });
+      return data;
     },
     config
   );
@@ -4332,13 +4497,6 @@ __name(useCfgAccountsProfileAvatarCreate, "useCfgAccountsProfileAvatarCreate");
 // src/_api/generated/_cfg_accounts/hooks/useCfgAccountsProfileDeleteCreate.ts
 var import_mutation10 = __toESM(require("swr/mutation"), 1);
 
-// src/_api/generated/_cfg_accounts/schemas/AccountDeleteResponse.ts
-var import_zod19 = require("zod");
-var AccountDeleteResponseSchema = import_zod19.z.object({
-  success: import_zod19.z.boolean(),
-  message: import_zod19.z.string()
-});
-
 // src/_api/generated/_cfg_accounts/hooks/useCfgAccountsProfilePartialPartialUpdate.ts
 var import_mutation11 = __toESM(require("swr/mutation"), 1);
 
@@ -4350,8 +4508,9 @@ function useCfgAccountsProfilePartialUpdate(config) {
     async (_key, { arg }) => {
       const res = await CfgAccountsProfile.cfgAccountsProfilePartialUpdate({ ...arg, throwOnError: true });
       const data = res.data;
-      const parsed = UserSchema.safeParse(data);
-      if (!parsed.success) {
+      void Promise.resolve().then(() => (init_User(), User_exports)).then(({ UserSchema: UserSchema2 }) => {
+        const parsed = UserSchema2.safeParse(data);
+        if (parsed.success) return;
         console.warn(
           "[zod] response did not match schema",
           {
@@ -4381,9 +4540,9 @@ function useCfgAccountsProfilePartialUpdate(config) {
           } catch {
           }
         }
-        return data;
-      }
-      return parsed.data;
+      }).catch(() => {
+      });
+      return data;
     },
     config
   );
@@ -4404,8 +4563,9 @@ function useCfgAccountsProfileUpdateUpdate(config) {
     async (_key, { arg }) => {
       const res = await CfgAccountsProfile.cfgAccountsProfileUpdateUpdate({ ...arg, throwOnError: true });
       const data = res.data;
-      const parsed = UserSchema.safeParse(data);
-      if (!parsed.success) {
+      void Promise.resolve().then(() => (init_User(), User_exports)).then(({ UserSchema: UserSchema2 }) => {
+        const parsed = UserSchema2.safeParse(data);
+        if (parsed.success) return;
         console.warn(
           "[zod] response did not match schema",
           {
@@ -4435,9 +4595,9 @@ function useCfgAccountsProfileUpdateUpdate(config) {
           } catch {
           }
         }
-        return data;
-      }
-      return parsed.data;
+      }).catch(() => {
+      });
+      return data;
     },
     config
   );
@@ -4449,28 +4609,15 @@ var import_mutation15 = __toESM(require("swr/mutation"), 1);
 
 // src/_api/generated/_cfg_accounts/hooks/useCfgAccountsTokenCreate.ts
 var import_mutation16 = __toESM(require("swr/mutation"), 1);
-
-// src/_api/generated/_cfg_accounts/schemas/PasswordLoginResponse.ts
-var import_zod20 = require("zod");
-var PasswordLoginResponseSchema = import_zod20.z.object({
-  requires_2fa: import_zod20.z.boolean().default(false).optional(),
-  session_id: import_zod20.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_zod20.z.string().nullable().optional(),
-  access: import_zod20.z.string().nullable().optional(),
-  user: UserSchema.nullable().optional(),
-  should_prompt_2fa: import_zod20.z.boolean().optional(),
-  persistent_session: import_zod20.z.boolean().optional()
-});
-
-// src/_api/generated/_cfg_accounts/hooks/useCfgAccountsTokenCreate.ts
 function useCfgAccountsTokenCreate(config) {
   return (0, import_mutation16.default)(
     ["cfg_accounts_token_create"],
     async (_key, { arg }) => {
       const res = await CfgAccountsAuth.cfgAccountsTokenCreate({ ...arg, throwOnError: true });
       const data = res.data;
-      const parsed = PasswordLoginResponseSchema.safeParse(data);
-      if (!parsed.success) {
+      void Promise.resolve().then(() => (init_PasswordLoginResponse(), PasswordLoginResponse_exports)).then(({ PasswordLoginResponseSchema: PasswordLoginResponseSchema2 }) => {
+        const parsed = PasswordLoginResponseSchema2.safeParse(data);
+        if (parsed.success) return;
         console.warn(
           "[zod] response did not match schema",
           {
@@ -4500,9 +4647,9 @@ function useCfgAccountsTokenCreate(config) {
           } catch {
           }
         }
-        return data;
-      }
-      return parsed.data;
+      }).catch(() => {
+      });
+      return data;
     },
     config
   );
@@ -4512,134 +4659,173 @@ __name(useCfgAccountsTokenCreate, "useCfgAccountsTokenCreate");
 // src/_api/generated/_cfg_accounts/hooks/useCfgAccountsTokenRefreshCreate.ts
 var import_mutation17 = __toESM(require("swr/mutation"), 1);
 
-// src/_api/generated/_cfg_accounts/schemas/TokenRefresh.ts
-var import_zod21 = require("zod");
-var TokenRefreshSchema = import_zod21.z.object({
-  access: import_zod21.z.string(),
-  refresh: import_zod21.z.string()
-});
+// src/_api/generated/_cfg_accounts/schemas/index.ts
+init_APIKey();
+init_APIKeyRegenerate();
 
 // src/_api/generated/_cfg_accounts/schemas/APIKeyRequest.ts
-var import_zod22 = require("zod");
-var APIKeyRequestSchema = import_zod22.z.object({
-  key: import_zod22.z.string().min(1),
-  reissued_at: import_zod22.z.string().datetime({ offset: true }).nullable(),
-  created_at: import_zod22.z.string().datetime({ offset: true })
+var import_zod9 = require("zod");
+var APIKeyRequestSchema = import_zod9.z.object({
+  key: import_zod9.z.string().min(1),
+  reissued_at: import_zod9.z.string().datetime({ offset: true }).nullable(),
+  created_at: import_zod9.z.string().datetime({ offset: true })
 });
 
+// src/_api/generated/_cfg_accounts/schemas/index.ts
+init_APIKeyReveal();
+
 // src/_api/generated/_cfg_accounts/schemas/APIKeyTestRequest.ts
-var import_zod23 = require("zod");
-var APIKeyTestRequestSchema = import_zod23.z.object({
-  key: import_zod23.z.string().min(1)
+var import_zod11 = require("zod");
+var APIKeyTestRequestSchema = import_zod11.z.object({
+  key: import_zod11.z.string().min(1)
 });
 
+// src/_api/generated/_cfg_accounts/schemas/index.ts
+init_APIKeyTestResult();
+init_AccountDeleteResponse();
+
 // src/_api/generated/_cfg_accounts/schemas/CfgUserUpdateRequest.ts
-var import_zod24 = require("zod");
-var CfgUserUpdateRequestSchema = import_zod24.z.object({
-  first_name: import_zod24.z.string().max(50).optional(),
-  last_name: import_zod24.z.string().max(50).optional(),
-  company: import_zod24.z.string().max(100).optional(),
-  phone: import_zod24.z.string().max(20).optional(),
-  position: import_zod24.z.string().max(100).optional(),
-  language: import_zod24.z.string().max(10).optional(),
-  timezone: import_zod24.z.string().max(64).optional()
+var import_zod14 = require("zod");
+var CfgUserUpdateRequestSchema = import_zod14.z.object({
+  first_name: import_zod14.z.string().max(50).optional(),
+  last_name: import_zod14.z.string().max(50).optional(),
+  company: import_zod14.z.string().max(100).optional(),
+  phone: import_zod14.z.string().max(20).optional(),
+  position: import_zod14.z.string().max(100).optional(),
+  language: import_zod14.z.string().max(10).optional(),
+  timezone: import_zod14.z.string().max(64).optional()
 });
 
+// src/_api/generated/_cfg_accounts/schemas/index.ts
+init_ConsentPolicy();
+init_MarketingConsentDefaultEnum();
+
 // src/_api/generated/_cfg_accounts/schemas/OAuthAuthorizeRequestRequest.ts
-var import_zod25 = require("zod");
-var OAuthAuthorizeRequestRequestSchema = import_zod25.z.object({
-  redirect_uri: import_zod25.z.url().or(import_zod25.z.literal("")).optional(),
-  source_url: import_zod25.z.url().or(import_zod25.z.literal("")).optional()
+var import_zod17 = require("zod");
+var OAuthAuthorizeRequestRequestSchema = import_zod17.z.object({
+  redirect_uri: import_zod17.z.url().or(import_zod17.z.literal("")).optional(),
+  source_url: import_zod17.z.url().or(import_zod17.z.literal("")).optional()
 });
 
+// src/_api/generated/_cfg_accounts/schemas/index.ts
+init_OAuthAuthorizeResponse();
+
 // src/_api/generated/_cfg_accounts/schemas/OAuthCallbackRequestRequest.ts
-var import_zod26 = require("zod");
-var OAuthCallbackRequestRequestSchema = import_zod26.z.object({
-  code: import_zod26.z.string().min(10).max(500),
-  state: import_zod26.z.string().min(20).max(100),
-  redirect_uri: import_zod26.z.url().or(import_zod26.z.literal("")).optional(),
-  remember_me: import_zod26.z.boolean().default(false).optional()
+var import_zod19 = require("zod");
+var OAuthCallbackRequestRequestSchema = import_zod19.z.object({
+  code: import_zod19.z.string().min(10).max(500),
+  state: import_zod19.z.string().min(20).max(100),
+  redirect_uri: import_zod19.z.url().or(import_zod19.z.literal("")).optional(),
+  remember_me: import_zod19.z.boolean().default(false).optional()
 });
 
+// src/_api/generated/_cfg_accounts/schemas/index.ts
+init_OAuthConnection();
+
 // src/_api/generated/_cfg_accounts/schemas/OAuthDisconnectRequestRequest.ts
-var import_zod27 = require("zod");
-var OAuthDisconnectRequestRequestSchema = import_zod27.z.object({
+var import_zod22 = require("zod");
+init_OAuthProviderEnum();
+var OAuthDisconnectRequestRequestSchema = import_zod22.z.object({
   provider: OAuthProviderEnumSchema
 });
 
 // src/_api/generated/_cfg_accounts/schemas/OAuthError.ts
-var import_zod28 = require("zod");
-var OAuthErrorSchema = import_zod28.z.object({
-  error: import_zod28.z.string(),
-  error_description: import_zod28.z.string().optional()
+var import_zod23 = require("zod");
+var OAuthErrorSchema = import_zod23.z.object({
+  error: import_zod23.z.string(),
+  error_description: import_zod23.z.string().optional()
 });
 
+// src/_api/generated/_cfg_accounts/schemas/index.ts
+init_OAuthProviderEnum();
+init_OAuthProvidersResponse();
+init_OAuthTokenResponse();
+
 // src/_api/generated/_cfg_accounts/schemas/OTPErrorResponse.ts
-var import_zod29 = require("zod");
-var OTPErrorResponseSchema = import_zod29.z.object({
-  error: import_zod29.z.string(),
-  error_code: import_zod29.z.string().nullable().optional(),
-  retry_after: import_zod29.z.number().int().nullable().optional()
+var import_zod26 = require("zod");
+var OTPErrorResponseSchema = import_zod26.z.object({
+  error: import_zod26.z.string(),
+  error_code: import_zod26.z.string().nullable().optional(),
+  retry_after: import_zod26.z.number().int().nullable().optional()
 });
 
 // src/_api/generated/_cfg_accounts/schemas/OTPRequestRequest.ts
-var import_zod30 = require("zod");
-var OTPRequestRequestSchema = import_zod30.z.object({
-  identifier: import_zod30.z.string().min(1),
-  source_url: import_zod30.z.url().or(import_zod30.z.literal("")).optional(),
-  marketing_consent: import_zod30.z.boolean().nullable().optional(),
-  consent_disclosure_version: import_zod30.z.string().max(64).optional()
+var import_zod27 = require("zod");
+var OTPRequestRequestSchema = import_zod27.z.object({
+  identifier: import_zod27.z.string().min(1),
+  source_url: import_zod27.z.url().or(import_zod27.z.literal("")).optional(),
+  marketing_consent: import_zod27.z.boolean().nullable().optional(),
+  consent_disclosure_version: import_zod27.z.string().max(64).optional()
 });
 
+// src/_api/generated/_cfg_accounts/schemas/index.ts
+init_OTPRequestResponse();
+
 // src/_api/generated/_cfg_accounts/schemas/OTPVerifyRequest.ts
-var import_zod31 = require("zod");
-var OTPVerifyRequestSchema = import_zod31.z.object({
-  identifier: import_zod31.z.string().min(1),
-  otp: import_zod31.z.string().min(4).max(4),
-  source_url: import_zod31.z.url().or(import_zod31.z.literal("")).optional(),
-  remember_me: import_zod31.z.boolean().default(false).optional()
+var import_zod28 = require("zod");
+var OTPVerifyRequestSchema = import_zod28.z.object({
+  identifier: import_zod28.z.string().min(1),
+  otp: import_zod28.z.string().min(4).max(4),
+  source_url: import_zod28.z.url().or(import_zod28.z.literal("")).optional(),
+  remember_me: import_zod28.z.boolean().default(false).optional()
 });
 
+// src/_api/generated/_cfg_accounts/schemas/index.ts
+init_OTPVerifyResponse();
+
 // src/_api/generated/_cfg_accounts/schemas/PasswordLoginError.ts
-var import_zod32 = require("zod");
-var PasswordLoginErrorSchema = import_zod32.z.object({
-  error: import_zod32.z.string(),
-  error_code: import_zod32.z.string(),
-  retry_after: import_zod32.z.number().int().nullable().optional()
+var import_zod29 = require("zod");
+var PasswordLoginErrorSchema = import_zod29.z.object({
+  error: import_zod29.z.string(),
+  error_code: import_zod29.z.string(),
+  retry_after: import_zod29.z.number().int().nullable().optional()
 });
 
 // src/_api/generated/_cfg_accounts/schemas/PasswordLoginRequest.ts
-var import_zod33 = require("zod");
-var PasswordLoginRequestSchema = import_zod33.z.object({
-  remember_me: import_zod33.z.boolean().default(false).optional(),
-  email: import_zod33.z.email(),
-  password: import_zod33.z.string()
+var import_zod30 = require("zod");
+var PasswordLoginRequestSchema = import_zod30.z.object({
+  remember_me: import_zod30.z.boolean().default(false).optional(),
+  email: import_zod30.z.email(),
+  password: import_zod30.z.string()
 });
 
+// src/_api/generated/_cfg_accounts/schemas/index.ts
+init_PasswordLoginResponse();
+
 // src/_api/generated/_cfg_accounts/schemas/PatchedCfgUserUpdateRequest.ts
-var import_zod34 = require("zod");
-var PatchedCfgUserUpdateRequestSchema = import_zod34.z.object({
-  first_name: import_zod34.z.string().max(50).optional(),
-  last_name: import_zod34.z.string().max(50).optional(),
-  company: import_zod34.z.string().max(100).optional(),
-  phone: import_zod34.z.string().max(20).optional(),
-  position: import_zod34.z.string().max(100).optional(),
-  language: import_zod34.z.string().max(10).optional(),
-  timezone: import_zod34.z.string().max(64).optional()
+var import_zod31 = require("zod");
+var PatchedCfgUserUpdateRequestSchema = import_zod31.z.object({
+  first_name: import_zod31.z.string().max(50).optional(),
+  last_name: import_zod31.z.string().max(50).optional(),
+  company: import_zod31.z.string().max(100).optional(),
+  phone: import_zod31.z.string().max(20).optional(),
+  position: import_zod31.z.string().max(100).optional(),
+  language: import_zod31.z.string().max(10).optional(),
+  timezone: import_zod31.z.string().max(64).optional()
 });
 
 // src/_api/generated/_cfg_accounts/schemas/TokenBlacklistRequest.ts
-var import_zod35 = require("zod");
-var TokenBlacklistRequestSchema = import_zod35.z.object({
-  refresh: import_zod35.z.string().min(1)
+var import_zod32 = require("zod");
+var TokenBlacklistRequestSchema = import_zod32.z.object({
+  refresh: import_zod32.z.string().min(1)
 });
 
+// src/_api/generated/_cfg_accounts/schemas/index.ts
+init_TokenRefresh();
+
 // src/_api/generated/_cfg_accounts/schemas/TokenRefreshRequest.ts
-var import_zod36 = require("zod");
-var TokenRefreshRequestSchema = import_zod36.z.object({
-  refresh: import_zod36.z.string().min(1)
+var import_zod34 = require("zod");
+var TokenRefreshRequestSchema = import_zod34.z.object({
+  refresh: import_zod34.z.string().min(1)
 });
 
+// src/_api/generated/_cfg_accounts/schemas/index.ts
+init_User();
+init_WebmailLink();
+init_WebmailLinkProviderEnum();
+init_cfg_accounts_oauth_connections_response_200_AutoRef();
+init_cfg_accounts_oauth_disconnect_response_200_AutoRef();
+
 // src/auth/context/AccountsContext.tsx
 var import_jsx_runtime = require("react/jsx-runtime");
 function hasApiOrigin() {