@explorins/pers-sdk 1.2.6 → 1.3.2

package/dist/index.js

@@ -1,4859 +1,23 @@
-import { AccountOwnerType, TransactionRole } from '@explorins/pers-shared';
+export { D as DEFAULT_PERS_CONFIG, a as PersApiClient, P as PersSDK, b as buildApiRoot, c as createPersSDK, m as mergeWithDefaults } from './chunks/pers-sdk-tKHGQr5x.js';
+export { d as detectEnvironment, e as environment, w as warnIfProblematicEnvironment } from './chunks/environment-C2AkkLPd.js';
 export { AccountOwnerType } from '@explorins/pers-shared';
-import { jwtDecode } from 'jwt-decode';
-import Web3 from 'web3';
-import { FetchRequest, JsonRpcProvider } from 'ethers';
-import { getSmartContractInstance, getAccountTokenBalance, getTokenUri, getTokenOfOwnerByIndex } from '@explorins/web3-ts';
-
-/**
- * PERS SDK Configuration interfaces
- */
-/**
- * Default configuration values
- */
-const DEFAULT_PERS_CONFIG = {
-    environment: 'production',
-    apiVersion: 'v2',
-    timeout: 30000,
-    retries: 3
-};
-/**
- * Internal function to construct API root from environment
- * Now defaults to production and v2
- */
-function buildApiRoot(environment = 'production', version = 'v2') {
-    const baseUrls = {
-        development: 'https://explorins-loyalty.ngrok.io',
-        staging: `https://dev.api.pers.ninja/${version}`,
-        production: `https://api.pers.ninja/${version}`
-    };
-    return `${baseUrls[environment]}`;
-}
-/**
- * Merge user config with defaults
- */
-function mergeWithDefaults(config) {
-    return {
-        ...DEFAULT_PERS_CONFIG,
-        ...config,
-        environment: config.environment ?? DEFAULT_PERS_CONFIG.environment,
-        apiVersion: config.apiVersion ?? DEFAULT_PERS_CONFIG.apiVersion,
-        timeout: config.timeout ?? DEFAULT_PERS_CONFIG.timeout,
-        retries: config.retries ?? DEFAULT_PERS_CONFIG.retries
-    };
-}
-
-/**
- * Platform-Agnostic Auth Admin API Client
- *
- * Handles authentication and authorization admin operations using the PERS backend.
- * Uses @explorins/pers-shared DTOs for consistency with backend.
- *
- * Note: Special header handling (bypass-auth-interceptor) may need to be implemented
- * at the PersApiClient level or through a specialized auth client.
- */
-class AuthApi {
-    constructor(apiClient) {
-        this.apiClient = apiClient;
-        this.basePath = '/auth';
-    }
-    // ==========================================
-    // ADMIN AUTHENTICATION OPERATIONS
-    // ==========================================
-    /**
-     * ADMIN: Login tenant admin with JWT
-     * Note: JWT handling and auth bypass headers may need special implementation
-     */
-    async loginTenantAdmin(jwt) {
-        const body = {
-            authToken: jwt,
-            authType: AccountOwnerType.TENANT
-        };
-        return this.apiClient.post(`${this.basePath}/token`, body);
-    }
-    async loginUser(jwt) {
-        const body = {
-            authToken: jwt,
-            authType: AccountOwnerType.USER
-        };
-        return this.apiClient.post(`${this.basePath}/token`, body);
-    }
-    /**
-     * ADMIN: Refresh access token
-     * Note: Bypass header handling may need special implementation
-     */
-    async refreshAccessToken(refreshToken) {
-        return this.apiClient.post(`${this.basePath}/refresh`, { refreshToken });
-    }
-}
-
-/**
- * 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);
-        }
-        return response;
-    }
-    /**
-     * ADMIN: Login user with JWT
-     * 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);
-        }
-        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) {
-        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);
-            }
-        }
-        catch (error) {
-            console.error('Failed to store tokens in auth provider:', error);
-            // Don't throw - token storage failure shouldn't break authentication
-        }
-    }
-}
-
-/**
- * Simple, self-contained authentication provider for SDK
- *
- * Manages tokens internally without external dependencies.
- * Perfect for platform-agnostic usage.
- */
-class SimpleSdkAuthProvider {
-    constructor(projectKey) {
-        this.accessToken = null;
-        this.refreshToken = null;
-        this.projectKey = null;
-        this.authType = 'admin';
-        this.projectKey = projectKey || null;
-        // Try to load tokens from localStorage if available
-        this.loadTokensFromStorage();
-    }
-    async getToken() {
-        // Return stored access token
-        return this.accessToken;
-    }
-    async getProjectKey() {
-        return this.projectKey;
-    }
-    async onTokenExpired() {
-        console.log('SimpleSdkAuthProvider: Token expired, attempting refresh...');
-        if (!this.refreshToken) {
-            console.warn('SimpleSdkAuthProvider: No refresh token available');
-            throw new Error('No refresh token available for refresh');
-        }
-        // Note: Actual refresh logic would be handled by the SDK's AuthService
-        // This provider just manages token storage
-        console.warn('SimpleSdkAuthProvider: Token refresh should be handled by SDK AuthService');
-    }
-    // Token storage methods
-    async setAccessToken(token) {
-        this.accessToken = token;
-        this.saveTokenToStorage('pers_access_token', token);
-    }
-    async setRefreshToken(token) {
-        this.refreshToken = token;
-        this.saveTokenToStorage('pers_refresh_token', token);
-    }
-    async getRefreshToken() {
-        return this.refreshToken;
-    }
-    async clearTokens() {
-        this.accessToken = null;
-        this.refreshToken = null;
-        // Clear from storage
-        this.removeTokenFromStorage('pers_access_token');
-        this.removeTokenFromStorage('pers_refresh_token');
-    }
-    // Internal methods for token persistence
-    loadTokensFromStorage() {
-        if (typeof localStorage !== 'undefined') {
-            try {
-                this.accessToken = localStorage.getItem('pers_access_token');
-                this.refreshToken = localStorage.getItem('pers_refresh_token');
-            }
-            catch (error) {
-                console.error('Failed to load tokens from localStorage:', error);
-            }
-        }
-        else {
-            console.warn('localStorage is not available for token persistence');
-        }
-    }
-    saveTokenToStorage(key, value) {
-        if (typeof localStorage !== 'undefined') {
-            localStorage.setItem(key, value);
-        }
-    }
-    removeTokenFromStorage(key) {
-        if (typeof localStorage !== 'undefined') {
-            localStorage.removeItem(key);
-        }
-    }
-    // Utility methods for external integration
-    hasValidToken() {
-        const hasToken = !!this.accessToken;
-        return hasToken;
-    }
-    hasRefreshToken() {
-        return !!this.refreshToken;
-    }
-}
-
-// packages/pers-sdk/src/core/pers-api-client.ts
-/**
- * PERS API Client - Core platform-agnostic client for PERS backend
- */
-class PersApiClient {
-    constructor(httpClient, config) {
-        this.httpClient = httpClient;
-        this.config = config;
-        // Merge user config with defaults (production + v2)
-        this.mergedConfig = mergeWithDefaults(config);
-        // Auto-create auth provider if none provided
-        if (!this.mergedConfig.authProvider) {
-            this.mergedConfig.authProvider = new SimpleSdkAuthProvider(this.mergedConfig.apiProjectKey);
-        }
-        // 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);
-        this.authService = new AuthService(this.authApi, this.mergedConfig.authProvider);
-    }
-    /**
-     * 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' } = options || {};
-        const url = `${this.apiRoot}${endpoint}`;
-        // ✅ DEBUGGING: Add extensive logging for CSV endpoint
-        const isCSVEndpoint = endpoint.includes('/export/csv');
-        const requestOptions = {
-            headers: await this.getHeaders(),
-            timeout: this.mergedConfig.timeout,
-            responseType
-        };
-        try {
-            let result;
-            switch (method) {
-                case 'GET':
-                    result = await this.httpClient.get(url, requestOptions);
-                    break;
-                case 'POST':
-                    result = await this.httpClient.post(url, body, requestOptions);
-                    break;
-                case 'PUT':
-                    result = await this.httpClient.put(url, body, requestOptions);
-                    break;
-                case 'DELETE':
-                    result = await this.httpClient.delete(url, requestOptions);
-                    break;
-                default:
-                    throw new Error(`Unsupported HTTP method: ${method}`);
-            }
-            return result;
-        }
-        catch (error) {
-            if (isCSVEndpoint) {
-                console.error('❌ [PERS API CLIENT] CSV Request failed:', error);
-            }
-            // Handle 401 errors with automatic token refresh
-            const apiError = error;
-            if (apiError.status === 401 && retryCount === 0 && this.mergedConfig.authProvider?.onTokenExpired) {
-                try {
-                    await this.mergedConfig.authProvider.onTokenExpired();
-                    // Retry once with refreshed token
-                    return this.request(method, endpoint, body, { ...options, retryCount: 1 });
-                }
-                catch (refreshError) {
-                    throw new PersApiError(`Authentication refresh failed: ${refreshError}`, endpoint, method, 401);
-                }
-            }
-            throw new PersApiError(`PERS API request failed: ${apiError.message || error}`, endpoint, method, apiError.status);
-        }
-    }
-    /**
-     * Generic GET request
-     */
-    async get(endpoint, responseType) {
-        return this.request('GET', endpoint, undefined, { responseType });
-    }
-    /**
-     * Generic POST request
-     */
-    async post(endpoint, body) {
-        return this.request('POST', endpoint, body);
-    }
-    /**
-     * Generic PUT request
-     */
-    async put(endpoint, body) {
-        return this.request('PUT', endpoint, body);
-    }
-    /**
-     * Generic DELETE request
-     */
-    async delete(endpoint) {
-        return this.request('DELETE', endpoint);
-    }
-    // ==========================================
-    // AUTHENTICATION METHODS
-    // ==========================================
-    /**
-     * Login admin user with external JWT (e.g., Firebase)
-     * Automatically stores tokens in auth provider if available
-     */
-    async loginAdmin(externalJwt) {
-        return this.authService.loginTenantAdmin(externalJwt);
-    }
-    /**
-     * Login regular user with external JWT
-     * Automatically stores tokens in auth provider if available
-     */
-    async loginUser(externalJwt) {
-        return this.authService.loginUser(externalJwt);
-    }
-    /**
-     * Refresh access token using stored refresh token
-     */
-    async refreshToken() {
-        const refreshToken = await this.mergedConfig.authProvider?.getRefreshToken?.();
-        if (!refreshToken) {
-            throw new Error('No refresh token available');
-        }
-        return this.authService.refreshAccessToken(refreshToken);
-    }
-    /**
-     * Clear all stored authentication tokens
-     */
-    async clearAuth() {
-        return this.authService.clearTokens();
-    }
-    /**
-     * Check if user has valid authentication token
-     */
-    hasValidAuth() {
-        return this.mergedConfig.authProvider?.hasValidToken?.() || false;
-    }
-    /**
-     * Get current configuration (returns merged config)
-     */
-    getConfig() {
-        return this.mergedConfig;
-    }
-    /**
-     * Get original user configuration
-     */
-    getOriginalConfig() {
-        return this.config;
-    }
-}
-class PersApiError extends Error {
-    constructor(message, endpoint, method, statusCode) {
-        super(message);
-        this.endpoint = endpoint;
-        this.method = method;
-        this.statusCode = statusCode;
-        this.name = 'PersApiError';
-    }
-}
-
-/**
- * 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 = `pers_access_token_${config.authType || 'user'}`;
-    const REFRESH_TOKEN_KEY = `pers_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) {
-                console.warn('Failed to retrieve token from storage:', error);
-            }
-            // 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) {
-                console.error('Failed to store access token:', error);
-                throw error;
-            }
-        },
-        async setRefreshToken(token) {
-            try {
-                await tokenStorage.setItem(REFRESH_TOKEN_KEY, token);
-            }
-            catch (error) {
-                console.error('Failed to store refresh token:', error);
-                throw error;
-            }
-        },
-        async getRefreshToken() {
-            try {
-                return await tokenStorage.getItem(REFRESH_TOKEN_KEY);
-            }
-            catch (error) {
-                console.warn('Failed to retrieve refresh token from storage:', error);
-                return null;
-            }
-        },
-        async clearTokens() {
-            currentToken = null;
-            try {
-                await Promise.all([
-                    tokenStorage.removeItem(ACCESS_TOKEN_KEY),
-                    tokenStorage.removeItem(REFRESH_TOKEN_KEY)
-                ]);
-            }
-            catch (error) {
-                console.error('Failed to clear tokens from storage:', error);
-                throw error;
-            }
-        },
-        async onTokenExpired() {
-            // Prevent concurrent refresh attempts
-            if (isRefreshing) {
-                if (refreshPromise) {
-                    await refreshPromise;
-                }
-                return;
-            }
-            // No refresh logic provided
-            if (!config.onTokenExpired) {
-                console.warn('Token expired but no refresh logic provided');
-                currentToken = null;
-                try {
-                    await tokenStorage.removeItem(ACCESS_TOKEN_KEY);
-                }
-                catch (error) {
-                    console.warn('Failed to clear expired token from storage:', error);
-                }
-                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) {
-                                console.warn('Failed to store refreshed token:', error);
-                            }
-                            // Notify about successful token refresh
-                            if (config.onTokenRefreshed) {
-                                config.onTokenRefreshed(newToken);
-                            }
-                        }
-                        else {
-                            console.warn('Token refresh completed but no new token received');
-                            currentToken = null;
-                            try {
-                                await tokenStorage.removeItem(ACCESS_TOKEN_KEY);
-                            }
-                            catch (error) {
-                                console.warn('Failed to clear token after failed refresh:', error);
-                            }
-                        }
-                    }
-                    else {
-                        // For static token configs, clear the token since we can't refresh
-                        console.warn('Token expired for static token config - clearing token');
-                        currentToken = null;
-                        try {
-                            await tokenStorage.removeItem(ACCESS_TOKEN_KEY);
-                        }
-                        catch (error) {
-                            console.warn('Failed to clear expired static token:', error);
-                        }
-                    }
-                }
-                catch (error) {
-                    console.error('Token refresh failed:', error);
-                    currentToken = null; // Clear token on refresh failure
-                    try {
-                        await tokenStorage.removeItem(ACCESS_TOKEN_KEY);
-                    }
-                    catch (storageError) {
-                        console.warn('Failed to clear token after refresh failure:', storageError);
-                    }
-                    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;
-  };
-} */
-
-/**
- * @explorins/pers-sdk/core/auth - Consolidated Auth Module
- *
- * All authentication functionality in one place:
- * - Auth provider interfaces and implementations
- * - Auth API and service logic
- * - Token management
- */
-// Auth provider interfaces and implementations
-/**
- * Create a complete Auth SDK instance (for backward compatibility)
- * Note: This is now handled directly by PersApiClient
- *
- * @param apiClient - Configured PERS API client
- * @param authProvider - Optional auth provider. If not provided, uses SimpleSdkAuthProvider
- * @returns Auth SDK with flattened structure for better DX
- */
-function createAuthSDK(apiClient, authProvider) {
-    // Use simple internal auth provider if none provided
-    const provider = authProvider || new SimpleSdkAuthProvider();
-    const authApi = new AuthApi(apiClient);
-    const authService = new AuthService(authApi, provider);
-    return {
-        // Direct access to service methods (primary interface)
-        // Admin authentication methods
-        loginTenantAdmin: (jwt) => authService.loginTenantAdmin(jwt),
-        loginUser: (jwt) => authService.loginUser(jwt),
-        refreshAccessToken: (refreshToken) => authService.refreshAccessToken(refreshToken),
-        clearTokens: () => authService.clearTokens(),
-        // Auth provider access for external integration
-        getAuthProvider: () => provider,
-        hasValidToken: () => provider.hasValidToken?.() || false,
-        // Advanced access for edge cases
-        api: authApi,
-        service: authService
-    };
-}
-
-/**
- * PERS SDK - Minimal platform-agnostic client with built-in authentication
- * Authentication is now handled at the SDK core level for better scalability
- */
-/**
- * Minimal PERS SDK - API client with authentication built-in
- * Platform adapters provide auth providers and HTTP clients
- */
-class PersSDK {
-    constructor(httpClient, config) {
-        this.apiClient = new PersApiClient(httpClient, config);
-    }
-    /**
-     * Get the API client for direct PERS API calls
-     * This is the main interface - keep it simple!
-     */
-    api() {
-        return this.apiClient;
-    }
-    /**
-     * Quick config check
-     */
-    isProduction() {
-        return this.apiClient.getConfig().environment === 'production';
-    }
-}
-/**
- * Simple factory function
- */
-function createPersSDK(httpClient, config) {
-    return new PersSDK(httpClient, config);
-}
-
-/**
- * Platform-Agnostic Business API Client
- *
- * Updated to match the actual RESTful endpoints:
- * - /businesses for business operations
- * - /business-types for business type operations (separate controller)
- */
-class BusinessApi {
-    constructor(apiClient) {
-        this.apiClient = apiClient;
-        this.basePath = '/businesses';
-        this.businessTypesPath = '/business-types'; // ✅ FIX: Separate controller
-    }
-    // ==========================================
-    // 🌐 BUSINESS TYPES MANAGEMENT
-    // ==========================================
-    /**
-     * Get all business types (project key required)
-     *
-     * Endpoint: GET /business-types
-     * Auth: @ApiSecurity('projectKey')
-     */
-    async getAllBusinessTypes() {
-        return this.apiClient.get(this.businessTypesPath); // ✅ FIX: Correct path
-    }
-    /**
-     * ADMIN: Create business type
-     *
-     * Endpoint: POST /business-types
-     * Auth: @TenantAdmin()
-     */
-    async createBusinessType(dto) {
-        return this.apiClient.post(this.businessTypesPath, dto); // ✅ FIX: Correct path
-    }
-    /**
-     * ADMIN: Update business type
-     *
-     * Endpoint: PUT /business-types
-     * Auth: @TenantAdmin()
-     */
-    async updateBusinessType(dto) {
-        return this.apiClient.put(this.businessTypesPath, dto); // ✅ FIX: Correct path
-    }
-    /**
-     * ADMIN: Delete business type
-     *
-     * Endpoint: DELETE /business-types/{id}
-     * Auth: @TenantAdmin()
-     */
-    async deleteBusinessType(id) {
-        return this.apiClient.delete(`${this.businessTypesPath}/${id}`); // ✅ FIX: Correct path
-    }
-    // ==========================================
-    // 🏢 BUSINESS MANAGEMENT
-    // ==========================================
-    /**
-     * Get current business info (business authentication required)
-     *
-     * Endpoint: GET /businesses/me
-     * Auth: @Business()
-     */
-    async getCurrentBusiness() {
-        return this.apiClient.get(`${this.basePath}/me`);
-    }
-    /**
-     * Get all businesses with role-based filtering
-     *
-     * Endpoint: GET /businesses?active={boolean}&sanitize={mode}
-     * Auth: @ApiSecurity('projectKey') (enhanced with role-based filtering)
-     * Note:
-     * - Project API Key users: Active businesses only (automatically filtered)
-     * - Admin JWT users: Full access with all query parameters
-     */
-    async getAllBusinesses(options) {
-        const params = new URLSearchParams();
-        if (options?.active !== undefined) {
-            params.append('active', String(options.active));
-        }
-        if (options?.sanitize) {
-            params.append('sanitize', options.sanitize);
-        }
-        const queryString = params.toString();
-        const url = queryString ? `${this.basePath}?${queryString}` : this.basePath;
-        return this.apiClient.get(url);
-    }
-    /**
-     * Get all active businesses (convenience method)
-     *
-     * Endpoint: GET /businesses
-     * Auth: @ApiSecurity('projectKey')
-     */
-    async getActiveBusinesses() {
-        return this.apiClient.get(this.basePath);
-    }
-    // ✅ REMOVED: getAllBusinessesAdmin() - No separate /admin endpoint exists
-    // The unified endpoint handles role-based access automatically
-    /**
-     * Get business by ID
-     *
-     * Endpoint: GET /businesses/{id}
-     * Auth: @ApiSecurity('projectKey')
-     */
-    async getBusinessById(businessId) {
-        return this.apiClient.get(`${this.basePath}/${businessId}`);
-    }
-    /**
-     * Get business by account address
-     *
-     * Endpoint: GET /businesses/account/{accountAddress}
-     * Auth: @ApiSecurity('projectKey')
-     */
-    async getBusinessByAccount(accountAddress) {
-        return this.apiClient.get(`${this.basePath}/account/${accountAddress}`);
-    }
-    // ==========================================
-    // 🔧 ADMIN OPERATIONS
-    // ==========================================
-    /**
-     * ADMIN: Create business
-     *
-     * Endpoint: POST /businesses
-     * Auth: @TenantAdmin()
-     * Returns: BusinessApiKeyDTO | BusinessTokenBalancesDTO
-     */
-    async createBusiness(dto) {
-        return this.apiClient.post(this.basePath, dto);
-    }
-    /**
-     * ADMIN: Create business by display name (convenience method)
-     */
-    async createBusinessByDisplayName(displayName) {
-        const dto = {
-            displayName,
-            // Add other required fields based on BusinessCreateRequestDTO structure
-        };
-        return this.createBusiness(dto);
-    }
-    /**
-     * ADMIN: Create businesses from URL
-     *
-     * Endpoint: POST /businesses/bulk/url
-     * Auth: @TenantAdmin()
-     */
-    async createBusinessesFromUrl(url) {
-        return this.apiClient.post(`${this.basePath}/bulk/url`, { url });
-    }
-    /**
-     * ADMIN: Update business
-     *
-     * Endpoint: PUT /businesses/{id}
-     * Auth: @TenantAdmin()
-     */
-    async updateBusiness(id, businessData) {
-        return this.apiClient.put(`${this.basePath}/${id}`, businessData);
-    }
-    /**
-     * ADMIN: Toggle business active status
-     *
-     * Endpoint: PUT /businesses/{id}/status
-     * Auth: @TenantAdmin()
-     */
-    async toggleBusinessActive(id, isActive) {
-        const dto = { isActive };
-        return this.apiClient.put(`${this.basePath}/${id}/status`, dto); // ✅ FIX: Correct endpoint
-    }
-}
-
-/**
- * Platform-Agnostic Business Service
- *
- * Contains business logic and operations that work across platforms.
- * No framework dependencies - pure TypeScript business logic.
- *
- * Focuses only on actual backend capabilities.
- */
-class BusinessService {
-    constructor(businessApi) {
-        this.businessApi = businessApi;
-    }
-    /**
-     * Get all active businesses
-     */
-    async getActiveBusinesses() {
-        return this.businessApi.getActiveBusinesses();
-    }
-    /**
-     * Get all business types
-     */
-    async getAllBusinessTypes() {
-        return this.businessApi.getAllBusinessTypes();
-    }
-    /**
-     * Get business by ID
-     */
-    async getBusinessById(businessId) {
-        return this.businessApi.getBusinessById(businessId);
-    }
-    /**
-     * Get business by account address
-     */
-    async getBusinessByAccount(accountAddress) {
-        return this.businessApi.getBusinessByAccount(accountAddress);
-    }
-    /**
-     * Get businesses by type (client-side filtering)
-     */
-    async getBusinessesByType(typeId) {
-        const businesses = await this.getActiveBusinesses();
-        return businesses.filter(business => business.businessType && business.businessType.id === parseInt(typeId));
-    }
-    // ==========================================
-    // ADMIN OPERATIONS
-    // ==========================================
-    /**
-     * ADMIN: Get all businesses (active and inactive)
-     */
-    async getAllBusinesses() {
-        return this.businessApi.getAllBusinesses();
-    }
-    /**
-     * ADMIN: Create business by display name
-     */
-    async createBusinessByDisplayName(displayName) {
-        return this.businessApi.createBusinessByDisplayName(displayName);
-    }
-    /**
-     * ADMIN: Update business
-     */
-    async updateBusiness(id, businessData) {
-        return this.businessApi.updateBusiness(id, businessData);
-    }
-    /**
-     * ADMIN: Toggle business active status
-     */
-    async toggleBusinessActive(id, isActive) {
-        return this.businessApi.toggleBusinessActive(id, isActive);
-    }
-}
-
-/**
- * @explorins/pers-sdk-business
- *
- * Platform-agnostic Business Domain SDK for PERS ecosystem
- * Focuses on non-admin business operations
- */
-// API Layer
-/**
- * Create a complete Business SDK instance
- *
- * @param apiClient - Configured PERS API client
- * @returns Business SDK with flattened structure for better DX
- */
-function createBusinessSDK(apiClient) {
-    const businessApi = new BusinessApi(apiClient);
-    const businessService = new BusinessService(businessApi);
-    return {
-        // Direct access to service methods (primary interface)
-        getActiveBusinesses: () => businessService.getActiveBusinesses(),
-        getAllBusinessTypes: () => businessService.getAllBusinessTypes(),
-        getBusinessById: (businessId) => businessService.getBusinessById(businessId),
-        getBusinessByAccount: (accountAddress) => businessService.getBusinessByAccount(accountAddress),
-        getBusinessesByType: (typeId) => businessService.getBusinessesByType(typeId),
-        // Admin methods
-        getAllBusinesses: () => businessService.getAllBusinesses(),
-        createBusinessByDisplayName: (displayName) => businessService.createBusinessByDisplayName(displayName),
-        updateBusiness: (id, businessData) => businessService.updateBusiness(id, businessData),
-        toggleBusinessActive: (id, isActive) => businessService.toggleBusinessActive(id, isActive),
-        // Advanced access for edge cases
-        api: businessApi,
-        service: businessService
-    };
-}
-
-/**
- * Platform-Agnostic Transaction API Client (UPDATED FOR NEW RESTful ENDPOINTS)
- *
- * Handles transaction operations using the PERS backend.
- * Uses @explorins/pers-shared DTOs for consistency with backend.
- *
- * MIGRATION NOTES:
- * - All endpoints changed from /transaction to /transactions
- * - Role-based paths removed (no more /auth, /admin, /business in URLs)
- * - New RESTful resource-based structure
- * - Added new client-side transaction flow methods
- * - Enhanced admin query capabilities
- */
-class TransactionApi {
-    constructor(apiClient) {
-        this.apiClient = apiClient;
-        this.basePath = '/transactions';
-    }
-    /**
-     * Get transaction by ID (public endpoint)
-     *
-     * UPDATED: /transaction/{id} → /transactions/{id}
-     */
-    async getTransactionById(transactionId) {
-        return this.apiClient.get(`${this.basePath}/${transactionId}`);
-    }
-    /**
-     * Unique method to create a transaction
-     * @param request
-     * @returns
-     */
-    async createTransaction(request) {
-        return this.apiClient.post(`${this.basePath}`, request);
-        // return this.apiClient.post<TransactionDTO>(`${this.basePath}/system`, request);
-    }
-    // ==========================================
-    // AUTHENTICATED USER OPERATIONS
-    // ==========================================
-    /**
-     * AUTH: Create authenticated user transaction
-     *
-     * UPDATED: /transaction/auth/transaction → /transactions/user
-     */
-    /* async createAuthTransaction(request: TransactionRequestDTO): Promise<TransactionRequestResponseDTO> {
-      return this.apiClient.post<TransactionRequestResponseDTO>(`${this.basePath}`, request);
-    } */
-    /**
-     * AUTH: Get user's sent transactions
-     *
-     * UPDATED: /transaction/auth/sender → /transactions/me/sent
-     */
-    async getUserSentTransactions() {
-        const params = new URLSearchParams({
-            timestamp: Date.now().toString()
-        });
-        return this.apiClient.get(`${this.basePath}/me/sent?${params.toString()}`);
-    }
-    /**
-     * AUTH: Get user's received transactions
-     *
-     * UPDATED: /transaction/auth/recipient → /transactions/me/received
-     */
-    async getUserReceivedTransactions() {
-        const params = new URLSearchParams({
-            timestamp: Date.now().toString()
-        });
-        return this.apiClient.get(`${this.basePath}/me/received?${params.toString()}`);
-    }
-    /**
-     * AUTH: Get user transaction history by type (backwards compatibility)
-     *
-     * UPDATED: Maps to appropriate /transactions/me/* endpoints
-     */
-    async getUserTransactionHistory(type) {
-        const params = new URLSearchParams({
-            timestamp: Date.now().toString()
-        });
-        // Map legacy type parameter to new endpoints
-        switch (type.toLowerCase()) {
-            case 'sender':
-            case 'sent':
-                return this.apiClient.get(`${this.basePath}/me/sent?${params.toString()}`);
-            case 'recipient':
-            case 'received':
-                return this.apiClient.get(`${this.basePath}/me/received?${params.toString()}`);
-            default:
-                // Default to sent transactions for backwards compatibility
-                return this.apiClient.get(`${this.basePath}/me/sent?${params.toString()}`);
-        }
-    }
-    /**
-     * AUTH: Prepare existing transaction for client-side signing
-     *
-     * NEW ENDPOINT: GET /transactions/{id}/prepare
-     */
-    async prepareExistingTransaction(transactionId) {
-        return this.apiClient.get(`${this.basePath}/${transactionId}/prepare`);
-    }
-    /**
-     * AUTH: Submit client-side signed transaction
-     *
-     * NEW ENDPOINT: POST /transactions/{id}/submit
-     */
-    async submitSignedTransaction(signedTxData) {
-        return this.apiClient.post(`${this.basePath}/submit`, signedTxData);
-    }
-    /**
-     * AUTH: Burn user tokens
-     *
-     * UPDATED: Uses new user transaction endpoint with burn-specific parameters
-     * Note: This might need backend confirmation on burn functionality implementation
-     */
-    /* async burnUserTokens(request: UserBurnTokenRequestDTO): Promise<TransactionRequestResponseDTO> {
-      // Map burn request to TransactionRequestDTO format for new endpoint
-      const transactionRequest: TransactionRequestDTO = {
-        ...request,
-        // Add any specific burn transaction parameters here
-      } as any;
-  
-      return this.apiClient.post<TransactionRequestResponseDTO>(`${this.basePath}`, transactionRequest);
-    } */
-    // ==========================================
-    // BUSINESS OPERATIONS
-    // ==========================================
-    /**
-     * BUSINESS: Create business transaction
-     *
-     * UPDATED: /transaction/business/transaction → /transactions/business
-     */
-    /* async createBusinessTransaction(request: TransactionRequestDTO): Promise<TransactionRequestResponseDTO> {
-      return this.apiClient.post<TransactionRequestResponseDTO>(`${this.basePath}`, request);
-    } */
-    // ==========================================
-    // ADMIN OPERATIONS
-    // ==========================================
-    /**
-     * ADMIN: Create admin transaction
-     *
-     * UPDATED: /transaction/admin/transaction → /transactions/admin
-     */
-    /* async createAdminTransaction(request: TransactionRequestDTO): Promise<TransactionRequestResponseDTO> {
-      // return this.apiClient.post<TransactionRequestResponseDTO>(`${this.basePath}`, request);
-      return this.apiClient.post<TransactionDTO>(`${this.basePath}/system`, request);
-    } */
-    /**
-     * AUTH: Prepare client signed transaction
-     *
-     * UPDATED: /transaction/auth/prepare-signing → /transactions/prepare
-     */
-    async prepareClientSignedTransaction(request) {
-        return this.apiClient.post(`${this.basePath}`, request);
-    }
-    /**
-     * ADMIN: Get all tenant transactions
-     *
-     * UPDATED: /transaction/admin → /transactions
-     */
-    async getTenantTransactions() {
-        const result = await this.apiClient.get(`${this.basePath}`);
-        // If the new endpoint returns paginated response, extract the data array
-        if ('data' in result) {
-            return result.data;
-        }
-        // Fallback for direct array response
-        return result;
-    }
-    /**
-     * ADMIN: Get paginated transactions with filtering and sorting
-     *
-     * UPDATED: /transaction/admin → /transactions (same endpoint, better structure)
-     */
-    async getPaginatedTransactions(params) {
-        // Build query parameters
-        const queryParams = {
-            page: params.page.toString(),
-            limit: params.limit.toString()
-        };
-        // Add sorting parameters if provided
-        if (params.sortBy) {
-            queryParams['sortBy'] = params.sortBy;
-        }
-        if (params.sortOrder) {
-            queryParams['sortOrder'] = params.sortOrder;
-        }
-        // Add user-specific filtering if provided
-        if (params.participantId) {
-            queryParams['participantId'] = params.participantId;
-        }
-        // Add status filtering if provided
-        if (params.status) {
-            queryParams['status'] = params.status;
-        }
-        // Add additional filters if provided
-        if (params.filters) {
-            if (params.filters.startDate) {
-                queryParams['startDate'] = params.filters.startDate;
-            }
-            if (params.filters.endDate) {
-                queryParams['endDate'] = params.filters.endDate;
-            }
-            if (params.filters.type && params.filters.type.length > 0) {
-                queryParams['type'] = params.filters.type.join(',');
-            }
-            if (params.filters.tokenType && params.filters.tokenType.length > 0) {
-                queryParams['tokenType'] = params.filters.tokenType.join(',');
-            }
-        }
-        // Build query string
-        const queryString = Object.entries(queryParams)
-            .map(([key, value]) => `${key}=${encodeURIComponent(value)}`)
-            .join('&');
-        return this.apiClient.get(`${this.basePath}?${queryString}`);
-    }
-    /**
-     * ADMIN: Export transactions to CSV
-     *
-     * UPDATED: /transaction/admin/export/csv → /transactions/export/csv
-     */
-    async exportTransactionsCSV() {
-        return this.apiClient.get(`${this.basePath}/export/csv`, 'blob');
-    }
-    // ==========================================
-    // NEW ADMIN QUERY METHODS
-    // ==========================================
-    /**
-     * ADMIN: Query transactions by sender
-     *
-     * NEW ENDPOINT: POST /transactions/query-sender
-     */
-    /**
-   * Query transactions by sender using unified endpoint
-   */
-    async queryTransactionsBySender(accountSelector) {
-        // Build query parameters safely
-        const queryParams = {};
-        if (accountSelector.accountId) {
-            queryParams['participantId'] = accountSelector.accountId;
-        }
-        queryParams['role'] = TransactionRole.SENDER.toString();
-        const params = new URLSearchParams(queryParams);
-        return this.apiClient.get(`${this.basePath}?${params.toString()}`).then(response => response); // Extract items from paginated response
-    }
-    /**
-     * Query transactions by recipient using unified endpoint
-     */
-    async queryTransactionsByRecipient(accountSelector) {
-        // Build query parameters safely
-        const queryParams = {};
-        if (accountSelector.accountId) {
-            queryParams['participantId'] = accountSelector.accountId;
-        }
-        queryParams['role'] = TransactionRole.RECIPIENT.toString();
-        const params = new URLSearchParams(queryParams);
-        return this.apiClient.get(`${this.basePath}?${params.toString()}`).then(response => response); // Extract items from paginated response
-    }
-    /**
-     * ADMIN: Get transaction analytics
-     *
-     * NEW ENDPOINT: POST /transactions/analytics
-     */
-    async getTransactionAnalytics(analyticsRequest) {
-        return this.apiClient.post(`${this.basePath}/analytics`, analyticsRequest);
-    }
-    // ==========================================
-    // CONVENIENCE METHODS (BACKWARDS COMPATIBILITY)
-    // ==========================================
-    /**
-     * Convenience method: Get user sent transactions (alias)
-     */
-    async getUserSenderTransactions() {
-        return this.getUserSentTransactions();
-    }
-    /**
-     * Convenience method: Get user received transactions (alias)
-     */
-    async getUserRecipientTransactions() {
-        return this.getUserReceivedTransactions();
-    }
-}
-
-/**
- * Platform-Agnostic Transaction Service
- *
- * Contains transaction business logic and operations that work across platforms.
- * No framework dependencies - pure TypeScript business logic.
- *
- * Focuses only on actual backend capabilities.
- */
-class TransactionService {
-    constructor(transactionApi) {
-        this.transactionApi = transactionApi;
-    }
-    /**
-     * Get transaction by ID
-     */
-    async getTransactionById(transactionId) {
-        return this.transactionApi.getTransactionById(transactionId);
-    }
-    // ==========================================
-    // AUTHENTICATED OPERATIONS
-    // ==========================================
-    /**
-     * AUTH: Create authenticated transaction
-     */
-    /* async createAuthTransaction(request: TransactionRequestDTO): Promise<TransactionRequestResponseDTO> {
-      return this.transactionApi.createAuthTransaction(request);
-    } */
-    async createTransaction(request) {
-        return this.transactionApi.createTransaction(request);
-    }
-    async submitSignedTransaction(signedTxData) {
-        return this.transactionApi.submitSignedTransaction(signedTxData);
-    }
-    /**
-     * AUTH: Get user transaction history by type
-     */
-    async getUserTransactionHistory(type) {
-        return this.transactionApi.getUserTransactionHistory(type);
-    }
-    /**
-     * AUTH: Prepare client signed transaction
-     */
-    /* async prepareClientSignedTransaction(request: TransactionRequestDTO): Promise<TransactionRequestResponseDTO> {
-      return this.transactionApi.prepareClientSignedTransaction(request);
-    } */
-    /**
-     * AUTH: Burn user tokens
-     */
-    /* async burnUserTokens(request: UserBurnTokenRequestDTO): Promise<TransactionRequestResponseDTO> {
-      return this.transactionApi.burnUserTokens(request);
-    } */
-    // ==========================================
-    // BUSINESS OPERATIONS
-    // ==========================================
-    /**
-     * BUSINESS: Create business transaction
-     */
-    /* async createBusinessTransaction(request: TransactionRequestDTO): Promise<TransactionRequestResponseDTO> {
-      return this.transactionApi.createBusinessTransaction(request);
-    } */
-    // ==========================================
-    // ADMIN OPERATIONS
-    // ==========================================
-    /**
-     * ADMIN: Create admin transaction
-     */
-    /* async createAdminTransaction(request: TransactionRequestDTO): Promise<TransactionRequestResponseDTO> {
-      return this.transactionApi.createAdminTransaction(request);
-    } */
-    /**
-     * ADMIN: Get all tenant transactions
-     */
-    async getTenantTransactions() {
-        return this.transactionApi.getTenantTransactions();
-    }
-    /**
-     * ADMIN: Get paginated transactions with filtering and sorting
-     */
-    async getPaginatedTransactions(params) {
-        return this.transactionApi.getPaginatedTransactions(params);
-    }
-    /**
-     * ADMIN: Export transactions to CSV
-     */
-    async exportTransactionsCSV() {
-        return this.transactionApi.exportTransactionsCSV();
-    }
-}
-
-/**
- * Transaction Domain Models
- *
- * Re-exports from @explorins/pers-shared for consistency with backend
- * and to provide a single import source for transaction-related types.
- */
-// Transaction account types (domain-specific enum)
-var TransactionAccountType;
-(function (TransactionAccountType) {
-    // Add specific transaction account types as needed
-    // This should match the enum used in the infrastructure layer
-})(TransactionAccountType || (TransactionAccountType = {}));
-
-/**
- * @explorins/pers-sdk-transaction
- *
- * Platform-agnostic Transaction Domain SDK for PERS ecosystem
- * Handles transaction operations across different authorization levels
- */
-// API Layer
-/**
- * Create a complete Transaction SDK instance
- *
- * @param apiClient - Configured PERS API client
- * @returns Transaction SDK with flattened structure for better DX
- */
-function createTransactionSDK(apiClient) {
-    const transactionApi = new TransactionApi(apiClient);
-    const transactionService = new TransactionService(transactionApi);
-    return {
-        // Direct access to service methods (primary interface)
-        // Public methods
-        getTransactionById: (transactionId) => transactionService.getTransactionById(transactionId),
-        createTransaction: (request) => transactionService.createTransaction(request),
-        // Auth methods
-        // createAuthTransaction: (request: TransactionRequestDTO) => transactionService.createAuthTransaction(request),
-        getUserTransactionHistory: (type) => transactionService.getUserTransactionHistory(type),
-        //prepareClientSignedTransaction: (request: TransactionRequestDTO) => transactionService.prepareClientSignedTransaction(request),
-        // burnUserTokens: (request: UserBurnTokenRequestDTO) => transactionService.burnUserTokens(request),
-        // Business methods
-        // createBusinessTransaction: (request: TransactionRequestDTO) => transactionService.createBusinessTransaction(request),
-        // Admin methods
-        // createAdminTransaction: (request: TransactionRequestDTO) => transactionService.createAdminTransaction(request),
-        getTenantTransactions: () => transactionService.getTenantTransactions(),
-        getPaginatedTransactions: (params) => transactionService.getPaginatedTransactions(params),
-        exportTransactionsCSV: () => transactionService.exportTransactionsCSV(),
-        // Advanced access for edge cases
-        api: transactionApi,
-        service: transactionService
-    };
-}
-
-/**
- * Platform-Agnostic Analytics API Client
- *
- * Handles analytics operations using the PERS backend.
- * Uses @explorins/pers-shared DTOs for consistency with backend.
- */
-class AnalyticsApi {
-    constructor(apiClient) {
-        this.apiClient = apiClient;
-    }
-    // ==========================================
-    // ADMIN OPERATIONS
-    // ==========================================
-    /**
-     * ADMIN: Get transaction analytics with filtering and aggregation
-     */
-    async getTransactionAnalytics(request) {
-        return this.apiClient.post('/transactions/analytics', request);
-    }
-}
-
-/**
- * Platform-Agnostic Analytics Service
- *
- * Contains analytics business logic and operations that work across platforms.
- * No framework dependencies - pure TypeScript business logic.
- *
- * Focuses only on actual backend capabilities.
- */
-class AnalyticsService {
-    constructor(analyticsApi) {
-        this.analyticsApi = analyticsApi;
-    }
-    // ==========================================
-    // ADMIN OPERATIONS
-    // ==========================================
-    /**
-     * ADMIN: Get transaction analytics with filtering and aggregation
-     */
-    async getTransactionAnalytics(request) {
-        return this.analyticsApi.getTransactionAnalytics(request);
-    }
-}
-
-/**
- * @explorins/pers-sdk-analytics
- *
- * Platform-agnostic Analytics Domain SDK for PERS ecosystem
- * Handles analytics operations and data aggregation
- */
-// API Layer
-/**
- * Create a complete Analytics SDK instance
- *
- * @param apiClient - Configured PERS API client
- * @returns Analytics SDK with flattened structure for better DX
- */
-function createAnalyticsSDK(apiClient) {
-    const analyticsApi = new AnalyticsApi(apiClient);
-    const analyticsService = new AnalyticsService(analyticsApi);
-    return {
-        // Direct access to service methods (primary interface)
-        // Admin methods
-        getTransactionAnalytics: (request) => analyticsService.getTransactionAnalytics(request),
-        // Advanced access for edge cases
-        api: analyticsApi,
-        service: analyticsService
-    };
-}
-
-/**
- * Platform-Agnostic Campaign API Client (NEW - RESTful Design)
- *
- * Updated to use the new microservice-ready campaign controllers:
- * - CampaignsController: Core campaign operations
- * - CampaignTagsController: Tag management
- * - CampaignTokensController: Token unit operations
- * - CampaignTriggersController: Trigger system
- * - CampaignEngagementsController: Business relationships
- * - CampaignClaimsController: Claims processing
- *
- * Uses @explorins/pers-shared DTOs for consistency with backend.
- * All endpoints updated to new RESTful patterns without role revelation.
- */
-class CampaignApi {
-    constructor(apiClient) {
-        this.apiClient = apiClient;
-    }
-    // ==========================================
-    // CORE CAMPAIGN OPERATIONS (/campaigns)
-    // ==========================================
-    /**
-     * PUBLIC: Get all active campaigns
-     * NEW: /campaigns (intelligent access detection)
-     */
-    async getActiveCampaigns() {
-        return this.apiClient.get('/campaigns');
-    }
-    /**
-     * ADMIN: Get campaigns with filtering options
-     * NEW: /campaigns with query parameters (admin access detected automatically)
-     */
-    async getCampaigns(options) {
-        let url = '/campaigns';
-        const params = [];
-        if (options) {
-            if (options.active !== undefined)
-                params.push(`active=${options.active}`);
-            if (options.tag)
-                params.push(`tag=${encodeURIComponent(options.tag)}`);
-            if (options.limit)
-                params.push(`limit=${options.limit}`);
-            if (options.offset)
-                params.push(`offset=${options.offset}`);
-            if (options.sort)
-                params.push(`sort=${options.sort}`);
-            if (options.order)
-                params.push(`order=${options.order}`);
-        }
-        if (params.length > 0) {
-            url += `?${params.join('&')}`;
-        }
-        return this.apiClient.get(url);
-    }
-    /**
-     * PUBLIC: Get campaign by ID
-     * NEW: /campaigns/{id}
-     */
-    async getCampaignById(id) {
-        return this.apiClient.get(`/campaigns/${id}`);
-    }
-    /**
-     * ADMIN: Create campaign
-     * NEW: POST /campaigns
-     */
-    async createCampaign(campaign) {
-        return this.apiClient.post('/campaigns', campaign);
-    }
-    /**
-     * ADMIN: Update campaign
-     * NEW: PUT /campaigns/{id}
-     */
-    async updateCampaign(campaignId, campaign) {
-        return this.apiClient.put(`/campaigns/${campaignId}`, campaign);
-    }
-    /**
-     * ADMIN: Toggle campaign active status
-     * NEW: PUT /campaigns/{id}/status
-     */
-    async toggleCampaignActive(campaignId) {
-        return this.apiClient.put(`/campaigns/${campaignId}/status`, {});
-    }
-    /**
-     * ADMIN: Toggle campaign testnet environment
-     * NEW: PUT /campaigns/{id}/environment
-     */
-    async toggleCampaignTestnet(campaignId) {
-        return this.apiClient.put(`/campaigns/${campaignId}/environment`, {});
-    }
-    /**
-     * ADMIN: Delete campaign
-     * NEW: DELETE /campaigns/{id}
-     */
-    async deleteCampaign(campaignId) {
-        return this.apiClient.delete(`/campaigns/${campaignId}`);
-    }
-    // ==========================================
-    // TAG MANAGEMENT (/campaign-tags)
-    // ==========================================
-    /**
-     * ADMIN: Get all unique campaign tags
-     * NEW: GET /campaign-tags
-     */
-    async getAllUniqueTags() {
-        return this.apiClient.get('/campaign-tags');
-    }
-    /**
-     * ADMIN: Update campaign tags (replace all)
-     * NEW: PUT /campaign-tags/{id}
-     */
-    async updateCampaignTags(campaignId, tags) {
-        return this.apiClient.put(`/campaign-tags/${campaignId}`, { tags });
-    }
-    /**
-     * ADMIN: Add tags to campaign
-     * NEW: POST /campaign-tags/{id}
-     */
-    async addTagsToCampaign(campaignId, tags) {
-        return this.apiClient.post(`/campaign-tags/${campaignId}`, { tags });
-    }
-    /**
-     * ADMIN: Remove tag from campaign
-     * NEW: DELETE /campaign-tags/{id}/{tag}
-     */
-    async removeTagFromCampaign(campaignId, tag) {
-        return this.apiClient.delete(`/campaign-tags/${campaignId}/${encodeURIComponent(tag)}`);
-    }
-    // ==========================================
-    // TOKEN MANAGEMENT (/campaign-tokens)
-    // ==========================================
-    /**
-     * ADMIN: Create campaign token unit
-     * NEW: POST /campaign-tokens/{id}
-     */
-    async createCampaignTokenUnit(campaignId, campaignTokenUnit) {
-        return this.apiClient.post(`/campaign-tokens/${campaignId}`, campaignTokenUnit);
-    }
-    /**
-     * ADMIN: Update campaign token unit
-     * NEW: PUT /campaign-tokens/{id}/{tokenUnitId}
-     */
-    async updateCampaignTokenUnit(campaignId, tokenUnitId, campaignTokenUnit) {
-        return this.apiClient.put(`/campaign-tokens/${campaignId}/${tokenUnitId}`, campaignTokenUnit);
-    }
-    /**
-     * ADMIN: Delete campaign token unit
-     * NEW: DELETE /campaign-tokens/{id}/{tokenUnitId}
-     */
-    async deleteCampaignTokenUnit(campaignId, campaignTokenUnitId) {
-        return this.apiClient.delete(`/campaign-tokens/${campaignId}/${campaignTokenUnitId}`);
-    }
-    // ==========================================
-    // TRIGGER SYSTEM (/campaign-triggers)
-    // ==========================================
-    /**
-     * PUBLIC: Get campaign triggers catalog
-     * NEW: GET /campaign-triggers
-     */
-    async getCampaignTriggers() {
-        return this.apiClient.get('/campaign-triggers');
-    }
-    /**
-     * ADMIN: Create campaign trigger
-     * NEW: POST /campaign-triggers
-     */
-    async createCampaignTrigger(trigger) {
-        return this.apiClient.post('/campaign-triggers', trigger);
-    }
-    /**
-     * ADMIN: Update campaign trigger
-     * NEW: PUT /campaign-triggers/{id}
-     */
-    async updateCampaignTrigger(triggerId, trigger) {
-        return this.apiClient.put(`/campaign-triggers/${triggerId}`, trigger);
-    }
-    /**
-     * ADMIN: Delete campaign trigger
-     * NEW: DELETE /campaign-triggers/{id}
-     */
-    async deleteCampaignTrigger(triggerId) {
-        return this.apiClient.delete(`/campaign-triggers/${triggerId}`);
-    }
-    /**
-     * ADMIN: Set campaign trigger
-     * NEW: PUT /campaign-triggers/campaigns/{id}/trigger/{triggerId}
-     */
-    async setCampaignTrigger(campaignId, triggerId) {
-        return this.apiClient.put(`/campaign-triggers/campaigns/${campaignId}/trigger/${triggerId}`, {});
-    }
-    /**
-     * ADMIN: Create trigger condition
-     * NEW: POST /campaign-triggers/conditions
-     */
-    async createTriggerCondition(condition) {
-        return this.apiClient.post('/campaign-triggers/conditions', condition);
-    }
-    /**
-     * ADMIN: Update trigger condition
-     * NEW: PUT /campaign-triggers/conditions/{id}
-     */
-    async updateTriggerCondition(conditionId, condition) {
-        return this.apiClient.put(`/campaign-triggers/conditions/${conditionId}`, condition);
-    }
-    /**
-     * ADMIN: Add/Remove condition to trigger
-     * NEW: PUT /campaign-triggers/{triggerId}/condition/{conditionId}
-     */
-    async addOrRemoveConditionToTrigger(triggerId, conditionId) {
-        return this.apiClient.put(`/campaign-triggers/${triggerId}/condition/${conditionId}`, {});
-    }
-    // ==========================================
-    // BUSINESS ENGAGEMENTS (/campaign-engagements)
-    // ==========================================
-    /**
-     * ADMIN: Add business engagement to campaign
-     * NEW: POST /campaign-engagements/{id}
-     */
-    async addBusinessEngagementToCampaign(campaignId, campaignBusinessEngagement) {
-        return this.apiClient.post(`/campaign-engagements/${campaignId}`, campaignBusinessEngagement);
-    }
-    /**
-     * ADMIN: Update campaign business engagement
-     * NEW: PUT /campaign-engagements/{id}/{businessEngagementId}
-     */
-    async updateCampaignBusinessEngagement(campaignId, businessEngagementId, campaignBusinessEngagement) {
-        return this.apiClient.put(`/campaign-engagements/${campaignId}/${businessEngagementId}`, campaignBusinessEngagement);
-    }
-    /**
-     * ADMIN: Delete campaign business engagement
-     * NEW: DELETE /campaign-engagements/{id}/{businessEngagementId}
-     */
-    async deleteCampaignBusinessEngagement(campaignId, businessEngagementId) {
-        return this.apiClient.delete(`/campaign-engagements/${campaignId}/${businessEngagementId}`);
-    }
-    // ==========================================
-    // CLAIMS PROCESSING (/campaign-claims)
-    // ==========================================
-    /**
-     * USER: Claim campaign reward
-     * NEW: POST /campaign-claims/user
-     */
-    async claimCampaign(request) {
-        return this.apiClient.post('/campaign-claims', request);
-    }
-    /**
-     * USER: Get claims for logged user
-     * NEW: GET /campaign-claims/users/me
-     */
-    async getClaimsForLoggedUser() {
-        return this.apiClient.get('/campaign-claims/me');
-    }
-    /**
-   * ADMIN: Get all campaign claims
-   * Updated to use unified endpoint
-   */
-    async getCampaignClaims() {
-        // Admin context - no parameters needed for all claims
-        return this.apiClient.get('/campaign-claims');
-    }
-    /**
-     * ADMIN: Get campaign claims by campaign ID
-     * Updated to use query parameters
-     */
-    async getCampaignClaimsByCampaignId(campaignId) {
-        return this.apiClient.get(`/campaign-claims?campaignId=${campaignId}`);
-    }
-    /**
-     * ADMIN: Get campaign claims by user ID
-     * Updated to use query parameters
-     */
-    async getCampaignClaimsByUserId(userId) {
-        return this.apiClient.get(`/campaign-claims?userId=${userId}`);
-    }
-    /**
-     * ADMIN: Get campaign claims by business ID
-     * Updated to use query parameters
-     */
-    async getCampaignClaimsByBusinessId(businessId) {
-        return this.apiClient.get(`/campaign-claims?businessId=${businessId}`);
-    }
-    /**
-     * ADMIN: Get campaign claims by user ID for specific campaign
-     * Combined filtering using query parameters
-     */
-    async getCampaignClaimsByUserAndCampaign(userId, campaignId) {
-        return this.apiClient.get(`/campaign-claims?userId=${userId}&campaignId=${campaignId}`);
-    }
-    /**
-     * ADMIN: Get campaign claims by business ID for specific campaign
-     * Combined filtering using query parameters
-     */
-    async getCampaignClaimsByBusinessAndCampaign(businessId, campaignId) {
-        return this.apiClient.get(`/campaign-claims?businessId=${businessId}&campaignId=${campaignId}`);
-    }
-    /**
-     * USER: Get user's own claims (all campaigns)
-     * Use convenience endpoint
-     */
-    async getUserClaims() {
-        return this.apiClient.get('/campaign-claims/me');
-    }
-    /**
-     * USER: Get user's claims for specific campaign
-     * Use convenience endpoint with query parameter
-     */
-    async getUserClaimsForCampaign(campaignId) {
-        return this.apiClient.get(`/campaign-claims/me?campaignId=${campaignId}`);
-    }
-    /**
-     * BUSINESS: Get business claims (all campaigns)
-     * Uses unified endpoint with business context
-     */
-    async getBusinessClaims() {
-        return this.apiClient.get('/campaign-claims');
-    }
-    /**
-     * BUSINESS: Get business claims for specific campaign
-     * Uses unified endpoint with business context and campaign filter
-     */
-    async getBusinessClaimsForCampaign(campaignId) {
-        return this.apiClient.get(`/campaign-claims?campaignId=${campaignId}`);
-    }
-    /**
-   * Helper: Build query string from parameters
-   */
-    buildQueryString(params) {
-        const validParams = Object.entries(params)
-            .filter(([_, value]) => value !== undefined)
-            .map(([key, value]) => `${key}=${encodeURIComponent(value)}`)
-            .join('&');
-        return validParams ? `?${validParams}` : '';
-    }
-    /**
-     * Flexible admin claims query with multiple filters
-     */
-    async getAdminClaims(filters) {
-        const queryString = this.buildQueryString(filters || {});
-        return this.apiClient.get(`/campaign-claims${queryString}`);
-    }
-}
-
-/**
- * Platform-Agnostic Campaign Service
- *
- * Contains campaign business logic and operations that work across platforms.
- * No framework dependencies - pure TypeScript business logic.
- *
- * Focuses only on actual backend capabilities.
- */
-class CampaignService {
-    constructor(campaignApi) {
-        this.campaignApi = campaignApi;
-    }
-    // ==========================================
-    // PUBLIC OPERATIONS
-    // ==========================================
-    /**
-     * PUBLIC: Get all active campaigns
-     */
-    async getActiveCampaigns() {
-        return this.campaignApi.getActiveCampaigns();
-    }
-    /**
-     * PUBLIC: Get campaign by ID
-     */
-    async getCampaignById(id) {
-        return this.campaignApi.getCampaignById(id);
-    }
-    // ==========================================
-    // AUTHENTICATED OPERATIONS
-    // ==========================================
-    /**
-     * AUTH: Claim campaign
-     */
-    async claimCampaign(request) {
-        return this.campaignApi.claimCampaign(request);
-    }
-    /**
-     * AUTH: Get claims for logged user
-     */
-    async getClaimsForLoggedUser() {
-        return this.campaignApi.getClaimsForLoggedUser();
-    }
-    // ==========================================
-    // ADMIN OPERATIONS
-    // ==========================================
-    /**
-     * ADMIN: Get campaigns with optional active filter
-     */
-    async getCampaigns(active) {
-        return this.campaignApi.getCampaigns(active !== undefined ? { active } : undefined);
-    }
-    /**
-     * ADMIN: Get campaign triggers
-     */
-    async getCampaignTriggers() {
-        return this.campaignApi.getCampaignTriggers();
-    }
-    /**
-     * ADMIN: Toggle campaign active status
-     */
-    async toggleCampaignActive(campaignId) {
-        return this.campaignApi.toggleCampaignActive(campaignId);
-    }
-    /**
-     * ADMIN: Toggle campaign testnet environment
-     */
-    async toggleCampaignTestnet(campaignId) {
-        return this.campaignApi.toggleCampaignTestnet(campaignId);
-    }
-    /**
-     * ADMIN: Create campaign
-     */
-    async createCampaign(campaign) {
-        return this.campaignApi.createCampaign(campaign);
-    }
-    /**
-     * ADMIN: Set campaign trigger
-     */
-    async setCampaignTrigger(campaignId, triggerId) {
-        return this.campaignApi.setCampaignTrigger(campaignId, triggerId);
-    }
-    /**
-     * ADMIN: Update campaign
-     */
-    async updateCampaign(campaignId, campaign) {
-        return this.campaignApi.updateCampaign(campaignId, campaign);
-    }
-    /**
-     * ADMIN: Create campaign token unit
-     */
-    async createCampaignTokenUnit(campaignId, campaignTokenUnit) {
-        return this.campaignApi.createCampaignTokenUnit(campaignId, campaignTokenUnit);
-    }
-    /**
-     * ADMIN: Delete campaign token unit
-     */
-    async deleteCampaignTokenUnit(campaignId, campaignTokenUnitId) {
-        return this.campaignApi.deleteCampaignTokenUnit(campaignId, campaignTokenUnitId);
-    }
-    /**
-     * ADMIN: Add business engagement to campaign
-     */
-    async addBusinessEngagementToCampaign(campaignId, campaignBusinessEngagement) {
-        return this.campaignApi.addBusinessEngagementToCampaign(campaignId, campaignBusinessEngagement);
-    }
-    /**
-     * ADMIN: Update campaign business engagement
-     */
-    async updateCampaignBusinessEngagement(campaignId, businessEngagementId, campaignBusinessEngagement) {
-        return this.campaignApi.updateCampaignBusinessEngagement(campaignId, businessEngagementId, campaignBusinessEngagement);
-    }
-    async deleteCampaignBusinessEngagement(campaignId, businessEngagementId) {
-        return this.campaignApi.deleteCampaignBusinessEngagement(campaignId, businessEngagementId);
-    }
-    /**
-     * ADMIN: Get all campaign claims
-     */
-    async getCampaignClaims() {
-        return this.campaignApi.getCampaignClaims();
-    }
-    /**
-     * ADMIN: Get campaign claims by user ID
-     */
-    async getCampaignClaimsByUserId(userId) {
-        return this.campaignApi.getCampaignClaimsByUserId(userId);
-    }
-    /**
-     * ADMIN: Get campaign claims by business ID
-     */
-    async getCampaignClaimsByBusinessId(businessId) {
-        return this.campaignApi.getCampaignClaimsByBusinessId(businessId);
-    }
-}
-
-/**
- * @explorins/pers-sdk-campaign
- *
- * Platform-agnostic Campaign Domain SDK for PERS ecosystem
- * Handles campaign operations across different authorization levels
- */
-// API Layer
-/**
- * Create a complete Campaign SDK instance
- *
- * @param apiClient - Configured PERS API client
- * @returns Campaign SDK with flattened structure for better DX
- */
-function createCampaignSDK(apiClient) {
-    const campaignApi = new CampaignApi(apiClient);
-    const campaignService = new CampaignService(campaignApi);
-    return {
-        // Direct access to service methods (primary interface)
-        // Public methods
-        getActiveCampaigns: () => campaignService.getActiveCampaigns(),
-        getCampaignById: (id) => campaignService.getCampaignById(id),
-        // Auth methods
-        claimCampaign: (request) => campaignService.claimCampaign(request),
-        getClaimsForLoggedUser: () => campaignService.getClaimsForLoggedUser(),
-        // Admin methods
-        getCampaigns: (active) => campaignService.getCampaigns(active),
-        getCampaignTriggers: () => campaignService.getCampaignTriggers(),
-        toggleCampaignActive: (campaignId) => campaignService.toggleCampaignActive(campaignId),
-        toggleCampaignTestnet: (campaignId) => campaignService.toggleCampaignTestnet(campaignId),
-        createCampaign: (campaign) => campaignService.createCampaign(campaign),
-        setCampaignTrigger: (campaignId, triggerId) => campaignService.setCampaignTrigger(campaignId, triggerId),
-        updateCampaign: (campaignId, campaign) => campaignService.updateCampaign(campaignId, campaign),
-        createCampaignTokenUnit: (campaignId, campaignTokenUnit) => campaignService.createCampaignTokenUnit(campaignId, campaignTokenUnit),
-        deleteCampaignTokenUnit: (campaignId, campaignTokenUnitId) => campaignService.deleteCampaignTokenUnit(campaignId, campaignTokenUnitId),
-        addBusinessEngagementToCampaign: (campaignId, campaignBusinessEngagement) => campaignService.addBusinessEngagementToCampaign(campaignId, campaignBusinessEngagement),
-        updateCampaignBusinessEngagement: (campaignId, businessEngagementId, campaignBusinessEngagement) => campaignService.updateCampaignBusinessEngagement(campaignId, businessEngagementId, campaignBusinessEngagement),
-        deleteCampaignBusinessEngagement: (campaignId, businessEngagementId) => campaignService.deleteCampaignBusinessEngagement(campaignId, businessEngagementId),
-        getCampaignClaims: () => campaignService.getCampaignClaims(),
-        getCampaignClaimsByUserId: (userId) => campaignService.getCampaignClaimsByUserId(userId),
-        getCampaignClaimsByBusinessId: (businessId) => campaignService.getCampaignClaimsByBusinessId(businessId),
-        // Advanced access for edge cases
-        api: campaignApi,
-        service: campaignService
-    };
-}
-
-/**
- * Platform-Agnostic Donation API Client
- *
- * Handles donation operations using the PERS backend.
- * Matches framework DonationApiService methods exactly.
- */
-class DonationApi {
-    constructor(apiClient) {
-        this.apiClient = apiClient;
-    }
-    // ==========================================
-    // PUBLIC OPERATIONS
-    // ==========================================
-    /**
-     * PUBLIC: Get all donation types
-     * ✅ ONLY method actually used by framework
-     */
-    async getAllDonationTypes() {
-        return this.apiClient.get('/purchases/donation-types');
-    }
-}
-
-/**
- * Platform-Agnostic Donation Service
- *
- * Contains donation business logic and operations that work across platforms.
- * No framework dependencies - pure TypeScript business logic.
- * Matches framework DonationApiService capabilities exactly.
- */
-class DonationService {
-    constructor(donationApi) {
-        this.donationApi = donationApi;
-    }
-    // ==========================================
-    // PUBLIC OPERATIONS
-    // ==========================================
-    /**
-     * PUBLIC: Get all donation types
-     * ✅ ONLY method actually used by framework
-     */
-    async getAllDonationTypes() {
-        return this.donationApi.getAllDonationTypes();
-    }
-}
-
-/**
- * @explorins/pers-sdk-donation
- *
- * Platform-agnostic Donation Domain SDK for PERS ecosystem
- * Handles donation type retrieval for purchase flow integration
- */
-// API Layer
-/**
- * Create a complete Donation SDK instance
- *
- * @param apiClient - Configured PERS API client
- * @returns Donation SDK with flattened structure for better DX
- */
-function createDonationSDK(apiClient) {
-    const donationApi = new DonationApi(apiClient);
-    const donationService = new DonationService(donationApi);
-    return {
-        // Direct access to service methods (primary interface)
-        // ✅ FRAMEWORK ALIGNED: Only method actually used by framework
-        // Public methods
-        getAllDonationTypes: () => donationService.getAllDonationTypes(),
-        // Advanced access for edge cases
-        api: donationApi,
-        service: donationService
-    };
-}
-
-/**
- * Platform-Agnostic Purchase API Client (RESTful Architecture)
- *
- * Handles purchase and payment operations using the PERS backend's new RESTful endpoints.
- * Uses @explorins/pers-shared DTOs for consistency with backend.
- *
- * Migration Status: Updated to match /purchases controller (replaces /purchase endpoints)
- *
- * Available Access Levels:
- * - PUBLIC: Project key authentication for catalog browsing and payment operations
- * - USER: Requires user authentication JWT (purchase creation, history access)
- * - ADMIN: Requires tenant admin privileges (not implemented in this client)
- *
- * Note: This SDK focuses on backend purchase operations only.
- * Payment provider integrations (Stripe, etc.) should remain in infrastructure layer.
- */
-class PurchaseApi {
-    constructor(apiClient) {
-        this.apiClient = apiClient;
-        this.basePath = '/purchases';
-    }
-    // ==========================================
-    // PUBLIC OPERATIONS (Project Key)
-    // ==========================================
-    /**
-     * PUBLIC: Get purchase tokens (Intelligent Access)
-     *
-     * RESTful endpoint: GET /purchases/tokens
-     * Replaces: GET /purchase/token
-     *
-     * INTELLIGENT ACCESS:
-     * - PUBLIC (Project Key): Returns active tokens only (active parameter ignored)
-     * - ADMIN (Tenant Admin JWT): Returns filtered results based on active parameter
-     */
-    async getPurchaseTokens(active) {
-        let url = `${this.basePath}/tokens`;
-        if (active !== undefined) {
-            url += `?active=${active}`;
-        }
-        return this.apiClient.get(url);
-    }
-    /**
-     * PUBLIC: Get donation types
-     *
-     * RESTful endpoint: GET /purchases/donation-types
-     * Replaces: GET /purchase/donation/type
-     */
-    async getDonationTypes() {
-        return this.apiClient.get(`${this.basePath}/donation-types`);
-    }
-    // ==========================================
-    // PAYMENT OPERATIONS (FINANCIAL - CRITICAL)
-    // ==========================================
-    /**
-     * PUBLIC: Create payment intent (FINANCIAL OPERATION)
-     *
-     * RESTful endpoint: POST /purchases/payment-intents
-     * Replaces: POST /purchase/payment-intent
-     *
-     * CRITICAL: Handles real money operations - tenant context required
-     */
-    async createPaymentIntent(amount, currency, receiptEmail, description) {
-        const body = {
-            amount,
-            currency,
-            receiptEmail,
-            description
-        };
-        return this.apiClient.post(`${this.basePath}/payment-intents`, body);
-    }
-    /**
-     * PUBLIC: Update payment intent (FINANCIAL OPERATION)
-     *
-     * RESTful endpoint: PUT /purchases/payment-intents/{paymentIntentId}
-     * Replaces: PUT /purchase/payment-intent/{paymentIntentId}
-     *
-     * CRITICAL: Handles real money operations - tenant context required
-     */
-    async updatePaymentIntent(paymentIntentId, amount, currency, receiptEmail, description) {
-        const body = {
-            amount,
-            currency,
-            receiptEmail,
-            description
-        };
-        return this.apiClient.put(`${this.basePath}/payment-intents/${paymentIntentId}`, body);
-    }
-    /**
-     * PUBLIC: Cancel payment intent (FINANCIAL OPERATION)
-     *
-     * RESTful endpoint: DELETE /purchases/payment-intents/{paymentIntentId}
-     * Replaces: DELETE /purchase/payment-intent/{paymentIntentId}
-     *
-     * CRITICAL: Handles real money operations - tenant context required
-     */
-    async cancelPaymentIntent(paymentIntentId) {
-        return this.apiClient.delete(`${this.basePath}/payment-intents/${paymentIntentId}`);
-    }
-    // ==========================================
-    // USER OPERATIONS (JWT + Project Key)
-    // ==========================================
-    /**
-     * USER: Create purchase (BUSINESS CRITICAL - FINANCIAL TRANSACTION)
-     *
-     * RESTful endpoint: POST /purchases
-     * Replaces: POST /purchase/auth
-     *
-     * USER-ONLY: Requires user authentication JWT for purchase creation
-     * CRITICAL: Real financial transaction with Stripe integration
-     */
-    async createUserPurchase(paymentIntentId, amount, purchaseTokenId, donationTypeId, donationAccountAddress) {
-        const body = {
-            quantity: amount,
-            purchaseTokenId: purchaseTokenId || '',
-            donationTypeId,
-            donationAccountAddress,
-            paymentIntentId
-        };
-        return this.apiClient.post(`${this.basePath}`, body);
-    }
-    /**
-     * USER: Get user purchase history
-     *
-     * RESTful endpoint: GET /purchases/me/history
-     * Replaces: GET /purchase/auth
-     *
-     * USER-ONLY: Get authenticated user's purchase history
-     * FINANCIAL RECORDS: User attribution critical for compliance
-     */
-    async getUserPurchaseHistory() {
-        return this.apiClient.get(`${this.basePath}/me/history`);
-    }
-    // ==========================================
-    // CONVENIENCE METHODS (Backward Compatibility)
-    // ==========================================
-    /**
-     * @deprecated Use getPurchaseTokens() instead
-     * Backward compatibility alias for getActivePurchaseTokens
-     */
-    async getActivePurchaseTokens(active = true) {
-        return this.getPurchaseTokens(active);
-    }
-    /**
-     * @deprecated Use createUserPurchase() instead
-     * Backward compatibility alias for createPurchase
-     */
-    async createPurchase(paymentIntentId, amount, purchaseTokenId, donationTypeId, donationAccountAddress) {
-        return this.createUserPurchase(paymentIntentId, amount, purchaseTokenId, donationTypeId, donationAccountAddress);
-    }
-    /**
-     * @deprecated Use getUserPurchaseHistory() instead
-     * Backward compatibility alias for getAllUserPurchases
-     */
-    async getAllUserPurchases() {
-        return this.getUserPurchaseHistory();
-    }
-}
-
-/**
- * Platform-Agnostic Payment Service
- *
- * Contains payment business logic and operations that work across platforms.
- * No framework dependencies - pure TypeScript business logic.
- *
- * Focuses only on actual backend capabilities.
- * Payment provider logic (Stripe, etc.) should remain in infrastructure layer.
- */
-class PaymentService {
-    constructor(paymentApi) {
-        this.paymentApi = paymentApi;
-    }
-    // ==========================================
-    // PUBLIC OPERATIONS
-    // ==========================================
-    /**
-     * PUBLIC: Get active purchase tokens
-     */
-    async getActivePurchaseTokens(active = true) {
-        return this.paymentApi.getActivePurchaseTokens(active);
-    }
-    /**
-     * PUBLIC: Create payment intent
-     */
-    async createPaymentIntent(amount, currency, receiptEmail, description) {
-        return this.paymentApi.createPaymentIntent(amount, currency, receiptEmail, description);
-    }
-    /**
-     * PUBLIC: Update payment intent
-     */
-    async updatePaymentIntent(paymentIntentId, amount, currency, receiptEmail, description) {
-        return this.paymentApi.updatePaymentIntent(paymentIntentId, amount, currency, receiptEmail, description);
-    }
-    /**
-     * PUBLIC: Cancel payment intent
-     */
-    async cancelPaymentIntent(paymentIntentId) {
-        return this.paymentApi.cancelPaymentIntent(paymentIntentId);
-    }
-    // ==========================================
-    // AUTHENTICATED OPERATIONS
-    // ==========================================
-    /**
-     * AUTH: Create purchase
-     */
-    async createPurchase(paymentIntentId, amount, purchaseTokenId, donationTypeId, donationAccountAddress) {
-        return this.paymentApi.createPurchase(paymentIntentId, amount, purchaseTokenId, donationTypeId, donationAccountAddress);
-    }
-    /**
-     * AUTH: Get all user purchases
-     */
-    async getAllUserPurchases() {
-        return this.paymentApi.getAllUserPurchases();
-    }
-}
-
-/**
- * @explorins/pers-sdk-payment
- *
- * Platform-agnostic Payment Domain SDK for PERS ecosystem
- * Handles payment intents, purchases, and purchase tokens
- *
- * Note: Payment provider integrations (Stripe, etc.) are kept separate
- * in the infrastructure layer to maintain platform-agnostic principles.
- */
-// API Layer
-/**
- * Create a complete Payment SDK instance
- *
- * @param apiClient - Configured PERS API client
- * @returns Payment SDK with flattened structure for better DX
- */
-function createPaymentSDK(apiClient) {
-    const paymentApi = new PurchaseApi(apiClient);
-    const paymentService = new PaymentService(paymentApi);
-    return {
-        // Direct access to service methods (primary interface)
-        // Public methods
-        getActivePurchaseTokens: (active) => paymentService.getActivePurchaseTokens(active),
-        // ✅ FIXED: Proper type instead of any
-        createPaymentIntent: (amount, currency, receiptEmail, description) => paymentService.createPaymentIntent(amount, currency, receiptEmail, description),
-        // ✅ FIXED: Proper type instead of any
-        updatePaymentIntent: (paymentIntentId, amount, currency, receiptEmail, description) => paymentService.updatePaymentIntent(paymentIntentId, amount, currency, receiptEmail, description),
-        cancelPaymentIntent: (paymentIntentId) => paymentService.cancelPaymentIntent(paymentIntentId),
-        // Auth methods
-        createPurchase: (paymentIntentId, amount, purchaseTokenId, donationTypeId, donationAccountAddress) => paymentService.createPurchase(paymentIntentId, amount, purchaseTokenId, donationTypeId, donationAccountAddress),
-        getAllUserPurchases: () => paymentService.getAllUserPurchases(),
-        // Advanced access for edge cases
-        api: paymentApi,
-        service: paymentService
-    };
-}
-
-/**
- * Platform-Agnostic Redemption API Client (UPDATED - RESTful Design)
- *
- * Updated to work with the new RESTful /redemptions and /redemption-redeems endpoints.
- * Handles redemption operations using the PERS backend with intelligent access detection.
- * Uses @explorins/pers-shared DTOs for consistency with backend.
- *
- * Migration Update: Updated all endpoints for unified controller pattern
- * - Removed role revelation from URLs (no more /admin, /auth paths)
- * - Added intelligent access detection for unified endpoints
- * - Added new /redemption-redeems endpoints for redeem processing
- * - Enhanced redemption process with role-based access control
- */
-class RedemptionApi {
-    constructor(apiClient) {
-        this.apiClient = apiClient;
-        this.basePath = '/redemptions';
-        this.redeemsPath = '/redemption-redeems';
-    }
-    // ==========================================
-    // PUBLIC OPERATIONS (Project Key)
-    // ==========================================
-    /**
-     * UNIFIED: Get redemptions with intelligent access control
-     *
-     * Intelligent endpoint that adapts based on authentication:
-     * - Public users: Get active redemptions only
-     * - Admin users: Get all redemptions with optional filtering
-     *
-     * @param options.active - Filter by active status (undefined = all for admins/active for public)
-     * @param options.adminAccess - Force admin access (requires admin auth)
-     */
-    async getRedemptions(options) {
-        let url = `${this.basePath}`;
-        if (options?.active !== undefined) {
-            url += `?active=${options.active}`;
-        }
-        return this.apiClient.get(url);
-    }
-    /**
-     * PUBLIC: Get redemption types
-     *
-     * Updated: /redemption/type → /redemptions/types
-     */
-    async getRedemptionTypes() {
-        return this.apiClient.get(`/redemption-types`);
-    }
-    /**
-     * PUBLIC: Get redemption by ID
-     *
-     * Updated: /redemption/:id → /redemptions/:id
-     */
-    async getRedemptionById(id) {
-        return this.apiClient.get(`${this.basePath}/${id}`);
-    }
-    /**
-     * PUBLIC: Get available supply for redemption
-     *
-     * Updated: /redemption/:id/available-supply → /redemptions/:id/supply
-     */
-    async getRedemptionAvailableSupply(id) {
-        return this.apiClient.get(`${this.basePath}/${id}/supply`);
-    }
-    // ==========================================
-    // REDEMPTION EXECUTION (NEW UNIFIED ENDPOINT)
-    // ==========================================
-    /**
-     * Execute redemption (unified endpoint)
-     *
-     * NEW: POST /redemption-redeems - Role-based processing
-     * - USER: Direct user redemption processing
-     * - ADMIN: Can process redemptions for any account type
-     * - BUSINESS: Process redemptions for customers
-     */
-    async redeemRedemption(redemptionId) {
-        const body = {
-            redemptionId: redemptionId,
-        };
-        return this.apiClient.post(this.redeemsPath, body);
-    }
-    // ==========================================
-    // REDEMPTION REDEEMS QUERIES (NEW ENDPOINTS)
-    // ==========================================
-    /**
-     * UNIFIED: Get redemption redeems with filtering and intelligent access
-     *
-     * Role-based access with unified filtering:
-     * - Users: See only their own redeems (userId/businessId filters ignored)
-     * - Admins: Can filter by userId, businessId, or redemptionId
-     *
-     * @param filters.redemptionId - Filter by specific redemption
-     * @param filters.userId - Admin only: Filter by user ID
-     * @param filters.businessId - Admin only: Filter by business ID
-     * @param filters.myRedeems - Force user's own redeems (uses /me endpoint)
-     */
-    async getRedemptionRedeems(filters) {
-        // Use convenience endpoint for user's own redeems
-        if (filters?.myRedeems) {
-            let url = `${this.redeemsPath}/me`;
-            if (filters.redemptionId) {
-                url += `?redemptionId=${filters.redemptionId}`;
-            }
-            return this.apiClient.get(url);
-        }
-        // Use admin endpoint with filtering
-        let url = this.redeemsPath;
-        const params = new URLSearchParams();
-        if (filters?.redemptionId)
-            params.append('redemptionId', filters.redemptionId);
-        if (filters?.userId)
-            params.append('userId', filters.userId);
-        if (filters?.businessId)
-            params.append('businessId', filters.businessId);
-        const queryString = params.toString();
-        if (queryString) {
-            url += `?${queryString}`;
-        }
-        return this.apiClient.get(url);
-    }
-    /**
-     * UNIFIED: Get specific redemption redeem by ID
-     */
-    async getRedemptionRedeemById(id) {
-        return this.apiClient.get(`${this.redeemsPath}/${id}`);
-    }
-    // ==========================================
-    // USER OPERATIONS (JWT + Project Key)
-    // ==========================================
-    /**
-     * UNIFIED: Get user redemption history
-     *
-     * Uses convenience endpoint /redemption-redeems/me with optional filtering
-     * @param redemptionId - Optional filter by specific redemption
-     */
-    async getUserRedeems(redemptionId) {
-        return this.getRedemptionRedeems({ myRedeems: true, redemptionId });
-    }
-    // ==========================================
-    // ADMIN OPERATIONS (Tenant Admin JWT)
-    // ==========================================
-    /**
-     * ADMIN: Get redemptions with filtering (using intelligent endpoint)
-     *
-     * Updated: /redemption/admin → /redemptions (intelligent access detection)
-     * The unified endpoint will detect admin privileges and allow filtering
-     */
-    async getRedemptionsAsAdmin(active) {
-        return this.getRedemptions({ active, adminAccess: true });
-    }
-    /**
-     * ADMIN: Create redemption
-     *
-     * Updated: /redemption/admin → /redemptions
-     */
-    async createRedemption(redemption) {
-        return this.apiClient.post(`${this.basePath}`, redemption);
-    }
-    /**
-     * ADMIN: Update redemption
-     *
-     * Updated: /redemption/admin/:id → /redemptions/:id
-     */
-    async updateRedemption(id, redemptionCreateRequest) {
-        return this.apiClient.put(`${this.basePath}/${id}`, redemptionCreateRequest);
-    }
-    /**
-     * UNIFIED: Toggle redemption active status
-     *
-     * Updated: /redemption/admin/:id/toggle-active → /redemptions/:id/status
-     * Following standard /status pattern used across domains
-     */
-    async toggleRedemptionActive(redemptionId) {
-        return this.apiClient.put(`${this.basePath}/${redemptionId}/status`, {});
-    }
-    /**
-     * ADMIN: Delete redemption
-     *
-     * Updated: /redemption/admin/:id → /redemptions/:id
-     */
-    async deleteRedemption(id) {
-        return this.apiClient.delete(`${this.basePath}/${id}`);
-    }
-    /**
-     * ADMIN: Create redemption type
-     *
-     * Updated: /redemption/admin/type → /redemptions/types
-     */
-    async createRedemptionType(redemptionType) {
-        return this.apiClient.post(`${this.basePath}/redemption-types`, redemptionType);
-    }
-    // ==========================================
-    // TOKEN UNIT MANAGEMENT (Admin)
-    // ==========================================
-    /**
-     * ADMIN: Create redemption token unit
-     *
-     * Updated: /redemption/admin/:id/token-units → /redemptions/:id/token-units
-     */
-    async createRedemptionTokenUnit(redemptionId, redemptionTokenUnit) {
-        return this.apiClient.post(`${this.basePath}/${redemptionId}/token-units`, redemptionTokenUnit);
-    }
-    /**
-     * ADMIN: Update redemption token unit
-     *
-     * Updated: /redemption/admin/:id/token-units/:tokenUnitId → /redemptions/:id/token-units/:tokenUnitId
-     */
-    async updateRedemptionTokenUnit(redemptionId, tokenUnitId, redemptionTokenUnit) {
-        return this.apiClient.put(`${this.basePath}/${redemptionId}/token-units/${tokenUnitId}`, redemptionTokenUnit);
-    }
-    /**
-     * ADMIN: Delete redemption token unit
-     *
-     * Updated: /redemption/admin/:id/token-units/:tokenUnitId → /redemptions/:id/token-units/:tokenUnitId
-     */
-    async deleteRedemptionTokenUnit(redemptionId, redemptionTokenUnitId) {
-        return this.apiClient.delete(`${this.basePath}/${redemptionId}/token-units/${redemptionTokenUnitId}`);
-    }
-    // ==========================================
-    // CONVENIENCE METHODS (Legacy Support)
-    // ==========================================
-    /**
-     * Convenience: Get active redemptions (public access)
-     */
-    async getActiveRedemptions() {
-        return this.getRedemptions({ active: true });
-    }
-}
-
-/**
- * Platform-Agnostic Redemption Service
- *
- * Contains redemption business logic and operations that work across platforms.
- * No framework dependencies - pure TypeScript business logic.
- *
- * Focuses only on actual backend capabilities.
- */
-class RedemptionService {
-    constructor(redemptionApi) {
-        this.redemptionApi = redemptionApi;
-    }
-    // ==========================================
-    // PUBLIC OPERATIONS
-    // ==========================================
-    /**
-     * UNIFIED: Get redemptions with intelligent access control
-     * @param options.active - Filter by active status
-     * @param options.adminAccess - Force admin access
-     */
-    async getRedemptions(options) {
-        return this.redemptionApi.getRedemptions(options);
-    }
-    /**
-     * Convenience: Get active redemptions (public)
-     */
-    async getActiveRedemptions() {
-        return this.redemptionApi.getActiveRedemptions();
-    }
-    /**
-     * PUBLIC: Get redemption types
-     */
-    async getRedemptionTypes() {
-        return this.redemptionApi.getRedemptionTypes();
-    }
-    // ==========================================
-    // AUTHENTICATED OPERATIONS
-    // ==========================================
-    /**
-     * AUTH: Redeem a redemption
-     */
-    async redeemRedemption(redemptionId) {
-        return this.redemptionApi.redeemRedemption(redemptionId);
-    }
-    /**
-     * UNIFIED: Get redemption redeems with filtering
-     */
-    async getRedemptionRedeems(filters) {
-        return this.redemptionApi.getRedemptionRedeems(filters);
-    }
-    /**
-     * Convenience: Get user redemptions
-     */
-    async getUserRedeems() {
-        return this.redemptionApi.getUserRedeems();
-    }
-    // ==========================================
-    // ADMIN OPERATIONS
-    // ==========================================
-    /**
-     * Convenience: Get redemptions as admin
-     */
-    async getRedemptionsAsAdmin(active) {
-        return this.redemptionApi.getRedemptionsAsAdmin(active);
-    }
-    /**
-     * ADMIN: Create redemption
-     */
-    async createRedemption(redemption) {
-        return this.redemptionApi.createRedemption(redemption);
-    }
-    /**
-     * ADMIN: Update redemption
-     */
-    async updateRedemption(id, redemptionCreateRequest) {
-        return this.redemptionApi.updateRedemption(id, redemptionCreateRequest); // ✅ CORRECTED: Fixed parameter
-    }
-    /**
-     * ADMIN: Toggle redemption active status
-     */
-    async toggleRedemptionActive(redemptionId) {
-        return this.redemptionApi.toggleRedemptionActive(redemptionId);
-    }
-    /**
-     * ADMIN: Create redemption token unit
-     */
-    async createRedemptionTokenUnit(redemptionId, redemptionTokenUnit) {
-        return this.redemptionApi.createRedemptionTokenUnit(redemptionId, redemptionTokenUnit);
-    }
-    /**
-     * ADMIN: Delete redemption token unit
-     */
-    async deleteRedemptionTokenUnit(redemptionId, redemptionTokenUnitId) {
-        return this.redemptionApi.deleteRedemptionTokenUnit(redemptionId, redemptionTokenUnitId);
-    }
-}
-
-/**
- * @explorins/pers-sdk-redemption
- *
- * Platform-agnostic Redemption Domain SDK for PERS ecosystem
- * Handles redemption operations across different authorization levels
- */
-// API Layer
-/**
- * Create a complete Redemption SDK instance
- *
- * @param apiClient - Configured PERS API client
- * @returns Redemption SDK with flattened structure for better DX
- */
-function createRedemptionSDK(apiClient) {
-    const redemptionApi = new RedemptionApi(apiClient);
-    const redemptionService = new RedemptionService(redemptionApi);
-    return {
-        // Direct access to service methods (primary interface)
-        // Public methods
-        getActiveRedemptions: () => redemptionService.getActiveRedemptions(),
-        getRedemptionTypes: () => redemptionService.getRedemptionTypes(),
-        // Auth methods
-        redeemRedemption: (redemptionId) => redemptionService.redeemRedemption(redemptionId),
-        getUserRedeems: () => redemptionService.getUserRedeems(),
-        // Admin methods
-        getRedemptionsAsAdmin: (active) => redemptionService.getRedemptionsAsAdmin(active),
-        createRedemption: (redemption) => redemptionService.createRedemption(redemption),
-        updateRedemption: (id, redemptionCreateRequest) => redemptionService.updateRedemption(id, redemptionCreateRequest),
-        toggleRedemptionActive: (redemptionId) => redemptionService.toggleRedemptionActive(redemptionId),
-        createRedemptionTokenUnit: (redemptionId, redemptionTokenUnit) => redemptionService.createRedemptionTokenUnit(redemptionId, redemptionTokenUnit),
-        deleteRedemptionTokenUnit: (redemptionId, redemptionTokenUnitId) => redemptionService.deleteRedemptionTokenUnit(redemptionId, redemptionTokenUnitId),
-        // Advanced access for edge cases
-        api: redemptionApi,
-        service: redemptionService
-    };
-}
-
-/**
- * Platform-Agnostic Tenant API Client
- *
- * Handles tenant and admin operations using the PERS backend.
- * Matches framework TenantApiService methods exactly.
- *
- * Note: Special header handling (bypass-auth-interceptor) should be handled by PersApiClient internally
- * or through endpoint-specific configuration.
- */
-class TenantApi {
-    constructor(apiClient) {
-        this.apiClient = apiClient;
-        this.basePath = '/tenants';
-        this.adminPath = '/admins';
-    }
-    // ==========================================
-    // PUBLIC OPERATIONS
-    // ==========================================
-    /**
-     * PUBLIC: Get tenant public information
-     * ✅ FIXED: Matches framework cache busting pattern exactly
-     */
-    async getRemoteTenant() {
-        const timestamp = Date.now().toString();
-        const url = `${this.basePath}/public?date=${timestamp}`;
-        return this.apiClient.get(url);
-    }
-    /**
-     * PUBLIC: Get remote login token
-     */
-    async getRemoteLoginToken() {
-        return this.apiClient.get(`${this.basePath}/login-token`);
-    }
-    /**
-     * PUBLIC: Get remote client configuration
-     * ✅ FIXED: Removed second parameter - PersApiClient handles bypass auth internally
-     * Note: The /tenants/client-config endpoint should be configured to bypass auth at the API client level
-     */
-    async getRemoteClientConfig() {
-        return this.apiClient.get(`${this.basePath}/client-config`);
-    }
-    // ==========================================
-    // ADMIN OPERATIONS
-    // ==========================================
-    /**
-     * ADMIN: Update tenant information
-     * ✅ FIXED: Uses TenantPublicDTO directly like framework
-     */
-    async updateRemoteTenant(tenantData) {
-        return this.apiClient.put(`${this.basePath}`, tenantData);
-    }
-    /**
-     * ADMIN: Get all tenant admins
-     */
-    async getAdmins() {
-        return this.apiClient.get(`${this.adminPath}`);
-    }
-    /**
-     * ADMIN: Create new admin
-     * ✅ FIXED: Renamed to match framework postAdmin method
-     */
-    async postAdmin(adminData) {
-        return this.apiClient.post(`${this.adminPath}`, adminData);
-    }
-    /**
-     * ADMIN: Update admin (toggle tenant association)
-     * ✅ FIXED: Renamed to match framework putAdmin method
-     */
-    async putAdmin(adminId, adminData) {
-        return this.apiClient.put(`${this.adminPath}/${adminId}/tenant`, adminData);
-    }
-}
-
-/**
- * Platform-Agnostic Tenant Service
- *
- * Contains tenant business logic and operations that work across platforms.
- * No framework dependencies - pure TypeScript business logic.
- * Matches framework TenantApiService capabilities exactly.
- */
-class TenantService {
-    constructor(tenantApi) {
-        this.tenantApi = tenantApi;
-    }
-    // ==========================================
-    // PUBLIC OPERATIONS
-    // ==========================================
-    /**
-     * PUBLIC: Get tenant public information
-     */
-    async getRemoteTenant() {
-        return this.tenantApi.getRemoteTenant();
-    }
-    /**
-     * PUBLIC: Get remote login token
-     */
-    async getRemoteLoginToken() {
-        return this.tenantApi.getRemoteLoginToken();
-    }
-    /**
-     * PUBLIC: Get remote client configuration
-     */
-    async getRemoteClientConfig() {
-        return this.tenantApi.getRemoteClientConfig();
-    }
-    // ==========================================
-    // ADMIN OPERATIONS
-    // ==========================================
-    /**
-     * ADMIN: Update tenant information
-     * ✅ FIXED: Uses TenantPublicDTO directly like framework
-     */
-    async updateRemoteTenant(tenantData) {
-        return this.tenantApi.updateRemoteTenant(tenantData);
-    }
-    /**
-     * ADMIN: Get all tenant admins
-     */
-    async getAdmins() {
-        return this.tenantApi.getAdmins();
-    }
-    /**
-     * ADMIN: Create new admin
-     * ✅ FIXED: Renamed to match framework postAdmin method
-     */
-    async postAdmin(adminData) {
-        return this.tenantApi.postAdmin(adminData);
-    }
-    /**
-     * ADMIN: Update admin (toggle tenant association)
-     * ✅ FIXED: Renamed to match framework putAdmin method
-     */
-    async putAdmin(adminId, adminData) {
-        return this.tenantApi.putAdmin(adminId, adminData);
-    }
-}
-
-/**
- * @explorins/pers-sdk-tenant
- *
- * Platform-agnostic Tenant Domain SDK for PERS ecosystem
- * Handles tenant management and admin operations for multi-tenant architecture
- */
-// API Layer
-/**
- * Create a complete Tenant SDK instance
- *
- * @param apiClient - Configured PERS API client
- * @returns Tenant SDK with flattened structure for better DX
- */
-function createTenantSDK(apiClient) {
-    const tenantApi = new TenantApi(apiClient);
-    const tenantService = new TenantService(tenantApi);
-    return {
-        // Direct access to service methods (primary interface)
-        // ✅ FRAMEWORK ALIGNED: Only methods actually used by framework
-        // Public methods
-        getRemoteTenant: () => tenantService.getRemoteTenant(),
-        getRemoteLoginToken: () => tenantService.getRemoteLoginToken(),
-        getRemoteClientConfig: () => tenantService.getRemoteClientConfig(),
-        // Admin methods - ✅ FIXED: Matches framework method names exactly
-        updateRemoteTenant: (tenantData) => tenantService.updateRemoteTenant(tenantData),
-        getAdmins: () => tenantService.getAdmins(),
-        postAdmin: (adminData) => tenantService.postAdmin(adminData),
-        putAdmin: (adminId, adminData) => tenantService.putAdmin(adminId, adminData),
-        // Advanced access for edge cases
-        api: tenantApi,
-        service: tenantService
-    };
-}
-
-class TokenApi {
-    constructor(apiClient) {
-        this.apiClient = apiClient;
-        this.basePath = '/tokens';
-    }
-    // ==========================================
-    // PUBLIC OPERATIONS
-    // ==========================================
-    /**
-     * PUBLIC: Get all remote tokens
-     * ENHANCED: Added admin filtering capability
-     */
-    async getRemoteTokens(includeInactive = false) {
-        const url = includeInactive ? `${this.basePath}?active=false` : `${this.basePath}`;
-        return this.apiClient.get(url);
-    }
-    /**
-     * PUBLIC: Get all remote token types
-     */
-    async getRemoteTokenTypes() {
-        return this.apiClient.get(`${this.basePath}/types`);
-    }
-    /**
-     * PUBLIC: Get active point token (was credit token)
-     */
-    async getRemoteActiveCreditToken() {
-        return this.apiClient.get(`${this.basePath}/points`);
-    }
-    /**
-     * PUBLIC: Get reward tokens
-     * ENHANCED: Added admin filtering capability
-     */
-    async getRemoteRewardTokens(includeInactive = false) {
-        const url = includeInactive ? `${this.basePath}/rewards?active=false` : `${this.basePath}/rewards`;
-        return this.apiClient.get(url);
-    }
-    /**
-     * PUBLIC: Get stamp tokens (was status tokens)
-     * ENHANCED: Added admin filtering capability
-     */
-    async getRemoteStatusTokens(includeInactive = false) {
-        const url = includeInactive ? `${this.basePath}/stamps?active=false` : `${this.basePath}/stamps`;
-        return this.apiClient.get(url);
-    }
-    /**
-     * PUBLIC: Get token by contract address
-     */
-    async getTokenByContractAddress(contractAddress, contractTokenId) {
-        let url = `${this.basePath}/address/${contractAddress}`;
-        if (contractTokenId) {
-            url += `?contractTokenId=${contractTokenId}`;
-        }
-        return this.apiClient.get(url);
-    }
-    // ==========================================
-    // ADMIN OPERATIONS
-    // ==========================================
-    /**
-     * ADMIN: Create new token
-     */
-    async createToken(tokenData) {
-        return this.apiClient.post(`${this.basePath}`, tokenData);
-    }
-    /**
-     * ADMIN: Update token
-     */
-    async updateToken(tokenId, tokenData) {
-        return this.apiClient.put(`${this.basePath}/${tokenId}`, tokenData);
-    }
-    /**
-     * ADMIN: Toggle token active status
-     * FIXED: Now calls correct endpoint
-     */
-    async toggleTokenActive(tokenId) {
-        return this.apiClient.put(`${this.basePath}/${tokenId}/status`, {});
-    }
-    /**
-     * ADMIN: Set mainnet contract address
-     */
-    async setMainnetContract(tokenId, contractAddress, chainId) {
-        return this.apiClient.put(`${this.basePath}/${tokenId}/mainnet`, {
-            contractAddress,
-            chainId
-        });
-    }
-    /**
-     * ADMIN: Create token metadata
-     */
-    async createTokenMetadata(tokenId, tokenData) {
-        return this.apiClient.post(`${this.basePath}/${tokenId}/metadata`, tokenData);
-    }
-    /**
-     * ADMIN: Toggle token metadata status (separate from token status)
-     */
-    async toggleTokenMetadataStatus(metadataId) {
-        return this.apiClient.put(`${this.basePath}/metadata/${metadataId}/status`, {});
-    }
-    /**
-     * ADMIN: Create token type
-     */
-    async createTokenType(tokenType) {
-        return this.apiClient.post(`${this.basePath}/types`, tokenType);
-    }
-}
-
-/**
- * Platform-Agnostic Token Service
- *
- * Contains token business logic and operations that work across platforms.
- * No framework dependencies - pure TypeScript business logic.
- * Matches framework TokenApiService capabilities exactly.
- */
-class TokenService {
-    constructor(tokenApi) {
-        this.tokenApi = tokenApi;
-    }
-    // ==========================================
-    // PUBLIC OPERATIONS
-    // ==========================================
-    /**
-     * PUBLIC: Get all remote tokens
-     */
-    async getRemoteTokens() {
-        return this.tokenApi.getRemoteTokens();
-    }
-    /**
-     * PUBLIC: Get all remote token types
-     */
-    async getRemoteTokenTypes() {
-        return this.tokenApi.getRemoteTokenTypes();
-    }
-    /**
-     * PUBLIC: Get active credit token
-     */
-    async getRemoteActiveCreditToken() {
-        return this.tokenApi.getRemoteActiveCreditToken();
-    }
-    /**
-     * PUBLIC: Get reward tokens
-     */
-    async getRemoteRewardTokens() {
-        return this.tokenApi.getRemoteRewardTokens();
-    }
-    /**
-     * PUBLIC: Get status tokens
-     */
-    async getRemoteStatusTokens() {
-        return this.tokenApi.getRemoteStatusTokens();
-    }
-    /**
-     * PUBLIC: Get token by contract address
-     * ✅ FIXED: Matches framework parameter types exactly
-     */
-    async getTokenByContractAddress(contractAddress, contractTokenId) {
-        return this.tokenApi.getTokenByContractAddress(contractAddress, contractTokenId);
-    }
-    // ==========================================
-    // ADMIN OPERATIONS
-    // ==========================================
-    /**
-     * ADMIN: Create token metadata
-     */
-    async createTokenMetadata(tokenId, tokenData) {
-        return this.tokenApi.createTokenMetadata(tokenId, tokenData);
-    }
-    /**
-     * ADMIN: Toggle token active status
-     */
-    async toggleTokenActive(tokenId) {
-        return this.tokenApi.toggleTokenActive(tokenId);
-    }
-    /**
-     * ADMIN: Create new token
-     */
-    async createToken(tokenData) {
-        return this.tokenApi.createToken(tokenData);
-    }
-    /**
-     * ADMIN: Update token
-     */
-    async updateToken(tokenId, tokenData) {
-        return this.tokenApi.updateToken(tokenId, tokenData);
-    }
-    /**
-     * ADMIN: Set mainnet contract address
-     */
-    async setMainnetContract(tokenId, contractAddress, chainId) {
-        return this.tokenApi.setMainnetContract(tokenId, contractAddress, chainId);
-    }
-    /**
-     * ADMIN: Toggle token metadata status
-     */
-    async toggleTokenMetadataStatus(metadataId) {
-        return this.tokenApi.toggleTokenMetadataStatus(metadataId);
-    }
-    /**
-     * ADMIN: Create token type
-     */
-    async createTokenType(tokenType) {
-        return this.tokenApi.createTokenType(tokenType);
-    }
-}
-
-/**
- * Token SDK - Class-based Promise SDK for Token Operations
- *
- * Modern, performant SDK with direct method access and excellent TypeScript support.
- * Optimized for bundle size, performance, and developer experience.
- *
- * Usage:
- *   const tokenSDK = new TokenSDK(apiClient);
- *   const tokens = await tokenSDK.getTokens();
- *   const creditToken = await tokenSDK.getActiveCreditToken();
- */
-class TokenSDK {
-    constructor(apiClient) {
-        this.tokenApi = new TokenApi(apiClient);
-        this.tokenService = new TokenService(this.tokenApi);
-    }
-    // ==========================================
-    // CONVENIENCE METHODS - Direct Promise API
-    // ==========================================
-    // Simplified method names for better developer experience
-    /**
-     * Get all tokens
-     * @returns Promise with all available tokens
-     */
-    async getTokens() {
-        return this.tokenService.getRemoteTokens();
-    }
-    /**
-     * Get all token types
-     * @returns Promise with all available token types
-     */
-    async getTokenTypes() {
-        return this.tokenService.getRemoteTokenTypes();
-    }
-    /**
-     * Get the active credit token
-     * @returns Promise with the current active credit token
-     */
-    async getActiveCreditToken() {
-        return this.tokenService.getRemoteActiveCreditToken();
-    }
-    /**
-     * Get all reward tokens
-     * @returns Promise with all reward tokens
-     */
-    async getRewardTokens() {
-        return this.tokenService.getRemoteRewardTokens();
-    }
-    /**
-     * Get all status tokens
-     * @returns Promise with all status tokens
-     */
-    async getStatusTokens() {
-        return this.tokenService.getRemoteStatusTokens();
-    }
-    /**
-     * Get token by contract address
-     * @param contractAddress - The contract address to search for
-     * @param contractTokenId - Optional contract token ID
-     * @returns Promise with the matching token
-     */
-    async getTokenByContract(contractAddress, contractTokenId = null) {
-        return this.tokenService.getTokenByContractAddress(contractAddress, contractTokenId);
-    }
-    // ==========================================
-    // ADMIN METHODS - Token Management
-    // ==========================================
-    /**
-     * Create token metadata
-     * @param tokenId - The token ID
-     * @param tokenData - The token storage data
-     * @returns Promise with the updated token
-     */
-    async createTokenMetadata(tokenId, tokenData) {
-        return this.tokenService.createTokenMetadata(tokenId, tokenData);
-    }
-    /**
-     * Toggle token active status
-     * @param tokenId - The token ID to toggle
-     * @returns Promise with the updated token
-     */
-    async toggleTokenActive(tokenId) {
-        return this.tokenService.toggleTokenActive(tokenId);
-    }
-    /**
-     * Create a new token
-     * @param tokenData - The token creation data
-     * @returns Promise with the created token
-     */
-    async createToken(tokenData) {
-        return this.tokenService.createToken(tokenData);
-    }
-    /**
-     * Update an existing token
-     * @param tokenId - The token ID to update
-     * @param tokenData - The token update data
-     * @returns Promise with the updated token
-     */
-    async updateToken(tokenId, tokenData) {
-        return this.tokenService.updateToken(tokenId, tokenData);
-    }
-    /**
-     * Set mainnet contract address for a token
-     * @param tokenId - The token ID
-     * @param contractAddress - The contract address
-     * @param chainId - The blockchain chain ID
-     * @returns Promise with the updated token
-     */
-    async setMainnetContract(tokenId, contractAddress, chainId) {
-        return this.tokenService.setMainnetContract(tokenId, contractAddress, chainId);
-    }
-    /**
-     * Toggle token metadata status
-     * @param metadataId - The metadata ID to toggle
-     * @returns Promise with the updated metadata
-     */
-    async toggleTokenMetadataStatus(metadataId) {
-        return this.tokenService.toggleTokenMetadataStatus(metadataId);
-    }
-    /**
-     * Create a new token type
-     * @param tokenType - The token type data
-     * @returns Promise with the created token type
-     */
-    async createTokenType(tokenType) {
-        return this.tokenService.createTokenType(tokenType);
-    }
-    // ==========================================
-    // ADVANCED ACCESS - For Complex Operations
-    // ==========================================
-    /**
-     * Get direct access to the token service for advanced operations
-     * @returns The underlying TokenService instance
-     */
-    getTokenService() {
-        return this.tokenService;
-    }
-    /**
-     * Get direct access to the token API for low-level operations
-     * @returns The underlying TokenApi instance
-     */
-    getTokenApi() {
-        return this.tokenApi;
-    }
-    // ==========================================
-    // FRAMEWORK COMPATIBILITY METHODS
-    // ==========================================
-    // These maintain compatibility with existing framework method names
-    /**
-     * @deprecated Use getTokens() instead
-     * Framework compatibility method
-     */
-    async getRemoteTokens() {
-        return this.getTokens();
-    }
-    /**
-     * @deprecated Use getTokenTypes() instead
-     * Framework compatibility method
-     */
-    async getRemoteTokenTypes() {
-        return this.getTokenTypes();
-    }
-    /**
-     * @deprecated Use getActiveCreditToken() instead
-     * Framework compatibility method
-     */
-    async getRemoteActiveCreditToken() {
-        return this.getActiveCreditToken();
-    }
-    /**
-     * @deprecated Use getRewardTokens() instead
-     * Framework compatibility method
-     */
-    async getRemoteRewardTokens() {
-        return this.getRewardTokens();
-    }
-    /**
-     * @deprecated Use getStatusTokens() instead
-     * Framework compatibility method
-     */
-    async getRemoteStatusTokens() {
-        return this.getStatusTokens();
-    }
-    /**
-     * @deprecated Use getTokenByContract() instead
-     * Framework compatibility method
-     */
-    async getTokenByContractAddress(contractAddress, contractTokenId) {
-        return this.getTokenByContract(contractAddress, contractTokenId);
-    }
-}
-
-/**
- * Abstract Base Token Service - Explicit Initialization Pattern
- *
- * Platform-agnostic token operations with Promise-based API.
- * Framework services extend this and control initialization lifecycle.
- *
- * Benefits:
- * - Explicit initialization control
- * - Better error boundaries
- * - Clear lifecycle management
- * - Testable initialization state
- * - Zero framework dependencies
- */
-class BaseTokenService {
-    constructor() {
-        this._isInitialized = false;
-    }
-    // ==========================================
-    // INITIALIZATION LIFECYCLE
-    // ==========================================
-    /**
-     * LIFECYCLE: Initialize token service with API client
-     * Must be called before using any token operations
-     */
-    initializeTokenService(apiClient) {
-        if (!apiClient) {
-            throw new Error('Cannot initialize TokenService: apiClient is null or undefined');
-        }
-        if (!this._isInitialized) {
-            this._tokenApi = new TokenApi(apiClient);
-            this._tokenBusinessService = new TokenService(this._tokenApi);
-            this._isInitialized = true;
-        }
-    }
-    /**
-     * LIFECYCLE: Check if token service is initialized
-     */
-    get isTokenServiceInitialized() {
-        return this._isInitialized;
-    }
-    /**
-     * INTERNAL: Get token business service (throws if not initialized)
-     */
-    get tokenBusinessService() {
-        if (!this._tokenBusinessService) {
-            throw new Error('TokenService not initialized. Call initializeTokenService(apiClient) first.');
-        }
-        return this._tokenBusinessService;
-    }
-    // ==========================================
-    // PUBLIC OPERATIONS
-    // ==========================================
-    /**
-     * PUBLIC: Get all remote tokens
-     */
-    getRemoteTokens() {
-        return this.tokenBusinessService.getRemoteTokens();
-    }
-    /**
-     * PUBLIC: Get all remote token types
-     */
-    getRemoteTokenTypes() {
-        return this.tokenBusinessService.getRemoteTokenTypes();
-    }
-    /**
-     * PUBLIC: Get active credit token
-     */
-    getRemoteActiveCreditToken() {
-        return this.tokenBusinessService.getRemoteActiveCreditToken();
-    }
-    /**
-     * PUBLIC: Get reward tokens
-     */
-    getRemoteRewardTokens() {
-        return this.tokenBusinessService.getRemoteRewardTokens();
-    }
-    /**
-     * PUBLIC: Get status tokens
-     */
-    getRemoteStatusTokens() {
-        return this.tokenBusinessService.getRemoteStatusTokens();
-    }
-    /**
-     * PUBLIC: Get token by contract address
-     */
-    getTokenByContractAddress(contractAddress, contractTokenId) {
-        return this.tokenBusinessService.getTokenByContractAddress(contractAddress, contractTokenId);
-    }
-    // ==========================================
-    // ADMIN OPERATIONS
-    // ==========================================
-    /**
-     * ADMIN: Create token metadata
-     */
-    createTokenMetadata(tokenId, tokenData) {
-        return this.tokenBusinessService.createTokenMetadata(tokenId, tokenData);
-    }
-    /**
-     * ADMIN: Toggle token active status
-     */
-    toggleTokenActive(tokenId) {
-        return this.tokenBusinessService.toggleTokenActive(tokenId);
-    }
-    /**
-     * ADMIN: Create new token
-     */
-    createToken(tokenData) {
-        return this.tokenBusinessService.createToken(tokenData);
-    }
-    /**
-     * ADMIN: Update token
-     */
-    updateToken(tokenId, tokenData) {
-        return this.tokenBusinessService.updateToken(tokenId, tokenData);
-    }
-    /**
-     * ADMIN: Set mainnet contract address
-     */
-    setMainnetContract(tokenId, contractAddress, chainId) {
-        return this.tokenBusinessService.setMainnetContract(tokenId, contractAddress, chainId);
-    }
-    /**
-     * ADMIN: Toggle token metadata status
-     */
-    toggleTokenMetadataStatus(metadataId) {
-        return this.tokenBusinessService.toggleTokenMetadataStatus(metadataId);
-    }
-    /**
-     * ADMIN: Create token type
-     */
-    createTokenType(tokenType) {
-        return this.tokenBusinessService.createTokenType(tokenType);
-    }
-}
-
-/**
- * Platform-Agnostic User API Client
- *
- * Handles user operations using the PERS backend RESTful API.
- * Updated to use new /users endpoints with enhanced security and consistency.
- * Maintains framework UserApiService method compatibility.
- */
-class UserApi {
-    constructor(apiClient) {
-        this.apiClient = apiClient;
-        this.basePath = '/users';
-    }
-    // ==========================================
-    // PUBLIC OPERATIONS
-    // ==========================================
-    /**
-     * PUBLIC: Get all users public profiles with optional filtering
-     * ✅ UPDATED: Uses new RESTful /users/public endpoint
-     */
-    async getAllUsersPublicProfiles(filter = null) {
-        let url = `${this.basePath}/public`;
-        if (filter) {
-            // ✅ MAINTAINED: Same parameter pattern for compatibility
-            const params = new URLSearchParams();
-            params.set('filterKey', filter.key);
-            params.set('filterValue', filter.value);
-            url += `?${params.toString()}`;
-        }
-        return this.apiClient.get(url);
-    }
-    // ==========================================
-    // AUTHENTICATED OPERATIONS
-    // ==========================================
-    /**
-     * AUTH: Get current authenticated user
-     * ✅ UPDATED: Uses new RESTful /users/me endpoint
-     */
-    async getRemoteUser() {
-        return this.apiClient.get(`${this.basePath}/me`);
-    }
-    /**
-     * AUTH: Update current authenticated user
-     * ✅ UPDATED: Uses new RESTful /users/me endpoint
-     */
-    async updateRemoteUser(updateRequest) {
-        return this.apiClient.put(`${this.basePath}/me`, updateRequest);
-    }
-    // ==========================================
-    // ADMIN OPERATIONS
-    // ==========================================
-    /**
-     * ADMIN: Get all remote users with query parameters
-     * ✅ UPDATED: Uses new RESTful /users endpoint with role-based access
-     * Note: Admin users get full data, non-admin users get public profiles only
-     */
-    async getAllRemoteUsers() {
-        // ✅ MAINTAINED: Same merge=soft parameter for compatibility
-        const url = `${this.basePath}?merge=soft`;
-        return this.apiClient.get(url);
-    }
-    /**
-     * ADMIN: Update user as admin
-     * ✅ UPDATED: Uses new RESTful /users/{id} endpoint
-     */
-    async updateUserAsAdmin(id, userData) {
-        return this.apiClient.put(`${this.basePath}/${id}`, userData);
-    }
-    /**
-     * ADMIN: Toggle user active status
-     * ✅ UPDATED: Uses new consistent /users/{id}/status endpoint
-     * Enhanced: Follows RESTful status management pattern across all domains
-     */
-    async toggleUserActiveStatusByUser(user) {
-        return this.apiClient.put(`${this.basePath}/${user.id}/status`, {});
-    }
-    /**
-     * ADMIN: Get user by unique identifier
-     * ✅ UPDATED: Uses new RESTful /users/{id} endpoint
-     */
-    async getUserByUniqueIdentifier(id) {
-        return this.apiClient.get(`${this.basePath}/${id}`);
-    }
-}
-
-/**
- * Platform-Agnostic User Service
- *
- * Contains user business logic and operations that work across platforms.
- * No framework dependencies - pure TypeScript business logic.
- * Matches framework UserApiService capabilities exactly.
- */
-class UserService {
-    constructor(userApi) {
-        this.userApi = userApi;
-    }
-    // ==========================================
-    // PUBLIC OPERATIONS
-    // ==========================================
-    /**
-     * PUBLIC: Get all users public profiles with optional filtering
-     * ✅ FIXED: Uses framework-compatible inline filter type
-     */
-    async getAllUsersPublicProfiles(filter = null) {
-        return this.userApi.getAllUsersPublicProfiles(filter);
-    }
-    // ==========================================
-    // AUTHENTICATED OPERATIONS
-    // ==========================================
-    /**
-     * AUTH: Get current authenticated user
-     */
-    async getRemoteUser() {
-        return this.userApi.getRemoteUser();
-    }
-    /**
-     * AUTH: Update current authenticated user
-     */
-    async updateRemoteUser(updateRequest) {
-        return this.userApi.updateRemoteUser(updateRequest);
-    }
-    // ==========================================
-    // ADMIN OPERATIONS
-    // ==========================================
-    /**
-     * ADMIN: Get all remote users
-     * ✅ FIXED: Matches API method signature (no parameters needed)
-     */
-    async getAllRemoteUsers() {
-        return this.userApi.getAllRemoteUsers();
-    }
-    /**
-     * ADMIN: Update user as admin
-     */
-    async updateUserAsAdmin(id, userData) {
-        return this.userApi.updateUserAsAdmin(id, userData);
-    }
-    async getUserByUniqueIdentifier(id) {
-        return this.userApi.getUserByUniqueIdentifier(id);
-    }
-    /**
-     * ADMIN: Toggle user active status by user object
-     * ✅ FIXED: Matches API method signature exactly
-     */
-    async toggleUserActiveStatusByUser(user) {
-        return this.userApi.toggleUserActiveStatusByUser(user);
-    }
-}
-
-/**
- * @explorins/pers-sdk-user
- *
- * Platform-agnostic User Domain SDK for PERS ecosystem
- * Handles user management, profiles, and authentication operations
- */
-// API Layer
-/**
- * Create a complete User SDK instance
- *
- * @param apiClient - Configured PERS API client
- * @returns User SDK with flattened structure for better DX
- */
-function createUserSDK(apiClient) {
-    const userApi = new UserApi(apiClient);
-    const userService = new UserService(userApi);
-    return {
-        // Direct access to service methods (primary interface)
-        // Public methods - matches framework exactly
-        getAllUsersPublicProfiles: (filter = null) => userService.getAllUsersPublicProfiles(filter),
-        // Auth methods - matches framework exactly
-        getRemoteUser: () => userService.getRemoteUser(),
-        updateRemoteUser: (updateRequest) => userService.updateRemoteUser(updateRequest),
-        // Admin methods - matches framework exactly
-        getAllRemoteUsers: () => userService.getAllRemoteUsers(),
-        updateUserAsAdmin: (id, userData) => userService.updateUserAsAdmin(id, userData),
-        toggleUserActiveStatusByUser: (user) => userService.toggleUserActiveStatusByUser(user),
-        getUserByUniqueIdentifier: (id) => userService.getUserByUniqueIdentifier(id),
-        // Advanced access for edge cases
-        api: userApi,
-        service: userService
-    };
-}
-
-/**
- * Platform-Agnostic User Status API Client
- *
- * Handles user status operations using the PERS backend.
- * Matches framework UserStatusApiService methods exactly.
- *
- * ✅ UPDATED: All endpoints updated to new RESTful /users patterns
- *
- * Error handling patterns follow framework implementation:
- * - getRemoteEarnedUserStatus() uses silent fallback (empty array)
- * - Other operations throw errors for proper error handling
- */
-class UserStatusApi {
-    constructor(apiClient) {
-        this.apiClient = apiClient;
-        this.basePath = '/users';
-    }
-    // ==========================================
-    // PUBLIC OPERATIONS
-    // ==========================================
-    /**
-     * PUBLIC: Get remote user status types
-     * ✅ UPDATED: /user/status-type → /users/status-types
-     */
-    async getRemoteUserStatusTypes() {
-        try {
-            return await this.apiClient.get(`${this.basePath}/status-types`);
-        }
-        catch (error) {
-            console.error('Error getting user status types', error);
-            throw error;
-        }
-    }
-    // ==========================================
-    // AUTHENTICATED OPERATIONS
-    // ==========================================
-    /**
-     * AUTH: Get earned user status for authenticated user
-     * ✅ UPDATED: /user/auth/status → /users/me/status
-     * ✅ FIXED: Returns UserStatusTypeDTO[] to match framework exactly
-     * Note: Uses silent fallback pattern from framework - returns empty array on error
-     */
-    async getRemoteEarnedUserStatus() {
-        try {
-            return await this.apiClient.get(`${this.basePath}/me/status`);
-        }
-        catch (error) {
-            console.error('Error getting user status', error);
-            // ✅ FIXED: Silent fallback pattern from framework implementation
-            return [];
-        }
-    }
-    // ==========================================
-    // ADMIN OPERATIONS
-    // ==========================================
-    /**
-     * ADMIN: Create user status type
-     * ✅ UPDATED: /user/admin/status-type → /users/status-types
-     */
-    async createUserStatusType(userStatusType) {
-        try {
-            return await this.apiClient.post(`${this.basePath}/status-types`, userStatusType);
-        }
-        catch (error) {
-            console.error('Error creating user status type', error);
-            throw error;
-        }
-    }
-}
-
-/**
- * Platform-Agnostic User Status Service
- *
- * Contains user status business logic and operations that work across platforms.
- * No framework dependencies - pure TypeScript business logic.
- * Matches framework UserStatusApiService capabilities exactly.
- */
-class UserStatusService {
-    constructor(userStatusApi) {
-        this.userStatusApi = userStatusApi;
-    }
-    // ==========================================
-    // PUBLIC OPERATIONS
-    // ==========================================
-    /**
-     * PUBLIC: Get remote user status types
-     */
-    async getRemoteUserStatusTypes() {
-        return this.userStatusApi.getRemoteUserStatusTypes();
-    }
-    // ==========================================
-    // AUTHENTICATED OPERATIONS
-    // ==========================================
-    /**
-     * AUTH: Get earned user status for authenticated user
-     */
-    async getRemoteEarnedUserStatus() {
-        return this.userStatusApi.getRemoteEarnedUserStatus();
-    }
-    // ==========================================
-    // ADMIN OPERATIONS
-    // ==========================================
-    /**
-     * ADMIN: Create user status type
-     */
-    async createUserStatusType(userStatusType) {
-        return this.userStatusApi.createUserStatusType(userStatusType);
-    }
-}
-
-/**
- * @explorins/pers-sdk-user-status
- *
- * Platform-agnostic User Status Domain SDK for PERS ecosystem
- * Handles user status management and type operations
- */
-// API Layer
-/**
- * Create a complete User Status SDK instance
- *
- * @param apiClient - Configured PERS API client
- * @returns User Status SDK with flattened structure for better DX
- */
-function createUserStatusSDK(apiClient) {
-    const userStatusApi = new UserStatusApi(apiClient);
-    const userStatusService = new UserStatusService(userStatusApi);
-    return {
-        // Direct access to service methods (primary interface)
-        // ✅ FRAMEWORK ALIGNED: Only methods actually used by framework
-        // Public methods
-        getRemoteUserStatusTypes: () => userStatusService.getRemoteUserStatusTypes(),
-        // Auth methods
-        getRemoteEarnedUserStatus: () => userStatusService.getRemoteEarnedUserStatus(),
-        // Admin methods
-        createUserStatusType: (userStatusType) => userStatusService.createUserStatusType(userStatusType),
-        // Advanced access for edge cases
-        api: userStatusApi,
-        service: userStatusService
-    };
-}
-
-/**
- * Platform-Agnostic Web3 Chain API Client
- *
- * Handles blockchain chain operations using the PERS backend.
- * Uses @explorins/web3-ts types for perfect framework compatibility.
- */
-class Web3ChainApi {
-    constructor(apiClient) {
-        this.apiClient = apiClient;
-        this.basePath = '/chains';
-    }
-    // ==========================================
-    // PUBLIC OPERATIONS
-    // ==========================================
-    /**
-     * PUBLIC: Get chain data by chain ID
-     * ✅ Returns ChainData exactly as framework expects from @explorins/web3-ts
-     */
-    async getChainData(chainId) {
-        try {
-            console.log('🔍 [Web3ChainApi] Fetching chain data for chainId:', chainId);
-            const response = await this.apiClient.get(`${this.basePath}/${chainId}`);
-            if (!response) {
-                throw new Error(`No chain data received for chainId: ${chainId}`);
-            }
-            return response;
-        }
-        catch (error) {
-            console.error('❌ [Web3ChainApi] Failed to get chain data:', {
-                chainId,
-                error: error instanceof Error ? error.message : String(error)
-            });
-            throw error;
-        }
-    }
-}
-
-const isTokenExpired = (token, margin = 60) => {
-    // ✅ SANITIZE: Remove any words (Bearer etc) if exists and get the token
-    const cleanToken = token.split(' ')[1] || token;
-    // ✅ VALIDATION: Check if token is jwt
-    if (!cleanToken || cleanToken.split('.').length !== 3) {
-        return true; // Consider invalid tokens as expired
-    }
-    try {
-        // ✅ TYPE-SAFE: Decode with proper typing
-        const decoded = jwtDecode(cleanToken);
-        const currentTime = Math.floor(Date.now() / 1000);
-        // ✅ CONFIGURABLE: Use provided margin (default 60 seconds)
-        return decoded.exp < (currentTime + margin);
-    }
-    catch (error) {
-        console.error('[SDK JWT Utils] Error decoding JWT token:', error);
-        return true; // Consider unparseable tokens as expired
-    }
-};
-
-class Web3ChainService {
-    constructor(web3ChainApi, providerService) {
-        this.web3ChainApi = web3ChainApi;
-        this.providerService = providerService;
-        this.web3InstanceCache = new Map();
-    }
-    async getWeb3ByChainId(chainId) {
-        const cached = this.web3InstanceCache.get(chainId);
-        // ✅ SMART CACHE: Check if cache is valid based on token expiration
-        if (cached && !this.checkIsTokenExpired(cached.chainData.authHeader)) {
-            console.log(`♻️ [Web3ChainService] Using cached Web3 instance for chain ${chainId}`);
-            return cached.web3Instance;
-        }
-        // ✅ CREATE WITH ERROR RECOVERY: Handle auth errors gracefully
-        try {
-            console.log(`🔧 [Web3ChainService] Creating new Web3 instance for chain ${chainId}`);
-            const { web3, chainData } = await this.createWeb3Instance(chainId);
-            // ✅ CACHE NEW INSTANCE
-            this.web3InstanceCache.set(chainId, {
-                web3Instance: web3,
-                chainData: chainData,
-                createdAt: Date.now(),
-                chainId
-            });
-            return web3;
-        }
-        catch (error) {
-            // ✅ AUTH ERROR RECOVERY: Clear cache and retry once
-            if (this.isAuthError(error)) {
-                console.warn(`🔄 [Web3ChainService] Auth error detected, clearing cache and retrying...`);
-                this.web3InstanceCache.delete(chainId);
-                // Retry once with fresh instance
-                const { web3, chainData } = await this.createWeb3Instance(chainId);
-                this.web3InstanceCache.set(chainId, {
-                    web3Instance: web3,
-                    chainData: chainData,
-                    createdAt: Date.now(),
-                    chainId
-                });
-                return web3;
-            }
-            throw error;
-        }
-    }
-    async getChainDataWithCache(chainId) {
-        const cached = this.web3InstanceCache.get(chainId);
-        //const now = Date.now();
-        if (cached && !this.checkIsTokenExpired(cached.chainData.authHeader)) {
-            console.log(`♻️ [Web3ChainService] Using cached ChainData for chain ${chainId}`);
-            return cached.chainData;
-        }
-        // If not cached, fetch fresh data
-        const chainData = await this.getChainDataById(chainId);
-        if (!chainData) {
-            throw new Error(`Chain data not found for chainId: ${chainId}`);
-        }
-        return chainData;
-    }
-    checkIsTokenExpired(authHeader) {
-        // ✅ NULL CHECK: Handle undefined case
-        if (!authHeader) {
-            return false; // No token means no expiration (public chains)
-        }
-        // ✅ FUNCTION CALL: Use imported function, not method
-        return isTokenExpired(authHeader);
-    }
-    async createWeb3Instance(chainId) {
-        const chainData = await this.getChainDataById(chainId);
-        if (!chainData) {
-            throw new Error(`Chain data not found for chainId: ${chainId}`);
-        }
-        // ✅ CRITICAL CHECK: Ensure authHeader is present for private chains
-        if (chainData.chainType === 'PRIVATE' && !chainData.authHeader) {
-            console.error('❌ [Web3ChainService] CRITICAL: Private chain missing authHeader!');
-            throw new Error(`Private chain ${chainId} missing authentication header`);
-        }
-        const web3 = await this.providerService.getWeb3(chainId, chainData.chainType || 'PUBLIC', chainData);
-        return { web3, chainData };
-    }
-    // ✅ HELPER: Type-safe error checking
-    isAuthError(error) {
-        const message = error instanceof Error ? error.message.toLowerCase() : String(error).toLowerCase();
-        return (message.includes('unauthorized') ||
-            message.includes('401') ||
-            message.includes('token expired') ||
-            message.includes('invalid token'));
-    }
-    async getChainDataById(chainId) {
-        try {
-            return await this.web3ChainApi.getChainData(chainId);
-        }
-        catch (error) {
-            console.error('❌ [SDK Web3ChainService] Error getting chain data for chainId:', chainId, error);
-            return null;
-        }
-    }
-}
-
-// ✅ REVERT: Función síncrona como el código comentado que funciona
-const getWeb3ProviderFromChainData = (chainData, timeout = 15000, customUserAgentName = '', tokenRefresher) => {
-    console.log(`🔧 [getWeb3FCD] Creating provider for chain ${chainData.chainId || 'unknown'}`);
-    let ethersProvider;
-    if (chainData.authHeader) {
-        // ✅ AUTHENTICATED: For private chains
-        const fetchRequest = new FetchRequest(chainData.rpcUrl);
-        fetchRequest.timeout = timeout;
-        // ✅ IMPROVED AUTH HEADER: Better handling
-        const authValue = chainData.authHeader.startsWith('Bearer ')
-            ? chainData.authHeader
-            : `Bearer ${chainData.authHeader}`;
-        fetchRequest.setHeader('Authorization', authValue);
-        fetchRequest.setHeader('Content-Type', 'application/json');
-        fetchRequest.setHeader('Accept', 'application/json');
-        if (customUserAgentName) {
-            fetchRequest.setHeader('User-Agent', customUserAgentName);
-        }
-        ethersProvider = new JsonRpcProvider(fetchRequest, undefined, {
-            staticNetwork: false,
-            polling: false,
-            batchMaxCount: 1, // ✅ DISABLE BATCHING: Better for private chains
-        });
-    }
-    else {
-        // ✅ PUBLIC: For public chains
-        ethersProvider = new JsonRpcProvider(chainData.rpcUrl, undefined, {
-            staticNetwork: false,
-            polling: false,
-        });
-    }
-    console.log(`✅ [getWeb3FCD] Provider created successfully`);
-    return {
-        web3Provider: null,
-        ethersProvider: ethersProvider,
-        isAuthenticated: !!chainData.authHeader,
-    };
-};
-// ✅ NEW: Async wrapper with retry for higher-level usage
-const getWeb3ProviderWithRetry = async (chainData, timeout = 15000, customUserAgentName = '', tokenRefresher, retryConfig = { maxAttempts: 3, baseDelay: 1000, maxDelay: 8000 }) => {
-    let lastError = null;
-    for (let attempt = 1; attempt <= retryConfig.maxAttempts; attempt++) {
-        try {
-            console.log(`🔄 [Web3Provider] Attempt ${attempt}/${retryConfig.maxAttempts} for chain ${chainData.chainId || 'unknown'}`);
-            // ✅ SYNC CALL: Use the original sync function
-            const provider = getWeb3ProviderFromChainData(chainData, timeout, customUserAgentName, tokenRefresher);
-            await validateChainConnection(provider.ethersProvider, chainData.authHeader ? 'private' : 'public');
-            console.log(`✅ [Web3Provider] Successfully connected on attempt ${attempt}`);
-            return provider;
-        }
-        catch (error) {
-            lastError = error instanceof Error ? error : new Error(String(error));
-            console.warn(`⚠️ [Web3Provider] Attempt ${attempt} failed:`, lastError.message);
-            // ✅ NO RETRY: if auth error, no retry
-            if (isAuthError(lastError) && chainData.authHeader) {
-                console.error(`❌ [Web3Provider] Auth error, stopping retries`);
-                break;
-            }
-            if (attempt === retryConfig.maxAttempts)
-                break;
-            const delay = Math.min(retryConfig.baseDelay * Math.pow(2, attempt - 1), retryConfig.maxDelay);
-            console.log(`⏳ [Web3Provider] Retrying in ${delay}ms...`);
-            await sleep(delay);
-        }
-    }
-    throw new Error(`Failed to create Web3 provider after ${retryConfig.maxAttempts} attempts. Last error: ${lastError?.message}`);
-};
-async function validateChainConnection(provider, chainType) {
-    try {
-        console.log(`🔍 [Validation] Testing ${chainType} chain connection...`);
-        // ✅ LIGHTWEIGHT TEST: Use eth_chainId (works for both public and private)
-        const timeoutPromise = new Promise((_, reject) => {
-            setTimeout(() => reject(new Error(`${chainType} chain validation timeout`)), 3000);
-        });
-        // Try chainId first (fast, lightweight, universal)
-        const chainIdPromise = provider.send('eth_chainId', []);
-        const result = await Promise.race([chainIdPromise, timeoutPromise]);
-        console.log(`✅ [Validation] ${chainType} chain connection validated - Chain ID: ${result}`);
-    }
-    catch (error) {
-        // ✅ FALLBACK: Try net_version if chainId fails
-        try {
-            console.log(`🔄 [Validation] Trying fallback validation for ${chainType} chain...`);
-            const timeoutPromise = new Promise((_, reject) => {
-                setTimeout(() => reject(new Error(`${chainType} chain fallback validation timeout`)), 3000);
-            });
-            const versionPromise = provider.send('net_version', []);
-            const result = await Promise.race([versionPromise, timeoutPromise]);
-            console.log(`✅ [Validation] ${chainType} chain connection validated via fallback - Network Version: ${result}`);
-        }
-        catch (fallbackError) {
-            throw new Error(`${chainType} chain validation failed: ${error instanceof Error ? error.message : String(error)}`);
-        }
-    }
-}
-// ✅ HELPER: Auth error detection
-function isAuthError(error) {
-    const message = error.message.toLowerCase();
-    return (message.includes('unauthorized') ||
-        message.includes('401') ||
-        message.includes('token expired') ||
-        message.includes('-40100'));
-}
-// ✅ HELPER: Sleep utility
-function sleep(ms) {
-    return new Promise(resolve => setTimeout(resolve, ms));
-}
-/*
-//IMPORTANT//
-//This function is temporary so we install ethers just to make it work, once we delete this function we must uninstall Ethers
-
-import { ChainData } from "@explorins/web3-ts";
-import { FetchRequest, JsonRpcProvider } from "ethers";
-
-export const getWeb3ProviderFromChainData = (
-  chainData: ChainData,
-  timeout = 15000,
-  customUserAgentName = '',
-  tokenRefresher?: () => Promise<string>
-) => {
-
-  // Fixed ethers provider setup for authenticated requests
-  let ethersProvider: JsonRpcProvider;
-
-  if (chainData.authHeader) {
-    // For authenticated requests, create a custom FetchRequest
-    const fetchRequest = new FetchRequest(chainData.rpcUrl);
-    fetchRequest.timeout = timeout;
-    fetchRequest.setHeader('Authorization', chainData.authHeader);
-    fetchRequest.setHeader('Content-Type', 'application/json');
-
-    if (customUserAgentName) {
-      fetchRequest.setHeader('User-Agent', customUserAgentName);
-    }
-
-    // Create provider with the configured FetchRequest
-    ethersProvider = new JsonRpcProvider(fetchRequest, undefined, {
-      staticNetwork: false,
-      polling: false, // Disable polling for better Lambda performance
-    });
-  } else {
-    // For public chains, use simple URL-based provider
-    ethersProvider = new JsonRpcProvider(chainData.rpcUrl, undefined, {
-      staticNetwork: false,
-      polling: false,
-    });
-  }
-
-  return {
-    web3Provider: null,
-    ethersProvider: ethersProvider,
-    isAuthenticated: !!chainData.authHeader,
-  };
-}; */
-
-class Web3ProviderService {
-    constructor() {
-        this._web3 = null;
-        this._currentChainId = null;
-        this._creationPromise = null;
-    }
-    async getWeb3(chainId, chainType, chainData) {
-        // ✅ EARLY RETURN: Reuse existing provider
-        if (this._web3 && this._currentChainId === chainId) {
-            return this._web3;
-        }
-        // ✅ PREVENT RACE CONDITION: Wait for ongoing creation
-        if (this._creationPromise) {
-            return await this._creationPromise;
-        }
-        if (!chainId)
-            throw new Error('ChainId not found');
-        if (!chainData)
-            throw new Error('ChainData not found');
-        // ✅ CREATE AND CACHE: Single promise for concurrent calls
-        this._creationPromise = this.createProvider(chainId, chainType, chainData);
-        try {
-            const web3Instance = await this._creationPromise;
-            this._web3 = web3Instance;
-            this._currentChainId = chainId;
-            return web3Instance;
-        }
-        finally {
-            // ✅ CLEANUP: Always reset promise after completion
-            this._creationPromise = null;
-        }
-    }
-    async createProvider(chainId, chainType, chainData) {
-        const provider = await getWeb3ProviderWithRetry(chainData);
-        return this.convertToWeb3(provider);
-    }
-    convertToWeb3(provider) {
-        if (provider instanceof Web3) {
-            return provider;
-        }
-        if (provider && typeof provider === 'object' && 'web3Provider' in provider) {
-            const providerObj = provider;
-            // If we want to user the web3Provider directly:
-            /*if (providerObj.web3Provider) {
-                return new Web3(providerObj.web3Provider as never);
-            }*/
-            if (providerObj.ethersProvider) {
-                const url = this.extractUrlFromEthersProvider(providerObj.ethersProvider);
-                const headers = this.extractHeadersFromEthersProvider(providerObj.ethersProvider);
-                const web3 = new Web3(url);
-                const currentProvider = web3.currentProvider;
-                if (currentProvider) {
-                    currentProvider['url'] = url;
-                    if (headers && Object.keys(headers).length > 0) {
-                        currentProvider['request'] = async (payload) => {
-                            const response = await fetch(url, {
-                                method: 'POST',
-                                headers: {
-                                    'Content-Type': 'application/json',
-                                    ...headers
-                                },
-                                body: JSON.stringify(payload)
-                            });
-                            if (!response.ok) {
-                                throw new Error(`HTTP ${response.status}: ${response.statusText}`);
-                            }
-                            return await response.json();
-                        };
-                    }
-                }
-                return web3;
-            }
-        }
-        return new Web3(provider);
-    }
-    extractUrlFromEthersProvider(ethersProvider) {
-        return ethersProvider.connection?.url ||
-            ethersProvider._getConnection?.()?.url ||
-            ethersProvider.url ||
-            '';
-    }
-    extractHeadersFromEthersProvider(ethersProvider) {
-        return ethersProvider.connection?.headers ||
-            ethersProvider._getConnection?.()?.headers ||
-            {};
-    }
-}
-/* import Web3 from "web3";
-import { ChainData, ChainType, ChainTypes } from "@explorins/web3-ts";
-import { PublicHttpProviderService } from "./public-http-provider.service";
-import { getWeb3ProviderFromChainData } from "./getWeb3FCD.service";
-
-
-export class Web3ProviderService {
-  
-    private _web3: Web3 | null = null;
-    private _currentChainId: number | null = null;
-  
-    constructor(
-        private readonly publicHttpProviderService: PublicHttpProviderService,
-    ) {
-    }
-  
-    public async getWeb3(chainId: number, chainType: ChainType, privateChainData: ChainData | null = null) {
-        if (!this._web3 || this._currentChainId !== chainId) {
-              
-            if(!chainId) throw new Error('ChainId not found')
-  
-            try {
-                this._currentChainId = chainId;
-                const provider = await this.getWeb3ByChainId(chainId, chainType, privateChainData);
-                this._web3 = this.convertToWeb3(provider);
-            } catch (error) {
-                console.error('Error getting web3 connection from chain id ' + chainId , error)
-                throw new Error('Error getting web3 connection from chain id ' + chainId)
-            }
-        }
-        return this._web3 as Web3;
-    }
-  
-    // Keep return type as 'any' to avoid TypeScript errors while still being adapted later
-    private getWeb3ByChainId(chainId: number, chainType: ChainType, privateChainData: ChainData | null = null): any {
-        // Rest of the method remains the same
-        if(chainType === ChainTypes.PRIVATE && privateChainData) {
-            //const privateProvider = this.privateChainProviderService.getProviderFromChainData(privateChainData)
-            const privateProvider = getWeb3ProviderFromChainData(privateChainData);
-            
-            if(!privateProvider || privateProvider instanceof Error) throw new Error('Error getting web3 provider');
-              
-            
-            return privateProvider;
-  
-        } else {
-            
-            const publicProvider = this.publicHttpProviderService.getProvider(chainId)
-            if(!publicProvider || publicProvider instanceof Error) throw new Error('Error getting web3 provider');
-              
-            return publicProvider;
-        }
-    }
-
-    private convertToWeb3(provider: unknown): Web3 {
-        if (provider instanceof Web3) {
-            return provider as Web3;
-        }
-
-        if (provider && typeof provider === 'object' && 'web3Provider' in provider) {
-            const providerObj = provider as {
-                web3Provider?: unknown;
-                ethersProvider?: any;
-                isAuthenticated?: boolean;
-            };
-            
-            // If we want to user the web3Provider directly:
-            /*if (providerObj.web3Provider) {
-                return new Web3(providerObj.web3Provider as never);
-            }*/
-/*if (providerObj.ethersProvider) {
-
-    const url = this.extractUrlFromEthersProvider(providerObj.ethersProvider);
-    const headers = this.extractHeadersFromEthersProvider(providerObj.ethersProvider);
-    
-    const web3 = new Web3(url);
-    const currentProvider = web3.currentProvider as unknown as Record<string, unknown>;
-
-    if (currentProvider) {
-        currentProvider['url'] = url;
-        
-        if (headers && Object.keys(headers).length > 0) {
-            currentProvider['request'] = async (payload: Record<string, unknown>): Promise<Record<string, unknown>> => {
-                const response = await fetch(url, {
-                    method: 'POST',
-                    headers: {
-                        'Content-Type': 'application/json',
-                        ...headers
-                    },
-                    body: JSON.stringify(payload)
-                });
-                
-                if (!response.ok) {
-                    throw new Error(`HTTP ${response.status}: ${response.statusText}`);
-                }
-                
-                return await response.json() as Record<string, unknown>;
-            };
-        }
-    }
-
-    return web3;
-}
-}
-
-return new Web3(provider as never);
-}
-
-
-private extractUrlFromEthersProvider(ethersProvider: any): string {
-return ethersProvider.connection?.url ||
-   ethersProvider._getConnection?.()?.url ||
-   ethersProvider.url ||
-   '';
-}
-
-private extractHeadersFromEthersProvider(ethersProvider: any): Record<string, string> {
-return ethersProvider.connection?.headers ||
-   ethersProvider._getConnection?.()?.headers ||
-   {};
-}
-} */
-
-/**
- * Web3 Chain Domain Models
- *
- * Minimal interface definitions matching framework usage exactly.
- * Local ChainData interface to avoid external dependency issues.
- */
-const ChainTypes = {
-    PUBLIC: 'PUBLIC',
-    PRIVATE: 'PRIVATE'
-};
-
-function createWeb3ChainSDK(apiClient, providerService) {
-    const web3ChainApi = new Web3ChainApi(apiClient);
-    const web3ChainService = new Web3ChainService(web3ChainApi, providerService); // ✅ DIRECT INJECTION
-    return {
-        // ✅ REPLICA: Same methods as framework
-        getChainDataById: (chainId) => web3ChainService.getChainDataById(chainId),
-        getWeb3ByChainId: (chainId) => web3ChainService.getWeb3ByChainId(chainId),
-        api: web3ChainApi,
-        service: web3ChainService
-    };
-}
-
-/**
- * TokenDomainService - Domain service for token operations
- * Implements business logic for token balance, metadata, and collection operations
- */
-class TokenDomainService {
-    constructor(web3Api, metadataService, contractService) {
-        this.web3Api = web3Api;
-        this.metadataService = metadataService;
-        this.contractService = contractService;
-    }
-    async getTokenBalance(request) {
-        const balance = await this.web3Api.getTokenBalance({
-            accountAddress: request.accountAddress,
-            contractAddress: request.contractAddress,
-            abi: request.abi,
-            tokenId: request.tokenId,
-            chainId: request.chainId
-        });
-        return {
-            tokenId: request.tokenId,
-            balance,
-            hasBalance: balance > 0,
-            metadata: null
-        };
-    }
-    async getTokenWithMetadata(params) {
-        try {
-            const balance = await this.web3Api.getTokenBalance({
-                accountAddress: params.accountAddress,
-                contractAddress: params.contractAddress,
-                abi: params.abi,
-                tokenId: params.tokenId,
-                chainId: params.chainId
-            });
-            let metadata = null;
-            if (balance > 0) {
-                const tokenUri = await this.web3Api.getTokenUri({
-                    contractAddress: params.contractAddress,
-                    abi: params.abi,
-                    tokenId: params.tokenId,
-                    chainId: params.chainId
-                });
-                if (tokenUri) {
-                    metadata = await this.metadataService.fetchAndProcessMetadata(tokenUri, params.chainId);
-                }
-            }
-            return {
-                tokenId: params.tokenId,
-                balance,
-                hasBalance: balance > 0,
-                metadata
-            };
-        }
-        catch (error) {
-            console.error('Error getting token with metadata:', error);
-            return {
-                tokenId: params.tokenId,
-                balance: 0,
-                hasBalance: false,
-                metadata: null
-            };
-        }
-    }
-    async getTokenCollection(params) {
-        try {
-            const contractAnalysis = this.contractService.analyzeContract(params.abi);
-            const tokens = [];
-            if (!contractAnalysis.hasEnumeration && !contractAnalysis.isERC1155) {
-                console.warn('Contract does not support enumeration, cannot retrieve full collection');
-                return {
-                    accountAddress: params.accountAddress,
-                    contractAddress: params.contractAddress,
-                    totalBalance: 0,
-                    tokensRetrieved: 0,
-                    tokens: [],
-                    note: 'Contract does not support enumeration'
-                };
-            }
-            else if (contractAnalysis.isERC1155) {
-                const tokenIdsToProcess = params.tokenIds || [];
-                if (tokenIdsToProcess.length > 0) {
-                    for (const tokenId of tokenIdsToProcess) {
-                        const tokenBalance = await this.getTokenWithMetadata({
-                            accountAddress: params.accountAddress,
-                            contractAddress: params.contractAddress,
-                            abi: params.abi,
-                            tokenId,
-                            chainId: params.chainId
-                        });
-                        tokens.push(tokenBalance);
-                    }
-                }
-                console.log('ERC-1155 User balances:', tokens);
-                // ERC-1155: Cannot enumerate without knowing token IDs
-                // Would need to use events or provide specific token IDs
-                console.warn('ERC-1155 collection retrieval requires specific token IDs or event analysis');
-                return {
-                    accountAddress: params.accountAddress,
-                    contractAddress: params.contractAddress,
-                    totalBalance: 0,
-                    tokensRetrieved: 0,
-                    tokens: tokens,
-                    note: 'ERC-1155 collection retrieval requires specific token IDs. Use getTokenWithMetadata() for individual tokens.'
-                };
-            }
-            // Handle different token standards
-            if (contractAnalysis.isERC721) {
-                // ERC-721: Get user's total balance and enumerate through tokens
-                const userBalance = await this.web3Api.getTokenBalance({
-                    accountAddress: params.accountAddress,
-                    contractAddress: params.contractAddress,
-                    abi: params.abi,
-                    tokenId: null, // null for ERC-721 total balance
-                    chainId: params.chainId
-                });
-                console.log(`ERC-721 User balance for ${params.accountAddress}:`, userBalance);
-                if (userBalance === 0) {
-                    return {
-                        accountAddress: params.accountAddress,
-                        contractAddress: params.contractAddress,
-                        totalBalance: 0,
-                        tokensRetrieved: 0,
-                        tokens: []
-                    };
-                }
-                // Enumerate through user's tokens
-                const maxTokens = params.maxTokens || userBalance;
-                const tokensToRetrieve = Math.min(maxTokens, userBalance);
-                for (let i = 0; i < tokensToRetrieve; i++) {
-                    try {
-                        const tokenId = await this.web3Api.getTokenOfOwnerByIndex({
-                            contractAddress: params.contractAddress,
-                            abi: params.abi,
-                            accountAddress: params.accountAddress,
-                            tokenIndex: i,
-                            chainId: params.chainId
-                        });
-                        const tokenWithMetadata = await this.getTokenWithMetadata({
-                            accountAddress: params.accountAddress,
-                            contractAddress: params.contractAddress,
-                            abi: params.abi,
-                            tokenId,
-                            chainId: params.chainId
-                        });
-                        if (tokenWithMetadata.hasBalance) {
-                            tokens.push(tokenWithMetadata);
-                        }
-                    }
-                    catch (error) {
-                        console.warn(`Error retrieving ERC-721 token at index ${i}:`, error);
-                        continue;
-                    }
-                }
-            }
-            else {
-                // Unknown standard
-                return {
-                    accountAddress: params.accountAddress,
-                    contractAddress: params.contractAddress,
-                    totalBalance: 0,
-                    tokensRetrieved: 0,
-                    tokens: [],
-                    note: 'Unsupported token standard for collection retrieval'
-                };
-            }
-            // Calculate total balance based on retrieved tokens
-            let totalBalance = 0;
-            if (contractAnalysis.isERC721) {
-                // For ERC-721, total balance is the number of unique tokens owned
-                totalBalance = tokens.length;
-            }
-            else {
-                // For other standards, sum up individual token balances
-                totalBalance = tokens.reduce((sum, token) => sum + token.balance, 0);
-            }
-            return {
-                accountAddress: params.accountAddress,
-                contractAddress: params.contractAddress,
-                totalBalance,
-                tokensRetrieved: tokens.length,
-                tokens
-            };
-        }
-        catch (error) {
-            console.error('Error getting token collection:', error);
-            return {
-                accountAddress: params.accountAddress,
-                contractAddress: params.contractAddress,
-                totalBalance: 0,
-                tokensRetrieved: 0,
-                tokens: [],
-                note: 'Error retrieving collection'
-            };
-        }
-    }
-    async getTokenMetadata(params) {
-        try {
-            const tokenUri = await this.web3Api.getTokenUri({
-                contractAddress: params.contractAddress,
-                abi: params.abi,
-                tokenId: params.tokenId,
-                chainId: params.chainId
-            });
-            let metadata = null;
-            if (tokenUri) {
-                metadata = await this.metadataService.fetchAndProcessMetadata(tokenUri, params.chainId);
-            }
-            return {
-                tokenId: params.tokenId,
-                tokenUri,
-                metadata
-            };
-        }
-        catch (error) {
-            console.error('Error getting token metadata:', error);
-            return {
-                tokenId: params.tokenId,
-                tokenUri: null,
-                metadata: null
-            };
-        }
-    }
-}
-
-/**
- * MetadataDomainService - Clean IPFS metadata resolution
- */
-class MetadataDomainService {
-    constructor(ipfsApi) {
-        this.ipfsApi = ipfsApi;
-    }
-    async fetchAndProcessMetadata(tokenUri, chainId) {
-        return this.ipfsApi.fetchAndProcessMetadata(tokenUri, chainId);
-    }
-    async resolveIPFSUrl(url, chainId) {
-        return this.ipfsApi.resolveIPFSUrl(url, chainId);
-    }
-}
-
-/**
- * ContractDomainService - Clean contract analysis without external dependencies
- */
-class ContractDomainService {
-    constructor() { }
-    analyzeContract(abi) {
-        const methods = abi.filter(item => item.type === 'function').map(item => item.name);
-        // ERC-721 detection
-        const hasOwnerOf = methods.includes('ownerOf');
-        const hasTokenURI = methods.includes('tokenURI');
-        const hasTransferFrom = methods.includes('transferFrom');
-        const isERC721 = hasOwnerOf && hasTokenURI && hasTransferFrom;
-        // ERC-1155 detection
-        const hasBalanceOfBatch = methods.includes('balanceOfBatch');
-        const hasSafeBatchTransferFrom = methods.includes('safeBatchTransferFrom');
-        const hasURI = methods.includes('uri');
-        const isERC1155 = hasBalanceOfBatch && hasSafeBatchTransferFrom && hasURI;
-        return {
-            hasEnumeration: methods.includes('tokenByIndex') && methods.includes('totalSupply'),
-            hasOwnerOf,
-            hasBalanceOf: methods.includes('balanceOf'),
-            hasTokenURI,
-            hasTransfer: methods.includes('transfer') || methods.includes('transferFrom'),
-            hasApprove: methods.includes('approve'),
-            isERC721,
-            isERC1155
-        };
-    }
-    supportsEnumeration(abi) {
-        return this.analyzeContract(abi).hasEnumeration;
-    }
-    supportsMethod(abi, methodName) {
-        const methods = abi.filter(item => item.type === 'function').map(item => item.name);
-        return methods.includes(methodName);
-    }
-}
-
-/**
- * Web3ApplicationService - Application layer entrance point
- * Orchestrates domain services and provides clean public interface
- * Simplified architecture with concrete classes
- */
-class Web3ApplicationService {
-    constructor(web3Api, ipfsApi) {
-        // Type-safe metadata conversion methods for ERC-721/ERC-1155 standards
-        this.metadataMapper = {
-            fromERCStandard: (ercMetadata) => ({
-                name: ercMetadata.name || '',
-                description: ercMetadata.description || '',
-                imageUrl: ercMetadata.image || '',
-                externalUrl: ercMetadata.external_url,
-                animationUrl: ercMetadata.animation_url,
-                animationUrlConverted: undefined, // Will be set by IPFS conversion
-                attributes: ercMetadata.attributes || [],
-                ...ercMetadata
-            }),
-            toERCStandard: (metadata) => ({
-                name: metadata.name,
-                description: metadata.description,
-                image: metadata.imageUrl,
-                animation_url: metadata.animationUrl,
-                external_url: metadata.externalUrl,
-                attributes: metadata.attributes,
-                ...Object.fromEntries(Object.entries(metadata).filter(([key]) => !['name', 'description', 'imageUrl', 'animationUrl', 'externalUrl', 'attributes', 'animationUrlConverted'].includes(key)))
-            })
-        };
-        // Create domain services with injected infrastructure dependencies
-        this.contractDomainService = new ContractDomainService();
-        this.metadataDomainService = new MetadataDomainService(ipfsApi);
-        this.tokenDomainService = new TokenDomainService(web3Api, this.metadataDomainService, this.contractDomainService);
-    }
-    /**
-     * Get balance and metadata for a specific token
-     */
-    async getSpecificTokenBalance(request) {
-        if (!request.tokenId) {
-            return this.tokenDomainService.getTokenBalance({
-                accountAddress: request.accountAddress || '',
-                contractAddress: request.contractAddress,
-                abi: request.abi,
-                tokenId: '',
-                chainId: request.chainId
-            });
-        }
-        return this.tokenDomainService.getTokenWithMetadata({
-            accountAddress: request.accountAddress || '',
-            contractAddress: request.contractAddress,
-            abi: request.abi,
-            tokenId: request.tokenId || '',
-            chainId: request.chainId
-        });
-    }
-    /**
-     * Get metadata for a specific token from on-chain
-     */
-    async getTokenMetadata(request) {
-        const domainResult = await this.tokenDomainService.getTokenMetadata({
-            contractAddress: request.contractAddress,
-            abi: request.abi,
-            tokenId: request.tokenId || '',
-            chainId: request.chainId
-        });
-        return domainResult.metadata;
-    }
-    /**
-     * Retrieve entire collection of tokens with balance and metadata
-     */
-    async getTokenCollection(request) {
-        return this.tokenDomainService.getTokenCollection({
-            accountAddress: request.accountAddress || '',
-            contractAddress: request.contractAddress,
-            abi: request.abi,
-            chainId: request.chainId,
-            maxTokens: request.maxTokens,
-            tokenIds: request.tokenIds
-        });
-    }
-    /**
-     * Resolve IPFS URLs to HTTPS if needed
-     */
-    async resolveIPFSUrl(url, chainId) {
-        return this.metadataDomainService.resolveIPFSUrl(url, chainId);
-    }
-    /**
-     * Fetch and process metadata from URI with IPFS conversion
-     */
-    async fetchAndProcessMetadata(tokenUri, chainId) {
-        const domainMetadata = await this.metadataDomainService.fetchAndProcessMetadata(tokenUri, chainId);
-        if (!domainMetadata)
-            return null;
-        // Convert from ERC token standard to our clean interface
-        const cleanMetadata = this.metadataMapper.fromERCStandard(domainMetadata);
-        // Add IPFS conversion if needed
-        if (cleanMetadata.animationUrl?.startsWith('ipfs://')) {
-            return {
-                ...cleanMetadata,
-                animationUrlConverted: await this.resolveIPFSUrl(cleanMetadata.animationUrl, chainId)
-            };
-        }
-        return cleanMetadata;
-    }
-}
-
-/**
- * Web3InfrastructureApi - Infrastructure implementation for blockchain operations
- * Uses @explorins/web3-ts for Web3 interactions
- */
-class Web3InfrastructureApi {
-    constructor(web3ChainService) {
-        this.web3ChainService = web3ChainService;
-    }
-    async getTokenBalance(request) {
-        try {
-            if (request.tokenId !== null)
-                request.tokenId = request.tokenId.toString();
-            const web3 = await this.web3ChainService.getWeb3ByChainId(request.chainId);
-            const contract = getSmartContractInstance(request.contractAddress, request.abi, web3);
-            return await getAccountTokenBalance(contract, request.accountAddress, request.tokenId);
-        }
-        catch (error) {
-            console.error(`Failed to get token balance for ${request.accountAddress} for ${request.contractAddress} and tokenId ${request.tokenId}, return 0 instead:`, error);
-            return 0;
-        }
-    }
-    async getTokenUri(request) {
-        try {
-            const web3 = await this.web3ChainService.getWeb3ByChainId(request.chainId);
-            const contract = getSmartContractInstance(request.contractAddress, request.abi, web3);
-            const tokenId = Number(request.tokenId);
-            const tokenUri = await getTokenUri(contract, tokenId);
-            return String(tokenUri);
-        }
-        catch (error) {
-            console.error(`Failed to get token URI for tokenId ${request.tokenId}:`, error);
-            throw error;
-        }
-    }
-    async getTokenOfOwnerByIndex(request) {
-        try {
-            const web3 = await this.web3ChainService.getWeb3ByChainId(request.chainId);
-            const tokenContract = getSmartContractInstance(request.contractAddress, request.abi, web3);
-            const tokenId = await getTokenOfOwnerByIndex(tokenContract, request.accountAddress, request.tokenIndex);
-            return String(tokenId);
-        }
-        catch (error) {
-            console.error(`Failed to get token by index ${request.tokenIndex} for ${request.accountAddress}:`, error);
-            throw error;
-        }
-    }
-}
-
-/**
- * IPFSInfrastructureApi - Infrastructure implementation for IPFS operations
- * Uses Web3ChainService for IPFS gateway resolution
- */
-class IPFSInfrastructureApi {
-    constructor(web3ChainService) {
-        this.web3ChainService = web3ChainService;
-        this.defaultIpfsGatewayDomain = 'pers.mypinata.cloud';
-    }
-    async getIpfsGatewayDomain(chainId) {
-        try {
-            const chainData = await this.web3ChainService.getChainDataWithCache(chainId);
-            return chainData.ipfsGatewayDomain || this.defaultIpfsGatewayDomain;
-        }
-        catch (error) {
-            console.warn(`Failed to get chain data for chainId ${chainId}, using default IPFS gateway:`, error);
-            return this.defaultIpfsGatewayDomain;
-        }
-    }
-    async resolveIPFSUrl(url, chainId) {
-        if (url.startsWith('ipfs://')) {
-            const gateway = await this.getIpfsGatewayDomain(chainId);
-            return url.replace('ipfs://', `https://${gateway}/ipfs/`);
-        }
-        return url;
-    }
-    async fetchAndProcessMetadata(tokenUri, chainId) {
-        try {
-            const resolvedUri = await this.resolveIPFSUrl(tokenUri, chainId);
-            const response = await fetch(resolvedUri);
-            if (!response.ok) {
-                throw new Error(`HTTP error! status: ${response.status}`);
-            }
-            const metadata = await response.json();
-            // Process and return clean metadata
-            return {
-                name: metadata.name || '',
-                description: metadata.description || '',
-                image: metadata.image ? await this.resolveIPFSUrl(metadata.image, chainId) : '',
-                attributes: metadata.attributes || [],
-                animation_url: metadata.animation_url ? await this.resolveIPFSUrl(metadata.animation_url, chainId) : undefined,
-                external_url: metadata.external_url || undefined
-            };
-        }
-        catch (error) {
-            console.error('Error fetching metadata:', error);
-            return null;
-        }
-    }
-    async fetchFromUrl(url) {
-        try {
-            const response = await fetch(url);
-            if (!response.ok) {
-                throw new Error(`Failed to fetch from ${url}: ${response.statusText}`);
-            }
-            return await response.json();
-        }
-        catch (error) {
-            console.error(`Error fetching from URL ${url}:`, error);
-            throw error;
-        }
-    }
-}
-
-function createWeb3SDK(apiClient) {
-    // TODO: FIX LATER - TEMPORARY CONSTRUCTION
-    const web3ProviderService = new Web3ProviderService();
-    const web3ChainSDK = createWeb3ChainSDK(apiClient, web3ProviderService);
-    // Create Web3ApplicationService - main entry point for all Web3 operations
-    const web3InfrastructureApi = new Web3InfrastructureApi(web3ChainSDK.service);
-    const ipfsInfrastructureApi = new IPFSInfrastructureApi(web3ChainSDK.service);
-    const web3ApplicationService = new Web3ApplicationService(web3InfrastructureApi, ipfsInfrastructureApi);
-    // Clean SDK - all functions route through Web3ApplicationService
-    return {
-        getTokenBalance: (request) => web3ApplicationService.getSpecificTokenBalance(request),
-        getTokenMetadata: (request) => web3ApplicationService.getTokenMetadata(request),
-        getTokenCollection: (request) => web3ApplicationService.getTokenCollection(request),
-        resolveIPFSUrl: (url, chainId) => web3ApplicationService.resolveIPFSUrl(url, chainId),
-        fetchAndProcessMetadata: (tokenUri, chainId) => web3ApplicationService.fetchAndProcessMetadata(tokenUri, chainId),
-        applicationService: web3ApplicationService
-    };
-}
-
-export { AnalyticsApi, AnalyticsService, AuthApi, AuthService, BaseTokenService, BusinessApi, BusinessService, CampaignApi, CampaignService, ChainTypes, DEFAULT_PERS_CONFIG, DonationApi, DonationService, IPFSInfrastructureApi, PurchaseApi as PaymentApi, PaymentService, PersApiClient, PersApiError, PersSDK, RedemptionApi, RedemptionService, SimpleSdkAuthProvider, TenantApi, TenantService, TokenApi, TokenSDK, TokenService, TransactionAccountType, TransactionApi, TransactionService, UserApi, UserService, UserStatusApi, UserStatusService, Web3ApplicationService, Web3ChainApi, Web3ChainService, Web3InfrastructureApi, Web3ProviderService, buildApiRoot, createAnalyticsSDK, createAuthProvider, createAuthSDK, createBusinessSDK, createCampaignSDK, createDonationSDK, createPaymentSDK, createPersSDK, createRedemptionSDK, createTenantSDK, createTransactionSDK, createUserSDK, createUserStatusSDK, createWeb3ChainSDK, createWeb3SDK, mergeWithDefaults };
+export { BusinessApi, BusinessService, createBusinessSDK } from './business.js';
+export { TransactionAccountType, TransactionApi, TransactionService, createTransactionSDK } from './transaction.js';
+export { AnalyticsApi, AnalyticsService, createAnalyticsSDK } from './analytics.js';
+export { CampaignApi, CampaignService, createCampaignSDK } from './campaign.js';
+export { DonationApi, DonationService, createDonationSDK } from './donation.js';
+export { PaymentApi, PaymentService, createPaymentSDK } from './payment.js';
+export { RedemptionApi, RedemptionService, createRedemptionSDK } from './redemption.js';
+export { TenantApi, TenantService, createTenantSDK } from './tenant.js';
+export { B as BaseTokenService, a as TokenApi, T as TokenSDK, b as TokenService } from './chunks/base-token-service-BA81_Ouq.js';
+export { UserApi, UserService, createUserSDK } from './user.js';
+export { UserStatusApi, UserStatusService, createUserStatusSDK } from './user-status.js';
+export { ChainTypes, Web3ChainApi, Web3ChainService, Web3ProviderService, createWeb3ChainSDK } from './web3-chain.js';
+export { IPFSInfrastructureApi, Web3ApplicationService, Web3InfrastructureApi, createWeb3SDK } from './web3.js';
+import './chunks/jwt.function-d6jPtBqI.js';
+import 'jwt-decode';
+import 'web3';
+import 'ethers/providers';
+import 'ethers/utils';
+import '@explorins/web3-ts';
 //# sourceMappingURL=index.js.map