@explorins/pers-sdk 1.6.4 → 1.6.9

package/dist/index.cjs

@@ -1,36 +1,42 @@
 'use strict';
 
-var persSdk = require('./chunks/pers-sdk-DbPwFKrf.cjs');
-var web3 = require('./chunks/index-CzEluQmf.cjs');
+var persSdk = require('./chunks/pers-sdk-CmyPEhy7.cjs');
 var persShared = require('@explorins/pers-shared');
-var business = require('./business.cjs');
+var businessService = require('./chunks/business-service-Cq3-oksM.cjs');
 var transaction = require('./transaction.cjs');
-var analytics = require('./analytics.cjs');
-var campaign = require('./campaign.cjs');
-var donation = require('./donation.cjs');
-var payment = require('./payment.cjs');
-var redemption = require('./redemption.cjs');
-var tenant = require('./tenant.cjs');
-var tokenSdk = require('./chunks/token-sdk-CiAbOb6c.cjs');
-var baseTokenService = require('./chunks/base-token-service-zNfPjHRx.cjs');
-var user = require('./user.cjs');
+var analyticsService = require('./chunks/analytics-service-CitlimKJ.cjs');
+var campaignService = require('./chunks/campaign-service-CWK9I388.cjs');
+var donationService = require('./chunks/donation-service-D-xFrONi.cjs');
+var paymentService = require('./chunks/payment-service-B4qx0qiE.cjs');
+var redemptionService = require('./chunks/redemption-service-7qbeQxEM.cjs');
+var tenantService = require('./chunks/tenant-service-Ba7xrWED.cjs');
+var baseTokenService = require('./chunks/base-token-service-CYuqPPs0.cjs');
+var tokenService = require('./chunks/token-service-BWScn8Qa.cjs');
+var userService = require('./chunks/user-service-D1Rn4U8u.cjs');
 var userStatus = require('./user-status.cjs');
-var web3Chain = require('./chunks/index-BfOoX87y.cjs');
+var web3ChainService = require('./chunks/web3-chain-service-D75TcHkh.cjs');
+var index = require('./chunks/index-CMk3Aqkk.cjs');
+var explorer_utils = require('./chunks/explorer.utils-GpskbLl1.cjs');
 var platformAdapters = require('./platform-adapters.cjs');
 require('@explorins/web3-ts/ethers');
-require('jwt-decode');
 
 
 
 exports.AnalyticsManager = persSdk.AnalyticsManager;
+exports.AuthApi = persSdk.AuthApi;
 exports.AuthManager = persSdk.AuthManager;
+exports.AuthService = persSdk.AuthService;
+exports.AuthTokenManager = persSdk.AuthTokenManager;
 exports.BusinessManager = persSdk.BusinessManager;
 exports.CampaignManager = persSdk.CampaignManager;
 exports.DEFAULT_PERS_CONFIG = persSdk.DEFAULT_PERS_CONFIG;
+exports.DefaultAuthProvider = persSdk.DefaultAuthProvider;
 exports.DonationManager = persSdk.DonationManager;
 exports.FileApi = persSdk.FileApi;
 exports.FileManager = persSdk.FileManager;
 exports.FileService = persSdk.FileService;
+exports.LocalStorageTokenStorage = persSdk.LocalStorageTokenStorage;
+exports.MemoryTokenStorage = persSdk.MemoryTokenStorage;
 exports.PersApiClient = persSdk.PersApiClient;
 exports.PersSDK = persSdk.PersSDK;
 exports.PurchaseManager = persSdk.PurchaseManager;
@@ -42,65 +48,53 @@ exports.UserManager = persSdk.UserManager;
 exports.UserStatusManager = persSdk.UserStatusManager;
 exports.Web3Manager = persSdk.Web3Manager;
 exports.buildApiRoot = persSdk.buildApiRoot;
