@explorins/pers-sdk 1.6.4 → 1.6.9

package/dist/chunks/pers-sdk-DbPwFKrf.cjs

@@ -1,3378 +0,0 @@
-'use strict';
-
-var persShared = require('@explorins/pers-shared');
-var user = require('../user.cjs');
-var userStatus = require('../user-status.cjs');
-var tokenSdk = require('./token-sdk-CiAbOb6c.cjs');
-var business = require('../business.cjs');
-var campaign = require('../campaign.cjs');
-var redemption = require('../redemption.cjs');
-var transaction = require('../transaction.cjs');
-var payment = require('../payment.cjs');
-var tenant = require('../tenant.cjs');
-var analytics = require('../analytics.cjs');
-var donation = require('../donation.cjs');
-var web3 = require('./index-CzEluQmf.cjs');
-var web3Chain = require('./index-BfOoX87y.cjs');
-
-/**
- * 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: persShared.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: persShared.AccountOwnerType.USER
-        };
-        return this.apiClient.post(`${this.basePath}/token`, body, { bypassAuth: true });
-    }
-    async loginUnAuthenticated(rawLoginData) {
-        const body = {
-            authToken: '',
-            authType: persShared.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 Promise.resolve().then(function () { return require('./index-BfOoX87y.cjs'); }).then(function (n) { return n.jwt_function; });
-            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 Promise.resolve().then(function () { return require('./index-BfOoX87y.cjs'); }).then(function (n) { return n.jwt_function; });
-            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 Promise.resolve().then(function () { return require('./index-BfOoX87y.cjs'); }).then(function (n) { return n.jwt_function; });
-            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 = user.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 = userStatus.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.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 = business.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 = campaign.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 = redemption.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 = transaction.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 = payment.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 = tenant.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 = analytics.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 = donation.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 = web3.createWeb3SDK(apiClient);
-        this.web3ChainSDK = web3Chain.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 web3.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);
-}
-
-exports.AnalyticsManager = AnalyticsManager;
-exports.AuthManager = AuthManager;
-exports.BusinessManager = BusinessManager;
-exports.CampaignManager = CampaignManager;
-exports.DEFAULT_PERS_CONFIG = DEFAULT_PERS_CONFIG;
-exports.DonationManager = DonationManager;
-exports.FileApi = FileApi;
-exports.FileManager = FileManager;
-exports.FileService = FileService;
-exports.PersApiClient = PersApiClient;
-exports.PersSDK = PersSDK;
-exports.PurchaseManager = PurchaseManager;
-exports.RedemptionManager = RedemptionManager;
-exports.TenantManager = TenantManager;
-exports.TokenManager = TokenManager;
-exports.TransactionManager = TransactionManager;
-exports.UserManager = UserManager;
-exports.UserStatusManager = UserStatusManager;
-exports.Web3Manager = Web3Manager;
-exports.buildApiRoot = buildApiRoot;
-exports.createAuthProvider = createAuthProvider;
-exports.createFileSDK = createFileSDK;
-exports.createPersSDK = createPersSDK;
-exports.mergeWithDefaults = mergeWithDefaults;
-//# sourceMappingURL=pers-sdk-DbPwFKrf.cjs.map