@oxyhq/services 5.13.15 → 5.13.16

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

@@ -0,0 +1,93 @@
+/**
+ * Device Methods Mixin
+ */
+import type { OxyServicesBase } from '../OxyServices.base';
+export declare function OxyServicesDevicesMixin<T extends typeof OxyServicesBase>(Base: T): {
+    new (...args: any[]): {
+        /**
+         * Register a new device
+         * @param deviceData - Device information
+         * @returns Registered device object
+         */
+        registerDevice(deviceData: any): Promise<any>;
+        /**
+         * Get all devices for the current user
+         * @returns Array of user devices
+         */
+        getUserDevices(): Promise<any[]>;
+        /**
+         * Remove a device
+         * @param deviceId - The device ID to remove
+         */
+        removeDevice(deviceId: string): Promise<void>;
+        /**
+         * Get device sessions for a given session ID
+         * Note: Not cached by default to ensure fresh data
+         * @param sessionId - The session ID
+         * @returns Array of device sessions
+         */
+        getDeviceSessions(sessionId: string): Promise<any[]>;
+        /**
+         * Logout all device sessions
+         * @param sessionId - The session ID
+         * @param deviceId - Optional device ID to target
+         * @param excludeCurrent - Whether to exclude the current session
+         * @returns Logout result
+         */
+        logoutAllDeviceSessions(sessionId: string, deviceId?: string, excludeCurrent?: boolean): Promise<any>;
+        /**
+         * Update device name
+         * @param sessionId - The session ID
+         * @param deviceName - New device name
+         * @returns Updated device object
+         */
+        updateDeviceName(sessionId: string, deviceName: string): Promise<any>;
+        httpClient: import("../HttpClient").HttpClient;
+        requestManager: import("../RequestManager").RequestManager;
+        cloudURL: string;
+        config: import("../OxyServices.base").OxyConfig;
+        makeRequest<T_1>(method: "GET" | "POST" | "PUT" | "PATCH" | "DELETE", url: string, data?: any, options?: import("../RequestManager").RequestOptions): Promise<T_1>;
+        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_1>(operation: () => Promise<T_1>, operationName: string, options?: {
+            maxRetries?: number;
+            retryDelay?: number;
+            authTimeoutMs?: number;
+        }): Promise<T_1>;
+        validate(): Promise<boolean>;
+        handleError(error: any): Error;
+        healthCheck(): Promise<{
+            status: string;
+            users?: number;
+            timestamp?: string;
+            [key: string]: any;
+        }>;
+    };
+    __resetTokensForTests(): void;
+} & T;
+//# sourceMappingURL=OxyServices.devices.d.ts.map

package/lib/typescript/core/mixins/OxyServices.devices.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"OxyServices.devices.d.ts","sourceRoot":"","sources":["../../../../src/core/mixins/OxyServices.devices.ts"],"names":[],"mappings":"AAAA;;GAEG;AACH,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,qBAAqB,CAAC;AAE3D,wBAAgB,uBAAuB,CAAC,CAAC,SAAS,OAAO,eAAe,EAAE,IAAI,EAAE,CAAC;kBAExD,GAAG,EAAE;QAI1B;;;;WAIG;mCAC8B,GAAG,GAAG,OAAO,CAAC,GAAG,CAAC;QAQnD;;;WAGG;0BACqB,OAAO,CAAC,GAAG,EAAE,CAAC;QAUtC;;;WAGG;+BAC0B,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;QAQnD;;;;;WAKG;qCACgC,MAAM,GAAG,OAAO,CAAC,GAAG,EAAE,CAAC;QAa1D;;;;;;WAMG;2CACsC,MAAM,aAAa,MAAM,mBAAmB,OAAO,GAAG,OAAO,CAAC,GAAG,CAAC;QAW3G;;;;;WAKG;oCAC+B,MAAM,cAAc,MAAM,GAAG,OAAO,CAAC,GAAG,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;sBAU08D,CAAC;sBAA0B,CAAC;yBAA6B,CAAC;;;;;;iBAA4wF,CAAC;qBAAwB,CAAC;;;;;MAFx3J"}

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

