@oxyhq/services 5.13.15 → 5.13.17

package/lib/typescript/core/OxyServices.d.ts

@@ -1,761 +1,985 @@
-import type { OxyConfig as OxyConfigBase, ApiError, User, Notification, AssetInitResponse, AssetUrlResponse, AssetVariant, BlockedUser, RestrictedUser } from '../models/interfaces';
-import type { LanguageMetadata } from '../utils/languageUtils';
 /**
- * OxyConfig - Configuration for OxyServices
- * @property baseURL - The Oxy API base URL (e.g., https://api.oxy.so)
- * @property cloudURL - The Oxy Cloud (file storage/CDN) URL (e.g., https://cloud.oxy.so)
- */
-export interface OxyConfig extends OxyConfigBase {
-    cloudURL?: string;
-}
-import type { SessionLoginResponse } from '../models/session';
-import { type PaginationParams } from '../utils/apiUtils';
-import { HttpClient } from './HttpClient';
-/**
- * Custom error types for better error handling
+ * OxyServices - Unified client for Oxy API and Oxy Cloud
+ *
+ * # Usage Examples
+ *
+ * ## Browser (ESM/TypeScript)
+ *
+ * ```typescript
+ * import { OxyServices } from './core/OxyServices';
+ *
+ * const oxy = new OxyServices({
+ *   baseURL: 'https://api.oxy.so',
+ *   cloudURL: 'https://cloud.oxy.so',
+ * });
+ *
+ * // Authenticate and fetch user
+ * await oxy.setTokens('ACCESS_TOKEN');
+ * const user = await oxy.getCurrentUser();
+ *
+ * // Upload a file (browser File API)
+ * const fileInput = document.querySelector('input[type=file]');
+ * const file = fileInput.files[0];
+ * await oxy.uploadRawFile(file);
+ *
+ * // Get a file stream URL for <img src>
+ * const url = oxy.getFileStreamUrl('fileId');
+ * ```
+ *
+ * ## Node.js (CommonJS/TypeScript)
+ *
+ * ```typescript
+ * import { OxyServices } from './core/OxyServices';
+ * import fs from 'fs';
+ *
+ * const oxy = new OxyServices({
+ *   baseURL: 'https://api.oxy.so',
+ *   cloudURL: 'https://cloud.oxy.so',
+ * });
+ *
+ * // Authenticate and fetch user
+ * await oxy.setTokens('ACCESS_TOKEN');
+ * const user = await oxy.getCurrentUser();
+ *
+ * // Upload a file (Node.js Buffer)
+ * const buffer = fs.readFileSync('myfile.png');
+ * const blob = new Blob([buffer]);
+ * await oxy.uploadRawFile(blob, { filename: 'myfile.png' });
+ *
+ * // Get a file download URL
+ * const url = oxy.getFileDownloadUrl('fileId');
+ * ```
+ *
+ * ## Configuration
+ * - `baseURL`: Oxy API endpoint (e.g., https://api.oxy.so)
+ * - `cloudURL`: Oxy Cloud/CDN endpoint (e.g., https://cloud.oxy.so)
+ *
+ * See method JSDoc for more details and options.
  */
-export declare class OxyAuthenticationError extends Error {
-    readonly code: string;
-    readonly status: number;
-    constructor(message: string, code?: string, status?: number);
-}
-export declare class OxyAuthenticationTimeoutError extends OxyAuthenticationError {
-    constructor(operationName: string, timeoutMs: number);
-}
+import { OxyServicesBase, type OxyConfig } from './OxyServices.base';
+import { OxyAuthenticationError, OxyAuthenticationTimeoutError } from './OxyServices.errors';
 /**
  * OxyServices - Unified client library for interacting with the Oxy API
  *
  * This class provides all API functionality in one simple, easy-to-use interface.
- * Architecture:
- * - HttpClient: Handles HTTP communication and authentication
- * - RequestManager: Handles caching, deduplication, queuing, and retry
- * - OxyServices: Provides high-level API methods
+ *
+ * ## Architecture
+ * - **HttpClient**: Handles HTTP communication and authentication
+ * - **RequestManager**: Handles caching, deduplication, queuing, and retry
+ * - **OxyServices**: Provides high-level API methods
+ *
+ * ## Mixin Composition
+ * The class is composed using TypeScript mixins for better code organization:
+ * - **Base**: Core infrastructure (HTTP client, request management, error handling)
+ * - **Auth**: Authentication and session management
+ * - **User**: User profiles, follow, notifications
+ * - **TOTP**: Two-factor authentication enrollment
+ * - **Privacy**: Blocked and restricted users
+ * - **Language**: Language detection and metadata
+ * - **Payment**: Payment processing
+ * - **Karma**: Karma system
+ * - **Assets**: File upload and asset management
+ * - **Developer**: Developer API management
+ * - **Location**: Location-based features
+ * - **Analytics**: Analytics tracking
+ * - **Devices**: Device management
+ * - **Utility**: Utility methods and Express middleware
+ *
+ * @example
+ * ```typescript
+ * const oxy = new OxyServices({
+ *   baseURL: 'https://api.oxy.so',
+ *   cloudURL: 'https://cloud.oxy.so'
+ * });
+ * ```
  */
