@djangocfg/api 2.1.322 → 2.1.327

package/src/_api/generated/cfg_centrifugo/index.ts

@@ -1,316 +1,29 @@
-// @ts-nocheck
-// Auto-generated by DjangoCFG - see CLAUDE.md
-/**
- * Django CFG API - API Client with JWT Management
- *
- * Usage:
- * ```typescript
- * import { API } from './api';
- *
- * const api = new API('https://api.example.com');
- *
- * // Set JWT token
- * api.setToken('your-jwt-token', 'refresh-token');
- *
- * // Use API
- * const posts = await api.posts.list();
- * const user = await api.users.retrieve(1);
- *
- * // Check authentication
- * if (api.isAuthenticated()) {
- *   // ...
- * }
- *
- * // Custom storage with logging (for Electron/Node.js)
- * import { MemoryStorageAdapter, APILogger } from './storage';
- * const logger = new APILogger({ enabled: true, logLevel: 'debug' });
- * const api = new API('https://api.example.com', {
- *   storage: new MemoryStorageAdapter(logger),
- *   loggerConfig: { enabled: true, logLevel: 'debug' }
- * });
- *
- * // Get OpenAPI schema
- * const schema = api.getSchema();
- * ```
- */
+// AUTO-GENERATED by django_generator / ts_extras.wrapper
+// Group barrel. DO NOT EDIT — re-run `make gen`.
 
-import { APIClient } from "./client";
-import {
-  StorageAdapter,
-  LocalStorageAdapter,
-  CookieStorageAdapter,
-  MemoryStorageAdapter
-} from "./storage";
-import type { RetryConfig } from "./retry";
-import type { LoggerConfig } from "./logger";
-import { APILogger } from "./logger";
-import { CentrifugoAuth } from "./centrifugo__centrifugo_auth/client";
-export * as CentrifugoAuthTypes from "./centrifugo__centrifugo_auth/models";
-// Note: Direct exports (export * from) are removed to avoid duplicate type conflicts
-// Use namespace exports like CfgAccountsTypes.User or import from specific modules
-
-// Re-export Zod schemas for runtime validation
-export * as Schemas from "./_utils/schemas";
-// Also export all schemas directly for convenience
-export * from "./_utils/schemas";
+// Wrapper class + per-group SDK re-exports
+export { API, type APIOptions, Cfg, Centrifugo, CentrifugoAuth } from './api';
 
