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

package/dist/hooks/useEvents.d.ts

@@ -0,0 +1,178 @@
+import type { PersEvent, EventHandler, EventFilter, Unsubscribe } from '@explorins/pers-sdk/core';
+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 declare const useEvents: () => EventsHook;
+export type EventsHook_ = ReturnType<typeof useEvents>;
+//# sourceMappingURL=useEvents.d.ts.map

package/dist/hooks/useEvents.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useEvents.d.ts","sourceRoot":"","sources":["../../src/hooks/useEvents.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EACV,SAAS,EACT,YAAY,EACZ,WAAW,EACX,WAAW,EACZ,MAAM,0BAA0B,CAAC;AAGlC,YAAY,EAAE,SAAS,EAAE,YAAY,EAAE,WAAW,EAAE,WAAW,EAAE,CAAC;AAElE;;;;;;;;;;;;GAYG;AACH,MAAM,WAAW,UAAU;IACzB,SAAS,EAAE,CAAC,OAAO,EAAE,YAAY,EAAE,MAAM,CAAC,EAAE,WAAW,KAAK,WAAW,CAAC;IACxE,IAAI,EAAE,CAAC,OAAO,EAAE,YAAY,EAAE,MAAM,CAAC,EAAE,WAAW,KAAK,WAAW,CAAC;IACnE,KAAK,EAAE,MAAM,IAAI,CAAC;IAClB,WAAW,EAAE,OAAO,CAAC;IACrB,eAAe,EAAE,MAAM,CAAC;CACzB;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAwJG;AACH,eAAO,MAAM,SAAS,QAAO,UA2K5B,CAAC;AAEF,MAAM,MAAM,WAAW,GAAG,UAAU,CAAC,OAAO,SAAS,CAAC,CAAC"}

package/dist/hooks/useEvents.js

