@explorins/pers-sdk 1.3.16 → 1.5.2

package/dist/chunks/{pers-sdk-DiwCwBiC.cjs → pers-sdk-CI2YXKb_.cjs}

@@ -1,6 +1,16 @@
 'use strict';
 
 var persShared = require('@explorins/pers-shared');
+var user = require('../user.cjs');
+var tokenSdk = require('./token-sdk-CiAbOb6c.cjs');
+var business = require('../business.cjs');
+var campaign = require('../campaign.cjs');
+var redemption = require('../redemption.cjs');
+var transaction = require('../transaction.cjs');
+var payment = require('../payment.cjs');
+var tenant = require('../tenant.cjs');
+var analytics = require('../analytics.cjs');
+var donation = require('../donation.cjs');
 
 /**
  * PERS SDK Configuration interfaces and utilities
@@ -300,7 +310,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;
     }
@@ -381,7 +391,7 @@ class TokenManager {
     async clearProviderToken() {
         await this.storage.removeToken(AUTH_STORAGE_KEYS.PROVIDER_TOKEN);
     }
-}
+};
 
 /**
  * PERS SDK Error Handling - Optimized for Performance
@@ -744,7 +754,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);
     }
@@ -1615,85 +1625,1360 @@ 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 = user.createUserSDK(apiClient);
+    }
+    /**
+     * Get current user profile
+     *
+     * @returns Promise resolving to current user data
+     */
+    async getCurrentUser() {
+        return this.userSDK.getRemoteUser();
+    }
+    /**
+     * Update current user profile
+     *
+     * @param userData - User data to update
+     * @returns Promise resolving to updated user data
+     */
+    async updateCurrentUser(userData) {
+        return this.userSDK.updateRemoteUser(userData);
+    }
+    /**
+     * Get user by unique identifier
+     *
+     * @param identifier - Unique identifier for the user
+     * @returns Promise resolving to user data
+     */
+    async getUserById(identifier) {
+        return this.userSDK.getUserByUniqueIdentifier(identifier);
+    }
+    /**
+     * Get all users public profiles with optional filtering
+     *
+     * @param filter - Optional filter criteria
+     * @returns Promise resolving to array of user public profiles
+     */
+    async getAllUsersPublic(filter) {
+        return this.userSDK.getAllUsersPublicProfiles(filter || null);
+    }
+    /**
+     * Admin: Get all users
+     *
+     * @returns Promise resolving to array of all users
+     */
+    async getAllUsers() {
+        return this.userSDK.getAllRemoteUsers();
+    }
+    /**
+     * Admin: Update user data
+     *
+     * @param userId - ID of user to update
+     * @param userData - User data to update
+     * @returns Promise resolving to updated user data
+     */
+    async updateUser(userId, userData) {
+        return this.userSDK.updateUserAsAdmin(userId, userData);
+    }
+    /**
+     * Admin: Toggle user active status
+     *
+     * @param user - User to toggle status for
+     * @returns Promise resolving to updated user data
+     */
+    async toggleUserStatus(user) {
+        return this.userSDK.toggleUserActiveStatusByUser(user);
+    }
+    /**
+     * Get the full user SDK for advanced operations
+     *
+     * @returns UserSDK instance
+     */
+    getUserSDK() {
+        return this.userSDK;
+    }
+}
+
+/**
+ * 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.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 = business.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 = campaign.createCampaignSDK(apiClient);
+    }
+    /**
+     * Get all active campaigns
+     *
+     * @returns Promise resolving to array of active campaigns
+     */
+    async getActiveCampaigns() {
+        return this.campaignSDK.getActiveCampaigns();
+    }
+    /**
+     * Get campaign by ID
+     *
+     * @param campaignId - ID of the campaign
+     * @returns Promise resolving to campaign data
+     */
+    async getCampaignById(campaignId) {
+        return this.campaignSDK.getCampaignById(campaignId);
+    }
+    /**
+     * Claim a campaign reward
+     *
+     * @param claimRequest - Campaign claim data
+     * @returns Promise resolving to claim result
+     */
+    async claimCampaign(claimRequest) {
+        return this.campaignSDK.claimCampaign(claimRequest);
+    }
+    /**
+     * Get user's campaign claims
+     *
+     * @returns Promise resolving to array of user's claims
+     */
+    async getUserClaims() {
+        return this.campaignSDK.getClaimsForLoggedUser();
+    }
+    /**
+     * Admin: Get all campaigns
+     *
+     * @param active - Filter by active status
+     * @returns Promise resolving to array of campaigns
+     */
+    async getAllCampaigns(active) {
+        return this.campaignSDK.getCampaigns(active);
+    }
+    /**
+     * Admin: Create new campaign
+     *
+     * @param campaignData - Campaign data
+     * @returns Promise resolving to created campaign
+     */
+    async createCampaign(campaignData) {
+        return this.campaignSDK.createCampaign(campaignData);
+    }
+    /**
+     * Admin: Update campaign
+     *
+     * @param campaignId - ID of campaign to update
+     * @param campaignData - Updated campaign data
+     * @returns Promise resolving to updated campaign
+     */
+    async updateCampaign(campaignId, campaignData) {
+        return this.campaignSDK.updateCampaign(campaignId, campaignData);
+    }
+    /**
+     * Admin: Toggle campaign active status
+     *
+     * @param campaignId - ID of campaign to toggle
+     * @returns Promise resolving to updated campaign
+     */
+    async toggleCampaignStatus(campaignId) {
+        return this.campaignSDK.toggleCampaignActive(campaignId);
+    }
+    /**
+     * Admin: Toggle campaign testnet environment
+     *
+     * @param campaignId - ID of campaign to toggle
+     * @returns Promise resolving to updated campaign
+     */
+    async toggleCampaignTestnet(campaignId) {
+        return this.campaignSDK.toggleCampaignTestnet(campaignId);
+    }
+    /**
+     * Admin: Get campaign triggers
+     *
+     * @returns Promise resolving to array of campaign triggers
+     */
+    async getCampaignTriggers() {
+        return this.campaignSDK.getCampaignTriggers();
+    }
+    /**
+     * Admin: Set campaign trigger
+     *
+     * @param campaignId - ID of campaign
+     * @param triggerId - ID of trigger to set
+     * @returns Promise resolving to updated campaign
+     */
+    async setCampaignTrigger(campaignId, triggerId) {
+        return this.campaignSDK.setCampaignTrigger(campaignId, triggerId);
+    }
+    /**
+     * Admin: Create campaign token unit
+     *
+     * @param campaignId - ID of campaign
+     * @param tokenUnit - Token unit data
+     * @returns Promise resolving to updated campaign
+     */
+    async createCampaignTokenUnit(campaignId, tokenUnit) {
+        return this.campaignSDK.createCampaignTokenUnit(campaignId, tokenUnit);
+    }
+    /**
+     * Admin: Delete campaign token unit
+     *
+     * @param campaignId - ID of campaign
+     * @param tokenUnitId - ID of token unit to delete
+     * @returns Promise resolving to updated campaign
+     */
+    async deleteCampaignTokenUnit(campaignId, tokenUnitId) {
+        return this.campaignSDK.deleteCampaignTokenUnit(campaignId, tokenUnitId);
+    }
+    /**
+     * Admin: Add business engagement to campaign
+     *
+     * @param campaignId - ID of campaign
+     * @param engagement - Business engagement data
+     * @returns Promise resolving to updated campaign
+     */
+    async addBusinessEngagementToCampaign(campaignId, engagement) {
+        return this.campaignSDK.addBusinessEngagementToCampaign(campaignId, engagement);
+    }
+    /**
+     * Admin: Update campaign business engagement
+     *
+     * @param campaignId - ID of campaign
+     * @param engagementId - ID of engagement to update
+     * @param engagement - Updated engagement data
+     * @returns Promise resolving to updated campaign
+     */
+    async updateCampaignBusinessEngagement(campaignId, engagementId, engagement) {
+        return this.campaignSDK.updateCampaignBusinessEngagement(campaignId, engagementId, engagement);
+    }
+    /**
+     * Admin: Delete campaign business engagement
+     *
+     * @param campaignId - ID of campaign
+     * @param engagementId - ID of engagement to delete
+     * @returns Promise resolving to updated campaign
+     */
+    async deleteCampaignBusinessEngagement(campaignId, engagementId) {
+        return this.campaignSDK.deleteCampaignBusinessEngagement(campaignId, engagementId);
+    }
+    /**
+     * Admin: Get all campaign claims
+     *
+     * @returns Promise resolving to array of campaign claims
+     */
+    async getCampaignClaims() {
+        return this.campaignSDK.getCampaignClaims();
+    }
+    /**
+     * Admin: Get campaign claims by user ID
+     *
+     * @param userId - ID of user
+     * @returns Promise resolving to array of user's campaign claims
+     */
+    async getCampaignClaimsByUserId(userId) {
+        return this.campaignSDK.getCampaignClaimsByUserId(userId);
+    }
+    /**
+     * Admin: Get campaign claims by business ID
+     *
+     * @param businessId - ID of business
+     * @returns Promise resolving to array of business's campaign claims
+     */
+    async getCampaignClaimsByBusinessId(businessId) {
+        return this.campaignSDK.getCampaignClaimsByBusinessId(businessId);
+    }
+    /**
+     * Get the full campaign SDK for advanced operations
+     *
+     * @returns CampaignSDK instance
+     */
+    getCampaignSDK() {
+        return this.campaignSDK;
+    }
+}
+
+/**
+ * Redemption Manager - Clean, high-level interface for redemption operations
+ *
+ * Provides a simplified API for common redemption management tasks while maintaining
+ * access to the full redemption SDK for advanced use cases.
+ */
+class RedemptionManager {
+    constructor(apiClient) {
+        this.apiClient = apiClient;
+        this.redemptionSDK = redemption.createRedemptionSDK(apiClient);
+    }
+    /**
+     * Get all active redemption offers
+     *
+     * @returns Promise resolving to array of active redemptions
+     */
+    async getActiveRedemptions() {
+        return this.redemptionSDK.getActiveRedemptions();
+    }
+    /**
+     * Get available redemption types
+     *
+     * @returns Promise resolving to array of redemption types
+     */
+    async getRedemptionTypes() {
+        return this.redemptionSDK.getRedemptionTypes();
+    }
+    /**
+     * Redeem a redemption offer
+     *
+     * @param redemptionId - ID of the redemption to redeem
+     * @returns Promise resolving to redemption result
+     */
+    async redeemOffer(redemptionId) {
+        return this.redemptionSDK.redeemRedemption(redemptionId);
+    }
+    /**
+     * Get user's redemption history
+     *
+     * @returns Promise resolving to array of user's redemptions
+     */
+    async getUserRedemptions() {
+        return this.redemptionSDK.getUserRedeems();
+    }
+    /**
+     * Admin: Get all redemptions
+     *
+     * @param active - Filter by active status
+     * @returns Promise resolving to array of redemptions
+     */
+    async getAllRedemptions(active) {
+        return this.redemptionSDK.getRedemptionsAsAdmin(active);
+    }
+    /**
+     * Admin: Create new redemption offer
+     *
+     * @param redemptionData - Redemption data
+     * @returns Promise resolving to created redemption
+     */
+    async createRedemption(redemptionData) {
+        return this.redemptionSDK.createRedemption(redemptionData);
+    }
+    /**
+     * Admin: Update redemption
+     *
+     * @param redemptionId - ID of redemption to update
+     * @param redemptionData - Updated redemption data
+     * @returns Promise resolving to updated redemption
+     */
+    async updateRedemption(redemptionId, redemptionData) {
+        return this.redemptionSDK.updateRedemption(redemptionId, redemptionData);
+    }
+    /**
+     * Admin: Toggle redemption active status
+     *
+     * @param redemptionId - ID of redemption to toggle
+     * @returns Promise resolving to updated redemption
+     */
+    async toggleRedemptionStatus(redemptionId) {
+        return this.redemptionSDK.toggleRedemptionActive(redemptionId);
+    }
+    /**
+     * Admin: Create redemption token unit
+     *
+     * @param redemptionId - ID of redemption
+     * @param tokenUnit - Token unit data
+     * @returns Promise resolving to updated redemption
+     */
+    async createRedemptionTokenUnit(redemptionId, tokenUnit) {
+        return this.redemptionSDK.createRedemptionTokenUnit(redemptionId, tokenUnit);
+    }
+    /**
+     * Admin: Delete redemption token unit
+     *
+     * @param redemptionId - ID of redemption
+     * @param tokenUnitId - ID of token unit to delete
+     * @returns Promise resolving to updated redemption
+     */
+    async deleteRedemptionTokenUnit(redemptionId, tokenUnitId) {
+        return this.redemptionSDK.deleteRedemptionTokenUnit(redemptionId, tokenUnitId);
+    }
+    /**
+     * Get the full redemption SDK for advanced operations
+     *
+     * @returns RedemptionSDK instance
+     */
+    getRedemptionSDK() {
+        return this.redemptionSDK;
+    }
+}
+
+/**
+ * Transaction Manager - Clean, high-level interface for transaction operations
+ *
+ * Provides a simplified API for common transaction management tasks while maintaining
+ * access to the full transaction SDK for advanced use cases.
+ */
+class TransactionManager {
+    constructor(apiClient) {
+        this.apiClient = apiClient;
+        this.transactionSDK = transaction.createTransactionSDK(apiClient);
+    }
+    /**
+     * Get transaction by ID
+     *
+     * @param transactionId - ID of the transaction
+     * @returns Promise resolving to transaction data
+     */
+    async getTransactionById(transactionId) {
+        return this.transactionSDK.getTransactionById(transactionId);
+    }
+    /**
+     * Create a new transaction
+     *
+     * @param transactionData - Transaction data
+     * @returns Promise resolving to transaction response
+     */
+    async createTransaction(transactionData) {
+        return this.transactionSDK.createTransaction(transactionData);
+    }
+    /**
+     * Get user's transaction history
+     *
+     * @param type - Transaction type filter
+     * @returns Promise resolving to array of user's transactions
+     */
+    async getUserTransactionHistory(type) {
+        return this.transactionSDK.getUserTransactionHistory(type);
+    }
+    /**
+     * Admin: Get all tenant transactions
+     *
+     * @returns Promise resolving to array of tenant transactions
+     */
+    async getTenantTransactions() {
+        return this.transactionSDK.getTenantTransactions();
+    }
+    /**
+     * Admin: Get paginated transactions
+     *
+     * @param params - Pagination parameters
+     * @returns Promise resolving to paginated transaction results
+     */
+    async getPaginatedTransactions(params) {
+        return this.transactionSDK.getPaginatedTransactions(params);
+    }
+    /**
+     * Admin: Export transactions as CSV
+     *
+     * @returns Promise resolving to CSV blob
+     */
+    async exportTransactionsCSV() {
+        return this.transactionSDK.exportTransactionsCSV();
+    }
+    /**
+     * Get the full transaction SDK for advanced operations
+     *
+     * @returns TransactionSDK instance
+     */
+    getTransactionSDK() {
+        return this.transactionSDK;
+    }
+}
+
+/**
+ * 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 = payment.createPaymentSDK(apiClient);
+    }
+    /**
+     * Create a payment intent
+     *
+     * @param amount - Payment amount
+     * @param currency - Payment currency
+     * @param receiptEmail - Receipt email
+     * @param description - Payment description
+     * @returns Promise resolving to created payment intent
+     */
+    async createPaymentIntent(amount, currency, receiptEmail, description) {
+        return this.paymentSDK.createPaymentIntent(amount, currency, receiptEmail, description);
+    }
+    /**
+     * Get active purchase tokens
+     *
+     * @param active - Filter by active status
+     * @returns Promise resolving to purchase tokens
+     */
+    async getActivePurchaseTokens(active) {
+        return this.paymentSDK.getActivePurchaseTokens(active);
+    }
+    /**
+     * Get all user purchases
+     *
+     * @returns Promise resolving to array of user's purchases
+     */
+    async getAllUserPurchases() {
+        return this.paymentSDK.getAllUserPurchases();
+    }
+    /**
+     * Get the full 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 = tenant.createTenantSDK(apiClient);
+    }
+    /**
+     * Get current tenant information
+     *
+     * @returns Promise resolving to tenant data
+     */
+    async getTenantInfo() {
+        return this.tenantSDK.getRemoteTenant();
+    }
+    /**
+     * Get tenant login token
+     *
+     * @returns Promise resolving to login token
+     */
+    async getLoginToken() {
+        return this.tenantSDK.getRemoteLoginToken();
+    }
+    /**
+     * Get tenant client configuration
+     *
+     * @returns Promise resolving to client config
+     */
+    async getClientConfig() {
+        return this.tenantSDK.getRemoteClientConfig();
+    }
+    /**
+     * Admin: Update tenant data
+     *
+     * @param tenantData - Updated tenant data
+     * @returns Promise resolving to updated tenant
+     */
+    async updateTenant(tenantData) {
+        return this.tenantSDK.updateRemoteTenant(tenantData);
+    }
+    /**
+     * Admin: Get all admins
+     *
+     * @returns Promise resolving to array of admins
+     */
+    async getAdmins() {
+        return this.tenantSDK.getAdmins();
+    }
+    /**
+     * Admin: Create new admin
+     *
+     * @param adminData - Admin data
+     * @returns Promise resolving to created admin
+     */
+    async createAdmin(adminData) {
+        return this.tenantSDK.postAdmin(adminData);
+    }
+    /**
+     * Get the full tenant SDK for advanced operations
+     *
+     * @returns TenantSDK instance
+     */
+    getTenantSDK() {
+        return this.tenantSDK;
+    }
+}
+
+/**
+ * Analytics Manager - Clean, high-level interface for analytics operations
+ *
+ * Provides a simplified API for common analytics tasks while maintaining
+ * access to the full analytics SDK for advanced use cases.
+ */
+class AnalyticsManager {
+    constructor(apiClient) {
+        this.apiClient = apiClient;
+        this.analyticsSDK = analytics.createAnalyticsSDK(apiClient);
+    }
+    /**
+     * Get transaction analytics
+     *
+     * @param request - Analytics request parameters
+     * @returns Promise resolving to transaction analytics data
+     */
+    async getTransactionAnalytics(request) {
+        return this.analyticsSDK.getTransactionAnalytics(request);
+    }
+    /**
+     * Get the full analytics SDK for advanced operations
+     *
+     * @returns AnalyticsSDK instance
+     */
+    getAnalyticsSDK() {
+        return this.analyticsSDK;
+    }
+}
+
+/**
+ * Donation Manager - Clean, high-level interface for donation operations
+ *
+ * Provides a simplified API for common donation tasks while maintaining
+ * access to the full donation SDK for advanced use cases.
+ */
+class DonationManager {
+    constructor(apiClient) {
+        this.apiClient = apiClient;
+        this.donationSDK = donation.createDonationSDK(apiClient);
+    }
+    /**
+     * Get available donation types
+     *
+     * @returns Promise resolving to array of donation types
+     */
+    async getDonationTypes() {
+        return this.donationSDK.getAllDonationTypes();
+    }
+    /**
+     * Get the full donation SDK for advanced operations
+     *
+     * @returns DonationSDK instance
+     */
+    getDonationSDK() {
+        return this.donationSDK;
+    }
+}
+
+/**
+ * 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);
 }
 
+exports.AnalyticsManager = AnalyticsManager;
+exports.AuthManager = AuthManager;
+exports.BusinessManager = BusinessManager;
+exports.CampaignManager = CampaignManager;
 exports.DEFAULT_PERS_CONFIG = DEFAULT_PERS_CONFIG;
+exports.DonationManager = DonationManager;
+exports.PaymentManager = PaymentManager;
 exports.PersApiClient = PersApiClient;
 exports.PersSDK = PersSDK;
+exports.RedemptionManager = RedemptionManager;
+exports.TenantManager = TenantManager;
+exports.TokenManager = TokenManager;
+exports.TransactionManager = TransactionManager;
+exports.UserManager = UserManager;
 exports.buildApiRoot = buildApiRoot;
 exports.createAuthProvider = createAuthProvider;
 exports.createPersSDK = createPersSDK;
 exports.mergeWithDefaults = mergeWithDefaults;
-//# sourceMappingURL=pers-sdk-DiwCwBiC.cjs.map
+//# sourceMappingURL=pers-sdk-CI2YXKb_.cjs.map