-// Re-export Zod validation events for browser integration
-export type { ValidationErrorDetail, ValidationErrorEvent } from "./validation-events";
-export { dispatchValidationError, onValidationError, formatZodError } from "./validation-events";
-
-// Re-export typed fetchers for universal usage
-export * as Fetchers from "./_utils/fetchers";
-export * from "./_utils/fetchers";
-
-// Re-export API instance configuration functions
+// Shared utilities (storage / errors / logger / validation events)
 export {
-  configureAPI,
-  getAPIInstance,
-  reconfigureAPI,
-  clearAPITokens,
-  resetAPI,
-  isAPIConfigured
-} from "./api-instance";
-// NOTE: SWR hooks are generated in ./_utils/hooks/ but NOT exported here to keep
-// the main bundle server-safe. Import hooks directly from the hooks directory:
-//   import { useUsers } from './_utils/hooks';
-// Or use a separate entry point like '@djangocfg/api/hooks' for client components.
-
-// Re-export core client
-export { APIClient };
-
-// Re-export storage adapters for convenience
-export type { StorageAdapter };
-export { LocalStorageAdapter, CookieStorageAdapter, MemoryStorageAdapter };
-
-// Re-export error classes for convenience
-export { APIError, NetworkError } from "./errors";
-
-// Re-export HTTP adapters for custom implementations
-export type { HttpClientAdapter, HttpRequest, HttpResponse } from "./http";
-export { FetchAdapter, KeepAliveFetchAdapter } from "./http";
-
-// Re-export logger types and classes
-export type { LoggerConfig, RequestLog, ResponseLog, ErrorLog } from "./logger";
-export { APILogger } from "./logger";
-
-// Re-export retry configuration and utilities
-export type { RetryConfig, FailedAttemptInfo } from "./retry";
-export { withRetry, shouldRetry, DEFAULT_RETRY_CONFIG } from "./retry";
-
-export const TOKEN_KEY = "auth_token";
-export const REFRESH_TOKEN_KEY = "refresh_token";
-
-/** Auto-detect locale from cookie NEXT_LOCALE or navigator.language */
-function detectLocale(): string | null {
-  try {
-    if (typeof document !== 'undefined') {
-      const match = document.cookie.match(/(?:^|;\s*)NEXT_LOCALE=([^;]*)/);
-      if (match) return match[1];
-    }
-    if (typeof navigator !== 'undefined' && navigator.language) {
-      return navigator.language;
-    }
-  } catch {}
-  return null;
-}
-
-export interface APIOptions {
-  /** Custom storage adapter (defaults to LocalStorageAdapter) */
-  storage?: StorageAdapter;
-  /** Custom HTTP client adapter (defaults to FetchAdapter) */
-  httpClient?: HttpClientAdapter;
-  /** Retry configuration for failed requests */
-  retryConfig?: RetryConfig;
-  /** Logger configuration */
-  loggerConfig?: Partial<LoggerConfig>;
-  /** Locale for Accept-Language header (e.g. 'en', 'ko', 'ru') */
-  locale?: string;
-}
-
-export class API {
-  private baseUrl: string;
-  private _client: APIClient;
-  private _token: string | null = null;
-  private _refreshToken: string | null = null;
-  private _locale: string | null = null;
-  private storage: StorageAdapter;
-  private options?: APIOptions;
-
-  // Sub-clients
-  public centrifugo_auth!: CentrifugoAuth;
-
-  constructor(baseUrl: string, options?: APIOptions) {
-    this.baseUrl = baseUrl;
-    this.options = options;
-
-    // Create logger if config provided
-    const logger = options?.loggerConfig ? new APILogger(options.loggerConfig) : undefined;
-
-    // Initialize storage with logger
-    this.storage = options?.storage || new LocalStorageAdapter(logger);
-
-    this._locale = options?.locale || null;
-
-    this._loadTokensFromStorage();
-
-    // Initialize APIClient with token getter for URL authentication
-    this._client = new APIClient(this.baseUrl, {
-      httpClient: this.options?.httpClient,
-      retryConfig: this.options?.retryConfig,
-      loggerConfig: this.options?.loggerConfig,
-      tokenGetter: () => this.getToken(),
-    });
-
-    // Always inject auth header wrapper (reads token dynamically from storage)
-    this._injectAuthHeader();
-
-    // Initialize sub-clients from APIClient
-    this.centrifugo_auth = this._client.centrifugo_auth;
-  }
-
-  private _loadTokensFromStorage(): void {
-    this._token = this.storage.getItem(TOKEN_KEY);
-    this._refreshToken = this.storage.getItem(REFRESH_TOKEN_KEY);
-  }
-
-  private _reinitClients(): void {
-    this._client = new APIClient(this.baseUrl, {
-      httpClient: this.options?.httpClient,
-      retryConfig: this.options?.retryConfig,
-      loggerConfig: this.options?.loggerConfig,
-      tokenGetter: () => this.getToken(),
-    });
-
-    // Always inject auth header wrapper (reads token dynamically from storage)
-    this._injectAuthHeader();
-
-    // Reinitialize sub-clients
-    this.centrifugo_auth = this._client.centrifugo_auth;
-  }
-
-  private _injectAuthHeader(): void {
-    // Override request method to inject auth header
-    const originalRequest = this._client.request.bind(this._client);
-    this._client.request = async <T>(
-      method: string,
-      path: string,
-      options?: { params?: Record<string, any>; body?: any; formData?: FormData; headers?: Record<string, string> }
-    ): Promise<T> => {
-      // Read token from storage dynamically (supports JWT injection after instantiation)
-      const token = this.getToken();
-      const locale = this._locale || detectLocale();
-      const mergedOptions = {
-        ...options,
-        headers: {
-          ...(options?.headers || {}),
-          ...(token ? { 'Authorization': `Bearer ${token}` } : {}),
-          ...(locale ? { 'Accept-Language': locale } : {}),
-        },
-      };
-
-      return originalRequest(method, path, mergedOptions);
-    };
-  }
-
-  /**
-   * Get current JWT token
-   */
-  getToken(): string | null {
-    return this.storage.getItem(TOKEN_KEY);
-  }
-
-  /**
-   * Get current refresh token
-   */
-  getRefreshToken(): string | null {
-    return this.storage.getItem(REFRESH_TOKEN_KEY);
-  }
-
-  /**
-   * Set JWT token and refresh token
-   * @param token - JWT access token
-   * @param refreshToken - JWT refresh token (optional)
-   */
-  setToken(token: string, refreshToken?: string): void {
-    this._token = token;
-    this.storage.setItem(TOKEN_KEY, token);
-
-    if (refreshToken) {
-      this._refreshToken = refreshToken;
-      this.storage.setItem(REFRESH_TOKEN_KEY, refreshToken);
-    }
-
-    // Reinitialize clients with new token
-    this._reinitClients();
-  }
-
-  /**
-   * Clear all tokens
-   */
-  clearTokens(): void {
-    this._token = null;
-    this._refreshToken = null;
-    this.storage.removeItem(TOKEN_KEY);
-    this.storage.removeItem(REFRESH_TOKEN_KEY);
-
-    // Reinitialize clients without token
-    this._reinitClients();
-  }
-
-  /**
-   * Check if user is authenticated
-   */
-  isAuthenticated(): boolean {
-    return !!this.getToken();
-  }
-
-  /**
-   * Update base URL and reinitialize clients
-   * @param url - New base URL
-   */
-  setBaseUrl(url: string): void {
-    this.baseUrl = url;
-    this._reinitClients();
-  }
-
-  /**
-   * Get current base URL
-   */
-  getBaseUrl(): string {
-    return this.baseUrl;
-  }
-
-  /**
-   * Set locale for Accept-Language header
-   * @param locale - Locale string (e.g. 'en', 'ko', 'ru') or null to clear
-   */
-  setLocale(locale: string | null): void {
-    this._locale = locale;
-  }
-
-  /**
-   * Get current locale
-   */
-  getLocale(): string | null {
-    return this._locale;
-  }
-
-  /**
-   * Get OpenAPI schema path
-   * @returns Path to the OpenAPI schema JSON file
-   *
-   * Note: The OpenAPI schema is available in the schema.json file.
-   * You can load it dynamically using:
-   * ```typescript
-   * const schema = await fetch('./schema.json').then(r => r.json());
-   * // or using fs in Node.js:
-   * // const schema = JSON.parse(fs.readFileSync('./schema.json', 'utf-8'));
-   * ```
-   */
-  getSchemaPath(): string {
-    return './schema.json';
-  }
-}
-
-export default API;
+  type StorageAdapter,
+  LocalStorageAdapter,
+  MemoryStorageAdapter,
+  CookieStorageAdapter,
+  APIError,
+  NetworkError,
+  APILogger,
+  defaultLogger,
+  type LoggerConfig,
+  type RequestLog,
+  type ResponseLog,
+  type ErrorLog,
+  dispatchValidationError,
+  onValidationError,
+  formatZodError,
+  type ValidationErrorDetail,
+  type ValidationErrorEvent,
+} from '../_shared';
+
+// Generated artifacts (Hey API)
+export type * from './types.gen';