@@ -0,0 +1,312 @@
+import { useCallback, useEffect, useRef } from 'react';
+import { usePersSDK } from '../providers/PersSDKProvider';
+/**
+ * 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 = () => {
+    const { sdk, isInitialized } = usePersSDK();
+    // Track subscriptions for cleanup
+    const subscriptionsRef = useRef([]);
+    // 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, filter) => {
+        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, filter) => {
+        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(() => {
+        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,
+    };
+};

package/dist/hooks/usePurchases.d.ts

@@ -1,8 +1,8 @@
-import type { PurchaseTokenDTO, PurchaseDTO } from '@explorins/pers-shared';
+import type { PurchaseTokenDTO, PurchaseDTO, PaginatedResponseDTO } from '@explorins/pers-shared';
 export declare const usePurchases: () => {
     createPaymentIntent: (amount: number, currency: string, receiptEmail: string, description: string) => Promise<import("@explorins/pers-shared").PaymentIntentDTO>;
-    getActivePurchaseTokens: () => Promise<PurchaseTokenDTO[]>;
-    getAllUserPurchases: () => Promise<PurchaseDTO[]>;
+    getActivePurchaseTokens: () => Promise<PaginatedResponseDTO<PurchaseTokenDTO>>;
+    getAllUserPurchases: () => Promise<PaginatedResponseDTO<PurchaseDTO>>;
     isAvailable: boolean;
 };
 export type PurchaseHook = ReturnType<typeof usePurchases>;

package/dist/hooks/usePurchases.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"usePurchases.d.ts","sourceRoot":"","sources":["../../src/hooks/usePurchases.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,gBAAgB,EAAE,WAAW,EAAE,MAAM,wBAAwB,CAAC;AAE5E,eAAO,MAAM,YAAY;kCAIb,MAAM,YACJ,MAAM,gBACF,MAAM,eACP,MAAM;mCAeiC,QAAQ,gBAAgB,EAAE,CAAC;+BAc/B,QAAQ,WAAW,EAAE,CAAC;;CAuBzE,CAAC;AAEF,MAAM,MAAM,YAAY,GAAG,UAAU,CAAC,OAAO,YAAY,CAAC,CAAC"}
+{"version":3,"file":"usePurchases.d.ts","sourceRoot":"","sources":["../../src/hooks/usePurchases.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,gBAAgB,EAAE,WAAW,EAAE,oBAAoB,EAAE,MAAM,wBAAwB,CAAC;AAElG,eAAO,MAAM,YAAY;kCAIb,MAAM,YACJ,MAAM,gBACF,MAAM,eACP,MAAM;mCAeiC,QAAQ,qBAAqB,gBAAgB,CAAC,CAAC;+BAcnD,QAAQ,qBAAqB,WAAW,CAAC,CAAC;;CAuB7F,CAAC;AAEF,MAAM,MAAM,YAAY,GAAG,UAAU,CAAC,OAAO,YAAY,CAAC,CAAC"}

package/dist/hooks/useRedemptions.d.ts

@@ -1,12 +1,13 @@
 import { OnStatusUpdateFn } from './useTransactionSigner';
-import type { RedemptionCreateRequestDTO, RedemptionDTO, RedemptionRedeemDTO, RedemptionRedeemRequestResponseDTO, RedemptionTypeDTO } from '@explorins/pers-shared';
+import type { RedemptionCreateRequestDTO, RedemptionDTO, RedemptionRedeemDTO, RedemptionRedeemRequestResponseDTO, RedemptionTypeDTO, PaginatedResponseDTO } from '@explorins/pers-shared';
 export declare const useRedemptions: () => {
-    getActiveRedemptions: () => Promise<RedemptionDTO[]>;
-    getUserRedemptions: () => Promise<RedemptionRedeemDTO[]>;
+    getRedemptions: (options?: {
+        active?: boolean;
+    }) => Promise<PaginatedResponseDTO<RedemptionDTO>>;
+    getUserRedemptions: () => Promise<PaginatedResponseDTO<RedemptionRedeemDTO>>;
     redeem: (redemptionId: string, onStatusUpdate?: OnStatusUpdateFn) => Promise<RedemptionRedeemRequestResponseDTO>;
-    getRedemptionTypes: () => Promise<RedemptionTypeDTO[]>;
+    getRedemptionTypes: () => Promise<PaginatedResponseDTO<RedemptionTypeDTO>>;
     createRedemption: (redemptionData: RedemptionCreateRequestDTO) => Promise<RedemptionDTO>;
-    getAllRedemptions: (active?: boolean) => Promise<RedemptionDTO[]>;
     updateRedemption: (redemptionId: string, redemptionData: RedemptionCreateRequestDTO) => Promise<RedemptionDTO>;
     toggleRedemptionStatus: (redemptionId: string) => Promise<RedemptionDTO>;
     isAvailable: boolean;

package/dist/hooks/useRedemptions.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"useRedemptions.d.ts","sourceRoot":"","sources":["../../src/hooks/useRedemptions.ts"],"names":[],"mappings":"AAEA,OAAO,EAA0C,gBAAgB,EAAE,MAAM,wBAAwB,CAAC;AAClG,OAAO,KAAK,EACV,0BAA0B,EAC1B,aAAa,EACb,mBAAmB,EACnB,kCAAkC,EAClC,iBAAiB,EAClB,MAAM,wBAAwB,CAAC;AAEhC,eAAO,MAAM,cAAc;gCAI0B,QAAQ,aAAa,EAAE,CAAC;8BAc1B,QAAQ,mBAAmB,EAAE,CAAC;2BAkB/B,MAAM,mBAAmB,gBAAgB,KAAG,QAAQ,kCAAkC,CAAC;8BA0EtF,QAAQ,iBAAiB,EAAE,CAAC;uCA5BjB,0BAA0B,KAAG,QAAQ,aAAa,CAAC;iCAczD,OAAO,KAAG,QAAQ,aAAa,EAAE,CAAC;qCA4B9B,MAAM,kBAAkB,0BAA0B,KAAG,QAAQ,aAAa,CAAC;2CAcrE,MAAM,KAAG,QAAQ,aAAa,CAAC;;;;CA4BhG,CAAC;AAEF,MAAM,MAAM,cAAc,GAAG,UAAU,CAAC,OAAO,cAAc,CAAC,CAAC"}
+{"version":3,"file":"useRedemptions.d.ts","sourceRoot":"","sources":["../../src/hooks/useRedemptions.ts"],"names":[],"mappings":"AAEA,OAAO,EAA0C,gBAAgB,EAAE,MAAM,wBAAwB,CAAC;AAClG,OAAO,KAAK,EACV,0BAA0B,EAC1B,aAAa,EACb,mBAAmB,EACnB,kCAAkC,EAClC,iBAAiB,EACjB,oBAAoB,EACrB,MAAM,wBAAwB,CAAC;AAEhC,eAAO,MAAM,cAAc;+BAY2B;QAAE,MAAM,CAAC,EAAE,OAAO,CAAA;KAAE,KAAG,QAAQ,qBAAqB,aAAa,CAAC,CAAC;8BActE,QAAQ,qBAAqB,mBAAmB,CAAC,CAAC;2BAkBnD,MAAM,mBAAmB,gBAAgB,KAAG,QAAQ,kCAAkC,CAAC;8BA4DtF,QAAQ,qBAAqB,iBAAiB,CAAC,CAAC;uCAdrC,0BAA0B,KAAG,QAAQ,aAAa,CAAC;qCA4BrD,MAAM,kBAAkB,0BAA0B,KAAG,QAAQ,aAAa,CAAC;2CAcrE,MAAM,KAAG,QAAQ,aAAa,CAAC;;;;CA2BhG,CAAC;AAEF,MAAM,MAAM,cAAc,GAAG,UAAU,CAAC,OAAO,cAAc,CAAC,CAAC"}

package/dist/hooks/useRedemptions.js

@@ -4,16 +4,24 @@ import { useTransactionSigner } from './useTransactionSigner';
 export const useRedemptions = () => {
     const { sdk, isInitialized, isAuthenticated } = usePersSDK();
     const { signAndSubmitTransactionWithJWT, isSignerAvailable, currentStatus, statusMessage } = useTransactionSigner();
-    const getActiveRedemptions = useCallback(async () => {
+    /**
+     * 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) => {
         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]);
@@ -23,7 +31,7 @@ export const useRedemptions = () => {
         }
         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 {
             const result = await sdk.redemptions.getUserRedemptions();
@@ -93,19 +101,6 @@ export const useRedemptions = () => {
             throw error;
         }
     }, [sdk, isInitialized]);
-    const getAllRedemptions = useCallback(async (active) => {
-        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 () => {
         if (!isInitialized || !sdk) {
             throw new Error('SDK not initialized. Call initialize() first.');
@@ -146,12 +141,11 @@ export const useRedemptions = () => {
         }
     }, [sdk, isInitialized]);
     return {
-        getActiveRedemptions,
+        getRedemptions,
         getUserRedemptions,
         redeem,
         getRedemptionTypes,
         createRedemption,
-        getAllRedemptions,
         updateRedemption,
         toggleRedemptionStatus,
         isAvailable: isInitialized && !!sdk?.redemptions,

package/dist/hooks/useTenants.d.ts

@@ -1,9 +1,9 @@
-import type { TenantPublicDTO, TenantClientConfigDTO, AdminDTO } from '@explorins/pers-shared';
+import type { TenantPublicDTO, TenantClientConfigDTO, AdminDTO, PaginatedResponseDTO } from '@explorins/pers-shared';
 export declare const useTenants: () => {
     getTenantInfo: () => Promise<TenantPublicDTO>;
     getClientConfig: () => Promise<TenantClientConfigDTO>;
     getLoginToken: () => Promise<string>;
-    getAdmins: () => Promise<AdminDTO[]>;
+    getAdmins: () => Promise<PaginatedResponseDTO<AdminDTO>>;
     isAvailable: boolean;
 };
 export type TenantHook = ReturnType<typeof useTenants>;

package/dist/hooks/useTenants.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"useTenants.d.ts","sourceRoot":"","sources":["../../src/hooks/useTenants.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,eAAe,EAAE,qBAAqB,EAAE,QAAQ,EAAE,MAAM,wBAAwB,CAAC;AAE/F,eAAO,MAAM,UAAU;yBAGuB,QAAQ,eAAe,CAAC;2BActB,QAAQ,qBAAqB,CAAC;yBAchC,QAAQ,MAAM,CAAC;qBAcnB,QAAQ,QAAQ,EAAE,CAAC;;CAqB5D,CAAC;AAEF,MAAM,MAAM,UAAU,GAAG,UAAU,CAAC,OAAO,UAAU,CAAC,CAAC"}
+{"version":3,"file":"useTenants.d.ts","sourceRoot":"","sources":["../../src/hooks/useTenants.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,eAAe,EAAE,qBAAqB,EAAE,QAAQ,EAAE,oBAAoB,EAAE,MAAM,wBAAwB,CAAC;AAErH,eAAO,MAAM,UAAU;yBAGuB,QAAQ,eAAe,CAAC;2BActB,QAAQ,qBAAqB,CAAC;yBAchC,QAAQ,MAAM,CAAC;qBAcnB,QAAQ,qBAAqB,QAAQ,CAAC,CAAC;;CAqBhF,CAAC;AAEF,MAAM,MAAM,UAAU,GAAG,UAAU,CAAC,OAAO,UAAU,CAAC,CAAC"}

package/dist/hooks/useTokens.d.ts

@@ -1,4 +1,4 @@
-import type { TokenDTO } from '@explorins/pers-shared';
+import type { TokenDTO, PaginatedResponseDTO } from '@explorins/pers-shared';
 /**
  * React hook for token operations in the PERS SDK
  *
@@ -28,11 +28,11 @@ import type { TokenDTO } from '@explorins/pers-shared';
  * ```
  */
 export declare const useTokens: () => {
-    getTokens: () => Promise<TokenDTO[]>;
+    getTokens: () => Promise<PaginatedResponseDTO<TokenDTO>>;
     getActiveCreditToken: () => Promise<TokenDTO>;
-    getRewardTokens: () => Promise<TokenDTO[]>;
+    getRewardTokens: () => Promise<PaginatedResponseDTO<TokenDTO>>;
     getTokenTypes: () => Promise<any>;
-    getStatusTokens: () => Promise<TokenDTO[]>;
+    getStatusTokens: () => Promise<PaginatedResponseDTO<TokenDTO>>;
     getTokenByContract: (contractAddress: string, contractTokenId?: string | null) => Promise<TokenDTO>;
     isAvailable: boolean;
 };