@@ -0,0 +1,89 @@
+/**
+ * Karma Methods Mixin
+ *
+ * Provides methods for karma system management
+ */
+import type { OxyServicesBase } from '../OxyServices.base';
+export declare function OxyServicesKarmaMixin<T extends typeof OxyServicesBase>(Base: T): {
+    new (...args: 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
+         * @param userId - The user ID
+         * @returns User karma total
+         */
+        getUserKarmaTotal(userId: string): Promise<any>;
+        /**
+         * Get user karma history
+         * @param userId - The user ID
+         * @param limit - Optional limit for results
+         * @param offset - Optional offset for pagination
+         * @returns User karma history
+         */
+        getUserKarmaHistory(userId: string, limit?: number, offset?: number): Promise<any>;
+        /**
+         * Get karma leaderboard
+         * @returns Karma leaderboard
+         */
+        getKarmaLeaderboard(): Promise<any>;
+        /**
+         * Get karma rules
+         * @returns Karma rules
+         */
+        getKarmaRules(): Promise<any>;
+        httpClient: import("../HttpClient").HttpClient;
+        requestManager: import("../RequestManager").RequestManager;
+        cloudURL: string;
+        config: import("../OxyServices.base").OxyConfig;
+        makeRequest<T_1>(method: "GET" | "POST" | "PUT" | "PATCH" | "DELETE", url: string, data?: any, options?: import("../RequestManager").RequestOptions): Promise<T_1>;
+        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_1>(operation: () => Promise<T_1>, operationName: string, options?: {
+            maxRetries?: number;
+            retryDelay?: number;
+            authTimeoutMs?: number;
+        }): Promise<T_1>;
+        validate(): Promise<boolean>;
+        handleError(error: any): Error;
+        healthCheck(): Promise<{
+            status: string;
+            users?: number;
+            timestamp?: string;
+            [key: string]: any;
+        }>;
+    };
+    __resetTokensForTests(): void;
+} & T;
+//# sourceMappingURL=OxyServices.karma.d.ts.map

package/lib/typescript/core/mixins/OxyServices.karma.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"OxyServices.karma.d.ts","sourceRoot":"","sources":["../../../../src/core/mixins/OxyServices.karma.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AACH,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,qBAAqB,CAAC;AAG3D,wBAAgB,qBAAqB,CAAC,CAAC,SAAS,OAAO,eAAe,EAAE,IAAI,EAAE,CAAC;kBAEtD,GAAG,EAAE;QAG1B;;WAEG;6BACwB,MAAM,GAAG,OAAO,CAAC,GAAG,CAAC;QAWhD;;WAEG;0BACqB,MAAM,UAAU,MAAM,WAAW,MAAM,GAAG,OAAO,CAAC,GAAG,CAAC;QAW9E;;;;WAIG;kCAC6B,MAAM,GAAG,OAAO,CAAC,GAAG,CAAC;QAWrD;;;;;;WAMG;oCAC+B,MAAM,UAAU,MAAM,WAAW,MAAM,GAAG,OAAO,CAAC,GAAG,CAAC;QAexF;;;WAGG;+BAC0B,OAAO,CAAC,GAAG,CAAC;QAWzC;;;WAGG;yBACoB,OAAO,CAAC,GAAG,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;sBAa82E,CAAC;sBAA0B,CAAC;yBAA6B,CAAC;;;;;;iBAA4wF,CAAC;qBAAwB,CAAC;;;;;MAFpvK"}

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

