@explorins/pers-sdk-react-native 1.5.35 → 2.0.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@explorins/pers-sdk-react-native",
-  "version": "1.5.35",
+  "version": "2.0.0",
   "description": "React Native SDK for PERS Platform - Tourism Loyalty System with Blockchain Transaction Signing and WebAuthn Authentication",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
@@ -37,8 +37,8 @@
   "author": "eXplorins",
   "license": "MIT",
   "dependencies": {
-    "@explorins/pers-sdk": "^1.6.42",
-    "@explorins/pers-shared": "^2.1.54",
+    "@explorins/pers-sdk": "^2.0.0",
+    "@explorins/pers-shared": "^2.1.64",
     "@explorins/pers-signer": "^1.0.33",
     "@explorins/web3-ts": "^0.3.77",
     "buffer": "^6.0.3",

package/src/hooks/index.ts

@@ -14,6 +14,7 @@ export { useUserStatus } from './useUserStatus';
 export { useFiles } from './useFiles';
 export { useAnalytics } from './useAnalytics';
 export { useDonations } from './useDonations';
+export { useEvents } from './useEvents';
 
 // Re-export auth-related types for convenience
 export type { RawUserData } from './useAuth';
@@ -26,4 +27,5 @@ export type {
   OnStatusUpdateFn,
   SigningStatus as SigningStatusType
 } from './useTransactionSigner';
-export type { UserOwnedTokensResult, Web3Hook } from './useWeb3';
+export type { AccountOwnedTokensResult, Web3Hook } from './useWeb3';
+export type { EventsHook, PersEvent, EventHandler, EventFilter, Unsubscribe } from './useEvents';

package/src/hooks/useBusiness.ts

@@ -1,6 +1,6 @@
 import { useCallback } from 'react';
 import { usePersSDK } from '../providers/PersSDKProvider';
-import type { BusinessDTO, BusinessTypeDTO, BusinessUpdateRequestDTO, BusinessToggleActiveRequestDTO } from '@explorins/pers-shared';
+import type { BusinessDTO, BusinessTypeDTO, BusinessUpdateRequestDTO, BusinessToggleActiveRequestDTO, PaginatedResponseDTO } from '@explorins/pers-shared';
 
 /**
  * React hook for business operations in the PERS SDK
@@ -52,7 +52,7 @@ export const useBusiness = () => {
    * console.log('Active businesses:', businesses);
    * ```
    */
-  const getActiveBusinesses = useCallback(async (): Promise<BusinessDTO[]> => {
+  const getActiveBusinesses = useCallback(async (): Promise<PaginatedResponseDTO<BusinessDTO>> => {
     if (!isInitialized || !sdk) {
       throw new Error('SDK not initialized. Call initialize() first.');
     }
@@ -79,7 +79,7 @@ export const useBusiness = () => {
    * console.log('Business types:', types);
    * ```
    */
-  const getBusinessTypes = useCallback(async (): Promise<BusinessTypeDTO[]> => {
+  const getBusinessTypes = useCallback(async (): Promise<PaginatedResponseDTO<BusinessTypeDTO>> => {
     if (!isInitialized || !sdk) {
       throw new Error('SDK not initialized. Call initialize() first.');
     }
@@ -107,7 +107,7 @@ export const useBusiness = () => {
     }
   }, [sdk, isInitialized]);
 
-  const getBusinesses = useCallback(async (): Promise<BusinessDTO[]> => {
+  const getBusinesses = useCallback(async (): Promise<PaginatedResponseDTO<BusinessDTO>> => {
     if (!isInitialized || !sdk) {
       throw new Error('SDK not initialized. Call initialize() first.');
     }
@@ -135,7 +135,7 @@ export const useBusiness = () => {
     }
   }, [sdk, isInitialized]);
 
-  const getBusinessesByType = useCallback(async (typeId: string): Promise<BusinessDTO[]> => {
+  const getBusinessesByType = useCallback(async (typeId: string): Promise<PaginatedResponseDTO<BusinessDTO>> => {
     if (!isInitialized || !sdk) {
       throw new Error('SDK not initialized. Call initialize() first.');
     }

package/src/hooks/useCampaigns.ts

@@ -7,19 +7,20 @@ import type {
   CampaignTriggerDTO,
   CampaignCreateRequestDTO,
   TokenUnitCreateRequestDTO,
-  CampaignBusinessEngagementCreateRequestDTO 
+  CampaignBusinessEngagementCreateRequestDTO,
+  PaginatedResponseDTO
 } from '@explorins/pers-shared';
 
 export const useCampaigns = () => {
   const { sdk, isInitialized, isAuthenticated } = usePersSDK();
 
-  const getActiveCampaigns = useCallback(async (): Promise<CampaignDTO[]> => {
+  const getActiveCampaigns = useCallback(async (): Promise<PaginatedResponseDTO<CampaignDTO>> => {
     if (!isInitialized || !sdk) {
       throw new Error('SDK not initialized. Call initialize() first.');
     }
     
     try {
-      const result = await sdk.campaigns.getActiveCampaigns();
+      const result = await sdk.campaigns.getCampaigns({ active: true });
       return result;
     } catch (error) {
       console.error('Failed to fetch active campaigns:', error);
@@ -58,13 +59,13 @@ export const useCampaigns = () => {
     }
   }, [sdk, isInitialized, isAuthenticated]);
 
-  const getUserClaims = useCallback(async (): Promise<CampaignClaimDTO[]> => {
+  const getUserClaims = useCallback(async (): Promise<PaginatedResponseDTO<CampaignClaimDTO>> => {
     if (!isInitialized || !sdk) {
       throw new Error('SDK not initialized. Call initialize() first.');
     }
     if (!isAuthenticated) {
       console.warn('SDK not authenticated. getUserClaims requires authentication.');
-      return [];
+      return { data: [], pagination: { page: 1, limit: 0, total: 0, pages: 0, hasNext: false, hasPrev: false } };
     }
     
     try {
@@ -76,7 +77,7 @@ export const useCampaigns = () => {
     }
   }, [sdk, isInitialized, isAuthenticated]);
 
-  const getCampaignTriggers = useCallback(async (): Promise<CampaignTriggerDTO[]> => {
+  const getCampaignTriggers = useCallback(async (): Promise<PaginatedResponseDTO<CampaignTriggerDTO>> => {
     if (!isInitialized || !sdk) {
       throw new Error('SDK not initialized. Call initialize() first.');
     }
@@ -91,13 +92,13 @@ export const useCampaigns = () => {
   }, [sdk, isInitialized]);
 
   // Admin methods
-  const getAllCampaigns = useCallback(async (active?: boolean): Promise<CampaignDTO[]> => {
+  const getAllCampaigns = useCallback(async (active?: boolean): Promise<PaginatedResponseDTO<CampaignDTO>> => {
     if (!isInitialized || !sdk) {
       throw new Error('SDK not initialized. Call initialize() first.');
     }
     
     try {
-      const result = await sdk.campaigns.getAllCampaigns(active);
+      const result = await sdk.campaigns.getCampaigns({ active });
       return result;
     } catch (error) {
       console.error('Failed to fetch all campaigns:', error);
@@ -105,7 +106,7 @@ export const useCampaigns = () => {
     }
   }, [sdk, isInitialized]);
 
-  const getCampaignClaims = useCallback(async (): Promise<CampaignClaimDTO[]> => {
+  const getCampaignClaims = useCallback(async (): Promise<PaginatedResponseDTO<CampaignClaimDTO>> => {
     if (!isInitialized || !sdk) {
       throw new Error('SDK not initialized. Call initialize() first.');
     }
@@ -119,7 +120,7 @@ export const useCampaigns = () => {
     }
   }, [sdk, isInitialized]);
 
-  const getCampaignClaimsByUserId = useCallback(async (userId: string): Promise<CampaignClaimDTO[]> => {
+  const getCampaignClaimsByUserId = useCallback(async (userId: string): Promise<PaginatedResponseDTO<CampaignClaimDTO>> => {
     if (!isInitialized || !sdk) {
       throw new Error('SDK not initialized. Call initialize() first.');
     }
@@ -133,7 +134,7 @@ export const useCampaigns = () => {
     }
   }, [sdk, isInitialized]);
 
-  const getCampaignClaimsByBusinessId = useCallback(async (businessId: string): Promise<CampaignClaimDTO[]> => {
+  const getCampaignClaimsByBusinessId = useCallback(async (businessId: string): Promise<PaginatedResponseDTO<CampaignClaimDTO>> => {
     if (!isInitialized || !sdk) {
       throw new Error('SDK not initialized. Call initialize() first.');
     }

package/src/hooks/useDonations.ts

@@ -1,6 +1,6 @@
 import { useCallback } from 'react';
 import { usePersSDK } from '../providers/PersSDKProvider';
-import type { DonationTypeDTO } from '@explorins/pers-shared';
+import type { DonationTypeDTO, PaginatedResponseDTO } from '@explorins/pers-shared';
 
 /**
  * React hook for donation operations in the PERS SDK
@@ -44,7 +44,7 @@ export const useDonations = () => {
    * console.log('Donation types:', types.map(t => t.name));
    * ```
    */
-  const getDonationTypes = useCallback(async (): Promise<DonationTypeDTO[]> => {
+  const getDonationTypes = useCallback(async (): Promise<PaginatedResponseDTO<DonationTypeDTO>> => {
     if (!isInitialized || !sdk) {
       throw new Error('SDK not initialized. Call initialize() first.');
     }

package/src/hooks/useEvents.ts

@@ -0,0 +1,360 @@
+import { useCallback, useEffect, useRef } from 'react';
+import { usePersSDK } from '../providers/PersSDKProvider';
+import type { 
+  PersEvent, 
+  EventHandler, 
+  EventFilter,
+  Unsubscribe 
+} from '@explorins/pers-sdk/core';
+
+// Re-export event types for convenience
+export type { PersEvent, EventHandler, EventFilter, Unsubscribe };
+
+/**
+ * Return interface for the useEvents hook
+ * 
+ * Provides event subscription capabilities for the PERS SDK event system.
+ * Use this to display notifications, update UI, or trigger side effects.
+ * 
+ * @interface EventsHook
+ * @property {Function} subscribe - Subscribe to SDK events with optional filtering
+ * @property {Function} once - Subscribe to a single event (auto-unsubscribes)
+ * @property {Function} clear - Clear all subscriptions
+ * @property {boolean} isAvailable - Whether the event system is available
+ * @property {number} subscriberCount - Current number of active subscribers
+ */
+export interface EventsHook {
+  subscribe: (handler: EventHandler, filter?: EventFilter) => Unsubscribe;
+  once: (handler: EventHandler, filter?: EventFilter) => Unsubscribe;
+  clear: () => void;
+  isAvailable: boolean;
+  subscriberCount: number;
+}
+
+/**
+ * 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.
+ * 
+ * **Event Domains:**
+ * - `auth` - Authentication events (login, logout, token refresh)
+ * - `user` - User profile events (update, create)
+ * - `transaction` - Transaction events (created, completed, failed)
+ * - `campaign` - Campaign events (claimed, activated)
+ * - `redemption` - Redemption events (redeemed, expired)
+ * - `business` - Business events (created, updated, membership)
+ * - `api` - API error events (network, validation, server errors)
+ * 
+ * **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
+ * the component unmounts, preventing memory leaks and stale event handlers.
+ * 
+ * @returns {EventsHook} Hook interface with event subscription methods
+ * 
+ * @example
+ * **Basic Usage - Show All Notifications**
+ * ```typescript
+ * import { useEvents } from '@explorins/pers-sdk-react-native';
+ * 
+ * function NotificationComponent() {
+ *   const { subscribe, isAvailable } = useEvents();
+ *   
+ *   useEffect(() => {
+ *     if (!isAvailable) return;
+ *     
+ *     const unsubscribe = subscribe((event) => {
+ *       // userMessage is always present and UI-ready
+ *       showNotification(event.userMessage, event.level);
+ *     });
+ *     
+ *     return () => unsubscribe();
+ *   }, [subscribe, isAvailable]);
+ *   
+ *   return <View />;
+ * }
+ * ```
+ * 
+ * @example
+ * **Filter by Domain and Level**
+ * ```typescript
+ * function TransactionListener() {
+ *   const { subscribe, isAvailable } = useEvents();
+ *   
+ *   useEffect(() => {
+ *     if (!isAvailable) return;
+ *     
+ *     // Only listen to successful transactions
+ *     const unsubscribe = subscribe(
+ *       (event) => {
+ *         if (event.level === 'success') {
+ *           playSuccessSound();
+ *           showConfetti();
+ *         }
+ *       },
+ *       { domain: 'transaction' }  // Filter
+ *     );
+ *     
+ *     return () => unsubscribe();
+ *   }, [subscribe, isAvailable]);
+ * }
+ * ```
+ * 
+ * @example
+ * **Filter Errors for Logging**
+ * ```typescript
+ * function ErrorLogger() {
+ *   const { subscribe, isAvailable } = useEvents();
+ *   
+ *   useEffect(() => {
+ *     if (!isAvailable) return;
+ *     
+ *     const unsubscribe = subscribe(
+ *       (event) => {
+ *         // Log errors to crash reporting
+ *         logToSentry({
+ *           message: event.userMessage,
+ *           domain: event.domain,
+ *           type: event.type,
+ *         });
+ *       },
+ *       { level: 'error' }  // Only errors
+ *     );
+ *     
+ *     return () => unsubscribe();
+ *   }, [subscribe, isAvailable]);
+ * }
+ * ```
+ * 
+ * @example
+ * **One-time Event**
+ * ```typescript
+ * function FirstTransactionHandler() {
+ *   const { once, isAvailable } = useEvents();
+ *   
+ *   useEffect(() => {
+ *     if (!isAvailable) return;
+ *     
+ *     // Auto-unsubscribe after first transaction event
+ *     const unsubscribe = once(
+ *       (event) => {
+ *         console.log('First transaction event:', event.type);
+ *         showOnboardingComplete();
+ *       },
+ *       { domain: 'transaction', level: 'success' }
+ *     );
+ *     
+ *     return () => unsubscribe();
+ *   }, [once, isAvailable]);
+ * }
+ * ```
+ * 
+ * @example
+ * **Combined Domain and Level Filter**
+ * ```typescript
+ * function AuthErrorHandler() {
+ *   const { subscribe, isAvailable } = useEvents();
+ *   
+ *   useEffect(() => {
+ *     if (!isAvailable) return;
+ *     
+ *     const unsubscribe = subscribe(
+ *       (event) => {
+ *         Alert.alert('Authentication Error', event.userMessage);
+ *         navigation.navigate('Login');
+ *       },
+ *       { domain: 'auth', level: 'error' }
+ *     );
+ *     
+ *     return () => unsubscribe();
+ *   }, [subscribe, isAvailable]);
+ * }
+ * ```
+ * 
+ * @see {@link PersEvent} for event structure
+ * @see {@link EventFilter} for filtering options
+ * @see {@link EventHandler} for handler function type
+ * 
+ * @since 1.6.49
+ */
+export const useEvents = (): EventsHook => {
+  const { sdk, isInitialized } = usePersSDK();
+  
+  // Track subscriptions for cleanup
+  const subscriptionsRef = useRef<Unsubscribe[]>([]);
+  
+  // Cleanup all subscriptions on unmount
+  useEffect(() => {
+    return () => {
+      subscriptionsRef.current.forEach(unsubscribe => {
+        try {
+          unsubscribe();
+        } catch (e) {
+          // Ignore cleanup errors
+        }
+      });
+      subscriptionsRef.current = [];
+    };
+  }, []);
+
+  /**
+   * Subscribe to SDK events with optional filtering
+   * 
+   * Creates a subscription that will be called for every matching event.
+   * The subscription is automatically tracked for cleanup when the component unmounts.
+   * 
+   * @param handler - Callback function invoked for each matching event
+   * @param filter - Optional filter to limit events (by domain, level, or both)
+   * @returns Unsubscribe function to manually cancel the subscription
+   * 
+   * @example
+   * ```typescript
+   * const unsubscribe = subscribe((event) => {
+   *   console.log('Event:', event.type, event.userMessage);
+   * });
+   * 
+   * // Later: manual cleanup
+   * unsubscribe();
+   * ```
+   */
+  const subscribe = useCallback((handler: EventHandler, filter?: EventFilter): Unsubscribe => {
+    if (!isInitialized || !sdk) {
+      console.warn('[useEvents] SDK not initialized. Cannot subscribe to events.');
+      return () => {}; // Return no-op unsubscribe
+    }
+    
+    const unsubscribe = sdk.events.subscribe(handler, filter);
+    
+    // Track for cleanup
+    subscriptionsRef.current.push(unsubscribe);
+    
+    // Return wrapped unsubscribe that also removes from tracking
+    return () => {
+      unsubscribe();
+      const index = subscriptionsRef.current.indexOf(unsubscribe);
+      if (index > -1) {
+        subscriptionsRef.current.splice(index, 1);
+      }
+    };
+  }, [sdk, isInitialized]);
+
+  /**
+   * Subscribe to a single event (auto-unsubscribes after first match)
+   * 
+   * Useful for one-time event handling, like waiting for a specific action to complete.
+   * 
+   * @param handler - Callback function invoked for the first matching event
+   * @param filter - Optional filter to limit events (by domain, level, or both)
+   * @returns Unsubscribe function to manually cancel before event fires
+   * 
+   * @example
+   * ```typescript
+   * once((event) => {
+   *   console.log('First event:', event.type);
+   * }, { domain: 'transaction', level: 'success' });
+   * ```
+   */
+  const once = useCallback((handler: EventHandler, filter?: EventFilter): Unsubscribe => {
+    if (!isInitialized || !sdk) {
+      console.warn('[useEvents] SDK not initialized. Cannot subscribe to events.');
+      return () => {};
+    }
+    
+    const unsubscribe = sdk.events.once(handler, filter);
+    
+    // Track for cleanup
+    subscriptionsRef.current.push(unsubscribe);
+    
+    return () => {
+      unsubscribe();
+      const index = subscriptionsRef.current.indexOf(unsubscribe);
+      if (index > -1) {
+        subscriptionsRef.current.splice(index, 1);
+      }
+    };
+  }, [sdk, isInitialized]);
+
+  /**
+   * Clear all event subscriptions from this hook instance
+   * 
+   * Useful when you want to reset all event listeners without unmounting the component.
+   * Note: This only clears subscriptions created through this hook instance.
+   * 
+   * @example
+   * ```typescript
+   * const { clear, subscribe } = useEvents();
+   * 
+   * // Create some subscriptions
+   * subscribe((event) => console.log(event));
+   * subscribe((event) => logToServer(event));
+   * 
+   * // Later: clear all subscriptions from this hook
+   * clear();
+   * ```
+   */
+  const clear = useCallback((): void => {
+    subscriptionsRef.current.forEach(unsubscribe => {
+      try {
+        unsubscribe();
+      } catch (e) {
+        // Ignore cleanup errors
+      }
+    });
+    subscriptionsRef.current = [];
+  }, []);
+
+  /**
+   * Get current subscriber count from the event emitter
+   * 
+   * Useful for debugging or showing active listener count in dev tools.
+   */
+  const subscriberCount = sdk?.events?.subscriberCount ?? 0;
+
+  return {
+    /**
+     * Subscribe to SDK events with optional filtering
+     * 
+     * @param handler - Callback function for each matching event
+     * @param filter - Optional filter by domain and/or level
+     * @returns Unsubscribe function
+     */
+    subscribe,
+    
+    /**
+     * Subscribe to a single event (auto-unsubscribes after first match)
+     * 
+     * @param handler - Callback function for the first matching event
+     * @param filter - Optional filter by domain and/or level
+     * @returns Unsubscribe function
+     */
+    once,
+    
+    /**
+     * Clear all subscriptions created through this hook instance
+     */
+    clear,
+    
+    /**
+     * Whether the event system is available
+     * 
+     * Returns `true` when SDK is initialized and events can be subscribed to.
+     */
+    isAvailable: isInitialized && !!sdk?.events,
+    
+    /**
+     * Current number of active subscribers across all components
+     * 
+     * Useful for debugging event system usage.
+     */
+    subscriberCount,
+  };
+};
+
+export type EventsHook_ = ReturnType<typeof useEvents>;

package/src/hooks/usePurchases.ts

@@ -1,6 +1,6 @@
 import { useCallback } from 'react';
 import { usePersSDK } from '../providers/PersSDKProvider';
-import type { PurchaseTokenDTO, PurchaseDTO } from '@explorins/pers-shared';
+import type { PurchaseTokenDTO, PurchaseDTO, PaginatedResponseDTO } from '@explorins/pers-shared';
 
 export const usePurchases = () => {
   const { sdk, isInitialized, isAuthenticated } = usePersSDK();
@@ -24,7 +24,7 @@ export const usePurchases = () => {
     }
   }, [sdk, isInitialized]);
 
-  const getActivePurchaseTokens = useCallback(async (): Promise<PurchaseTokenDTO[]> => {
+  const getActivePurchaseTokens = useCallback(async (): Promise<PaginatedResponseDTO<PurchaseTokenDTO>> => {
     if (!isInitialized || !sdk) {
       throw new Error('SDK not initialized. Call initialize() first.');
     }
@@ -38,7 +38,7 @@ export const usePurchases = () => {
     }
   }, [sdk, isInitialized]);
 
-  const getAllUserPurchases = useCallback(async (): Promise<PurchaseDTO[]> => {
+  const getAllUserPurchases = useCallback(async (): Promise<PaginatedResponseDTO<PurchaseDTO>> => {
     if (!isInitialized || !sdk) {
       throw new Error('SDK not initialized. Call initialize() first.');
     }

package/src/hooks/useRedemptions.ts

@@ -7,33 +7,42 @@ import type {
   RedemptionRedeemDTO, 
   RedemptionRedeemRequestResponseDTO,
   RedemptionTypeDTO,
+  PaginatedResponseDTO
 } from '@explorins/pers-shared';
 
 export const useRedemptions = () => {
   const { sdk, isInitialized, isAuthenticated } = usePersSDK();
   const { signAndSubmitTransactionWithJWT, isSignerAvailable, currentStatus, statusMessage } = useTransactionSigner();
 
-  const getActiveRedemptions = useCallback(async (): Promise<RedemptionDTO[]> => {
+  /**
+   * Get redemption offers based on user permissions
+   * 
+   * **Regular Users:** Automatically see only active redemptions available for purchase
+   * **Administrators:** Can see all redemptions and filter by active/inactive status
+   * 
+   * The backend enforces permission-based filtering automatically.
+   */
+  const getRedemptions = useCallback(async (options?: { active?: boolean }): Promise<PaginatedResponseDTO<RedemptionDTO>> => {
     if (!isInitialized || !sdk) {
       throw new Error('SDK not initialized. Call initialize() first.');
     }
     
     try {
-      const result = await sdk.redemptions.getActiveRedemptions();
+      const result = await sdk.redemptions.getRedemptions(options);
       return result;
     } catch (error) {
-      console.error('Failed to fetch active redemptions:', error);
+      console.error('Failed to fetch redemptions:', error);
       throw error;
     }
   }, [sdk, isInitialized]);
 
-  const getUserRedemptions = useCallback(async (): Promise<RedemptionRedeemDTO[]> => {
+  const getUserRedemptions = useCallback(async (): Promise<PaginatedResponseDTO<RedemptionRedeemDTO>> => {
     if (!isInitialized || !sdk) {
       throw new Error('SDK not initialized. Call initialize() first.');
     }
     if (!isAuthenticated) {
       console.warn('SDK not authenticated. getUserRedemptions requires authentication.');
-      return [];
+      return { data: [], pagination: { page: 1, limit: 0, total: 0, pages: 0, hasNext: false, hasPrev: false } };
     }
     
     try {
@@ -105,21 +114,7 @@ export const useRedemptions = () => {
     }
   }, [sdk, isInitialized]);
 
-  const getAllRedemptions = useCallback(async (active?: boolean): Promise<RedemptionDTO[]> => {
-    if (!isInitialized || !sdk) {
-      throw new Error('SDK not initialized. Call initialize() first.');
-    }
-    
-    try {
-      const result = await sdk.redemptions.getAllRedemptions(active);
-      return result;
-    } catch (error) {
-      console.error('Failed to fetch all redemptions:', error);
-      throw error;
-    }
-  }, [sdk, isInitialized]);
-
-  const getRedemptionTypes = useCallback(async (): Promise<RedemptionTypeDTO[]> => {
+  const getRedemptionTypes = useCallback(async (): Promise<PaginatedResponseDTO<RedemptionTypeDTO>> => {
     if (!isInitialized || !sdk) {
       throw new Error('SDK not initialized. Call initialize() first.');
     }
@@ -162,12 +157,11 @@ export const useRedemptions = () => {
   }, [sdk, isInitialized]);
 
   return {
-    getActiveRedemptions,
+    getRedemptions,
     getUserRedemptions,
     redeem,
     getRedemptionTypes,
     createRedemption,
-    getAllRedemptions,
     updateRedemption,
     toggleRedemptionStatus,
     isAvailable: isInitialized && !!sdk?.redemptions,

package/src/hooks/useTenants.ts

@@ -1,6 +1,6 @@
 import { useCallback } from 'react';
 import { usePersSDK } from '../providers/PersSDKProvider';
-import type { TenantPublicDTO, TenantClientConfigDTO, AdminDTO } from '@explorins/pers-shared';
+import type { TenantPublicDTO, TenantClientConfigDTO, AdminDTO, PaginatedResponseDTO } from '@explorins/pers-shared';
 
 export const useTenants = () => {
   const { sdk, isInitialized } = usePersSDK();
@@ -47,7 +47,7 @@ export const useTenants = () => {
     }
   }, [sdk, isInitialized]);
 
-  const getAdmins = useCallback(async (): Promise<AdminDTO[]> => {
+  const getAdmins = useCallback(async (): Promise<PaginatedResponseDTO<AdminDTO>> => {
     if (!isInitialized || !sdk) {
       throw new Error('SDK not initialized. Call initialize() first.');
     }