@explorins/pers-sdk-react-native 2.1.5 → 2.1.6

package/dist/index.js

@@ -2593,6 +2593,8 @@ exports.TransactionStatus = void 0;
     TransactionStatus["PROCESSING"] = "processing";
     // when transaction is pending to be signed
     TransactionStatus["PENDING_SIGNATURE"] = "pending_signature";
+    // when transaction is signed but pending submission (sign-only flow)
+    TransactionStatus["PENDING_SUBMISSION"] = "pending_submission";
     // after transaction has been broadcasted
     TransactionStatus["BROADCASTED"] = "broadcasted";
     // after transaction has succeeded
@@ -2634,6 +2636,7 @@ exports.ApiKeyType = void 0;
     ApiKeyType["BLOCKCHAIN_WRITER_JWT"] = "BLOCKCHAIN_WRITER_JWT";
     ApiKeyType["BLOCKCHAIN_READER_JWT"] = "BLOCKCHAIN_READER_JWT";
     ApiKeyType["TRANSACTION_JWT_ACCESS_TOKEN"] = "TRANSACTION_JWT_ACCESS_TOKEN";
+    ApiKeyType["WEBHOOK_OUTBOUND_JWT"] = "WEBHOOK_OUTBOUND_JWT";
     // TODO: this needs to be removed. However, there is still dependency
     ApiKeyType["TENANT_LEGACY_ADMIN"] = "TENANT_ADMIN_JWT";
     // TENANT_SYSTEM_API_SECRET    = 'TENANT_SYSTEM_API_SECRET',
@@ -2850,6 +2853,66 @@ exports.ProcessRecordStatus = void 0;
     ProcessRecordStatus["FAILED"] = "FAILED"; // Transaction processing failed (blockchain or validation error)
 })(exports.ProcessRecordStatus || (exports.ProcessRecordStatus = {}));
 
+/**
+ * Entity types that support file uploads in the storage system.
+ * Used for organizing uploaded files by entity category.
+ */
+exports.FileUploadEntityType = void 0;
+(function (FileUploadEntityType) {
+    FileUploadEntityType["TOKEN"] = "token";
+    FileUploadEntityType["CAMPAIGN"] = "campaign";
+    FileUploadEntityType["REDEMPTION"] = "redemption";
+    FileUploadEntityType["BUSINESS"] = "business";
+    FileUploadEntityType["TENANT"] = "tenant";
+    FileUploadEntityType["USER"] = "user";
+})(exports.FileUploadEntityType || (exports.FileUploadEntityType = {}));
+
+/**
+ * Types of signed URLs for storage operations.
+ * GET: For downloading/reading files
+ * PUT: For uploading/writing files
+ */
+exports.SignedUrlType = void 0;
+(function (SignedUrlType) {
+    SignedUrlType["GET"] = "GET";
+    SignedUrlType["PUT"] = "PUT";
+})(exports.SignedUrlType || (exports.SignedUrlType = {}));
+
+/**
+ * Token Validity Type Enum
+ *
+ * Defines how token expiry is calculated:
+ * - FIXED_DATE: Uses expiryDate directly as absolute expiration
+ * - DAYS_FROM_ISSUANCE: Computes expiry as issuance date + validityDuration days
+ * - HOURS_FROM_ISSUANCE: Computes expiry as issuance date + validityDuration hours
+ * - MONTHS_FROM_ISSUANCE: Computes expiry as issuance date + validityDuration months
+ * - END_OF_MONTH: Token expires at end of the month when issued
+ * - END_OF_YEAR: Token expires at end of the year when issued
+ */
+const TokenValidityTypes = {
+    FIXED_DATE: 'fixed_date',
+    DAYS_FROM_ISSUANCE: 'days_from_issuance',
+    HOURS_FROM_ISSUANCE: 'hours_from_issuance',
+    MONTHS_FROM_ISSUANCE: 'months_from_issuance',
+    END_OF_MONTH: 'end_of_month',
+    END_OF_YEAR: 'end_of_year',
+};
+const TOKEN_VALIDITY_TYPE_VALUES = Object.values(TokenValidityTypes);
+
+/**
+ * Balance Migration Type
+ *
+ * Defines how token balances should be migrated between accounts.
+ * Used during user merge operations and account balance transfers.
+ */
+exports.BalanceMigrationType = void 0;
+(function (BalanceMigrationType) {
+    /** Replace: New balance = from balance - to balance (diff only) */
+    BalanceMigrationType["REPLACE"] = "replace";
+    /** Merge: New balance = from balance (full transfer) */
+    BalanceMigrationType["MERGE"] = "merge";
+})(exports.BalanceMigrationType || (exports.BalanceMigrationType = {}));
+
 exports.PurchaseStatus = void 0;
 (function (PurchaseStatus) {
     // after creation of payment and before payment is done by user
@@ -2911,6 +2974,208 @@ exports.CampaignTriggerType = void 0;
     CampaignTriggerType["CLAIM_BY_BUSINESS"] = "CLAIM_BY_BUSINESS";
 })(exports.CampaignTriggerType || (exports.CampaignTriggerType = {}));
 
+/**
+ * AI Operation Types
+ *
+ * Categorizes AI generation operations for analytics and billing.
+ * Used across AI module and Analytics module.
+ */
+exports.AiOperationType = void 0;
+(function (AiOperationType) {
+    /** Text generation using Gemini models */
+    AiOperationType["TEXT_GENERATION"] = "TEXT_GENERATION";
+    /** Text generation with streaming response */
+    AiOperationType["TEXT_GENERATION_STREAM"] = "TEXT_GENERATION_STREAM";
+    /** Text generation with reasoning/thinking (Gemini 2.5+) */
+    AiOperationType["TEXT_WITH_REASONING"] = "TEXT_WITH_REASONING";
+    /** Image generation using Imagen models */
+    AiOperationType["IMAGE_GENERATION"] = "IMAGE_GENERATION";
+    /** Structured output generation with schema */
+    AiOperationType["STRUCTURED_OUTPUT"] = "STRUCTURED_OUTPUT";
+    /** Multimodal input processing (text + images) */
+    AiOperationType["MULTIMODAL"] = "MULTIMODAL";
+})(exports.AiOperationType || (exports.AiOperationType = {}));
+
+/**
+ * AI Trigger Process Types
+ *
+ * Identifies which business process triggered an AI generation.
+ * Used for cost allocation and analytics grouping.
+ *
+ * NOTE: This enum will grow as AI is integrated into more processes.
+ */
+exports.AiTriggerProcessType = void 0;
+(function (AiTriggerProcessType) {
+    /** AI triggered during transaction processing (e.g., dynamic token image/description) */
+    AiTriggerProcessType["TRANSACTION"] = "TRANSACTION";
+})(exports.AiTriggerProcessType || (exports.AiTriggerProcessType = {}));
+
+/**
+ * AI Analytics Metric Enum
+ *
+ * Available metrics for AI analytics aggregation and sorting.
+ */
+exports.AiAnalyticsMetric = void 0;
+(function (AiAnalyticsMetric) {
+    /** Count of generations */
+    AiAnalyticsMetric["COUNT"] = "count";
+    /** Total tokens (input + output) */
+    AiAnalyticsMetric["TOTAL_TOKENS"] = "totalTokens";
+    /** Input tokens */
+    AiAnalyticsMetric["INPUT_TOKENS"] = "inputTokens";
+    /** Output tokens */
+    AiAnalyticsMetric["OUTPUT_TOKENS"] = "outputTokens";
+    /** Total estimated cost in USD */
+    AiAnalyticsMetric["TOTAL_COST_USD"] = "totalCostUsd";
+    /** Average response time in milliseconds */
+    AiAnalyticsMetric["AVG_RESPONSE_TIME_MS"] = "avgResponseTimeMs";
+})(exports.AiAnalyticsMetric || (exports.AiAnalyticsMetric = {}));
+/**
+ * AI Analytics Group By Enum
+ *
+ * Available fields for grouping AI analytics results.
+ */
+exports.AiAnalyticsGroupBy = void 0;
+(function (AiAnalyticsGroupBy) {
+    /** Group by day */
+    AiAnalyticsGroupBy["DAY"] = "day";
+    /** Group by week */
+    AiAnalyticsGroupBy["WEEK"] = "week";
+    /** Group by month */
+    AiAnalyticsGroupBy["MONTH"] = "month";
+    /** Group by AI model */
+    AiAnalyticsGroupBy["MODEL"] = "model";
+    /** Group by operation type */
+    AiAnalyticsGroupBy["OPERATION_TYPE"] = "operationType";
+    /** Group by trigger process type */
+    AiAnalyticsGroupBy["TRIGGER_PROCESS_TYPE"] = "triggerProcessType";
+    /** Group by user ID */
+    AiAnalyticsGroupBy["USER_ID"] = "userId";
+    /** Group by success status */
+    AiAnalyticsGroupBy["SUCCESS"] = "success";
+})(exports.AiAnalyticsGroupBy || (exports.AiAnalyticsGroupBy = {}));
+
+/**
+ * Webhook-related enums
+ * Single source of truth for webhook types across the application
+ */
+/**
+ * HTTP methods allowed for webhook forwarding
+ */
+exports.WebhookMethod = void 0;
+(function (WebhookMethod) {
+    WebhookMethod["GET"] = "GET";
+    WebhookMethod["POST"] = "POST";
+    WebhookMethod["PUT"] = "PUT";
+    WebhookMethod["PATCH"] = "PATCH";
+    WebhookMethod["DELETE"] = "DELETE";
+})(exports.WebhookMethod || (exports.WebhookMethod = {}));
+/**
+ * Authentication types for outbound webhook forwarding
+ */
+exports.WebhookAuthType = void 0;
+(function (WebhookAuthType) {
+    WebhookAuthType["NONE"] = "NONE";
+    WebhookAuthType["BEARER"] = "BEARER";
+    WebhookAuthType["JWT"] = "JWT";
+})(exports.WebhookAuthType || (exports.WebhookAuthType = {}));
+/**
+ * Sources that can invoke a webhook
+ */
+exports.WebhookSource = void 0;
+(function (WebhookSource) {
+    // Internal authenticated sources
+    WebhookSource["USER"] = "USER";
+    WebhookSource["BUSINESS"] = "BUSINESS";
+    WebhookSource["TENANT"] = "TENANT";
+    // External verified sources
+    WebhookSource["STRIPE"] = "STRIPE";
+    // Allow any external traffic (no verification)
+    WebhookSource["ANY"] = "ANY";
+})(exports.WebhookSource || (exports.WebhookSource = {}));
+/**
+ * Webhook execution status
+ */
+exports.WebhookExecutionStatus = void 0;
+(function (WebhookExecutionStatus) {
+    WebhookExecutionStatus["PENDING"] = "PENDING";
+    WebhookExecutionStatus["SUCCESS"] = "SUCCESS";
+    WebhookExecutionStatus["FAILED"] = "FAILED";
+    WebhookExecutionStatus["BLOCKED"] = "BLOCKED";
+})(exports.WebhookExecutionStatus || (exports.WebhookExecutionStatus = {}));
+/**
+ * Webhook callback status (from external workflow engine)
+ */
+exports.WebhookCallbackStatus = void 0;
+(function (WebhookCallbackStatus) {
+    /** No callback received yet */
+    WebhookCallbackStatus["NONE"] = "NONE";
+    /** Workflow completed successfully */
+    WebhookCallbackStatus["SUCCESS"] = "SUCCESS";
+    /** Workflow failed */
+    WebhookCallbackStatus["FAILED"] = "FAILED";
+    /** Workflow was cancelled */
+    WebhookCallbackStatus["CANCELLED"] = "CANCELLED";
+})(exports.WebhookCallbackStatus || (exports.WebhookCallbackStatus = {}));
+
+/**
+ * Core Entity Types
+ *
+ * Single source of truth for entity type identifiers used across the system.
+ * Other type consts (ErrorDomains, AuditEntityTypes) extend from this base.
+ */
+const EntityTypes = {
+    // Core entities
+    USER: 'user',
+    ADMIN: 'admin',
+    TENANT: 'tenant',
+    // Token entities
+    TOKEN: 'token',
+    TOKEN_METADATA: 'token_metadata',
+    TOKEN_TYPE: 'token_type',
+    // Financial entities
+    WALLET: 'wallet',
+    BALANCE: 'balance',
+    TRANSACTION: 'transaction',
+    PURCHASE: 'purchase',
+    // Business entities
+    BUSINESS: 'business',
+    BUSINESS_TYPE: 'business_type',
+    // Campaign entities
+    CAMPAIGN: 'campaign',
+    CAMPAIGN_TRIGGER: 'campaign_trigger',
+    // Redemption entities
+    REDEMPTION: 'redemption',
+    REDEMPTION_TYPE: 'redemption_type',
+    // Infrastructure entities
+    CONTRACT: 'contract',
+    SIGNING_ACCOUNT: 'signing_account',
+    API_KEY: 'api_key',
+    WEBHOOK: 'webhook',
+};
+/**
+ * Error-specific domains (extends EntityTypes)
+ *
+ * Includes entity types plus error-specific classification domains.
+ */
+const ErrorDomains = {
+    ...EntityTypes,
+    // Error-specific domains (not entities, but error classifications)
+    VALIDATION: 'validation',
+    SYSTEM: 'system',
+    AUTHENTICATION: 'authentication',
+    EXTERNAL: 'external',
+};
+/**
+ * Auditable Entity Types (extends EntityTypes)
+ *
+ * All entities that can be audited. Currently same as EntityTypes,
+ * but can be extended with audit-specific entities if needed.
+ */
+const AuditEntityTypes = {
+    ...EntityTypes,
+};
+
 /**
  * Error categories for classification and handling
  *
@@ -2953,6 +3218,62 @@ exports.ErrorCategory = void 0;
     ErrorCategory["UNKNOWN"] = "UNKNOWN";
 })(exports.ErrorCategory || (exports.ErrorCategory = {}));
 
+/**
+ * PERS WS-Relay Shared Types
+ *
+ * Type-safe WebSocket communication types for the PERS event relay system.
+ *
+ * @version 1.2.0
+ */
+// =============================================================================
+// HELPER FUNCTIONS (TYPE GUARDS)
+// =============================================================================
+/**
+ * Type guard for server messages
+ */
+function isServerMessage(data) {
+    return (typeof data === 'object' &&
+        data !== null &&
+        'type' in data &&
+        'timestamp' in data);
+}
+/**
+ * Type guard for event messages
+ */
+function isEventMessage(msg) {
+    return msg.type === 'event';
+}
+/**
+ * Type guard for connected messages
+ */
+function isConnectedMessage(msg) {
+    return msg.type === 'connected';
+}
+/**
+ * Type guard for subscribed messages
+ */
+function isSubscribedMessage(msg) {
+    return msg.type === 'subscribed';
+}
+/**
+ * Type guard for unsubscribed messages
+ */
+function isUnsubscribedMessage(msg) {
+    return msg.type === 'unsubscribed';
+}
+/**
+ * Type guard for error messages
+ */
+function isErrorMessage(msg) {
+    return msg.type === 'error';
+}
+/**
+ * Type guard for ping messages
+ */
+function isPingMessage(msg) {
+    return msg.type === 'ping';
+}
+
 const apiPublicKeyTestPrefix = 'pk_test_';
 const testnetPrefix = 'testnet-';
 const testnetShortPrefix = 'tn-';
@@ -3218,6 +3539,42 @@ function isValidRedemptionRedeemRelation(value) {
     return VALID_REDEMPTION_REDEEM_RELATIONS.includes(value);
 }
 
