@explorins/pers-sdk 1.3.16 → 1.5.2

package/dist/chunks/{pers-sdk-Rc8YKyNc.js → pers-sdk-CVSAFBLh.js}

@@ -1,4 +1,14 @@
 import { AccountOwnerType } from '@explorins/pers-shared';
+import { createUserSDK } from '../user.js';
+import { T as TokenSDK } from './token-sdk-BW4kkJb3.js';
+import { createBusinessSDK } from '../business.js';
+import { createCampaignSDK } from '../campaign.js';
+import { createRedemptionSDK } from '../redemption.js';
+import { createTransactionSDK } from '../transaction.js';
+import { createPaymentSDK } from '../payment.js';
+import { createTenantSDK } from '../tenant.js';
+import { createAnalyticsSDK } from '../analytics.js';
+import { createDonationSDK } from '../donation.js';
 
 /**
  * PERS SDK Configuration interfaces and utilities
@@ -298,7 +308,7 @@ let LocalStorageTokenStorage$1 = class LocalStorageTokenStorage {
 /**
  * Token Manager - High-level token management
  */
-class TokenManager {
+let TokenManager$1 = class TokenManager {
     constructor(storage = new LocalStorageTokenStorage$1()) {
         this.storage = storage;
     }
@@ -379,7 +389,7 @@ class TokenManager {
     async clearProviderToken() {
         await this.storage.removeToken(AUTH_STORAGE_KEYS.PROVIDER_TOKEN);
     }
-}
+};
 
 /**
  * PERS SDK Error Handling - Optimized for Performance
@@ -742,7 +752,7 @@ class DefaultAuthProvider {
         this.authType = 'admin';
         this.projectKey = projectKey || null;
         this.authApi = authApi || null;
-        this.tokenManager = new TokenManager();
+        this.tokenManager = new TokenManager$1();
         const refreshStrategy = new DefaultAuthRefreshStrategy(this.tokenManager, () => Promise.resolve(this.getProviderToken()), this.authApi);
         this.tokenRefreshManager = new TokenRefreshManager(this.tokenManager, refreshStrategy);
     }
@@ -1613,79 +1623,1343 @@ function createAuthProvider(config) {
 } */
 
 /**
- * PERS SDK - Platform-agnostic TypeScript SDK for PERS API
+ * Authentication Manager - Clean, high-level interface for authentication operations
  *
- * Provides a simple wrapper around the core API client with
- * intelligent authentication and token management.
+ * Provides a simplified API for common authentication tasks while maintaining
+ * access to the underlying API client for advanced use cases.
  */
+class AuthManager {
+    constructor(apiClient) {
+        this.apiClient = apiClient;
+    }
+    /**
+     * Login with JWT token
+     *
+     * @param jwtToken - JWT token to authenticate with
+     * @param userType - Type of user ('user' | 'admin')
+     * @returns Promise resolving to authentication response
+     */
+    async loginWithToken(jwtToken, userType = 'user') {
+        return userType === 'admin'
+            ? this.apiClient.loginAdmin(jwtToken)
+            : this.apiClient.loginUser(jwtToken);
+    }
+    /**
+     * Login with raw user data
+     *
+     * @param rawUserData - Raw user data for authentication
+     * @returns Promise resolving to authentication response
+     */
+    async loginWithRawData(rawUserData) {
+        return this.apiClient.loginUserWithRawData(rawUserData);
+    }
+    /**
+     * Get current authenticated user
+     *
+     * @returns Promise resolving to current user data
+     */
+    async getCurrentUser() {
+        return this.apiClient.get('/users/me');
+    }
+    /**
+     * Refresh current user data
+     *
+     * @returns Promise resolving to updated user data
+     */
+    async refreshUserData() {
+        return this.getCurrentUser();
+    }
+    /**
+     * Check if user is authenticated
+     *
+     * @returns Promise resolving to boolean indicating authentication status
+     */
+    async isAuthenticated() {
+        try {
+            await this.getCurrentUser();
+            return true;
+        }
+        catch {
+            return false;
+        }
+    }
+    /**
+     * Refresh access token using stored refresh token
+     *
+     * @param refreshToken - Optional refresh token, uses stored token if not provided
+     * @returns Promise resolving to new auth tokens
+     */
+    async refreshTokens(refreshToken) {
+        return this.apiClient.refreshTokens(refreshToken);
+    }
+    /**
+     * Clear stored authentication tokens
+     *
+     * @returns Promise that resolves when tokens are cleared
+     */
+    async clearAuth() {
+        // Use auth provider to clear tokens if available
+        const authProvider = this.apiClient.getConfig().authProvider;
+        if (authProvider?.clearTokens) {
+            await authProvider.clearTokens();
+        }
+    }
+    /**
+     * Check if SDK has valid authentication
+     *
+     * @returns Boolean indicating if valid authentication exists
+     */
+    hasValidAuth() {
+        return this.apiClient.hasValidAuth();
+    }
+    /**
+     * Admin login with JWT token
+     *
+     * @param jwt - JWT token for admin authentication
+     * @returns Promise resolving to authentication context
+     */
+    async loginAdmin(jwt) {
+        return this.apiClient.loginAdmin(jwt);
+    }
+    /**
+     * User login with JWT token
+     *
+     * @param jwt - JWT token for user authentication
+     * @returns Promise resolving to authentication context
+     */
+    async loginUser(jwt) {
+        return this.apiClient.loginUser(jwt);
+    }
+}
+
 /**
- * Main PERS SDK class
- *
- * Minimal wrapper around PersApiClient providing a clean interface
- * for platform-specific implementations.
- *
- * @example
- * ```typescript
- * import { createPersSDK, createAuthProvider } from '@explorins/pers-sdk/core';
- * import { BrowserHttpClient } from '@explorins/pers-sdk/browser';
+ * User Manager - Clean, high-level interface for user operations
  *
- * const authProvider = createAuthProvider({
- *   tokenProvider: () => getFirebaseToken()
- * });
+ * Provides a simplified API for common user management tasks while maintaining
+ * access to the full user SDK for advanced use cases.
+ */
+class UserManager {
+    constructor(apiClient) {
+        this.apiClient = apiClient;
+        this.userSDK = createUserSDK(apiClient);
+    }
+    /**
+     * Get current user profile
+     *
+     * @returns Promise resolving to current user data
+     */
+    async getCurrentUser() {
+        return this.userSDK.getRemoteUser();
+    }
+    /**
+     * Update current user profile
+     *
+     * @param userData - User data to update
+     * @returns Promise resolving to updated user data
+     */
+    async updateCurrentUser(userData) {
+        return this.userSDK.updateRemoteUser(userData);
+    }
+    /**
+     * Get user by unique identifier
+     *
+     * @param identifier - Unique identifier for the user
+     * @returns Promise resolving to user data
+     */
+    async getUserById(identifier) {
+        return this.userSDK.getUserByUniqueIdentifier(identifier);
+    }
+    /**
+     * Get all users public profiles with optional filtering
+     *
+     * @param filter - Optional filter criteria
+     * @returns Promise resolving to array of user public profiles
+     */
+    async getAllUsersPublic(filter) {
+        return this.userSDK.getAllUsersPublicProfiles(filter || null);
+    }
+    /**
+     * Admin: Get all users
+     *
+     * @returns Promise resolving to array of all users
+     */
+    async getAllUsers() {
+        return this.userSDK.getAllRemoteUsers();
+    }
+    /**
+     * Admin: Update user data
+     *
+     * @param userId - ID of user to update
+     * @param userData - User data to update
+     * @returns Promise resolving to updated user data
+     */
+    async updateUser(userId, userData) {
+        return this.userSDK.updateUserAsAdmin(userId, userData);
+    }
+    /**
+     * Admin: Toggle user active status
+     *
+     * @param user - User to toggle status for
+     * @returns Promise resolving to updated user data
+     */
+    async toggleUserStatus(user) {
+        return this.userSDK.toggleUserActiveStatusByUser(user);
+    }
+    /**
+     * Get the full user SDK for advanced operations
+     *
+     * @returns UserSDK instance
+     */
+    getUserSDK() {
+        return this.userSDK;
+    }
+}
+
+/**
+ * Token Manager - Clean, high-level interface for token operations
  *
- * const sdk = new PersSDK(new BrowserHttpClient(), {
- *   environment: 'production',
- *   apiProjectKey: 'your-project-key',
- *   authProvider
- * });
+ * Provides a simplified API for common token management tasks while maintaining
+ * access to the full token SDK for advanced use cases.
+ */
+class TokenManager {
+    constructor(apiClient) {
+        this.apiClient = apiClient;
+        this.tokenSDK = new TokenSDK(apiClient);
+    }
+    /**
+     * Get all available tokens
+     *
+     * @returns Promise resolving to array of tokens
+     */
+    async getTokens() {
+        return this.tokenSDK.getTokens();
+    }
+    /**
+     * Get all token types
+     *
+     * @returns Promise resolving to token types
+     */
+    async getTokenTypes() {
+        return this.tokenSDK.getTokenTypes();
+    }
+    /**
+     * Get active credit token
+     *
+     * @returns Promise resolving to active credit token
+     */
+    async getActiveCreditToken() {
+        return this.tokenSDK.getActiveCreditToken();
+    }
+    /**
+     * Get reward tokens
+     *
+     * @returns Promise resolving to reward tokens
+     */
+    async getRewardTokens() {
+        return this.tokenSDK.getRewardTokens();
+    }
+    /**
+     * Get status tokens
+     *
+     * @returns Promise resolving to status tokens
+     */
+    async getStatusTokens() {
+        return this.tokenSDK.getStatusTokens();
+    }
+    /**
+     * Get token by contract address
+     *
+     * @param contractAddress - Contract address to search for
+     * @param contractTokenId - Optional contract token ID
+     * @returns Promise resolving to token
+     */
+    async getTokenByContract(contractAddress, contractTokenId) {
+        return this.tokenSDK.getTokenByContract(contractAddress, contractTokenId);
+    }
+    /**
+     * Admin: Create new token
+     *
+     * @param tokenData - Token creation data
+     * @returns Promise resolving to created token
+     */
+    async createToken(tokenData) {
+        return this.tokenSDK.createToken(tokenData);
+    }
+    /**
+     * Admin: Update token
+     *
+     * @param tokenId - Token ID to update
+     * @param tokenData - Token update data
+     * @returns Promise resolving to updated token
+     */
+    async updateToken(tokenId, tokenData) {
+        return this.tokenSDK.updateToken(tokenId, tokenData);
+    }
+    /**
+     * Admin: Toggle token active status
+     *
+     * @param tokenId - Token ID to toggle
+     * @returns Promise resolving to updated token
+     */
+    async toggleTokenActive(tokenId) {
+        return this.tokenSDK.toggleTokenActive(tokenId);
+    }
+    /**
+     * Get the full token SDK for advanced operations
+     *
+     * @returns TokenSDK instance
+     */
+    getTokenSDK() {
+        return this.tokenSDK;
+    }
+}
+
+/**
+ * Business Manager - Clean, high-level interface for business operations
  *
- * const apiClient = sdk.api();
- * const user = await apiClient.get('/users/me');
- * ```
+ * Provides a simplified API for common business management tasks while maintaining
+ * access to the full business SDK for advanced use cases.
  */
-class PersSDK {
+class BusinessManager {
+    constructor(apiClient) {
+        this.apiClient = apiClient;
+        this.businessSDK = createBusinessSDK(apiClient);
+    }
     /**
-     * Creates a new PERS SDK instance
+     * Get all active businesses
      *
-     * @param httpClient Platform-specific HTTP client implementation
-     * @param config SDK configuration options
+     * @returns Promise resolving to array of active businesses
      */
-    constructor(httpClient, config) {
-        this.apiClient = new PersApiClient(httpClient, config);
+    async getActiveBusinesses() {
+        return this.businessSDK.getActiveBusinesses();
     }
     /**
-     * Gets the API client for making PERS API requests
+     * Get business by ID
      *
-     * This is the main interface for interacting with the PERS backend.
-     * The returned client handles authentication, token refresh, and error handling automatically.
+     * @param businessId - Business ID to fetch
+     * @returns Promise resolving to business data
+     */
+    async getBusinessById(businessId) {
+        return this.businessSDK.getBusinessById(businessId);
+    }
+    /**
+     * Get business by account address
      *
-     * @returns Configured PersApiClient instance
+     * @param accountAddress - Account address to search for
+     * @returns Promise resolving to business data
+     */
+    async getBusinessByAccount(accountAddress) {
+        return this.businessSDK.getBusinessByAccount(accountAddress);
+    }
+    /**
+     * Get all business types
      *
-     * @example
-     * ```typescript
-     * const apiClient = sdk.api();
-     * const user = await apiClient.get<User>('/users/me');
-     * await apiClient.post('/users', userData);
-     * ```
+     * @returns Promise resolving to array of business types
      */
-    api() {
-        return this.apiClient;
+    async getBusinessTypes() {
+        return this.businessSDK.getAllBusinessTypes();
     }
     /**
-     * Checks if SDK is configured for production environment
+     * Get businesses by type
      *
-     * @returns True if environment is 'production', false otherwise
+     * @param typeId - Business type ID to filter by
+     * @returns Promise resolving to array of businesses
      */
-    isProduction() {
-        return this.apiClient.getConfig().environment === 'production';
+    async getBusinessesByType(typeId) {
+        return this.businessSDK.getBusinessesByType(typeId);
+    }
+    /**
+     * Admin: Get all businesses (including inactive)
+     *
+     * @returns Promise resolving to array of all businesses
+     */
+    async getAllBusinesses() {
+        return this.businessSDK.getAllBusinesses();
+    }
+    /**
+     * Admin: Create new business
+     *
+     * @param displayName - Display name for the business
+     * @returns Promise resolving to created business data
+     */
+    async createBusiness(displayName) {
+        return this.businessSDK.createBusinessByDisplayName(displayName);
+    }
+    /**
+     * Admin: Update business
+     *
+     * @param businessId - ID of business to update
+     * @param businessData - Business data to update
+     * @returns Promise resolving to updated business data
+     */
+    async updateBusiness(businessId, businessData) {
+        return this.businessSDK.updateBusiness(businessId, businessData);
+    }
+    /**
+     * Admin: Toggle business active status
+     *
+     * @param businessId - ID of business to toggle
+     * @param toggleData - Toggle request data
+     * @returns Promise resolving to updated business data
+     */
+    async toggleBusinessStatus(businessId, toggleData) {
+        return this.businessSDK.toggleBusinessActive(businessId, toggleData);
+    }
+    /**
+     * Get the full business SDK for advanced operations
+     *
+     * @returns BusinessSDK instance
+     */
+    getBusinessSDK() {
+        return this.businessSDK;
     }
 }
+
 /**
- * Simple factory function
+ * Campaign Manager - Clean, high-level interface for campaign operations
+ *
+ * Provides a simplified API for common campaign management tasks while maintaining
+ * access to the full campaign SDK for advanced use cases.
+ */
+class CampaignManager {
+    constructor(apiClient) {
+        this.apiClient = apiClient;
+        this.campaignSDK = createCampaignSDK(apiClient);
+    }
+    /**
+     * Get all active campaigns
+     *
+     * @returns Promise resolving to array of active campaigns
+     */
+    async getActiveCampaigns() {
+        return this.campaignSDK.getActiveCampaigns();
+    }
+    /**
+     * Get campaign by ID
+     *
+     * @param campaignId - ID of the campaign
+     * @returns Promise resolving to campaign data
+     */
+    async getCampaignById(campaignId) {
+        return this.campaignSDK.getCampaignById(campaignId);
+    }
+    /**
+     * Claim a campaign reward
+     *
+     * @param claimRequest - Campaign claim data
+     * @returns Promise resolving to claim result
+     */
+    async claimCampaign(claimRequest) {
+        return this.campaignSDK.claimCampaign(claimRequest);
+    }
+    /**
+     * Get user's campaign claims
+     *
+     * @returns Promise resolving to array of user's claims
+     */
+    async getUserClaims() {
+        return this.campaignSDK.getClaimsForLoggedUser();
+    }
+    /**
+     * Admin: Get all campaigns
+     *
+     * @param active - Filter by active status
+     * @returns Promise resolving to array of campaigns
+     */
+    async getAllCampaigns(active) {
+        return this.campaignSDK.getCampaigns(active);
+    }
+    /**
+     * Admin: Create new campaign
+     *
+     * @param campaignData - Campaign data
+     * @returns Promise resolving to created campaign
+     */
+    async createCampaign(campaignData) {
+        return this.campaignSDK.createCampaign(campaignData);
+    }
+    /**
+     * Admin: Update campaign
+     *
+     * @param campaignId - ID of campaign to update
+     * @param campaignData - Updated campaign data
+     * @returns Promise resolving to updated campaign
+     */
+    async updateCampaign(campaignId, campaignData) {
+        return this.campaignSDK.updateCampaign(campaignId, campaignData);
+    }
+    /**
+     * Admin: Toggle campaign active status
+     *
+     * @param campaignId - ID of campaign to toggle
+     * @returns Promise resolving to updated campaign
+     */
+    async toggleCampaignStatus(campaignId) {
+        return this.campaignSDK.toggleCampaignActive(campaignId);
+    }
+    /**
+     * Admin: Toggle campaign testnet environment
+     *
+     * @param campaignId - ID of campaign to toggle
+     * @returns Promise resolving to updated campaign
+     */
+    async toggleCampaignTestnet(campaignId) {
+        return this.campaignSDK.toggleCampaignTestnet(campaignId);
+    }
+    /**
+     * Admin: Get campaign triggers
+     *
+     * @returns Promise resolving to array of campaign triggers
+     */
+    async getCampaignTriggers() {
+        return this.campaignSDK.getCampaignTriggers();
+    }
+    /**
+     * Admin: Set campaign trigger
+     *
+     * @param campaignId - ID of campaign
+     * @param triggerId - ID of trigger to set
+     * @returns Promise resolving to updated campaign
+     */
+    async setCampaignTrigger(campaignId, triggerId) {
+        return this.campaignSDK.setCampaignTrigger(campaignId, triggerId);
+    }
+    /**
+     * Admin: Create campaign token unit
+     *
+     * @param campaignId - ID of campaign
+     * @param tokenUnit - Token unit data
+     * @returns Promise resolving to updated campaign
+     */
+    async createCampaignTokenUnit(campaignId, tokenUnit) {
+        return this.campaignSDK.createCampaignTokenUnit(campaignId, tokenUnit);
+    }
+    /**
+     * Admin: Delete campaign token unit
+     *
+     * @param campaignId - ID of campaign
+     * @param tokenUnitId - ID of token unit to delete
+     * @returns Promise resolving to updated campaign
+     */
+    async deleteCampaignTokenUnit(campaignId, tokenUnitId) {
+        return this.campaignSDK.deleteCampaignTokenUnit(campaignId, tokenUnitId);
+    }
+    /**
+     * Admin: Add business engagement to campaign
+     *
+     * @param campaignId - ID of campaign
+     * @param engagement - Business engagement data
+     * @returns Promise resolving to updated campaign
+     */
+    async addBusinessEngagementToCampaign(campaignId, engagement) {
+        return this.campaignSDK.addBusinessEngagementToCampaign(campaignId, engagement);
+    }
+    /**
+     * Admin: Update campaign business engagement
+     *
+     * @param campaignId - ID of campaign
+     * @param engagementId - ID of engagement to update
+     * @param engagement - Updated engagement data
+     * @returns Promise resolving to updated campaign
+     */
+    async updateCampaignBusinessEngagement(campaignId, engagementId, engagement) {
+        return this.campaignSDK.updateCampaignBusinessEngagement(campaignId, engagementId, engagement);
+    }
+    /**
+     * Admin: Delete campaign business engagement
+     *
+     * @param campaignId - ID of campaign
+     * @param engagementId - ID of engagement to delete
+     * @returns Promise resolving to updated campaign
+     */
+    async deleteCampaignBusinessEngagement(campaignId, engagementId) {
+        return this.campaignSDK.deleteCampaignBusinessEngagement(campaignId, engagementId);
+    }
+    /**
+     * Admin: Get all campaign claims
+     *
+     * @returns Promise resolving to array of campaign claims
+     */
+    async getCampaignClaims() {
+        return this.campaignSDK.getCampaignClaims();
+    }
+    /**
+     * Admin: Get campaign claims by user ID
+     *
+     * @param userId - ID of user
+     * @returns Promise resolving to array of user's campaign claims
+     */
+    async getCampaignClaimsByUserId(userId) {
+        return this.campaignSDK.getCampaignClaimsByUserId(userId);
+    }
+    /**
+     * Admin: Get campaign claims by business ID
+     *
+     * @param businessId - ID of business
+     * @returns Promise resolving to array of business's campaign claims
+     */
+    async getCampaignClaimsByBusinessId(businessId) {
+        return this.campaignSDK.getCampaignClaimsByBusinessId(businessId);
+    }
+    /**
+     * Get the full campaign SDK for advanced operations
+     *
+     * @returns CampaignSDK instance
+     */
+    getCampaignSDK() {
+        return this.campaignSDK;
+    }
+}
+
+/**
+ * Redemption Manager - Clean, high-level interface for redemption operations
+ *
+ * Provides a simplified API for common redemption management tasks while maintaining
+ * access to the full redemption SDK for advanced use cases.
+ */
+class RedemptionManager {
+    constructor(apiClient) {
+        this.apiClient = apiClient;
+        this.redemptionSDK = createRedemptionSDK(apiClient);
+    }
+    /**
+     * Get all active redemption offers
+     *
+     * @returns Promise resolving to array of active redemptions
+     */
+    async getActiveRedemptions() {
+        return this.redemptionSDK.getActiveRedemptions();
+    }
+    /**
+     * Get available redemption types
+     *
+     * @returns Promise resolving to array of redemption types
+     */
+    async getRedemptionTypes() {
+        return this.redemptionSDK.getRedemptionTypes();
+    }
+    /**
+     * Redeem a redemption offer
+     *
+     * @param redemptionId - ID of the redemption to redeem
+     * @returns Promise resolving to redemption result
+     */
+    async redeemOffer(redemptionId) {
+        return this.redemptionSDK.redeemRedemption(redemptionId);
+    }
+    /**
+     * Get user's redemption history
+     *
+     * @returns Promise resolving to array of user's redemptions
+     */
+    async getUserRedemptions() {
+        return this.redemptionSDK.getUserRedeems();
+    }
+    /**
+     * Admin: Get all redemptions
+     *
+     * @param active - Filter by active status
+     * @returns Promise resolving to array of redemptions
+     */
+    async getAllRedemptions(active) {
+        return this.redemptionSDK.getRedemptionsAsAdmin(active);
+    }
+    /**
+     * Admin: Create new redemption offer
+     *
+     * @param redemptionData - Redemption data
+     * @returns Promise resolving to created redemption
+     */
+    async createRedemption(redemptionData) {
+        return this.redemptionSDK.createRedemption(redemptionData);
+    }
+    /**
+     * Admin: Update redemption
+     *
+     * @param redemptionId - ID of redemption to update
+     * @param redemptionData - Updated redemption data
+     * @returns Promise resolving to updated redemption
+     */
+    async updateRedemption(redemptionId, redemptionData) {
+        return this.redemptionSDK.updateRedemption(redemptionId, redemptionData);
+    }
+    /**
+     * Admin: Toggle redemption active status
+     *
+     * @param redemptionId - ID of redemption to toggle
+     * @returns Promise resolving to updated redemption
+     */
+    async toggleRedemptionStatus(redemptionId) {
+        return this.redemptionSDK.toggleRedemptionActive(redemptionId);
+    }
+    /**
+     * Admin: Create redemption token unit
+     *
+     * @param redemptionId - ID of redemption
+     * @param tokenUnit - Token unit data
+     * @returns Promise resolving to updated redemption
+     */
+    async createRedemptionTokenUnit(redemptionId, tokenUnit) {
+        return this.redemptionSDK.createRedemptionTokenUnit(redemptionId, tokenUnit);
+    }
+    /**
+     * Admin: Delete redemption token unit
+     *
+     * @param redemptionId - ID of redemption
+     * @param tokenUnitId - ID of token unit to delete
+     * @returns Promise resolving to updated redemption
+     */
+    async deleteRedemptionTokenUnit(redemptionId, tokenUnitId) {
+        return this.redemptionSDK.deleteRedemptionTokenUnit(redemptionId, tokenUnitId);
+    }
+    /**
+     * Get the full redemption SDK for advanced operations
+     *
+     * @returns RedemptionSDK instance
+     */
+    getRedemptionSDK() {
+        return this.redemptionSDK;
+    }
+}
+
+/**
+ * Transaction Manager - Clean, high-level interface for transaction operations
+ *
+ * Provides a simplified API for common transaction management tasks while maintaining
+ * access to the full transaction SDK for advanced use cases.
+ */
+class TransactionManager {
+    constructor(apiClient) {
+        this.apiClient = apiClient;
+        this.transactionSDK = createTransactionSDK(apiClient);
+    }
+    /**
+     * Get transaction by ID
+     *
+     * @param transactionId - ID of the transaction
+     * @returns Promise resolving to transaction data
+     */
+    async getTransactionById(transactionId) {
+        return this.transactionSDK.getTransactionById(transactionId);
+    }
+    /**
+     * Create a new transaction
+     *
+     * @param transactionData - Transaction data
+     * @returns Promise resolving to transaction response
+     */
+    async createTransaction(transactionData) {
+        return this.transactionSDK.createTransaction(transactionData);
+    }
+    /**
+     * Get user's transaction history
+     *
+     * @param type - Transaction type filter
+     * @returns Promise resolving to array of user's transactions
+     */
+    async getUserTransactionHistory(type) {
+        return this.transactionSDK.getUserTransactionHistory(type);
+    }
+    /**
+     * Admin: Get all tenant transactions
+     *
+     * @returns Promise resolving to array of tenant transactions
+     */
+    async getTenantTransactions() {
+        return this.transactionSDK.getTenantTransactions();
+    }
+    /**
+     * Admin: Get paginated transactions
+     *
+     * @param params - Pagination parameters
+     * @returns Promise resolving to paginated transaction results
+     */
+    async getPaginatedTransactions(params) {
+        return this.transactionSDK.getPaginatedTransactions(params);
+    }
+    /**
+     * Admin: Export transactions as CSV
+     *
+     * @returns Promise resolving to CSV blob
+     */
+    async exportTransactionsCSV() {
+        return this.transactionSDK.exportTransactionsCSV();
+    }
+    /**
+     * Get the full transaction SDK for advanced operations
+     *
+     * @returns TransactionSDK instance
+     */
+    getTransactionSDK() {
+        return this.transactionSDK;
+    }
+}
+
+/**
+ * Payment Manager - Clean, high-level interface for payment operations
+ *
+ * Provides a simplified API for common payment management tasks while maintaining
+ * access to the full payment SDK for advanced use cases.
+ */
+class PaymentManager {
+    constructor(apiClient) {
+        this.apiClient = apiClient;
+        this.paymentSDK = createPaymentSDK(apiClient);
+    }
+    /**
+     * Create a payment intent
+     *
+     * @param amount - Payment amount
+     * @param currency - Payment currency
+     * @param receiptEmail - Receipt email
+     * @param description - Payment description
+     * @returns Promise resolving to created payment intent
+     */
+    async createPaymentIntent(amount, currency, receiptEmail, description) {
+        return this.paymentSDK.createPaymentIntent(amount, currency, receiptEmail, description);
+    }
+    /**
+     * Get active purchase tokens
+     *
+     * @param active - Filter by active status
+     * @returns Promise resolving to purchase tokens
+     */
+    async getActivePurchaseTokens(active) {
+        return this.paymentSDK.getActivePurchaseTokens(active);
+    }
+    /**
+     * Get all user purchases
+     *
+     * @returns Promise resolving to array of user's purchases
+     */
+    async getAllUserPurchases() {
+        return this.paymentSDK.getAllUserPurchases();
+    }
+    /**
+     * Get the full payment SDK for advanced operations
+     *
+     * @returns PaymentSDK instance
+     */
+    getPaymentSDK() {
+        return this.paymentSDK;
+    }
+}
+
+/**
+ * Tenant Manager - Clean, high-level interface for tenant operations
+ *
+ * Provides a simplified API for common tenant management tasks while maintaining
+ * access to the full tenant SDK for advanced use cases.
+ */
+class TenantManager {
+    constructor(apiClient) {
+        this.apiClient = apiClient;
+        this.tenantSDK = createTenantSDK(apiClient);
+    }
+    /**
+     * Get current tenant information
+     *
+     * @returns Promise resolving to tenant data
+     */
+    async getTenantInfo() {
+        return this.tenantSDK.getRemoteTenant();
+    }
+    /**
+     * Get tenant login token
+     *
+     * @returns Promise resolving to login token
+     */
+    async getLoginToken() {
+        return this.tenantSDK.getRemoteLoginToken();
+    }
+    /**
+     * Get tenant client configuration
+     *
+     * @returns Promise resolving to client config
+     */
+    async getClientConfig() {
+        return this.tenantSDK.getRemoteClientConfig();
+    }
+    /**
+     * Admin: Update tenant data
+     *
+     * @param tenantData - Updated tenant data
+     * @returns Promise resolving to updated tenant
+     */
+    async updateTenant(tenantData) {
+        return this.tenantSDK.updateRemoteTenant(tenantData);
+    }
+    /**
+     * Admin: Get all admins
+     *
+     * @returns Promise resolving to array of admins
+     */
+    async getAdmins() {
+        return this.tenantSDK.getAdmins();
+    }
+    /**
+     * Admin: Create new admin
+     *
+     * @param adminData - Admin data
+     * @returns Promise resolving to created admin
+     */
+    async createAdmin(adminData) {
+        return this.tenantSDK.postAdmin(adminData);
+    }
+    /**
+     * Get the full tenant SDK for advanced operations
+     *
+     * @returns TenantSDK instance
+     */
+    getTenantSDK() {
+        return this.tenantSDK;
+    }
+}
+
+/**
+ * Analytics Manager - Clean, high-level interface for analytics operations
+ *
+ * Provides a simplified API for common analytics tasks while maintaining
+ * access to the full analytics SDK for advanced use cases.
+ */
+class AnalyticsManager {
+    constructor(apiClient) {
+        this.apiClient = apiClient;
+        this.analyticsSDK = createAnalyticsSDK(apiClient);
+    }
+    /**
+     * Get transaction analytics
+     *
+     * @param request - Analytics request parameters
+     * @returns Promise resolving to transaction analytics data
+     */
+    async getTransactionAnalytics(request) {
+        return this.analyticsSDK.getTransactionAnalytics(request);
+    }
+    /**
+     * Get the full analytics SDK for advanced operations
+     *
+     * @returns AnalyticsSDK instance
+     */
+    getAnalyticsSDK() {
+        return this.analyticsSDK;
+    }
+}
+
+/**
+ * Donation Manager - Clean, high-level interface for donation operations
+ *
+ * Provides a simplified API for common donation tasks while maintaining
+ * access to the full donation SDK for advanced use cases.
+ */
+class DonationManager {
+    constructor(apiClient) {
+        this.apiClient = apiClient;
+        this.donationSDK = createDonationSDK(apiClient);
+    }
+    /**
+     * Get available donation types
+     *
+     * @returns Promise resolving to array of donation types
+     */
+    async getDonationTypes() {
+        return this.donationSDK.getAllDonationTypes();
+    }
+    /**
+     * Get the full donation SDK for advanced operations
+     *
+     * @returns DonationSDK instance
+     */
+    getDonationSDK() {
+        return this.donationSDK;
+    }
+}
+
+/**
+ * PERS SDK - Platform-agnostic TypeScript SDK with High-Level Managers
+ *
+ * ## Overview
+ *
+ * The PERS SDK provides a comprehensive interface for integrating with the PERS
+ * (Phygital Experience Rewards System) platform. It features a clean manager-based
+ * architecture that abstracts complex domain operations into intuitive high-level APIs.
+ *
+ * ## Architecture
+ *
+ * ```
+ * PersSDK
+ * ├── Domain Managers (Recommended)    // High-level, intuitive APIs
+ * │   ├── auth: AuthManager           // Authentication & user sessions
+ * │   ├── users: UserManager          // User profile management
+ * │   ├── tokens: TokenManager        // Token balances & transfers
+ * │   ├── businesses: BusinessManager // Business operations
+ * │   ├── campaigns: CampaignManager  // Marketing campaigns
+ * │   ├── redemptions: RedemptionManager // Reward redemptions
+ * │   ├── transactions: TransactionManager // Transaction history
+ * │   ├── payments: PaymentManager    // Payment processing
+ * │   └── analytics: AnalyticsManager // Reporting & analytics
+ * ├── Domain SDKs (Advanced)          // Full-featured domain access
+ * │   ├── createBusinessSDK()
+ * │   ├── createCampaignSDK()
+ * │   └── TokenSDK, etc.
+ * └── Core API Client (Expert)        // Direct REST API access
+ *     └── api(): PersApiClient
+ * ```
+ *
+ * ## Usage Patterns
+ *
+ * ### 1. High-Level Manager Pattern (Recommended)
+ *
+ * ```typescript
+ * import { PersSDK } from '@explorins/pers-sdk';
+ * import { BrowserFetchClientAdapter } from '@explorins/pers-sdk/platform-adapters';
+ *
+ * const sdk = new PersSDK(new BrowserFetchClientAdapter(), {
+ *   environment: 'production',
+ *   apiProjectKey: 'your-project-key'
+ * });
+ *
+ * // Clean, intuitive manager interface
+ * const user = await sdk.auth.getCurrentUser();
+ * const campaigns = await sdk.campaigns.getActiveCampaigns();
+ * const balances = await sdk.tokens.getTokens();
+ * ```
+ *
+ * ### 2. Advanced Domain SDK Access
+ *
+ * ```typescript
+ * // Access full SDK capabilities when needed
+ * const campaignSDK = sdk.campaigns.getCampaignSDK();
+ * const advancedCampaignOps = await campaignSDK.api.createComplexCampaign(data);
+ * ```
+ *
+ * ### 3. Direct API Client Access
+ *
+ * ```typescript
+ * // For custom endpoints or advanced operations
+ * const apiClient = sdk.api();
+ * const customData = await apiClient.get('/custom-endpoint');
+ * ```
+ *
+ * ## Platform Integration
+ *
+ * The SDK provides pre-built adapters for common platforms:
+ *
+ * - **Angular**: `AngularHttpClientAdapter`
+ * - **Browser/React/Vue**: `BrowserFetchClientAdapter`
+ * - **Node.js**: `NodeHttpClientAdapter`
+ * - **Custom**: Implement `HttpClient` interface
+ *
+ * ## Features
+ *
+ * - ✅ **Type-safe**: Full TypeScript support with comprehensive type definitions
+ * - ✅ **Platform-agnostic**: Works in browsers, Node.js, React Native, and more
+ * - ✅ **Authentication**: Automatic token management and refresh
+ * - ✅ **Error handling**: Comprehensive error handling with typed exceptions
+ * - ✅ **Modular**: Import only the domains you need
+ * - ✅ **Manager pattern**: Clean, high-level APIs for common operations
+ * - ✅ **Backward compatible**: Maintains compatibility with existing integrations
+ * - ✅ **Tree-shakable**: Optimized for minimal bundle size
+ *
+ * @example Basic Setup
+ * ```typescript
+ * import { PersSDK } from '@explorins/pers-sdk';
+ * import { BrowserFetchClientAdapter } from '@explorins/pers-sdk/platform-adapters';
+ *
+ * const sdk = new PersSDK(new BrowserFetchClientAdapter(), {
+ *   environment: 'production',
+ *   apiProjectKey: 'your-project-key'
+ * });
+ * ```
+ *
+ * @example Authentication Flow
+ * ```typescript
+ * // Login with external JWT (Firebase, Auth0, etc.)
+ * await sdk.auth.loginWithToken(firebaseJWT, 'user');
+ *
+ * // Check authentication status
+ * if (await sdk.auth.isAuthenticated()) {
+ *   const user = await sdk.auth.getCurrentUser();
+ *   console.log('Welcome,', user.name);
+ * }
+ * ```
+ *
+ * @example Business Operations
+ * ```typescript
+ * // Get active businesses
+ * const businesses = await sdk.businesses.getActiveBusinesses();
+ *
+ * // Get business details
+ * const business = await sdk.businesses.getBusinessById(businessId);
+ *
+ * // Admin: Create new business
+ * const newBusiness = await sdk.businesses.createBusiness({
+ *   name: 'New Business',
+ *   location: 'City Center',
+ *   type: 'restaurant'
+ * });
+ * ```
+ *
+ * @example Campaign Management
+ * ```typescript
+ * // Get active campaigns
+ * const campaigns = await sdk.campaigns.getActiveCampaigns();
+ *
+ * // Claim a campaign
+ * await sdk.campaigns.claimCampaign({
+ *   campaignId: 'campaign-123',
+ *   metadata: { source: 'mobile-app' }
+ * });
+ *
+ * // Get user's claims
+ * const claims = await sdk.campaigns.getUserClaims();
+ * ```
+ *
+ * @example Token Operations
+ * ```typescript
+ * // Get user's token balances
+ * const tokens = await sdk.tokens.getTokens();
+ *
+ * // Transfer tokens between users
+ * await sdk.tokens.transferTokens({
+ *   fromUserId: 'user-1',
+ *   toUserId: 'user-2',
+ *   tokenType: 'CREDIT',
+ *   amount: 100
+ * });
+ * ```
+ *
+ * @since 1.3.0 - Manager pattern architecture
+ */
+/**
+ * PERS SDK class with domain managers
+ *
+ * Main SDK interface providing clean, high-level managers for common operations
+ * while maintaining full access to the underlying API client and domain SDKs.
+ *
+ * @example
+ * ```typescript
+ * import { PersSDK, createAuthProvider } from '@explorins/pers-sdk/core';
+ * import { BrowserHttpClient } from '@explorins/pers-sdk/browser';
+ *
+ * const authProvider = createAuthProvider({
+ *   tokenProvider: () => getFirebaseToken()
+ * });
+ *
+ * const sdk = new PersSDK(new BrowserHttpClient(), {
+ *   environment: 'production',
+ *   apiProjectKey: 'your-project-key',
+ *   authProvider
+ * });
+ *
+ * // High-level manager interface
+ * const user = await sdk.auth.getCurrentUser();
+ * const tokens = await sdk.tokens.getTokens();
+ * const businesses = await sdk.business.getActiveBusinesses();
+ *
+ * // Direct API access for advanced operations
+ * const apiClient = sdk.api();
+ * const customData = await apiClient.get('/custom-endpoint');
+ * ```
+ */
+class PersSDK {
+    /**
+     * Creates a new PERS SDK instance
+     *
+     * @param httpClient Platform-specific HTTP client implementation
+     * @param config SDK configuration options
+     */
+    constructor(httpClient, config) {
+        this.apiClient = new PersApiClient(httpClient, config);
+        // Initialize domain managers
+        this._auth = new AuthManager(this.apiClient);
+        this._users = new UserManager(this.apiClient);
+        this._tokens = new TokenManager(this.apiClient);
+        this._businesses = new BusinessManager(this.apiClient);
+        this._campaigns = new CampaignManager(this.apiClient);
+        this._redemptions = new RedemptionManager(this.apiClient);
+        this._transactions = new TransactionManager(this.apiClient);
+        this._payments = new PaymentManager(this.apiClient);
+        this._tenants = new TenantManager(this.apiClient);
+        this._analytics = new AnalyticsManager(this.apiClient);
+        this._donations = new DonationManager(this.apiClient);
+    }
+    /**
+     * Authentication manager - High-level auth operations
+     *
+     * @example
+     * ```typescript
+     * await sdk.auth.loginWithToken(jwtToken);
+     * const user = await sdk.auth.getCurrentUser();
+     * const isAuth = await sdk.auth.isAuthenticated();
+     * ```
+     */
+    get auth() {
+        return this._auth;
+    }
+    /**
+     * User manager - High-level user operations
+     *
+     * @example
+     * ```typescript
+     * const user = await sdk.user.getCurrentUser();
+     * await sdk.user.updateCurrentUser(userData);
+     * const users = await sdk.user.getAllUsersPublic();
+     * ```
+     */
+    get users() {
+        return this._users;
+    }
+    /**
+     * Token manager - High-level token operations
+     *
+     * @example
+     * ```typescript
+     * const tokens = await sdk.tokens.getTokens();
+     * const creditToken = await sdk.tokens.getActiveCreditToken();
+     * const rewards = await sdk.tokens.getRewardTokens();
+     * ```
+     */
+    get tokens() {
+        return this._tokens;
+    }
+    /**
+     * Business manager - High-level business operations
+     *
+     * @example
+     * ```typescript
+     * const businesses = await sdk.business.getActiveBusinesses();
+     * const business = await sdk.business.getBusinessById(id);
+     * const types = await sdk.business.getBusinessTypes();
+     * ```
+     */
+    get businesses() {
+        return this._businesses;
+    }
+    /**
+     * Campaign manager - High-level campaign operations
+     *
+     * @example
+     * ```typescript
+     * const campaigns = await sdk.campaigns.getActiveCampaigns();
+     * await sdk.campaigns.claimCampaign(claimData);
+     * const claims = await sdk.campaigns.getUserClaims();
+     * ```
+     */
+    get campaigns() {
+        return this._campaigns;
+    }
+    /**
+     * Redemption manager - High-level redemption operations
+     *
+     * @example
+     * ```typescript
+     * const redemptions = await sdk.redemptions.getActiveRedemptions();
+     * await sdk.redemptions.redeemOffer(redemptionId);
+     * const history = await sdk.redemptions.getUserRedemptions();
+     * ```
+     */
+    get redemptions() {
+        return this._redemptions;
+    }
+    /**
+     * Transaction manager - High-level transaction operations
+     *
+     * @example
+     * ```typescript
+     * const transaction = await sdk.transactions.getTransactionById(id);
+     * await sdk.transactions.createTransaction(txData);
+     * const history = await sdk.transactions.getUserTransactionHistory('all');
+     * ```
+     */
+    get transactions() {
+        return this._transactions;
+    }
+    /**
+     * Payment manager - High-level payment operations
+     *
+     * @example
+     * ```typescript
+     * const intent = await sdk.payments.createPaymentIntent(100, 'usd', 'email@example.com', 'Purchase');
+     * const tokens = await sdk.payments.getActivePurchaseTokens();
+     * const purchases = await sdk.payments.getAllUserPurchases();
+     * ```
+     */
+    get payments() {
+        return this._payments;
+    }
+    /**
+     * Tenant manager - High-level tenant operations
+     *
+     * @example
+     * ```typescript
+     * const tenant = await sdk.tenant.getTenantInfo();
+     * const config = await sdk.tenant.getClientConfig();
+     * const admins = await sdk.tenant.getAdmins();
+     * ```
+     */
+    get tenants() {
+        return this._tenants;
+    }
+    /**
+     * Analytics manager - High-level analytics operations
+     *
+     * @example
+     * ```typescript
+     * const analytics = await sdk.analytics.getTransactionAnalytics(request);
+     * ```
+     */
+    get analytics() {
+        return this._analytics;
+    }
+    /**
+     * Donation manager - High-level donation operations
+     *
+     * @example
+     * ```typescript
+     * const types = await sdk.donations.getDonationTypes();
+     * ```
+     */
+    get donations() {
+        return this._donations;
+    }
+    /**
+     * Gets the API client for direct PERS API requests
+     *
+     * Use this for advanced operations not covered by the managers.
+     * The returned client handles authentication, token refresh, and error handling automatically.
+     *
+     * @returns Configured PersApiClient instance
+     *
+     * @example
+     * ```typescript
+     * const apiClient = sdk.api();
+     * const customData = await apiClient.get<CustomType>('/custom-endpoint');
+     * await apiClient.post('/custom-endpoint', customData);
+     * ```
+     */
+    api() {
+        return this.apiClient;
+    }
+    /**
+     * Checks if SDK is configured for production environment
+     *
+     * @returns True if environment is 'production', false otherwise
+     */
+    isProduction() {
+        return this.apiClient.getConfig().environment === 'production';
+    }
+}
+/**
+ * Factory function for creating PERS SDK
+ *
+ * @param httpClient Platform-specific HTTP client implementation
+ * @param config SDK configuration options
+ * @returns PERS SDK instance
  */
 function createPersSDK(httpClient, config) {
     return new PersSDK(httpClient, config);
 }
 
-export { DEFAULT_PERS_CONFIG as D, PersSDK as P, createPersSDK as a, PersApiClient as b, createAuthProvider as c, buildApiRoot as d, mergeWithDefaults as m };
-//# sourceMappingURL=pers-sdk-Rc8YKyNc.js.map
+export { AuthManager as A, BusinessManager as B, CampaignManager as C, DEFAULT_PERS_CONFIG as D, PersSDK as P, RedemptionManager as R, TokenManager as T, UserManager as U, createAuthProvider as a, PersApiClient as b, createPersSDK as c, buildApiRoot as d, TransactionManager as e, PaymentManager as f, TenantManager as g, AnalyticsManager as h, DonationManager as i, mergeWithDefaults as m };
+//# sourceMappingURL=pers-sdk-CVSAFBLh.js.map