@djangocfg/api 2.1.322 → 2.1.331

package/src/_api/index.ts

@@ -1,23 +1,5 @@
-// Singletons + BaseClient
-export { api, apiAccounts, apiTotp, apiCentrifugo, BaseClient, LocalStorageAdapter, MemoryStorageAdapter } from './BaseClient';
-
-// cfg_accounts
-export * from './generated/cfg_accounts';
-export { Schemas, Fetchers, Enums } from './generated/cfg_accounts';
-export * as CfgAccountsTypes from './generated/cfg_accounts';
-
-// cfg_centrifugo
-export { getCentrifugoAuthTokenRetrieve } from './generated/cfg_centrifugo';
-export * as CentrifugoHooks from './generated/cfg_centrifugo/_utils/hooks';
-export * as CentrifugoFetchers from './generated/cfg_centrifugo/_utils/fetchers';
-export * as CentrifugoTypes from './generated/cfg_centrifugo/_utils/schemas';
-
-// cfg_totp
-export * as TotpHooks from './generated/cfg_totp/_utils/hooks';
-export * as TotpFetchers from './generated/cfg_totp/_utils/fetchers';
-export * as TotpTypes from './generated/cfg_totp/_utils/schemas';
-
-// API Classes
-export { API as AccountsAPI } from './generated/cfg_accounts';
-export { API as TotpAPI } from './generated/cfg_totp';
-export { API as CentrifugoAPI } from './generated/cfg_centrifugo';
+// Re-export the generated barrel directly. Per-group API singletons,
+// API classes (AccountsAPI/TotpAPI/CentrifugoAPI), and shared utilities
+// (LocalStorageAdapter / MemoryStorageAdapter / APIError / ...) all come
+// from `_api/generated/index.ts`.
+export * from './generated';

package/src/auth/context/AccountsContext.tsx