package/src/_api/generated/cfg_centrifugo/schemas/ConnectionTokenResponse.ts

@@ -0,0 +1,14 @@
+// AUTO-GENERATED by django-cfg / django_generator.ts_extras
+// Source: OpenAPI 3.1 components.schemas
+// DO NOT EDIT — re-run `make gen`.
+
+import { z } from "zod";
+
+export const ConnectionTokenResponseSchema = z.object({
+  token: z.string(),
+  centrifugo_url: z.string(),
+  expires_at: z.string(),
+  channels: z.array(z.string()),
+});
+
+export type ConnectionTokenResponse = z.infer<typeof ConnectionTokenResponseSchema>;

package/src/_api/generated/cfg_centrifugo/schemas/index.ts

@@ -0,0 +1,4 @@
+// AUTO-GENERATED — barrel for zod schemas.
+// DO NOT EDIT.
+
+export * from "./ConnectionTokenResponse";

package/src/_api/generated/cfg_centrifugo/sdk.gen.ts

@@ -0,0 +1,64 @@
+// This file is auto-generated by @hey-api/openapi-ts
+
+import type { Client, Options as Options2, TDataShape } from './client';
+import { client } from './client.gen';
+import type { CfgCentrifugoAuthTokenRetrieveData, CfgCentrifugoAuthTokenRetrieveErrors, CfgCentrifugoAuthTokenRetrieveResponses } from './types.gen';
+
+export type Options<TData extends TDataShape = TDataShape, ThrowOnError extends boolean = boolean, TResponse = unknown> = Options2<TData, ThrowOnError, TResponse> & {
+    /**
+     * You can provide a client instance returned by `createClient()` instead of
+     * individual options. This might be also useful if you want to implement a
+     * custom client.
+     */
+    client?: Client;
+    /**
+     * You can pass arbitrary values through the `meta` object. This can be
+     * used to access values that aren't defined as part of the SDK function.
+     */
+    meta?: Record<string, unknown>;
+};
+
+export class Cfg {
+    /**
+     * Get Centrifugo connection token
+     *
+     * Generate JWT token for WebSocket connection to Centrifugo. Token includes user's allowed channels based on their permissions. Requires authentication.
+     */
+    public static cfgCentrifugoAuthTokenRetrieve<ThrowOnError extends boolean = false>(options?: Options<CfgCentrifugoAuthTokenRetrieveData, ThrowOnError>) {
+        return (options?.client ?? client).get<CfgCentrifugoAuthTokenRetrieveResponses, CfgCentrifugoAuthTokenRetrieveErrors, ThrowOnError>({
+            security: [{ scheme: 'bearer', type: 'http' }],
+            url: '/cfg/centrifugo/auth/token/',
+            ...options
+        });
+    }
+}
+
+export class Centrifugo {
+    /**
+     * Get Centrifugo connection token
+     *
+     * Generate JWT token for WebSocket connection to Centrifugo. Token includes user's allowed channels based on their permissions. Requires authentication.
+     */
+    public static cfgCentrifugoAuthTokenRetrieve<ThrowOnError extends boolean = false>(options?: Options<CfgCentrifugoAuthTokenRetrieveData, ThrowOnError>) {
+        return (options?.client ?? client).get<CfgCentrifugoAuthTokenRetrieveResponses, CfgCentrifugoAuthTokenRetrieveErrors, ThrowOnError>({
+            security: [{ scheme: 'bearer', type: 'http' }],
+            url: '/cfg/centrifugo/auth/token/',
+            ...options
+        });
+    }
+}
+
+export class CentrifugoAuth {
+    /**
+     * Get Centrifugo connection token
+     *
+     * Generate JWT token for WebSocket connection to Centrifugo. Token includes user's allowed channels based on their permissions. Requires authentication.
+     */
+    public static cfgCentrifugoAuthTokenRetrieve<ThrowOnError extends boolean = false>(options?: Options<CfgCentrifugoAuthTokenRetrieveData, ThrowOnError>) {
+        return (options?.client ?? client).get<CfgCentrifugoAuthTokenRetrieveResponses, CfgCentrifugoAuthTokenRetrieveErrors, ThrowOnError>({
+            security: [{ scheme: 'bearer', type: 'http' }],
+            url: '/cfg/centrifugo/auth/token/',
+            ...options
+        });
+    }
+}