-export declare class OxyServices {
-    private httpClient;
-    private requestManager;
-    private cloudURL;
-    private config;
-    /**
-     * Creates a new instance of the OxyServices client
-     * @param config - Configuration for the client
-     *   config.baseURL: Oxy API URL (e.g., https://api.oxy.so)
-     *   config.cloudURL: Oxy Cloud URL (e.g., https://cloud.oxy.so)
-     */
-    constructor(config: OxyConfig);
-    static __resetTokensForTests(): void;
-    /**
-     * Make a request with all performance optimizations
-     * This is the main method for all API calls - ensures authentication and performance features
-     */
-    private makeRequest;
-    /**
-     * Get the configured Oxy API base URL
-     */
-    getBaseURL(): string;
-    /**
-     * Get the HTTP client instance
-     * Useful for advanced use cases where direct access to the HTTP client is needed
-     */
-    getClient(): HttpClient;
-    /**
-     * Get performance metrics
-     */
-    getMetrics(): {
-        totalRequests: number;
-        successfulRequests: number;
-        failedRequests: number;
-        cacheHits: number;
-        cacheMisses: number;
-        averageResponseTime: number;
+declare const OxyServicesComposed: {
+    new (...args: any[]): {
+        fetchLinkMetadata(url: string): Promise<{
+            url: string;
+            title: string;
+            description: string;
+            image?: string;
+        }>;
+        auth(options?: {
+            debug?: boolean;
+            onError?: ((error: import(".").ApiError) => any) | undefined;
+            loadUser?: boolean;
+            session?: boolean;
+        }): (req: any, res: any, next: any) => any;
+        httpClient: import("./HttpClient").HttpClient;
+        requestManager: import("./RequestManager").RequestManager;
+        cloudURL: string;
+        config: OxyConfig;
+        makeRequest<T>(method: "GET" | "POST" | "PUT" | "PATCH" | "DELETE", url: string, data?: any, options?: import("./RequestManager").RequestOptions): Promise<T>;
+        getBaseURL(): string;
+        getClient(): import("./HttpClient").HttpClient;
+        getMetrics(): {
+            totalRequests: number;
+            successfulRequests: number;
+            failedRequests: number;
+            cacheHits: number;
+            cacheMisses: number;
+            averageResponseTime: number;
+        };
+        clearCache(): void;
+        clearCacheEntry(key: string): void;
+        getCacheStats(): {
+            size: number;
+            hits: number;
+            misses: number;
+            hitRate: number;
+        };
+        getCloudURL(): string;
+        setTokens(accessToken: string, refreshToken?: string): void;
+        clearTokens(): void;
+        getCurrentUserId(): string | null;
+        hasValidToken(): boolean;
+        getAccessToken(): string | null;
+        waitForAuth(timeoutMs?: number): Promise<boolean>;
+        waitForAuthentication(timeoutMs?: number): Promise<boolean>;
+        hasAccessToken(): boolean;
+        withAuthRetry<T>(operation: () => Promise<T>, operationName: string, options?: {
+            maxRetries?: number;
+            retryDelay?: number;
+            authTimeoutMs?: number;
+        }): Promise<T>;
+        validate(): Promise<boolean>;
+        handleError(error: any): Error;
+        healthCheck(): Promise<{
+            status: string;
+            users?: number;
+            timestamp?: string;
+            [key: string]: any;
+        }>;
+    };
+    __resetTokensForTests(): void;
+} & {
+    new (...args: any[]): {
+        registerDevice(deviceData: any): Promise<any>;
+        getUserDevices(): Promise<any[]>;
+        removeDevice(deviceId: string): Promise<void>;
+        getDeviceSessions(sessionId: string): Promise<any[]>;
+        logoutAllDeviceSessions(sessionId: string, deviceId?: string, excludeCurrent?: boolean): Promise<any>;
+        updateDeviceName(sessionId: string, deviceName: string): Promise<any>;
+        httpClient: import("./HttpClient").HttpClient;
+        requestManager: import("./RequestManager").RequestManager;
+        cloudURL: string;
+        config: OxyConfig;
+        makeRequest<T>(method: "GET" | "POST" | "PUT" | "PATCH" | "DELETE", url: string, data?: any, options?: import("./RequestManager").RequestOptions): Promise<T>;
+        getBaseURL(): string;
+        getClient(): import("./HttpClient").HttpClient;
+        getMetrics(): {
+            totalRequests: number;
+            successfulRequests: number;
+            failedRequests: number;
+            cacheHits: number;
+            cacheMisses: number;
+            averageResponseTime: number;
+        };
+        clearCache(): void;
+        clearCacheEntry(key: string): void;
+        getCacheStats(): {
+            size: number;
+            hits: number;
+            misses: number;
+            hitRate: number;
+        };
+        getCloudURL(): string;
+        setTokens(accessToken: string, refreshToken?: string): void;
+        clearTokens(): void;
+        getCurrentUserId(): string | null;
+        hasValidToken(): boolean;
+        getAccessToken(): string | null;
+        waitForAuth(timeoutMs?: number): Promise<boolean>;
+        waitForAuthentication(timeoutMs?: number): Promise<boolean>;
+        hasAccessToken(): boolean;
+        withAuthRetry<T>(operation: () => Promise<T>, operationName: string, options?: {
+            maxRetries?: number;
+            retryDelay?: number;
+            authTimeoutMs?: number;
+        }): Promise<T>;
+        validate(): Promise<boolean>;
+        handleError(error: any): Error;
+        healthCheck(): Promise<{
+            status: string;
+            users?: number;
+            timestamp?: string;
+            [key: string]: any;
+        }>;
+    };
+    __resetTokensForTests(): void;
+} & {
+    new (...args: any[]): {
+        trackEvent(eventName: string, properties?: Record<string, any>): Promise<void>;
+        getAnalytics(startDate?: string, endDate?: string): Promise<any>;
+        httpClient: import("./HttpClient").HttpClient;
+        requestManager: import("./RequestManager").RequestManager;
+        cloudURL: string;
+        config: OxyConfig;
+        makeRequest<T>(method: "GET" | "POST" | "PUT" | "PATCH" | "DELETE", url: string, data?: any, options?: import("./RequestManager").RequestOptions): Promise<T>;
+        getBaseURL(): string;
+        getClient(): import("./HttpClient").HttpClient;
+        getMetrics(): {
+            totalRequests: number;
+            successfulRequests: number;
+            failedRequests: number;
+            cacheHits: number;
+            cacheMisses: number;
+            averageResponseTime: number;
+        };
+        clearCache(): void;
+        clearCacheEntry(key: string): void;
+        getCacheStats(): {
+            size: number;
+            hits: number;
+            misses: number;
+            hitRate: number;
+        };
+        getCloudURL(): string;
+        setTokens(accessToken: string, refreshToken?: string): void;
+        clearTokens(): void;
+        getCurrentUserId(): string | null;
+        hasValidToken(): boolean;
+        getAccessToken(): string | null;
+        waitForAuth(timeoutMs?: number): Promise<boolean>;
+        waitForAuthentication(timeoutMs?: number): Promise<boolean>;
+        hasAccessToken(): boolean;
+        withAuthRetry<T>(operation: () => Promise<T>, operationName: string, options?: {
+            maxRetries?: number;
+            retryDelay?: number;
+            authTimeoutMs?: number;
+        }): Promise<T>;
+        validate(): Promise<boolean>;
+        handleError(error: any): Error;
+        healthCheck(): Promise<{
+            status: string;
+            users?: number;
+            timestamp?: string;
+            [key: string]: any;
+        }>;
+    };
+    __resetTokensForTests(): void;
+} & {
+    new (...args: any[]): {
+        updateLocation(latitude: number, longitude: number): Promise<any>;
+        getNearbyUsers(radius?: number): Promise<any[]>;
+        httpClient: import("./HttpClient").HttpClient;
+        requestManager: import("./RequestManager").RequestManager;
+        cloudURL: string;
+        config: OxyConfig;
+        makeRequest<T>(method: "GET" | "POST" | "PUT" | "PATCH" | "DELETE", url: string, data?: any, options?: import("./RequestManager").RequestOptions): Promise<T>;
+        getBaseURL(): string;
+        getClient(): import("./HttpClient").HttpClient;
+        getMetrics(): {
+            totalRequests: number;
+            successfulRequests: number;
+            failedRequests: number;
+            cacheHits: number;
+            cacheMisses: number;
+            averageResponseTime: number;
+        };
+        clearCache(): void;
+        clearCacheEntry(key: string): void;
+        getCacheStats(): {
+            size: number;
+            hits: number;
+            misses: number;
+            hitRate: number;
+        };
+        getCloudURL(): string;
+        setTokens(accessToken: string, refreshToken?: string): void;
+        clearTokens(): void;
+        getCurrentUserId(): string | null;
+        hasValidToken(): boolean;
+        getAccessToken(): string | null;
+        waitForAuth(timeoutMs?: number): Promise<boolean>;
+        waitForAuthentication(timeoutMs?: number): Promise<boolean>;
+        hasAccessToken(): boolean;
+        withAuthRetry<T>(operation: () => Promise<T>, operationName: string, options?: {
+            maxRetries?: number;
+            retryDelay?: number;
+            authTimeoutMs?: number;
+        }): Promise<T>;
+        validate(): Promise<boolean>;
+        handleError(error: any): Error;
+        healthCheck(): Promise<{
+            status: string;
+            users?: number;
+            timestamp?: string;
+            [key: string]: any;
+        }>;
+    };
+    __resetTokensForTests(): void;
+} & {
+    new (...args: any[]): {
+        getDeveloperApps(): Promise<any[]>;
+        createDeveloperApp(data: {
+            name: string;
+            description?: string;
+            webhookUrl: string;
+            devWebhookUrl?: string;
+            scopes?: string[];
+        }): Promise<any>;
+        getDeveloperApp(appId: string): Promise<any>;
+        updateDeveloperApp(appId: string, data: {
+            name?: string;
+            description?: string;
+            webhookUrl?: string;
+            devWebhookUrl?: string;
+            scopes?: string[];
+        }): Promise<any>;
+        regenerateDeveloperAppSecret(appId: string): Promise<any>;
+        deleteDeveloperApp(appId: string): Promise<any>;
+        httpClient: import("./HttpClient").HttpClient;
+        requestManager: import("./RequestManager").RequestManager;
+        cloudURL: string;
+        config: OxyConfig;
+        makeRequest<T>(method: "GET" | "POST" | "PUT" | "PATCH" | "DELETE", url: string, data?: any, options?: import("./RequestManager").RequestOptions): Promise<T>;
+        getBaseURL(): string;
+        getClient(): import("./HttpClient").HttpClient;
+        getMetrics(): {
+            totalRequests: number;
+            successfulRequests: number;
+            failedRequests: number;
+            cacheHits: number;
+            cacheMisses: number;
+            averageResponseTime: number;
+        };
+        clearCache(): void;
+        clearCacheEntry(key: string): void;
+        getCacheStats(): {
+            size: number;
+            hits: number;
+            misses: number;
+            hitRate: number;
+        };
+        getCloudURL(): string;
+        setTokens(accessToken: string, refreshToken?: string): void;
+        clearTokens(): void;
+        getCurrentUserId(): string | null;
+        hasValidToken(): boolean;
+        getAccessToken(): string | null;
+        waitForAuth(timeoutMs?: number): Promise<boolean>;
+        waitForAuthentication(timeoutMs?: number): Promise<boolean>;
+        hasAccessToken(): boolean;
+        withAuthRetry<T>(operation: () => Promise<T>, operationName: string, options?: {
+            maxRetries?: number;
+            retryDelay?: number;
+            authTimeoutMs?: number;
+        }): Promise<T>;
+        validate(): Promise<boolean>;
+        handleError(error: any): Error;
+        healthCheck(): Promise<{
+            status: string;
+            users?: number;
+            timestamp?: string;
+            [key: string]: any;
+        }>;
+    };
+    __resetTokensForTests(): void;
+} & {
+    new (...args: any[]): {
+        deleteFile(fileId: string): Promise<any>;
+        getFileDownloadUrl(fileId: string, variant?: string, expiresIn?: number): string;
+        getFileDownloadUrlAsync(fileId: string, variant?: string, expiresIn?: number): Promise<string>;
+        getFileStreamUrl(fileId: string): string;
+        listUserFiles(limit?: number, offset?: number): Promise<{
+            files: any[];
+            total: number;
+            hasMore: boolean;
+        }>;
+        getFileContentAsText(fileId: string, variant?: string): Promise<string>;
+        getFileContentAsBlob(fileId: string, variant?: string): Promise<Blob>;
+        uploadRawFile(file: File | Blob, visibility?: "private" | "public" | "unlisted", metadata?: Record<string, any>): Promise<any>;
+        calculateSHA256(file: File | Blob): Promise<string>;
+        assetInit(sha256: string, size: number, mime: string): Promise<import(".").AssetInitResponse>;
+        assetComplete(fileId: string, originalName: string, size: number, mime: string, visibility?: "private" | "public" | "unlisted", metadata?: Record<string, any>): Promise<any>;
+        assetUpload(file: File, visibility?: "private" | "public" | "unlisted", metadata?: Record<string, any>, onProgress?: ((progress: number) => void) | undefined): Promise<any>;
+        uploadToPresignedUrl(url: string, file: File, onProgress?: ((progress: number) => void) | undefined): Promise<void>;
+        assetLink(fileId: string, app: string, entityType: string, entityId: string, visibility?: "private" | "public" | "unlisted", webhookUrl?: string): Promise<any>;
+        assetUnlink(fileId: string, app: string, entityType: string, entityId: string): Promise<any>;
+        assetGet(fileId: string): Promise<any>;
+        assetGetUrl(fileId: string, variant?: string, expiresIn?: number): Promise<import(".").AssetUrlResponse>;
+        assetRestore(fileId: string): Promise<any>;
+        assetDelete(fileId: string, force?: boolean): Promise<any>;
+        assetGetVariants(fileId: string): Promise<import(".").AssetVariant[]>;
+        assetUpdateVisibility(fileId: string, visibility: "private" | "public" | "unlisted"): Promise<any>;
+        uploadAvatar(file: File, userId: string, app?: string): Promise<any>;
+        uploadProfileBanner(file: File, userId: string, app?: string): Promise<any>;
+        httpClient: import("./HttpClient").HttpClient;
+        requestManager: import("./RequestManager").RequestManager;
+        cloudURL: string;
+        config: OxyConfig;
+        makeRequest<T>(method: "GET" | "POST" | "PUT" | "PATCH" | "DELETE", url: string, data?: any, options?: import("./RequestManager").RequestOptions): Promise<T>;
+        getBaseURL(): string;
+        getClient(): import("./HttpClient").HttpClient;
+        getMetrics(): {
+            totalRequests: number;
+            successfulRequests: number;
+            failedRequests: number;
+            cacheHits: number;
+            cacheMisses: number;
+            averageResponseTime: number;
+        };
+        clearCache(): void;
+        clearCacheEntry(key: string): void;
+        getCacheStats(): {
+            size: number;
+            hits: number;
+            misses: number;
+            hitRate: number;
+        };
+        getCloudURL(): string;
+        setTokens(accessToken: string, refreshToken?: string): void;
+        clearTokens(): void;
+        getCurrentUserId(): string | null;
+        hasValidToken(): boolean;
+        getAccessToken(): string | null;
+        waitForAuth(timeoutMs?: number): Promise<boolean>;
+        waitForAuthentication(timeoutMs?: number): Promise<boolean>;
+        hasAccessToken(): boolean;
+        withAuthRetry<T>(operation: () => Promise<T>, operationName: string, options?: {
+            maxRetries?: number;
+            retryDelay?: number;
+            authTimeoutMs?: number;
+        }): Promise<T>;
+        validate(): Promise<boolean>;
+        handleError(error: any): Error;
+        healthCheck(): Promise<{
+            status: string;
+            users?: number;
+            timestamp?: string;
+            [key: string]: any;
+        }>;
+    };
+    __resetTokensForTests(): void;
+} & {
+    new (...args: any[]): {
+        getUserKarma(userId: string): Promise<any>;
+        giveKarma(userId: string, amount: number, reason?: string): Promise<any>;
+        getUserKarmaTotal(userId: string): Promise<any>;
+        getUserKarmaHistory(userId: string, limit?: number, offset?: number): Promise<any>;
+        getKarmaLeaderboard(): Promise<any>;
+        getKarmaRules(): Promise<any>;
+        httpClient: import("./HttpClient").HttpClient;
+        requestManager: import("./RequestManager").RequestManager;
+        cloudURL: string;
+        config: OxyConfig;
+        makeRequest<T>(method: "GET" | "POST" | "PUT" | "PATCH" | "DELETE", url: string, data?: any, options?: import("./RequestManager").RequestOptions): Promise<T>;
+        getBaseURL(): string;
+        getClient(): import("./HttpClient").HttpClient;
+        getMetrics(): {
+            totalRequests: number;
+            successfulRequests: number;
+            failedRequests: number;
+            cacheHits: number;
+            cacheMisses: number;
+            averageResponseTime: number;
+        };
+        clearCache(): void;
+        clearCacheEntry(key: string): void;
+        getCacheStats(): {
+            size: number;
+            hits: number;
+            misses: number;
+            hitRate: number;
+        };
+        getCloudURL(): string;
+        setTokens(accessToken: string, refreshToken?: string): void;
+        clearTokens(): void;
+        getCurrentUserId(): string | null;
+        hasValidToken(): boolean;
+        getAccessToken(): string | null;
+        waitForAuth(timeoutMs?: number): Promise<boolean>;
+        waitForAuthentication(timeoutMs?: number): Promise<boolean>;
+        hasAccessToken(): boolean;
+        withAuthRetry<T>(operation: () => Promise<T>, operationName: string, options?: {
+            maxRetries?: number;
+            retryDelay?: number;
+            authTimeoutMs?: number;
+        }): Promise<T>;
+        validate(): Promise<boolean>;
+        handleError(error: any): Error;
+        healthCheck(): Promise<{
+            status: string;
+            users?: number;
+            timestamp?: string;
+            [key: string]: any;
+        }>;
+    };
+    __resetTokensForTests(): void;
+} & {
+    new (...args: any[]): {
+        createPayment(data: any): Promise<any>;
+        getPayment(paymentId: string): Promise<any>;
+        getUserPayments(): Promise<any[]>;
+        httpClient: import("./HttpClient").HttpClient;
+        requestManager: import("./RequestManager").RequestManager;
+        cloudURL: string;
+        config: OxyConfig;
+        makeRequest<T>(method: "GET" | "POST" | "PUT" | "PATCH" | "DELETE", url: string, data?: any, options?: import("./RequestManager").RequestOptions): Promise<T>;
+        getBaseURL(): string;
+        getClient(): import("./HttpClient").HttpClient;
+        getMetrics(): {
+            totalRequests: number;
+            successfulRequests: number;
+            failedRequests: number;
+            cacheHits: number;
+            cacheMisses: number;
+            averageResponseTime: number;
+        };
+        clearCache(): void;
+        clearCacheEntry(key: string): void;
+        getCacheStats(): {
+            size: number;
+            hits: number;
+            misses: number;
+            hitRate: number;
+        };
+        getCloudURL(): string;
+        setTokens(accessToken: string, refreshToken?: string): void;
+        clearTokens(): void;
+        getCurrentUserId(): string | null;
+        hasValidToken(): boolean;
+        getAccessToken(): string | null;
+        waitForAuth(timeoutMs?: number): Promise<boolean>;
+        waitForAuthentication(timeoutMs?: number): Promise<boolean>;
+        hasAccessToken(): boolean;
+        withAuthRetry<T>(operation: () => Promise<T>, operationName: string, options?: {
+            maxRetries?: number;
+            retryDelay?: number;
+            authTimeoutMs?: number;
+        }): Promise<T>;
+        validate(): Promise<boolean>;
+        handleError(error: any): Error;
+        healthCheck(): Promise<{
+            status: string;
+            users?: number;
+            timestamp?: string;
+            [key: string]: any;
+        }>;
+    };
+    __resetTokensForTests(): void;
+} & {
+    new (...args: any[]): {
+        getStorage(): Promise<{
+            getItem: (key: string) => Promise<string | null>;
+            setItem: (key: string, value: string) => Promise<void>;
+            removeItem: (key: string) => Promise<void>;
+        }>;
+        getCurrentLanguage(storageKeyPrefix?: string): Promise<string | null>;
+        getCurrentLanguageMetadata(storageKeyPrefix?: string): Promise<import(".").LanguageMetadata | null>;
+        getCurrentLanguageName(storageKeyPrefix?: string): Promise<string | null>;
+        getCurrentNativeLanguageName(storageKeyPrefix?: string): Promise<string | null>;
+        httpClient: import("./HttpClient").HttpClient;
+        requestManager: import("./RequestManager").RequestManager;
+        cloudURL: string;
+        config: OxyConfig;
+        makeRequest<T>(method: "GET" | "POST" | "PUT" | "PATCH" | "DELETE", url: string, data?: any, options?: import("./RequestManager").RequestOptions): Promise<T>;
+        getBaseURL(): string;
+        getClient(): import("./HttpClient").HttpClient;
+        getMetrics(): {
+            totalRequests: number;
+            successfulRequests: number;
+            failedRequests: number;
+            cacheHits: number;
+            cacheMisses: number;
+            averageResponseTime: number;
+        };
+        clearCache(): void;
+        clearCacheEntry(key: string): void;
+        getCacheStats(): {
+            size: number;
+            hits: number;
+            misses: number;
+            hitRate: number;
+        };
+        getCloudURL(): string;
+        setTokens(accessToken: string, refreshToken?: string): void;
+        clearTokens(): void;
+        getCurrentUserId(): string | null;
+        hasValidToken(): boolean;
+        getAccessToken(): string | null;
+        waitForAuth(timeoutMs?: number): Promise<boolean>;
+        waitForAuthentication(timeoutMs?: number): Promise<boolean>;
+        hasAccessToken(): boolean;
+        withAuthRetry<T>(operation: () => Promise<T>, operationName: string, options?: {
+            maxRetries?: number;
+            retryDelay?: number;
+            authTimeoutMs?: number;
+        }): Promise<T>;
+        validate(): Promise<boolean>;
+        handleError(error: any): Error;
+        healthCheck(): Promise<{
+            status: string;
+            users?: number;
+            timestamp?: string;
+            [key: string]: any;
+        }>;
     };
-    /**
-     * Clear request cache
-     */
-    clearCache(): void;
-    /**
-     * Clear specific cache entry
-     */
-    clearCacheEntry(key: string): void;
-    /**
-     * Get cache statistics
-     */
-    getCacheStats(): {
-        size: number;
-        hits: number;
-        misses: number;
-        hitRate: number;
+    __resetTokensForTests(): void;
+} & {
+    new (...args: any[]): {
+        extractUserId(userIdField: string | {
+            _id: string;
+            username?: string;
+            avatar?: string;
+        }): string;
+        isUserInList<T extends import(".").BlockedUser | import(".").RestrictedUser>(userId: string, getUserList: () => Promise<T[]>, getIdField: (item: T) => string | {
+            _id: string;
+            username?: string;
+            avatar?: string;
+        }): Promise<boolean>;
+        getBlockedUsers(): Promise<import(".").BlockedUser[]>;
+        blockUser(userId: string): Promise<{
+            message: string;
+        }>;
+        unblockUser(userId: string): Promise<{
+            message: string;
+        }>;
+        isUserBlocked(userId: string): Promise<boolean>;
+        getRestrictedUsers(): Promise<import(".").RestrictedUser[]>;
+        restrictUser(userId: string): Promise<{
+            message: string;
+        }>;
+        unrestrictUser(userId: string): Promise<{
+            message: string;
+        }>;
+        isUserRestricted(userId: string): Promise<boolean>;
+        httpClient: import("./HttpClient").HttpClient;
+        requestManager: import("./RequestManager").RequestManager;
+        cloudURL: string;
+        config: OxyConfig;
+        makeRequest<T>(method: "GET" | "POST" | "PUT" | "PATCH" | "DELETE", url: string, data?: any, options?: import("./RequestManager").RequestOptions): Promise<T>;
+        getBaseURL(): string;
+        getClient(): import("./HttpClient").HttpClient;
+        getMetrics(): {
+            totalRequests: number;
+            successfulRequests: number;
+            failedRequests: number;
+            cacheHits: number;
+            cacheMisses: number;
+            averageResponseTime: number;
+        };
+        clearCache(): void;
+        clearCacheEntry(key: string): void;
+        getCacheStats(): {
+            size: number;
+            hits: number;
+            misses: number;
+            hitRate: number;
+        };
+        getCloudURL(): string;
+        setTokens(accessToken: string, refreshToken?: string): void;
+        clearTokens(): void;
+        getCurrentUserId(): string | null;
+        hasValidToken(): boolean;
+        getAccessToken(): string | null;
+        waitForAuth(timeoutMs?: number): Promise<boolean>;
+        waitForAuthentication(timeoutMs?: number): Promise<boolean>;
+        hasAccessToken(): boolean;
+        withAuthRetry<T>(operation: () => Promise<T>, operationName: string, options?: {
+            maxRetries?: number;
+            retryDelay?: number;
+            authTimeoutMs?: number;
+        }): Promise<T>;
+        validate(): Promise<boolean>;
+        handleError(error: any): Error;
+        healthCheck(): Promise<{
+            status: string;
+            users?: number;
+            timestamp?: string;
+            [key: string]: any;
+        }>;
     };
-    /**
-     * Get the configured Oxy Cloud (file storage/CDN) URL
-     */
-    getCloudURL(): string;
-    /**
-     * Set authentication tokens
-     */
-    setTokens(accessToken: string, refreshToken?: string): void;
-    /**
-     * Clear stored authentication tokens
-     */
-    clearTokens(): void;
-    /**
-     * Get the current user ID from the access token
-     */
-    getCurrentUserId(): string | null;
-    /**
-     * Check if the client has a valid access token
-     */
-    private hasAccessToken;
-    /**
-     * Check if the client has a valid access token (public method)
-     */
-    hasValidToken(): boolean;
-    /**
-     * Get the raw access token (for constructing anchor URLs when needed)
-     */
-    getAccessToken(): string | null;
-    /**
-     * Wait for authentication to be ready (public method)
-     * Useful for apps that want to ensure authentication is complete before proceeding
-     */
-    waitForAuth(timeoutMs?: number): Promise<boolean>;
-    /**
-     * Wait for authentication to be ready with timeout
-     */
-    private waitForAuthentication;
-    /**
-     * Execute a function with automatic authentication retry logic
-     * This handles the common case where API calls are made before authentication completes
-     */
-    private withAuthRetry;
-    /**
-     * Validate the current access token with the server
-     */
-    validate(): Promise<boolean>;
-    /**
-     * Centralized error handling
-     */
-    protected handleError(error: any): Error;
-    /**
-     * Health check endpoint
-     */
-    healthCheck(): Promise<{
-        status: string;
-        users?: number;
-        timestamp?: string;
-        [key: string]: any;
-    }>;
-    /**
-     * Sign up a new user
-     */
-    signUp(username: string, email: string, password: string): Promise<{
-        message: string;
-        token: string;
-        user: User;
-    }>;
-    /**
-     * Request account recovery (send verification code)
-     */
-    requestRecovery(identifier: string): Promise<{
-        delivery?: string;
-        destination?: string;
-    }>;
-    /**
-     * Verify recovery code
-     */
-    verifyRecoveryCode(identifier: string, code: string): Promise<{
-        verified: boolean;
-    }>;
-    /**
-     * Reset password using verified code
-     */
-    resetPassword(identifier: string, code: string, newPassword: string): Promise<{
-        success: boolean;
-    }>;
-    /**
-     * Reset password using TOTP code (recommended recovery)
-     */
-    resetPasswordWithTotp(identifier: string, code: string, newPassword: string): Promise<{
-        success: boolean;
-    }>;
-    resetPasswordWithBackupCode(identifier: string, backupCode: string, newPassword: string): Promise<{
-        success: boolean;
-    }>;
-    resetPasswordWithRecoveryKey(identifier: string, recoveryKey: string, newPassword: string): Promise<{
-        success: boolean;
-        nextRecoveryKey?: string;
-    }>;
-    /**
-     * Sign in with device management
-     */
-    signIn(username: string, password: string, deviceName?: string, deviceFingerprint?: any): Promise<SessionLoginResponse | {
-        mfaRequired: true;
-        mfaToken: string;
-        expiresAt: string;
-    }>;
-    /**
-     * Complete login by verifying TOTP with MFA token
-     */
-    verifyTotpLogin(mfaToken: string, code: string): Promise<SessionLoginResponse>;
-    /**
-     * Get user by session ID
-     */
-    getUserBySession(sessionId: string): Promise<User>;
-    /**
-     * Batch get multiple user profiles by session IDs (optimized for account switching)
-     * Returns array of { sessionId, user } objects
-     */
-    getUsersBySessions(sessionIds: string[]): Promise<Array<{
-        sessionId: string;
-        user: User | null;
-    }>>;
-    /**
-     * Get access token by session ID and set it in the token store
-     */
-    getTokenBySession(sessionId: string): Promise<{
-        accessToken: string;
-        expiresAt: string;
-    }>;
-    /**
-     * Get sessions by session ID
-     */
-    getSessionsBySessionId(sessionId: string): Promise<any[]>;
-    /**
-     * Logout from a specific session
-     */
-    logoutSession(sessionId: string, targetSessionId?: string): Promise<void>;
-    /**
-     * Logout from all sessions
-     */
-    logoutAllSessions(sessionId: string): Promise<void>;
-    /**
-     * Validate session
-     */
-    validateSession(sessionId: string, options?: {
-        deviceFingerprint?: string;
-        useHeaderValidation?: boolean;
-    }): Promise<{
-        valid: boolean;
-        expiresAt: string;
-        lastActivity: string;
-        user: User;
-        sessionId?: string;
-        source?: string;
-    }>;
-    /**
-     * Check username availability
-     */
-    checkUsernameAvailability(username: string): Promise<{
-        available: boolean;
-        message: string;
-    }>;
-    /**
-     * Check email availability
-     */
-    checkEmailAvailability(email: string): Promise<{
-        available: boolean;
-        message: string;
-    }>;
-    /**
-     * Get profile by username
-     */
-    getProfileByUsername(username: string): Promise<User>;
-    startTotpEnrollment(sessionId: string): Promise<{
-        secret: string;
-        otpauthUrl: string;
-        issuer: string;
-        label: string;
-    }>;
-    verifyTotpEnrollment(sessionId: string, code: string): Promise<{
-        enabled: boolean;
-        backupCodes?: string[];
-        recoveryKey?: string;
-    }>;
-    disableTotp(sessionId: string, code: string): Promise<{
-        disabled: boolean;
-    }>;
-    /**
-     * Search user profiles
-     */
-    searchProfiles(query: string, pagination?: PaginationParams): Promise<User[]>;
-    /**
-     * Get profile recommendations
-     */
-    getProfileRecommendations(): Promise<Array<{
-        id: string;
-        username: string;
-        name?: {
-            first?: string;
-            last?: string;
-            full?: string;
+    __resetTokensForTests(): void;
+} & {
+    new (...args: any[]): {
+        startTotpEnrollment(sessionId: string): Promise<{
+            secret: string;
+            otpauthUrl: string;
+            issuer: string;
+            label: string;
+        }>;
+        verifyTotpEnrollment(sessionId: string, code: string): Promise<{
+            enabled: boolean;
+            backupCodes?: string[];
+            recoveryKey?: string;
+        }>;
+        disableTotp(sessionId: string, code: string): Promise<{
+            disabled: boolean;
+        }>;
+        httpClient: import("./HttpClient").HttpClient;
+        requestManager: import("./RequestManager").RequestManager;
+        cloudURL: string;
+        config: OxyConfig;
+        makeRequest<T>(method: "GET" | "POST" | "PUT" | "PATCH" | "DELETE", url: string, data?: any, options?: import("./RequestManager").RequestOptions): Promise<T>;
+        getBaseURL(): string;
+        getClient(): import("./HttpClient").HttpClient;
+        getMetrics(): {
+            totalRequests: number;
+            successfulRequests: number;
+            failedRequests: number;
+            cacheHits: number;
+            cacheMisses: number;
+            averageResponseTime: number;
         };
-        description?: string;
-        _count?: {
-            followers: number;
-            following: number;
+        clearCache(): void;
+        clearCacheEntry(key: string): void;
+        getCacheStats(): {
+            size: number;
+            hits: number;
+            misses: number;
+            hitRate: number;
         };
-        [key: string]: any;
-    }>>;
-    /**
-     * Get user by ID
-     */
-    getUserById(userId: string): Promise<User>;
-    /**
-     * Get current user
-     */
-    getCurrentUser(): Promise<User>;
-    /**
-     * Update user profile
-     */
-    updateProfile(updates: Record<string, any>): Promise<User>;
-    /**
-     * Get privacy settings for a user
-     * @param userId - The user ID (defaults to current user)
-     */
-    getPrivacySettings(userId?: string): Promise<any>;
-    /**
-     * Update privacy settings
-     * @param settings - Partial privacy settings object
-     * @param userId - The user ID (defaults to current user)
-     */
-    updatePrivacySettings(settings: Record<string, any>, userId?: string): Promise<any>;
-    /**
-     * Get list of blocked users
-     * @returns Array of blocked users
-     */
-    getBlockedUsers(): Promise<BlockedUser[]>;
-    /**
-     * Block a user
-     * @param userId - The user ID to block
-     * @returns Success message
-     */
-    blockUser(userId: string): Promise<{
-        message: string;
-    }>;
-    /**
-     * Unblock a user
-     * @param userId - The user ID to unblock
-     * @returns Success message
-     */
-    unblockUser(userId: string): Promise<{
-        message: string;
-    }>;
-    /**
-     * Extract user ID from blocked/restricted user object
-     * @private
-     */
-    private extractUserId;
-    /**
-     * Check if a user is in a list (blocked or restricted)
-     * @private
-     */
-    private isUserInList;
-    /**
-     * Check if a user is blocked
-     * @param userId - The user ID to check
-     * @returns True if the user is blocked, false otherwise
-     */
-    isUserBlocked(userId: string): Promise<boolean>;
-    /**
-     * Get list of restricted users
-     * @returns Array of restricted users
-     */
-    getRestrictedUsers(): Promise<RestrictedUser[]>;
-    /**
-     * Restrict a user (limit their interactions without fully blocking)
-     * @param userId - The user ID to restrict
-     * @returns Success message
-     */
-    restrictUser(userId: string): Promise<{
-        message: string;
-    }>;
-    /**
-     * Unrestrict a user
-     * @param userId - The user ID to unrestrict
-     * @returns Success message
-     */
-    unrestrictUser(userId: string): Promise<{
-        message: string;
-    }>;
-    /**
-     * Check if a user is restricted
-     * @param userId - The user ID to check
-     * @returns True if the user is restricted, false otherwise
-     */
-    isUserRestricted(userId: string): Promise<boolean>;
-    /**
-     * Request account verification
-     */
-    requestAccountVerification(reason: string, evidence?: string): Promise<{
-        message: string;
-        requestId: string;
-    }>;
-    /**
-     * Download account data export
-     */
-    downloadAccountData(format?: 'json' | 'csv'): Promise<Blob>;
-    /**
-     * Delete account permanently
-     * @param password - User password for confirmation
-     * @param confirmText - Confirmation text (usually username)
-     */
-    deleteAccount(password: string, confirmText: string): Promise<{
-        message: string;
-    }>;
-    /**
-     * Get the current language from storage or user profile
-     * @param storageKeyPrefix - Optional prefix for storage key (default: 'oxy_session')
-     * @returns The current language code (e.g., 'en-US') or null if not set
-     */
-    getCurrentLanguage(storageKeyPrefix?: string): Promise<string | null>;
-    /**
-     * Get the current language with metadata (name, nativeName, etc.)
-     * @param storageKeyPrefix - Optional prefix for storage key (default: 'oxy_session')
-     * @returns Language metadata object or null if not set
-     */
-    getCurrentLanguageMetadata(storageKeyPrefix?: string): Promise<LanguageMetadata | null>;
-    /**
-     * Get the current language name (e.g., 'English')
-     * @param storageKeyPrefix - Optional prefix for storage key (default: 'oxy_session')
-     * @returns Language name or null if not set
-     */
-    getCurrentLanguageName(storageKeyPrefix?: string): Promise<string | null>;
-    /**
-     * Get the current native language name (e.g., 'Español')
-     * @param storageKeyPrefix - Optional prefix for storage key (default: 'oxy_session')
-     * @returns Native language name or null if not set
-     */
-    getCurrentNativeLanguageName(storageKeyPrefix?: string): Promise<string | null>;
-    /**
-     * Get appropriate storage for the platform (similar to DeviceManager)
-     * @private
-     */
-    private getStorage;
-    /**
-     * Update user by ID (admin function)
-     */
-    updateUser(userId: string, updates: Record<string, any>): Promise<User>;
-    /**
-     * Follow a user
-     */
-    followUser(userId: string): Promise<{
-        success: boolean;
-        message: string;
-    }>;
-    /**
-     * Unfollow a user
-     */
-    unfollowUser(userId: string): Promise<{
-        success: boolean;
-        message: string;
-    }>;
-    /**
-     * Get follow status
-     */
-    getFollowStatus(userId: string): Promise<{
-        isFollowing: boolean;
-    }>;
-    /**
-     * Get user followers
-     */
-    getUserFollowers(userId: string, pagination?: PaginationParams): Promise<{
-        followers: User[];
-        total: number;
-        hasMore: boolean;
-    }>;
-    /**
-     * Get user following
-     */
-    getUserFollowing(userId: string, pagination?: PaginationParams): Promise<{
-        following: User[];
-        total: number;
-        hasMore: boolean;
-    }>;
-    /**
-     * Get notifications
-     */
-    getNotifications(): Promise<Notification[]>;
-    /**
-     * Get unread notification count
-     */
-    getUnreadCount(): Promise<number>;
-    /**
-     * Create notification
-     */
-    createNotification(data: Partial<Notification>): Promise<Notification>;
-    /**
-     * Mark notification as read
-     */
-    markNotificationAsRead(notificationId: string): Promise<void>;
-    /**
-     * Mark all notifications as read
-     */
-    markAllNotificationsAsRead(): Promise<void>;
-    /**
-     * Delete notification
-     */
-    deleteNotification(notificationId: string): Promise<void>;
-    /**
-     * Create a payment
-     */
-    createPayment(data: any): Promise<any>;
-    /**
-     * Get payment by ID
-     */
-    getPayment(paymentId: string): Promise<any>;
-    /**
-     * Get user payments
-     */
-    getUserPayments(): Promise<any[]>;
-    /**
-     * Get user karma
-     */
-    getUserKarma(userId: string): Promise<any>;
-    /**
-     * Give karma to user
-     */
-    giveKarma(userId: string, amount: number, reason?: string): Promise<any>;
-    /**
-     * Get user karma total
-     */
-    getUserKarmaTotal(userId: string): Promise<any>;
-    /**
-     * Get user karma history
-     */
-    getUserKarmaHistory(userId: string, limit?: number, offset?: number): Promise<any>;
-    /**
-     * Get karma leaderboard
-     */
-    getKarmaLeaderboard(): Promise<any>;
-    /**
-     * Get karma rules
-     */
-    getKarmaRules(): Promise<any>;
-    /**
-     * Delete file
-     */
-    deleteFile(fileId: string): Promise<any>;
-    /**
-     * Get file download URL (API streaming proxy, attaches token for <img src>)
-     */
-    getFileDownloadUrl(fileId: string, variant?: string, expiresIn?: number): string;
-    /**
-     * Get file stream URL (direct Oxy Cloud/CDN URL, no token)
-     */
-    getFileStreamUrl(fileId: string): string;
-    /**
-     * List user files
-     */
-    listUserFiles(limit?: number, offset?: number): Promise<{
-        files: any[];
-        total: number;
-        hasMore: boolean;
-    }>;
-    /**
-     * Get file content as text
-     */
-    getFileContentAsText(fileId: string, variant?: string): Promise<string>;
-    /**
-     * Get file content as blob
-     */
-    getFileContentAsBlob(fileId: string, variant?: string): Promise<Blob>;
-    /**
-     * Upload raw file data
-     */
-    uploadRawFile(file: File | Blob, visibility?: 'private' | 'public' | 'unlisted', metadata?: Record<string, any>): Promise<any>;
-    /**
-     * Calculate SHA256 hash of file content
-     */
-    calculateSHA256(file: File | Blob): Promise<string>;
-    /**
-     * Initialize asset upload - returns pre-signed URL and file ID
-     */
-    assetInit(sha256: string, size: number, mime: string): Promise<AssetInitResponse>;
-    /**
-     * Complete asset upload - commit metadata and trigger variant generation
-     */
-    assetComplete(fileId: string, originalName: string, size: number, mime: string, visibility?: 'private' | 'public' | 'unlisted', metadata?: Record<string, any>): Promise<any>;
-    /**
-     * Upload file using Central Asset Service
-     */
-    assetUpload(file: File, visibility?: 'private' | 'public' | 'unlisted', metadata?: Record<string, any>, onProgress?: (progress: number) => void): Promise<any>;
-    /**
-     * Upload file to pre-signed URL
-     */
-    private uploadToPresignedUrl;
-    /**
-     * Link asset to an entity
-     */
-    assetLink(fileId: string, app: string, entityType: string, entityId: string, visibility?: 'private' | 'public' | 'unlisted', webhookUrl?: string): Promise<any>;
-    /**
-     * Unlink asset from an entity
-     */
-    assetUnlink(fileId: string, app: string, entityType: string, entityId: string): Promise<any>;
-    /**
-     * Get asset metadata
-     */
-    assetGet(fileId: string): Promise<any>;
-    /**
-     * Get asset URL (CDN or signed URL)
-     */
-    assetGetUrl(fileId: string, variant?: string, expiresIn?: number): Promise<AssetUrlResponse>;
-    /**
-     * Restore asset from trash
-     */
-    assetRestore(fileId: string): Promise<any>;
-    /**
-     * Delete asset with optional force
-     */
-    assetDelete(fileId: string, force?: boolean): Promise<any>;
-    /**
-     * Get list of available variants for an asset
-     */
-    assetGetVariants(fileId: string): Promise<AssetVariant[]>;
-    /**
-     * Update asset visibility
-     * @param fileId - The file ID
-     * @param visibility - New visibility level ('private', 'public', or 'unlisted')
-     * @returns Updated asset information
-     */
-    assetUpdateVisibility(fileId: string, visibility: 'private' | 'public' | 'unlisted'): Promise<any>;
-    /**
-     * Helper: Upload and link avatar with automatic public visibility
-     * @param file - The avatar file
-     * @param userId - User ID to link to
-     * @param app - App name (defaults to 'profiles')
-     * @returns The uploaded and linked asset
-     */
-    uploadAvatar(file: File, userId: string, app?: string): Promise<any>;
-    /**
-     * Helper: Upload and link profile banner with automatic public visibility
-     * @param file - The banner file
-     * @param userId - User ID to link to
-     * @param app - App name (defaults to 'profiles')
-     * @returns The uploaded and linked asset
-     */
-    uploadProfileBanner(file: File, userId: string, app?: string): Promise<any>;
-    /**
-     * Get developer apps for the current user
-     */
-    getDeveloperApps(): Promise<any[]>;
-    /**
-     * Create a new developer app
-     */
-    createDeveloperApp(data: {
-        name: string;
-        description?: string;
-        webhookUrl: string;
-        devWebhookUrl?: string;
-        scopes?: string[];
-    }): Promise<any>;
-    /**
-     * Get a specific developer app
-     */
-    getDeveloperApp(appId: string): Promise<any>;
-    /**
-     * Update a developer app
-     */
-    updateDeveloperApp(appId: string, data: {
-        name?: string;
-        description?: string;
-        webhookUrl?: string;
-        devWebhookUrl?: string;
-        scopes?: string[];
-    }): Promise<any>;
-    /**
-     * Regenerate API secret for a developer app
-     */
-    regenerateDeveloperAppSecret(appId: string): Promise<any>;
-    /**
-     * Delete a developer app
-     */
-    deleteDeveloperApp(appId: string): Promise<any>;
-    /**
-     * Update user location
-     */
-    updateLocation(latitude: number, longitude: number): Promise<any>;
-    /**
-     * Get nearby users
-     */
-    getNearbyUsers(radius?: number): Promise<any[]>;
-    /**
-     * Track event
-     */
-    trackEvent(eventName: string, properties?: Record<string, any>): Promise<void>;
-    /**
-     * Get analytics data
-     */
-    getAnalytics(startDate?: string, endDate?: string): Promise<any>;
-    /**
-     * Register device
-     */
-    registerDevice(deviceData: any): Promise<any>;
-    /**
-     * Get user devices
-     */
-    getUserDevices(): Promise<any[]>;
-    /**
-     * Remove device
-     */
-    removeDevice(deviceId: string): Promise<void>;
-    /**
-     * Get device sessions
-     * Note: Not cached by default to ensure fresh data, but can be cached via makeRequest if needed
-     */
-    getDeviceSessions(sessionId: string): Promise<any[]>;
-    /**
-     * Logout all device sessions
-     */
-    logoutAllDeviceSessions(sessionId: string, deviceId?: string, excludeCurrent?: boolean): Promise<any>;
-    /**
-     * Update device name
-     */
-    updateDeviceName(sessionId: string, deviceName: string): Promise<any>;
-    /**
-     * Fetch link metadata
-     */
-    fetchLinkMetadata(url: string): Promise<{
-        url: string;
-        title: string;
-        description: string;
-        image?: string;
-    }>;
-    /**
-     * Simple Express.js authentication middleware
-     *
-     * Built-in authentication middleware that validates JWT tokens and adds user data to requests.
-     *
-     * @example
-     * ```typescript
-     * // Basic usage - just add it to your routes
-     * app.use('/api/protected', oxyServices.auth());
-     *
-     * // With debug logging
-     * app.use('/api/protected', oxyServices.auth({ debug: true }));
-     *
-     * // With custom error handling
-     * app.use('/api/protected', oxyServices.auth({
-     *   onError: (error) => console.error('Auth failed:', error)
-     * }));
-     *
-     * // Load full user data
-     * app.use('/api/protected', oxyServices.auth({ loadUser: true }));
-     * ```
-     *
-     * @param options Optional configuration
-     * @param options.debug Enable debug logging (default: false)
-     * @param options.onError Custom error handler
-     * @param options.loadUser Load full user data (default: false for performance)
-     * @param options.session Use session-based validation (default: false)
-     * @returns Express middleware function
-     */
-    auth(options?: {
-        debug?: boolean;
-        onError?: (error: ApiError) => any;
-        loadUser?: boolean;
-        session?: boolean;
-    }): (req: any, res: any, next: any) => any;
+        getCloudURL(): string;
+        setTokens(accessToken: string, refreshToken?: string): void;
+        clearTokens(): void;
+        getCurrentUserId(): string | null;
+        hasValidToken(): boolean;
+        getAccessToken(): string | null;
+        waitForAuth(timeoutMs?: number): Promise<boolean>;
+        waitForAuthentication(timeoutMs?: number): Promise<boolean>;
+        hasAccessToken(): boolean;
+        withAuthRetry<T>(operation: () => Promise<T>, operationName: string, options?: {
+            maxRetries?: number;
+            retryDelay?: number;
+            authTimeoutMs?: number;
+        }): Promise<T>;
+        validate(): Promise<boolean>;
+        handleError(error: any): Error;
+        healthCheck(): Promise<{
+            status: string;
+            users?: number;
+            timestamp?: string;
+            [key: string]: any;
+        }>;
+    };
+    __resetTokensForTests(): void;
+} & {
+    new (...args: any[]): {
+        getProfileByUsername(username: string): Promise<import(".").User>;
+        searchProfiles(query: string, pagination?: import("..").PaginationParams): Promise<import(".").SearchProfilesResponse>;
+        getProfileRecommendations(): Promise<{
+            [key: string]: any;
+            id: string;
+            username: string;
+            name?: {
+                first?: string;
+                last?: string;
+                full?: string;
+            } | undefined;
+            description?: string;
+            _count?: {
+                followers: number;
+                following: number;
+            } | undefined;
+        }[]>;
+        getUserById(userId: string): Promise<import(".").User>;
+        getCurrentUser(): Promise<import(".").User>;
+        updateProfile(updates: Record<string, any>): Promise<import(".").User>;
+        getPrivacySettings(userId?: string): Promise<any>;
+        updatePrivacySettings(settings: Record<string, any>, userId?: string): Promise<any>;
+        requestAccountVerification(reason: string, evidence?: string): Promise<{
+            message: string;
+            requestId: string;
+        }>;
+        downloadAccountData(format?: "json" | "csv"): Promise<Blob>;
+        deleteAccount(password: string, confirmText: string): Promise<{
+            message: string;
+        }>;
+        updateUser(userId: string, updates: Record<string, any>): Promise<import(".").User>;
+        followUser(userId: string): Promise<{
+            success: boolean;
+            message: string;
+        }>;
+        unfollowUser(userId: string): Promise<{
+            success: boolean;
+            message: string;
+        }>;
+        getFollowStatus(userId: string): Promise<{
+            isFollowing: boolean;
+        }>;
+        getUserFollowers(userId: string, pagination?: import("..").PaginationParams): Promise<{
+            followers: import(".").User[];
+            total: number;
+            hasMore: boolean;
+        }>;
+        getUserFollowing(userId: string, pagination?: import("..").PaginationParams): Promise<{
+            following: import(".").User[];
+            total: number;
+            hasMore: boolean;
+        }>;
+        getNotifications(): Promise<import(".").Notification[]>;
+        getUnreadCount(): Promise<number>;
+        createNotification(data: Partial<import(".").Notification>): Promise<import(".").Notification>;
+        markNotificationAsRead(notificationId: string): Promise<void>;
+        markAllNotificationsAsRead(): Promise<void>;
+        deleteNotification(notificationId: string): Promise<void>;
+        httpClient: import("./HttpClient").HttpClient;
+        requestManager: import("./RequestManager").RequestManager;
+        cloudURL: string;
+        config: OxyConfig;
+        makeRequest<T>(method: "GET" | "POST" | "PUT" | "PATCH" | "DELETE", url: string, data?: any, options?: import("./RequestManager").RequestOptions): Promise<T>;
+        getBaseURL(): string;
+        getClient(): import("./HttpClient").HttpClient;
+        getMetrics(): {
+            totalRequests: number;
+            successfulRequests: number;
+            failedRequests: number;
+            cacheHits: number;
+            cacheMisses: number;
+            averageResponseTime: number;
+        };
+        clearCache(): void;
+        clearCacheEntry(key: string): void;
+        getCacheStats(): {
+            size: number;
+            hits: number;
+            misses: number;
+            hitRate: number;
+        };
+        getCloudURL(): string;
+        setTokens(accessToken: string, refreshToken?: string): void;
+        clearTokens(): void;
+        getCurrentUserId(): string | null;
+        hasValidToken(): boolean;
+        getAccessToken(): string | null;
+        waitForAuth(timeoutMs?: number): Promise<boolean>;
+        waitForAuthentication(timeoutMs?: number): Promise<boolean>;
+        hasAccessToken(): boolean;
+        withAuthRetry<T>(operation: () => Promise<T>, operationName: string, options?: {
+            maxRetries?: number;
+            retryDelay?: number;
+            authTimeoutMs?: number;
+        }): Promise<T>;
+        validate(): Promise<boolean>;
+        handleError(error: any): Error;
+        healthCheck(): Promise<{
+            status: string;
+            users?: number;
+            timestamp?: string;
+            [key: string]: any;
+        }>;
+    };
+    __resetTokensForTests(): void;
+} & {
+    new (...args: any[]): {
+        signUp(username: string, email: string, password: string): Promise<{
+            message: string;
+            token: string;
+            user: import(".").User;
+        }>;
+        requestRecovery(identifier: string): Promise<{
+            delivery?: string;
+            destination?: string;
+        }>;
+        verifyRecoveryCode(identifier: string, code: string): Promise<{
+            verified: boolean;
+        }>;
+        resetPassword(identifier: string, code: string, newPassword: string): Promise<{
+            success: boolean;
+        }>;
+        resetPasswordWithTotp(identifier: string, code: string, newPassword: string): Promise<{
+            success: boolean;
+        }>;
+        resetPasswordWithBackupCode(identifier: string, backupCode: string, newPassword: string): Promise<{
+            success: boolean;
+        }>;
+        resetPasswordWithRecoveryKey(identifier: string, recoveryKey: string, newPassword: string): Promise<{
+            success: boolean;
+            nextRecoveryKey?: string;
+        }>;
+        signIn(username: string, password: string, deviceName?: string, deviceFingerprint?: any): Promise<import(".").SessionLoginResponse | {
+            mfaRequired: true;
+            mfaToken: string;
+            expiresAt: string;
+        }>;
+        verifyTotpLogin(mfaToken: string, code: string): Promise<import(".").SessionLoginResponse>;
+        getUserBySession(sessionId: string): Promise<import(".").User>;
+        getUsersBySessions(sessionIds: string[]): Promise<{
+            sessionId: string;
+            user: import(".").User | null;
+        }[]>;
+        getTokenBySession(sessionId: string): Promise<{
+            accessToken: string;
+            expiresAt: string;
+        }>;
+        getSessionsBySessionId(sessionId: string): Promise<any[]>;
+        logoutSession(sessionId: string, targetSessionId?: string): Promise<void>;
+        logoutAllSessions(sessionId: string): Promise<void>;
+        validateSession(sessionId: string, options?: {
+            deviceFingerprint?: string;
+            useHeaderValidation?: boolean;
+        }): Promise<{
+            valid: boolean;
+            expiresAt: string;
+            lastActivity: string;
+            user: import(".").User;
+            sessionId?: string;
+            source?: string;
+        }>;
+        checkUsernameAvailability(username: string): Promise<{
+            available: boolean;
+            message: string;
+        }>;
+        checkEmailAvailability(email: string): Promise<{
+            available: boolean;
+            message: string;
+        }>;
+        httpClient: import("./HttpClient").HttpClient;
+        requestManager: import("./RequestManager").RequestManager;
+        cloudURL: string;
+        config: OxyConfig;
+        makeRequest<T>(method: "GET" | "POST" | "PUT" | "PATCH" | "DELETE", url: string, data?: any, options?: import("./RequestManager").RequestOptions): Promise<T>;
+        getBaseURL(): string;
+        getClient(): import("./HttpClient").HttpClient;
+        getMetrics(): {
+            totalRequests: number;
+            successfulRequests: number;
+            failedRequests: number;
+            cacheHits: number;
+            cacheMisses: number;
+            averageResponseTime: number;
+        };
+        clearCache(): void;
+        clearCacheEntry(key: string): void;
+        getCacheStats(): {
+            size: number;
+            hits: number;
+            misses: number;
+            hitRate: number;
+        };
+        getCloudURL(): string;
+        setTokens(accessToken: string, refreshToken?: string): void;
+        clearTokens(): void;
+        getCurrentUserId(): string | null;
+        hasValidToken(): boolean;
+        getAccessToken(): string | null;
+        waitForAuth(timeoutMs?: number): Promise<boolean>;
+        waitForAuthentication(timeoutMs?: number): Promise<boolean>;
+        hasAccessToken(): boolean;
+        withAuthRetry<T>(operation: () => Promise<T>, operationName: string, options?: {
+            maxRetries?: number;
+            retryDelay?: number;
+            authTimeoutMs?: number;
+        }): Promise<T>;
+        validate(): Promise<boolean>;
+        handleError(error: any): Error;
+        healthCheck(): Promise<{
+            status: string;
+            users?: number;
+            timestamp?: string;
+            [key: string]: any;
+        }>;
+    };
+    __resetTokensForTests(): void;
+} & typeof OxyServicesBase;
+export declare class OxyServices extends OxyServicesComposed {
+    constructor(config: OxyConfig);
 }
+export { OxyAuthenticationError, OxyAuthenticationTimeoutError };
 /**
  * Export the default Oxy Cloud URL (for backward compatibility)
  */