-exports.createAuthProvider = persSdk.createAuthProvider;
 exports.createFileSDK = persSdk.createFileSDK;
 exports.createPersSDK = persSdk.createPersSDK;
+exports.detectEnvironment = persSdk.detectEnvironment;
+exports.environment = persSdk.environment;
 exports.mergeWithDefaults = persSdk.mergeWithDefaults;
-exports.IPFSInfrastructureApi = web3.IPFSInfrastructureApi;
-exports.Web3ApplicationService = web3.Web3ApplicationService;
-exports.Web3InfrastructureApi = web3.Web3InfrastructureApi;
-exports.createWeb3SDK = web3.createWeb3SDK;
-exports.detectEnvironment = web3.detectEnvironment;
-exports.environment = web3.environment;
-exports.getExplorerUrl = web3.getExplorerUrl;
-exports.getExplorerUrlByChainId = web3.getExplorerUrlByChainId;
-exports.warnIfProblematicEnvironment = web3.warnIfProblematicEnvironment;
+exports.warnIfProblematicEnvironment = persSdk.warnIfProblematicEnvironment;
 Object.defineProperty(exports, "AccountOwnerType", {
 	enumerable: true,
 	get: function () { return persShared.AccountOwnerType; }
 });
-exports.BusinessApi = business.BusinessApi;
-exports.BusinessService = business.BusinessService;
-exports.createBusinessSDK = business.createBusinessSDK;
+exports.BusinessApi = businessService.BusinessApi;
+exports.BusinessService = businessService.BusinessService;
 Object.defineProperty(exports, "TransactionAccountType", {
 	enumerable: true,
 	get: function () { return transaction.TransactionAccountType; }
 });
 exports.TransactionApi = transaction.TransactionApi;
 exports.TransactionService = transaction.TransactionService;
-exports.createTransactionSDK = transaction.createTransactionSDK;
-exports.AnalyticsApi = analytics.AnalyticsApi;
-exports.AnalyticsService = analytics.AnalyticsService;
-exports.createAnalyticsSDK = analytics.createAnalyticsSDK;
-exports.CampaignApi = campaign.CampaignApi;
-exports.CampaignService = campaign.CampaignService;
-exports.createCampaignSDK = campaign.createCampaignSDK;
-exports.DonationApi = donation.DonationApi;
-exports.DonationService = donation.DonationService;
-exports.createDonationSDK = donation.createDonationSDK;
-exports.PaymentApi = payment.PaymentApi;
-exports.PaymentService = payment.PaymentService;
-exports.createPaymentSDK = payment.createPaymentSDK;
-exports.RedemptionApi = redemption.RedemptionApi;
-exports.RedemptionService = redemption.RedemptionService;
-exports.createRedemptionSDK = redemption.createRedemptionSDK;
-exports.TenantApi = tenant.TenantApi;
-exports.TenantService = tenant.TenantService;
-exports.createTenantSDK = tenant.createTenantSDK;
-exports.TokenApi = tokenSdk.TokenApi;
-exports.TokenSDK = tokenSdk.TokenSDK;
-exports.TokenService = tokenSdk.TokenService;
+exports.AnalyticsApi = analyticsService.AnalyticsApi;
+exports.AnalyticsService = analyticsService.AnalyticsService;
+exports.CampaignApi = campaignService.CampaignApi;
+exports.CampaignService = campaignService.CampaignService;
+exports.DonationApi = donationService.DonationApi;
+exports.DonationService = donationService.DonationService;
+exports.PaymentApi = paymentService.PurchaseApi;
+exports.PaymentService = paymentService.PaymentService;
+exports.RedemptionApi = redemptionService.RedemptionApi;
+exports.RedemptionService = redemptionService.RedemptionService;
+exports.TenantApi = tenantService.TenantApi;
+exports.TenantService = tenantService.TenantService;
 exports.BaseTokenService = baseTokenService.BaseTokenService;