+/**
+ * Valid business membership relations for runtime validation
+ */
+const VALID_BUSINESS_MEMBERSHIP_RELATIONS = [
+    'user',
+    'business'
+];
+/**
+ * Type guard to validate business membership relation strings at runtime
+ */
+function isValidBusinessMembershipRelation(value) {
+    return VALID_BUSINESS_MEMBERSHIP_RELATIONS.includes(value);
+}
+
+/**
+ * Valid include relations for User endpoints.
+ * These relations can be requested via ?include=status,balances query parameter.
+ */
+const VALID_USER_RELATIONS = ['status', 'balances'];
+/**
+ * Type guard to check if a string is a valid UserIncludeRelation
+ */
+function isValidUserRelation(value) {
+    return VALID_USER_RELATIONS.includes(value);
+}
+
+/**
+ * Chain Data Types
+ *
+ * Types for blockchain chain configuration.
+ */
+const ChainTypes = {
+    PRIVATE: "PRIVATE",
+    PUBLIC: "PUBLIC"
+};
+
 /**
  * Transaction format constants for Ethereum and EVM-compatible chains
  * Using const assertions for zero runtime overhead
@@ -3504,6 +3861,281 @@ const ApiErrorDetector = {
         ErrorUtils.isTokenExpiredError(error)
 };
 
+/**
+ * Centralized Cache Service for PERS SDK
+ * Simple, efficient caching with memory management
+ */
+const DEFAULT_CACHE_CONFIG = {
+    defaultTtl: 30 * 60 * 1000, // 30 minutes
+    maxMemoryMB: 50, // 50MB cache limit
+    cleanupInterval: 5 * 60 * 1000, // Cleanup every 5 minutes
+    maxEntries: 10000, // Entry count limit
+    evictionBatchPercent: 0.2, // Remove 20% when evicting
+};
+// Constants for memory estimation
+const ENTRY_OVERHEAD_BYTES = 64;
+const DEFAULT_OBJECT_SIZE_BYTES = 1024;
+const MEMORY_CHECK_INTERVAL_MS = 60000; // Lazy check every 60s
+class CacheService {
+    constructor(config) {
+        this.cache = new Map();
+        this.cleanupTimer = null;
+        this.lastMemoryCheck = 0;
+        this.pendingFetches = new Map();
+        this.accessOrder = new Set();
+        this.stats = {
+            hits: 0,
+            misses: 0,
+            errors: 0
+        };
+        this.config = { ...DEFAULT_CACHE_CONFIG, ...config };
+        this.startCleanupTimer();
+    }
+    /**
+     * Set a value in cache with optional TTL
+     */
+    set(key, value, ttl) {
+        if (!key || value === undefined)
+            return;
+        const entry = {
+            value,
+            timestamp: Date.now(),
+            ttl: ttl || this.config.defaultTtl,
+            lastAccessed: Date.now()
+        };
+        this.cache.set(key, entry);
+        this.accessOrder.add(key);
+        // Fast entry count check first
+        if (this.cache.size > this.config.maxEntries) {
+            this.evictOldestEntries();
+        }
+        // Lazy memory check (only every 10s)
+        const now = Date.now();
+        if (now - this.lastMemoryCheck > MEMORY_CHECK_INTERVAL_MS) {
+            this.lastMemoryCheck = now;
+            this.enforceMemoryLimit();
+        }
+    }
+    /**
+     * Get a value from cache
+     */
+    get(key) {
+        const entry = this.cache.get(key);
+        if (!entry) {
+            this.stats.misses++;
+            return null;
+        }
+        // Check if expired
+        const now = Date.now();
+        if (now - entry.timestamp > entry.ttl) {
+            this.cache.delete(key);
+            this.accessOrder.delete(key);
+            this.stats.misses++;
+            return null;
+        }
+        // Update access order efficiently
+        this.accessOrder.delete(key);
+        this.accessOrder.add(key);
+        entry.lastAccessed = now;
+        this.stats.hits++;
+        return entry.value;
+    }
+    /**
+     * Get or set pattern - common caching pattern with race condition protection
+     */
+    async getOrSet(key, fetcher, ttl) {
+        const cached = this.get(key);
+        if (cached !== null)
+            return cached;
+        // Prevent duplicate fetches
+        if (this.pendingFetches.has(key)) {
+            return this.pendingFetches.get(key);
+        }
+        const fetchPromise = fetcher()
+            .then(value => {
+            this.pendingFetches.delete(key);
+            if (value !== undefined) {
+                this.set(key, value, ttl);
+            }
+            return value;
+        })
+            .catch(error => {
+            this.pendingFetches.delete(key);
+            this.stats.errors++;
+            throw error;
+        });
+        this.pendingFetches.set(key, fetchPromise);
+        return fetchPromise;
+    }
+    /**
+     * Delete a specific key
+     */
+    delete(key) {
+        this.accessOrder.delete(key);
+        return this.cache.delete(key);
+    }
+    /**
+     * Clear all keys matching a prefix
+     */
+    clearByPrefix(prefix) {
+        const keysToDelete = Array.from(this.cache.keys()).filter(key => key.startsWith(prefix));
+        keysToDelete.forEach(key => {
+            this.cache.delete(key);
+            this.accessOrder.delete(key);
+        });
+        return keysToDelete.length;
+    }
+    /**
+     * Clear all cache
+     */
+    clear() {
+        this.cache.clear();
+        this.accessOrder.clear();
+        this.pendingFetches.clear();
+        this.stats = { hits: 0, misses: 0, errors: 0 };
+    }
+    /**
+     * Force cleanup of expired entries
+     */
+    cleanup() {
+        const now = Date.now();
+        const keysToDelete = [];
+        for (const [key, entry] of this.cache.entries()) {
+            if (now - entry.timestamp > entry.ttl) {
+                keysToDelete.push(key);
+            }
+        }
+        keysToDelete.forEach(key => {
+            this.cache.delete(key);
+            this.accessOrder.delete(key);
+        });
+        return keysToDelete.length;
+    }
+    /**
+     * Stop cleanup timer and clear cache
+     */
+    destroy() {
+        this.stopCleanupTimer();
+        this.clear();
+    }
+    /**
+     * Create a namespaced cache interface
+     */
+    createNamespace(namespace) {
+        if (!namespace || namespace.includes(':')) {
+            throw new Error('Namespace must be non-empty and cannot contain ":"');
+        }
+        return {
+            set: (key, value, ttl) => this.set(`${namespace}:${key}`, value, ttl),
+            get: (key) => this.get(`${namespace}:${key}`),
+            getOrSet: (key, fetcher, ttl) => this.getOrSet(`${namespace}:${key}`, fetcher, ttl),
+            delete: (key) => this.delete(`${namespace}:${key}`),
+            clear: () => this.clearByPrefix(`${namespace}:`)
+        };
+    }
+    startCleanupTimer() {
+        this.stopCleanupTimer();
+        this.cleanupTimer = setInterval(() => {
+            this.safeCleanup();
+        }, this.config.cleanupInterval);
+        // Platform-agnostic: Prevent hanging process in Node.js environments
+        if (this.cleanupTimer && typeof this.cleanupTimer.unref === 'function') {
+            this.cleanupTimer.unref();
+        }
+    }
+    stopCleanupTimer() {
+        if (this.cleanupTimer) {
+            clearInterval(this.cleanupTimer);
+            this.cleanupTimer = null;
+        }
+    }
+    safeCleanup() {
+        try {
+            this.cleanup();
+            this.enforceMemoryLimit();
+        }
+        catch (error) {
+            this.stats.errors++;
+            // Platform-agnostic error logging
+            if (typeof console !== 'undefined' && console.warn) {
+                console.warn('Cache cleanup error:', error);
+            }
+        }
+    }
+    estimateValueSize(value) {
+        if (typeof value === 'string') {
+            return value.length * 2; // UTF-16 encoding
+        }
+        if (typeof value === 'number' || typeof value === 'boolean') {
+            return 8; // Primitive values
+        }
+        if (value === null || value === undefined) {
+            return 4;
+        }
+        try {
+            // More accurate JSON-based estimation for serializable objects
+            const jsonString = JSON.stringify(value);
+            return jsonString.length * 2;
+        }
+        catch {
+            // Fallback for non-serializable objects
+            if (Array.isArray(value)) {
+                return value.length * 100; // Better estimate for arrays
+            }
+            if (value && typeof value === 'object') {
+                return Object.keys(value).length * 50; // Better estimate for objects
+            }
+            return DEFAULT_OBJECT_SIZE_BYTES;
+        }
+    }
+    estimateMemoryUsage() {
+        let totalSize = 0;
+        for (const [key, entry] of this.cache.entries()) {
+            totalSize += key.length * 2; // Key size
+            totalSize += this.estimateValueSize(entry.value);
+            totalSize += ENTRY_OVERHEAD_BYTES;
+        }
+        return totalSize / (1024 * 1024);
+    }
+    enforceMemoryLimit() {
+        const memoryUsage = this.estimateMemoryUsage();
+        if (memoryUsage <= this.config.maxMemoryMB || this.cache.size === 0)
+            return;
+        this.evictOldestEntries();
+    }
+    evictOldestEntries() {
+        if (this.cache.size === 0)
+            return;
+        const batchSize = Math.floor(this.cache.size * this.config.evictionBatchPercent);
+        const toRemove = Math.max(batchSize, 1);
+        // Efficiently remove oldest entries using access order
+        const iterator = this.accessOrder.values();
+        for (let i = 0; i < toRemove; i++) {
+            const result = iterator.next();
+            if (result.done)
+                break;
+            const key = result.value;
+            this.cache.delete(key);
+            this.accessOrder.delete(key);
+        }
+    }
+}
+// Singleton instance
+const globalCacheService = new CacheService();
+
+/**
+ * Cache module exports
+ */
+// Predefined cache TTL constants
+const CacheTTL = {
+    SHORT: 5 * 60 * 1000, // 5 minutes
+    MEDIUM: 30 * 60 * 1000, // 30 minutes  
+    LONG: 24 * 60 * 60 * 1000, // 24 hours
+    METADATA: 24 * 60 * 60 * 1000, // 24 hours - IPFS metadata is immutable
+    GATEWAY: 30 * 60 * 1000, // 30 minutes - Gateway config can change
+    PROVIDER: 60 * 60 * 1000, // 1 hour - Provider connections with auth
+};
+
 // ==========================================
 // UTILITY FUNCTIONS
 // ==========================================