package/src/_api/generated/cfg_centrifugo/types.gen.ts

@@ -0,0 +1,61 @@
+// This file is auto-generated by @hey-api/openapi-ts
+
+export type ClientOptions = {
+    baseUrl: 'http://localhost:8000' | (string & {});
+};
+
+/**
+ * ConnectionTokenResponse
+ *
+ * Response model for Centrifugo connection token.
+ */
+export type ConnectionTokenResponse = {
+    /**
+     * Token
+     *
+     * JWT token for Centrifugo connection
+     */
+    token: string;
+    /**
+     * Centrifugo Url
+     *
+     * Centrifugo WebSocket URL
+     */
+    centrifugo_url: string;
+    /**
+     * Expires At
+     *
+     * Token expiration time (ISO 8601)
+     */
+    expires_at: string;
+    /**
+     * Channels
+     *
+     * List of allowed channels
+     */
+    channels: Array<string>;
+};
+
+export type CfgCentrifugoAuthTokenRetrieveData = {
+    body?: never;
+    path?: never;
+    query?: never;
+    url: '/cfg/centrifugo/auth/token/';
+};
+
+export type CfgCentrifugoAuthTokenRetrieveErrors = {
+    /**
+     * Unauthorized - authentication required
+     */
+    401: unknown;
+    /**
+     * Server error
+     */
+    500: unknown;
+};
+
+export type CfgCentrifugoAuthTokenRetrieveResponses = {
+    200: ConnectionTokenResponse;
+};
+
+export type CfgCentrifugoAuthTokenRetrieveResponse = CfgCentrifugoAuthTokenRetrieveResponses[keyof CfgCentrifugoAuthTokenRetrieveResponses];