package/dist/hooks/useTokens.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"useTokens.d.ts","sourceRoot":"","sources":["../../src/hooks/useTokens.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,wBAAwB,CAAC;AAEvD;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AACH,eAAO,MAAM,SAAS;qBAoBoB,QAAQ,QAAQ,EAAE,CAAC;gCA2BR,QAAQ,QAAQ,CAAC;2BA2BtB,QAAQ,QAAQ,EAAE,CAAC;yBA2BrB,QAAQ,GAAG,CAAC;2BA2BV,QAAQ,QAAQ,EAAE,CAAC;0CA6BF,MAAM,oBAAoB,MAAM,GAAG,IAAI,KAAG,QAAQ,QAAQ,CAAC;;CAuB3H,CAAC;AAEF,MAAM,MAAM,SAAS,GAAG,UAAU,CAAC,OAAO,SAAS,CAAC,CAAC"}
+{"version":3,"file":"useTokens.d.ts","sourceRoot":"","sources":["../../src/hooks/useTokens.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,QAAQ,EAAE,oBAAoB,EAAE,MAAM,wBAAwB,CAAC;AAE7E;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AACH,eAAO,MAAM,SAAS;qBAoBoB,QAAQ,qBAAqB,QAAQ,CAAC,CAAC;gCA2B5B,QAAQ,QAAQ,CAAC;2BA2BtB,QAAQ,qBAAqB,QAAQ,CAAC,CAAC;yBA2BzC,QAAQ,GAAG,CAAC;2BA2BV,QAAQ,qBAAqB,QAAQ,CAAC,CAAC;0CA6BtB,MAAM,oBAAoB,MAAM,GAAG,IAAI,KAAG,QAAQ,QAAQ,CAAC;;CAuB3H,CAAC;AAEF,MAAM,MAAM,SAAS,GAAG,UAAU,CAAC,OAAO,SAAS,CAAC,CAAC"}

package/dist/hooks/useTransactionSigner.d.ts

@@ -17,6 +17,7 @@ export type OnStatusUpdateFn = (status: SigningStatus, message: string, data?: S
  *
  * @interface TransactionSignerHook
  * @property {Function} signAndSubmitTransactionWithJWT - Main method to sign and submit transactions
+ * @property {Function} signPersTransaction - Sign transaction without submitting (for POS flows)
  * @property {boolean} isSignerInitialized - Whether the signer SDK has been initialized
  * @property {boolean} isSignerAvailable - Whether signing functionality is fully available
  * @property {SigningStatus | null} currentStatus - Current signing status for UI feedback
@@ -24,6 +25,7 @@ export type OnStatusUpdateFn = (status: SigningStatus, message: string, data?: S
  */
 export interface TransactionSignerHook {
     signAndSubmitTransactionWithJWT: (jwt: string, onStatusUpdate?: OnStatusUpdateFn) => Promise<SubmissionResult>;
+    signPersTransaction: (jwt: string, onStatusUpdate?: OnStatusUpdateFn) => Promise<TransactionSigningResult>;
     isSignerInitialized: boolean;
     isSignerAvailable: boolean;
     currentStatus: SigningStatus | null;

package/dist/hooks/useTransactionSigner.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"useTransactionSigner.d.ts","sourceRoot":"","sources":["../../src/hooks/useTransactionSigner.ts"],"names":[],"mappings":"AAEA,OAAO,EAAoB,aAAa,EAAkB,gBAAgB,EAAE,MAAM,wBAAwB,CAAC;AAI3G,KAAK,gBAAgB,GAAG,OAAO,qCAAqC,EAAE,gBAAgB,CAAC;AACvF,KAAK,iBAAiB,GAAG,OAAO,qCAAqC,EAAE,iBAAiB,CAAC;AACzF,KAAK,wBAAwB,GAAG,OAAO,qCAAqC,EAAE,wBAAwB,CAAC;AAGvG,OAAO,EAAE,aAAa,EAAE,CAAC;AACzB,YAAY,EAAE,gBAAgB,EAAE,CAAC;AAEjC;;;GAGG;AACH,MAAM,MAAM,gBAAgB,GAAG,CAAC,MAAM,EAAE,aAAa,EAAE,OAAO,EAAE,MAAM,EAAE,IAAI,CAAC,EAAE,gBAAgB,KAAK,IAAI,CAAC;AAczG;;;;;;;;;;;;GAYG;AACH,MAAM,WAAW,qBAAqB;IACpC,+BAA+B,EAAE,CAAC,GAAG,EAAE,MAAM,EAAE,cAAc,CAAC,EAAE,gBAAgB,KAAK,OAAO,CAAC,gBAAgB,CAAC,CAAC;IAC/G,mBAAmB,EAAE,OAAO,CAAC;IAC7B,iBAAiB,EAAE,OAAO,CAAC;IAC3B,aAAa,EAAE,aAAa,GAAG,IAAI,CAAC;IACpC,aAAa,EAAE,MAAM,GAAG,IAAI,CAAC;CAC9B;AAKD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAgLG;AACH,eAAO,MAAM,oBAAoB,QAAO,qBAoPvC,CAAC;AAEF;;;;;;;;;;GAUG;AACH,YAAY,EAAE,gBAAgB,EAAE,iBAAiB,EAAE,wBAAwB,EAAE,CAAC"}
+{"version":3,"file":"useTransactionSigner.d.ts","sourceRoot":"","sources":["../../src/hooks/useTransactionSigner.ts"],"names":[],"mappings":"AAEA,OAAO,EAAoB,aAAa,EAAkB,gBAAgB,EAAE,MAAM,wBAAwB,CAAC;AAI3G,KAAK,gBAAgB,GAAG,OAAO,qCAAqC,EAAE,gBAAgB,CAAC;AACvF,KAAK,iBAAiB,GAAG,OAAO,qCAAqC,EAAE,iBAAiB,CAAC;AACzF,KAAK,wBAAwB,GAAG,OAAO,qCAAqC,EAAE,wBAAwB,CAAC;AAGvG,OAAO,EAAE,aAAa,EAAE,CAAC;AACzB,YAAY,EAAE,gBAAgB,EAAE,CAAC;AAEjC;;;GAGG;AACH,MAAM,MAAM,gBAAgB,GAAG,CAAC,MAAM,EAAE,aAAa,EAAE,OAAO,EAAE,MAAM,EAAE,IAAI,CAAC,EAAE,gBAAgB,KAAK,IAAI,CAAC;AAczG;;;;;;;;;;;;;GAaG;AACH,MAAM,WAAW,qBAAqB;IACpC,+BAA+B,EAAE,CAAC,GAAG,EAAE,MAAM,EAAE,cAAc,CAAC,EAAE,gBAAgB,KAAK,OAAO,CAAC,gBAAgB,CAAC,CAAC;IAC/G,mBAAmB,EAAE,CAAC,GAAG,EAAE,MAAM,EAAE,cAAc,CAAC,EAAE,gBAAgB,KAAK,OAAO,CAAC,wBAAwB,CAAC,CAAC;IAC3G,mBAAmB,EAAE,OAAO,CAAC;IAC7B,iBAAiB,EAAE,OAAO,CAAC;IAC3B,aAAa,EAAE,aAAa,GAAG,IAAI,CAAC;IACpC,aAAa,EAAE,MAAM,GAAG,IAAI,CAAC;CAC9B;AAKD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAgLG;AACH,eAAO,MAAM,oBAAoB,QAAO,qBA2TvC,CAAC;AAEF;;;;;;;;;;GAUG;AACH,YAAY,EAAE,gBAAgB,EAAE,iBAAiB,EAAE,wBAAwB,EAAE,CAAC"}