/**
 * Centralized mixin exports and composition helper
 *
 * This module provides a clean way to compose all mixins
 * and ensures consistent ordering for better maintainability
 */
import { OxyServicesBase } from '../OxyServices.base';
/**
 * Composes all OxyServices mixins in the correct order
 *
 * Order matters for mixins - dependencies should be applied first.
 * This function ensures consistent composition across the codebase.
 *
 * @returns The fully composed OxyServices class with all mixins applied
 */
export declare function composeOxyServices(): {
    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;
        httpService: import("../HttpService").HttpService;
        cloudURL: string;
        config: import("../OxyServices.base").OxyConfig;
        makeRequest<T>(method: "GET" | "POST" | "PUT" | "PATCH" | "DELETE", url: string, data?: any, options?: import("../HttpService").RequestOptions): Promise<T>;
        getBaseURL(): string;
        getClient(): import("../HttpService").HttpService;
        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>;
        withAuthRetry<T>(operation: () => Promise<T>, operationName: string, options?: {
            maxRetries?: number;
            retryDelay?: number;
            authTimeoutMs?: number;
        }): Promise<T>;
        validate(): Promise<boolean>;
        handleError(error: unknown): Error;
        healthCheck(): Promise<{
            status: string;
            users?: number;
            timestamp?: string;
            [key: string]: any;
        }>;
    };
    __resetTokensForTests(): void;
} & {
    new (...args: any[]): {
        getSecurityActivity(limit?: number, offset?: number, eventType?: import("..").SecurityEventType): Promise<import("..").SecurityActivityResponse>;
        getRecentSecurityActivity(limit?: number): Promise<import("..").SecurityActivity[]>;
        httpService: import("../HttpService").HttpService;
        cloudURL: string;
        config: import("../OxyServices.base").OxyConfig;
        makeRequest<T>(method: "GET" | "POST" | "PUT" | "PATCH" | "DELETE", url: string, data?: any, options?: import("../HttpService").RequestOptions): Promise<T>;
        getBaseURL(): string;
        getClient(): import("../HttpService").HttpService;
        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>;
        withAuthRetry<T>(operation: () => Promise<T>, operationName: string, options?: {
            maxRetries?: number;
            retryDelay?: number;
            authTimeoutMs?: number;
        }): Promise<T>;
        validate(): Promise<boolean>;
        handleError(error: unknown): 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>;
        getSecurityInfo(): Promise<{
            recoveryEmail: string | null;
        }>;
        httpService: import("../HttpService").HttpService;
        cloudURL: string;
        config: import("../OxyServices.base").OxyConfig;
        makeRequest<T>(method: "GET" | "POST" | "PUT" | "PATCH" | "DELETE", url: string, data?: any, options?: import("../HttpService").RequestOptions): Promise<T>;
        getBaseURL(): string;
        getClient(): import("../HttpService").HttpService;
        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>;
        withAuthRetry<T>(operation: () => Promise<T>, operationName: string, options?: {
            maxRetries?: number;
            retryDelay?: number;
            authTimeoutMs?: number;
        }): Promise<T>;
        validate(): Promise<boolean>;
        handleError(error: unknown): 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>;
        httpService: import("../HttpService").HttpService;
        cloudURL: string;
        config: import("../OxyServices.base").OxyConfig;
        makeRequest<T>(method: "GET" | "POST" | "PUT" | "PATCH" | "DELETE", url: string, data?: any, options?: import("../HttpService").RequestOptions): Promise<T>;
        getBaseURL(): string;
        getClient(): import("../HttpService").HttpService;
        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>;
        withAuthRetry<T>(operation: () => Promise<T>, operationName: string, options?: {
            maxRetries?: number;
            retryDelay?: number;
            authTimeoutMs?: number;
        }): Promise<T>;
        validate(): Promise<boolean>;
        handleError(error: unknown): 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[]>;
        httpService: import("../HttpService").HttpService;
        cloudURL: string;
        config: import("../OxyServices.base").OxyConfig;
        makeRequest<T>(method: "GET" | "POST" | "PUT" | "PATCH" | "DELETE", url: string, data?: any, options?: import("../HttpService").RequestOptions): Promise<T>;
        getBaseURL(): string;
        getClient(): import("../HttpService").HttpService;
        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>;
        withAuthRetry<T>(operation: () => Promise<T>, operationName: string, options?: {
            maxRetries?: number;
            retryDelay?: number;
            authTimeoutMs?: number;
        }): Promise<T>;
        validate(): Promise<boolean>;
        handleError(error: unknown): 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>;
        httpService: import("../HttpService").HttpService;
        cloudURL: string;
        config: import("../OxyServices.base").OxyConfig;
        makeRequest<T>(method: "GET" | "POST" | "PUT" | "PATCH" | "DELETE", url: string, data?: any, options?: import("../HttpService").RequestOptions): Promise<T>;
        getBaseURL(): string;
        getClient(): import("../HttpService").HttpService;
        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>;
        withAuthRetry<T>(operation: () => Promise<T>, operationName: string, options?: {
            maxRetries?: number;
            retryDelay?: number;
            authTimeoutMs?: number;
        }): Promise<T>;
        validate(): Promise<boolean>;
        handleError(error: unknown): 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>;
        listUserFiles(limit?: number, offset?: number): Promise<{
            files: any[];
            total: number;
            hasMore: boolean;
        }>;
        getAccountStorageUsage(): Promise<import("..").AccountStorageUsageResponse>;
        getFileContentAsText(fileId: string, variant?: string): Promise<string>;
        getFileContentAsBlob(fileId: string, variant?: string): Promise<Blob>;
        getBatchFileAccess(fileIds: string[], context?: string): Promise<Record<string, any>>;
        getFileDownloadUrls(fileIds: string[], context?: string): Promise<Record<string, string>>;
        uploadRawFile(file: File | Blob, 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>;
        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>;
        getAssetUrlCacheTTL(expiresIn?: number): number;
        fetchAssetDownloadUrl(fileId: string, variant?: string, cacheTTL?: number, expiresIn?: number): Promise<string | null>;
        fetchAssetContent(url: string, type: "text"): Promise<string>;
        fetchAssetContent(url: string, type: "blob"): Promise<Blob>;
        httpService: import("../HttpService").HttpService;
        cloudURL: string;
        config: import("../OxyServices.base").OxyConfig;
        makeRequest<T>(method: "GET" | "POST" | "PUT" | "PATCH" | "DELETE", url: string, data?: any, options?: import("../HttpService").RequestOptions): Promise<T>;
        getBaseURL(): string;
        getClient(): import("../HttpService").HttpService;
        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>;
        withAuthRetry<T>(operation: () => Promise<T>, operationName: string, options?: {
            maxRetries?: number;
            retryDelay?: number;
            authTimeoutMs?: number;
        }): Promise<T>;
        validate(): Promise<boolean>;
        handleError(error: unknown): 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>;
        httpService: import("../HttpService").HttpService;
        cloudURL: string;
        config: import("../OxyServices.base").OxyConfig;
        makeRequest<T>(method: "GET" | "POST" | "PUT" | "PATCH" | "DELETE", url: string, data?: any, options?: import("../HttpService").RequestOptions): Promise<T>;
        getBaseURL(): string;
        getClient(): import("../HttpService").HttpService;
        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>;
        withAuthRetry<T>(operation: () => Promise<T>, operationName: string, options?: {
            maxRetries?: number;
            retryDelay?: number;
            authTimeoutMs?: number;
        }): Promise<T>;
        validate(): Promise<boolean>;
        handleError(error: unknown): 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[]>;
        getSubscription(userId: string): Promise<any>;
        getCurrentUserSubscription(): Promise<any>;
        getWallet(userId: string): Promise<any>;
        getCurrentUserWallet(): Promise<any>;
        getWalletTransactions(userId: string, options?: {
            limit?: number;
            offset?: number;
        } | undefined): Promise<any>;
        getCurrentUserWalletTransactions(options?: {
            limit?: number;
            offset?: number;
        } | undefined): Promise<any>;
        httpService: import("../HttpService").HttpService;
        cloudURL: string;
        config: import("../OxyServices.base").OxyConfig;
        makeRequest<T>(method: "GET" | "POST" | "PUT" | "PATCH" | "DELETE", url: string, data?: any, options?: import("../HttpService").RequestOptions): Promise<T>;
        getBaseURL(): string;
        getClient(): import("../HttpService").HttpService;
        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>;
        withAuthRetry<T>(operation: () => Promise<T>, operationName: string, options?: {
            maxRetries?: number;
            retryDelay?: number;
            authTimeoutMs?: number;
        }): Promise<T>;
        validate(): Promise<boolean>;
        handleError(error: unknown): 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>;
        httpService: import("../HttpService").HttpService;
        cloudURL: string;
        config: import("../OxyServices.base").OxyConfig;
        makeRequest<T>(method: "GET" | "POST" | "PUT" | "PATCH" | "DELETE", url: string, data?: any, options?: import("../HttpService").RequestOptions): Promise<T>;
        getBaseURL(): string;
        getClient(): import("../HttpService").HttpService;
        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>;
        withAuthRetry<T>(operation: () => Promise<T>, operationName: string, options?: {
            maxRetries?: number;
            retryDelay?: number;
            authTimeoutMs?: number;
        }): Promise<T>;
        validate(): Promise<boolean>;
        handleError(error: unknown): Error;
        healthCheck(): Promise<{
            status: string;
            users?: number;
            timestamp?: string;
            [key: string]: any;
        }>;
    };
    __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>;
        httpService: import("../HttpService").HttpService;
        cloudURL: string;
        config: import("../OxyServices.base").OxyConfig;
        makeRequest<T>(method: "GET" | "POST" | "PUT" | "PATCH" | "DELETE", url: string, data?: any, options?: import("../HttpService").RequestOptions): Promise<T>;
        getBaseURL(): string;
        getClient(): import("../HttpService").HttpService;
        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>;
        withAuthRetry<T>(operation: () => Promise<T>, operationName: string, options?: {
            maxRetries?: number;
            retryDelay?: number;
            authTimeoutMs?: number;
        }): Promise<T>;
        validate(): Promise<boolean>;
        handleError(error: unknown): 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;
        }>;
        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>;
        httpService: import("../HttpService").HttpService;
        cloudURL: string;
        config: import("../OxyServices.base").OxyConfig;
        makeRequest<T>(method: "GET" | "POST" | "PUT" | "PATCH" | "DELETE", url: string, data?: any, options?: import("../HttpService").RequestOptions): Promise<T>;
        getBaseURL(): string;
        getClient(): import("../HttpService").HttpService;
        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>;
        withAuthRetry<T>(operation: () => Promise<T>, operationName: string, options?: {
            maxRetries?: number;
            retryDelay?: number;
            authTimeoutMs?: number;
        }): Promise<T>;
        validate(): Promise<boolean>;
        handleError(error: unknown): Error;
        healthCheck(): Promise<{
            status: string;
            users?: number;
            timestamp?: string;
            [key: string]: any;
        }>;
    };
    __resetTokensForTests(): void;
} & {
    new (...args: any[]): {
        register(publicKey: string, signature: string, timestamp: number): Promise<{
            message: string;
            user: import("..").User;
        }>;
        requestChallenge(publicKey: string): Promise<import("./OxyServices.auth").ChallengeResponse>;
        verifyChallenge(publicKey: string, challenge: string, signature: string, timestamp: number, deviceName?: string, deviceFingerprint?: string): Promise<import("..").SessionLoginResponse>;
        checkPublicKeyRegistered(publicKey: string): Promise<import("./OxyServices.auth").PublicKeyCheckResponse>;
        getUserByPublicKey(publicKey: string): Promise<import("..").User>;
        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;
        }>;
        signUp(username: string, email: string, password: string): Promise<{
            message: string;
            token: string;
            user: import("..").User;
        }>;
        signIn(username: string, password: string, deviceName?: string, deviceFingerprint?: any): Promise<import("..").SessionLoginResponse | {
            mfaRequired: true;
            mfaToken: string;
            expiresAt: string;
        }>;
        httpService: import("../HttpService").HttpService;
        cloudURL: string;
        config: import("../OxyServices.base").OxyConfig;
        makeRequest<T>(method: "GET" | "POST" | "PUT" | "PATCH" | "DELETE", url: string, data?: any, options?: import("../HttpService").RequestOptions): Promise<T>;
        getBaseURL(): string;
        getClient(): import("../HttpService").HttpService;
        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>;
        withAuthRetry<T>(operation: () => Promise<T>, operationName: string, options?: {
            maxRetries?: number;
            retryDelay?: number;
            authTimeoutMs?: number;
        }): Promise<T>;
        validate(): Promise<boolean>;
        handleError(error: unknown): Error;
        healthCheck(): Promise<{
            status: string;
            users?: number;
            timestamp?: string;
            [key: string]: any;
        }>;
    };
    __resetTokensForTests(): void;
} & typeof OxyServicesBase;
//# sourceMappingURL=index.d.ts.map