package/src/_api/generated/cfg_totp/api.ts

@@ -0,0 +1,181 @@
+// AUTO-GENERATED by django_generator / ts_extras.wrapper
+// Self-contained API wrapper for this group. DO NOT EDIT — re-run `make gen`.
+
+import { client } from './client.gen';
+import type { StorageAdapter } from '../_shared/storage';
+import { LocalStorageAdapter } from '../_shared/storage';
+import { APILogger, type LoggerConfig } from '../_shared/logger';
+
+import { Cfg } from './sdk.gen';
+import { Totp } from './sdk.gen';
+import { BackupCodes } from './sdk.gen';
+import { TotpManagement } from './sdk.gen';
+import { TotpSetup } from './sdk.gen';
+import { TotpVerification } from './sdk.gen';
+import type { ZodTypeAny } from 'zod';
+import {
+  BackupCodesRegenerateResponseSchema,
+  BackupCodesStatusSchema,
+  ConfirmSetupResponseSchema,
+  DeviceListResponseSchema,
+  SetupResponseSchema,
+  VerifyResponseSchema,
+} from './schemas';
+import { dispatchValidationError } from '../_shared/validation-events';
+
+const ACCESS_KEY = 'cfg.access_token';
+const REFRESH_KEY = 'cfg.refresh_token';
+
+interface ValidationRoute {
+  method: string;
+  re: RegExp;
+  schema: ZodTypeAny;
+  path: string;
+}
+const VALIDATION_ROUTES: ReadonlyArray<ValidationRoute> = [
+  { method: 'GET', re: new RegExp('^/cfg/totp/backup\\-codes/?$'), schema: BackupCodesStatusSchema, path: '/cfg/totp/backup-codes/' },
+  { method: 'POST', re: new RegExp('^/cfg/totp/backup\\-codes/regenerate/?$'), schema: BackupCodesRegenerateResponseSchema, path: '/cfg/totp/backup-codes/regenerate/' },
+  { method: 'GET', re: new RegExp('^/cfg/totp/devices/?$'), schema: DeviceListResponseSchema, path: '/cfg/totp/devices/' },
+  { method: 'POST', re: new RegExp('^/cfg/totp/setup/?$'), schema: SetupResponseSchema, path: '/cfg/totp/setup/' },
+  { method: 'POST', re: new RegExp('^/cfg/totp/setup/confirm/?$'), schema: ConfirmSetupResponseSchema, path: '/cfg/totp/setup/confirm/' },
+  { method: 'POST', re: new RegExp('^/cfg/totp/verify/?$'), schema: VerifyResponseSchema, path: '/cfg/totp/verify/' },
+  { method: 'POST', re: new RegExp('^/cfg/totp/verify/backup/?$'), schema: VerifyResponseSchema, path: '/cfg/totp/verify/backup/' }
+];
+
+/** Auto-detect locale from cookie NEXT_LOCALE or navigator.language. */
+function detectLocale(): string | null {
+  try {
+    if (typeof document !== 'undefined') {
+      const m = document.cookie.match(/(?:^|;\s*)NEXT_LOCALE=([^;]*)/);
+      if (m) return decodeURIComponent(m[1]);
+    }
+    if (typeof navigator !== 'undefined' && navigator.language) {
+      return navigator.language;
+    }
+  } catch {}
+  return null;
+}
+
+export interface APIOptions {
+  /** Override storage backend (LocalStorage by default; Memory for SSR/tests). */
+  storage?: StorageAdapter;
+  /** Logger config (defaults to dev-only). */
+  logger?: Partial<LoggerConfig>;
+  /** Locale for `Accept-Language`. If omitted, auto-detected from cookie/navigator. */
+  locale?: string;
+  /** API key sent as `X-API-Key`. Falls back to NEXT_PUBLIC_API_KEY. */
+  apiKey?: string;
+  /** Send Django session/CSRF cookies cross-origin. Defaults to true. */
+  withCredentials?: boolean;
+}
+
+/**
+ * Self-contained API wrapper for this group.
+ *
+ * Each group has its own client + interceptor + token store. The interceptor
+ * automatically attaches:
+ *   - `Authorization: Bearer <jwt>` from storage
+ *   - `Accept-Language` from `opts.locale` or `NEXT_LOCALE` cookie
+ *   - `X-API-Key` from `opts.apiKey` or `NEXT_PUBLIC_API_KEY`
+ *   - `credentials: 'include'` for Django session/CSRF cookies (toggle via opts)
+ */
+export class API {
+  private baseUrl: string;
+  private storage: StorageAdapter;
+  private locale: string | null;
+  private apiKey: string | null;
+  readonly logger: APILogger;
+
+  readonly cfg = Cfg;
+  readonly totp = Totp;
+  readonly backupCodes = BackupCodes;
+  readonly totpManagement = TotpManagement;
+  readonly totpSetup = TotpSetup;
+  readonly totpVerification = TotpVerification;
+
+  constructor(baseUrl: string, opts: APIOptions = {}) {
+    this.baseUrl = baseUrl.replace(/\/$/, '');
+    this.storage = opts.storage ?? new LocalStorageAdapter();
+    this.logger = new APILogger(opts.logger);
+    this.locale = opts.locale ?? null;
+    this.apiKey = opts.apiKey ?? (typeof process !== 'undefined' ? (process.env?.NEXT_PUBLIC_API_KEY ?? null) : null);
+
+    const credentials: RequestCredentials = (opts.withCredentials ?? true) ? 'include' : 'same-origin';
+    client.setConfig({ baseUrl: this.baseUrl, credentials });
+
+    client.interceptors.request.use((request) => {
+      const access = this.getToken();
+      if (access) request.headers.set('Authorization', `Bearer ${access}`);
+
+      const locale = this.locale ?? detectLocale();
+      if (locale) request.headers.set('Accept-Language', locale);
+
+      if (this.apiKey) request.headers.set('X-API-Key', this.apiKey);
+
+      return request;
+    });
+
+    client.interceptors.response.use(async (response, request) => {
+      if (!response.ok) return response;
+      const ct = response.headers.get('content-type') || '';
+      if (!ct.includes('application/json')) return response;
+      const url = new URL(request.url);
+      const method = request.method.toUpperCase();
+      const route = VALIDATION_ROUTES.find(
+        (r) => r.method === method && r.re.test(url.pathname),
+      );
+      if (!route) return response;
+      let payload: unknown;
+      try {
+        payload = await response.clone().json();
+      } catch {
+        return response;
+      }
+      const result = route.schema.safeParse(payload);
+      if (!result.success) {
+        dispatchValidationError({
+          operation: `${method} ${route.path}`,
+          path: route.path,
+          method,
+          error: result.error,
+          response: payload,
+          timestamp: new Date(),
+        });
+      }
+      return response;
+    });
+  }
+
+  // ── Base URL ────────────────────────────────────────────────────────────
+  getBaseUrl(): string { return this.baseUrl; }
+  setBaseUrl(url: string): void {
+    this.baseUrl = url.replace(/\/$/, '');
+    client.setConfig({ baseUrl: this.baseUrl });
+  }
+
+  // ── Tokens ──────────────────────────────────────────────────────────────
+  getToken(): string | null { return this.storage.getItem(ACCESS_KEY); }
+  setToken(token: string | null): void {
+    if (token) this.storage.setItem(ACCESS_KEY, token);
+    else this.storage.removeItem(ACCESS_KEY);
+  }
+  getRefreshToken(): string | null { return this.storage.getItem(REFRESH_KEY); }
+  setRefreshToken(token: string | null): void {
+    if (token) this.storage.setItem(REFRESH_KEY, token);
+    else this.storage.removeItem(REFRESH_KEY);
+  }
+  clearToken(): void {
+    this.storage.removeItem(ACCESS_KEY);
+    this.storage.removeItem(REFRESH_KEY);
+  }
+  isAuthenticated(): boolean { return this.getToken() !== null; }
+
+  // ── Locale / API key ────────────────────────────────────────────────────
+  getLocale(): string | null { return this.locale ?? detectLocale(); }
+  setLocale(locale: string | null): void { this.locale = locale; }
+  getApiKey(): string | null { return this.apiKey; }
+  setApiKey(key: string | null): void { this.apiKey = key; }
+}
+
+export { Cfg, Totp, BackupCodes, TotpManagement, TotpSetup, TotpVerification };
+export { client };