@explorins/pers-sdk 1.6.3 → 1.6.6

package/dist/chunks/pers-sdk-Z6MKeFBX.js

@@ -1,3353 +0,0 @@
-import { AccountOwnerType } from '@explorins/pers-shared';
-import { createUserSDK } from '../user.js';
-import { createUserStatusSDK } from '../user-status.js';
-import { T as TokenSDK } from './token-sdk-BW4kkJb3.js';
-import { createBusinessSDK } from '../business.js';
-import { createCampaignSDK } from '../campaign.js';
-import { createRedemptionSDK } from '../redemption.js';
-import { createTransactionSDK } from '../transaction.js';
-import { createPaymentSDK } from '../payment.js';
-import { createTenantSDK } from '../tenant.js';
-import { createAnalyticsSDK } from '../analytics.js';
-import { createDonationSDK } from '../donation.js';
-import { c as createWeb3SDK, b as getExplorerUrlByChainId } from './index-CJ9Jfa4A.js';
-import { c as createWeb3ChainSDK } from './index-CM21r58m.js';
-
-/**
- * PERS SDK Configuration interfaces and utilities
- *
- * Provides type-safe configuration options for the PERS SDK
- * with sensible defaults for production environments.
- */
-/**
- * Default configuration values
- */
-const DEFAULT_PERS_CONFIG = {
-    environment: 'production',
-    apiVersion: 'v2',
-    timeout: 30000,
-    retries: 3,
-    tokenRefreshMargin: 60, // Refresh tokens 60 seconds before expiry
-    backgroundRefreshThreshold: 30 // Use background refresh if >30s remaining
-};
-/**
- * Internal function to construct API root from environment
- * Now defaults to production and v2
- */
-function buildApiRoot(environment = 'production', version = 'v2') {
-    const baseUrls = {
-        development: 'https://explorins-loyalty.ngrok.io',
-        staging: `https://dev.api.pers.ninja/${version}`,
-        production: `https://api.pers.ninja/${version}`
-    };
-    return `${baseUrls[environment]}`;
-}
-/**
- * Merge user config with defaults
- */
-function mergeWithDefaults(config) {
-    return {
-        ...DEFAULT_PERS_CONFIG,
-        ...config,
-        environment: config.environment ?? DEFAULT_PERS_CONFIG.environment,
-        apiVersion: config.apiVersion ?? DEFAULT_PERS_CONFIG.apiVersion,
-        timeout: config.timeout ?? DEFAULT_PERS_CONFIG.timeout,
-        retries: config.retries ?? DEFAULT_PERS_CONFIG.retries
-    };
-}
-
-/**
- * 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.
- */
-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
-     */
-    async loginTenantAdmin(jwt) {
-        const body = {
-            authToken: jwt,
-            authType: AccountOwnerType.TENANT
-        };
-        return this.apiClient.post(`${this.basePath}/token`, body, { bypassAuth: true });
-    }
-    /**
-     * Login user with JWT - bypasses auth headers
-     */
-    async loginUser(jwt) {
-        const body = {
-            authToken: jwt,
-            authType: AccountOwnerType.USER
-        };
-        return this.apiClient.post(`${this.basePath}/token`, body, { bypassAuth: true });
-    }
-    async loginUnAuthenticated(rawLoginData) {
-        const body = {
-            authToken: '',
-            authType: AccountOwnerType.USER,
-            rawLoginData
-        };
-        return this.apiClient.post(`${this.basePath}/token`, body, { bypassAuth: true });
-    }
-    /**
-     * Refresh access token - bypasses auth headers to prevent circular dependency
-     */
-    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.
- */
-class AuthService {
-    constructor(authApi, authProvider) {
-        this.authApi = authApi;
-        this.authProvider = authProvider;
-    }
-    // ==========================================
-    // ADMIN AUTHENTICATION OPERATIONS
-    // ==========================================
-    /**
-     * ADMIN: Login tenant admin with JWT
-     * Automatically stores tokens if auth provider supports token storage
-     */
-    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
-     */
-    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
-     */
-    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
-        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
-     */
-    async refreshAccessToken(refreshToken) {
-        // Use provided refresh token or get from auth provider
-        const tokenToUse = refreshToken || (this.authProvider?.getRefreshToken ? 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;
-    }
-    /**
-     * Automatic token refresh using stored refresh token
-     * Convenience method for 401 error handling
-     */
-    async autoRefreshToken() {
-        return this.refreshAccessToken(); // Uses stored refresh token
-    }
-    /**
-     * Clear stored tokens if auth provider supports it
-     */
-    async clearTokens() {
-        if (this.authProvider?.clearTokens) {
-            await this.authProvider.clearTokens();
-        }
-    }
-    /**
-     * Check if we have valid tokens for authentication
-     */
-    hasValidAuth() {
-        return this.authProvider?.hasValidToken?.() ?? false;
-    }
-    // ==========================================
-    // PRIVATE HELPERS
-    // ==========================================
-    /**
-     * Store tokens using auth provider if it supports token storage
-     */
-    async storeTokens(accessToken, refreshToken, authType, providerToken) {
-        if (!this.authProvider)
-            return;
-        try {
-            // Store access token
-            if (this.authProvider.setAccessToken) {
-                await this.authProvider.setAccessToken(accessToken);
-            }
-            // Store refresh token if provided and supported
-            if (refreshToken && this.authProvider.setRefreshToken) {
-                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);
-            }
-            // 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);
-            }
-        }
-        catch (error) {
-            // Don't throw - token storage failure shouldn't break authentication
-        }
-    }
-}
-
-/**
- * Authentication-related constants for type safety
- */
-/**
- * Storage keys for authentication tokens
- */
-const AUTH_STORAGE_KEYS = {
-    ACCESS_TOKEN: 'pers_access_token',
-    REFRESH_TOKEN: 'pers_refresh_token',
-    PROVIDER_TOKEN: 'pers_provider_token', // Generic external JWT (Firebase, Auth0, etc.)
-    AUTH_TYPE: 'pers_auth_type',
-};
-/**
- * Generate prefixed storage keys for different auth types
- */
-function createStorageKey(baseKey, authType = 'user') {
-    if (baseKey === AUTH_STORAGE_KEYS.ACCESS_TOKEN) {
-        return `pers_access_token_${authType}`;
-    }
-    if (baseKey === AUTH_STORAGE_KEYS.REFRESH_TOKEN) {
-        return `pers_refresh_token_${authType}`;
-    }
-    return baseKey;
-}
-/**
- * Authentication method types
- */
-const AUTH_METHODS = {
-    GET: 'GET',
-    POST: 'POST',
-    PUT: 'PUT',
-    DELETE: 'DELETE',
-};
-
-/**
- * Token Storage Management
- *
- * Handles secure token storage with different strategies
- */
-/**
- * LocalStorage-based token storage
- */
-let LocalStorageTokenStorage$1 = class LocalStorageTokenStorage {
-    async setToken(key, value) {
-        if (typeof localStorage !== 'undefined') {
-            localStorage.setItem(key, value);
-        }
-    }
-    async getToken(key) {
-        if (typeof localStorage !== 'undefined') {
-            return localStorage.getItem(key);
-        }
-        return null;
-    }
-    async removeToken(key) {
-        if (typeof localStorage !== 'undefined') {
-            localStorage.removeItem(key);
-        }
-    }
-    async clear() {
-        if (typeof localStorage !== 'undefined') {
-            Object.values(AUTH_STORAGE_KEYS).forEach(key => {
-                localStorage.removeItem(key);
-            });
-        }
-    }
-};
-/**
- * Token Manager - High-level token management
- */
-let TokenManager$1 = class TokenManager {
-    constructor(storage = new LocalStorageTokenStorage$1()) {
-        this.storage = storage;
-    }
-    async setAccessToken(token) {
-        await this.storage.setToken(AUTH_STORAGE_KEYS.ACCESS_TOKEN, token);
-    }
-    async getAccessToken() {
-        return this.storage.getToken(AUTH_STORAGE_KEYS.ACCESS_TOKEN);
-    }
-    async setRefreshToken(token) {
-        await this.storage.setToken(AUTH_STORAGE_KEYS.REFRESH_TOKEN, token);
-    }
-    async getRefreshToken() {
-        return this.storage.getToken(AUTH_STORAGE_KEYS.REFRESH_TOKEN);
-    }
-    async getProviderToken() {
-        return await this.storage.getToken(AUTH_STORAGE_KEYS.PROVIDER_TOKEN);
-    }
-    async setTokenData(data) {
-        if (data.accessToken) {
-            await this.setAccessToken(data.accessToken);
-        }
-        if (data.refreshToken) {
-            await this.setRefreshToken(data.refreshToken);
-        }
-        // Could store expiration time if needed
-    }
-    async getTokenData() {
-        const accessToken = await this.getAccessToken();
-        const refreshToken = await this.getRefreshToken();
-        return {
-            accessToken: accessToken || undefined,
-            refreshToken: refreshToken || undefined
-        };
-    }
-    async clearAllTokens() {
-        await this.storage.clear();
-    }
-    async hasValidTokens() {
-        const accessToken = await this.getAccessToken();
-        return !!accessToken;
-    }
-    async hasRefreshToken() {
-        const refreshToken = await this.getRefreshToken();
-        return !!refreshToken;
-    }
-    async removeToken(key) {
-        await this.storage.removeToken(key);
-    }
-    /**
-     * Set auth type (user or admin)
-     */
-    async setAuthType(authType) {
-        await this.storage.setToken(AUTH_STORAGE_KEYS.AUTH_TYPE, authType);
-    }
-    /**
-     * Get stored auth type
-     */
-    async getAuthType() {
-        const authType = await this.storage.getToken(AUTH_STORAGE_KEYS.AUTH_TYPE);
-        return authType;
-    }
-    /**
-     * Clear auth type from storage
-     */
-    async clearAuthType() {
-        await this.storage.removeToken(AUTH_STORAGE_KEYS.AUTH_TYPE);
-    }
-    /**
-     * Set provider token (generic external JWT)
-     */
-    async setProviderToken(token) {
-        await this.storage.setToken(AUTH_STORAGE_KEYS.PROVIDER_TOKEN, token);
-    }
-    /**
-     * Clear provider token
-     */
-    async clearProviderToken() {
-        await this.storage.removeToken(AUTH_STORAGE_KEYS.PROVIDER_TOKEN);
-    }
-};
-
-/**
- * PERS SDK Error Handling - Optimized for Performance
- *
- * Consolidated API and auth errors for fast SDK performance
- * Uses @explorins/pers-shared when available, fallback to SDK errors
- */
-// Fast type guards and utilities
-class ErrorUtils {
-    /**
-     * Fast token expiration detection
-     */
-    static isTokenExpired(error) {
-        if (typeof error !== 'object' || error === null)
-            return false;
-        const err = error;
-        const apiError = err?.error || err?.response?.data || err;
-        const status = err?.status || err?.response?.status || err?.statusCode;
-        return apiError?.code === 'TOKEN_EXPIRED' ||
-            apiError?.errorCode === 'TOKEN_EXPIRED' ||
-            (status === 401 && apiError?.message?.toLowerCase()?.includes('token'));
-    }
-    /**
-     * Fast error message extraction
-     */
-    static getMessage(error) {
-        if (typeof error !== 'object' || error === null)
-            return 'Unknown error';
-        const err = error;
-        const apiError = err?.error || err?.response?.data || err;
-        return apiError?.message || apiError?.detail || err?.message || 'Request failed';
-    }
-    /**
-     * Fast status code extraction
-     */
-    static getStatus(error) {
-        if (typeof error !== 'object' || error === null)
-            return null;
-        const err = error;
-        return err?.status || err?.statusCode || err?.response?.status || null;
-    }
-    /**
-     * Fast retryability check
-     */
-    static isRetryable(error) {
-        if (typeof error !== 'object' || error === null)
-            return false;
-        const err = error;
-        // Check explicit retryable property first (fastest)
-        if (typeof err?.retryable === 'boolean')
-            return err.retryable;
-        // Fast status-based check
-        const status = ErrorUtils.getStatus(error);
-        return status === null || status >= 500 || status === 429;
-    }
-    /**
-     * Check if error is from PERS API (uses @explorins/pers-shared format)
-     */
-    static isPersApiError(error) {
-        return typeof error === 'object' && error !== null &&
-            'errorCode' in error && 'domain' in error && 'category' in error;
-    }
-}
-// SDK-specific error classes for auth flows
-class TokenRefreshNeeded extends Error {
-    constructor(refreshToken) {
-        super('Token refresh needed');
-        this.refreshToken = refreshToken;
-        this.errorCode = 'TOKEN_REFRESH_NEEDED';
-        this.domain = 'auth';
-        this.category = 'SECURITY';
-        this.retryable = true;
-        this.name = 'TokenRefreshNeeded';
-    }
-}
-class ProviderTokenRefreshNeeded extends Error {
-    constructor(providerToken) {
-        super('Provider token refresh needed');
-        this.providerToken = providerToken;
-        this.errorCode = 'PROVIDER_TOKEN_REFRESH_NEEDED';
-        this.domain = 'auth';
-        this.category = 'SECURITY';
-        this.retryable = true;
-        this.name = 'ProviderTokenRefreshNeeded';
-    }
-}
-class LogoutRequired extends Error {
-    constructor(message) {
-        super(message);
-        this.errorCode = 'LOGOUT_REQUIRED';
-        this.domain = 'auth';
-        this.category = 'SECURITY';
-        this.retryable = false;
-        this.name = 'LogoutRequired';
-    }
-}
-class PersApiError extends Error {
-    constructor(message, endpoint, method, status, retryable = false) {
-        super(`API request failed: ${message}`);
-        this.endpoint = endpoint;
-        this.method = method;
-        this.status = status;
-        this.errorCode = 'PERS_API_ERROR';
-        this.domain = 'api';
-        this.category = 'TECHNICAL';
-        this.name = 'PersApiError';
-        this.retryable = retryable;
-    }
-}
-
-/**
- * Token Refresh Management
- *
- * Handles the 6-step authentication process:
- * 1. Check for provider token → get complete token set from PERS if missing
- * 2. Store all tokens (access, refresh, provider)
- * 3. Use access token for requests
- * 4. Use refresh token if access expires → get new token set, keep provider
- * 5. Fall back to provider token if refresh fails → get fresh token set from PERS
- * 6. Clear all tokens if provider also fails
- */
-/**
- * Token Refresh Manager
- *
- * Implements the 6-step authentication process:
- * 1. Use provider token to retrieve complete token set from PERS if not present
- * 2. Store all 3 tokens (access, refresh, provider)
- * 3. Use access token for API requests
- * 4. Use refresh token if access expires → get new token set, preserve provider token
- * 5. Fall back to provider token if refresh fails → get fresh token set from PERS
- * 6. Clear all tokens if provider also fails → force logout
- */
-class TokenRefreshManager {
-    constructor(tokenManager, refreshStrategy) {
-        this.refreshAttempts = new Map();
-        this.MAX_REFRESH_ATTEMPTS = 1;
-        this.loginRequiredListeners = [];
-        this.tokenManager = tokenManager;
-        this.refreshStrategy = refreshStrategy;
-    }
-    /**
-     * Add listener for login required events
-     */
-    onLoginRequired(listener) {
-        this.loginRequiredListeners.push(listener);
-    }
-    /**
-     * Remove listener for login required events
-     */
-    removeLoginRequiredListener(listener) {
-        const index = this.loginRequiredListeners.indexOf(listener);
-        if (index > -1) {
-            this.loginRequiredListeners.splice(index, 1);
-        }
-    }
-    /**
-     * Emit login required event to all listeners
-     */
-    emitLoginRequired(reason) {
-        const event = {
-            reason,
-            timestamp: new Date()
-        };
-        this.loginRequiredListeners.forEach(listener => {
-            try {
-                listener(event);
-            }
-            catch (error) {
-                // Listener error - continuing with other listeners
-            }
-        });
-    }
-    /**
-     * Handle token expiration - orchestrates the 6-step authentication process
-     * 1. Check for provider token → get complete token set from PERS if missing
-     * 2. Store all 3 tokens (access, refresh, provider)
-     * 3. Use access token for requests
-     * 4. Use refresh token if access expires → get new token set, keep provider
-     * 5. Fall back to provider token if refresh fails → get fresh token set from PERS
-     * 6. Clear all tokens if provider also fails
-     */
-    async handleTokenExpiration() {
-        try {
-            const accessToken = await this.tokenManager.getAccessToken();
-            const refreshToken = await this.tokenManager.getRefreshToken();
-            const providerToken = await this.tokenManager.getProviderToken();
-            // If we have no PERS tokens but have a provider token, use it to get the complete set
-            if (!accessToken && !refreshToken && providerToken) {
-                await this.executeProviderTokenFlow(providerToken);
-                return;
-            }
-            // Try refresh token if we have one  
-            if (refreshToken) {
-                await this.executeRefreshTokenFlow(refreshToken);
-                return;
-            }
-            // No refresh token, try provider token
-            if (providerToken) {
-                await this.executeProviderTokenFlow(providerToken);
-                return;
-            }
-            // No tokens available, require login
-            await this.executeAuthCleanup('No authentication tokens available');
-            throw new LogoutRequired('No authentication tokens available');
-        }
-        catch (error) {
-            if (error instanceof TokenRefreshNeeded || error instanceof ProviderTokenRefreshNeeded || error instanceof LogoutRequired) {
-                throw error;
-            }
-            // Convert unexpected errors to login requirement
-            await this.executeAuthCleanup('Authentication process failed unexpectedly');
-            throw new LogoutRequired('Authentication process failed unexpectedly');
-        }
-    }
-    /**
-     * Execute refresh with refresh token (Step 4)
-     * Use refresh token to get new access token, preserve provider token
-     */
-    async executeRefreshTokenFlow(refreshToken) {
-        const attempts = this.refreshAttempts.get(refreshToken) || 0;
-        if (attempts >= this.MAX_REFRESH_ATTEMPTS) {
-            await this.fallbackToProviderToken();
-            return;
-        }
-        try {
-            this.refreshAttempts.set(refreshToken, attempts + 1);
-            const result = await this.refreshStrategy.refreshWithRefreshToken(refreshToken);
-            await this.storeTokenResult(result);
-            this.refreshAttempts.delete(refreshToken);
-        }
-        catch (error) {
-            await this.fallbackToProviderToken();
-        }
-    } /**
-     * Execute refresh with provider token (Step 5)
-     * Uses provider token to get a fresh token set from PERS backend
-     */
-    async executeProviderTokenFlow(providerToken) {
-        try {
-            const result = await this.refreshStrategy.refreshWithProviderToken(providerToken);
-            await this.storeTokenResult(result);
-            this.refreshAttempts.clear();
-        }
-        catch (error) {
-            await this.executeAuthCleanup('Provider token authentication failed - all methods exhausted');
-            throw new LogoutRequired('Provider token authentication failed - all methods exhausted');
-        }
-    }
-    async storeTokenResult(result) {
-        await this.tokenManager.setAccessToken(result.accessToken);
-        if (result.refreshToken) {
-            await this.tokenManager.setRefreshToken(result.refreshToken);
-        }
-    }
-    async fallbackToProviderToken() {
-        const providerToken = await this.tokenManager.getProviderToken();
-        if (providerToken) {
-            try {
-                await this.executeProviderTokenFlow(providerToken);
-            }
-            catch (providerError) {
-                await this.executeAuthCleanup('All authentication methods exhausted');
-                throw new LogoutRequired('All authentication methods exhausted');
-            }
-        }
-        else {
-            await this.executeAuthCleanup('Refresh failed and no provider token available');
-            throw new LogoutRequired('Refresh failed and no provider token available');
-        }
-    }
-    async clearAuthTokens() {
-        await this.tokenManager.removeToken(AUTH_STORAGE_KEYS.ACCESS_TOKEN);
-        await this.tokenManager.removeToken(AUTH_STORAGE_KEYS.REFRESH_TOKEN);
-        // Clear refresh attempts tracking
-        this.refreshAttempts.clear();
-    }
-    /**
-     * Execute authentication cleanup and notify login required (Step 6)
-     */
-    async executeAuthCleanup(reason = 'Authentication failed') {
-        await this.tokenManager.clearAllTokens();
-        this.refreshAttempts.clear();
-        this.emitLoginRequired(reason);
-    }
-    /**
-     * Check if an error should trigger token refresh (React Native compatible)
-     */
-    shouldRefreshToken(error) {
-        return ErrorUtils.isTokenExpired(error);
-    }
-}
-
-/**
- * DefaultAuthRefreshStrategy - Implements the actual refresh logic
- */
-class DefaultAuthRefreshStrategy {
-    constructor(tokenManager, getProviderTokenFn, authApi) {
-        this.tokenManager = tokenManager;
-        this.getProviderTokenFn = getProviderTokenFn;
-        this.authApi = authApi;
-    }
-    async refreshWithRefreshToken(refreshToken) {
-        try {
-            const result = await this.authApi.refreshAccessToken(refreshToken);
-            if (!result.accessToken) {
-                throw new Error('Invalid refresh response: missing accessToken');
-            }
-            return {
-                accessToken: result.accessToken,
-                refreshToken: result.refreshToken || refreshToken
-            };
-        }
-        catch (error) {
-            throw new Error(`Refresh token invalid or expired: ${error instanceof Error ? error.message : 'Unknown error'}`);
-        }
-    }
-    async refreshWithProviderToken(providerToken) {
-        try {
-            const storedAuthType = await this.tokenManager.getAuthType();
-            let result;
-            if (storedAuthType === 'admin') {
-                result = await this.authApi.loginTenantAdmin(providerToken);
-            }
-            else if (storedAuthType === 'user') {
-                result = await this.authApi.loginUser(providerToken);
-            }
-            else {
-                try {
-                    result = await this.authApi.loginUser(providerToken);
-                    await this.tokenManager.setAuthType('user');
-                }
-                catch (userLoginError) {
-                    result = await this.authApi.loginTenantAdmin(providerToken);
-                    await this.tokenManager.setAuthType('admin');
-                }
-            }
-            if (!result.accessToken) {
-                throw new Error('Invalid provider login response: missing accessToken');
-            }
-            return {
-                accessToken: result.accessToken,
-                refreshToken: result.refreshToken
-            };
-        }
-        catch (error) {
-            throw new Error(`Provider token login failed: ${error instanceof Error ? error.message : 'Unknown error'}`);
-        }
-    }
-}
-/**
- * Default authentication provider with modular architecture
- *
- * Delegates token storage to TokenManager and refresh logic to TokenRefreshManager.
- * Perfect for platform-agnostic usage with reliable error handling.
- */
-class DefaultAuthProvider {
-    constructor(projectKey, authApi) {
-        this.projectKey = null;
-        this.authApi = null;
-        this.authType = 'admin';
-        this.projectKey = projectKey || null;
-        this.authApi = authApi || null;
-        this.tokenManager = new TokenManager$1();
-        const refreshStrategy = new DefaultAuthRefreshStrategy(this.tokenManager, () => Promise.resolve(this.getProviderToken()), this.authApi);
-        this.tokenRefreshManager = new TokenRefreshManager(this.tokenManager, refreshStrategy);
-    }
-    async getToken() {
-        return await this.tokenManager.getAccessToken();
-    }
-    async getProjectKey() {
-        return this.projectKey;
-    }
-    /**
-     * Centralized token refresh handler - delegates to TokenRefreshManager
-     */
-    async onTokenExpired() {
-        await this.tokenRefreshManager.handleTokenExpiration();
-    }
-    /**
-     * Check if an error indicates token expiration (React Native compatible)
-     */
-    isTokenExpiredError(error) {
-        return ErrorUtils.isTokenExpired(error);
-    }
-    /**
-     * Get Firebase or other provider token for fresh JWT request
-     * Type-safe method that uses proper storage keys from AUTH_STORAGE_KEYS
-     */
-    getProviderToken() {
-        if (typeof localStorage !== 'undefined') {
-            return localStorage.getItem(AUTH_STORAGE_KEYS.PROVIDER_TOKEN);
-        }
-        return null;
-    }
-    async setAccessToken(token) {
-        await this.tokenManager.setAccessToken(token);
-    }
-    async setRefreshToken(token) {
-        await this.tokenManager.setRefreshToken(token);
-    }
-    async getRefreshToken() {
-        return await this.tokenManager.getRefreshToken();
-    }
-    async setProviderToken(token) {
-        await this.tokenManager.setProviderToken(token);
-    }
-    async clearProviderToken() {
-        await this.tokenManager.clearProviderToken();
-    }
-    async clearTokens() {
-        await this.tokenManager.clearAllTokens();
-    }
-    hasValidToken() {
-        if (typeof localStorage !== 'undefined') {
-            return !!localStorage.getItem(AUTH_STORAGE_KEYS.ACCESS_TOKEN);
-        }
-        return false;
-    }
-    hasRefreshToken() {
-        if (typeof localStorage !== 'undefined') {
-            return !!localStorage.getItem(AUTH_STORAGE_KEYS.REFRESH_TOKEN);
-        }
-        return false;
-    }
-    /**
-     * Proactively check token expiry and refresh if needed BEFORE making requests
-     * Uses smart refresh strategy based on time remaining:
-     * - >backgroundThreshold seconds: Background refresh (non-blocking)
-     * - <backgroundThreshold seconds: Immediate refresh (blocking)
-     */
-    async ensureValidToken(marginSeconds = 60, backgroundThreshold = 30) {
-        try {
-            const currentToken = await this.getToken();
-            // If no token, nothing to check
-            if (!currentToken) {
-                return;
-            }
-            // Check if token is expired or will expire within margin
-            if (await this.isTokenExpired(marginSeconds)) {
-                // Determine refresh strategy based on time remaining
-                const timeToExpiry = await this.getTokenTimeToExpiry(currentToken);
-                if (timeToExpiry > backgroundThreshold) {
-                    // Token has enough time left - start background refresh (non-blocking)
-                    this.startBackgroundRefresh();
-                }
-                else {
-                    // Token expiring soon or expired - block and refresh immediately
-                    const shouldSkipRefresh = await this.isRefreshTokenExpired(marginSeconds);
-                    if (shouldSkipRefresh) {
-                        // Both tokens expired - use provider token directly
-                        await this.handleExpiredRefreshToken();
-                    }
-                    else {
-                        // Normal refresh with refresh token
-                        if (this.onTokenExpired) {
-                            await this.onTokenExpired();
-                        }
-                    }
-                }
-            }
-        }
-        catch (error) {
-            // If token check/refresh fails, the error will be handled by the calling code
-            throw error;
-        }
-    }
-    /**
-     * Check if current access token is expired
-     */
-    async isTokenExpired(marginSeconds = 60) {
-        try {
-            const currentToken = await this.getToken();
-            if (!currentToken) {
-                return true;
-            }
-            // Import isTokenExpired function here to avoid circular imports
-            const { isTokenExpired } = await import('./index-CM21r58m.js').then(function (n) { return n.j; });
-            return isTokenExpired(currentToken, marginSeconds);
-        }
-        catch (error) {
-            return true;
-        }
-    }
-    /**
-     * Check if refresh token is expired
-     */
-    async isRefreshTokenExpired(marginSeconds = 60) {
-        try {
-            const refreshToken = await this.tokenManager.getRefreshToken();
-            if (!refreshToken) {
-                return true; // No refresh token
-            }
-            // Import isTokenExpired function here to avoid circular imports
-            const { isTokenExpired } = await import('./index-CM21r58m.js').then(function (n) { return n.j; });
-            return isTokenExpired(refreshToken, marginSeconds);
-        }
-        catch (error) {
-            return true; // Assume expired if we can't check
-        }
-    }
-    /**
-     * Check if both access and refresh tokens are expired
-     */
-    async areAllTokensExpired(marginSeconds = 60) {
-        const accessTokenExpired = await this.isTokenExpired(marginSeconds);
-        const refreshTokenExpired = await this.isRefreshTokenExpired(marginSeconds);
-        return accessTokenExpired && refreshTokenExpired;
-    }
-    /**
-     * Get seconds until token expires
-     */
-    async getTokenTimeToExpiry(token) {
-        try {
-            const { isTokenExpired } = await import('./index-CM21r58m.js').then(function (n) { return n.j; });
-            const { jwtDecode } = await import('jwt-decode');
-            const decoded = jwtDecode(token);
-            const currentTime = Math.floor(Date.now() / 1000);
-            return Math.max(0, decoded.exp - currentTime);
-        }
-        catch (error) {
-            return 0; // Assume expired if can't decode
-        }
-    }
-    /**
-     * Start refresh in background without blocking current request
-     */
-    startBackgroundRefresh() {
-        // Use setTimeout to avoid blocking the current request
-        setTimeout(async () => {
-            try {
-                if (this.onTokenExpired) {
-                    await this.onTokenExpired();
-                }
-            }
-            catch (error) {
-                // Background refresh failed - next request will trigger reactive refresh
-            }
-        }, 0);
-    }
-    /**
-     * Handle case where refresh token is also expired - use provider token directly
-     */
-    async handleExpiredRefreshToken() {
-        try {
-            // Get provider token if available
-            const providerToken = this.getProviderToken();
-            if (!providerToken) {
-                // No provider token available - let normal refresh handle the failure
-                if (this.onTokenExpired) {
-                    await this.onTokenExpired();
-                }
-                return;
-            }
-            // Clear expired PERS tokens and use provider token to get fresh ones
-            await this.clearTokens();
-            // Trigger refresh which should now use provider token path
-            if (this.onTokenExpired) {
-                await this.onTokenExpired();
-            }
-        }
-        catch (error) {
-            // If provider token flow fails, let normal refresh handle it
-            if (this.onTokenExpired) {
-                await this.onTokenExpired();
-            }
-        }
-    }
-}
-
-// 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.
- *
- * 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
- *
- * @example
- * ```typescript
- * const client = new PersApiClient(httpClient, {
- *   environment: 'production',
- *   apiProjectKey: 'your-project-key',
- *   authProvider: createAuthProvider({
- *     tokenProvider: () => getFirebaseToken()
- *   })
- * });
- *
- * // Make authenticated requests
- * const data = await client.get('/users/me');
- * ```
- */
-class PersApiClient {
-    /**
-     * Creates a new PERS API Client instance
-     *
-     * @param httpClient - Platform-specific HTTP client implementation
-     * @param config - Configuration options for the API client
-     */
-    constructor(httpClient, config) {
-        this.httpClient = httpClient;
-        this.config = config;
-        // Merge user config with defaults (production + v2)
-        this.mergedConfig = mergeWithDefaults(config);
-        // Build API root from merged environment and version
-        this.apiRoot = buildApiRoot(this.mergedConfig.environment, this.mergedConfig.apiVersion);
-        // Initialize auth services for direct authentication
-        this.authApi = new AuthApi(this);
-        // Auto-create auth provider if none provided
-        if (!this.mergedConfig.authProvider) {
-            this.mergedConfig.authProvider = new DefaultAuthProvider(this.mergedConfig.apiProjectKey, this.authApi);
-        }
-        this.authService = new AuthService(this.authApi, this.mergedConfig.authProvider);
-    }
-    /**
-     * Ensures valid authentication token before making requests
-     *
-     * Implements intelligent refresh strategy:
-     * - Tokens with sufficient time remaining: Background refresh (non-blocking)
-     * - Tokens expiring soon or expired: Immediate refresh (blocking)
-     *
-     * @private
-     * @returns Promise that resolves when token validation is complete
-     */
-    async ensureValidToken() {
-        if (!this.mergedConfig.authProvider?.ensureValidToken) {
-            return; // Auth provider doesn't support proactive validation
-        }
-        try {
-            const refreshMargin = this.mergedConfig.tokenRefreshMargin || 60;
-            const backgroundThreshold = this.mergedConfig.backgroundRefreshThreshold || 30;
-            await this.mergedConfig.authProvider.ensureValidToken(refreshMargin, backgroundThreshold);
-        }
-        catch (error) {
-            // If token check/refresh fails, continue with request
-            // The reactive error handling will catch any auth issues
-        }
-    }
-    /**
-     * 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}`;
-            }
-        }
-        // 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
-        if (!bypassAuth && this.mergedConfig.authProvider && retryCount === 0) {
-            await this.ensureValidToken();
-        }
-        const requestOptions = {
-            headers: bypassAuth ? await this.getHeadersWithoutAuth() : await this.getHeaders(),
-            timeout: this.mergedConfig.timeout,
-            responseType
-        };
-        // Log API request with auth info
-        // const hasAuth = !!this.mergedConfig.authProvider;
-        endpoint.includes('/export/csv');
-        try {
-            let result;
-            switch (method) {
-                case AUTH_METHODS.GET:
-                    result = await this.httpClient.get(url, requestOptions);
-                    break;
-                case AUTH_METHODS.POST:
-                    result = await this.httpClient.post(url, body, requestOptions);
-                    break;
-                case AUTH_METHODS.PUT:
-                    result = await this.httpClient.put(url, body, requestOptions);
-                    break;
-                case AUTH_METHODS.DELETE:
-                    result = await this.httpClient.delete(url, requestOptions);
-                    break;
-                default:
-                    throw new Error(`Unsupported HTTP method: ${method}`);
-            }
-            return result;
-        }
-        catch (error) {
-            // Error handling - proactive token refresh should prevent most 401s
-            const status = ErrorUtils.getStatus(error);
-            const errorMessage = ErrorUtils.getMessage(error);
-            // Fallback: reactive token refresh only if proactive check missed something
-            if (retryCount === 0 && this.mergedConfig.authProvider && ErrorUtils.isTokenExpired(error)) {
-                try {
-                    // Fallback token refresh delegation
-                    const result = await this.handleTokenRefreshDelegation(method, endpoint, body, options);
-                    if (result !== null) {
-                        return result;
-                    }
-                }
-                catch (refreshError) {
-                    throw new PersApiError(`Auth failed: ${refreshError.message || refreshError}`, endpoint, method, 401);
-                }
-            }
-            throw new PersApiError(errorMessage, endpoint, method, status || undefined, ErrorUtils.isRetryable(error));
-        }
-    }
-    /**
-     * Delegate token refresh to auth provider and handle the results
-     */
-    async handleTokenRefreshDelegation(method, endpoint, body, options) {
-        try {
-            // Let auth provider handle the refresh process
-            const authProvider = this.mergedConfig.authProvider;
-            if (authProvider?.onTokenExpired) {
-                await authProvider.onTokenExpired();
-            }
-            // If we get here, tokens should be refreshed - retry the request
-            // Auth provider refresh succeeded, retrying...
-            return this.request(method, endpoint, body, { ...options, retryCount: 1 });
-        }
-        catch (refreshError) {
-            // Auth provider handled all refresh attempts and failed
-            // Re-throw the error for the caller to handle
-            throw refreshError;
-        }
-    }
-    /**
-     * Performs an authenticated GET request
-     *
-     * @template T - Expected response type
-     * @param endpoint - API endpoint path (without base URL)
-     * @param responseType - Expected response format
-     * @returns Promise resolving to typed response data
-     *
-     * @example
-     * ```typescript
-     * const user = await client.get<User>('/users/123');
-     * const csvData = await client.get('/export/data', 'blob');
-     * ```
-     */
-    async get(endpoint, responseType) {
-        return this.request(AUTH_METHODS.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);
-    }
-    /**
-     * Generic PUT request
-     */
-    async put(endpoint, body) {
-        return this.request(AUTH_METHODS.PUT, endpoint, body);
-    }
-    /**
-     * Generic DELETE request
-     */
-    async delete(endpoint) {
-        return this.request(AUTH_METHODS.DELETE, endpoint);
-    }
-    /**
-   * Get request headers WITHOUT auth token (for auth operations like refresh/login)
-   */
-    async getHeadersWithoutAuth() {
-        const headers = {
-            'Content-Type': 'application/json',
-        };
-        // Add project key only (no auth token)
-        if (this.mergedConfig.authProvider) {
-            const projectKey = await this.mergedConfig.authProvider.getProjectKey();
-            if (projectKey) {
-                headers['x-project-key'] = projectKey;
-            }
-        }
-        else if (this.mergedConfig.apiProjectKey) {
-            headers['x-project-key'] = this.mergedConfig.apiProjectKey;
-        }
-        return headers;
-    }
-    // ==========================================
-    // AUTHENTICATION METHODS
-    // ==========================================
-    /**
-     * Authenticates an admin user using external JWT token
-     *
-     * Exchanges external provider token (Firebase, Auth0, etc.) for PERS access tokens.
-     * Automatically stores received tokens for subsequent requests.
-     *
-     * @param externalJwt - JWT token from external authentication provider
-     * @returns Promise resolving to session context with admin permissions
-     *
-     * @example
-     * ```typescript
-     * const firebaseToken = await getIdToken();
-     * const session = await client.loginAdmin(firebaseToken);
-     * console.log('Admin authenticated:', session.user.email);
-     * ```
-     */
-    async loginAdmin(externalJwt) {
-        return this.authService.loginTenantAdmin(externalJwt);
-    }
-    /**
-     * Authenticates a regular user using external JWT token
-     *
-     * Exchanges external provider token for PERS access tokens with user-level permissions.
-     * Automatically stores received tokens for subsequent requests.
-     *
-     * @param externalJwt - JWT token from external authentication provider
-     * @returns Promise resolving to session context with user permissions
-     *
-     * @example
-     * ```typescript
-     * const firebaseToken = await getIdToken();
-     * const session = await client.loginUser(firebaseToken);
-     * console.log('User authenticated:', session.user.email);
-     * ```
-     */
-    async loginUser(externalJwt) {
-        return this.authService.loginUser(externalJwt);
-    }
-    /**
-     * Authenticates a user using raw login data (no external JWT)
-     *
-     * Useful for custom authentication flows where user data is provided directly.
-     * Automatically stores received tokens for subsequent requests.
-     *
-     * @param rawLoginData - Object containing user login data (email, name, etc.)
-     * @return Promise resolving to session context with user permissions
-     */
-    async loginUserWithRawData(rawLoginData) {
-        return this.authService.loginUserWithRawData(rawLoginData);
-    }
-    /**
-     * Checks if current user has a valid authentication token
-     *
-     * Performs basic token availability check without network requests.
-     * For comprehensive validation including expiry, use isTokenExpired().
-     *
-     * @returns True if valid token exists, false otherwise
-     *
-     * @example
-     * ```typescript
-     * if (client.hasValidAuth()) {
-     *   // User is authenticated, proceed with API calls
-     *   const data = await client.get('/protected-data');
-     * } else {
-     *   // Redirect to login
-     *   redirectToLogin();
-     * }
-     * ```
-     */
-    hasValidAuth() {
-        return this.mergedConfig.authProvider?.hasValidToken?.() || false;
-    }
-    /**
-     * Checks if current access token is expired or expiring soon
-     *
-     * @param marginSeconds - Seconds before expiry to consider token as expired (default: 60)
-     * @returns Promise resolving to true if token is expired/expiring, false if valid
-     *
-     * @example
-     * ```typescript
-     * if (await client.isTokenExpired(120)) {
-     *   console.log('Token expires within 2 minutes');
-     *   // Optionally trigger manual refresh
-     * }
-     * ```
-     */
-    async isTokenExpired(marginSeconds = 60) {
-        if (!this.mergedConfig.authProvider?.isTokenExpired) {
-            return true; // No auth provider or doesn't support expiry checking
-        }
-        try {
-            return await this.mergedConfig.authProvider.isTokenExpired(marginSeconds);
-        }
-        catch (error) {
-            return true;
-        }
-    }
-    /**
-     * Checks if both access and refresh tokens are expired
-     *
-     * Useful for determining if full re-authentication is required.
-     *
-     * @param marginSeconds - Seconds before expiry to consider tokens as expired (default: 60)
-     * @returns Promise resolving to true if both tokens expired, false otherwise
-     *
-     * @example
-     * ```typescript
-     * if (await client.areAllTokensExpired()) {
-     *   // Full re-authentication required
-     *   await redirectToLogin();
-     * }
-     * ```
-     */
-    async areAllTokensExpired(marginSeconds = 60) {
-        if (!this.mergedConfig.authProvider?.areAllTokensExpired) {
-            // Fallback to checking access token only
-            return await this.isTokenExpired(marginSeconds);
-        }
-        return await this.mergedConfig.authProvider.areAllTokensExpired(marginSeconds);
-    }
-    /**
-     * Refresh access token using stored refresh token
-     *
-     * @param refreshToken - Optional refresh token, uses stored token if not provided
-     * @returns Promise resolving to new auth tokens
-     *
-     * @example
-     * ```typescript
-     * try {
-     *   const tokens = await client.refreshTokens();
-     *   console.log('Tokens refreshed successfully');
-     * } catch (error) {
-     *   console.error('Token refresh failed:', error);
-     * }
-     * ```
-     */
-    async refreshTokens(refreshToken) {
-        return this.authService.refreshAccessToken(refreshToken);
-    }
-    /**
-     * Get current configuration (returns merged config)
-     */
-    getConfig() {
-        return this.mergedConfig;
-    }
-    /**
-     * Get original user configuration
-     */
-    getOriginalConfig() {
-        return this.config;
-    }
-}
-
-/**
- * Memory-based token storage (default)
- */
-class MemoryTokenStorage {
-    constructor() {
-        this.storage = new Map();
-    }
-    async setItem(key, value) {
-        this.storage.set(key, value);
-    }
-    async getItem(key) {
-        return this.storage.get(key) || null;
-    }
-    async removeItem(key) {
-        this.storage.delete(key);
-    }
-}
-/**
- * localStorage-based token storage (browser only)
- */
-class LocalStorageTokenStorage {
-    async setItem(key, value) {
-        if (typeof localStorage !== 'undefined') {
-            localStorage.setItem(key, value);
-        }
-        else {
-            throw new Error('localStorage is not available in this environment');
-        }
-    }
-    async getItem(key) {
-        if (typeof localStorage !== 'undefined') {
-            return localStorage.getItem(key);
-        }
-        return null;
-    }
-    async removeItem(key) {
-        if (typeof localStorage !== 'undefined') {
-            localStorage.removeItem(key);
-        }
-    }
-}
-/**
- * Creates a platform-agnostic AuthProvider from simple configuration
- *
- * This factory function is completely platform-agnostic and can be used
- * across Angular, React, Vue, Node.js, or any other JavaScript environment.
- *
- * Features:
- * - Token caching with refresh support
- * - Automatic token refresh on expiration
- * - Configurable token providers
- * - Token storage (memory, localStorage, custom)
- * - Platform-independent
- *
- * @param config - Simple auth configuration
- * @returns AuthProvider implementation
- */
-function createAuthProvider(config) {
-    // Initialize token storage
-    let tokenStorage;
-    switch (config.tokenStorage) {
-        case 'localStorage':
-            tokenStorage = new LocalStorageTokenStorage();
-            break;
-        case 'custom':
-            if (!config.customTokenStorage) {
-                throw new Error('Custom token storage configuration is required when tokenStorage is "custom"');
-            }
-            tokenStorage = config.customTokenStorage;
-            break;
-        case 'memory':
-        default:
-            tokenStorage = new MemoryTokenStorage();
-            break;
-    }
-    // Token storage keys
-    const ACCESS_TOKEN_KEY = createStorageKey(AUTH_STORAGE_KEYS.ACCESS_TOKEN, config.authType || 'user');
-    const REFRESH_TOKEN_KEY = createStorageKey(AUTH_STORAGE_KEYS.REFRESH_TOKEN, config.authType || 'user');
-    // Store current token for refresh scenarios and caching
-    let currentToken = config.token || null;
-    let isRefreshing = false; // Prevent concurrent refresh attempts
-    let refreshPromise = null;
-    return {
-        authType: config.authType || 'user',
-        async getToken() {
-            // If currently refreshing, wait for it to complete
-            if (isRefreshing && refreshPromise) {
-                await refreshPromise;
-                return currentToken;
-            }
-            // Use cached current token (updated after refresh)
-            if (currentToken) {
-                return currentToken;
-            }
-            // Try to get token from storage
-            try {
-                const storedToken = await tokenStorage.getItem(ACCESS_TOKEN_KEY);
-                if (storedToken) {
-                    currentToken = storedToken;
-                    return storedToken;
-                }
-            }
-            catch (error) {
-                // Token retrieval failed - continuing without storage
-            }
-            // Custom token provider function (always fresh)
-            if (config.tokenProvider) {
-                const token = await config.tokenProvider();
-                currentToken = token; // Cache for future calls
-                return token;
-            }
-            // No token available
-            return null;
-        },
-        async getProjectKey() {
-            return config.projectKey || null;
-        },
-        // Token storage methods
-        async setAccessToken(token) {
-            currentToken = token;
-            try {
-                await tokenStorage.setItem(ACCESS_TOKEN_KEY, token);
-            }
-            catch (error) {
-                throw error;
-            }
-        },
-        async setRefreshToken(token) {
-            try {
-                await tokenStorage.setItem(REFRESH_TOKEN_KEY, token);
-            }
-            catch (error) {
-                throw error;
-            }
-        },
-        async getRefreshToken() {
-            try {
-                return await tokenStorage.getItem(REFRESH_TOKEN_KEY);
-            }
-            catch (error) {
-                return null;
-            }
-        },
-        async clearTokens() {
-            currentToken = null;
-            try {
-                await Promise.all([
-                    tokenStorage.removeItem(ACCESS_TOKEN_KEY),
-                    tokenStorage.removeItem(REFRESH_TOKEN_KEY)
-                ]);
-            }
-            catch (error) {
-                throw error;
-            }
-        },
-        async onTokenExpired() {
-            // Prevent concurrent refresh attempts
-            if (isRefreshing) {
-                if (refreshPromise) {
-                    await refreshPromise;
-                }
-                return;
-            }
-            // No refresh logic provided
-            if (!config.onTokenExpired) {
-                currentToken = null;
-                try {
-                    await tokenStorage.removeItem(ACCESS_TOKEN_KEY);
-                }
-                catch (error) {
-                    // Token clearing failed - continuing
-                }
-                return;
-            }
-            // Start refresh process
-            isRefreshing = true;
-            refreshPromise = (async () => {
-                try {
-                    // Execute refresh logic (should update token source)
-                    await config.onTokenExpired();
-                    // After refresh, get the new token
-                    if (config.tokenProvider) {
-                        const newToken = await config.tokenProvider();
-                        if (newToken && newToken !== currentToken) {
-                            currentToken = newToken;
-                            // Store the new token
-                            try {
-                                await tokenStorage.setItem(ACCESS_TOKEN_KEY, newToken);
-                            }
-                            catch (error) {
-                                // Token storage failed - token still valid in memory
-                            }
-                            // Notify about successful token refresh
-                            if (config.onTokenRefreshed) {
-                                config.onTokenRefreshed(newToken);
-                            }
-                        }
-                        else {
-                            currentToken = null;
-                            try {
-                                await tokenStorage.removeItem(ACCESS_TOKEN_KEY);
-                            }
-                            catch (error) {
-                                // Token clearing failed - continuing
-                            }
-                        }
-                    }
-                    else {
-                        // For static token configs, clear the token since we can't refresh
-                        currentToken = null;
-                        try {
-                            await tokenStorage.removeItem(ACCESS_TOKEN_KEY);
-                        }
-                        catch (error) {
-                            // Token clearing failed - continuing
-                        }
-                    }
-                }
-                catch (error) {
-                    currentToken = null; // Clear token on refresh failure
-                    try {
-                        await tokenStorage.removeItem(ACCESS_TOKEN_KEY);
-                    }
-                    catch (storageError) {
-                        // Token clearing failed - continuing
-                    }
-                    throw error; // Re-throw to let SDK handle the error
-                }
-                finally {
-                    isRefreshing = false;
-                    refreshPromise = null;
-                }
-            })();
-            await refreshPromise;
-        }
-    };
-}
-/**
- * Platform-specific localStorage token provider for browsers
- * This is a convenience function for browser environments
- */
-/* export function createBrowserTokenProvider(tokenKey: string = 'userJwt'): () => Promise<string | null> {
-  return async () => {
-    if (typeof localStorage !== 'undefined') {
-      return localStorage.getItem(tokenKey);
-    }
-    return null;
-  };
-} */
-/**
- * Platform-specific environment variable token provider for Node.js
- * This is a convenience function for Node.js environments
- */
-/* export function createNodeTokenProvider(envVar: string = 'JWT_TOKEN'): () => Promise<string | null> {
-  return async () => {
-    if (typeof process !== 'undefined' && process.env) {
-      return process.env[envVar] || null;
-    }
-    return null;
-  };
-} */
-
-/**
- * Authentication Manager - Clean, high-level interface for authentication operations
- *
- * Provides a simplified API for common authentication tasks while maintaining
- * access to the underlying API client for advanced use cases.
- */
-class AuthManager {
-    constructor(apiClient) {
-        this.apiClient = apiClient;
-    }
-    /**
-     * Login with JWT token
-     *
-     * @param jwtToken - JWT token to authenticate with
-     * @param userType - Type of user ('user' | 'admin')
-     * @returns Promise resolving to authentication response
-     */
-    async loginWithToken(jwtToken, userType = 'user') {
-        return userType === 'admin'
-            ? this.apiClient.loginAdmin(jwtToken)
-            : this.apiClient.loginUser(jwtToken);
-    }
-    /**
-     * Login with raw user data
-     *
-     * @param rawUserData - Raw user data for authentication
-     * @returns Promise resolving to authentication response
-     */
-    async loginWithRawData(rawUserData) {
-        return this.apiClient.loginUserWithRawData(rawUserData);
-    }
-    /**
-     * Get current authenticated user
-     *
-     * @returns Promise resolving to current user data
-     */
-    async getCurrentUser() {
-        return this.apiClient.get('/users/me');
-    }
-    /**
-     * Refresh current user data
-     *
-     * @returns Promise resolving to updated user data
-     */
-    async refreshUserData() {
-        return this.getCurrentUser();
-    }
-    /**
-     * Check if user is authenticated
-     *
-     * @returns Promise resolving to boolean indicating authentication status
-     */
-    async isAuthenticated() {
-        try {
-            await this.getCurrentUser();
-            return true;
-        }
-        catch {
-            return false;
-        }
-    }
-    /**
-     * Refresh access token using stored refresh token
-     *
-     * @param refreshToken - Optional refresh token, uses stored token if not provided
-     * @returns Promise resolving to new auth tokens
-     */
-    async refreshTokens(refreshToken) {
-        return this.apiClient.refreshTokens(refreshToken);
-    }
-    /**
-     * Clear stored authentication tokens
-     *
-     * @returns Promise that resolves when tokens are cleared
-     */
-    async clearAuth() {
-        // Use auth provider to clear tokens if available
-        const authProvider = this.apiClient.getConfig().authProvider;
-        if (authProvider?.clearTokens) {
-            await authProvider.clearTokens();
-        }
-    }
-    /**
-     * Check if SDK has valid authentication
-     *
-     * @returns Boolean indicating if valid authentication exists
-     */
-    hasValidAuth() {
-        return this.apiClient.hasValidAuth();
-    }
-    /**
-     * Admin login with JWT token
-     *
-     * @param jwt - JWT token for admin authentication
-     * @returns Promise resolving to authentication context
-     */
-    async loginAdmin(jwt) {
-        return this.apiClient.loginAdmin(jwt);
-    }
-    /**
-     * User login with JWT token
-     *
-     * @param jwt - JWT token for user authentication
-     * @returns Promise resolving to authentication context
-     */
-    async loginUser(jwt) {
-        return this.apiClient.loginUser(jwt);
-    }
-}
-
-/**
- * User Manager - Clean, high-level interface for user operations
- *
- * Provides a simplified API for common user management tasks while maintaining
- * access to the full user SDK for advanced use cases.
- */
-class UserManager {
-    constructor(apiClient) {
-        this.apiClient = apiClient;
-        this.userSDK = createUserSDK(apiClient);
-    }
-    /**
-     * Get current user profile
-     *
-     * @returns Promise resolving to current user data
-     */
-    async getCurrentUser() {
-        return this.userSDK.getRemoteUser();
-    }
-    /**
-     * Update current user profile
-     *
-     * @param userData - User data to update
-     * @returns Promise resolving to updated user data
-     */
-    async updateCurrentUser(userData) {
-        return this.userSDK.updateRemoteUser(userData);
-    }
-    /**
-     * Get user by unique identifier
-     *
-     * @param identifier - Unique identifier for the user
-     * @returns Promise resolving to user data
-     */
-    async getUserById(identifier) {
-        return this.userSDK.getUserByUniqueIdentifier(identifier);
-    }
-    /**
-     * Get all users public profiles with optional filtering
-     *
-     * @param filter - Optional filter criteria
-     * @returns Promise resolving to array of user public profiles
-     */
-    async getAllUsersPublic(filter) {
-        return this.userSDK.getAllUsersPublicProfiles(filter || null);
-    }
-    /**
-     * Admin: Get all users
-     *
-     * @returns Promise resolving to array of all users
-     */
-    async getAllUsers() {
-        return this.userSDK.getAllRemoteUsers();
-    }
-    /**
-     * Admin: Update user data
-     *
-     * @param userId - ID of user to update
-     * @param userData - User data to update
-     * @returns Promise resolving to updated user data
-     */
-    async updateUser(userId, userData) {
-        return this.userSDK.updateUserAsAdmin(userId, userData);
-    }
-    /**
-     * Admin: Toggle user active status
-     *
-     * @param user - User to toggle status for
-     * @returns Promise resolving to updated user data
-     */
-    async toggleUserStatus(user) {
-        return this.userSDK.toggleUserActiveStatusByUser(user);
-    }
-    /**
-     * Get the full user SDK for advanced operations
-     *
-     * @returns UserSDK instance
-     */
-    getUserSDK() {
-        return this.userSDK;
-    }
-}
-
-/**
- * User Status Manager - Clean, high-level interface for user status operations
- *
- * Provides a simplified API for common user status management tasks while maintaining
- * access to the full user status SDK for advanced use cases.
- */
-class UserStatusManager {
-    constructor(apiClient) {
-        this.apiClient = apiClient;
-        this.userStatusSDK = createUserStatusSDK(apiClient);
-    }
-    /**
-     * Get all user status types
-     *
-     * @returns Promise resolving to array of user status types
-     */
-    async getUserStatusTypes() {
-        return this.userStatusSDK.getRemoteUserStatusTypes();
-    }
-    /**
-     * Get earned user status for authenticated user
-     *
-     * @returns Promise resolving to array of earned user status
-     */
-    async getEarnedUserStatus() {
-        return this.userStatusSDK.getRemoteEarnedUserStatus();
-    }
-    /**
-     * Admin: Create new user status type
-     *
-     * @param userStatusType - User status type data
-     * @returns Promise resolving to created user status type
-     */
-    async createUserStatusType(userStatusType) {
-        return this.userStatusSDK.createUserStatusType(userStatusType);
-    }
-    /**
-     * Get the full user status SDK for advanced operations
-     *
-     * @returns UserStatusSDK instance
-     */
-    getUserStatusSDK() {
-        return this.userStatusSDK;
-    }
-}
-
-/**
- * Token Manager - Clean, high-level interface for token operations
- *
- * Provides a simplified API for common token management tasks while maintaining
- * access to the full token SDK for advanced use cases.
- */
-class TokenManager {
-    constructor(apiClient) {
-        this.apiClient = apiClient;
-        this.tokenSDK = new TokenSDK(apiClient);
-    }
-    /**
-     * Get all available tokens
-     *
-     * @returns Promise resolving to array of tokens
-     */
-    async getTokens() {
-        return this.tokenSDK.getTokens();
-    }
-    /**
-     * Get all token types
-     *
-     * @returns Promise resolving to token types
-     */
-    async getTokenTypes() {
-        return this.tokenSDK.getTokenTypes();
-    }
-    /**
-     * Get active credit token
-     *
-     * @returns Promise resolving to active credit token
-     */
-    async getActiveCreditToken() {
-        return this.tokenSDK.getActiveCreditToken();
-    }
-    /**
-     * Get reward tokens
-     *
-     * @returns Promise resolving to reward tokens
-     */
-    async getRewardTokens() {
-        return this.tokenSDK.getRewardTokens();
-    }
-    /**
-     * Get status tokens
-     *
-     * @returns Promise resolving to status tokens
-     */
-    async getStatusTokens() {
-        return this.tokenSDK.getStatusTokens();
-    }
-    /**
-     * Get token by contract address
-     *
-     * @param contractAddress - Contract address to search for
-     * @param contractTokenId - Optional contract token ID
-     * @returns Promise resolving to token
-     */
-    async getTokenByContract(contractAddress, contractTokenId) {
-        return this.tokenSDK.getTokenByContract(contractAddress, contractTokenId);
-    }
-    /**
-     * Admin: Create new token
-     *
-     * @param tokenData - Token creation data
-     * @returns Promise resolving to created token
-     */
-    async createToken(tokenData) {
-        return this.tokenSDK.createToken(tokenData);
-    }
-    /**
-     * Admin: Update token
-     *
-     * @param tokenId - Token ID to update
-     * @param tokenData - Token update data
-     * @returns Promise resolving to updated token
-     */
-    async updateToken(tokenId, tokenData) {
-        return this.tokenSDK.updateToken(tokenId, tokenData);
-    }
-    /**
-     * Admin: Toggle token active status
-     *
-     * @param tokenId - Token ID to toggle
-     * @returns Promise resolving to updated token
-     */
-    async toggleTokenActive(tokenId) {
-        return this.tokenSDK.toggleTokenActive(tokenId);
-    }
-    /**
-     * Get the full token SDK for advanced operations
-     *
-     * @returns TokenSDK instance
-     */
-    getTokenSDK() {
-        return this.tokenSDK;
-    }
-}
-
-/**
- * Business Manager - Clean, high-level interface for business operations
- *
- * Provides a simplified API for common business management tasks while maintaining
- * access to the full business SDK for advanced use cases.
- */
-class BusinessManager {
-    constructor(apiClient) {
-        this.apiClient = apiClient;
-        this.businessSDK = createBusinessSDK(apiClient);
-    }
-    /**
-     * Get all active businesses
-     *
-     * @returns Promise resolving to array of active businesses
-     */
-    async getActiveBusinesses() {
-        return this.businessSDK.getActiveBusinesses();
-    }
-    /**
-     * Get business by ID
-     *
-     * @param businessId - Business ID to fetch
-     * @returns Promise resolving to business data
-     */
-    async getBusinessById(businessId) {
-        return this.businessSDK.getBusinessById(businessId);
-    }
-    /**
-     * Get business by account address
-     *
-     * @param accountAddress - Account address to search for
-     * @returns Promise resolving to business data
-     */
-    async getBusinessByAccount(accountAddress) {
-        return this.businessSDK.getBusinessByAccount(accountAddress);
-    }
-    /**
-     * Get all business types
-     *
-     * @returns Promise resolving to array of business types
-     */
-    async getBusinessTypes() {
-        return this.businessSDK.getBusinessTypes();
-    }
-    /**
-     * Get businesses by type
-     *
-     * @param typeId - Business type ID to filter by
-     * @returns Promise resolving to array of businesses
-     */
-    async getBusinessesByType(typeId) {
-        return this.businessSDK.getBusinessesByType(typeId);
-    }
-    /**
-     * Admin: Get all businesses (including inactive)
-     *
-     * @returns Promise resolving to array of all businesses
-     */
-    async getBusinesses() {
-        return this.businessSDK.getBusinesses();
-    }
-    /**
-     * Admin: Create new business
-     *
-     * @param displayName - Display name for the business
-     * @returns Promise resolving to created business data
-     */
-    async createBusiness(displayName) {
-        return this.businessSDK.createBusinessByDisplayName(displayName);
-    }
-    /**
-     * Admin: Update business
-     *
-     * @param businessId - ID of business to update
-     * @param businessData - Business data to update
-     * @returns Promise resolving to updated business data
-     */
-    async updateBusiness(businessId, businessData) {
-        return this.businessSDK.updateBusiness(businessId, businessData);
-    }
-    /**
-     * Admin: Toggle business active status
-     *
-     * @param businessId - ID of business to toggle
-     * @param toggleData - Toggle request data
-     * @returns Promise resolving to updated business data
-     */
-    async toggleBusinessStatus(businessId, toggleData) {
-        return this.businessSDK.toggleBusinessActive(businessId, toggleData);
-    }
-    /**
-     * Get the full business SDK for advanced operations
-     *
-     * @returns BusinessSDK instance
-     */
-    getBusinessSDK() {
-        return this.businessSDK;
-    }
-}
-
-/**
- * Campaign Manager - Clean, high-level interface for campaign operations
- *
- * Provides a simplified API for common campaign management tasks while maintaining
- * access to the full campaign SDK for advanced use cases.
- */
-class CampaignManager {
-    constructor(apiClient) {
-        this.apiClient = apiClient;
-        this.campaignSDK = createCampaignSDK(apiClient);
-    }
-    /**
-     * Get all active campaigns
-     *
-     * @returns Promise resolving to array of active campaigns
-     */
-    async getActiveCampaigns() {
-        return this.campaignSDK.getActiveCampaigns();
-    }
-    /**
-     * Get campaign by ID
-     *
-     * @param campaignId - ID of the campaign
-     * @returns Promise resolving to campaign data
-     */
-    async getCampaignById(campaignId) {
-        return this.campaignSDK.getCampaignById(campaignId);
-    }
-    /**
-     * Claim a campaign reward
-     *
-     * @param claimRequest - Campaign claim data
-     * @returns Promise resolving to claim result
-     */
-    async claimCampaign(claimRequest) {
-        return this.campaignSDK.claimCampaign(claimRequest);
-    }
-    /**
-     * Get user's campaign claims
-     *
-     * @returns Promise resolving to array of user's claims
-     */
-    async getUserClaims() {
-        return this.campaignSDK.getClaimsForLoggedUser();
-    }
-    /**
-     * Admin: Get all campaigns
-     *
-     * @param active - Filter by active status
-     * @returns Promise resolving to array of campaigns
-     */
-    async getAllCampaigns(active) {
-        return this.campaignSDK.getCampaigns(active);
-    }
-    /**
-     * Admin: Create new campaign
-     *
-     * @param campaignData - Campaign data
-     * @returns Promise resolving to created campaign
-     */
-    async createCampaign(campaignData) {
-        return this.campaignSDK.createCampaign(campaignData);
-    }
-    /**
-     * Admin: Update campaign
-     *
-     * @param campaignId - ID of campaign to update
-     * @param campaignData - Updated campaign data
-     * @returns Promise resolving to updated campaign
-     */
-    async updateCampaign(campaignId, campaignData) {
-        return this.campaignSDK.updateCampaign(campaignId, campaignData);
-    }
-    /**
-     * Admin: Toggle campaign active status
-     *
-     * @param campaignId - ID of campaign to toggle
-     * @returns Promise resolving to updated campaign
-     */
-    async toggleCampaignStatus(campaignId) {
-        return this.campaignSDK.toggleCampaignActive(campaignId);
-    }
-    /**
-     * Admin: Toggle campaign testnet environment
-     *
-     * @param campaignId - ID of campaign to toggle
-     * @returns Promise resolving to updated campaign
-     */
-    async toggleCampaignTestnet(campaignId) {
-        return this.campaignSDK.toggleCampaignTestnet(campaignId);
-    }
-    /**
-     * Admin: Get campaign triggers
-     *
-     * @returns Promise resolving to array of campaign triggers
-     */
-    async getCampaignTriggers() {
-        return this.campaignSDK.getCampaignTriggers();
-    }
-    /**
-     * Admin: Set campaign trigger
-     *
-     * @param campaignId - ID of campaign
-     * @param triggerId - ID of trigger to set
-     * @returns Promise resolving to updated campaign
-     */
-    async setCampaignTrigger(campaignId, triggerId) {
-        return this.campaignSDK.setCampaignTrigger(campaignId, triggerId);
-    }
-    /**
-     * Admin: Create campaign token unit
-     *
-     * @param campaignId - ID of campaign
-     * @param tokenUnit - Token unit data
-     * @returns Promise resolving to updated campaign
-     */
-    async createCampaignTokenUnit(campaignId, tokenUnit) {
-        return this.campaignSDK.createCampaignTokenUnit(campaignId, tokenUnit);
-    }
-    /**
-     * Admin: Delete campaign token unit
-     *
-     * @param campaignId - ID of campaign
-     * @param tokenUnitId - ID of token unit to delete
-     * @returns Promise resolving to updated campaign
-     */
-    async deleteCampaignTokenUnit(campaignId, tokenUnitId) {
-        return this.campaignSDK.deleteCampaignTokenUnit(campaignId, tokenUnitId);
-    }
-    /**
-     * Admin: Add business engagement to campaign
-     *
-     * @param campaignId - ID of campaign
-     * @param engagement - Business engagement data
-     * @returns Promise resolving to updated campaign
-     */
-    async addBusinessEngagementToCampaign(campaignId, engagement) {
-        return this.campaignSDK.addBusinessEngagementToCampaign(campaignId, engagement);
-    }
-    /**
-     * Admin: Update campaign business engagement
-     *
-     * @param campaignId - ID of campaign
-     * @param engagementId - ID of engagement to update
-     * @param engagement - Updated engagement data
-     * @returns Promise resolving to updated campaign
-     */
-    async updateCampaignBusinessEngagement(campaignId, engagementId, engagement) {
-        return this.campaignSDK.updateCampaignBusinessEngagement(campaignId, engagementId, engagement);
-    }
-    /**
-     * Admin: Delete campaign business engagement
-     *
-     * @param campaignId - ID of campaign
-     * @param engagementId - ID of engagement to delete
-     * @returns Promise resolving to updated campaign
-     */
-    async deleteCampaignBusinessEngagement(campaignId, engagementId) {
-        return this.campaignSDK.deleteCampaignBusinessEngagement(campaignId, engagementId);
-    }
-    /**
-     * Admin: Get all campaign claims
-     *
-     * @returns Promise resolving to array of campaign claims
-     */
-    async getCampaignClaims() {
-        return this.campaignSDK.getCampaignClaims();
-    }
-    /**
-     * Admin: Get campaign claims by user ID
-     *
-     * @param userId - ID of user
-     * @returns Promise resolving to array of user's campaign claims
-     */
-    async getCampaignClaimsByUserId(userId) {
-        return this.campaignSDK.getCampaignClaimsByUserId(userId);
-    }
-    /**
-     * Admin: Get campaign claims by business ID
-     *
-     * @param businessId - ID of business
-     * @returns Promise resolving to array of business's campaign claims
-     */
-    async getCampaignClaimsByBusinessId(businessId) {
-        return this.campaignSDK.getCampaignClaimsByBusinessId(businessId);
-    }
-    /**
-     * Get the full campaign SDK for advanced operations
-     *
-     * @returns CampaignSDK instance
-     */
-    getCampaignSDK() {
-        return this.campaignSDK;
-    }
-}
-
-/**
- * Redemption Manager - Clean, high-level interface for redemption operations
- *
- * Provides a simplified API for common redemption management tasks while maintaining
- * access to the full redemption SDK for advanced use cases.
- */
-class RedemptionManager {
-    constructor(apiClient) {
-        this.apiClient = apiClient;
-        this.redemptionSDK = createRedemptionSDK(apiClient);
-    }
-    /**
-     * Get all active redemption offers
-     *
-     * @returns Promise resolving to array of active redemptions
-     */
-    async getActiveRedemptions() {
-        return this.redemptionSDK.getActiveRedemptions();
-    }
-    /**
-     * Get available redemption types
-     *
-     * @returns Promise resolving to array of redemption types
-     */
-    async getRedemptionTypes() {
-        return this.redemptionSDK.getRedemptionTypes();
-    }
-    /**
-     * Redeem a redemption offer
-     *
-     * @param redemptionId - ID of the redemption to redeem
-     * @returns Promise resolving to redemption result
-     */
-    async redeemOffer(redemptionId) {
-        return this.redemptionSDK.redeemRedemption(redemptionId);
-    }
-    /**
-     * Get user's redemption history
-     *
-     * @returns Promise resolving to array of user's redemptions
-     */
-    async getUserRedemptions() {
-        return this.redemptionSDK.getUserRedeems();
-    }
-    /**
-     * Admin: Get all redemptions
-     *
-     * @param active - Filter by active status
-     * @returns Promise resolving to array of redemptions
-     */
-    async getAllRedemptions(active) {
-        return this.redemptionSDK.getRedemptionsAsAdmin(active);
-    }
-    /**
-     * Admin: Create new redemption offer
-     *
-     * @param redemptionData - Redemption data
-     * @returns Promise resolving to created redemption
-     */
-    async createRedemption(redemptionData) {
-        return this.redemptionSDK.createRedemption(redemptionData);
-    }
-    /**
-     * Admin: Update redemption
-     *
-     * @param redemptionId - ID of redemption to update
-     * @param redemptionData - Updated redemption data
-     * @returns Promise resolving to updated redemption
-     */
-    async updateRedemption(redemptionId, redemptionData) {
-        return this.redemptionSDK.updateRedemption(redemptionId, redemptionData);
-    }
-    /**
-     * Admin: Toggle redemption active status
-     *
-     * @param redemptionId - ID of redemption to toggle
-     * @returns Promise resolving to updated redemption
-     */
-    async toggleRedemptionStatus(redemptionId) {
-        return this.redemptionSDK.toggleRedemptionActive(redemptionId);
-    }
-    /**
-     * Admin: Create redemption token unit
-     *
-     * @param redemptionId - ID of redemption
-     * @param tokenUnit - Token unit data
-     * @returns Promise resolving to updated redemption
-     */
-    async createRedemptionTokenUnit(redemptionId, tokenUnit) {
-        return this.redemptionSDK.createRedemptionTokenUnit(redemptionId, tokenUnit);
-    }
-    /**
-     * Admin: Delete redemption token unit
-     *
-     * @param redemptionId - ID of redemption
-     * @param tokenUnitId - ID of token unit to delete
-     * @returns Promise resolving to updated redemption
-     */
-    async deleteRedemptionTokenUnit(redemptionId, tokenUnitId) {
-        return this.redemptionSDK.deleteRedemptionTokenUnit(redemptionId, tokenUnitId);
-    }
-    /**
-     * Get the full redemption SDK for advanced operations
-     *
-     * @returns RedemptionSDK instance
-     */
-    getRedemptionSDK() {
-        return this.redemptionSDK;
-    }
-}
-
-/**
- * Transaction Manager - Clean, high-level interface for transaction operations
- *
- * Provides a simplified API for common transaction management tasks while maintaining
- * access to the full transaction SDK for advanced use cases.
- */
-class TransactionManager {
-    constructor(apiClient) {
-        this.apiClient = apiClient;
-        this.transactionSDK = createTransactionSDK(apiClient);
-    }
-    /**
-     * Get transaction by ID
-     *
-     * @param transactionId - ID of the transaction
-     * @returns Promise resolving to transaction data
-     */
-    async getTransactionById(transactionId) {
-        return this.transactionSDK.getTransactionById(transactionId);
-    }
-    /**
-     * Create a new transaction
-     *
-     * @param transactionData - Transaction data
-     * @returns Promise resolving to transaction response
-     */
-    async createTransaction(transactionData) {
-        return this.transactionSDK.createTransaction(transactionData);
-    }
-    /**
-     * Get user's transaction history
-     *
-     * @param type - Transaction type filter
-     * @returns Promise resolving to array of user's transactions
-     */
-    async getUserTransactionHistory(type) {
-        return this.transactionSDK.getUserTransactionHistory(type);
-    }
-    /**
-     * Admin: Get all tenant transactions
-     *
-     * @returns Promise resolving to array of tenant transactions
-     */
-    async getTenantTransactions() {
-        return this.transactionSDK.getTenantTransactions();
-    }
-    /**
-     * Admin: Get paginated transactions
-     *
-     * @param params - Pagination parameters
-     * @returns Promise resolving to paginated transaction results
-     */
-    async getPaginatedTransactions(params) {
-        return this.transactionSDK.getPaginatedTransactions(params);
-    }
-    /**
-     * Admin: Export transactions as CSV
-     *
-     * @returns Promise resolving to CSV blob
-     */
-    async exportTransactionsCSV() {
-        return this.transactionSDK.exportTransactionsCSV();
-    }
-    /**
-     * Get the full transaction SDK for advanced operations
-     *
-     * @returns TransactionSDK instance
-     */
-    getTransactionSDK() {
-        return this.transactionSDK;
-    }
-}
-
-/**
- * Purchase Manager - Clean, high-level interface for purchase operations
- *
- * Provides a simplified API for common purchase management tasks while maintaining
- * access to the full payment SDK for advanced use cases.
- */
-class PurchaseManager {
-    constructor(apiClient) {
-        this.apiClient = apiClient;
-        this.paymentSDK = createPaymentSDK(apiClient);
-    }
-    /**
-     * Create a payment intent
-     *
-     * @param amount - Payment amount
-     * @param currency - Payment currency
-     * @param receiptEmail - Receipt email
-     * @param description - Payment description
-     * @returns Promise resolving to created payment intent
-     */
-    async createPaymentIntent(amount, currency, receiptEmail, description) {
-        return this.paymentSDK.createPaymentIntent(amount, currency, receiptEmail, description);
-    }
-    /**
-     * Get active purchase tokens
-     *
-     * @param active - Filter by active status
-     * @returns Promise resolving to purchase tokens
-     */
-    async getActivePurchaseTokens(active) {
-        return this.paymentSDK.getActivePurchaseTokens(active);
-    }
-    /**
-     * Get all user purchases
-     *
-     * @returns Promise resolving to array of user's purchases
-     */
-    async getAllUserPurchases() {
-        return this.paymentSDK.getAllUserPurchases();
-    }
-    /**
-     * Get the full purchase SDK for advanced operations
-     *
-     * @returns PaymentSDK instance
-     */
-    getPurchaseSDK() {
-        return this.paymentSDK;
-    }
-}
-
-/**
- * Platform-Agnostic File API Client
- *
- * Handles file operations using the PERS backend's RESTful endpoints.
- */
-class FileApi {
-    constructor(apiClient) {
-        this.apiClient = apiClient;
-        this.basePath = '/files';
-    }
-    // ==========================================
-    // PUBLIC OPERATIONS
-    // ==========================================
-    /**
-     * PUBLIC: Get signed URL for file operations
-     *
-     * @param request - Signed URL request parameters
-     * @returns Promise resolving to signed URL response
-     */
-    async getSignedUrl(request) {
-        return this.apiClient.post(`${this.basePath}/entity-storage-url`, request);
-    }
-    /**
-     * PUBLIC: Get signed GET URL for file access
-     *
-     * @param url - File URL
-     * @param expireSeconds - Optional expiration time in seconds
-     * @returns Promise resolving to signed URL response
-     */
-    async getSignedGetUrl(url, expireSeconds) {
-        const searchParams = new URLSearchParams({ url });
-        if (expireSeconds) {
-            searchParams.set('expireSeconds', expireSeconds.toString());
-        }
-        return this.apiClient.get(`${this.basePath}/signed-url?${searchParams.toString()}`);
-    }
-    /**
-     * PUBLIC: Optimize media from URL
-     *
-     * @param request - File optimization request
-     * @returns Promise resolving to optimized file URL
-     */
-    async optimizeMediaFromUrl(request) {
-        const searchParams = new URLSearchParams({ url: request.url });
-        if (request.width)
-            searchParams.set('width', request.width.toString());
-        if (request.height)
-            searchParams.set('height', request.height.toString());
-        return this.apiClient.get(`/file/optimize-url?${searchParams.toString()}`);
-    }
-}
-
-/**
- * File Service - High-level file operations
- *
- * Provides convenient methods for file upload, signed URLs, and media optimization.
- */
-class FileService {
-    constructor(apiClient) {
-        this.fileApi = new FileApi(apiClient);
-    }
-    /**
-     * Get signed PUT URL for file upload
-     *
-     * @param entityId - Entity ID to associate the file with
-     * @param entityType - Type of entity (token, campaign, etc.)
-     * @param fileExtension - File extension (e.g., 'jpg', 'png')
-     * @returns Promise resolving to signed upload URL
-     */
-    async getSignedPutUrl(entityId, entityType, fileExtension) {
-        const request = {
-            entityId,
-            entityType,
-            signedUrlType: 'PUT',
-            fileExtension
-        };
-        const response = await this.fileApi.getSignedUrl(request);
-        return response.signedUrl;
-    }
-    /**
-     * Get signed GET URL for file access
-     *
-     * @param entityId - Entity ID
-     * @param entityType - Type of entity
-     * @param expireSeconds - Optional expiration time in seconds
-     * @returns Promise resolving to signed access URL
-     */
-    async getSignedGetUrl(entityId, entityType, expireSeconds) {
-        const request = {
-            entityId,
-            entityType,
-            signedUrlType: 'GET'
-        };
-        const response = await this.fileApi.getSignedUrl(request);
-        return response.signedUrl;
-    }
-    /**
-     * Get signed URL for any file operation
-     *
-     * @param request - Signed URL request
-     * @returns Promise resolving to signed URL
-     */
-    async getSignedUrl(request) {
-        const response = await this.fileApi.getSignedUrl(request);
-        return response.signedUrl;
-    }
-    /**
-     * Optimize media from URL
-     *
-     * @param url - Original file URL
-     * @param width - Optional target width
-     * @param height - Optional target height
-     * @returns Promise resolving to optimized file URL
-     */
-    async optimizeMedia(url, width, height) {
-        const request = { url, width, height };
-        const response = await this.fileApi.optimizeMediaFromUrl(request);
-        return response.optimizedUrl;
-    }
-    /**
-     * Get the file API instance for advanced operations
-     *
-     * @returns FileApi instance
-     */
-    getFileApi() {
-        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
- *
- * Provides a simplified API for common file management tasks while maintaining
- * access to the full file SDK for advanced use cases.
- */
-class FileManager {
-    constructor(apiClient) {
-        this.apiClient = apiClient;
-        this.fileSDK = createFileSDK(apiClient);
-    }
-    /**
-     * Get signed URL for file upload
-     *
-     * @param entityId - Entity ID to associate the file with
-     * @param entityType - Type of entity (token, campaign, etc.)
-     * @param fileExtension - File extension (e.g., 'jpg', 'png')
-     * @returns Promise resolving to signed upload URL
-     */
-    async getSignedPutUrl(entityId, entityType, fileExtension) {
-        return this.fileSDK.getSignedPutUrl(entityId, entityType, fileExtension);
-    }
-    /**
-     * Get signed URL for file access
-     *
-     * @param entityId - Entity ID
-     * @param entityType - Type of entity
-     * @param expireSeconds - Optional expiration time in seconds
-     * @returns Promise resolving to signed access URL
-     */
-    async getSignedGetUrl(entityId, entityType, expireSeconds) {
-        return this.fileSDK.getSignedGetUrl(entityId, entityType, expireSeconds);
-    }
-    /**
-     * Get signed URL for any file operation
-     *
-     * @param request - Signed URL request
-     * @returns Promise resolving to signed URL
-     */
-    async getSignedUrl(request) {
-        return this.fileSDK.getSignedUrl(request);
-    }
-    /**
-     * Optimize media file
-     *
-     * @param url - Original file URL
-     * @param width - Optional target width
-     * @param height - Optional target height
-     * @returns Promise resolving to optimized file URL
-     */
-    async optimizeMedia(url, width, height) {
-        return this.fileSDK.optimizeMedia(url, width, height);
-    }
-    /**
-     * Get the full file SDK for advanced operations
-     *
-     * @returns FileService instance
-     */
-    getFileSDK() {
-        return this.fileSDK;
-    }
-}
-
-/**
- * Tenant Manager - Clean, high-level interface for tenant operations
- *
- * Provides a simplified API for common tenant management tasks while maintaining
- * access to the full tenant SDK for advanced use cases.
- */
-class TenantManager {
-    constructor(apiClient) {
-        this.apiClient = apiClient;
-        this.tenantSDK = createTenantSDK(apiClient);
-    }
-    /**
-     * Get current tenant information
-     *
-     * @returns Promise resolving to tenant data
-     */
-    async getTenantInfo() {
-        return this.tenantSDK.getRemoteTenant();
-    }
-    /**
-     * Get tenant login token
-     *
-     * @returns Promise resolving to login token
-     */
-    async getLoginToken() {
-        return this.tenantSDK.getRemoteLoginToken();
-    }
-    /**
-     * Get tenant client configuration
-     *
-     * @returns Promise resolving to client config
-     */
-    async getClientConfig() {
-        return this.tenantSDK.getRemoteClientConfig();
-    }
-    /**
-     * Admin: Update tenant data
-     *
-     * @param tenantData - Updated tenant data
-     * @returns Promise resolving to updated tenant
-     */
-    async updateTenant(tenantData) {
-        return this.tenantSDK.updateRemoteTenant(tenantData);
-    }
-    /**
-     * Admin: Get all admins
-     *
-     * @returns Promise resolving to array of admins
-     */
-    async getAdmins() {
-        return this.tenantSDK.getAdmins();
-    }
-    /**
-     * Admin: Create new admin
-     *
-     * @param adminData - Admin data
-     * @returns Promise resolving to created admin
-     */
-    async createAdmin(adminData) {
-        return this.tenantSDK.postAdmin(adminData);
-    }
-    /**
-     * Admin: Update existing admin
-     *
-     * @param adminId - ID of the admin to update
-     * @param adminData - Updated admin data
-     * @returns Promise resolving to updated admin
-     */
-    async updateAdmin(adminId, adminData) {
-        return this.tenantSDK.putAdmin(adminId, adminData);
-    }
-    /**
-     * Get the full tenant SDK for advanced operations
-     *
-     * @returns TenantSDK instance
-     */
-    getTenantSDK() {
-        return this.tenantSDK;
-    }
-}
-
-/**
- * Analytics Manager - Clean, high-level interface for analytics operations
- *
- * Provides a simplified API for common analytics tasks while maintaining
- * access to the full analytics SDK for advanced use cases.
- */
-class AnalyticsManager {
-    constructor(apiClient) {
-        this.apiClient = apiClient;
-        this.analyticsSDK = createAnalyticsSDK(apiClient);
-    }
-    /**
-     * Get transaction analytics
-     *
-     * @param request - Analytics request parameters
-     * @returns Promise resolving to transaction analytics data
-     */
-    async getTransactionAnalytics(request) {
-        return this.analyticsSDK.getTransactionAnalytics(request);
-    }
-    /**
-     * Get the full analytics SDK for advanced operations
-     *
-     * @returns AnalyticsSDK instance
-     */
-    getAnalyticsSDK() {
-        return this.analyticsSDK;
-    }
-}
-
-/**
- * Donation Manager - Clean, high-level interface for donation operations
- *
- * Provides a simplified API for common donation tasks while maintaining
- * access to the full donation SDK for advanced use cases.
- */
-class DonationManager {
-    constructor(apiClient) {
-        this.apiClient = apiClient;
-        this.donationSDK = createDonationSDK(apiClient);
-    }
-    /**
-     * Get available donation types
-     *
-     * @returns Promise resolving to array of donation types
-     */
-    async getDonationTypes() {
-        return this.donationSDK.getAllDonationTypes();
-    }
-    /**
-     * Get the full donation SDK for advanced operations
-     *
-     * @returns DonationSDK instance
-     */
-    getDonationSDK() {
-        return this.donationSDK;
-    }
-}
-
-/**
- * Web3 Manager - Clean, high-level interface for Web3 operations
- *
- * Provides a simplified API for common Web3 blockchain tasks while maintaining
- * access to the full Web3 SDK for advanced use cases.
- */
-class Web3Manager {
-    constructor(apiClient) {
-        this.apiClient = apiClient;
-        this.web3SDK = createWeb3SDK(apiClient);
-        this.web3ChainSDK = createWeb3ChainSDK(apiClient);
-    }
-    /**
-     * Get token balance for a specific token
-     *
-     * @param request - Token balance request parameters
-     * @returns Promise resolving to token balance
-     */
-    async getTokenBalance(request) {
-        return this.web3SDK.getTokenBalance(request);
-    }
-    /**
-     * Get token metadata
-     *
-     * @param request - Token metadata request parameters
-     * @returns Promise resolving to token metadata or null if not found
-     */
-    async getTokenMetadata(request) {
-        return this.web3SDK.getTokenMetadata(request);
-    }
-    /**
-     * Get token collection
-     *
-     * @param request - Token collection request parameters
-     * @returns Promise resolving to token collection
-     */
-    async getTokenCollection(request) {
-        return this.web3SDK.getTokenCollection(request);
-    }
-    /**
-     * Resolve IPFS URL to accessible URL
-     *
-     * @param url - IPFS URL to resolve
-     * @param chainId - Chain ID for context
-     * @returns Promise resolving to accessible URL
-     */
-    async resolveIPFSUrl(url, chainId) {
-        return this.web3SDK.resolveIPFSUrl(url, chainId);
-    }
-    /**
-     * Fetch and process token metadata
-     *
-     * @param tokenUri - Token URI to fetch metadata from
-     * @param chainId - Chain ID for context
-     * @returns Promise resolving to processed metadata or null if not found
-     */
-    async fetchAndProcessMetadata(tokenUri, chainId) {
-        return this.web3SDK.fetchAndProcessMetadata(tokenUri, chainId);
-    }
-    /**
-     * Get blockchain chain data by chain ID
-     *
-     * @param chainId - Chain ID to get data for
-     * @returns Promise resolving to chain data or null if not found
-     */
-    async getChainDataById(chainId) {
-        return this.web3ChainSDK.getChainDataById(chainId);
-    }
-    /**
-     * Get explorer URL for a given address or transaction
-     *
-     * @param chainId - Chain ID to get explorer URL for
-     * @param address - Address or transaction hash
-     * @param type - Type of explorer URL ('address' or 'tx')
-     * @returns Promise resolving to explorer URL
-     */
-    async getExplorerUrl(chainId, address, type) {
-        return getExplorerUrlByChainId((id) => this.getChainDataById(id), chainId, address, type);
-    }
-    /**
-     * Get the full Web3 SDK for advanced operations
-     *
-     * @returns Web3SDK instance
-     */
-    getWeb3SDK() {
-        return this.web3SDK;
-    }
-}
-
-/**
- * PERS SDK - Platform-agnostic TypeScript SDK with High-Level Managers
- *
- * ## Overview
- *
- * The PERS SDK provides a comprehensive interface for integrating with the PERS
- * (Phygital Experience Rewards System) platform. It features a clean manager-based
- * architecture that abstracts complex domain operations into intuitive high-level APIs.
- *
- * ## Architecture
- *
- * ```
- * PersSDK
- * ├── Domain Managers (Recommended)    // High-level, intuitive APIs
- * │   ├── auth: AuthManager           // Authentication & user sessions
- * │   ├── users: UserManager          // User profile management
- * │   ├── tokens: TokenManager        // Token balances & transfers
- * │   ├── businesses: BusinessManager // Business operations
- * │   ├── campaigns: CampaignManager  // Marketing campaigns
- * │   ├── redemptions: RedemptionManager // Reward redemptions
- * │   ├── transactions: TransactionManager // Transaction history
- * │   ├── purchases: PurchaseManager    // Purchase processing
- * │   └── analytics: AnalyticsManager // Reporting & analytics
- * ├── Domain SDKs (Advanced)          // Full-featured domain access
- * │   ├── createBusinessSDK()
- * │   ├── createCampaignSDK()
- * │   └── TokenSDK, etc.
- * └── Core API Client (Expert)        // Direct REST API access
- *     └── api(): PersApiClient
- * ```
- *
- * ## Usage Patterns
- *
- * ### 1. High-Level Manager Pattern (Recommended)
- *
- * ```typescript
- * import { PersSDK } from '@explorins/pers-sdk';
- * import { BrowserFetchClientAdapter } from '@explorins/pers-sdk/platform-adapters';
- *
- * const sdk = new PersSDK(new BrowserFetchClientAdapter(), {
- *   environment: 'production',
- *   apiProjectKey: 'your-project-key'
- * });
- *
- * // Clean, intuitive manager interface
- * const user = await sdk.auth.getCurrentUser();
- * const campaigns = await sdk.campaigns.getActiveCampaigns();
- * const balances = await sdk.tokens.getTokens();
- * ```
- *
- * ### 2. Advanced Domain SDK Access
- *
- * ```typescript
- * // Access full SDK capabilities when needed
- * const campaignSDK = sdk.campaigns.getCampaignSDK();
- * const advancedCampaignOps = await campaignSDK.api.createComplexCampaign(data);
- * ```
- *
- * ### 3. Direct API Client Access
- *
- * ```typescript
- * // For custom endpoints or advanced operations
- * const apiClient = sdk.api();
- * const customData = await apiClient.get('/custom-endpoint');
- * ```
- *
- * ## Platform Integration
- *
- * The SDK provides pre-built adapters for common platforms:
- *
- * - **Angular**: `AngularHttpClientAdapter`
- * - **Browser/React/Vue**: `BrowserFetchClientAdapter`
- * - **Node.js**: `NodeHttpClientAdapter`
- * - **Custom**: Implement `HttpClient` interface
- *
- * ## Features
- *
- * - ✅ **Type-safe**: Full TypeScript support with comprehensive type definitions
- * - ✅ **Platform-agnostic**: Works in browsers, Node.js, React Native, and more
- * - ✅ **Authentication**: Automatic token management and refresh
- * - ✅ **Error handling**: Comprehensive error handling with typed exceptions
- * - ✅ **Modular**: Import only the domains you need
- * - ✅ **Manager pattern**: Clean, high-level APIs for common operations
- * - ✅ **Backward compatible**: Maintains compatibility with existing integrations
- * - ✅ **Tree-shakable**: Optimized for minimal bundle size
- *
- * @example Basic Setup
- * ```typescript
- * import { PersSDK } from '@explorins/pers-sdk';
- * import { BrowserFetchClientAdapter } from '@explorins/pers-sdk/platform-adapters';
- *
- * const sdk = new PersSDK(new BrowserFetchClientAdapter(), {
- *   environment: 'production',
- *   apiProjectKey: 'your-project-key'
- * });
- * ```
- *
- * @example Authentication Flow
- * ```typescript
- * // Login with external JWT (Firebase, Auth0, etc.)
- * await sdk.auth.loginWithToken(firebaseJWT, 'user');
- *
- * // Check authentication status
- * if (await sdk.auth.isAuthenticated()) {
- *   const user = await sdk.auth.getCurrentUser();
- *   console.log('Welcome,', user.name);
- * }
- * ```
- *
- * @example Business Operations
- * ```typescript
- * // Get active businesses
- * const businesses = await sdk.businesses.getActiveBusinesses();
- *
- * // Get business details
- * const business = await sdk.businesses.getBusinessById(businessId);
- *
- * // Admin: Create new business
- * const newBusiness = await sdk.businesses.createBusiness({
- *   name: 'New Business',
- *   location: 'City Center',
- *   type: 'restaurant'
- * });
- * ```
- *
- * @example Campaign Management
- * ```typescript
- * // Get active campaigns
- * const campaigns = await sdk.campaigns.getActiveCampaigns();
- *
- * // Claim a campaign
- * await sdk.campaigns.claimCampaign({
- *   campaignId: 'campaign-123',
- *   metadata: { source: 'mobile-app' }
- * });
- *
- * // Get user's claims
- * const claims = await sdk.campaigns.getUserClaims();
- * ```
- *
- * @example Token Operations
- * ```typescript
- * // Get user's token balances
- * const tokens = await sdk.tokens.getTokens();
- *
- * // Transfer tokens between users
- * await sdk.tokens.transferTokens({
- *   fromUserId: 'user-1',
- *   toUserId: 'user-2',
- *   tokenType: 'CREDIT',
- *   amount: 100
- * });
- * ```
- *
- * @since 1.3.0 - Manager pattern architecture
- */
-/**
- * PERS SDK class with domain managers
- *
- * Main SDK interface providing clean, high-level managers for common operations
- * while maintaining full access to the underlying API client and domain SDKs.
- *
- * @example
- * ```typescript
- * import { PersSDK, createAuthProvider } from '@explorins/pers-sdk/core';
- * import { BrowserHttpClient } from '@explorins/pers-sdk/browser';
- *
- * const authProvider = createAuthProvider({
- *   tokenProvider: () => getFirebaseToken()
- * });
- *
- * const sdk = new PersSDK(new BrowserHttpClient(), {
- *   environment: 'production',
- *   apiProjectKey: 'your-project-key',
- *   authProvider
- * });
- *
- * // High-level manager interface
- * const user = await sdk.auth.getCurrentUser();
- * const tokens = await sdk.tokens.getTokens();
- * const businesses = await sdk.business.getActiveBusinesses();
- *
- * // Direct API access for advanced operations
- * const apiClient = sdk.api();
- * const customData = await apiClient.get('/custom-endpoint');
- * ```
- */
-class PersSDK {
-    /**
-     * Creates a new PERS SDK instance
-     *
-     * @param httpClient Platform-specific HTTP client implementation
-     * @param config SDK configuration options
-     */
-    constructor(httpClient, config) {
-        this.apiClient = new PersApiClient(httpClient, config);
-        // Initialize domain managers
-        this._auth = new AuthManager(this.apiClient);
-        this._users = new UserManager(this.apiClient);
-        this._userStatus = new UserStatusManager(this.apiClient);
-        this._tokens = new TokenManager(this.apiClient);
-        this._businesses = new BusinessManager(this.apiClient);
-        this._campaigns = new CampaignManager(this.apiClient);
-        this._redemptions = new RedemptionManager(this.apiClient);
-        this._transactions = new TransactionManager(this.apiClient);
-        this._purchases = new PurchaseManager(this.apiClient);
-        this._files = new FileManager(this.apiClient);
-        this._tenants = new TenantManager(this.apiClient);
-        this._analytics = new AnalyticsManager(this.apiClient);
-        this._donations = new DonationManager(this.apiClient);
-        this._web3 = new Web3Manager(this.apiClient);
-    }
-    /**
-     * Authentication manager - High-level auth operations
-     *
-     * @example
-     * ```typescript
-     * await sdk.auth.loginWithToken(jwtToken);
-     * const user = await sdk.auth.getCurrentUser();
-     * const isAuth = await sdk.auth.isAuthenticated();
-     * ```
-     */
-    get auth() {
-        return this._auth;
-    }
-    /**
-     * User manager - High-level user operations
-     *
-     * @example
-     * ```typescript
-     * const user = await sdk.user.getCurrentUser();
-     * await sdk.user.updateCurrentUser(userData);
-     * const users = await sdk.user.getAllUsersPublic();
-     * ```
-     */
-    get users() {
-        return this._users;
-    }
-    /**
-     * User Status manager - High-level user status operations
-     *
-     * @example
-     * ```typescript
-     * const statusTypes = await sdk.userStatus.getUserStatusTypes();
-     * const earnedStatus = await sdk.userStatus.getEarnedUserStatus();
-     * await sdk.userStatus.createUserStatusType(statusData);
-     * ```
-     */
-    get userStatus() {
-        return this._userStatus;
-    }
-    /**
-     * Token manager - High-level token operations
-     *
-     * @example
-     * ```typescript
-     * const tokens = await sdk.tokens.getTokens();
-     * const creditToken = await sdk.tokens.getActiveCreditToken();
-     * const rewards = await sdk.tokens.getRewardTokens();
-     * ```
-     */
-    get tokens() {
-        return this._tokens;
-    }
-    /**
-     * Business manager - High-level business operations
-     *
-     * @example
-     * ```typescript
-     * const businesses = await sdk.business.getActiveBusinesses();
-     * const business = await sdk.business.getBusinessById(id);
-     * const types = await sdk.business.getBusinessTypes();
-     * ```
-     */
-    get businesses() {
-        return this._businesses;
-    }
-    /**
-     * Campaign manager - High-level campaign operations
-     *
-     * @example
-     * ```typescript
-     * const campaigns = await sdk.campaigns.getActiveCampaigns();
-     * await sdk.campaigns.claimCampaign(claimData);
-     * const claims = await sdk.campaigns.getUserClaims();
-     * ```
-     */
-    get campaigns() {
-        return this._campaigns;
-    }
-    /**
-     * Redemption manager - High-level redemption operations
-     *
-     * @example
-     * ```typescript
-     * const redemptions = await sdk.redemptions.getActiveRedemptions();
-     * await sdk.redemptions.redeemOffer(redemptionId);
-     * const history = await sdk.redemptions.getUserRedemptions();
-     * ```
-     */
-    get redemptions() {
-        return this._redemptions;
-    }
-    /**
-     * Transaction manager - High-level transaction operations
-     *
-     * @example
-     * ```typescript
-     * const transaction = await sdk.transactions.getTransactionById(id);
-     * await sdk.transactions.createTransaction(txData);
-     * const history = await sdk.transactions.getUserTransactionHistory('all');
-     * ```
-     */
-    get transactions() {
-        return this._transactions;
-    }
-    /**
-     * Purchase manager - High-level purchase operations
-     *
-     * @example
-     * ```typescript
-     * const intent = await sdk.purchases.createPaymentIntent(100, 'usd', 'email@example.com', 'Purchase');
-     * const tokens = await sdk.purchases.getActivePurchaseTokens();
-     * const purchases = await sdk.purchases.getAllUserPurchases();
-     * ```
-     */
-    get purchases() {
-        return this._purchases;
-    }
-    /**
-     * File manager - High-level file operations
-     *
-     * @example
-     * ```typescript
-     * const uploadUrl = await sdk.files.getSignedPutUrl('entity-123', 'token', 'jpg');
-     * const accessUrl = await sdk.files.getSignedGetUrl('entity-123', 'token');
-     * const optimizedUrl = await sdk.files.optimizeMedia(originalUrl, 800, 600);
-     * ```
-     */
-    get files() {
-        return this._files;
-    }
-    /**
-     * Tenant manager - High-level tenant operations
-     *
-     * @example
-     * ```typescript
-     * const tenant = await sdk.tenant.getTenantInfo();
-     * const config = await sdk.tenant.getClientConfig();
-     * const admins = await sdk.tenant.getAdmins();
-     * ```
-     */
-    get tenants() {
-        return this._tenants;
-    }
-    /**
-     * Analytics manager - High-level analytics operations
-     *
-     * @example
-     * ```typescript
-     * const analytics = await sdk.analytics.getTransactionAnalytics(request);
-     * ```
-     */
-    get analytics() {
-        return this._analytics;
-    }
-    /**
-     * Donation manager - High-level donation operations
-     *
-     * @example
-     * ```typescript
-     * const types = await sdk.donations.getDonationTypes();
-     * ```
-     */
-    get donations() {
-        return this._donations;
-    }
-    /**
-     * Web3 manager - High-level blockchain operations
-     *
-     * @example
-     * ```typescript
-     * const balance = await sdk.web3.getTokenBalance(request);
-     * const metadata = await sdk.web3.getTokenMetadata(request);
-     * const collection = await sdk.web3.getTokenCollection(request);
-     * ```
-     */
-    get web3() {
-        return this._web3;
-    }
-    /**
-     * Gets the API client for direct PERS API requests
-     *
-     * Use this for advanced operations not covered by the managers.
-     * The returned client handles authentication, token refresh, and error handling automatically.
-     *
-     * @returns Configured PersApiClient instance
-     *
-     * @example
-     * ```typescript
-     * const apiClient = sdk.api();
-     * const customData = await apiClient.get<CustomType>('/custom-endpoint');
-     * await apiClient.post('/custom-endpoint', customData);
-     * ```
-     */
-    api() {
-        return this.apiClient;
-    }
-    /**
-     * Checks if SDK is configured for production environment
-     *
-     * @returns True if environment is 'production', false otherwise
-     */
-    isProduction() {
-        return this.apiClient.getConfig().environment === 'production';
-    }
-}
-/**
- * Factory function for creating PERS SDK
- *
- * @param httpClient Platform-specific HTTP client implementation
- * @param config SDK configuration options
- * @returns PERS SDK instance
- */
-function createPersSDK(httpClient, config) {
-    return new PersSDK(httpClient, config);
-}
-
-export { AuthManager as A, BusinessManager as B, CampaignManager as C, DEFAULT_PERS_CONFIG as D, FileManager as F, PersSDK as P, RedemptionManager as R, TokenManager as T, UserManager as U, Web3Manager as W, createAuthProvider as a, PersApiClient as b, createPersSDK as c, buildApiRoot as d, UserStatusManager as e, TransactionManager as f, PurchaseManager as g, TenantManager as h, AnalyticsManager as i, DonationManager as j, FileApi as k, FileService as l, mergeWithDefaults as m, createFileSDK as n };
-//# sourceMappingURL=pers-sdk-Z6MKeFBX.js.map