@@ -3713,9 +4345,15 @@ class UserApi {
     /**
      * AUTH: Get current authenticated user
      * Uses new RESTful /users/me endpoint
+     *
+     * @param options - Query options. Use `include` to specify relations: 'status' (user status types), 'balances' (token balances)
      */
-    async getRemoteUser() {
-        return this.apiClient.get(`${this.basePath}/me`);
+    async getRemoteUser(options) {
+        let url = `${this.basePath}/me`;
+        if (options?.include?.length) {
+            url += `?include=${options.include.join(',')}`;
+        }
+        return this.apiClient.get(url);
     }
     /**
      * AUTH: Update current authenticated user
@@ -3791,19 +4429,66 @@ class UserApi {
         return this.apiClient.put(`${this.basePath}/${id}`, userData);
     }
     /**
-     * ADMIN: Toggle user active status
+     * ADMIN: Set or toggle user active status
      * Uses new consistent /users/{id}/status endpoint
      * Enhanced: Follows RESTful status management pattern across all domains
+     *
+     * @param userId - User ID
+     * @param isActive - Optional explicit status. If provided, sets to this value. If omitted, toggles current status.
+     *
+     * @example
+     * ```typescript
+     * // Explicit set
+     * await sdk.users.setUserActiveStatus('user-123', true);   // Activate
+     * await sdk.users.setUserActiveStatus('user-123', false);  // Deactivate
+     *
+     * // Toggle (current behavior)
+     * await sdk.users.setUserActiveStatus('user-123');  // Flips current status
+     * ```
      */
-    async toggleUserActiveStatusByUser(user) {
-        return this.apiClient.put(`${this.basePath}/${user.id}/status`, {});
+    async setUserActiveStatus(userId, isActive) {
+        const body = isActive !== undefined ? { isActive } : {};
+        return this.apiClient.put(`${this.basePath}/${userId}/status`, body);
     }
     /**
      * ADMIN: Get user by unique identifier
      * Uses new RESTful /users/{id} endpoint
+     *
+     * @param id - User unique identifier (id, email, externalId, accountAddress, etc.)
+     * @param options - Query options. Use `include` to specify relations: 'status' (user status types), 'balances' (token balances)
      */
-    async getUserByUniqueIdentifier(id) {
-        return this.apiClient.get(`${this.basePath}/${id}`);
+    async getUserByUniqueIdentifier(id, options) {
+        let url = `${this.basePath}/${id}`;
+        if (options?.include?.length) {
+            url += `?include=${options.include.join(',')}`;
+        }
+        return this.apiClient.get(url);
+    }
+    /**
+     * ADMIN: Delete user by identifier (soft delete)
+     * Uses RESTful /users/{identifier} DELETE endpoint
+     *
+     * Soft deletes a user. The user data is retained for 30 days before GDPR anonymization.
+     * Use restoreUser() to restore within the grace period.
+     *
+     * @param identifier - User unique identifier (id, email, externalId, accountAddress, etc.)
+     * @returns Promise resolving to success status and message
+     */
+    async deleteUser(identifier) {
+        return this.apiClient.delete(`${this.basePath}/${identifier}`);
+    }
+    /**
+     * ADMIN: Restore deleted user by identifier
+     * Uses RESTful /users/{identifier}/restore POST endpoint
+     *
+     * Restores a soft-deleted user within the 30-day grace period.
+     * After GDPR anonymization (30 days), restoration is not possible.
+     *
+     * @param identifier - User unique identifier (id, email, externalId, accountAddress, etc.)
+     * @returns Promise resolving to restored user data
+     */
+    async restoreUser(identifier) {
+        return this.apiClient.post(`${this.basePath}/${identifier}/restore`);
     }
 }
 
@@ -3833,9 +4518,11 @@ class UserService {
     // ==========================================
     /**
      * AUTH: Get current authenticated user
+     *
+     * @param options - Query options. Use `include` to specify relations: 'status' (user status types), 'balances' (token balances)
      */
-    async getRemoteUser() {
-        return this.userApi.getRemoteUser();
+    async getRemoteUser(options) {
+        return this.userApi.getRemoteUser(options);
     }
     /**
      * AUTH: Update current authenticated user
@@ -3886,15 +4573,47 @@ class UserService {
     async updateUserAsAdmin(id, userData) {
         return this.userApi.updateUserAsAdmin(id, userData);
     }
-    async getUserByUniqueIdentifier(id) {
-        return this.userApi.getUserByUniqueIdentifier(id);
+    /**
+     * ADMIN: Get user by unique identifier
+     *
+     * @param id - User unique identifier (id, email, externalId, accountAddress, etc.)
+     * @param options - Query options. Use `include` to specify relations: 'status' (user status types), 'balances' (token balances)
+     */
+    async getUserByUniqueIdentifier(id, options) {
+        return this.userApi.getUserByUniqueIdentifier(id, options);
+    }
+    /**
+     * ADMIN: Set or toggle user active status
+     *
+     * @param userId - User ID
+     * @param isActive - Optional explicit status. If provided, sets to this value. If omitted, toggles current status.
+     */
+    async setUserActiveStatus(userId, isActive) {
+        return this.userApi.setUserActiveStatus(userId, isActive);
     }
     /**
-     * ADMIN: Toggle user active status by user object
-     * ✅ FIXED: Matches API method signature exactly
+     * ADMIN: Delete user by identifier (soft delete)
+     *
+     * Soft deletes a user. The user data is retained for 30 days before GDPR anonymization.
+     * Use restoreUser() to restore within the grace period.
+     *
+     * @param identifier - User unique identifier (id, email, externalId, accountAddress, etc.)
+     * @returns Promise resolving to success status and message
      */
-    async toggleUserActiveStatusByUser(user) {
-        return this.userApi.toggleUserActiveStatusByUser(user);
+    async deleteUser(identifier) {
+        return this.userApi.deleteUser(identifier);
+    }
+    /**
+     * ADMIN: Restore deleted user by identifier
+     *
+     * Restores a soft-deleted user within the 30-day grace period.
+     * After GDPR anonymization (30 days), restoration is not possible.
+     *
+     * @param identifier - User unique identifier (id, email, externalId, accountAddress, etc.)
+     * @returns Promise resolving to restored user data
+     */
+    async restoreUser(identifier) {
+        return this.userApi.restoreUser(identifier);
     }
 }
 
@@ -3973,6 +4692,32 @@ class UserStatusApi {
             throw error;
         }
     }
+    /**
+     * ADMIN: Update user status type
+     * PUT /users/status-types/:id
+     */
+    async updateUserStatusType(id, userStatusType) {
+        try {
+            return await this.apiClient.put(`${this.basePath}/status-types/${id}`, userStatusType);
+        }
+        catch (error) {
+            console.error('Error updating user status type', error);
+            throw error;
+        }
+    }
+    /**
+     * ADMIN: Delete user status type
+     * DELETE /users/status-types/:id
+     */
+    async deleteUserStatusType(id) {
+        try {
+            await this.apiClient.delete(`${this.basePath}/status-types/${id}`);
+        }
+        catch (error) {
+            console.error('Error deleting user status type', error);
+            throw error;
+        }
+    }
 }
 
 /**
@@ -4013,6 +4758,18 @@ class UserStatusService {
     async createUserStatusType(userStatusType) {
         return this.userStatusApi.createUserStatusType(userStatusType);
     }
+    /**
+     * ADMIN: Update user status type
+     */
+    async updateUserStatusType(id, userStatusType) {
+        return this.userStatusApi.updateUserStatusType(id, userStatusType);
+    }
+    /**
+     * ADMIN: Delete user status type
+     */
+    async deleteUserStatusType(id) {
+        return this.userStatusApi.deleteUserStatusType(id);
+    }
 }
 
 /**
@@ -4040,6 +4797,8 @@ function createUserStatusSDK(apiClient) {
         getRemoteEarnedUserStatus: (options) => userStatusService.getRemoteEarnedUserStatus(options),
         // Admin methods
         createUserStatusType: (userStatusType) => userStatusService.createUserStatusType(userStatusType),
+        updateUserStatusType: (id, userStatusType) => userStatusService.updateUserStatusType(id, userStatusType),
+        deleteUserStatusType: (id) => userStatusService.deleteUserStatusType(id),
         // Advanced access for edge cases
         api: userStatusApi,
         service: userStatusService
@@ -4166,6 +4925,13 @@ class TokenApi {
     async createTokenMetadata(tokenId, tokenData) {
         return this.apiClient.post(`${this.basePath}/${tokenId}/metadata`, tokenData);
     }
+    /**
+     * ADMIN: Update token metadata (ERC721 only)
+     * Note: Existing minted NFTs retain their original metadata - this only affects future mints
+     */
+    async updateTokenMetadata(metadataId, tokenData) {
+        return this.apiClient.put(`${this.basePath}/metadata/${metadataId}`, tokenData);
+    }
     /**
      * ADMIN: Toggle token metadata status (separate from token status)
      */
@@ -4240,6 +5006,13 @@ class TokenService {
     async createTokenMetadata(tokenId, tokenData) {
         return this.tokenApi.createTokenMetadata(tokenId, tokenData);
     }
+    /**
+     * ADMIN: Update token metadata (ERC721 only)
+     * Note: Existing minted NFTs retain their original metadata - this only affects future mints
+     */
+    async updateTokenMetadata(metadataId, tokenData) {
+        return this.tokenApi.updateTokenMetadata(metadataId, tokenData);
+    }
     /**
      * ADMIN: Toggle token active status
      */
@@ -4508,7 +5281,7 @@ class BusinessMembershipApi {
      * Min Role: VIEWER (any member can view)
      *
      * @param businessId - The business UUID
-     * @param options - Pagination and filter options
+     * @param options - Pagination, filter, and include options
      * @returns Paginated array of business memberships with user and role details
      *
      * @throws {AuthenticationError} 401 - Not authenticated
@@ -4520,15 +5293,19 @@ class BusinessMembershipApi {
      * const page1 = await membershipApi.getMembers('business-123');
      * page1.data.forEach(m => console.log(`${m.userId}: ${m.role}`));
      *
-     * // Filter by role
-     * const admins = await membershipApi.getMembers('business-123', {
-     *   role: MembershipRole.ADMIN,
+     * // Include user data for display
+     * const withUsers = await membershipApi.getMembers('business-123', {
+     *   include: ['user'],
      *   page: 1,
      *   limit: 50
      * });
+     * withUsers.data.forEach(m => console.log(m.included?.user?.email));
      *
-     * // Paginate through all members
-     * const page2 = await membershipApi.getMembers('business-123', { page: 2 });
+     * // Filter by role with user data
+     * const admins = await membershipApi.getMembers('business-123', {
+     *   role: MembershipRole.ADMIN,
+     *   include: ['user']
+     * });
      * ```
      */
     async getMembers(businessId, options) {
@@ -4536,6 +5313,9 @@ class BusinessMembershipApi {
         if (options?.role) {
             params.set('role', options.role);
         }
+        if (options?.include?.length) {
+            params.set('include', options.include.join(','));
+        }
         const response = await this.apiClient.get(`${this.getMembersPath(businessId)}?${params.toString()}`);
         return normalizeToPaginated(response);
     }
@@ -4795,8 +5575,15 @@ class BusinessMembershipService {
      * Get all members of a business with pagination
      *
      * @param businessId - The business UUID
-     * @param options - Pagination options
+     * @param options - Pagination and include options
      * @returns Paginated response with business memberships
+     *
+     * @example
+     * ```typescript
+     * // Get members with user data for display
+     * const members = await service.getMembers('biz-123', { include: ['user'] });
+     * members.data.forEach(m => console.log(m.included?.user?.email));
+     * ```
      */
     async getMembers(businessId, options) {
         return this.membershipApi.getMembers(businessId, options);
@@ -6346,7 +7133,9 @@ class TransactionService {
         return this.transactionApi.getTransactionAnalytics(analyticsRequest);
     }
 }
-
+// ============================================================================
+// CLIENT TRANSACTION TYPES
+// ============================================================================
 /**
  * Client-side transaction types extending backend Web3TransactionType
  * Includes client-specific flows like pending submissions (POS flow)
@@ -7054,6 +7843,156 @@ class TenantService {
     }
 }
 
+/**
+ * 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.
+ *
+ * Also provides chain-agnostic IPFS URL resolution using tenant configuration.
+ */
+class TenantManager {
+    constructor(apiClient) {
+        this.apiClient = apiClient;
+        this.cache = globalCacheService.createNamespace('tenant');
+        const tenantApi = new TenantApi(apiClient);
+        this.tenantService = new TenantService(tenantApi);
+    }
+    /**
+     * Get current tenant information
+     *
+     * @returns Promise resolving to tenant data
+     */
+    async getTenantInfo() {
+        return this.tenantService.getRemoteTenant();
+    }
+    /**
+     * Get tenant login token
+     *
+     * @returns Promise resolving to login token
+     */
+    async getLoginToken() {
+        return this.tenantService.getRemoteLoginToken();
+    }
+    /**
+     * Get tenant client configuration (cached)
+     *
+     * @returns Promise resolving to client config
+     */
+    async getClientConfig() {
+        return this.cache.getOrSet('clientConfig', () => this.tenantService.getRemoteClientConfig(), CacheTTL.LONG);
+    }
+    // ==========================================
+    // IPFS OPERATIONS (Chain-agnostic)
+    // ==========================================
+    /**
+     * Resolve IPFS URL to HTTPS URL using tenant's configured gateway.
+     *
+     * This is chain-agnostic - IPFS gateway is configured at the tenant level,
+     * not per-chain. Use this for resolving any ipfs:// URLs (images, metadata, etc.).
+     *
+     * @param url - URL to resolve (can be ipfs:// or https://)
+     * @returns Resolved HTTPS URL
+     * @throws Error if tenant's ipfsGatewayDomain is not configured
+     *
+     * @example
+     * ```typescript
+     * const imageUrl = await sdk.tenant.resolveIPFSUrl('ipfs://QmXxx.../image.png');
+     * // Returns: 'https://pers.mypinata.cloud/ipfs/QmXxx.../image.png'
+     *
+     * // Non-IPFS URLs pass through unchanged
+     * const httpUrl = await sdk.tenant.resolveIPFSUrl('https://example.com/image.png');
+     * // Returns: 'https://example.com/image.png'
+     * ```
+     */
+    async resolveIPFSUrl(url) {
+        if (!url || !url.startsWith('ipfs://')) {
+            return url;
+        }
+        const gateway = await this.getIpfsGatewayDomain();
+        return url.replace('ipfs://', `https://${gateway}/ipfs/`);
+    }
+    /**
+     * Get IPFS gateway domain from tenant configuration (cached).
+     *
+     * @returns IPFS gateway domain (e.g., 'pers.mypinata.cloud')
+     * @throws Error if ipfsGatewayDomain is not configured for this tenant
+     */
+    async getIpfsGatewayDomain() {
+        return this.cache.getOrSet('ipfsGateway', async () => {
+            const config = await this.getClientConfig();
+            if (!config.ipfsGatewayDomain) {
+                throw new Error('IPFS gateway domain not configured for tenant. ' +
+                    'Please configure ipfsGatewayDomain in tenant settings.');
+            }
+            return config.ipfsGatewayDomain;
+        }, CacheTTL.GATEWAY);
+    }
+    /**
+     * Get Google API key from tenant configuration (cached).
+     *
+     * @returns Google API key or undefined if not configured
+     */
+    async getGoogleApiKey() {
+        const config = await this.getClientConfig();
+        return config.googleApiKey;
+    }
+    // ==========================================
+    // ADMIN OPERATIONS
+    // ==========================================
+    /**
+     * Admin: Update tenant data
+     *
+     * @param tenantData - Updated tenant data
+     * @returns Promise resolving to updated tenant
+     */
+    async updateTenant(tenantData) {
+        return this.tenantService.updateRemoteTenant(tenantData);
+    }
+    /**
+     * Admin: Get all admins
+     *
+     * @param options - Pagination options
+     * @returns Promise resolving to paginated admins
+     */
+    async getAdmins(options) {
+        return this.tenantService.getAdmins(options);
+    }
+    /**
+     * Admin: Create new admin
+     *
+     * @param adminData - Admin data
+     * @returns Promise resolving to created admin
+     */
+    async createAdmin(adminData) {
+        return this.tenantService.postAdmin(adminData);
+    }
+    /**
+     * Admin: Update existing admin
+     *
+     * @param adminId - ID of the admin to update
+     * @param adminData - Updated admin data
+     * @returns Promise resolving to updated admin
+     */
+    async updateAdmin(adminId, adminData) {
+        return this.tenantService.putAdmin(adminId, adminData);
+    }
+    /**
+     * Get the tenant service for advanced operations
+     *
+     * @returns TenantService instance
+     */
+    getTenantService() {
+        return this.tenantService;
+    }
+    /**
+     * Clear tenant cache (useful after config changes)
+     */
+    clearCache() {
+        this.cache.clear();
+    }
+}
+
 /**
  * Platform-Agnostic Analytics API Client
  *
@@ -7257,6 +8196,57 @@ class AnalyticsApi {
     async getRetentionAnalytics(request = {}) {
         return this.apiClient.post('/analytics/users/retention', request);
     }
+    // ==========================================
+    // TAG ANALYTICS
+    // ==========================================
+    /**
+     * ADMIN: Get tag usage analytics across entities
+     *
+     * Aggregates tag usage across all taggable entities (campaigns, redemptions,
+     * businesses, token metadata, user status types). Perfect for:
+     * - Tag autocomplete/suggestions
+     * - Tag management dashboards
+     * - Usage analytics
+     *
+     * @param request - Optional filters for entity types
+     * @returns Aggregated tag usage with per-entity-type breakdown
+     *
+     * @example Get all tags across all entities
+     * ```typescript
+     * const allTags = await analyticsApi.getTagAnalytics();
+     * console.log(`${allTags.totalTags} unique tags, ${allTags.totalUsage} total usages`);
+     *
+     * // Use for autocomplete suggestions
+     * const suggestions = allTags.tags.map(t => t.tag);
+     * ```
+     *
+     * @example Get tags only from campaigns and businesses
+     * ```typescript
+     * const filteredTags = await analyticsApi.getTagAnalytics({
+     *   entityTypes: [TaggableEntityType.CAMPAIGN, TaggableEntityType.BUSINESS]
+     * });
+     * ```
+     *
+     * @example Tag usage breakdown
+     * ```typescript
+     * const analytics = await analyticsApi.getTagAnalytics();
+     * analytics.tags.forEach(({ tag, count, usageByEntityType }) => {
+     *   console.log(`${tag}: ${count} total`);
+     *   usageByEntityType.forEach(({ entityType, count }) => {
+     *     console.log(`  - ${entityType}: ${count}`);
+     *   });
+     * });
+     * ```
+     */
+    async getTagAnalytics(request = {}) {
+        const params = new URLSearchParams();
+        if (request.entityTypes?.length) {
+            params.set('entityTypes', request.entityTypes.join(','));
+        }
+        const queryString = params.toString();
+        const url = queryString ? `/analytics/tags?${queryString}` : '/analytics/tags';
+        return this.apiClient.get(url);
+    }
 }
 
 /**
@@ -7321,6 +8311,18 @@ class AnalyticsService {
     async getRetentionAnalytics(request = {}) {
         return this.analyticsApi.getRetentionAnalytics(request);
     }
+    // ==========================================
+    // TAG ANALYTICS
+    // ==========================================
+    /**
+     * ADMIN: Get tag usage analytics across entities
+     *
+     * Aggregates tag usage across all taggable entities for autocomplete,
+     * tag management dashboards, and usage analytics.
+     */
+    async getTagAnalytics(request = {}) {
+        return this.analyticsApi.getTagAnalytics(request);
+    }
 }
 
 /**
@@ -7523,19 +8525,40 @@ const DEFAULT_PERS_CONFIG = {
     timeout: 30000,
     retries: 3,
     tokenRefreshMargin: 60, // Refresh tokens 60 seconds before expiry
-    backgroundRefreshThreshold: 30 // Use background refresh if >30s remaining
+    backgroundRefreshThreshold: 30, // Use background refresh if >30s remaining
+    captureWalletEvents: true // Auto-connect to wallet events after auth
 };
 /**
- * Internal function to construct API root from environment
- * Now defaults to production and v2
+ * Build the API root URL based on config
+ *
+ * Priority:
+ * 1. customApiUrl (if provided)
+ * 2. Environment-based URL (staging/production)
+ *
+ * @internal
  */
-function buildApiRoot(environment = 'production', version = 'v2') {
+function buildApiRoot(environment = 'production', version = 'v2', customApiUrl) {
+    // Custom URL takes priority
+    if (customApiUrl) {
+        return customApiUrl;
+    }
     const baseUrls = {
-        development: 'https://explorins-loyalty.ngrok.io',
         staging: `https://dev.api.pers.ninja/${version}`,
         production: `https://api.pers.ninja/${version}`
     };
-    return `${baseUrls[environment]}`;
+    return baseUrls[environment];
+}
+/**
+ * Build wallet events WebSocket URL based on config
+ *
+ * @internal
+ */
+function buildWalletEventsWsUrl(environment = 'production', customWsUrl) {
+    const wsUrls = {
+        staging: 'wss://events-staging.pers.ninja',
+        production: 'wss://events.pers.ninja'
+    };
+    return wsUrls[environment];
 }
 /**
  * Merge user config with defaults
@@ -8454,8 +9477,8 @@ class PersApiClient {
         this.initializationPromise = null;
         // Merge user config with defaults (production + v2)
         this.mergedConfig = mergeWithDefaults(config);
-        // Build API root from merged environment and version
-        this.apiRoot = buildApiRoot(this.mergedConfig.environment, this.mergedConfig.apiVersion);
+        // Build API root - customApiUrl takes priority over environment
+        this.apiRoot = buildApiRoot(this.mergedConfig.environment, this.mergedConfig.apiVersion, this.mergedConfig.customApiUrl);
         // Initialize auth services for direct authentication
         this.authApi = new AuthApi(this);
         // Auto-create auth provider if none provided
@@ -8795,7 +9818,6 @@ class PersEventEmitter {
     constructor() {
         this.handlers = new Set();
         this._instanceId = ++emitterInstanceCounter;
-        console.log(`[PersEventEmitter] Instance #${this._instanceId} created`);
     }
     get instanceId() {
         return this._instanceId;
@@ -9340,23 +10362,32 @@ class UserManager {
      * Retrieves the complete profile of the currently authenticated user.
      * Requires valid authentication tokens.
      *
+     * @param options - Query options. Use `include` to specify relations: 'status' (user status types), 'balances' (token balances)
      * @returns Promise resolving to current user data with full profile information
      * @throws {PersApiError} When user is not authenticated
      *
-     * @example
+     * @example Basic Usage
      * ```typescript
      * try {
      *   const user = await sdk.users.getCurrentUser();
-     *   console.log('Current user:', user.name, user.email);
-     *   console.log('User ID:', user.id);
-     *   console.log('Registration date:', user.createdAt);
+     *   console.log('Current user:', user.firstName, user.email);
      * } catch (error) {
      *   console.log('User not authenticated');
      * }
      * ```
+     *
+     * @example With Status Types and Balances
+     * ```typescript
+     * // Include status types and token balances
+     * const user = await sdk.users.getCurrentUser({
+     *   include: ['status', 'balances']
+     * });
+     * console.log('Status types:', user.included?.statusTypes);
+     * console.log('Token balances:', user.included?.tokenBalances);
+     * ```
      */
-    async getCurrentUser() {
-        return this.userService.getRemoteUser();
+    async getCurrentUser(options) {
+        return this.userService.getRemoteUser(options);
     }
     /**
      * Update current user profile
@@ -9402,25 +10433,34 @@ class UserManager {
      * requires appropriate permissions (admin or specific access rights).
      *
      * @param identifier - Unique identifier for the user (user ID, email, etc.)
+     * @param options - Query options. Use `include` to specify relations: 'status' (user status types), 'balances' (token balances)
      * @returns Promise resolving to user data
      * @throws {PersApiError} When user not found or insufficient permissions
      *
-     * @example
+     * @example Basic Usage
      * ```typescript
      * try {
      *   const user = await sdk.users.getUserById('user-123');
-     *   console.log('Found user:', user.name);
+     *   console.log('Found user:', user.firstName);
      * } catch (error) {
      *   if (error.statusCode === 404) {
      *     console.log('User not found');
-     *   } else if (error.statusCode === 403) {
-     *     console.log('Access denied');
      *   }
      * }
      * ```
+     *
+     * @example With Status Types and Balances
+     * ```typescript
+     * // Get user with status types and token balances
+     * const user = await sdk.users.getUserById('user-123', {
+     *   include: ['status', 'balances']
+     * });
+     * console.log('Status types:', user.included?.statusTypes);
+     * console.log('Token balances:', user.included?.tokenBalances);
+     * ```
      */
-    async getUserById(identifier) {
-        return this.userService.getUserByUniqueIdentifier(identifier);
+    async getUserById(identifier, options) {
+        return this.userService.getUserByUniqueIdentifier(identifier, options);
     }
     /**
      * Get all users public profiles with optional filtering
@@ -9600,34 +10640,104 @@ class UserManager {
         return this.userService.updateUserAsAdmin(userId, userData);
     }
     /**
-     * Admin: Toggle user active status
+     * Admin: Set or toggle user active status
      *
-     * Toggles the active/inactive status of a user account. This is typically
-     * used for account suspension or reactivation. Requires administrator privileges.
+     * Sets the active/inactive status of a user account explicitly, or toggles
+     * if no explicit value is provided. This is typically used for account
+     * suspension or reactivation. Requires administrator privileges.
      *
-     * @param user - User object to toggle status for
+     * @param userId - User ID to update
+     * @param isActive - Optional explicit status. If provided, sets to this value. If omitted, toggles current status.
      * @returns Promise resolving to updated user data
      * @throws {PersApiError} When not authenticated as admin
      *
-     * @example Suspend User
+     * @example Explicit Status
      * ```typescript
-     * // Admin operation - toggle user status
+     * // Admin operation - explicitly activate user
+     * const activated = await sdk.users.setUserActiveStatus('user-123', true);
+     * console.log('User activated:', activated.isActive); // true
+     *
+     * // Explicitly deactivate user
+     * const deactivated = await sdk.users.setUserActiveStatus('user-123', false);
+     * console.log('User deactivated:', deactivated.isActive); // false
+     * ```
+     *
+     * @example Toggle Status
+     * ```typescript
+     * // Admin operation - toggle current status
+     * const toggled = await sdk.users.setUserActiveStatus('user-123');
+     * console.log('User status toggled:', toggled.isActive);
+     * ```
+     */
+    async setUserActiveStatus(userId, isActive) {
+        return this.userService.setUserActiveStatus(userId, isActive);
+    }
+    /**
+     * Admin: Delete user (soft delete)
+     *
+     * Soft deletes a user account. The user data is retained for 30 days before
+     * GDPR anonymization. Use restoreUser() to restore within the grace period.
+     *
+     * ⚠️ This operation is irreversible after 30 days. Consider using toggleUserStatus()
+     * for temporary deactivation instead.
+     *
+     * @param identifier - User unique identifier (id, email, externalId, accountAddress, etc.)
+     * @returns Promise resolving to success status and message
+     * @throws {PersApiError} When not authenticated as admin or user not found
+     *
+     * @example Delete User
+     * ```typescript
+     * // Admin operation - soft delete a user
      * try {
-     *   const user = await sdk.users.getUserById('problematic-user-123');
-     *   const updated = await sdk.users.toggleUserStatus(user);
+     *   const result = await sdk.users.deleteUser('user-123');
+     *   console.log(result.message); // "User user-123 has been deleted"
+     * } catch (error) {
+     *   console.log('Failed to delete user:', error.message);
+     * }
+     * ```
+     */
+    async deleteUser(identifier) {
+        const result = await this.userService.deleteUser(identifier);
+        this.events?.emitSuccess({
+            domain: 'user',
+            type: 'USER_DELETED',
+            userMessage: 'User deleted successfully',
+            details: { identifier }
+        });
+        return result;
+    }
+    /**
+     * Admin: Restore deleted user
      *
-     *   if (updated.isActive) {
-     *     console.log('User account reactivated');
-     *   } else {
-     *     console.log('User account suspended');
-     *   }
+     * Restores a soft-deleted user within the 30-day grace period.
+     * After GDPR anonymization (30 days), restoration is not possible.
+     *
+     * @param identifier - User unique identifier (id, email, externalId, accountAddress, etc.)
+     * @returns Promise resolving to restored user data
+     * @throws {PersApiError} When not authenticated as admin, user not found, or already anonymized
+     *
+     * @example Restore Deleted User
+     * ```typescript
+     * // Admin operation - restore a deleted user
+     * try {
+     *   const user = await sdk.users.restoreUser('user-123');
+     *   console.log('User restored:', user.firstName);
      * } catch (error) {
-     *   console.log('Failed to update user status');
+     *   if (error.message.includes('anonymized')) {
+     *     console.log('User cannot be restored - already anonymized');
+     *   }
      * }
      * ```
      */
-    async toggleUserStatus(user) {
-        return this.userService.toggleUserActiveStatusByUser(user);
+    async restoreUser(identifier) {
+        const result = await this.userService.restoreUser(identifier);
+        this.events?.emitSuccess({
+            domain: 'user',
+            type: 'USER_RESTORED',
+            userMessage: 'User restored successfully',
+            details: { identifier, userId: result.id }
+        });
+        return result;
     }
     /**
      * Get the user service for advanced operations
@@ -9686,6 +10796,25 @@ class UserStatusManager {
     async createUserStatusType(userStatusType) {
         return this.userStatusSDK.createUserStatusType(userStatusType);
     }
+    /**
+     * Admin: Update existing user status type
+     *
+     * @param id - User status type ID
+     * @param userStatusType - User status type data
+     * @returns Promise resolving to updated user status type
+     */
+    async updateUserStatusType(id, userStatusType) {
+        return this.userStatusSDK.updateUserStatusType(id, userStatusType);
+    }
+    /**
+     * Admin: Delete user status type
+     *
+     * @param id - User status type ID
+     * @returns Promise resolving when deleted
+     */
+    async deleteUserStatusType(id) {
+        return this.userStatusSDK.deleteUserStatusType(id);
+    }
     /**
      * Get the full user status SDK for advanced operations
      *
@@ -10401,22 +11530,23 @@ class BusinessManager {
      * Any member of the business can view the member list.
      *
      * @param businessId - The business UUID
-     * @returns Promise resolving to array of business memberships
+     * @param options - Pagination and include options
+     * @returns Promise resolving to paginated business memberships
      * @throws {PersApiError} 401 - Not authenticated
      * @throws {PersApiError} 403 - Not a member of this business
      *
      * @example
      * ```typescript
-     * const members = await sdk.business.getMembers('business-123');
+     * // Get members with user data for display
+     * const { data: members } = await sdk.business.getMembers('business-123', {
+     *   include: ['user']
+     * });
      *
      * console.log('Business Members:');
      * members.forEach(member => {
-     *   console.log(`- User ${member.userId}: ${member.role}`);
+     *   const email = member.included?.user?.email || member.userId;
+     *   console.log(`- ${email}: ${member.role}`);
      * });
-     *
-     * // Count members by role
-     * const admins = members.filter(m => m.role === 'ADMIN' || m.role === 'OWNER');
-     * console.log(`Administrators: ${admins.length}`);
      * ```
      */
     async getMembers(businessId, options) {
@@ -13656,89 +14786,6 @@ class FileManager {
     }
 }
 
-/**
- * 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;
-        const tenantApi = new TenantApi(apiClient);
-        this.tenantService = new TenantService(tenantApi);
-    }
-    /**
-     * Get current tenant information
-     *
-     * @returns Promise resolving to tenant data
-     */
-    async getTenantInfo() {
-        return this.tenantService.getRemoteTenant();
-    }
-    /**
-     * Get tenant login token
-     *
-     * @returns Promise resolving to login token
-     */
-    async getLoginToken() {
-        return this.tenantService.getRemoteLoginToken();
-    }
-    /**
-     * Get tenant client configuration
-     *
-     * @returns Promise resolving to client config
-     */
-    async getClientConfig() {
-        return this.tenantService.getRemoteClientConfig();
-    }
-    /**
-     * Admin: Update tenant data
-     *
-     * @param tenantData - Updated tenant data
-     * @returns Promise resolving to updated tenant
-     */
-    async updateTenant(tenantData) {
-        return this.tenantService.updateRemoteTenant(tenantData);
-    }
-    /**
-     * Admin: Get all admins
-     *
-     * @param options - Pagination options
-     * @returns Promise resolving to paginated admins
-     */
-    async getAdmins(options) {
-        return this.tenantService.getAdmins(options);
-    }
-    /**
-     * Admin: Create new admin
-     *
-     * @param adminData - Admin data
-     * @returns Promise resolving to created admin
-     */
-    async createAdmin(adminData) {
-        return this.tenantService.postAdmin(adminData);
-    }
-    /**
-     * Admin: Update existing admin
-     *
-     * @param adminId - ID of the admin to update
-     * @param adminData - Updated admin data
-     * @returns Promise resolving to updated admin
-     */
-    async updateAdmin(adminId, adminData) {
-        return this.tenantService.putAdmin(adminId, adminData);
-    }
-    /**
-     * Get the tenant service for advanced operations
-     *
-     * @returns TenantService instance
-     */
-    getTenantService() {
-        return this.tenantService;
-    }
-}
-
 /**
  * Platform-Agnostic API Key API Client
  *
@@ -14333,6 +15380,36 @@ class AnalyticsManager {
     async getRetentionAnalytics(request = {}) {
         return this.analyticsService.getRetentionAnalytics(request);
     }
+    /**
+     * Get tag usage analytics across entities
+     *
+     * Aggregates tag usage across all taggable entities (campaigns, redemptions,
+     * businesses, token metadata, user status types). Perfect for:
+     * - Tag autocomplete/suggestions
+     * - Tag management dashboards
+     * - Usage analytics
+     *
+     * @param request - Optional filters for entity types
+     * @returns Promise resolving to aggregated tag usage data
+     *
+     * @example Get all tags for autocomplete
+     * ```typescript
+     * const allTags = await sdk.analytics.getTagAnalytics();
+     * const suggestions = allTags.tags.map(t => t.tag);
+     * ```
+     *
+     * @example Get tags only from campaigns
+     * ```typescript
+     * import { TaggableEntityType } from '@explorins/pers-sdk';
+     *
+     * const campaignTags = await sdk.analytics.getTagAnalytics({
+     *   entityTypes: [TaggableEntityType.CAMPAIGN]
+     * });
+     * ```
+     */
+    async getTagAnalytics(request = {}) {
+        return this.analyticsService.getTagAnalytics(request);
+    }
     /**
      * Get the full analytics service for advanced operations
      *
@@ -14643,6 +15720,1411 @@ class TriggerSourceManager {
     }
 }
 
+/**
+ * Webhook API - Low-level API client for webhook operations
+ *
+ * Backend routes:
+ * - Admin CRUD: /hooks (requires tenant auth)
+ * - Proxy/Trigger: /hooks/:projectKey/:hookId (public, identified by projectKey)
+ * - Callback: /hooks/:projectKey/executions/:executionId/callback (public)
+ *
+ * @internal Use WebhookService or WebhookManager for higher-level operations
+ */
+class WebhookApi {
+    constructor(apiClient) {
+        this.apiClient = apiClient;
+        this.basePath = '/hooks';
+    }
+    // ================================
+    // ADMIN: Webhook Configuration CRUD
+    // All require tenant auth (handled by apiClient)
+    // ================================
+    /**
+     * List all webhooks (Admin)
+     * GET /hooks
+     */
+    async listWebhooks(options) {
+        const params = new URLSearchParams();
+        if (options?.active !== undefined)
+            params.append('active', String(options.active));
+        if (options?.page)
+            params.append('page', String(options.page));
+        if (options?.limit)
+            params.append('limit', String(options.limit));
+        if (options?.search)
+            params.append('search', options.search);
+        const queryString = params.toString();
+        const url = queryString ? `${this.basePath}?${queryString}` : this.basePath;
+        return this.apiClient.get(url);
+    }
+    /**
+     * Get webhook by ID (Admin)
+     * GET /hooks/:hookId
+     */
+    async getWebhookById(webhookId) {
+        return this.apiClient.get(`${this.basePath}/${webhookId}`);
+    }
+    /**
+     * Create a new webhook (Admin)
+     * POST /hooks
+     */
+    async createWebhook(webhook) {
+        return this.apiClient.post(this.basePath, webhook);
+    }
+    /**
+     * Update a webhook (Admin)
+     * PUT /hooks/:hookId
+     */
+    async updateWebhook(webhookId, webhook) {
+        return this.apiClient.put(`${this.basePath}/${webhookId}`, webhook);
+    }
+    /**
+     * Delete a webhook (Admin)
+     * DELETE /hooks/:hookId
+     */
+    async deleteWebhook(webhookId) {
+        return this.apiClient.delete(`${this.basePath}/${webhookId}`);
+    }
+    // ================================
+    // Webhook Triggering via Proxy
+    // Route: /hooks/:projectKey/:hookId
+    // Public endpoint identified by projectKey in URL
+    // ================================
+    /**
+     * Trigger a webhook programmatically
+     *
+     * Uses the proxy endpoint which requires projectKey in the URL path.
+     * The projectKey is obtained from SDK config.
+     *
+     * ALL /hooks/:projectKey/:hookId
+     */
+    async triggerWebhook(request, projectKey) {
+        const { hookId, method = 'POST', body, queryParams, waitForCallback, callbackTimeoutMs } = request;
+        // Build query string from queryParams
+        const params = new URLSearchParams();
+        if (queryParams) {
+            Object.entries(queryParams).forEach(([key, value]) => params.append(key, value));
+        }
+        if (waitForCallback)
+            params.append('waitForCallback', 'true');
+        if (callbackTimeoutMs)
+            params.append('callbackTimeoutMs', String(callbackTimeoutMs));
+        const queryString = params.toString();
+        // Use proxy path with projectKey
+        const proxyPath = `${this.basePath}/${projectKey}/${hookId}`;
+        const url = queryString ? `${proxyPath}?${queryString}` : proxyPath;
+        // Use appropriate HTTP method - backend returns WebhookTriggerResponseDTO
+        switch (method) {
+            case 'GET':
+                return this.apiClient.get(url);
+            case 'PUT':
+                return this.apiClient.put(url, body);
+            case 'DELETE':
+                return this.apiClient.delete(url);
+            case 'POST':
+            default:
+                return this.apiClient.post(url, body);
+        }
+    }
+    // ================================
+    // Execution History (Admin)
+    // GET /hooks/executions
+    // ================================
+    /**
+     * List webhook executions (Admin)
+     * GET /hooks/executions
+     */
+    async listExecutions(options) {
+        const params = new URLSearchParams();
+        if (options?.webhookId)
+            params.append('hookId', options.webhookId);
+        if (options?.status)
+            params.append('status', options.status);
+        if (options?.fromDate)
+            params.append('dateFrom', options.fromDate);
+        if (options?.toDate)
+            params.append('dateTo', options.toDate);
+        if (options?.page)
+            params.append('page', String(options.page));
+        if (options?.limit)
+            params.append('limit', String(options.limit));
+        const queryString = params.toString();
+        const url = queryString ? `${this.basePath}/executions?${queryString}` : `${this.basePath}/executions`;
+        return this.apiClient.get(url);
+    }
+    /**
+     * Get execution by ID (Admin)
+     * Note: This endpoint doesn't exist in current backend - would need to filter by ID
+     */
+    async getExecutionById(executionId) {
+        // Filter executions by ID since direct endpoint doesn't exist
+        const result = await this.listExecutions({ page: 1, limit: 1 });
+        const execution = result.data.find(e => e.id === executionId);
+        if (!execution) {
+            throw new Error(`Execution ${executionId} not found`);
+        }
+        return execution;
+    }
+    // ================================
+    // Callback (Public - called by external systems)
+    // POST /hooks/:projectKey/executions/:executionId/callback
+    // ================================
+    /**
+     * Send callback result (for testing or manual callback trigger)
+     * This is normally called by external systems like n8n
+     *
+     * POST /hooks/:projectKey/executions/:executionId/callback
+     */
+    async sendCallback(executionId, callback, projectKey) {
+        return this.apiClient.post(`${this.basePath}/${projectKey}/executions/${executionId}/callback`, callback);
+    }
+}
+
+/**
+ * Webhook Service - Business logic layer for webhook operations
+ *
+ * Provides higher-level operations on top of WebhookApi including:
+ * - Validation and error handling
+ * - Convenience methods for common patterns
+ * - Async workflow support with callbacks
+ *
+ * Note: Trigger operations require projectKey which is obtained from SDK config.
+ *
+ * @group Services
+ * @category Webhook
+ */
+class WebhookService {
+    constructor(webhookApi, projectKey) {
+        this.webhookApi = webhookApi;
+        this.projectKey = projectKey;
+    }
+    // ================================
+    // Admin: Webhook Configuration
+    // ================================
+    /**
+     * Get all webhooks with optional filters
+     */
+    async getWebhooks(options) {
+        return this.webhookApi.listWebhooks(options);
+    }
+    /**
+     * Get active webhooks only
+     */
+    async getActiveWebhooks() {
+        return this.webhookApi.listWebhooks({ active: true });
+    }
+    /**
+     * Get webhook by ID
+     */
+    async getWebhookById(webhookId) {
+        return this.webhookApi.getWebhookById(webhookId);
+    }
+    /**
+     * Create a new webhook
+     */
+    async createWebhook(webhook) {
+        // Validate required fields
+        if (!webhook.name?.trim()) {
+            throw new Error('Webhook name is required');
+        }
+        if (!webhook.targetUrl?.trim()) {
+            throw new Error('Target URL is required');
+        }
+        // Validate URL format
+        try {
+            new URL(webhook.targetUrl);
+        }
+        catch {
+            throw new Error('Invalid target URL format');
+        }
+        return this.webhookApi.createWebhook(webhook);
+    }
+    /**
+     * Update a webhook
+     */
+    async updateWebhook(webhookId, webhook) {
+        // Validate URL if provided (cast to access optional property from PartialType)
+        const update = webhook;
+        if (update.targetUrl) {
+            try {
+                new URL(update.targetUrl);
+            }
+            catch {
+                throw new Error('Invalid target URL format');
+            }
+        }
+        return this.webhookApi.updateWebhook(webhookId, webhook);
+    }
+    /**
+     * Enable a webhook
+     */
+    async enableWebhook(webhookId) {
+        return this.webhookApi.updateWebhook(webhookId, { isActive: true });
+    }
+    /**
+     * Disable a webhook
+     */
+    async disableWebhook(webhookId) {
+        return this.webhookApi.updateWebhook(webhookId, { isActive: false });
+    }
+    /**
+     * Delete a webhook
+     */
+    async deleteWebhook(webhookId) {
+        return this.webhookApi.deleteWebhook(webhookId);
+    }
+    // ================================
+    // Webhook Triggering (via Proxy)
+    // Uses /hooks/:projectKey/:hookId
+    // ================================
+    /**
+     * Trigger a webhook with full control over request parameters
+     */
+    async triggerWebhook(request) {
+        return this.webhookApi.triggerWebhook(request, this.projectKey);
+    }
+    /**
+     * Simple POST trigger with JSON body
+     */
+    async post(hookId, body) {
+        return this.webhookApi.triggerWebhook({
+            hookId,
+            method: exports.WebhookMethod.POST,
+            body
+        }, this.projectKey);
+    }
+    /**
+     * Simple GET trigger
+     */
+    async get(hookId, queryParams) {
+        return this.webhookApi.triggerWebhook({
+            hookId,
+            method: exports.WebhookMethod.GET,
+            queryParams
+        }, this.projectKey);
+    }
+    /**
+     * Trigger and wait for async callback (for workflow systems like n8n)
+     *
+     * @param hookId - Webhook ID to trigger
+     * @param body - Request body
+     * @param timeoutMs - How long to wait for callback (default: 30000ms)
+     */
+    async triggerAndWait(hookId, body, timeoutMs = 30000) {
+        return this.webhookApi.triggerWebhook({
+            hookId,
+            method: exports.WebhookMethod.POST,
+            body,
+            waitForCallback: true,
+            callbackTimeoutMs: timeoutMs
+        }, this.projectKey);
+    }
+    // ================================
+    // Execution History (Admin)
+    // ================================
+    /**
+     * Get execution history with filters
+     */
+    async getExecutions(options) {
+        return this.webhookApi.listExecutions(options);
+    }
+    /**
+     * Get executions for a specific webhook
+     */
+    async getWebhookExecutions(webhookId, options) {
+        return this.webhookApi.listExecutions({ ...options, webhookId });
+    }
+    /**
+     * Get failed executions
+     */
+    async getFailedExecutions(options) {
+        return this.webhookApi.listExecutions({ ...options, status: exports.WebhookExecutionStatus.FAILED });
+    }
+    /**
+     * Get execution details by ID
+     */
+    async getExecutionById(executionId) {
+        return this.webhookApi.getExecutionById(executionId);
+    }
+    // ================================
+    // Callback (for testing/manual triggers)
+    // ================================
+    /**
+     * Send a callback result for an execution
+     * Normally this is called by external systems like n8n
+     */
+    async sendCallback(executionId, callback) {
+        return this.webhookApi.sendCallback(executionId, callback, this.projectKey);
+    }
+}
+
+/**
+ * Webhook Manager - Clean, high-level interface for webhook operations
+ *
+ * Webhooks enable integration with external systems (n8n, Zapier, custom backends):
+ * - **Admin operations**: Create, configure, and manage webhook endpoints
+ * - **Trigger operations**: Programmatically trigger webhooks with payloads
+ * - **Async workflows**: Wait for callbacks from workflow systems
+ * - **Monitoring**: Track execution history
+ *
+ * ## Security Model
+ * - Admin endpoints require tenant authentication
+ * - Trigger endpoints work with user/business/tenant auth
+ * - Caller identity is passed to webhook target
+ *
+ * @group Managers
+ * @category Webhook Management
+ *
+ * @example Basic Webhook Operations
+ * ```typescript
+ * // Admin: Create a webhook for order processing
+ * const webhook = await sdk.webhooks.create({
+ *   name: 'Process Order',
+ *   targetUrl: 'https://n8n.example.com/webhook/orders',
+ *   method: 'POST',
+ *   headers: { 'X-Custom-Header': 'value' }
+ * });
+ *
+ * // Trigger webhook with order data
+ * const result = await sdk.webhooks.trigger(webhook.id, {
+ *   orderId: 'order-123',
+ *   items: [{ productId: 'prod-1', quantity: 2 }]
+ * });
+ *
+ * console.log('Execution ID:', result.executionId);
+ * ```
+ *
+ * @example Async Workflow with Callback
+ * ```typescript
+ * // Trigger and wait for workflow completion (up to 30s)
+ * const result = await sdk.webhooks.triggerAndWait(
+ *   'ai-processing-webhook',
+ *   { prompt: 'Generate report for Q1' },
+ *   30000
+ * );
+ *
+ * if (result.status === 'COMPLETED') {
+ *   console.log('AI Response:', result.body);
+ * }
+ * ```
+ */
+class WebhookManager {
+    constructor(apiClient, projectKey, events) {
+        this.apiClient = apiClient;
+        this.projectKey = projectKey;
+        this.events = events;
+        const webhookApi = new WebhookApi(apiClient);
+        this.webhookService = new WebhookService(webhookApi, projectKey);
+    }
+    // ================================
+    // Admin: Webhook Configuration
+    // ================================
+    /**
+     * Get all webhooks with optional filters (Admin)
+     *
+     * @param options - Filter and pagination options
+     * @returns Promise resolving to paginated webhooks
+     *
+     * @example
+     * ```typescript
+     * // Get all webhooks
+     * const webhooks = await sdk.webhooks.getAll();
+     *
+     * // Get only active webhooks
+     * const active = await sdk.webhooks.getAll({ active: true });
+     *
+     * // Search by name
+     * const found = await sdk.webhooks.getAll({ search: 'order' });
+     * ```
+     */
+    async getAll(options) {
+        return this.webhookService.getWebhooks(options);
+    }
+    /**
+     * Get active webhooks only (Admin)
+     */
+    async getActive() {
+        return this.webhookService.getActiveWebhooks();
+    }
+    /**
+     * Get webhook by ID (Admin)
+     *
+     * @param webhookId - UUID of the webhook
+     * @returns Promise resolving to webhook details
+     */
+    async getById(webhookId) {
+        return this.webhookService.getWebhookById(webhookId);
+    }
+    /**
+     * Create a new webhook (Admin)
+     *
+     * @param webhook - Webhook configuration
+     * @returns Promise resolving to created webhook
+     *
+     * @example
+     * ```typescript
+     * const webhook = await sdk.webhooks.create({
+     *   name: 'Order Notifications',
+     *   targetUrl: 'https://api.example.com/webhooks/orders',
+     *   method: 'POST',
+     *   headers: {
+     *     'Authorization': 'Bearer secret-token'
+     *   },
+     *   rateLimitPerMinute: 60
+     * });
+     * ```
+     */
+    async create(webhook) {
+        const result = await this.webhookService.createWebhook(webhook);
+        this.events?.emitSuccess({
+            domain: 'webhook',
+            type: 'WEBHOOK_CREATED',
+            userMessage: 'Webhook created successfully',
+            details: { webhookId: result.id, name: result.name }
+        });
+        return result;
+    }
+    /**
+     * Update a webhook (Admin)
+     *
+     * @param webhookId - UUID of the webhook to update
+     * @param webhook - Updated configuration (partial)
+     * @returns Promise resolving to updated webhook
+     */
+    async update(webhookId, webhook) {
+        const result = await this.webhookService.updateWebhook(webhookId, webhook);
+        this.events?.emitSuccess({
+            domain: 'webhook',
+            type: 'WEBHOOK_UPDATED',
+            userMessage: 'Webhook updated successfully',
+            details: { webhookId }
+        });
+        return result;
+    }
+    /**
+     * Enable a webhook (Admin)
+     */
+    async enable(webhookId) {
+        return this.webhookService.enableWebhook(webhookId);
+    }
+    /**
+     * Disable a webhook (Admin)
+     */
+    async disable(webhookId) {
+        return this.webhookService.disableWebhook(webhookId);
+    }
+    /**
+     * Delete a webhook (Admin)
+     *
+     * @param webhookId - UUID of the webhook to delete
+     * @returns Promise resolving to deletion confirmation
+     */
+    async delete(webhookId) {
+        const result = await this.webhookService.deleteWebhook(webhookId);
+        this.events?.emitSuccess({
+            domain: 'webhook',
+            type: 'WEBHOOK_DELETED',
+            userMessage: 'Webhook deleted successfully',
+            details: { webhookId }
+        });
+        return result;
+    }
+    // ================================
+    // Webhook Triggering
+    // ================================
+    /**
+     * Trigger a webhook with GET method
+     *
+     * Sends a GET request through the webhook proxy. Returns the full response
+     * including execution metadata and raw data from the target.
+     *
+     * @param hookId - Webhook ID to trigger
+     * @param queryParams - Optional query parameters
+     * @returns Promise resolving to trigger response with metadata and data
+     *
+     * @example
+     * ```typescript
+     * // Fetch data from external API via webhook proxy
+     * const result = await sdk.webhooks.get('user-directory-webhook');
+     * console.log('Success:', result.success);
+     * console.log('Data:', result.data); // Raw data from target
+     * ```
+     */
+    async get(hookId, queryParams) {
+        return this.webhookService.get(hookId, queryParams);
+    }
+    /**
+     * Trigger a webhook with POST method
+     *
+     * Sends data to the configured webhook target. The caller's identity
+     * (user/business/tenant) is included in the request context.
+     *
+     * @param hookId - Webhook ID to trigger
+     * @param body - Payload to send
+     * @returns Promise resolving to trigger response with execution metadata
+     *
+     * @example
+     * ```typescript
+     * const result = await sdk.webhooks.trigger('order-webhook', {
+     *   orderId: 'order-123',
+     *   action: 'created',
+     *   items: [...]
+     * });
+     *
+     * console.log('Success:', result.success);
+     * console.log('Execution ID:', result.executionId);
+     * console.log('Response:', result.data);
+     * ```
+     */
+    async trigger(hookId, body) {
+        const result = await this.webhookService.post(hookId, body);
+        this.events?.emitSuccess({
+            domain: 'webhook',
+            type: 'WEBHOOK_TRIGGERED',
+            userMessage: 'Webhook triggered',
+            details: { hookId, executionId: result.executionId }
+        });
+        return result;
+    }
+    /**
+     * Trigger a webhook and wait for async callback
+     *
+     * Use this for workflow systems (n8n, Zapier) that need time to process
+     * and return results via callback. The SDK will wait for the callback
+     * up to the specified timeout.
+     *
+     * @param hookId - Webhook ID to trigger
+     * @param body - Payload to send
+     * @param timeoutMs - Max time to wait for callback (default: 30s)
+     * @returns Promise resolving when callback received or timeout
+     *
+     * @example
+     * ```typescript
+     * // Trigger AI workflow and wait for result
+     * const result = await sdk.webhooks.triggerAndWait(
+     *   'ai-analysis-webhook',
+     *   { documentId: 'doc-123', analysisType: 'sentiment' },
+     *   60000 // Wait up to 60 seconds
+     * );
+     *
+     * if (result.success) {
+     *   console.log('Analysis:', result.data);
+     * }
+     * ```
+     */
+    async triggerAndWait(hookId, body, timeoutMs = 30000) {
+        return this.webhookService.triggerAndWait(hookId, body, timeoutMs);
+    }
+    // ================================
+    // Execution History & Monitoring
+    // ================================
+    /**
+     * Get webhook execution history (Admin)
+     *
+     * @param options - Filter and pagination options
+     * @returns Promise resolving to paginated executions
+     *
+     * @example
+     * ```typescript
+     * // Get recent failed executions
+     * const failed = await sdk.webhooks.getExecutions({ status: 'FAILED' });
+     *
+     * // Get executions for specific webhook
+     * const executions = await sdk.webhooks.getExecutions({
+     *   webhookId: 'webhook-123',
+     *   fromDate: '2024-01-01'
+     * });
+     * ```
+     */
+    async getExecutions(options) {
+        return this.webhookService.getExecutions(options);
+    }
+    /**
+     * Get execution details by ID (Admin)
+     */
+    async getExecutionById(executionId) {
+        return this.webhookService.getExecutionById(executionId);
+    }
+    /**
+     * Get the full webhook service for advanced operations
+     *
+     * @returns WebhookService instance with full API access
+     */
+    getWebhookService() {
+        return this.webhookService;
+    }
+}
+
+/**
+ * PERS Events Client
+ *
+ * Lightweight WebSocket client for real-time blockchain event streaming.
+ * Connects to the PERS WS Relay server to receive events for user's wallets.
+ *
+ * ## v1.2.0 Subscription Model
+ *
+ * JWT is used for authentication only. After connecting, you must explicitly
+ * subscribe to wallets (user SDK) or chains (admin dashboard).
+ *
+ * @example User SDK - Subscribe to specific wallets
+ * ```typescript
+ * const client = new PersEventsClient({
+ *   wsUrl: 'wss://events.pers.ninja',
+ *   autoReconnect: true
+ * });
+ *
+ * await client.connect(jwtToken);
+ *
+ * // Subscribe to user's wallets
+ * await client.subscribeWallets([
+ *   { address: '0x123...', chainId: 39123 }
+ * ]);
+ *
+ * client.on('Transfer', (event) => {
+ *   console.log(`Received ${event.data.value} tokens`);
+ * });
+ * ```
+ *
+ * @example Admin Dashboard - Subscribe to all events on chains
+ * ```typescript
+ * await client.connect(adminJwtToken);
+ *
+ * // Subscribe to all events on specific chains
+ * await client.subscribeChains([39123, 137]);
+ *
+ * client.on('*', (event) => {
+ *   console.log(`Chain ${event.chainId}: ${event.type}`);
+ * });
+ * ```
+ */
+const DEFAULT_CONFIG = {
+    autoReconnect: true,
+    maxReconnectAttempts: 10,
+    reconnectDelay: 1000,
+    connectionTimeout: 30000,
+    debug: false,
+    tokenRefresher: undefined,
+};
+class PersEventsClient {
+    constructor(config) {
+        this.ws = null;
+        this.state = 'disconnected';
+        this.reconnectAttempts = 0;
+        this.reconnectTimeout = null;
+        this.token = null;
+        // Event handlers by type
+        this.handlers = new Map();
+        this.stateHandlers = new Set();
+        // Connection info from server
+        this.connectionInfo = null;
+        // Current subscription state
+        this.subscriptionState = { wallets: [], chains: [], activeChains: [] };
+        // Pending subscription promise resolver
+        this.pendingSubscription = null;
+        // Subscriptions to restore on reconnect
+        this.savedSubscriptions = { wallets: [], chains: [] };
+        this.config = { ...DEFAULT_CONFIG, ...config };
+    }
+    /**
+     * Connect to the WS relay server
+     * @param token - JWT token for authentication (wallets no longer required in JWT)
+     */
+    async connect(token) {
+        if (this.state === 'connected' || this.state === 'connecting') {
+            this.log('Already connected or connecting');
+            return;
+        }
+        this.token = token;
+        this.setState('connecting');
+        return new Promise((resolve, reject) => {
+            // Connection timeout
+            const connectionTimeout = setTimeout(() => {
+                this.log('Connection timeout');
+                this.cleanup();
+                this.setState('error');
+                reject(new Error(`Connection timeout after ${this.config.connectionTimeout}ms`));
+            }, this.config.connectionTimeout);
+            const clearTimeoutAndResolve = () => {
+                clearTimeout(connectionTimeout);
+                resolve();
+            };
+            const clearTimeoutAndReject = (err) => {
+                clearTimeout(connectionTimeout);
+                reject(err);
+            };
+            try {
+                const url = new URL(this.config.wsUrl);
+                url.searchParams.set('token', token);
+                this.ws = new WebSocket(url.toString());
+                this.ws.onopen = () => {
+                    // Wait for server 'connected' message
+                };
+                this.ws.onmessage = (event) => {
+                    this.handleMessage(event.data, clearTimeoutAndResolve);
+                };
+                this.ws.onerror = (error) => {
+                    this.log('WebSocket error:', error);
+                    this.setState('error');
+                    clearTimeoutAndReject(new Error('Connection failed'));
+                };
+                this.ws.onclose = (event) => {
+                    this.log(`WebSocket closed: ${event.code} ${event.reason}`);
+                    // Only reject if we were still connecting
+                    if (this.state === 'connecting') {
+                        clearTimeoutAndReject(new Error(`Connection closed during handshake: ${event.code} ${event.reason}`));
+                    }
+                    this.handleDisconnect();
+                };
+            }
+            catch (err) {
+                this.log('Error creating WebSocket:', err);
+                this.setState('error');
+                clearTimeoutAndReject(err instanceof Error ? err : new Error(String(err)));
+            }
+        });
+    }
+    /**
+     * Disconnect from the server
+     */
+    disconnect() {
+        this.config.autoReconnect = false; // Prevent reconnect
+        this.cleanup();
+        this.setState('disconnected');
+    }
+    // ─────────────────────────────────────────────────────────────────────────────
+    // Subscription Methods (v1.2.0)
+    // ─────────────────────────────────────────────────────────────────────────────
+    /**
+     * Subscribe to wallet events (User SDK)
+     *
+     * Receives events only for the specified wallet addresses.
+     * Can be called multiple times to add more wallets.
+     *
+     * @param wallets - Array of wallet info (address + chainId)
+     * @returns Promise that resolves when subscription is confirmed
+     */
+    async subscribeWallets(wallets) {
+        return this.sendSubscription({ type: 'subscribe', wallets });
+    }
+    /**
+     * Subscribe to chain events (Admin Dashboard)
+     *
+     * Receives ALL events on the specified chains.
+     * Use for admin dashboards that need to monitor all activity.
+     *
+     * @param chains - Array of chain IDs to subscribe to
+     * @returns Promise that resolves when subscription is confirmed
+     */
+    async subscribeChains(chains) {
+        return this.sendSubscription({ type: 'subscribe', chains });
+    }
+    /**
+     * Unsubscribe from wallet events
+     *
+     * @param wallets - Array of wallet info to unsubscribe from
+     * @returns Promise that resolves when unsubscription is confirmed
+     */
+    async unsubscribeWallets(wallets) {
+        return this.sendSubscription({ type: 'unsubscribe', wallets });
+    }
+    /**
+     * Unsubscribe from chain events
+     *
+     * @param chains - Array of chain IDs to unsubscribe from
+     * @returns Promise that resolves when unsubscription is confirmed
+     */
+    async unsubscribeChains(chains) {
+        return this.sendSubscription({ type: 'unsubscribe', chains });
+    }
+    /**
+     * Get current subscription state
+     */
+    getSubscriptionState() {
+        return { ...this.subscriptionState };
+    }
+    // ─────────────────────────────────────────────────────────────────────────────
+    // Event Handlers
+    // ─────────────────────────────────────────────────────────────────────────────
+    /**
+     * Subscribe to blockchain events
+     * @param eventType - Event type to listen for, or '*' for all events
+     * @param handler - Event handler function
+     * @returns Unsubscribe function
+     */
+    on(eventType, handler) {
+        if (!this.handlers.has(eventType)) {
+            this.handlers.set(eventType, new Set());
+        }
+        this.handlers.get(eventType).add(handler);
+        return () => {
+            this.handlers.get(eventType)?.delete(handler);
+        };
+    }
+    /**
+     * Subscribe to connection state changes
+     */
+    onStateChange(handler) {
+        this.stateHandlers.add(handler);
+        return () => this.stateHandlers.delete(handler);
+    }
+    /**
+     * Get current connection state
+     */
+    getState() {
+        return this.state;
+    }
+    /**
+     * Get connection info (userId, initial wallets, activeChains)
+     */
+    getConnectionInfo() {
+        return this.connectionInfo;
+    }
+    // ─────────────────────────────────────────────────────────────────────────────
+    // Private methods
+    // ─────────────────────────────────────────────────────────────────────────────
+    async sendSubscription(message) {
+        if (this.state !== 'connected' || !this.ws) {
+            throw new Error('Not connected to server');
+        }
+        // Save subscriptions for reconnect
+        if (message.type === 'subscribe') {
+            if (message.wallets) {
+                this.savedSubscriptions.wallets = [
+                    ...this.savedSubscriptions.wallets,
+                    ...message.wallets.filter(w => !this.savedSubscriptions.wallets.some(sw => sw.address === w.address && sw.chainId === w.chainId))
+                ];
+            }
+            if (message.chains) {
+                this.savedSubscriptions.chains = [
+                    ...new Set([...this.savedSubscriptions.chains, ...message.chains])
+                ];
+            }
+        }
+        else if (message.type === 'unsubscribe') {
+            if (message.wallets) {
+                this.savedSubscriptions.wallets = this.savedSubscriptions.wallets.filter(sw => !message.wallets.some(w => w.address === sw.address && w.chainId === sw.chainId));
+            }
+            if (message.chains) {
+                this.savedSubscriptions.chains = this.savedSubscriptions.chains.filter(c => !message.chains.includes(c));
+            }
+        }
+        return new Promise((resolve, reject) => {
+            // Set up timeout
+            const timeout = setTimeout(() => {
+                this.pendingSubscription = null;
+                reject(new Error('Subscription timeout'));
+            }, 10000);
+            this.pendingSubscription = {
+                resolve: () => {
+                    clearTimeout(timeout);
+                    this.pendingSubscription = null;
+                    resolve(this.subscriptionState);
+                },
+                reject: (err) => {
+                    clearTimeout(timeout);
+                    this.pendingSubscription = null;
+                    reject(err);
+                }
+            };
+            this.ws.send(JSON.stringify(message));
+            this.log('Sent subscription message:', message);
+        });
+    }
+    handleMessage(data, onConnected) {
+        try {
+            const message = JSON.parse(data);
+            switch (message.type) {
+                case 'connected':
+                    this.connectionInfo = message.payload;
+                    this.reconnectAttempts = 0;
+                    this.setState('connected');
+                    this.log('Connected:', message.payload);
+                    onConnected?.();
+                    // Restore subscriptions on reconnect
+                    this.restoreSubscriptions();
+                    break;
+                case 'subscribed':
+                    this.subscriptionState = message.payload;
+                    this.log('Subscription confirmed:', message.payload);
+                    this.pendingSubscription?.resolve();
+                    break;
+                case 'unsubscribed':
+                    this.subscriptionState = message.payload;
+                    this.log('Unsubscription confirmed:', message.payload);
+                    this.pendingSubscription?.resolve();
+                    break;
+                case 'event':
+                    this.routeEvent(message.payload);
+                    break;
+                case 'ping':
+                    // Respond to server ping with pong
+                    this.sendPong();
+                    break;
+                case 'error':
+                    this.log('Server error:', message.payload);
+                    this.pendingSubscription?.reject(new Error(message.payload.message));
+                    break;
+            }
+        }
+        catch (err) {
+            this.log('Failed to parse message:', err);
+        }
+    }
+    sendPong() {
+        if (this.ws && this.ws.readyState === WebSocket.OPEN) {
+            this.ws.send(JSON.stringify({ type: 'pong' }));
+            this.log('Sent pong');
+        }
+    }
+    async restoreSubscriptions() {
+        // Restore wallet subscriptions
+        if (this.savedSubscriptions.wallets.length > 0) {
+            this.log('Restoring wallet subscriptions:', this.savedSubscriptions.wallets);
+            try {
+                await this.subscribeWallets(this.savedSubscriptions.wallets);
+            }
+            catch (err) {
+                this.log('Failed to restore wallet subscriptions:', err);
+            }
+        }
+        // Restore chain subscriptions
+        if (this.savedSubscriptions.chains.length > 0) {
+            this.log('Restoring chain subscriptions:', this.savedSubscriptions.chains);
+            try {
+                await this.subscribeChains(this.savedSubscriptions.chains);
+            }
+            catch (err) {
+                this.log('Failed to restore chain subscriptions:', err);
+            }
+        }
+    }
+    routeEvent(event) {
+        this.log('Event received:', event.type, event);
+        // Call specific type handlers
+        const typeHandlers = this.handlers.get(event.type);
+        typeHandlers?.forEach(handler => {
+            try {
+                handler(event);
+            }
+            catch (err) {
+                console.error('[PERS-Events] Handler error:', err);
+            }
+        });
+        // Call wildcard handlers
+        const wildcardHandlers = this.handlers.get('*');
+        wildcardHandlers?.forEach(handler => {
+            try {
+                handler(event);
+            }
+            catch (err) {
+                console.error('[PERS-Events] Handler error:', err);
+            }
+        });
+    }
+    handleDisconnect() {
+        this.cleanup();
+        this.setState('disconnected');
+        if (this.config.autoReconnect && this.token) {
+            if (this.reconnectAttempts < this.config.maxReconnectAttempts) {
+                this.attemptReconnect();
+            }
+            else {
+                this.log(`Max reconnect attempts (${this.config.maxReconnectAttempts}) reached. Call connect() manually to retry.`);
+                // Reset counter so manual connect() will work
+                this.reconnectAttempts = 0;
+            }
+        }
+    }
+    attemptReconnect() {
+        const delay = Math.min(this.config.reconnectDelay * Math.pow(2, this.reconnectAttempts), 30000 // Max 30 second delay
+        );
+        this.reconnectAttempts++;
+        this.log(`🔄 Reconnecting in ${delay}ms (attempt ${this.reconnectAttempts}/${this.config.maxReconnectAttempts})`);
+        this.setState('reconnecting');
+        this.reconnectTimeout = setTimeout(async () => {
+            try {
+                // Try to get fresh token if tokenRefresher is provided
+                let tokenToUse = this.token;
+                if (this.config.tokenRefresher) {
+                    try {
+                        this.log('🔄 Refreshing token before reconnect...');
+                        tokenToUse = await this.config.tokenRefresher();
+                        this.token = tokenToUse; // Update stored token
+                    }
+                    catch (refreshErr) {
+                        this.log('⚠️ Token refresh failed, using existing token:', refreshErr);
+                    }
+                }
+                if (tokenToUse) {
+                    this.log(`🔄 Attempting reconnection...`);
+                    await this.connect(tokenToUse);
+                }
+            }
+            catch (err) {
+                this.log('❌ Reconnect failed:', err);
+            }
+        }, delay);
+    }
+    cleanup() {
+        if (this.reconnectTimeout) {
+            clearTimeout(this.reconnectTimeout);
+            this.reconnectTimeout = null;
+        }
+        if (this.ws) {
+            this.ws.onopen = null;
+            this.ws.onmessage = null;
+            this.ws.onerror = null;
+            this.ws.onclose = null;
+            if (this.ws.readyState === WebSocket.OPEN) {
+                this.ws.close();
+            }
+            this.ws = null;
+        }
+    }
+    setState(state) {
+        if (this.state !== state) {
+            this.state = state;
+            this.stateHandlers.forEach(handler => handler(state));
+        }
+    }
+    log(...args) {
+        if (this.config.debug) {
+            console.log('[PERS-Events]', ...args);
+        }
+    }
+}
+
+/**
+ * Wallet Events Manager - Real-time blockchain events for user's wallets
+ *
+ * Provides automatic connection management and event routing integrated
+ * with the SDK's authentication flow and event system.
+ *
+ * Events are routed through the SDK's PersEventEmitter, so you can either:
+ * 1. Subscribe via `sdk.walletEvents.on()` for wallet-specific handling
+ * 2. Subscribe via `sdk.events.subscribe()` for unified event stream
+ *
+ * ## v1.2.0 - Subscription Model
+ *
+ * After connecting, you must explicitly subscribe to wallets or chains:
+ * - User SDK: `subscribeWallets([{ address, chainId }])`
+ * - Admin Dashboard: `subscribeChains([chainId1, chainId2])`
+ *
+ * For convenience, use `sdk.connectWalletEvents()` which auto-subscribes
+ * based on auth type.
+ *
+ * @example Manual subscription
+ * ```typescript
+ * await sdk.walletEvents.connect();
+ * await sdk.walletEvents.subscribeWallets([
+ *   { address: user.wallets[0].address, chainId: 39123 }
+ * ]);
+ *
+ * sdk.walletEvents.on('Transfer', (event) => {
+ *   console.log(`Received ${event.data.value} tokens`);
+ * });
+ * ```
+ *
+ * @example Auto-subscription (recommended)
+ * ```typescript
+ * // Auto-subscribes based on auth type (user/business/admin)
+ * await sdk.connectWalletEvents();
+ * ```
+ */
+/**
+ * Wallet Events Manager - Manages real-time blockchain event subscriptions
+ *
+ * Low-level WS client wrapper. For auto-subscription based on auth type,
+ * use `sdk.connectWalletEvents()` which handles subscription automatically.
+ */
+class WalletEventsManager {
+    constructor(apiClient, eventEmitter, config) {
+        this.apiClient = apiClient;
+        this.eventEmitter = eventEmitter;
+        this.client = null;
+        this.pendingHandlers = [];
+        this.unsubscribes = [];
+        this.config = {
+            autoReconnect: true,
+            connectionTimeout: 30000,
+            debug: false,
+            ...config,
+        };
+    }
+    /**
+     * Connect to real-time wallet events
+     *
+     * Establishes WebSocket connection to the WS relay server.
+     * After connecting, call subscribeWallets() or subscribeChains() to start
+     * receiving events.
+     *
+     * For auto-subscription, use `sdk.connectWalletEvents()` instead.
+     */
+    async connect() {
+        // Already connected?
+        if (this.client?.getState() === 'connected') {
+            return;
+        }
+        const sdkConfig = this.apiClient.getConfig();
+        const authProvider = sdkConfig.authProvider;
+        if (!authProvider) {
+            throw new Error('Not authenticated. Call sdk.auth.login() first.');
+        }
+        const token = await authProvider.getToken();
+        if (!token) {
+            throw new Error('No authentication token available. Call sdk.auth.login() first.');
+        }
+        // Resolve wsUrl: config override > SDK config > environment default
+        const wsUrl = this.config.wsUrl
+            || sdkConfig.walletEventsWsUrl
+            || buildWalletEventsWsUrl(sdkConfig.environment);
+        // Create token refresher that fetches fresh token from auth provider
+        const tokenRefresher = async () => {
+            const freshToken = await authProvider.getToken();
+            if (!freshToken) {
+                throw new Error('Failed to refresh token');
+            }
+            return freshToken;
+        };
+        this.client = new PersEventsClient({
+            wsUrl,
+            autoReconnect: this.config.autoReconnect,
+            connectionTimeout: this.config.connectionTimeout,
+            debug: this.config.debug,
+            tokenRefresher,
+        });
+        await this.client.connect(token);
+        // Clear previous unsubscribes on new connection (prevent memory leak)
+        this.unsubscribes.forEach(unsub => unsub());
+        this.unsubscribes = [];
+        // Route all events through PersEventEmitter for unified stream
+        // Note: Cast needed because web3-types uses string for event.type while pers-shared uses strict union
+        this.client.on('*', (event) => this.emitToPersEvents(event));
+        // Re-attach any handlers registered before connect
+        for (const { type, handler } of this.pendingHandlers) {
+            this.unsubscribes.push(this.client.on(type, handler));
+        }
+        this.pendingHandlers = [];
+    }
+    /**
+     * Disconnect from real-time events
+     */
+    disconnect() {
+        this.unsubscribes.forEach(unsub => unsub());
+        this.unsubscribes = [];
+        this.client?.disconnect();
+        this.client = null;
+    }
+    // ─────────────────────────────────────────────────────────────────────────────
+    // Subscription Methods (v1.2.0)
+    // ─────────────────────────────────────────────────────────────────────────────
+    /**
+     * Subscribe to wallet events
+     *
+     * Receives events only for the specified wallet addresses.
+     * Use this for user-facing SDK where you want to monitor specific wallets.
+     *
+     * @param wallets - Array of wallet info (address + chainId)
+     * @returns Promise that resolves when subscription is confirmed
+     *
+     * @example
+     * ```typescript
+     * await sdk.walletEvents.connect();
+     * await sdk.walletEvents.subscribeWallets([
+     *   { address: '0x123...', chainId: 39123 }
+     * ]);
+     * ```
+     */
+    async subscribeWallets(wallets) {
+        if (!this.client) {
+            throw new Error('Not connected. Call connect() first.');
+        }
+        return this.client.subscribeWallets(wallets);
+    }
+    /**
+     * Subscribe to chain events (Admin Dashboard)
+     *
+     * Receives ALL events on the specified chains.
+     * Use for admin dashboards that need to monitor all activity.
+     *
+     * @param chains - Array of chain IDs to subscribe to
+     * @returns Promise that resolves when subscription is confirmed
+     *
+     * @example
+     * ```typescript
+     * await sdk.walletEvents.connect();
+     * await sdk.walletEvents.subscribeChains([39123, 137]);
+     * ```
+     */
+    async subscribeChains(chains) {
+        if (!this.client) {
+            throw new Error('Not connected. Call connect() first.');
+        }
+        return this.client.subscribeChains(chains);
+    }
+    /**
+     * Unsubscribe from wallet events
+     *
+     * @param wallets - Array of wallet info to unsubscribe from
+     * @returns Promise that resolves when unsubscription is confirmed
+     */
+    async unsubscribeWallets(wallets) {
+        if (!this.client) {
+            throw new Error('Not connected. Call connect() first.');
+        }
+        return this.client.unsubscribeWallets(wallets);
+    }
+    /**
+     * Unsubscribe from chain events
+     *
+     * @param chains - Array of chain IDs to unsubscribe from
+     * @returns Promise that resolves when unsubscription is confirmed
+     */
+    async unsubscribeChains(chains) {
+        if (!this.client) {
+            throw new Error('Not connected. Call connect() first.');
+        }
+        return this.client.unsubscribeChains(chains);
+    }
+    /**
+     * Get current subscription state
+     */
+    getSubscriptionState() {
+        return this.client?.getSubscriptionState() ?? { wallets: [], chains: [], activeChains: [] };
+    }
+    // ─────────────────────────────────────────────────────────────────────────────
+    // Event Handlers
+    // ─────────────────────────────────────────────────────────────────────────────
+    /**
+     * Subscribe to blockchain events
+     *
+     * @param eventType - Event type ('Transfer', 'Approval', etc.) or '*' for all
+     * @param handler - Callback function when event is received
+     * @returns Unsubscribe function
+     *
+     * @example
+     * ```typescript
+     * const unsub = sdk.walletEvents.on('Transfer', (event) => {
+     *   console.log(`Transfer: ${event.data.from} -> ${event.data.to}`);
+     * });
+     *
+     * // Later: stop listening
+     * unsub();
+     * ```
+     */
+    on(eventType, handler) {
+        if (this.client) {
+            const unsub = this.client.on(eventType, handler);
+            this.unsubscribes.push(unsub);
+            return unsub;
+        }
+        else {
+            // Store for when connect() is called
+            this.pendingHandlers.push({ type: eventType, handler });
+            return () => {
+                const idx = this.pendingHandlers.findIndex(h => h.handler === handler);
+                if (idx !== -1)
+                    this.pendingHandlers.splice(idx, 1);
+            };
+        }
+    }
+    /**
+     * Subscribe to connection state changes
+     */
+    onStateChange(handler) {
+        if (this.client) {
+            return this.client.onStateChange(handler);
+        }
+        return () => { };
+    }
+    /**
+     * Get current connection state
+     */
+    getState() {
+        return this.client?.getState() ?? 'disconnected';
+    }
+    /**
+     * Check if connected
+     */
+    isConnected() {
+        return this.getState() === 'connected';
+    }
+    /**
+     * Get connection info (wallets, active chains)
+     */
+    getConnectionInfo() {
+        return this.client?.getConnectionInfo();
+    }
+    // ─────────────────────────────────────────────────────────────────────────────
+    // Private Methods
+    // ─────────────────────────────────────────────────────────────────────────────
+    /**
+     * Build a descriptive message for blockchain events
+     * Neutral tone - frontend will handle user-facing presentation
+     */
+    buildUserMessage(event) {
+        const { type, data } = event;
+        // Use string for switch since event types may extend beyond strict BlockchainEventType union
+        const eventType = type;
+        const from = data.from?.toLowerCase();
+        const to = data.to?.toLowerCase();
+        const shortFrom = from ? `${from.slice(0, 6)}...${from.slice(-4)}` : 'unknown';
+        const shortTo = to ? `${to.slice(0, 6)}...${to.slice(-4)}` : 'unknown';
+        // Get user's wallets to determine direction
+        const subscriptionState = this.getSubscriptionState();
+        const userWallets = subscriptionState.wallets.map(w => w.address.toLowerCase());
+        const isIncoming = to && userWallets.includes(to);
+        const isOutgoing = from && userWallets.includes(from);
+        const isMint = from === '0x0000000000000000000000000000000000000000';
+        const isBurn = to === '0x0000000000000000000000000000000000000000';
+        switch (eventType) {
+            case 'Transfer':
+                if (isMint) {
+                    return `Token minted to ${shortTo}`;
+                }
+                else if (isBurn) {
+                    return `Token burned from ${shortFrom}`;
+                }
+                else if (isIncoming) {
+                    return `Transfer received from ${shortFrom}`;
+                }
+                else if (isOutgoing) {
+                    return `Transfer sent to ${shortTo}`;
+                }
+                return `Transfer from ${shortFrom} to ${shortTo}`;
+            case 'Approval':
+                return `Approval from ${shortFrom}`;
+            case 'SmartWalletCreated':
+                return `Smart wallet created: ${shortTo}`;
+            case 'TransactionExecuted':
+                return `Transaction executed by ${shortFrom}`;
+            case 'OwnershipTransferred':
+                return `Ownership transferred from ${shortFrom} to ${shortTo}`;
+            default:
+                return `${eventType} event`;
+        }
+    }
+    /**
+     * Route blockchain event to PersEventEmitter for unified event stream
+     */
+    emitToPersEvents(event) {
+        const userMessage = this.buildUserMessage(event);
+        this.eventEmitter.emitSuccess({
+            type: `wallet_${event.type.toLowerCase()}`,
+            domain: 'wallet',
+            userMessage,
+            details: {
+                chainId: event.chainId,
+                txHash: event.txHash,
+                blockNumber: event.blockNumber,
+                timestamp: event.timestamp,
+                contractAddress: event.contractAddress,
+                ...event.data,
+            },
+        });
+    }
+}
+
 /**
  * @fileoverview PERS SDK - Platform-agnostic TypeScript SDK with High-Level Managers
  *
@@ -14756,6 +17238,81 @@ class PersSDK {
         // Initialize event emitter and wire to API client for error events
         this._events = new PersEventEmitter();
         this.apiClient.setEvents(this._events);
+        // Auto-connect to wallet events on successful login (if enabled)
+        this.setupWalletEventsAutoConnect();
+    }
+    /**
+     * Setup auto-connect for wallet events on authentication
+     * @internal
+     */
+    setupWalletEventsAutoConnect() {
+        const config = this.apiClient.getConfig();
+        // Check if captureWalletEvents is enabled (default: true)
+        if (config.captureWalletEvents === false) {
+            return;
+        }
+        // Listen for login success events (both fresh login and session restoration)
+        this._events.subscribe((event) => {
+            if (event.level === 'success' && (event.type === 'LOGIN_SUCCESS' || event.type === 'session_restored')) {
+                // Auto-connect and subscribe to wallet events (fire and forget, log errors)
+                this.connectWalletEvents().catch((err) => {
+                    console.warn('[PersSDK] Failed to auto-connect wallet events:', err.message);
+                });
+            }
+            // Disconnect on logout
+            if (event.level === 'success' && event.type === 'logout_success') {
+                this.walletEvents.disconnect();
+            }
+        });
+    }
+    /**
+     * Connect to wallet events and auto-subscribe based on auth type
+     *
+     * Connects to the WebSocket relay and automatically subscribes to relevant
+     * blockchain events based on the current authentication type:
+     * - **USER**: Subscribes to all user's wallets
+     * - **BUSINESS**: Subscribes to all business's wallets
+     * - **TENANT**: Subscribes to all chains where tokens are deployed
+     *
+     * This method is called automatically on login when `captureWalletEvents` is enabled.
+     * Call manually if you need to reconnect or refresh subscriptions.
+     *
+     * @example Manual connection
+     * ```typescript
+     * await sdk.connectWalletEvents();
+     * ```
+     */
+    async connectWalletEvents() {
+        await this.walletEvents.connect();
+        // Get authType from auth provider (where it's stored during login)
+        const authProvider = this.apiClient.getConfig().authProvider;
+        const authType = authProvider?.getAuthType ? await authProvider.getAuthType() : undefined;
+        switch (authType) {
+            case exports.AccountOwnerType.USER: {
+                const user = await this.users.getCurrentUser();
+                const wallets = user.wallets?.map(w => ({ address: w.address, chainId: w.chainId })) || [];
+                if (wallets.length > 0) {
+                    await this.walletEvents.subscribeWallets(wallets);
+                }
+                break;
+            }
+            case exports.AccountOwnerType.BUSINESS: {
+                const business = await this.auth.getCurrentBusiness();
+                const wallets = business.wallets?.map(w => ({ address: w.address, chainId: w.chainId })) || [];
+                if (wallets.length > 0) {
+                    await this.walletEvents.subscribeWallets(wallets);
+                }
+                break;
+            }
+            case exports.AccountOwnerType.TENANT: {
+                const tokens = await this.tokens.getTokens();
+                const chains = [...new Set(tokens.data.map(t => t.chainId))];
+                if (chains.length > 0) {
+                    await this.walletEvents.subscribeChains(chains);
+                }
+                break;
+            }
+        }
     }
     /**
      * Restore user session from stored tokens
@@ -15163,6 +17720,103 @@ class PersSDK {
         }
         return this._triggerSources;
     }
+    /**
+     * Webhook manager - High-level webhook operations
+     *
+     * Provides methods for creating webhooks, triggering them programmatically,
+     * and monitoring execution history. Supports async workflows with callbacks.
+     *
+     * @returns WebhookManager instance
+     *
+     * @example Webhook Operations
+     * ```typescript
+     * // Admin: Create a webhook
+     * const webhook = await sdk.webhooks.create({
+     *   name: 'Order Processing',
+     *   targetUrl: 'https://n8n.example.com/webhook/orders',
+     *   method: 'POST'
+     * });
+     *
+     * // Trigger webhook with payload
+     * const result = await sdk.webhooks.trigger(webhook.id, {
+     *   orderId: 'order-123',
+     *   action: 'created'
+     * });
+     *
+     * // Trigger and wait for async workflow completion
+     * const asyncResult = await sdk.webhooks.triggerAndWait(
+     *   'ai-webhook',
+     *   { prompt: 'Analyze this data' },
+     *   30000  // Wait up to 30s
+     * );
+     * ```
+     *
+     * @see {@link WebhookManager} for detailed documentation
+     */
+    get webhooks() {
+        if (!this._webhooks) {
+            const projectKey = this.apiClient.getConfig().apiProjectKey || '';
+            this._webhooks = new WebhookManager(this.apiClient, projectKey, this._events);
+        }
+        return this._webhooks;
+    }
+    /**
+     * Wallet Events Manager - Real-time blockchain events for user's wallets
+     *
+     * Provides real-time WebSocket connection to receive blockchain events
+     * for the user's wallets (transfers, approvals, NFT mints, etc.).
+     *
+     * Events are also routed through `sdk.events` for unified event handling.
+     *
+     * **Important:** Requires `walletEventsWsUrl` configuration and authentication.
+     *
+     * @returns WalletEventsManager instance
+     *
+     * @example Basic Usage
+     * ```typescript
+     * // Configure SDK with events URL
+     * sdk.configureWalletEvents({ wsUrl: 'wss://events.pers.ninja' });
+     *
+     * // Connect after authentication
+     * await sdk.auth.loginWithToken(jwt, 'user');
+     * await sdk.walletEvents.connect();
+     *
+     * // Listen for token transfers
+     * sdk.walletEvents.on('Transfer', (event) => {
+     *   if (event.data.to === myWallet) {
+     *     showNotification(`Received ${event.data.value} tokens!`);
+     *   }
+     * });
+     * ```
+     *
+     * @example Unified Event Stream
+     * ```typescript
+     * // Wallet events also flow through sdk.events
+     * sdk.events.subscribe((event) => {
+     *   if (event.domain === 'wallet') {
+     *     console.log('Wallet event:', event.type);
+     *   }
+     * });
+     * ```
+     *
+     * @see {@link WalletEventsManager} for detailed documentation
+     */
+    get walletEvents() {
+        if (!this._walletEvents) {
+            this._walletEvents = new WalletEventsManager(this.apiClient, this._events, this.walletEventsConfig);
+        }
+        return this._walletEvents;
+    }
+    /**
+     * Configure wallet events (call before accessing walletEvents)
+     *
+     * @param config - Events configuration including wsUrl
+     */
+    configureWalletEvents(config) {
+        this.walletEventsConfig = config;
+        // Reset manager so it picks up new config
+        this._walletEvents = undefined;
+    }
     /**
      * Gets the API client for direct PERS API requests
      *
@@ -15233,281 +17887,6 @@ function detectEnvironment() {
  */
 detectEnvironment();
 
-/**
- * Centralized Cache Service for PERS SDK
- * Simple, efficient caching with memory management
- */
-const DEFAULT_CACHE_CONFIG = {
-    defaultTtl: 30 * 60 * 1000, // 30 minutes
-    maxMemoryMB: 50, // 50MB cache limit
-    cleanupInterval: 5 * 60 * 1000, // Cleanup every 5 minutes
-    maxEntries: 10000, // Entry count limit
-    evictionBatchPercent: 0.2, // Remove 20% when evicting
-};
-// Constants for memory estimation
-const ENTRY_OVERHEAD_BYTES = 64;
-const DEFAULT_OBJECT_SIZE_BYTES = 1024;
-const MEMORY_CHECK_INTERVAL_MS = 60000; // Lazy check every 60s
-class CacheService {
-    constructor(config) {
-        this.cache = new Map();
-        this.cleanupTimer = null;
-        this.lastMemoryCheck = 0;
-        this.pendingFetches = new Map();
-        this.accessOrder = new Set();
-        this.stats = {
-            hits: 0,
-            misses: 0,
-            errors: 0
-        };
-        this.config = { ...DEFAULT_CACHE_CONFIG, ...config };
-        this.startCleanupTimer();
-    }
-    /**
-     * Set a value in cache with optional TTL
-     */
-    set(key, value, ttl) {
-        if (!key || value === undefined)
-            return;
-        const entry = {
-            value,
-            timestamp: Date.now(),
-            ttl: ttl || this.config.defaultTtl,
-            lastAccessed: Date.now()
-        };
-        this.cache.set(key, entry);
-        this.accessOrder.add(key);
-        // Fast entry count check first
-        if (this.cache.size > this.config.maxEntries) {
-            this.evictOldestEntries();
-        }
-        // Lazy memory check (only every 10s)
-        const now = Date.now();
-        if (now - this.lastMemoryCheck > MEMORY_CHECK_INTERVAL_MS) {
-            this.lastMemoryCheck = now;
-            this.enforceMemoryLimit();
-        }
-    }
-    /**
-     * Get a value from cache
-     */
-    get(key) {
-        const entry = this.cache.get(key);
-        if (!entry) {
-            this.stats.misses++;
-            return null;
-        }
-        // Check if expired
-        const now = Date.now();
-        if (now - entry.timestamp > entry.ttl) {
-            this.cache.delete(key);
-            this.accessOrder.delete(key);
-            this.stats.misses++;
-            return null;
-        }
-        // Update access order efficiently
-        this.accessOrder.delete(key);
-        this.accessOrder.add(key);
-        entry.lastAccessed = now;
-        this.stats.hits++;
-        return entry.value;
-    }
-    /**
-     * Get or set pattern - common caching pattern with race condition protection
-     */
-    async getOrSet(key, fetcher, ttl) {
-        const cached = this.get(key);
-        if (cached !== null)
-            return cached;
-        // Prevent duplicate fetches
-        if (this.pendingFetches.has(key)) {
-            return this.pendingFetches.get(key);
-        }
-        const fetchPromise = fetcher()
-            .then(value => {
-            this.pendingFetches.delete(key);
-            if (value !== undefined) {
-                this.set(key, value, ttl);
-            }
-            return value;
-        })
-            .catch(error => {
-            this.pendingFetches.delete(key);
-            this.stats.errors++;
-            throw error;
-        });
-        this.pendingFetches.set(key, fetchPromise);
-        return fetchPromise;
-    }
-    /**
-     * Delete a specific key
-     */
-    delete(key) {
-        this.accessOrder.delete(key);
-        return this.cache.delete(key);
-    }
-    /**
-     * Clear all keys matching a prefix
-     */
-    clearByPrefix(prefix) {
-        const keysToDelete = Array.from(this.cache.keys()).filter(key => key.startsWith(prefix));
-        keysToDelete.forEach(key => {
-            this.cache.delete(key);
-            this.accessOrder.delete(key);
-        });
-        return keysToDelete.length;
-    }
-    /**
-     * Clear all cache
-     */
-    clear() {
-        this.cache.clear();
-        this.accessOrder.clear();
-        this.pendingFetches.clear();
-        this.stats = { hits: 0, misses: 0, errors: 0 };
-    }
-    /**
-     * Force cleanup of expired entries
-     */
-    cleanup() {
-        const now = Date.now();
-        const keysToDelete = [];
-        for (const [key, entry] of this.cache.entries()) {
-            if (now - entry.timestamp > entry.ttl) {
-                keysToDelete.push(key);
-            }
-        }
-        keysToDelete.forEach(key => {
-            this.cache.delete(key);
-            this.accessOrder.delete(key);
-        });
-        return keysToDelete.length;
-    }
-    /**
-     * Stop cleanup timer and clear cache
-     */
-    destroy() {
-        this.stopCleanupTimer();
-        this.clear();
-    }
-    /**
-     * Create a namespaced cache interface
-     */
-    createNamespace(namespace) {
-        if (!namespace || namespace.includes(':')) {
-            throw new Error('Namespace must be non-empty and cannot contain ":"');
-        }
-        return {
-            set: (key, value, ttl) => this.set(`${namespace}:${key}`, value, ttl),
-            get: (key) => this.get(`${namespace}:${key}`),
-            getOrSet: (key, fetcher, ttl) => this.getOrSet(`${namespace}:${key}`, fetcher, ttl),
-            delete: (key) => this.delete(`${namespace}:${key}`),
-            clear: () => this.clearByPrefix(`${namespace}:`)
-        };
-    }
-    startCleanupTimer() {
-        this.stopCleanupTimer();
-        this.cleanupTimer = setInterval(() => {
-            this.safeCleanup();
-        }, this.config.cleanupInterval);
-        // Platform-agnostic: Prevent hanging process in Node.js environments
-        if (this.cleanupTimer && typeof this.cleanupTimer.unref === 'function') {
-            this.cleanupTimer.unref();
-        }
-    }
-    stopCleanupTimer() {
-        if (this.cleanupTimer) {
-            clearInterval(this.cleanupTimer);
-            this.cleanupTimer = null;
-        }
-    }
-    safeCleanup() {
-        try {
-            this.cleanup();
-            this.enforceMemoryLimit();
-        }
-        catch (error) {
-            this.stats.errors++;
-            // Platform-agnostic error logging
-            if (typeof console !== 'undefined' && console.warn) {
-                console.warn('Cache cleanup error:', error);
-            }
-        }
-    }
-    estimateValueSize(value) {
-        if (typeof value === 'string') {
-            return value.length * 2; // UTF-16 encoding
-        }
-        if (typeof value === 'number' || typeof value === 'boolean') {
-            return 8; // Primitive values
-        }
-        if (value === null || value === undefined) {
-            return 4;
-        }
-        try {
-            // More accurate JSON-based estimation for serializable objects
-            const jsonString = JSON.stringify(value);
-            return jsonString.length * 2;
-        }
-        catch {
-            // Fallback for non-serializable objects
-            if (Array.isArray(value)) {
-                return value.length * 100; // Better estimate for arrays
-            }
-            if (value && typeof value === 'object') {
-                return Object.keys(value).length * 50; // Better estimate for objects
-            }
-            return DEFAULT_OBJECT_SIZE_BYTES;
-        }
-    }
-    estimateMemoryUsage() {
-        let totalSize = 0;
-        for (const [key, entry] of this.cache.entries()) {
-            totalSize += key.length * 2; // Key size
-            totalSize += this.estimateValueSize(entry.value);
-            totalSize += ENTRY_OVERHEAD_BYTES;
-        }
-        return totalSize / (1024 * 1024);
-    }
-    enforceMemoryLimit() {
-        const memoryUsage = this.estimateMemoryUsage();
-        if (memoryUsage <= this.config.maxMemoryMB || this.cache.size === 0)
-            return;
-        this.evictOldestEntries();
-    }
-    evictOldestEntries() {
-        if (this.cache.size === 0)
-            return;
-        const batchSize = Math.floor(this.cache.size * this.config.evictionBatchPercent);
-        const toRemove = Math.max(batchSize, 1);
-        // Efficiently remove oldest entries using access order
-        const iterator = this.accessOrder.values();
-        for (let i = 0; i < toRemove; i++) {
-            const result = iterator.next();
-            if (result.done)
-                break;
-            const key = result.value;
-            this.cache.delete(key);
-            this.accessOrder.delete(key);
-        }
-    }
-}
-// Singleton instance
-const globalCacheService = new CacheService();
-
-/**
- * Cache module exports
- */
-// Predefined cache TTL constants
-const CacheTTL = {
-    SHORT: 5 * 60 * 1000, // 5 minutes
-    MEDIUM: 30 * 60 * 1000, // 30 minutes  
-    LONG: 24 * 60 * 60 * 1000, // 24 hours
-    METADATA: 24 * 60 * 60 * 1000, // 24 hours - IPFS metadata is immutable
-    GATEWAY: 30 * 60 * 1000, // 30 minutes - Gateway config can change
-    PROVIDER: 60 * 60 * 1000, // 1 hour - Provider connections with auth
-};
-
 /**
  * AsyncStorage Token Storage for React Native Mobile Platforms
  *
@@ -16052,7 +18431,35 @@ class ReactNativeHttpClient {
 
 // Create the context
 const SDKContext = react.createContext(null);
-// Provider component
+/**
+ * PERS SDK Provider for React Native
+ *
+ * Wraps your app to provide SDK context to all child components.
+ * Handles platform-specific initialization (DPoP, storage, etc.).
+ *
+ * @param config - SDK configuration (see PersConfig)
+ * @param config.apiProjectKey - Your PERS project key (required)
+ * @param config.environment - 'staging' | 'production' (default: 'staging')
+ * @param config.captureWalletEvents - Enable real-time blockchain events (default: true)
+ * @param config.dpop - DPoP configuration for enhanced security
+ *
+ * @example Basic usage
+ * ```tsx
+ * <PersSDKProvider config={{ apiProjectKey: 'my-project' }}>
+ *   <App />
+ * </PersSDKProvider>
+ * ```
+ *
+ * @example Disable wallet events
+ * ```tsx
+ * <PersSDKProvider config={{
+ *   apiProjectKey: 'my-project',
+ *   captureWalletEvents: false  // Disable auto-connect to blockchain events
+ * }}>
+ *   <App />
+ * </PersSDKProvider>
+ * ```
+ */
 const PersSDKProvider = ({ children, config }) => {
     const initializingRef = react.useRef(false);
     // State refs for stable functions to read current values
@@ -36196,6 +38603,7 @@ class Web3ChainApi {
     // ==========================================
     /**
      * PUBLIC: Get chain data by chain ID
+     * Returns ChainDataDTO from the API (rpcUrl may be optional)
      */
     async getChainData(chainId) {
         try {
@@ -36423,7 +38831,7 @@ class TokenDomainService {
                 const abi = convertAbiToInterface(params.abi);
                 const tokenUri = await this.web3Api.getTokenUri({ ...params, abi });
                 const metadata = tokenUri
-                    ? await this.metadataService.fetchAndProcessMetadata(tokenUri, params.chainId)
+                    ? await this.metadataService.fetchAndProcessMetadata(tokenUri)
                     : null;
                 return { tokenId: params.tokenId, tokenUri, metadata };
             }
@@ -36614,17 +39022,19 @@ class TokenDomainService {
 
 /**
  * MetadataDomainService - Clean IPFS metadata resolution with centralized caching
+ *
+ * IPFS gateway is resolved from tenant configuration (chain-agnostic).
  */
 class MetadataDomainService {
     constructor(ipfsApi) {
         this.ipfsApi = ipfsApi;
         this.cache = globalCacheService.createNamespace('metadata');
     }
-    async fetchAndProcessMetadata(tokenUri, chainId) {
-        const cacheKey = `fetch:${tokenUri}:${chainId}`;
+    async fetchAndProcessMetadata(tokenUri) {
+        const cacheKey = `fetch:${tokenUri}`;
         return this.cache.getOrSet(cacheKey, async () => {
             try {
-                return await this.ipfsApi.fetchAndProcessMetadata(tokenUri, chainId);
+                return await this.ipfsApi.fetchAndProcessMetadata(tokenUri);
             }
             catch (error) {
                 console.error(`Error fetching metadata for ${tokenUri}:`, error);
@@ -36632,9 +39042,9 @@ class MetadataDomainService {
             }
         }, CacheTTL.METADATA);
     }
-    async resolveIPFSUrl(url, chainId) {
-        const cacheKey = `resolve:${url}:${chainId}`;
-        return this.cache.getOrSet(cacheKey, () => this.ipfsApi.resolveIPFSUrl(url, chainId), CacheTTL.GATEWAY);
+    async resolveIPFSUrl(url) {
+        const cacheKey = `resolve:${url}`;
+        return this.cache.getOrSet(cacheKey, () => this.ipfsApi.resolveIPFSUrl(url), CacheTTL.GATEWAY);
     }
     /**
      * Clear all cached metadata and URLs for this service
@@ -36734,19 +39144,22 @@ class Web3ApplicationService {
         });
     }
     /**
-     * Resolve IPFS URLs to HTTPS if needed
+     * Resolve IPFS URLs to HTTPS if needed.
+     *
+     * IPFS gateway is resolved from tenant configuration (chain-agnostic).
      */
-    async resolveIPFSUrl(url, chainId) {
-        return this.metadataDomainService.resolveIPFSUrl(url, chainId);
+    async resolveIPFSUrl(url) {
+        return this.metadataDomainService.resolveIPFSUrl(url);
     }
     /**
      * Fetch and process metadata from any URI with IPFS conversion.
      *
      * Use this for ad-hoc metadata fetching when you have a tokenURI.
      * Normalization happens at infrastructure layer.
+     * IPFS gateway is resolved from tenant configuration (chain-agnostic).
      */
-    async fetchAndProcessMetadata(tokenUri, chainId) {
-        return this.metadataDomainService.fetchAndProcessMetadata(tokenUri, chainId);
+    async fetchAndProcessMetadata(tokenUri) {
+        return this.metadataDomainService.fetchAndProcessMetadata(tokenUri);
     }
 }
 
@@ -36800,30 +39213,42 @@ class Web3InfrastructureApi {
 
 /**
  * IPFSInfrastructureApi - Infrastructure implementation for IPFS operations
- * Uses Web3ChainService for IPFS gateway resolution with centralized caching
+ * Uses TenantManager for IPFS gateway resolution with centralized caching
+ *
+ * IMPORTANT: IPFS gateway domain is now fetched from tenant configuration (TenantClientConfigDTO),
+ * not from chain data. This is the correct architecture since IPFS is chain-agnostic.
  */
 class IPFSInfrastructureApi {
-    constructor(web3ChainService) {
-        this.web3ChainService = web3ChainService;
-        this.defaultIpfsGatewayDomain = 'pers.mypinata.cloud';
+    constructor(tenantManager) {
+        this.tenantManager = tenantManager;
         this.cache = globalCacheService.createNamespace('ipfs');
     }
-    async getIpfsGatewayDomain(chainId) {
-        const cacheKey = `gateway:${chainId}`;
+    /**
+     * Get IPFS gateway domain from tenant configuration.
+     *
+     * @returns The IPFS gateway domain from tenant configuration
+     * @throws Error if tenant config is not found or ipfsGatewayDomain is not configured
+     */
+    async getIpfsGatewayDomain() {
+        const cacheKey = 'gateway';
         return this.cache.getOrSet(cacheKey, async () => {
-            try {
-                const chainData = await this.web3ChainService.getChainDataWithCache(chainId);
-                return chainData.ipfsGatewayDomain || this.defaultIpfsGatewayDomain;
-            }
-            catch (error) {
-                console.warn(`Failed to get chain data for chainId ${chainId}, using default IPFS gateway:`, error);
-                return this.defaultIpfsGatewayDomain;
+            const clientConfig = await this.tenantManager.getClientConfig();
+            if (!clientConfig.ipfsGatewayDomain) {
+                throw new Error(`IPFS gateway domain not configured for tenant. ` +
+                    `Please configure ipfsGatewayDomain in the tenant configuration.`);
             }
+            return clientConfig.ipfsGatewayDomain;
         }, CacheTTL.GATEWAY);
     }
-    async resolveIPFSUrl(url, chainId) {
+    /**
+     * Resolve IPFS URL to HTTPS URL using tenant's configured gateway.
+     *
+     * @param url - The URL to resolve (can be ipfs:// or https://)
+     * @returns Resolved HTTPS URL
+     */
+    async resolveIPFSUrl(url) {
         if (url.startsWith('ipfs://')) {
-            const gateway = await this.getIpfsGatewayDomain(chainId);
+            const gateway = await this.getIpfsGatewayDomain();
             return url.replace('ipfs://', `https://${gateway}/ipfs/`);
         }
         return url;
@@ -36836,12 +39261,11 @@ class IPFSInfrastructureApi {
      * All downstream consumers receive normalized SDK format with resolved HTTPS URLs.
      *
      * @param tokenUri - Token URI (can be ipfs:// or https://)
-     * @param chainId - Chain ID for IPFS gateway selection
      * @returns Normalized TokenMetadata with resolved HTTPS URLs, or null on error
      */
-    async fetchAndProcessMetadata(tokenUri, chainId) {
+    async fetchAndProcessMetadata(tokenUri) {
         try {
-            const resolvedUri = await this.resolveIPFSUrl(tokenUri, chainId);
+            const resolvedUri = await this.resolveIPFSUrl(tokenUri);
             const response = await fetch(resolvedUri);
             if (!response.ok) {
                 throw new Error(`HTTP error! status: ${response.status}`);
@@ -36849,10 +39273,10 @@ class IPFSInfrastructureApi {
             const rawMetadata = await response.json();
             // Resolve IPFS URLs for media fields
             const resolvedImageUrl = rawMetadata.image
-                ? await this.resolveIPFSUrl(rawMetadata.image, chainId)
+                ? await this.resolveIPFSUrl(rawMetadata.image)
                 : '';
             const resolvedAnimationUrl = rawMetadata.animation_url
-                ? await this.resolveIPFSUrl(rawMetadata.animation_url, chainId)
+                ? await this.resolveIPFSUrl(rawMetadata.animation_url)
                 : undefined;
             // Extract custom properties (anything not in ERC standard)
             const customProperties = Object.fromEntries(Object.entries(rawMetadata).filter(([key]) => !['name', 'description', 'image', 'animation_url', 'external_url', 'attributes'].includes(key)));
@@ -36985,6 +39409,11 @@ async function getExplorerUrlByChainId(getChainData, chainId, address, type) {
  *   tokenIds  // Required for ERC-1155, optional for ERC-721
  * });
  * ```
+ *
+ * ## IPFS Resolution
+ *
+ * For IPFS URL resolution, use `sdk.tenant.resolveIPFSUrl()` instead.
+ * IPFS is chain-agnostic and configured at the tenant level.
  */
 class Web3Manager {
     // TODO: Add PersEventEmitter support for blockchain events
@@ -36994,14 +39423,16 @@ class Web3Manager {
     // 3. Emit via: this.events?.emitSuccess({ domain: 'web3', type: 'NFT_TRANSFERRED', ... })
     // 4. Filter to only user's address (not all transfers)
     // 5. Add cleanup for event listeners on SDK destroy
-    constructor(apiClient) {
+    constructor(apiClient, tenantManager) {
         this.apiClient = apiClient;
+        // Use provided TenantManager or create one
+        this.tenantManager = tenantManager || new TenantManager(apiClient);
         // Initialize Web3 Chain service
         const web3ChainApi = new Web3ChainApi(apiClient);
         this.web3ChainService = new Web3ChainService(web3ChainApi);
-        // Initialize Web3 Application service
+        // Initialize Web3 Application service with TenantManager for IPFS
         const web3InfrastructureApi = new Web3InfrastructureApi(this.web3ChainService);
-        const ipfsInfrastructureApi = new IPFSInfrastructureApi(this.web3ChainService);
+        const ipfsInfrastructureApi = new IPFSInfrastructureApi(this.tenantManager);
         this.web3ApplicationService = new Web3ApplicationService(web3InfrastructureApi, ipfsInfrastructureApi);
     }
     /**
@@ -37031,25 +39462,14 @@ class Web3Manager {
     async getTokenCollection(request) {
         return this.web3ApplicationService.getTokenCollection(request);
     }
-    /**
-     * Resolve IPFS URL to accessible URL
-     *
-     * @param url - IPFS URL to resolve
-     * @param chainId - Chain ID for context
-     * @returns Promise resolving to accessible URL
-     */
-    async resolveIPFSUrl(url, chainId) {
-        return this.web3ApplicationService.resolveIPFSUrl(url, chainId);
-    }
     /**
      * Fetch and process token metadata
      *
      * @param tokenUri - Token URI to fetch metadata from
-     * @param chainId - Chain ID for context
      * @returns Promise resolving to processed metadata or null if not found
      */
-    async fetchAndProcessMetadata(tokenUri, chainId) {
-        return this.web3ApplicationService.fetchAndProcessMetadata(tokenUri, chainId);
+    async fetchAndProcessMetadata(tokenUri) {
+        return this.web3ApplicationService.fetchAndProcessMetadata(tokenUri);
     }
     /**
      * Get blockchain chain data by chain ID
@@ -37133,7 +39553,7 @@ class Web3Manager {
      *
      * @param accountAddress - Any valid blockchain address (wallet, contract, etc.)
      * @param token - Token definition (from getRewardTokens, getStatusTokens, etc.)
-     * @param maxTokens - Maximum tokens to retrieve (default: 50)
+     * @param maxTokens - Maximum tokens to retrieve (default: 100, max: 100)
      * @returns Promise resolving to collection result with owned tokens
      *
      * @example Query user's wallet
@@ -37153,7 +39573,7 @@ class Web3Manager {
      * @see {@link extractTokenIds} - Low-level helper used internally for ERC-1155
      * @see {@link buildCollectionRequest} - For manual request building
      */
-    async getAccountOwnedTokensFromContract(accountAddress, token, maxTokens = 50) {
+    async getAccountOwnedTokensFromContract(accountAddress, token, maxTokens = 100) {
         // For ERC-1155, extract tokenIds from metadata
         const tokenIds = token.type === NativeTokenTypes.ERC1155 ? this.extractTokenIds(token) : undefined;
         const collection = await this.getTokenCollection({
@@ -37354,25 +39774,38 @@ const useWeb3 = () => {
             throw error;
         }
     }, [web3, isInitialized]);
-    const resolveIPFSUrl = react.useCallback(async (url, chainId) => {
-        if (!isInitialized || !web3) {
+    /**
+     * Resolve IPFS URL to HTTP gateway URL
+     *
+     * @deprecated Use `sdk.tenant.resolveIPFSUrl()` directly - IPFS is chain-agnostic
+     * @param url - IPFS URL to resolve (ipfs://...)
+     * @returns Promise resolving to HTTP gateway URL
+     */
+    const resolveIPFSUrl = react.useCallback(async (url) => {
+        if (!isInitialized || !sdk) {
             throw new Error('SDK not initialized. Call initialize() first.');
         }
         try {
-            const result = await web3.resolveIPFSUrl(url, chainId);
+            const result = await sdk.tenants.resolveIPFSUrl(url);
             return result;
         }
         catch (error) {
             console.error('Failed to resolve IPFS URL:', error);
             throw error;
         }
-    }, [web3, isInitialized]);
-    const fetchAndProcessMetadata = react.useCallback(async (tokenUri, chainId) => {
+    }, [sdk, isInitialized]);
+    /**
+     * Fetch and process token metadata from a URI
+     *
+     * @param tokenUri - Token URI to fetch metadata from
+     * @returns Promise resolving to processed metadata or null
+     */
+    const fetchAndProcessMetadata = react.useCallback(async (tokenUri) => {
         if (!isInitialized || !web3) {
             throw new Error('SDK not initialized. Call initialize() first.');
         }
         try {
-            const result = await web3.fetchAndProcessMetadata(tokenUri, chainId);
+            const result = await web3.fetchAndProcessMetadata(tokenUri);
             return result;
         }
         catch (error) {
@@ -37442,7 +39875,7 @@ const useWeb3 = () => {
      *
      * @param accountAddress - Any valid blockchain address (wallet, contract, etc.)
      * @param token - Token definition (from getRewardTokens, getStatusTokens, etc.)
-     * @param maxTokens - Maximum tokens to retrieve (default: 50)
+     * @param maxTokens - Maximum tokens to retrieve (default: 100, max: 100)
      * @returns Promise resolving to result with owned tokens
      * @throws Error if SDK is not initialized
      *
@@ -37461,7 +39894,7 @@ const useWeb3 = () => {
      * @see {@link extractTokenIds} - Low-level helper used internally for ERC-1155
      * @see {@link buildCollectionRequest} - For manual request building
      */
-    const getAccountOwnedTokensFromContract = react.useCallback(async (accountAddress, token, maxTokens = 50) => {
+    const getAccountOwnedTokensFromContract = react.useCallback(async (accountAddress, token, maxTokens = 100) => {
         if (!isInitialized || !web3) {
             throw new Error('SDK not initialized. Call initialize() first.');
         }
@@ -37476,10 +39909,10 @@ const useWeb3 = () => {
      *
      * @param accountAddress - Any valid blockchain address (wallet, contract, etc.)
      * @param token - Token definition
-     * @param maxTokens - Maximum tokens to retrieve (default: 50)
+     * @param maxTokens - Maximum tokens to retrieve (default: 100, max: 100)
      * @returns TokenCollectionRequest ready for getTokenCollection()
      */
-    const buildCollectionRequest = react.useCallback((accountAddress, token, maxTokens = 50) => {
+    const buildCollectionRequest = react.useCallback((accountAddress, token, maxTokens = 100) => {
         if (!web3) {
             throw new Error('SDK not initialized. Call initialize() first.');
         }
@@ -37571,6 +40004,18 @@ const useWeb3 = () => {
  * ```
  *
  * @example
+ * **With Wallet Events (Real-time):**
+ * ```typescript
+ * // Auto-refresh on Transfer, Approval, and other blockchain events
+ * const { tokenBalances } = useTokenBalances({
+ *   accountAddress: walletAddress!,
+ *   availableTokens,
+ *   refreshOnWalletEvents: true,    // Enable real-time refresh (default: true)
+ *   walletEventDebounceMs: 1000     // Debounce rapid events (default: 1000ms)
+ * });
+ * ```
+ *
+ * @example
  * **Multi-Wallet Support:**
  * ```typescript
  * function MultiWalletBalances() {
@@ -37589,12 +40034,14 @@ const useWeb3 = () => {
  * ```
  */
 function useTokenBalances(options) {
-    const { accountAddress, availableTokens = [], autoLoad = true, refreshInterval = 0 } = options;
+    const { accountAddress, availableTokens = [], autoLoad = true, refreshInterval = 0, refreshOnWalletEvents = true, walletEventDebounceMs = 1000 } = options;
     const { isAuthenticated, sdk } = usePersSDK();
     const web3 = useWeb3();
     const [tokenBalances, setTokenBalances] = react.useState([]);
     const [isLoading, setIsLoading] = react.useState(false);
     const [error, setError] = react.useState(null);
+    // Debounce ref for wallet events
+    const walletEventDebounceRef = react.useRef(null);
     // Check if the hook is available for use
     const isAvailable = web3.isAvailable && isAuthenticated && !!accountAddress;
     /**
@@ -37714,6 +40161,32 @@ function useTokenBalances(options) {
             clearInterval(intervalId);
         };
     }, [sdk, refreshInterval, isAvailable, loadBalances]);
+    // Wallet events refresh: listen for real-time blockchain events
+    // Refreshes on ANY wallet domain event (Transfer, TransferSingle, etc.)
+    // Debouncing prevents excessive API calls during rapid events
+    react.useEffect(() => {
+        if (!sdk || !refreshOnWalletEvents || !isAvailable)
+            return;
+        const unsubscribe = sdk.events.subscribe((event) => {
+            if (event.domain === 'wallet') {
+                // Debounce rapid events (batch transfers, etc.)
+                if (walletEventDebounceRef.current) {
+                    clearTimeout(walletEventDebounceRef.current);
+                }
+                walletEventDebounceRef.current = setTimeout(() => {
+                    console.log(`[useTokenBalances] Wallet event (${event.type}), refreshing balances...`);
+                    loadBalances();
+                    walletEventDebounceRef.current = null;
+                }, walletEventDebounceMs);
+            }
+        }, { domains: ['wallet'] });
+        return () => {
+            unsubscribe();
+            if (walletEventDebounceRef.current) {
+                clearTimeout(walletEventDebounceRef.current);
+            }
+        };
+    }, [sdk, refreshOnWalletEvents, walletEventDebounceMs, isAvailable, loadBalances]);
     return {
         tokenBalances,
         isLoading,
@@ -39315,7 +41788,23 @@ const useTenants = () => {
 
 const useUsers = () => {
     const { sdk, isInitialized, isAuthenticated } = usePersSDK();
-    const getCurrentUser = react.useCallback(async () => {
+    /**
+     * Get the current authenticated user with optional include relations
+     *
+     * @param options - Query options including include relations
+     * @returns Current user data
+     *
+     * @example
+     * ```typescript
+     * // Basic
+     * const user = await getCurrentUser();
+     *
+     * // With wallets included
+     * const userWithWallets = await getCurrentUser({ include: ['wallets'] });
+     * console.log('Wallets:', userWithWallets.included?.wallets);
+     * ```
+     */
+    const getCurrentUser = react.useCallback(async (options) => {
         if (!isInitialized || !sdk) {
             throw new Error('SDK not initialized. Call initialize() first.');
         }
@@ -39323,7 +41812,7 @@ const useUsers = () => {
             throw new Error('SDK not authenticated. getCurrentUser requires authentication.');
         }
         try {
-            const result = await sdk.users.getCurrentUser();
+            const result = await sdk.users.getCurrentUser(options);
             return result;
         }
         catch (error) {
@@ -39347,12 +41836,28 @@ const useUsers = () => {
             throw error;
         }
     }, [sdk, isInitialized, isAuthenticated]);
-    const getUserById = react.useCallback(async (userId) => {
+    /**
+     * Get user by ID with optional include relations
+     *
+     * @param userId - User identifier (id, email, externalId, etc.)
+     * @param options - Query options including include relations
+     * @returns User data
+     *
+     * @example
+     * ```typescript
+     * // Basic
+     * const user = await getUserById('user-123');
+     *
+     * // With wallets included
+     * const userWithWallets = await getUserById('user-123', { include: ['wallets'] });
+     * ```
+     */
+    const getUserById = react.useCallback(async (userId, options) => {
         if (!isInitialized || !sdk) {
             throw new Error('SDK not initialized. Call initialize() first.');
         }
         try {
-            const result = await sdk.users.getUserById(userId);
+            const result = await sdk.users.getUserById(userId, options);
             return result;
         }
         catch (error) {
@@ -39400,16 +41905,23 @@ const useUsers = () => {
             throw error;
         }
     }, [sdk, isInitialized]);
-    const toggleUserStatus = react.useCallback(async (user) => {
+    /**
+     * Toggle or set a user's active status (admin only)
+     *
+     * @param userId - User ID to update
+     * @param isActive - Optional explicit status. If omitted, toggles current status.
+     * @returns Updated user
+     */
+    const setUserActiveStatus = react.useCallback(async (userId, isActive) => {
         if (!isInitialized || !sdk) {
             throw new Error('SDK not initialized. Call initialize() first.');
         }
         try {
-            const result = await sdk.users.toggleUserStatus(user);
+            const result = await sdk.users.setUserActiveStatus(userId, isActive);
             return result;
         }
         catch (error) {
-            console.error('Failed to toggle user status:', error);
+            console.error('Failed to set user active status:', error);
             throw error;
         }
     }, [sdk, isInitialized]);
@@ -39420,7 +41932,7 @@ const useUsers = () => {
         getAllUsersPublic,
         getAllUsers,
         updateUser,
-        toggleUserStatus,
+        setUserActiveStatus,
         isAvailable: isInitialized && !!sdk?.users,
     };
 };
@@ -39968,23 +42480,35 @@ const useDonations = () => {
  * React Native hook for PERS SDK event system
  *
  * This hook provides access to the platform-agnostic event system for subscribing to
- * transaction, authentication, campaign, and system events. All events include a
- * `userMessage` field ready for display to end users.
+ * transaction, authentication, campaign, blockchain, and system events. All events
+ * include a `userMessage` field ready for display to end users.
  *
  * **Event Domains:**
  * - `auth` - Authentication events (login, logout, token refresh)
  * - `user` - User profile events (update, create)
- * - `transaction` - Transaction events (created, completed, failed)
+ * - `transaction` - Transaction events (created, submitted, confirmed)
  * - `campaign` - Campaign events (claimed, activated)
  * - `redemption` - Redemption events (redeemed, expired)
  * - `business` - Business events (created, updated, membership)
+ * - `wallet` - Real-time blockchain events (Transfer, Approval, etc.) - Auto-enabled on auth
  * - `api` - API error events (network, validation, server errors)
  *
+ * **Blockchain Events (Wallet Domain):**
+ * When `sdk.connectWalletEvents()` is called (or auto-enabled via `captureWalletEvents: true`),
+ * real-time blockchain events are automatically routed through the same event system:
+ * ```typescript
+ * const { subscribe } = useEvents();
+ *
+ * subscribe((event) => {
+ *   if (event.domain === 'wallet') {
+ *     console.log('Blockchain event:', event.type); // wallet_transfer, wallet_approval, etc.
+ *   }
+ * });
+ * ```
+ *
  * **Notification Levels:**
  * - `success` - Operation completed successfully
  * - `error` - Operation failed
- * - `warning` - Operation completed with warnings
- * - `info` - Informational event
  *
  * **Cleanup:**
  * All subscriptions created through this hook are automatically cleaned up when
@@ -40619,9 +43143,13 @@ function getMetadataFromTokenUnitResponse(tokenUnit, incrementalId) {
 exports.ANALYTICS_GROUP_BY_TYPES = ANALYTICS_GROUP_BY_TYPES;
 exports.ANALYTICS_METRIC_TYPES = ANALYTICS_METRIC_TYPES;
 exports.AsyncStorageTokenStorage = AsyncStorageTokenStorage;
+exports.AuditEntityTypes = AuditEntityTypes;
 exports.AuthenticationError = AuthenticationError;
+exports.ChainTypes = ChainTypes;
 exports.ClientTransactionType = ClientTransactionType;
 exports.Domains = Domains;
+exports.EntityTypes = EntityTypes;
+exports.ErrorDomains = ErrorDomains;
 exports.ErrorUtils = ErrorUtils;
 exports.MEMBERSHIP_ROLE_HIERARCHY = MEMBERSHIP_ROLE_HIERARCHY;
 exports.NativeTokenTypes = NativeTokenTypes;
@@ -40634,15 +43162,19 @@ exports.ReactNativeSecureStorage = ReactNativeSecureStorage;
 exports.SOURCE_LOGIC_TYPES = SOURCE_LOGIC_TYPES;
 exports.SOURCE_LOGIC_TYPE_VALUES = SOURCE_LOGIC_TYPE_VALUES;
 exports.SigningStatus = SigningStatus;
+exports.TOKEN_VALIDITY_TYPE_VALUES = TOKEN_VALIDITY_TYPE_VALUES;
 exports.TRANSACTION_FORMATS = TRANSACTION_FORMATS;
 exports.TRANSACTION_FORMAT_DESCRIPTIONS = TRANSACTION_FORMAT_DESCRIPTIONS;
 exports.TRIGGER_SOURCE_TYPES = TRIGGER_SOURCE_TYPES;
 exports.TRIGGER_SOURCE_TYPE_VALUES = TRIGGER_SOURCE_TYPE_VALUES;
+exports.TokenValidityTypes = TokenValidityTypes;
+exports.VALID_BUSINESS_MEMBERSHIP_RELATIONS = VALID_BUSINESS_MEMBERSHIP_RELATIONS;
 exports.VALID_CAMPAIGN_CLAIM_RELATIONS = VALID_CAMPAIGN_CLAIM_RELATIONS;
 exports.VALID_CAMPAIGN_RELATIONS = VALID_CAMPAIGN_RELATIONS;
 exports.VALID_REDEMPTION_REDEEM_RELATIONS = VALID_REDEMPTION_REDEEM_RELATIONS;
 exports.VALID_RELATIONS = VALID_RELATIONS;
 exports.VALID_TRANSACTION_RELATIONS = VALID_TRANSACTION_RELATIONS;
+exports.VALID_USER_RELATIONS = VALID_USER_RELATIONS;
 exports.apiPublicKeyTestPrefix = apiPublicKeyTestPrefix;
 exports.buildBurnRequest = buildBurnRequest;
 exports.buildMintRequest = buildMintRequest;
@@ -40662,13 +43194,22 @@ exports.fetchAllPages = fetchAllPages;
 exports.getMetadataFromTokenUnitResponse = getMetadataFromTokenUnitResponse;
 exports.hasMinimumRole = hasMinimumRole;
 exports.initializeReactNativePolyfills = initializeReactNativePolyfills;
+exports.isConnectedMessage = isConnectedMessage;
+exports.isErrorMessage = isErrorMessage;
+exports.isEventMessage = isEventMessage;
 exports.isPaginatedResponse = isPaginatedResponse;
+exports.isPingMessage = isPingMessage;
+exports.isServerMessage = isServerMessage;
+exports.isSubscribedMessage = isSubscribedMessage;
+exports.isUnsubscribedMessage = isUnsubscribedMessage;
 exports.isUserIdentifierObject = isUserIdentifierObject;
+exports.isValidBusinessMembershipRelation = isValidBusinessMembershipRelation;
 exports.isValidCampaignClaimRelation = isValidCampaignClaimRelation;
 exports.isValidCampaignRelation = isValidCampaignRelation;
 exports.isValidRedemptionRedeemRelation = isValidRedemptionRedeemRelation;
 exports.isValidRelation = isValidRelation;
 exports.isValidTransactionRelation = isValidTransactionRelation;
+exports.isValidUserRelation = isValidUserRelation;
 exports.normalizeToPaginated = normalizeToPaginated;
 exports.registerIdentifierType = registerIdentifierType;
 exports.testnetPrefix = testnetPrefix;