@oxyhq/services 5.18.0 → 5.18.2

package/lib/typescript/module/core/mixins/index.d.ts

@@ -0,0 +1,1128 @@
+/**
+ * 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.
+ *
+ * New cross-domain auth mixins added:
+ * - FedCM: Modern browser-native identity federation (Google-style)
+ * - Popup: OAuth2-style popup authentication
+ * - Redirect: Traditional redirect-based authentication
+ *
+ * @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, // Base authentication mixin
+        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[]): {
+        submitFeedback(payload: import("./OxyServices.features").FeedbackPayload): Promise<import("./OxyServices.features").FeedbackResult>;
+        getSubscriptionPlans(): Promise<import("./OxyServices.features").SubscriptionPlan[]>;
+        getIndividualFeatures(): Promise<any[]>;
+        subscribe(planId: string, paymentMethodId?: string): Promise<import("./OxyServices.features").SubscriptionResult>;
+        subscribeToFeature(featureId: string, paymentMethodId?: string): Promise<import("./OxyServices.features").SubscriptionResult>;
+        cancelSubscription(subscriptionId: string): Promise<void>;
+        reactivateSubscription(subscriptionId: string): Promise<void>;
+        getCurrentSubscription(): Promise<import("./OxyServices.features").SubscriptionResult | null>;
+        getSavedItems(userId?: string): Promise<import("./OxyServices.features").SavedItem[]>;
+        getCollections(userId?: string): Promise<import("./OxyServices.features").Collection[]>;
+        saveItem(itemId: string, itemType: string, collectionId?: string): Promise<import("./OxyServices.features").SavedItem>;
+        removeSavedItem(saveId: string): Promise<void>;
+        createCollection(name: string, description?: string): Promise<import("./OxyServices.features").Collection>;
+        deleteCollection(collectionId: string): Promise<void>;
+        getUserStats(userId: string): Promise<import("./OxyServices.features").UserStats>;
+        getUserHistory(userId?: string, limit?: number, offset?: number): Promise<import("./OxyServices.features").HistoryItem[]>;
+        clearUserHistory(): Promise<void>;
+        deleteHistoryItem(itemId: string): Promise<void>;
+        getFAQs(category?: string): Promise<import("./OxyServices.features").FAQ[]>;
+        searchFAQs(query: string): Promise<import("./OxyServices.features").FAQ[]>;
+        getUserAchievements(userId?: string): Promise<import("./OxyServices.features").Achievement[]>;
+        getAllAchievements(): Promise<import("./OxyServices.features").Achievement[]>;
+        deleteAccount(password: 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[]): {
+        getSecurityActivity(limit?: number, offset?: number, eventType?: import("..").SecurityEventType): Promise<import("..").SecurityActivityResponse>;
+        getRecentSecurityActivity(limit?: number): Promise<import("..").SecurityActivity[]>;
+        logPrivateKeyExported(deviceId?: string): Promise<void>;
+        logBackupCreated(deviceId?: 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[]): {
+        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[]): {
+        signInWithRedirect(options?: import("./OxyServices.redirect").RedirectAuthOptions): void;
+        signUpWithRedirect(options?: import("./OxyServices.redirect").RedirectAuthOptions): void;
+        handleAuthCallback(): import("..").SessionLoginResponse | null;
+        restoreSession(): boolean;
+        clearStoredSession(): void;
+        getStoredSessionId(): string | null;
+        buildAuthUrl(params: {
+            mode: string;
+            redirectUri: string;
+            state: string;
+            nonce: string;
+            clientId: string;
+        }): string;
+        storeTokens(accessToken: string, sessionId: string): void;
+        generateState(): string;
+        generateNonce(): string;
+        storeAuthState(state: string, nonce: string): void;
+        getStoredState(): string | null;
+        clearAuthState(): void;
+        savePreAuthUrl(url: string): void;
+        cleanAuthCallbackUrl(url: URL): 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;
+        }>;
+    };
+    readonly AUTH_URL: "https://auth.oxy.so";
+    readonly TOKEN_STORAGE_KEY: "oxy_access_token";
+    readonly SESSION_STORAGE_KEY: "oxy_session_id";
+    readonly STATE_STORAGE_KEY: "oxy_auth_state";
+    readonly PRE_AUTH_URL_KEY: "oxy_pre_auth_url";
+    readonly NONCE_STORAGE_KEY: "oxy_auth_nonce";
+    __resetTokensForTests(): void;
+} & {
+    new (...args: any[]): {
+        signInWithPopup(options?: import("./OxyServices.popup").PopupAuthOptions): Promise<import("..").SessionLoginResponse>;
+        signUpWithPopup(options?: import("./OxyServices.popup").PopupAuthOptions): Promise<import("..").SessionLoginResponse>;
+        silentSignIn(options?: import("./OxyServices.popup").SilentAuthOptions): Promise<import("..").SessionLoginResponse | null>;
+        openCenteredPopup(url: string, title: string, width: number, height: number): Window | null;
+        waitForPopupAuth(popup: Window, expectedState: string, timeout: number): Promise<import("..").SessionLoginResponse>;
+        waitForIframeAuth(iframe: HTMLIFrameElement, timeout: number, expectedOrigin: string): Promise<import("..").SessionLoginResponse | null>;
+        buildAuthUrl(params: {
+            mode: string;
+            state: string;
+            nonce: string;
+            clientId: string;
+            redirectUri: string;
+        }): string;
+        generateState(): string;
+        generateNonce(): string;
+        storeAuthState(state: string, nonce: string): void;
+        clearAuthState(state: string): 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;
+        }>;
+    };
+    readonly AUTH_URL: "https://auth.oxy.so";
+    readonly POPUP_WIDTH: 500;
+    readonly POPUP_HEIGHT: 700;
+    readonly POPUP_TIMEOUT: 60000;
+    readonly SILENT_TIMEOUT: 5000;
+    __resetTokensForTests(): void;
+} & {
+    new (...args: any[]): {
+        isFedCMSupported(): boolean;
+        signInWithFedCM(options?: import("./OxyServices.fedcm").FedCMAuthOptions): Promise<import("..").SessionLoginResponse>;
+        silentSignInWithFedCM(): Promise<import("..").SessionLoginResponse | null>;
+        requestIdentityCredential(options: {
+            configURL: string;
+            clientId: string;
+            nonce: string;
+            context?: string;
+            mediation?: "silent" | "optional" | "required";
+        }): Promise<{
+            token: string;
+        } | null>;
+        exchangeIdTokenForSession(idToken: string): Promise<import("..").SessionLoginResponse>;
+        revokeFedCMCredential(): Promise<void>;
+        getFedCMConfig(): import("./OxyServices.fedcm").FedCMConfig;
+        generateNonce(): string;
+        getClientId(): 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;
+        }>;
+    };
+    readonly DEFAULT_CONFIG_URL: "https://auth.oxy.so/fedcm.json";
+    readonly FEDCM_TIMEOUT: 60000;
+    isFedCMSupported(): boolean;
+    __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, deviceName?: string, deviceFingerprint?: any): Promise<import("..").SessionLoginResponse>;
+        signIn(identifier: string, password: string, deviceName?: string, deviceFingerprint?: any): Promise<import("..").SessionLoginResponse>;
+        signInWithEmail(email: string, password: string, deviceName?: string, deviceFingerprint?: any): Promise<import("..").SessionLoginResponse>;
+        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