@@ -1,7 +1,7 @@
 /**
  * Accounts Context
  *
- * Manages user authentication and profile operations using generated SWR hooks
+ * Manages user authentication and profile operations using generated SWR hooks.
  *
  * Features:
  * - OTP-based authentication
@@ -17,87 +17,72 @@ import {
     createContext, ReactNode, useCallback, useContext, useEffect, useRef, useState
 } from 'react';
 
-// Import API instance and fetcher
-import { api as apiAccounts, getAccountsProfileRetrieve } from '../../';
-// Import schema
-import { PatchedUserProfileUpdateRequestSchema } from '../../_api/generated/cfg_accounts';
-// Import hooks from generated API hooks
+import { CfgAccountsApi } from '../../';
+import { Accounts, Auth, UserProfile } from '../../_api/generated/_cfg_accounts/sdk.gen';
 import {
-    useCreateAccountsOtpRequestCreate, useCreateAccountsOtpVerifyCreate,
-    useCreateAccountsProfileAvatarCreate, useCreateAccountsTokenRefreshCreate,
-    usePartialUpdateAccountsProfilePartialUpdate, useUpdateAccountsProfileUpdateUpdate
-} from '../../_api/generated/cfg_accounts/_utils/hooks';
+    useCfgAccountsOtpRequestCreate,
+    useCfgAccountsOtpVerifyCreate,
+    useCfgAccountsProfileAvatarCreate,
+    useCfgAccountsProfilePartialUpdate,
+    useCfgAccountsProfileUpdateUpdate,
+    useCfgAccountsTokenRefreshCreate,
+} from '../../_api/generated/_cfg_accounts/hooks';
+import { PatchedCfgUserUpdateRequestSchema } from '../../_api/generated/_cfg_accounts/schemas';
 import { clearProfileCache, getCachedProfile, setCachedProfile } from '../hooks/useProfileCache';
 import { authLogger } from '../utils/logger';
 
-// Import types from generated API
 import type {
-  User,
-  UserProfileUpdateRequest,
-  PatchedUserProfileUpdateRequest,
-  OTPRequestRequest,
-  OTPVerifyRequest,
-  OTPRequestResponse,
-  OTPVerifyResponse,
-  TokenRefresh,
-  API,
-} from '../../_api/generated/cfg_accounts';
-// Re-export schemas for external use
-export { PatchedUserProfileUpdateRequestSchema };
-export type { PatchedUserProfileUpdateRequest };
+    User,
+    CfgUserUpdateRequest,
+    PatchedCfgUserUpdateRequest,
+    OtpRequestRequest,
+    OtpVerifyRequest,
+    OtpRequestResponse,
+    OtpVerifyResponse,
+    TokenRefresh,
+    TokenRefreshRequest,
+} from '../../_api/generated/_cfg_accounts/types.gen';
+
+export { PatchedCfgUserUpdateRequestSchema };
+export type { PatchedCfgUserUpdateRequest, User, CfgUserUpdateRequest as UserProfileUpdateRequest };
 
 // ─────────────────────────────────────────────────────────────────────────
 // Context Type
 // ─────────────────────────────────────────────────────────────────────────
 
 export interface AccountsContextValue {
-  // Current user profile
   profile?: User;
   isLoadingProfile: boolean;
   profileError: Error | null;
 
-  // Profile operations
-  updateProfile: (data: UserProfileUpdateRequest) => Promise<User>;
-  partialUpdateProfile: (data: PatchedUserProfileUpdateRequest) => Promise<User>;
+  updateProfile: (data: CfgUserUpdateRequest) => Promise<User>;
+  partialUpdateProfile: (data: PatchedCfgUserUpdateRequest) => Promise<User>;
   uploadAvatar: (avatar: File | Blob) => Promise<User>;
   refreshProfile: (options?: { callerId?: string; force?: boolean }) => Promise<User | undefined>;
 
-  // Authentication
-  requestOTP: (data: OTPRequestRequest) => Promise<OTPRequestResponse>;
-  verifyOTP: (data: OTPVerifyRequest) => Promise<OTPVerifyResponse>;
+  requestOTP: (data: OtpRequestRequest) => Promise<OtpRequestResponse>;
+  verifyOTP: (data: OtpVerifyRequest) => Promise<OtpVerifyResponse>;
   refreshToken: (refresh: string) => Promise<TokenRefresh>;
   logout: () => void;
 }
 
-// ─────────────────────────────────────────────────────────────────────────
-// Context
-// ─────────────────────────────────────────────────────────────────────────
-
 const AccountsContext = createContext<AccountsContextValue | undefined>(undefined);
 
-// ─────────────────────────────────────────────────────────────────────────
-// Provider Component
-// ─────────────────────────────────────────────────────────────────────────
-
 interface AccountsProviderProps {
   children: ReactNode;
 }
 
 export function AccountsProvider({ children }: AccountsProviderProps) {
-  // State management with localStorage cache
   const [profile, setProfile] = useState<User | undefined>(() => {
-    // Initialize from cache on mount
-    const cached = getCachedProfile();
+    const cached = getCachedProfile() as User | null;
     return cached || undefined;
   });
   const [isLoadingProfile, setIsLoadingProfile] = useState(false);
   const [profileError, setProfileError] = useState<Error | null>(null);
 
-  // Use refs to access current state without adding to dependencies
   const profileRef = useRef<User | undefined>(profile);
   const isLoadingRef = useRef(false);
 
-  // Keep refs in sync with state
   useEffect(() => {
     profileRef.current = profile;
   }, [profile]);
@@ -106,21 +91,17 @@ export function AccountsProvider({ children }: AccountsProviderProps) {
     isLoadingRef.current = isLoadingProfile;
   }, [isLoadingProfile]);
 
-  // Mutation hooks
-  const updateMutation = useUpdateAccountsProfileUpdateUpdate();
-  const partialUpdateMutation = usePartialUpdateAccountsProfilePartialUpdate();
-  const avatarMutation = useCreateAccountsProfileAvatarCreate();
-  const otpRequestMutation = useCreateAccountsOtpRequestCreate();
-  const otpVerifyMutation = useCreateAccountsOtpVerifyCreate();
-  const tokenRefreshMutation = useCreateAccountsTokenRefreshCreate();
+  const { trigger: triggerProfileUpdate } = useCfgAccountsProfileUpdateUpdate();
+  const { trigger: triggerProfilePartialUpdate } = useCfgAccountsProfilePartialUpdate();
+  const { trigger: triggerAvatar } = useCfgAccountsProfileAvatarCreate();
+  const { trigger: triggerOtpRequest } = useCfgAccountsOtpRequestCreate();
+  const { trigger: triggerOtpVerify } = useCfgAccountsOtpVerifyCreate();
+  const { trigger: triggerTokenRefresh } = useCfgAccountsTokenRefreshCreate();
 
-  // Refresh profile - fetch from API and update cache
   const refreshProfile = useCallback(async (options?: { callerId?: string; force?: boolean }): Promise<User | undefined> => {
     const { callerId, force } = options || {};
-    const currentLoading = isLoadingRef.current;
 
-    // Prevent duplicate concurrent calls
-    if (currentLoading) {
+    if (isLoadingRef.current) {
       authLogger.debug(`Profile loading in progress, skipping (caller: ${callerId})`);
       return profileRef.current;
     }
@@ -130,7 +111,8 @@ export function AccountsProvider({ children }: AccountsProviderProps) {
     setProfileError(null);
     try {
       authLogger.debug(`Fetching profile from API (caller: ${callerId}, force: ${force})`);
-      const result = await getAccountsProfileRetrieve(apiAccounts);
+      const res = await UserProfile.cfgAccountsProfileRetrieve({ throwOnError: true });
+      const result = res.data;
       setProfile(result);
       profileRef.current = result;
       setCachedProfile(result);
@@ -145,48 +127,40 @@ export function AccountsProvider({ children }: AccountsProviderProps) {
     }
   }, []);
 
-  // Update profile (full) - then reload from API
-  const updateProfile = async (data: UserProfileUpdateRequest): Promise<User> => {
-    await updateMutation(data, apiAccounts);
+  const updateProfile = async (data: CfgUserUpdateRequest): Promise<User> => {
+    await triggerProfileUpdate({ body: data });
     const user = await refreshProfile({ callerId: 'updateProfile', force: true });
     return user as User;
   };
 
-  // Partial update profile - then reload from API
-  const partialUpdateProfile = async (data: PatchedUserProfileUpdateRequest): Promise<User> => {
-    await partialUpdateMutation(data, apiAccounts);
+  const partialUpdateProfile = async (data: PatchedCfgUserUpdateRequest): Promise<User> => {
+    await triggerProfilePartialUpdate({ body: data });
     const user = await refreshProfile({ callerId: 'partialUpdateProfile', force: true });
     return user as User;
   };
 
-  // Upload avatar - then reload from API
   const uploadAvatar = async (avatar: File | Blob): Promise<User> => {
-    await avatarMutation({ avatar }, apiAccounts);
+    await triggerAvatar({ body: { avatar } });
     const user = await refreshProfile({ callerId: 'uploadAvatar', force: true });
     return user as User;
   };
 
-  // Request OTP
-  const requestOTP = async (data: OTPRequestRequest): Promise<OTPRequestResponse> => {
-    const result = await otpRequestMutation(data, apiAccounts);
-    return result as OTPRequestResponse;
+  const requestOTP = async (data: OtpRequestRequest): Promise<OtpRequestResponse> => {
+    const result = await triggerOtpRequest({ body: data });
+    return result as OtpRequestResponse;
   };
 
-  // Verify OTP
-  const verifyOTP = async (data: OTPVerifyRequest): Promise<OTPVerifyResponse> => {
-    const result = await otpVerifyMutation(data, apiAccounts);
+  const verifyOTP = async (data: OtpVerifyRequest): Promise<OtpVerifyResponse> => {
+    const result = (await triggerOtpVerify({ body: data })) as OtpVerifyResponse;
 
-    // Check if 2FA is required - don't save tokens yet
     if (result.requires_2fa && result.session_id) {
       authLogger.info('2FA required, session:', result.session_id);
-      // Return result without saving tokens - caller handles 2FA step
-      return result as OTPVerifyResponse;
+      return result;
     }
 
-    // Normal flow - save tokens after successful verification
     if (result.access && result.refresh) {
-      apiAccounts.setToken(result.access, result.refresh);
-      // Refresh profile — don't let profile fetch error kill the whole verification
+      CfgAccountsApi.setToken(result.access);
+      CfgAccountsApi.setRefreshToken(result.refresh);
       try {
         await refreshProfile({ callerId: 'verifyOTP', force: true });
       } catch (profileError) {
@@ -194,24 +168,23 @@ export function AccountsProvider({ children }: AccountsProviderProps) {
       }
     }
 
-    return result as OTPVerifyResponse;
+    return result;
   };
 
-  // Refresh token
   const refreshToken = async (refresh: string): Promise<TokenRefresh> => {
-    const result = await tokenRefreshMutation({ refresh }, apiAccounts);
+    const body: TokenRefreshRequest = { refresh };
+    const result = (await triggerTokenRefresh({ body })) as TokenRefresh;
 
-    // Automatically save new access token
     if (result.access) {
-      apiAccounts.setToken(result.access, refresh);
+      CfgAccountsApi.setToken(result.access);
+      CfgAccountsApi.setRefreshToken(refresh);
     }
 
-    return result as TokenRefresh;
+    return result;
   };
 
-  // Logout - clear tokens, profile state, and cache
   const logout = useCallback(() => {
-    apiAccounts.clearTokens();
+    CfgAccountsApi.clearToken();
     setProfile(undefined);
     setProfileError(null);
     clearProfileCache();
@@ -238,10 +211,6 @@ export function AccountsProvider({ children }: AccountsProviderProps) {
   );
 }
 
-// ─────────────────────────────────────────────────────────────────────────
-// Hook
-// ─────────────────────────────────────────────────────────────────────────
-
 export function useAccountsContext(): AccountsContextValue {
   const context = useContext(AccountsContext);
   if (!context) {

package/src/auth/context/AuthContext.tsx

@@ -11,7 +11,7 @@ import { SWRConfig } from 'swr';
 import { useCfgRouter, useLocalStorage, useQueryParams } from '../hooks';
 
 import { api as apiAccounts } from '../../';
-import { APIError } from '../../_api/generated/cfg_accounts/errors';
+import { APIError } from '../../_api/generated/helpers';
 import { clearProfileCache, getCachedProfile } from '../hooks/useProfileCache';
 import { useAuthRedirectManager } from '../hooks/useAuthRedirect';
 import { useTokenRefresh } from '../hooks/useTokenRefresh';
@@ -101,7 +101,7 @@ const AuthProviderInternal: React.FC<AuthProviderProps> = ({ children, config })
   // Common function to clear auth state
   const clearAuthState = useCallback((caller: string) => {
     authLogger.info('clearAuthState >> caller', caller);
-    apiAccounts.clearTokens();
+    apiAccounts.clearToken();
     clearProfileCache(); // Clear profile cache from localStorage
     // Note: user is now managed by AccountsContext, will auto-update
     setInitialized(true);
@@ -354,7 +354,7 @@ const AuthProviderInternal: React.FC<AuthProviderProps> = ({ children, config })
   const requestOTP = useCallback(
     async (identifier: string, sourceUrl?: string): Promise<{ success: boolean; message: string; statusCode?: number; retryAfter?: number }> => {
       // Clear tokens before requesting OTP
-      apiAccounts.clearTokens();
+      apiAccounts.clearToken();
 
       try {
         const result = await accounts.requestOTP({

package/src/auth/context/index.ts

@@ -1,4 +1,4 @@
 export { AuthProvider, useAuth } from './AuthContext';
 export type { AuthConfig, AuthContextType, AuthProviderProps, UserProfile } from './types';
-export { AccountsProvider, useAccountsContext, PatchedUserProfileUpdateRequestSchema } from './AccountsContext';
-export type { AccountsContextValue, PatchedUserProfileUpdateRequest } from './AccountsContext'; 
+export { AccountsProvider, useAccountsContext, PatchedCfgUserUpdateRequestSchema } from './AccountsContext';
+export type { AccountsContextValue, PatchedCfgUserUpdateRequest } from './AccountsContext'; 

package/src/auth/hooks/useDeleteAccount.ts

@@ -3,6 +3,7 @@
 import { useCallback, useState } from 'react';
 
 import { apiAccounts } from '../../clients';
+import { UserProfile } from '../../_api/generated/sdk.gen';
 import { useAuth } from '../context';
 import { authLogger } from '../utils/logger';
 
@@ -60,7 +61,8 @@ export const useDeleteAccount = (): UseDeleteAccountReturn => {
     try {
       authLogger.info('Deleting account...');
 
-      const response = await apiAccounts.user_profile.accountsProfileDeleteCreate();
+      const result = await UserProfile.cfgAccountsProfileDeleteCreate({ throwOnError: true });
+      const response = result.data;
 
       if (!response.success) {
         authLogger.error('Failed to delete account:', response.message);

package/src/auth/hooks/useGithubAuth.ts

@@ -3,6 +3,7 @@
 import { useCallback, useState } from 'react';
 
 import { apiAccounts } from '../../clients';
+import { OAuth } from '../../_api/generated/sdk.gen';
 import { Analytics, AnalyticsCategory, AnalyticsEvent } from '../utils/analytics';
 import { authLogger } from '../utils/logger';
 import { useCfgRouter } from './useCfgRouter';
@@ -69,9 +70,13 @@ export const useGithubAuth = (options: UseGithubAuthOptions = {}): UseGithubAuth
 
       // Call API to get authorization URL
       // The API will auto-generate redirect_uri from config if not provided
-      const response = await apiAccounts.oauth.accountsOauthGithubAuthorizeCreate({
-        source_url: sourceUrl || (typeof window !== 'undefined' ? window.location.href : ''),
+      const result = await OAuth.cfgAccountsOauthGithubAuthorizeCreate({
+        body: {
+          source_url: sourceUrl || (typeof window !== 'undefined' ? window.location.href : ''),
+        },
+        throwOnError: true,
       });
+      const response = result.data;
 
       if (!response.authorization_url) {
         throw new Error('Failed to get authorization URL');
@@ -79,13 +84,11 @@ export const useGithubAuth = (options: UseGithubAuthOptions = {}): UseGithubAuth
 
       authLogger.info('Redirecting to GitHub...', response.authorization_url);
 
-      // Store state in sessionStorage for verification on callback
       if (typeof window !== 'undefined') {
         sessionStorage.setItem('oauth_state', response.state);
         sessionStorage.setItem('oauth_provider', 'github');
       }
 
-      // Redirect to GitHub
       window.location.href = response.authorization_url;
 
     } catch (err) {
@@ -128,12 +131,11 @@ export const useGithubAuth = (options: UseGithubAuthOptions = {}): UseGithubAuth
         sessionStorage.removeItem('oauth_provider');
       }
 
-      // Exchange code for tokens
-      // The API will auto-generate redirect_uri from config if not provided
-      const response = await apiAccounts.oauth.accountsOauthGithubCallbackCreate({
-        code,
-        state,
+      const result = await OAuth.cfgAccountsOauthGithubCallbackCreate({
+        body: { code, state },
+        throwOnError: true,
       });
+      const response = result.data;
 
       // Check if 2FA is required
       if (response.requires_2fa && response.session_id) {
@@ -156,8 +158,8 @@ export const useGithubAuth = (options: UseGithubAuthOptions = {}): UseGithubAuth
 
       authLogger.info('GitHub OAuth successful, user:', response.user);
 
-      // Save tokens using API client
-      apiAccounts.setToken(response.access, response.refresh);
+      apiAccounts.setToken(response.access);
+      apiAccounts.setRefreshToken(response.refresh);
 
       // Track successful OAuth
       Analytics.event(AnalyticsEvent.AUTH_LOGIN_SUCCESS, {

package/src/auth/hooks/useTokenRefresh.ts

@@ -12,6 +12,7 @@
 import { useCallback, useEffect, useRef } from 'react';
 
 import { api as apiAccounts } from '../../';
+import { Auth } from '../../_api/generated/sdk.gen';
 import { authLogger } from '../utils/logger';
 
 // Configuration
@@ -77,17 +78,19 @@ export function useTokenRefresh(options: UseTokenRefreshOptions = {}) {
 
     try {
       // Use generated API client with correct URL (/cfg/accounts/token/refresh/)
-      const result = await apiAccounts.auth.accountsTokenRefreshCreate({
-        refresh: refreshTokenValue,
+      const result = await Auth.cfgAccountsTokenRefreshCreate({
+        body: { refresh: refreshTokenValue },
+        throwOnError: true,
       });
 
-      const newAccessToken = result.access;
+      const newAccessToken = result.data.access;
 
       if (!newAccessToken) {
         throw new Error('No access token in refresh response');
       }
 
-      apiAccounts.setToken(newAccessToken, refreshTokenValue);
+      apiAccounts.setToken(newAccessToken);
+      apiAccounts.setRefreshToken(refreshTokenValue);
       authLogger.info('Token refreshed successfully');
 
       onRefresh?.(newAccessToken);

package/src/auth/hooks/useTwoFactor.ts

@@ -3,7 +3,8 @@
 import { useCallback, useState } from 'react';
 
 import { apiAccounts, apiTotp } from '../../clients';
-import { APIError } from '../../_api/generated/cfg_totp/errors';
+import { APIError } from '../../_api/generated/helpers';
+import { TotpVerification } from '../../_api/generated/sdk.gen';
 import { Analytics, AnalyticsCategory, AnalyticsEvent } from '../utils/analytics';
 import { authLogger } from '../utils/logger';
 import { useCfgRouter } from './useCfgRouter';
@@ -88,7 +89,8 @@ export const useTwoFactor = (options: UseTwoFactorOptions = {}): UseTwoFactorRet
     remaining_backup_codes?: number;
   }) => {
     // Save tokens
-    apiAccounts.setToken(response.access_token, response.refresh_token);
+    apiAccounts.setToken(response.access_token);
+    apiAccounts.setRefreshToken(response.refresh_token);
 
     // Set warning if any
     if (response.warning) {
@@ -146,10 +148,11 @@ export const useTwoFactor = (options: UseTwoFactorOptions = {}): UseTwoFactorRet
     try {
       authLogger.info('Verifying TOTP code...');
 
-      const response = await apiTotp.totp_verification.totpVerifyCreate({
-        session_id: sessionId,
-        code,
+      const result = await TotpVerification.cfgTotpVerifyCreate({
+        body: { session_id: sessionId, code },
+        throwOnError: true,
       });
+      const response = result.data;
 
       if (!response.access_token || !response.refresh_token) {
         throw new Error('Invalid response from 2FA verification');
@@ -205,10 +208,14 @@ export const useTwoFactor = (options: UseTwoFactorOptions = {}): UseTwoFactorRet
     try {
       authLogger.info('Verifying backup code...');
 
-      const response = await apiTotp.totp_verification.totpVerifyBackupCreate({
-        session_id: sessionId,
-        backup_code: backupCode.replace(/\s+/g, ''), // Remove spaces
+      const result = await TotpVerification.cfgTotpVerifyBackupCreate({
+        body: {
+          session_id: sessionId,
+          backup_code: backupCode.replace(/\s+/g, ''),
+        },
+        throwOnError: true,
       });
+      const response = result.data;
 
       if (!response.access_token || !response.refresh_token) {
         throw new Error('Invalid response from backup code verification');

package/src/auth/hooks/useTwoFactorSetup.ts

@@ -3,6 +3,7 @@
 import { useCallback, useState } from 'react';
 
 import { apiTotp } from '../../clients';
+import { TotpSetup } from '../../_api/generated/sdk.gen';
 import { authLogger } from '../utils/logger';
 
 export interface TwoFactorSetupData {
@@ -115,9 +116,11 @@ export const useTwoFactorSetup = (options: UseTwoFactorSetupOptions = {}): UseTw
     try {
       authLogger.info('Starting 2FA setup...');
 
-      const response = await apiTotp.totp_setup.create({
-        device_name: deviceName,
+      const result = await TotpSetup.cfgTotpSetupCreate({
+        body: { device_name: deviceName },
+        throwOnError: true,
       });
+      const response = result.data;
 
       const data: TwoFactorSetupData = {
         deviceId: response.device_id,
@@ -169,10 +172,11 @@ export const useTwoFactorSetup = (options: UseTwoFactorSetupOptions = {}): UseTw
     try {
       authLogger.info('Confirming 2FA setup...');
 
-      const response = await apiTotp.totp_setup.confirmCreate({
-        device_id: setupData.deviceId,
-        code,
+      const result = await TotpSetup.cfgTotpSetupConfirmCreate({
+        body: { device_id: setupData.deviceId, code },
+        throwOnError: true,
       });
+      const response = result.data;
 
       const codes = response.backup_codes;
       setBackupCodes(codes);

package/src/auth/hooks/useTwoFactorStatus.ts

@@ -3,7 +3,8 @@
 import { useCallback, useState } from 'react';
 
 import { apiTotp } from '../../clients';
-import { APIError } from '../../_api/generated/cfg_totp';
+import { APIError } from '../../_api/generated/helpers';
+import { TotpManagement } from '../../_api/generated/sdk.gen';
 import { authLogger } from '../utils/logger';
 
 export interface TwoFactorDevice {
@@ -82,7 +83,8 @@ export const useTwoFactorStatus = (): UseTwoFactorStatusReturn => {
       authLogger.info('Fetching 2FA status...');
 
       // API returns { devices: [...], has_2fa_enabled: bool }
-      const response = await apiTotp.totp_management.totpDevicesRetrieve();
+      const result = await TotpManagement.cfgTotpDevicesRetrieve({ throwOnError: true });
+      const response = result.data;
 
       const mappedDevices: TwoFactorDevice[] = response.devices.map((device) => ({
         id: device.id,
@@ -121,7 +123,7 @@ export const useTwoFactorStatus = (): UseTwoFactorStatusReturn => {
     try {
       authLogger.info('Disabling 2FA...');
 
-      await apiTotp.totp_management.totpDisableCreate({ code });
+      await TotpManagement.cfgTotpDisableCreate({ body: { code }, throwOnError: true });
 
       setHas2FAEnabled(false);
       setDevices([]);

package/src/auth/middlewares/tokenRefresh.ts

@@ -6,6 +6,7 @@
  */
 
 import { api as apiAccounts } from '../../';
+import { Auth } from '../../_api/generated/sdk.gen';
 import { authLogger } from '../utils/logger';
 
 // Refresh state management
@@ -51,11 +52,12 @@ export async function refreshAccessToken(): Promise<string | null> {
     }
 
     // Use generated API client with correct URL (/cfg/accounts/token/refresh/)
-    const result = await apiAccounts.auth.accountsTokenRefreshCreate({
-      refresh: refreshToken,
+    const result = await Auth.cfgAccountsTokenRefreshCreate({
+      body: { refresh: refreshToken },
+      throwOnError: true,
     });
 
-    const newAccessToken = result.access;
+    const newAccessToken = result.data.access;
 
     if (!newAccessToken) {
       authLogger.error('Token refresh response missing access token');
@@ -64,7 +66,8 @@ export async function refreshAccessToken(): Promise<string | null> {
     }
 
     // Update tokens in storage
-    apiAccounts.setToken(newAccessToken, refreshToken);
+    apiAccounts.setToken(newAccessToken);
+    apiAccounts.setRefreshToken(refreshToken);
     authLogger.info('Token refreshed successfully');
 
     onTokenRefreshed(newAccessToken);