@@ -0,0 +1,85 @@
+import type { LanguageMetadata } from '../../utils/languageUtils';
+import type { OxyServicesBase } from '../OxyServices.base';
+export declare function OxyServicesLanguageMixin<T extends typeof OxyServicesBase>(Base: T): {
+    new (...args: any[]): {
+        /**
+         * Get appropriate storage for the platform (similar to DeviceManager)
+         */
+        getStorage(): Promise<{
+            getItem: (key: string) => Promise<string | null>;
+            setItem: (key: string, value: string) => Promise<void>;
+            removeItem: (key: string) => Promise<void>;
+        }>;
+        /**
+         * 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>;
+        httpClient: import("../HttpClient").HttpClient;
+        requestManager: import("../RequestManager").RequestManager;
+        cloudURL: string;
+        config: import("../OxyServices.base").OxyConfig;
+        makeRequest<T_1>(method: "GET" | "POST" | "PUT" | "PATCH" | "DELETE", url: string, data?: any, options?: import("../RequestManager").RequestOptions): Promise<T_1>;
+        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_1>(operation: () => Promise<T_1>, operationName: string, options?: {
+            maxRetries?: number;
+            retryDelay?: number;
+            authTimeoutMs?: number;
+        }): Promise<T_1>;
+        validate(): Promise<boolean>;
+        handleError(error: any): Error;
+        healthCheck(): Promise<{
+            status: string;
+            users?: number;
+            timestamp?: string;
+            [key: string]: any;
+        }>;
+    };
+    __resetTokensForTests(): void;
+} & T;
+//# sourceMappingURL=OxyServices.language.d.ts.map

package/lib/typescript/core/mixins/OxyServices.language.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"OxyServices.language.d.ts","sourceRoot":"","sources":["../../../../src/core/mixins/OxyServices.language.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,2BAA2B,CAAC;AAClE,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,qBAAqB,CAAC;AAE3D,wBAAgB,wBAAwB,CAAC,CAAC,SAAS,OAAO,eAAe,EAAE,IAAI,EAAE,CAAC;kBAEzD,GAAG,EAAE;QAG1B;;WAEG;sBACwB,OAAO,CAAC;YACjC,OAAO,EAAE,CAAC,GAAG,EAAE,MAAM,KAAK,OAAO,CAAC,MAAM,GAAG,IAAI,CAAC,CAAC;YACjD,OAAO,EAAE,CAAC,GAAG,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,KAAK,OAAO,CAAC,IAAI,CAAC,CAAC;YACvD,UAAU,EAAE,CAAC,GAAG,EAAE,MAAM,KAAK,OAAO,CAAC,IAAI,CAAC,CAAC;SAC5C,CAAC;QAuCF;;;;WAIG;8CACwC,MAAM,GAAmB,OAAO,CAAC,MAAM,GAAG,IAAI,CAAC;QA8B1F;;;;WAIG;sDACgD,MAAM,GAAmB,OAAO,CAAC,gBAAgB,GAAG,IAAI,CAAC;QAK5G;;;;WAIG;kDAC4C,MAAM,GAAmB,OAAO,CAAC,MAAM,GAAG,IAAI,CAAC;QAM9F;;;;WAIG;wDACkD,MAAM,GAAmB,OAAO,CAAC,MAAM,GAAG,IAAI,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;sBAQsR,CAAC;sBAA0B,CAAC;yBAA6B,CAAC;;;;;;iBAA4wF,CAAC;qBAAwB,CAAC;;;;;MAF7tG"}

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

@@ -0,0 +1,68 @@
+/**
+ * Location Methods Mixin
+ */
+import type { OxyServicesBase } from '../OxyServices.base';
+export declare function OxyServicesLocationMixin<T extends typeof OxyServicesBase>(Base: T): {
+    new (...args: any[]): {
+        /**
+         * Update user location
+         * @param latitude - Latitude coordinate
+         * @param longitude - Longitude coordinate
+         * @returns Location update result
+         */
+        updateLocation(latitude: number, longitude: number): Promise<any>;
+        /**
+         * Get nearby users
+         * @param radius - Optional search radius in meters
+         * @returns Array of nearby users
+         */
+        getNearbyUsers(radius?: number): Promise<any[]>;
+        httpClient: import("../HttpClient").HttpClient;
+        requestManager: import("../RequestManager").RequestManager;
+        cloudURL: string;
+        config: import("../OxyServices.base").OxyConfig;
+        makeRequest<T_1>(method: "GET" | "POST" | "PUT" | "PATCH" | "DELETE", url: string, data?: any, options?: import("../RequestManager").RequestOptions): Promise<T_1>;
+        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_1>(operation: () => Promise<T_1>, operationName: string, options?: {
+            maxRetries?: number;
+            retryDelay?: number;
+            authTimeoutMs?: number;
+        }): Promise<T_1>;
+        validate(): Promise<boolean>;
+        handleError(error: any): Error;
+        healthCheck(): Promise<{
+            status: string;
+            users?: number;
+            timestamp?: string;
+            [key: string]: any;
+        }>;
+    };
+    __resetTokensForTests(): void;
+} & T;
+//# sourceMappingURL=OxyServices.location.d.ts.map

package/lib/typescript/core/mixins/OxyServices.location.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"OxyServices.location.d.ts","sourceRoot":"","sources":["../../../../src/core/mixins/OxyServices.location.ts"],"names":[],"mappings":"AAAA;;GAEG;AACH,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,qBAAqB,CAAC;AAE3D,wBAAgB,wBAAwB,CAAC,CAAC,SAAS,OAAO,eAAe,EAAE,IAAI,EAAE,CAAC;kBAEzD,GAAG,EAAE;QAI1B;;;;;WAKG;iCAC4B,MAAM,aAAa,MAAM,GAAG,OAAO,CAAC,GAAG,CAAC;QAWvE;;;;WAIG;gCAC2B,MAAM,GAAG,OAAO,CAAC,GAAG,EAAE,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;sBAao/H,CAAC;sBAA0B,CAAC;yBAA6B,CAAC;;;;;;iBAA4wF,CAAC;qBAAwB,CAAC;;;;;MAF54N"}

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

@@ -0,0 +1,74 @@
+/**
+ * Payment Methods Mixin
+ *
+ * Provides methods for payment processing and management
+ */
+import type { OxyServicesBase } from '../OxyServices.base';
+export declare function OxyServicesPaymentMixin<T extends typeof OxyServicesBase>(Base: T): {
+    new (...args: any[]): {
+        /**
+         * Create a payment
+         * @param data - Payment data
+         * @returns Created payment object
+         */
+        createPayment(data: any): Promise<any>;
+        /**
+         * Get payment by ID
+         * @param paymentId - The payment ID
+         * @returns Payment object
+         */
+        getPayment(paymentId: string): Promise<any>;
+        /**
+         * Get user payments
+         * @returns Array of user payments
+         */
+        getUserPayments(): Promise<any[]>;
+        httpClient: import("../HttpClient").HttpClient;
+        requestManager: import("../RequestManager").RequestManager;
+        cloudURL: string;
+        config: import("../OxyServices.base").OxyConfig;
+        makeRequest<T_1>(method: "GET" | "POST" | "PUT" | "PATCH" | "DELETE", url: string, data?: any, options?: import("../RequestManager").RequestOptions): Promise<T_1>;
+        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_1>(operation: () => Promise<T_1>, operationName: string, options?: {
+            maxRetries?: number;
+            retryDelay?: number;
+            authTimeoutMs?: number;
+        }): Promise<T_1>;
+        validate(): Promise<boolean>;
+        handleError(error: any): Error;
+        healthCheck(): Promise<{
+            status: string;
+            users?: number;
+            timestamp?: string;
+            [key: string]: any;
+        }>;
+    };
+    __resetTokensForTests(): void;
+} & T;
+//# sourceMappingURL=OxyServices.payment.d.ts.map

package/lib/typescript/core/mixins/OxyServices.payment.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"OxyServices.payment.d.ts","sourceRoot":"","sources":["../../../../src/core/mixins/OxyServices.payment.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AACH,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,qBAAqB,CAAC;AAG3D,wBAAgB,uBAAuB,CAAC,CAAC,SAAS,OAAO,eAAe,EAAE,IAAI,EAAE,CAAC;kBAExD,GAAG,EAAE;QAI1B;;;;WAIG;4BACuB,GAAG,GAAG,OAAO,CAAC,GAAG,CAAC;QAQ5C;;;;WAIG;8BACyB,MAAM,GAAG,OAAO,CAAC,GAAG,CAAC;QAWjD;;;WAGG;2BACsB,OAAO,CAAC,GAAG,EAAE,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;sBAY4vH,CAAC;sBAA0B,CAAC;yBAA6B,CAAC;;;;;;iBAA4wF,CAAC;qBAAwB,CAAC;;;;;MAFtoN"}

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

@@ -0,0 +1,126 @@
+/**
+ * Privacy Methods Mixin (Blocked & Restricted Users)
+ */
+import type { BlockedUser, RestrictedUser } from '../../models/interfaces';
+import type { OxyServicesBase } from '../OxyServices.base';
+export declare function OxyServicesPrivacyMixin<T extends typeof OxyServicesBase>(Base: T): {
+    new (...args: any[]): {
+        /**
+         * Extract user ID from blocked/restricted user object
+         */
+        extractUserId(userIdField: string | {
+            _id: string;
+            username?: string;
+            avatar?: string;
+        }): string;
+        /**
+         * Check if a user is in a list (blocked or restricted)
+         */
+        isUserInList<T_1 extends BlockedUser | RestrictedUser>(userId: string, getUserList: () => Promise<T_1[]>, getIdField: (item: T_1) => string | {
+            _id: string;
+            username?: string;
+            avatar?: string;
+        }): Promise<boolean>;
+        /**
+         * 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;
+        }>;
+        /**
+         * 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>;
+        httpClient: import("../HttpClient").HttpClient;
+        requestManager: import("../RequestManager").RequestManager;
+        cloudURL: string;
+        config: import("../OxyServices.base").OxyConfig;
+        makeRequest<T_1>(method: "GET" | "POST" | "PUT" | "PATCH" | "DELETE", url: string, data?: any, options?: import("../RequestManager").RequestOptions): Promise<T_1>;
+        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_1>(operation: () => Promise<T_1>, operationName: string, options?: {
+            maxRetries?: number;
+            retryDelay?: number;
+            authTimeoutMs?: number;
+        }): Promise<T_1>;
+        validate(): Promise<boolean>;
+        handleError(error: any): Error;
+        healthCheck(): Promise<{
+            status: string;
+            users?: number;
+            timestamp?: string;
+            [key: string]: any;
+        }>;
+    };
+    __resetTokensForTests(): void;
+} & T;
+//# sourceMappingURL=OxyServices.privacy.d.ts.map

package/lib/typescript/core/mixins/OxyServices.privacy.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"OxyServices.privacy.d.ts","sourceRoot":"","sources":["../../../../src/core/mixins/OxyServices.privacy.ts"],"names":[],"mappings":"AAAA;;GAEG;AACH,OAAO,KAAK,EAAE,WAAW,EAAE,cAAc,EAAE,MAAM,yBAAyB,CAAC;AAC3E,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,qBAAqB,CAAC;AAE3D,wBAAgB,uBAAuB,CAAC,CAAC,SAAS,OAAO,eAAe,EAAE,IAAI,EAAE,CAAC;kBAExD,GAAG,EAAE;QAG1B;;WAEG;mCAC+B,MAAM,GAAG;YAAE,GAAG,EAAE,MAAM,CAAC;YAAC,QAAQ,CAAC,EAAE,MAAM,CAAC;YAAC,MAAM,CAAC,EAAE,MAAM,CAAA;SAAE,GAAG,MAAM;QAIvG;;WAEG;iCACiC,WAAW,GAAG,cAAc,UACtD,MAAM,eACD,MAAM,OAAO,CAAC,GAAC,EAAE,CAAC,cACnB,CAAC,IAAI,EAAE,GAAC,KAAK,MAAM,GAAG;YAAE,GAAG,EAAE,MAAM,CAAC;YAAC,QAAQ,CAAC,EAAE,MAAM,CAAC;YAAC,MAAM,CAAC,EAAE,MAAM,CAAA;SAAE,GACpF,OAAO,CAAC,OAAO,CAAC;QAuBnB;;;WAGG;2BACsB,OAAO,CAAC,WAAW,EAAE,CAAC;QAW/C;;;;WAIG;0BACqB,MAAM,GAAG,OAAO,CAAC;YAAE,OAAO,EAAE,MAAM,CAAA;SAAE,CAAC;QAa7D;;;;WAIG;4BACuB,MAAM,GAAG,OAAO,CAAC;YAAE,OAAO,EAAE,MAAM,CAAA;SAAE,CAAC;QAa/D;;;;WAIG;8BACyB,MAAM,GAAG,OAAO,CAAC,OAAO,CAAC;QAYrD;;;WAGG;8BACyB,OAAO,CAAC,cAAc,EAAE,CAAC;QAWrD;;;;WAIG;6BACwB,MAAM,GAAG,OAAO,CAAC;YAAE,OAAO,EAAE,MAAM,CAAA;SAAE,CAAC;QAahE;;;;WAIG;+BAC0B,MAAM,GAAG,OAAO,CAAC;YAAE,OAAO,EAAE,MAAM,CAAA;SAAE,CAAC;QAalE;;;;WAIG;iCAC4B,MAAM,GAAG,OAAO,CAAC,OAAO,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;sBAC5C,CAAC;sBACN,CAAC;yBACa,CAAC;;;;;;iBAOgqF,CAAC;qBAAwB,CAAC;;;;;MAFntF"}

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

@@ -0,0 +1,69 @@
+/**
+ * TOTP Enrollment Methods Mixin
+ */
+import type { OxyServicesBase } from '../OxyServices.base';
+export declare function OxyServicesTotpMixin<T extends typeof OxyServicesBase>(Base: T): {
+    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: import("../OxyServices.base").OxyConfig;
+        makeRequest<T_1>(method: "GET" | "POST" | "PUT" | "PATCH" | "DELETE", url: string, data?: any, options?: import("../RequestManager").RequestOptions): Promise<T_1>;
+        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_1>(operation: () => Promise<T_1>, operationName: string, options?: {
+            maxRetries?: number;
+            retryDelay?: number;
+            authTimeoutMs?: number;
+        }): Promise<T_1>;
+        validate(): Promise<boolean>;
+        handleError(error: any): Error;
+        healthCheck(): Promise<{
+            status: string;
+            users?: number;
+            timestamp?: string;
+            [key: string]: any;
+        }>;
+    };
+    __resetTokensForTests(): void;
+} & T;
+//# sourceMappingURL=OxyServices.totp.d.ts.map

package/lib/typescript/core/mixins/OxyServices.totp.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"OxyServices.totp.d.ts","sourceRoot":"","sources":["../../../../src/core/mixins/OxyServices.totp.ts"],"names":[],"mappings":"AAAA;;GAEG;AACH,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,qBAAqB,CAAC;AAE3D,wBAAgB,oBAAoB,CAAC,CAAC,SAAS,OAAO,eAAe,EAAE,IAAI,EAAE,CAAC;kBAErD,GAAG,EAAE;uCAGW,MAAM,GAAG,OAAO,CAAC;YAAE,MAAM,EAAE,MAAM,CAAC;YAAC,UAAU,EAAE,MAAM,CAAC;YAAC,MAAM,EAAE,MAAM,CAAC;YAAC,KAAK,EAAE,MAAM,CAAA;SAAE,CAAC;wCAQtF,MAAM,QAAQ,MAAM,GAAG,OAAO,CAAC;YAAE,OAAO,EAAE,OAAO,CAAC;YAAC,WAAW,CAAC,EAAE,MAAM,EAAE,CAAC;YAAC,WAAW,CAAC,EAAE,MAAM,CAAA;SAAE,CAAC;+BAQ3G,MAAM,QAAQ,MAAM,GAAG,OAAO,CAAC;YAAE,QAAQ,EAAE,OAAO,CAAA;SAAE,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;sBAUs+H,CAAC;sBAA0B,CAAC;yBAA6B,CAAC;;;;;;iBAA4wF,CAAC;qBAAwB,CAAC;;;;;MAF35N"}