-exports.UserApi = user.UserApi;
-exports.UserService = user.UserService;
-exports.createUserSDK = user.createUserSDK;
+exports.TokenSDK = baseTokenService.TokenSDK;
+exports.TokenApi = tokenService.TokenApi;
+exports.TokenService = tokenService.TokenService;
+exports.UserApi = userService.UserApi;
+exports.UserService = userService.UserService;
 exports.UserStatusApi = userStatus.UserStatusApi;
 exports.UserStatusService = userStatus.UserStatusService;
 exports.createUserStatusSDK = userStatus.createUserStatusSDK;
-exports.ChainTypes = web3Chain.ChainTypes;
-exports.Web3ChainApi = web3Chain.Web3ChainApi;
-exports.Web3ChainService = web3Chain.Web3ChainService;
-exports.createWeb3ChainSDK = web3Chain.createWeb3ChainSDK;
+exports.Web3ChainApi = web3ChainService.Web3ChainApi;
+exports.Web3ChainService = web3ChainService.Web3ChainService;
+exports.ChainTypes = index.ChainTypes;
+exports.IPFSInfrastructureApi = explorer_utils.IPFSInfrastructureApi;
+exports.Web3ApplicationService = explorer_utils.Web3ApplicationService;
+exports.Web3InfrastructureApi = explorer_utils.Web3InfrastructureApi;
+exports.getExplorerUrl = explorer_utils.getExplorerUrl;
+exports.getExplorerUrlByChainId = explorer_utils.getExplorerUrlByChainId;
 exports.AngularHttpClientAdapter = platformAdapters.AngularHttpClientAdapter;
 exports.BrowserFetchClientAdapter = platformAdapters.BrowserFetchClientAdapter;
 exports.NodeHttpClientAdapter = platformAdapters.NodeHttpClientAdapter;

