@explorins/pers-sdk 1.6.6 → 1.6.10

package/dist/chunks/{pers-sdk-eO4XUi8w.js → pers-sdk-DOuNyWFC.js}

@@ -1,4 +1,5 @@
 import { AccountOwnerType } from '@explorins/pers-shared';
+import { i as isTokenExpired, a as Web3ChainService, W as Web3ChainApi } from './web3-chain-service-Dp5Z8p9I.js';
 import { a as UserService, U as UserApi } from './user-service-D6mTa_WZ.js';
 import { createUserStatusSDK } from '../user-status.js';
 import { a as TokenService, T as TokenApi } from './token-service-CpVwC5Eb.js';
@@ -11,7 +12,6 @@ import { a as TenantService, T as TenantApi } from './tenant-service-DELk412y.js
 import { a as AnalyticsService, A as AnalyticsApi } from './analytics-service-CxyrOwel.js';
 import { a as DonationService, D as DonationApi } from './donation-service-CyJS4DIZ.js';
 import { a as Web3InfrastructureApi, I as IPFSInfrastructureApi, W as Web3ApplicationService, b as getExplorerUrlByChainId } from './explorer.utils-Ckll15ja.js';
-import { a as Web3ChainService, W as Web3ChainApi } from './web3-chain-service-DN6tJmvK.js';
 
 /**
  * PERS SDK Configuration interfaces and utilities
@@ -57,25 +57,16 @@ function mergeWithDefaults(config) {
 }
 
 /**
- * Platform-Agnostic Auth Admin API Client
- *
- * Handles authentication and authorization admin operations using the PERS backend.
- * Uses @explorins/pers-shared DTOs for consistency with backend.
- *
- * Note: Special header handling (bypass-auth-interceptor) may need to be implemented
- * at the PersApiClient level or through a specialized auth client.
+ * Platform-Agnostic Auth API Client
+ * Handles authentication operations using the PERS backend
  */
 class AuthApi {
     constructor(apiClient) {
         this.apiClient = apiClient;
         this.basePath = '/auth';
     }
-    // ==========================================
-    // ADMIN AUTHENTICATION OPERATIONS
-    // ==========================================
     /**
-     * ADMIN: Login tenant admin with JWT
-     * Note: JWT handling and auth bypass headers may need special implementation
+     * Login tenant admin with JWT
      */
     async loginTenantAdmin(jwt) {
         const body = {
@@ -85,7 +76,7 @@ class AuthApi {
         return this.apiClient.post(`${this.basePath}/token`, body, { bypassAuth: true });
     }
     /**
-     * Login user with JWT - bypasses auth headers
+     * Login user with JWT
      */
     async loginUser(jwt) {
         const body = {
@@ -94,6 +85,9 @@ class AuthApi {
         };
         return this.apiClient.post(`${this.basePath}/token`, body, { bypassAuth: true });
     }
+    /**
+     * Login user with raw data (no external authentication)
+     */
     async loginUnAuthenticated(rawLoginData) {
         const body = {
             authToken: '',
@@ -103,21 +97,16 @@ class AuthApi {
         return this.apiClient.post(`${this.basePath}/token`, body, { bypassAuth: true });
     }
     /**
-     * Refresh access token - bypasses auth headers to prevent circular dependency
+     * Refresh access token
      */
     async refreshAccessToken(refreshToken) {
-        // Bypass auth headers for refresh calls to prevent circular dependency
         return this.apiClient.post(`${this.basePath}/refresh`, { refreshToken }, { bypassAuth: true });
     }
 }
 
 /**
- * Platform-Agnostic Auth Admin Service
- *
- * Contains auth admin business logic and operations that work across platforms.
- * No framework dependencies - pure TypeScript business logic.
- *
- * Focuses only on actual backend capabilities.
+ * Platform-agnostic authentication service
+ * Handles login, token refresh, and storage operations
  */
 class AuthService {
     constructor(authApi, authProvider) {
@@ -126,110 +115,84 @@ class AuthService {
         this.activeRefreshPromise = null;
     }
     // ==========================================
-    // ADMIN AUTHENTICATION OPERATIONS
+    // AUTHENTICATION OPERATIONS
     // ==========================================
     /**
-     * ADMIN: Login tenant admin with JWT
-     * Automatically stores tokens if auth provider supports token storage
+     * Login tenant admin with JWT
      */
     async loginTenantAdmin(jwt) {
         const response = await this.authApi.loginTenantAdmin(jwt);
-        // Store tokens if auth provider supports it
         if (this.authProvider && response.accessToken) {
             await this.storeTokens(response.accessToken, response.refreshToken, 'admin', jwt);
         }
         return response;
     }
     /**
-     * Automatically stores tokens if auth provider supports token storage
+     * Login user with JWT
      */
     async loginUser(jwt) {
         const response = await this.authApi.loginUser(jwt);
-        // Store tokens if auth provider supports it
         if (this.authProvider && response.accessToken) {
             await this.storeTokens(response.accessToken, response.refreshToken, 'user', jwt);
         }
         return response;
     }
     /**
-     * Automatically stores tokens if auth provider supports token storage
+     * Login user with raw data (no external auth)
      */
     async loginUserWithRawData(rawLoginData) {
-        const loginData = {
-            externalId: rawLoginData?.externalId,
-            email: rawLoginData?.email,
-            firstName: rawLoginData?.firstName,
-            lastName: rawLoginData?.lastName,
-            customData: rawLoginData?.customData
-        };
-        const response = await this.authApi.loginUnAuthenticated(loginData);
-        // Store tokens if auth provider supports it
+        const response = await this.authApi.loginUnAuthenticated(rawLoginData);
         if (this.authProvider && response.accessToken) {
             await this.storeTokens(response.accessToken, response.refreshToken, 'user');
         }
         return response;
     }
     /**
-     * ADMIN: Refresh access token
-     * Automatically stores new tokens if auth provider supports token storage
-     *
-     * Implements refresh deduplication to prevent race conditions when multiple
-     * requests trigger refresh simultaneously.
+     * Refresh access token with race condition protection
      */
     async refreshAccessToken(refreshToken) {
-        // If there's already an active refresh, return that promise instead of starting a new one
         if (this.activeRefreshPromise) {
-            console.log('[AuthService] Refresh already in progress, reusing existing promise');
             try {
                 return await this.activeRefreshPromise;
             }
             catch (error) {
-                // If the active refresh failed, we'll try again with a fresh attempt
                 console.warn('[AuthService] Active refresh failed, attempting new refresh:', error);
                 this.activeRefreshPromise = null;
             }
         }
-        // Start a new refresh operation
         this.activeRefreshPromise = this.performRefresh(refreshToken);
         try {
-            const result = await this.activeRefreshPromise;
-            return result;
+            return await this.activeRefreshPromise;
         }
         finally {
-            // Clear the active refresh promise when done (success or failure)
             this.activeRefreshPromise = null;
         }
     }
     /**
      * Performs the actual refresh operation
-     * Separated from refreshAccessToken for cleaner promise management
      */
     async performRefresh(refreshToken) {
-        // Use provided refresh token or get from auth provider
         const tokenToUse = refreshToken || (this.authProvider ? await this.authProvider.getRefreshToken() : null);
         if (!tokenToUse) {
             throw new Error('No refresh token available for token refresh');
         }
         const response = await this.authApi.refreshAccessToken(tokenToUse);
-        // Store new tokens if auth provider supports it
         if (this.authProvider && response.accessToken) {
             await this.storeTokens(response.accessToken, response.refreshToken);
         }
         return response;
     }
     /**
-     * Clear stored tokens if auth provider supports it
-     * Also clears any active refresh operations
+     * Clear stored tokens and active refresh operations
      */
     async clearTokens() {
-        // Clear any active refresh operation
         this.activeRefreshPromise = null;
         if (this.authProvider) {
             await this.authProvider.clearTokens();
         }
     }
     /**
-     * Check if we have valid tokens for authentication
+     * Check if we have valid authentication tokens
      */
     async hasValidAuth() {
         if (!this.authProvider)
@@ -241,43 +204,34 @@ class AuthService {
     // PRIVATE HELPERS
     // ==========================================
     /**
-     * Store tokens using auth provider if it supports token storage
+     * Store tokens using auth provider
      */
     async storeTokens(accessToken, refreshToken, authType, providerToken) {
         if (!this.authProvider)
             return;
         try {
-            // Store access token
-            if (this.authProvider) {
-                await this.authProvider.setAccessToken(accessToken);
-            }
-            // Store refresh token if provided and supported
-            if (refreshToken && this.authProvider) {
+            await this.authProvider.setAccessToken(accessToken);
+            if (refreshToken) {
                 await this.authProvider.setRefreshToken(refreshToken);
             }
-            // Store provider token if provided and provider supports it
-            if (providerToken && 'setProviderToken' in this.authProvider &&
-                typeof this.authProvider.setProviderToken === 'function') {
-                await this.authProvider.setProviderToken(providerToken);
+            // Type-safe handling of extended token storage features
+            const extendedProvider = this.authProvider;
+            if (providerToken && extendedProvider.setProviderToken) {
+                await extendedProvider.setProviderToken(providerToken);
             }
-            // Store auth type if provided and provider supports it
-            if (authType && 'setAuthType' in this.authProvider &&
-                typeof this.authProvider.setAuthType === 'function') {
-                await this.authProvider.setAuthType(authType);
+            if (authType && extendedProvider.setAuthType) {
+                await extendedProvider.setAuthType(authType);
             }
         }
         catch (error) {
-            // Log error for debugging but don't throw - token storage failure shouldn't break auth flow
             console.warn('[AuthService] Failed to store tokens:', error);
         }
     }
 }
 
 /**
- * Simple Token Refresh Manager
- *
- * Just moves the working refresh logic to a separate file for better organization.
- * No overengineering - keeps the exact same simple logic.
+ * Token Refresh Manager
+ * Simple container for token refresh logic with better organization
  */
 class TokenRefreshManager {
     constructor(authService, authProvider) {
@@ -288,12 +242,7 @@ class TokenRefreshManager {
     async ensureValidToken() {
         try {
             const token = await this.authProvider.getToken();
-            if (!token) {
-                await this.attemptInternalRefresh();
-                return;
-            }
-            // Check if token is close to expiry (within 2 minutes)
-            if (this.isTokenExpiringSoon(token, this.tokenRefreshMarginSeconds)) {
+            if (!token || isTokenExpired(token, this.tokenRefreshMarginSeconds)) {
                 await this.attemptInternalRefresh();
             }
         }
@@ -311,27 +260,11 @@ class TokenRefreshManager {
             return false;
         }
     }
-    isTokenExpiringSoon(token, marginSeconds) {
-        try {
-            const parts = token.split('.');
-            if (parts.length !== 3)
-                return true;
-            const payload = JSON.parse(atob(parts[1]));
-            if (!payload.exp)
-                return false;
-            const timeUntilExpiry = payload.exp - Math.floor(Date.now() / 1000);
-            return timeUntilExpiry <= marginSeconds;
-        }
-        catch {
-            return true;
-        }
-    }
 }
 
 /**
- * Clean Token Storage System
- *
- * Simple, focused token storage with clear separation of concerns.
+ * Token Storage System
+ * Simple, focused token storage with clear separation of concerns
  */
 const AUTH_STORAGE_KEYS = {
     ACCESS_TOKEN: 'pers_access_token',
@@ -344,26 +277,24 @@ const AUTH_STORAGE_KEYS = {
  */
 class LocalStorageTokenStorage {
     async get(key) {
-        if (typeof localStorage === 'undefined')
-            return null;
-        return localStorage.getItem(key);
+        return typeof localStorage !== 'undefined' ? localStorage.getItem(key) : null;
     }
     async set(key, value) {
-        if (typeof localStorage === 'undefined')
-            return;
-        localStorage.setItem(key, value);
+        if (typeof localStorage !== 'undefined') {
+            localStorage.setItem(key, value);
+        }
     }
     async remove(key) {
-        if (typeof localStorage === 'undefined')
-            return;
-        localStorage.removeItem(key);
+        if (typeof localStorage !== 'undefined') {
+            localStorage.removeItem(key);
+        }
     }
     async clear() {
-        if (typeof localStorage === 'undefined')
-            return;
-        Object.values(AUTH_STORAGE_KEYS).forEach(key => {
-            localStorage.removeItem(key);
-        });
+        if (typeof localStorage !== 'undefined') {
+            Object.values(AUTH_STORAGE_KEYS).forEach(key => {
+                localStorage.removeItem(key);
+            });
+        }
     }
 }
 /**
@@ -388,34 +319,29 @@ class MemoryTokenStorage {
 }
 /**
  * Token manager for authentication tokens
- * Clean, focused on auth tokens only
  */
 class AuthTokenManager {
     constructor(storage = new LocalStorageTokenStorage()) {
         this.storage = storage;
     }
-    // Access token methods
     async getAccessToken() {
         return this.storage.get(AUTH_STORAGE_KEYS.ACCESS_TOKEN);
     }
     async setAccessToken(token) {
         await this.storage.set(AUTH_STORAGE_KEYS.ACCESS_TOKEN, token);
     }
-    // Refresh token methods
     async getRefreshToken() {
         return this.storage.get(AUTH_STORAGE_KEYS.REFRESH_TOKEN);
     }
     async setRefreshToken(token) {
         await this.storage.set(AUTH_STORAGE_KEYS.REFRESH_TOKEN, token);
     }
-    // Provider token methods
     async getProviderToken() {
         return this.storage.get(AUTH_STORAGE_KEYS.PROVIDER_TOKEN);
     }
     async setProviderToken(token) {
         await this.storage.set(AUTH_STORAGE_KEYS.PROVIDER_TOKEN, token);
     }
-    // Auth type methods
     async getAuthType() {
         const authType = await this.storage.get(AUTH_STORAGE_KEYS.AUTH_TYPE);
         return authType;
@@ -423,7 +349,6 @@ class AuthTokenManager {
     async setAuthType(authType) {
         await this.storage.set(AUTH_STORAGE_KEYS.AUTH_TYPE, authType);
     }
-    // Bulk operations
     async setTokens(accessToken, refreshToken, providerToken) {
         await this.setAccessToken(accessToken);
         if (refreshToken)
@@ -434,7 +359,6 @@ class AuthTokenManager {
     async clearAllTokens() {
         await this.storage.clear();
     }
-    // Utility methods
     async hasAccessToken() {
         const token = await this.getAccessToken();
         return !!token;
@@ -446,31 +370,24 @@ class AuthTokenManager {
 }
 
 /**
- * Clean Default Authentication Provider
- *
- * Simple, focused implementation of PERS authentication
- * with clear separation of concerns and minimal complexity.
+ * Default Authentication Provider
+ * Simple implementation of PERS authentication with token lifecycle management
  */
 /**
- * Clean, simple authentication provider
- * Handles token lifecycle with minimal complexity
+ * Simple authentication provider with token storage
  */
 class DefaultAuthProvider {
     constructor(config = {}) {
         this.config = config;
         this.authType = config.authType || 'user';
-        // Use custom storage if provided, otherwise auto-detect
         const storage = config.storage || this.createStorage();
         this.tokenManager = new AuthTokenManager(storage);
     }
     createStorage() {
-        // Memory storage for server-side or when localStorage unavailable
-        if (typeof window === 'undefined' || typeof localStorage === 'undefined') {
-            return new MemoryTokenStorage();
-        }
-        return new LocalStorageTokenStorage();
+        return typeof window === 'undefined' || typeof localStorage === 'undefined'
+            ? new MemoryTokenStorage()
+            : new LocalStorageTokenStorage();
     }
-    // Core PersAuthProvider methods
     getToken() {
         return this.tokenManager.getAccessToken();
     }
@@ -479,14 +396,10 @@ class DefaultAuthProvider {
     }
     async onTokenExpired() {
         try {
-            // Note: Internal refresh token logic is now handled by PersApiClient.attemptInternalRefresh()
-            // This callback is only called when internal refresh fails or no refresh token is available
-            // Try custom expiration handler first  
             if (this.config.onTokenExpired) {
                 await this.config.onTokenExpired();
                 return;
             }
-            // Try token provider (Firebase, Auth0, etc.) as fallback
             if (this.config.tokenProvider) {
                 const newToken = await this.config.tokenProvider();
                 if (newToken) {
@@ -495,15 +408,12 @@ class DefaultAuthProvider {
                     return;
                 }
             }
-            // Final fallback: clear all tokens (logout)
             await this.tokenManager.clearAllTokens();
         }
         catch (error) {
-            // On any error, clear tokens to ensure clean state
             await this.tokenManager.clearAllTokens();
         }
     }
-    // TokenStorageProvider methods  
     async setAccessToken(token) {
         await this.tokenManager.setAccessToken(token);
     }
@@ -516,7 +426,6 @@ class DefaultAuthProvider {
     async clearTokens() {
         await this.tokenManager.clearAllTokens();
     }
-    // Utility methods
     async setTokens(accessToken, refreshToken, providerToken) {
         await this.tokenManager.setTokens(accessToken, refreshToken, providerToken);
     }
@@ -618,39 +527,21 @@ class PersApiError extends Error {
 
 // packages/pers-sdk/src/core/pers-api-client.ts
 /**
- * PERS API Client - Core platform-agnostic client for PERS backend
- *
- * Provides authenticated HTTP client with automatic token management,
- * proactive refresh, and comprehensive error handling.
+ * PERS API Client - Platform-agnostic HTTP client with authentication
  *
- * Features:
- * - Automatic token refresh before expiry
- * - Background refresh for optimal performance
- * - Provider token fallback for seamless authentication
- * - Configurable retry and timeout settings
- * - Platform-agnostic design
+ * Features: automatic token refresh, background validation, configurable settings
  *
  * @example
  * ```typescript
  * const client = new PersApiClient(httpClient, {
  *   environment: 'production',
  *   apiProjectKey: 'your-project-key',
- *   authProvider: new DefaultAuthProvider({
- *     tokenProvider: () => getFirebaseToken()
- *   })
+ *   authProvider: new DefaultAuthProvider()
  * });
  *
- * // Make authenticated requests
  * const data = await client.get('/users/me');
  * ```
  */
-// Auth constants
-const AUTH_METHODS = {
-    GET: 'GET',
-    POST: 'POST',
-    PUT: 'PUT',
-    DELETE: 'DELETE',
-};
 class PersApiClient {
     /**
      * Creates a new PERS API Client instance
@@ -699,72 +590,36 @@ class PersApiClient {
     async attemptInternalRefresh() {
         return this.refreshManager.attemptInternalRefresh();
     }
-    /**
-     * Get request headers including auth token and project key
-     */
-    async getHeaders() {
-        const headers = {
-            'Content-Type': 'application/json',
-        };
-        // Add authentication token
-        if (this.mergedConfig.authProvider) {
-            const token = await this.mergedConfig.authProvider.getToken();
-            if (token) {
-                headers['Authorization'] = `Bearer ${token}`;
-            }
-            else {
-                console.warn('[PersApiClient] No token available from auth provider');
-            }
-        }
-        else {
-            console.warn('[PersApiClient] No auth provider configured');
-        }
-        // Add project key
-        if (this.mergedConfig.authProvider) {
-            const projectKey = await this.mergedConfig.authProvider.getProjectKey();
-            if (projectKey) {
-                headers['x-project-key'] = projectKey;
-            }
-        }
-        else if (this.mergedConfig.apiProjectKey) {
-            // Fallback to config project key if no auth provider
-            headers['x-project-key'] = this.mergedConfig.apiProjectKey;
-        }
-        return headers;
-    }
     /**
      * Make a request with proper headers, auth, and error handling
      */
     async request(method, endpoint, body, options) {
         const { retryCount = 0, responseType = 'json', bypassAuth = false } = options || {};
         const url = `${this.apiRoot}${endpoint}`;
-        // Proactive token expiry check and refresh BEFORE making the request
-        // Non-blocking for optimal performance - request proceeds immediately
+        // Proactive token validation for optimal performance
         if (!bypassAuth && this.mergedConfig.authProvider && retryCount === 0) {
             this.ensureValidToken().catch(error => {
-                // Log but don't block request - 401 handling will catch any issues
                 console.debug('[PersApiClient] Background token validation failed:', error);
             });
         }
         const requestOptions = {
-            headers: bypassAuth ? await this.getHeadersWithoutAuth() : await this.getHeaders(),
+            headers: await this.getHeaders(!bypassAuth),
             timeout: this.mergedConfig.timeout,
             responseType
         };
-        // const isCSVEndpoint = endpoint.includes('/export/csv');
         try {
             let result;
             switch (method) {
-                case AUTH_METHODS.GET:
+                case 'GET':
                     result = await this.httpClient.get(url, requestOptions);
                     break;
-                case AUTH_METHODS.POST:
+                case 'POST':
                     result = await this.httpClient.post(url, body, requestOptions);
                     break;
-                case AUTH_METHODS.PUT:
+                case 'PUT':
                     result = await this.httpClient.put(url, body, requestOptions);
                     break;
-                case AUTH_METHODS.DELETE:
+                case 'DELETE':
                     result = await this.httpClient.delete(url, requestOptions);
                     break;
                 default:
@@ -817,46 +672,51 @@ class PersApiClient {
      * ```
      */
     async get(endpoint, responseType) {
-        return this.request(AUTH_METHODS.GET, endpoint, undefined, { responseType });
+        return this.request('GET', endpoint, undefined, { responseType });
     }
     /**
      * Performs an authenticated POST request
-     *
-     * @template T - Expected response type
-     * @param endpoint - API endpoint path (without base URL)
-     * @param body - Request payload data
-     * @param options - Request options including auth bypass
-     * @returns Promise resolving to typed response data
-     *
-     * @example
-     * ```typescript
-     * const user = await client.post<User>('/users', userData);
-     * const publicData = await client.post('/public/contact', formData, { bypassAuth: true });
-     * ```
      */
     async post(endpoint, body, options) {
-        return this.request(AUTH_METHODS.POST, endpoint, body, options);
+        return this.request('POST', endpoint, body, options);
     }
     /**
      * Generic PUT request
      */
     async put(endpoint, body) {
-        return this.request(AUTH_METHODS.PUT, endpoint, body);
+        return this.request('PUT', endpoint, body);
     }
     /**
      * Generic DELETE request
      */
     async delete(endpoint) {
-        return this.request(AUTH_METHODS.DELETE, endpoint);
+        return this.request('DELETE', endpoint);
     }
     /**
-   * Get request headers WITHOUT auth token (for auth operations like refresh/login)
-   */
-    async getHeadersWithoutAuth() {
+     * Get request headers with optional auth token and project key
+     *
+     * @param includeAuth - Whether to include the Authorization header (default: true)
+     */
+    async getHeaders(includeAuth = true) {
         const headers = {
             'Content-Type': 'application/json',
         };
-        // Add project key only (no auth token)
+        if (includeAuth) {
+            // Add authentication token
+            if (this.mergedConfig.authProvider) {
+                const token = await this.mergedConfig.authProvider.getToken();
+                if (token) {
+                    headers['Authorization'] = `Bearer ${token}`;
+                }
+                else {
+                    console.warn('[PersApiClient] No token available from auth provider');
+                }
+            }
+            else {
+                console.warn('[PersApiClient] No auth provider configured');
+            }
+        }
+        // Add project key
         if (this.mergedConfig.authProvider) {
             const projectKey = await this.mergedConfig.authProvider.getProjectKey();
             if (projectKey) {
@@ -869,11 +729,10 @@ class PersApiClient {
         return headers;
     }
     // ==========================================
-    // INTERNAL AUTH METHODS (For AuthManager use only)
+    // INTERNAL AUTH METHODS
     // ==========================================
     /**
      * @internal - For AuthManager use only
-     * Direct access to auth service for manager layer
      */
     getAuthService() {
         return this.authService;
@@ -894,25 +753,21 @@ class PersApiClient {
 
 /**
  * Environment Detection Utility
- *
- * Detects the runtime environment to handle platform-specific behaviors
- * for bundling and module resolution.
+ * Detects runtime environment for platform-specific behaviors
  */
 /**
  * Detects the current runtime environment
  */
 function detectEnvironment() {
+    const global = globalThis;
     const isNode = typeof process !== 'undefined' &&
-        process.versions != null &&
-        process.versions.node != null &&
-        typeof globalThis.window === 'undefined';
-    const isBrowser = typeof globalThis.window !== 'undefined' &&
-        typeof globalThis.document !== 'undefined';
-    const isReactNative = typeof globalThis.navigator !== 'undefined' &&
-        typeof globalThis.navigator.product === 'string' &&
-        globalThis.navigator.product.toLowerCase() === 'reactnative';
+        process.versions?.node != null &&
+        typeof global.window === 'undefined';
+    const isBrowser = typeof global.window !== 'undefined' &&
+        typeof global.document !== 'undefined';
+    const isReactNative = typeof global.navigator?.product === 'string' &&
+        global.navigator.product.toLowerCase() === 'reactnative';
     const isWeb = isBrowser || isReactNative;
-    // Node.js streams: Only native in Node.js, need polyfills or avoidance in web
     const needsNodeStreamPolyfills = isWeb;
     return {
         isNode,
@@ -927,7 +782,7 @@ function detectEnvironment() {
  */
 const environment = detectEnvironment();
 /**
- * Warns if we're in an environment that might have bundling issues
+ * Warns if environment might have bundling issues
  */
 function warnIfProblematicEnvironment(feature) {
     if (environment.needsNodeStreamPolyfills) {
@@ -4430,12 +4285,6 @@ class FileService {
         return this.fileApi;
     }
 }
-/**
- * Factory function for creating file service
- */
-function createFileSDK(apiClient) {
-    return new FileService(apiClient);
-}
 
 /**
  * File Manager - Clean, high-level interface for file operations
@@ -4502,7 +4351,7 @@ function createFileSDK(apiClient) {
 class FileManager {
     constructor(apiClient) {
         this.apiClient = apiClient;
-        this.fileSDK = createFileSDK(apiClient);
+        this.fileService = new FileService(apiClient);
     }
     /**
      * Get signed URL for file upload
@@ -4599,7 +4448,7 @@ class FileManager {
      * ```
      */
     async getSignedPutUrl(entityId, entityType, fileExtension) {
-        return this.fileSDK.getSignedPutUrl(entityId, entityType, fileExtension);
+        return this.fileService.getSignedPutUrl(entityId, entityType, fileExtension);
     }
     /**
      * Get signed URL for file access
@@ -4691,7 +4540,7 @@ class FileManager {
      * ```
      */
     async getSignedGetUrl(entityId, entityType, expireSeconds) {
-        return this.fileSDK.getSignedGetUrl(entityId, entityType, expireSeconds);
+        return this.fileService.getSignedGetUrl(entityId, entityType, expireSeconds);
     }
     /**
      * Get signed URL for any file operation
@@ -4756,7 +4605,7 @@ class FileManager {
      * ```
      */
     async getSignedUrl(request) {
-        return this.fileSDK.getSignedUrl(request);
+        return this.fileService.getSignedUrl(request);
     }
     /**
      * Optimize media file
@@ -4870,10 +4719,10 @@ class FileManager {
      * ```
      */
     async optimizeMedia(url, width, height) {
-        return this.fileSDK.optimizeMedia(url, width, height);
+        return this.fileService.optimizeMedia(url, width, height);
     }
     /**
-     * Get the full file SDK for advanced operations
+     * Get the full file service for advanced operations
      *
      * Provides access to the complete FileService instance for advanced file
      * operations, batch processing, storage analytics, and operations not
@@ -4883,20 +4732,20 @@ class FileManager {
      *
      * @example Advanced Operations
      * ```typescript
-     * const fileSDK = sdk.files.getFileSDK();
+     * const fileService = sdk.files.getFileService();
      *
      * // Access storage analytics
-     * const storageStats = await fileSDK.getStorageAnalytics();
+     * const storageStats = await fileService.getStorageAnalytics();
      * console.log('Storage usage:', storageStats.totalSize);
      *
      * // Access batch file operations
-     * const batchResult = await fileSDK.batchDeleteFiles(['file1', 'file2', 'file3']);
+     * const batchResult = await fileService.batchDeleteFiles(['file1', 'file2', 'file3']);
      *
      * // Access file metadata management
-     * const metadata = await fileSDK.getFileMetadata('entity-123', 'campaign');
+     * const metadata = await fileService.getFileMetadata('entity-123', 'campaign');
      *
      * // Access advanced optimization options
-     * const advancedOptimization = await fileSDK.optimizeMediaAdvanced(url, {
+     * const advancedOptimization = await fileService.optimizeMediaAdvanced(url, {
      *   width: 400,
      *   height: 300,
      *   quality: 85,
@@ -4906,14 +4755,14 @@ class FileManager {
      * });
      *
      * // Access file upload monitoring
-     * const uploadProgress = fileSDK.monitorUploadProgress('upload-session-123');
+     * const uploadProgress = fileService.monitorUploadProgress('upload-session-123');
      * uploadProgress.on('progress', (percent) => {
      *   console.log(`Upload: ${percent}%`);
      * });
      * ```
      */
-    getFileSDK() {
-        return this.fileSDK;
+    getFileService() {
+        return this.fileService;
     }
 }
 
@@ -5813,5 +5662,5 @@ function createPersSDK(httpClient, config) {
     return new PersSDK(httpClient, config);
 }
 
-export { AuthTokenManager as A, BusinessManager as B, CampaignManager as C, DefaultAuthProvider as D, FileManager as F, LocalStorageTokenStorage as L, MemoryTokenStorage as M, PersSDK as P, RedemptionManager as R, TokenManager as T, UserManager as U, Web3Manager as W, PersApiClient as a, DEFAULT_PERS_CONFIG as b, createPersSDK as c, buildApiRoot as d, detectEnvironment as e, environment as f, AuthApi as g, AuthService as h, AuthManager as i, UserStatusManager as j, TransactionManager as k, PurchaseManager as l, mergeWithDefaults as m, TenantManager as n, AnalyticsManager as o, DonationManager as p, FileApi as q, FileService as r, createFileSDK as s, warnIfProblematicEnvironment as w };
-//# sourceMappingURL=pers-sdk-eO4XUi8w.js.map
+export { AuthTokenManager as A, BusinessManager as B, CampaignManager as C, DefaultAuthProvider as D, FileManager as F, LocalStorageTokenStorage as L, MemoryTokenStorage as M, PersSDK as P, RedemptionManager as R, TokenManager as T, UserManager as U, Web3Manager as W, PersApiClient as a, DEFAULT_PERS_CONFIG as b, createPersSDK as c, buildApiRoot as d, detectEnvironment as e, environment as f, AuthApi as g, AuthService as h, AuthManager as i, UserStatusManager as j, TransactionManager as k, PurchaseManager as l, mergeWithDefaults as m, TenantManager as n, AnalyticsManager as o, DonationManager as p, FileApi as q, FileService as r, warnIfProblematicEnvironment as w };
+//# sourceMappingURL=pers-sdk-DOuNyWFC.js.map