package/dist/index.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"index.cjs","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}
+{"version":3,"file":"index.cjs","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}

package/dist/index.js

@@ -1,20 +1,20 @@
-export { i as AnalyticsManager, A as AuthManager, B as BusinessManager, C as CampaignManager, D as DEFAULT_PERS_CONFIG, j as DonationManager, k as FileApi, F as FileManager, l as FileService, b as PersApiClient, P as PersSDK, g as PurchaseManager, R as RedemptionManager, h as TenantManager, T as TokenManager, f as TransactionManager, U as UserManager, e as UserStatusManager, W as Web3Manager, d as buildApiRoot, a as createAuthProvider, n as createFileSDK, c as createPersSDK, m as mergeWithDefaults } from './chunks/pers-sdk-Z6MKeFBX.js';
-export { I as IPFSInfrastructureApi, W as Web3ApplicationService, a as Web3InfrastructureApi, c as createWeb3SDK, d as detectEnvironment, e as environment, g as getExplorerUrl, b as getExplorerUrlByChainId, w as warnIfProblematicEnvironment } from './chunks/index-CJ9Jfa4A.js';
+export { o as AnalyticsManager, g as AuthApi, i as AuthManager, h as AuthService, A as AuthTokenManager, B as BusinessManager, C as CampaignManager, b as DEFAULT_PERS_CONFIG, D as DefaultAuthProvider, p as DonationManager, q as FileApi, F as FileManager, r as FileService, L as LocalStorageTokenStorage, M as MemoryTokenStorage, a as PersApiClient, P as PersSDK, l as PurchaseManager, R as RedemptionManager, n as TenantManager, T as TokenManager, k as TransactionManager, U as UserManager, j as UserStatusManager, W as Web3Manager, d as buildApiRoot, s as createFileSDK, c as createPersSDK, e as detectEnvironment, f as environment, m as mergeWithDefaults, w as warnIfProblematicEnvironment } from './chunks/pers-sdk-Bd6BZHgt.js';
 export { AccountOwnerType } from '@explorins/pers-shared';
-export { BusinessApi, BusinessService, createBusinessSDK } from './business.js';
-export { TransactionAccountType, TransactionApi, TransactionService, createTransactionSDK } from './transaction.js';
-export { AnalyticsApi, AnalyticsService, createAnalyticsSDK } from './analytics.js';
-export { CampaignApi, CampaignService, createCampaignSDK } from './campaign.js';
-export { DonationApi, DonationService, createDonationSDK } from './donation.js';
-export { PaymentApi, PaymentService, createPaymentSDK } from './payment.js';
-export { RedemptionApi, RedemptionService, createRedemptionSDK } from './redemption.js';
-export { TenantApi, TenantService, createTenantSDK } from './tenant.js';
-export { a as TokenApi, T as TokenSDK, b as TokenService } from './chunks/token-sdk-BW4kkJb3.js';
-export { B as BaseTokenService } from './chunks/base-token-service-D0KANDgM.js';
-export { UserApi, UserService, createUserSDK } from './user.js';
+export { B as BusinessApi, a as BusinessService } from './chunks/business-service-DrC-TNGa.js';
+export { TransactionAccountType, TransactionApi, TransactionService } from './transaction.js';
+export { A as AnalyticsApi, a as AnalyticsService } from './chunks/analytics-service-CxyrOwel.js';
+export { C as CampaignApi, a as CampaignService } from './chunks/campaign-service-Dd7gMjC9.js';
+export { D as DonationApi, a as DonationService } from './chunks/donation-service-CyJS4DIZ.js';
+export { P as PaymentApi, a as PaymentService } from './chunks/payment-service-DfCBFosx.js';
+export { R as RedemptionApi, a as RedemptionService } from './chunks/redemption-service-BT0J5Iy7.js';
+export { T as TenantApi, a as TenantService } from './chunks/tenant-service-DELk412y.js';
+export { B as BaseTokenService, T as TokenSDK } from './chunks/base-token-service-BSXDwrcq.js';
+export { T as TokenApi, a as TokenService } from './chunks/token-service-CpVwC5Eb.js';
+export { U as UserApi, a as UserService } from './chunks/user-service-D6mTa_WZ.js';
 export { UserStatusApi, UserStatusService, createUserStatusSDK } from './user-status.js';
-export { C as ChainTypes, W as Web3ChainApi, a as Web3ChainService, c as createWeb3ChainSDK } from './chunks/index-CM21r58m.js';
+export { W as Web3ChainApi, a as Web3ChainService } from './chunks/web3-chain-service-Dp5Z8p9I.js';
+export { C as ChainTypes } from './chunks/index-BtDNXaFq.js';
+export { I as IPFSInfrastructureApi, W as Web3ApplicationService, a as Web3InfrastructureApi, g as getExplorerUrl, b as getExplorerUrlByChainId } from './chunks/explorer.utils-Ckll15ja.js';
 export { AngularHttpClientAdapter, BrowserFetchClientAdapter, NodeHttpClientAdapter } from './platform-adapters.js';
 import '@explorins/web3-ts/ethers';
-import 'jwt-decode';
 //# sourceMappingURL=index.js.map

package/dist/managers/analytics-manager.d.ts

@@ -1,28 +1,308 @@
 import { PersApiClient } from '../core/pers-api-client';
-import { AnalyticsSDK } from '../analytics';
+import { AnalyticsService } from '../analytics';
 import type { TransactionAnalyticsRequestDTO } from '../analytics/models';
 /**
  * Analytics Manager - Clean, high-level interface for analytics operations
  *
- * Provides a simplified API for common analytics tasks while maintaining
- * access to the full analytics SDK for advanced use cases.
+ * Provides comprehensive analytics and business intelligence capabilities for the
+ * loyalty ecosystem including transaction analysis, user behavior tracking, campaign
+ * performance metrics, and business insights. Enables data-driven decision making
+ * with real-time and historical analytics across all system domains.
+ *
+ * @group Managers
+ * @category Analytics & Reporting
+ *
+ * @example Basic Transaction Analytics
+ * ```typescript
+ * // Get transaction analytics for the last 30 days
+ * const analytics = await sdk.analytics.getTransactionAnalytics({
+ *   startDate: '2024-01-01',
+ *   endDate: '2024-01-31',
+ *   groupBy: 'day',
+ *   metrics: ['volume', 'count', 'averageValue']
+ * });
+ *
+ * console.log('Transaction Trends:');
+ * console.log(`Total Volume: $${analytics.totalVolume}`);
+ * console.log(`Total Transactions: ${analytics.totalCount}`);
+ * console.log(`Average Transaction: $${analytics.averageValue}`);
+ * ```
+ *
+ * @example Business Performance Analysis
+ * ```typescript
+ * // Analyze performance by business partner
+ * const businessAnalytics = await sdk.analytics.getTransactionAnalytics({
+ *   startDate: '2024-01-01',
+ *   endDate: '2024-12-31',
+ *   groupBy: 'business',
+ *   includeDetails: true
+ * });
+ *
+ * console.log('Top Performing Partners:');
+ * businessAnalytics.businessBreakdown?.forEach((business, index) => {
+ *   console.log(`${index + 1}. ${business.name}`);
+ *   console.log(`   Volume: $${business.volume}`);
+ *   console.log(`   Transactions: ${business.count}`);
+ * });
+ * ```
+ *
+ * @example Advanced Analytics
+ * ```typescript
+ * // Get comprehensive analytics dashboard data
+ * const analyticsService = sdk.analytics.getAnalyticsService();
+ *
+ * // Get multiple analytics in parallel
+ * const [userMetrics, campaignMetrics, tokenMetrics] = await Promise.all([
+ *   analyticsService.getUserEngagementMetrics(),
+ *   analyticsService.getCampaignPerformance(),
+ *   analyticsService.getTokenDistributionAnalytics()
+ * ]);
+ * ```
  */
 export declare class AnalyticsManager {
     private apiClient;
-    private analyticsSDK;
+    private analyticsService;
     constructor(apiClient: PersApiClient);
     /**
      * Get transaction analytics
      *
-     * @param request - Analytics request parameters
-     * @returns Promise resolving to transaction analytics data
+     * Retrieves comprehensive transaction analytics with flexible filtering,
+     * grouping, and metric selection. Provides insights into transaction volumes,
+     * trends, business performance, and user behavior patterns across the
+     * loyalty ecosystem.
+     *
+     * @param request - Analytics request parameters including date range, filters, and metrics
+     * @returns Promise resolving to transaction analytics data with metrics and breakdowns
+     * @throws {PersApiError} When analytics data is unavailable or parameters are invalid
+     *
+     * @example Volume and Trend Analysis
+     * ```typescript
+     * try {
+     *   const analytics = await sdk.analytics.getTransactionAnalytics({
+     *     startDate: '2024-01-01T00:00:00Z',
+     *     endDate: '2024-01-31T23:59:59Z',
+     *     groupBy: 'day',
+     *     metrics: ['volume', 'count', 'averageValue', 'tokens'],
+     *     includeComparisons: true  // Compare with previous period
+     *   });
+     *
+     *   console.log('📊 Transaction Analytics Summary:');
+     *   console.log(`Total Volume: $${analytics.totalVolume.toLocaleString()}`);
+     *   console.log(`Total Transactions: ${analytics.totalCount.toLocaleString()}`);
+     *   console.log(`Average Transaction: $${analytics.averageValue.toFixed(2)}`);
+     *   console.log(`Tokens Distributed: ${analytics.totalTokens.toLocaleString()}`);
+     *
+     *   if (analytics.periodComparison) {
+     *     const volumeChange = analytics.periodComparison.volumeChangePercent;
+     *     const countChange = analytics.periodComparison.countChangePercent;
+     *
+     *     console.log('\n📈 Period-over-Period Changes:');
+     *     console.log(`Volume: ${volumeChange > 0 ? '+' : ''}${volumeChange}%`);
+     *     console.log(`Count: ${countChange > 0 ? '+' : ''}${countChange}%`);
+     *   }
+     *
+     *   // Display daily trend data
+     *   if (analytics.dailyBreakdown) {
+     *     console.log('\n📅 Daily Trends:');
+     *     analytics.dailyBreakdown.forEach(day => {
+     *       console.log(`${day.date}: $${day.volume} (${day.count} transactions)`);
+     *     });
+     *   }
+     *
+     * } catch (error) {
+     *   console.log('Analytics retrieval failed:', error.message);
+     * }
+     * ```
+     *
+     * @example Business Partner Analysis
+     * ```typescript
+     * // Analyze transaction performance by business partner
+     * const businessAnalytics = await sdk.analytics.getTransactionAnalytics({
+     *   startDate: '2024-01-01',
+     *   endDate: '2024-03-31',
+     *   groupBy: 'business',
+     *   metrics: ['volume', 'count', 'averageValue', 'customerCount'],
+     *   includeDetails: true,
+     *   minimumTransactionCount: 10  // Only include businesses with 10+ transactions
+     * });
+     *
+     * console.log('🏢 Business Partner Performance:');
+     *
+     * if (businessAnalytics.businessBreakdown) {
+     *   // Sort by volume descending
+     *   const sortedBusinesses = businessAnalytics.businessBreakdown
+     *     .sort((a, b) => b.volume - a.volume);
+     *
+     *   console.log('\nTop 10 Partners by Volume:');
+     *   sortedBusinesses.slice(0, 10).forEach((business, index) => {
+     *     console.log(`\n${index + 1}. ${business.name}`);
+     *     console.log(`   Volume: $${business.volume.toLocaleString()}`);
+     *     console.log(`   Transactions: ${business.count}`);
+     *     console.log(`   Avg Transaction: $${business.averageValue.toFixed(2)}`);
+     *     console.log(`   Unique Customers: ${business.customerCount}`);
+     *     console.log(`   Customer LTV: $${(business.volume / business.customerCount).toFixed(2)}`);
+     *   });
+     *
+     *   // Identify growth opportunities
+     *   const lowVolumeHighFrequency = sortedBusinesses.filter(b =>
+     *     b.count > 50 && b.averageValue < 25
+     *   );
+     *
+     *   if (lowVolumeHighFrequency.length > 0) {
+     *     console.log('\n💡 Growth Opportunities (High Frequency, Low Value):');
+     *     lowVolumeHighFrequency.forEach(business => {
+     *       console.log(`${business.name}: ${business.count} transactions, $${business.averageValue} avg`);
+     *     });
+     *   }
+     * }
+     * ```
+     *
+     * @example Seasonal and Trend Analysis
+     * ```typescript
+     * // Analyze seasonal patterns and trends
+     * const seasonalAnalytics = await sdk.analytics.getTransactionAnalytics({
+     *   startDate: '2023-01-01',
+     *   endDate: '2024-12-31',
+     *   groupBy: 'month',
+     *   metrics: ['volume', 'count'],
+     *   includeSeasonalAnalysis: true,
+     *   includeTrendLine: true
+     * });
+     *
+     * console.log('📈 Seasonal Analysis:');
+     *
+     * if (seasonalAnalytics.monthlyBreakdown) {
+     *   const monthlyData = seasonalAnalytics.monthlyBreakdown;
+     *
+     *   // Find peak months
+     *   const peakVolumeMonth = monthlyData.reduce((max, current) =>
+     *     current.volume > max.volume ? current : max
+     *   );
+     *
+     *   const peakCountMonth = monthlyData.reduce((max, current) =>
+     *     current.count > max.count ? current : max
+     *   );
+     *
+     *   console.log(`Peak Volume Month: ${peakVolumeMonth.month} ($${peakVolumeMonth.volume})`);
+     *   console.log(`Peak Transaction Month: ${peakCountMonth.month} (${peakCountMonth.count})`);
+     *
+     *   // Calculate quarterly performance
+     *   const quarters = {
+     *     Q1: monthlyData.slice(0, 3).reduce((sum, m) => sum + m.volume, 0),
+     *     Q2: monthlyData.slice(3, 6).reduce((sum, m) => sum + m.volume, 0),
+     *     Q3: monthlyData.slice(6, 9).reduce((sum, m) => sum + m.volume, 0),
+     *     Q4: monthlyData.slice(9, 12).reduce((sum, m) => sum + m.volume, 0)
+     *   };
+     *
+     *   console.log('\n📊 Quarterly Performance:');
+     *   Object.entries(quarters).forEach(([quarter, volume]) => {
+     *     console.log(`${quarter}: $${volume.toLocaleString()}`);
+     *   });
+     * }
+     *
+     * if (seasonalAnalytics.trendAnalysis) {
+     *   console.log('\n📈 Trend Analysis:');
+     *   console.log(`Growth Rate: ${seasonalAnalytics.trendAnalysis.growthRate}%/month`);
+     *   console.log(`Trend Direction: ${seasonalAnalytics.trendAnalysis.direction}`);
+     *   console.log(`Seasonality Score: ${seasonalAnalytics.trendAnalysis.seasonalityScore}`);
+     * }
+     * ```
+     *
+     * @example Real-time Dashboard Metrics
+     * ```typescript
+     * // Get real-time metrics for dashboard display
+     * const realTimeMetrics = await sdk.analytics.getTransactionAnalytics({
+     *   startDate: new Date(Date.now() - 24 * 60 * 60 * 1000).toISOString(), // Last 24 hours
+     *   endDate: new Date().toISOString(),
+     *   groupBy: 'hour',
+     *   metrics: ['volume', 'count', 'tokens'],
+     *   includeRealTimeMetrics: true
+     * });
+     *
+     * console.log('⚡ Real-time Metrics (Last 24 Hours):');
+     * console.log(`Current Volume: $${realTimeMetrics.totalVolume}`);
+     * console.log(`Active Users: ${realTimeMetrics.activeUserCount}`);
+     * console.log(`Transactions/Hour: ${realTimeMetrics.transactionsPerHour}`);
+     *
+     * if (realTimeMetrics.hourlyBreakdown) {
+     *   // Show last 6 hours
+     *   const lastSixHours = realTimeMetrics.hourlyBreakdown.slice(-6);
+     *   console.log('\n🕐 Last 6 Hours:');
+     *   lastSixHours.forEach(hour => {
+     *     console.log(`${hour.hour}:00 - $${hour.volume} (${hour.count} txns)`);
+     *   });
+     * }
+     *
+     * // Update dashboard in real-time
+     * const updateDashboard = () => {
+     *   document.getElementById('totalVolume').textContent = `$${realTimeMetrics.totalVolume}`;
+     *   document.getElementById('transactionCount').textContent = realTimeMetrics.totalCount;
+     *   document.getElementById('activeUsers').textContent = realTimeMetrics.activeUserCount;
+     * };
+     *
+     * updateDashboard();
+     * ```
      */
-    getTransactionAnalytics(request: TransactionAnalyticsRequestDTO): Promise<import("..").TransactionAnalyticsResponseDTO>;
+    getTransactionAnalytics(request: TransactionAnalyticsRequestDTO): Promise<import("../analytics").TransactionAnalyticsResponseDTO>;
     /**
-     * Get the full analytics SDK for advanced operations
+     * Get the full analytics service for advanced operations
+     *
+     * Provides access to the complete AnalyticsService instance for advanced analytics
+     * operations, custom metrics, predictive analytics, cohort analysis, and
+     * operations not covered by the high-level manager methods.
+     *
+     * @returns AnalyticsService instance with full API access
+     *
+     * @example Advanced Analytics Operations
+     * ```typescript
+     * const analyticsService = sdk.analytics.getAnalyticsService();
+     *
+     * // Access user engagement analytics
+     * const engagementMetrics = await analyticsService.getUserEngagementMetrics({
+     *   timeframe: 'last-90-days',
+     *   includeSegmentation: true
+     * });
+     *
+     * // Access campaign performance analytics
+     * const campaignMetrics = await analyticsService.getCampaignPerformance({
+     *   campaignIds: ['summer-2024', 'holiday-2024'],
+     *   includeConversionFunnel: true
+     * });
+     *
+     * // Access token distribution analytics
+     * const tokenAnalytics = await analyticsService.getTokenDistributionAnalytics({
+     *   tokenTypes: ['CREDIT', 'REWARD'],
+     *   includePredictions: true
+     * });
+     *
+     * // Access cohort analysis
+     * const cohorts = await analyticsService.getCohortAnalysis({
+     *     cohortType: 'monthly',
+     *     startDate: '2024-01-01',
+     *     metrics: ['retention', 'revenue', 'activity']
+     * });
+     *
+     * // Access predictive analytics
+     * const predictions = await analyticsService.getPredictiveAnalytics({
+     *   model: 'customer-lifetime-value',
+     *   horizon: '12-months'
+     * });
+     *
+     * // Access real-time streaming analytics
+     * const realTimeStream = analyticsService.getRealtimeMetrics();
+     * realTimeStream.on('update', (metrics) => {
+     *   console.log('Real-time update:', metrics);
+     * });
+     *
+     * // Access custom analytics queries
+     * const customAnalytics = await analyticsService.executeCustomQuery({
+     *   query: 'business-performance-by-region',
+     *   parameters: { region: 'north-america', timeframe: 'Q1-2024' }
+     * });
      *
-     * @returns AnalyticsSDK instance
+     * console.log('Advanced analytics data retrieved');
+     * ```
      */
-    getAnalyticsSDK(): AnalyticsSDK;
+    getAnalyticsService(): AnalyticsService;
 }
 //# sourceMappingURL=analytics-manager.d.ts.map

package/dist/managers/analytics-manager.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"analytics-manager.d.ts","sourceRoot":"","sources":["../../src/managers/analytics-manager.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,aAAa,EAAE,MAAM,yBAAyB,CAAC;AACxD,OAAO,EAAsB,YAAY,EAAE,MAAM,cAAc,CAAC;AAChE,OAAO,KAAK,EAAE,8BAA8B,EAAE,MAAM,qBAAqB,CAAC;AAE1E;;;;;GAKG;AACH,qBAAa,gBAAgB;IAGf,OAAO,CAAC,SAAS;IAF7B,OAAO,CAAC,YAAY,CAAe;gBAEf,SAAS,EAAE,aAAa;IAI5C;;;;;OAKG;IACG,uBAAuB,CAAC,OAAO,EAAE,8BAA8B;IAIrE;;;;OAIG;IACH,eAAe,IAAI,YAAY;CAGhC"}
+{"version":3,"file":"analytics-manager.d.ts","sourceRoot":"","sources":["../../src/managers/analytics-manager.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,aAAa,EAAE,MAAM,yBAAyB,CAAC;AACxD,OAAO,EAAgB,gBAAgB,EAAE,MAAM,cAAc,CAAC;AAC9D,OAAO,KAAK,EAAE,8BAA8B,EAAE,MAAM,qBAAqB,CAAC;AAE1E;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAyDG;AACH,qBAAa,gBAAgB;IAGf,OAAO,CAAC,SAAS;IAF7B,OAAO,CAAC,gBAAgB,CAAmB;gBAEvB,SAAS,EAAE,aAAa;IAK5C;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OAmLG;IACG,uBAAuB,CAAC,OAAO,EAAE,8BAA8B;IAIrE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OA0DG;IACH,mBAAmB,IAAI,gBAAgB;CAGxC"}