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

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"}

package/dist/hooks/useTransactionSigner.js

@@ -338,6 +338,63 @@ export const useTransactionSigner = () => {
             throw error; // Re-throw to maintain error handling upstream
         }
     }, [isSignerInitialized]);
+    /**
+     * Sign a PERS transaction without submitting (for POS flows with QR codes)
+     *
+     * This method signs the transaction but does NOT submit it to the blockchain.
+     * Instead, it returns the signature which can be displayed as a QR code for
+     * the business to scan and submit.
+     *
+     * **Use Case:** Point-of-Sale (POS) flows where:
+     * 1. User signs the transaction
+     * 2. App generates QR code with signature
+     * 3. Business scans QR code
+     * 4. Business submits transaction to blockchain
+     *
+     * @param {string} jwt - JWT token with transaction and user data
+     * @param {StatusCallback} [onStatusUpdate] - Optional callback for status updates
+     * @returns {Promise<TransactionSigningResult>} Signing result with signature for QR code
+     *
+     * @example
+     * ```typescript
+     * const { signPersTransaction } = useTransactionSigner();
+     *
+     * const result = await signPersTransaction(jwtToken);
+     * if (result.success) {
+     *   const qrData = {
+     *     transactionId: result.transactionId,
+     *     signature: result.signature,
+     *     transactionFormat: result.signingData.format,
+     *     txType: 'PENDING_SUBMISSION'
+     *   };
+     *   // Display QR code with qrData
+     * }
+     * ```
+     */
+    const signPersTransaction = useCallback(async (jwt, onStatusUpdate) => {
+        if (!isSignerInitialized || !signerSDKRef.current) {
+            throw new Error('Signer SDK not initialized');
+        }
+        // Create status callback wrapper
+        const statusCallback = {
+            onStatusUpdate: (status, message, data) => {
+                setCurrentStatus(status);
+                setStatusMessage(message);
+                onStatusUpdate?.(status, message, data);
+            }
+        };
+        try {
+            // Use the SDK's sign-only method
+            const signingResult = await signerSDKRef.current.signPersTransaction(jwt, statusCallback);
+            return signingResult;
+        }
+        catch (error) {
+            console.error('[useTransactionSigner] Sign-only transaction failed:', error);
+            setCurrentStatus(SigningStatus.ERROR);
+            setStatusMessage(error instanceof Error ? error.message : 'Signing failed');
+            throw error;
+        }
+    }, [isSignerInitialized]);
     return {
         /**
          * Sign and submit a blockchain transaction using JWT token
@@ -350,6 +407,17 @@ export const useTransactionSigner = () => {
          * @returns {Promise<SubmissionResult>} Transaction result with hash and status
          */
         signAndSubmitTransactionWithJWT,
+        /**
+         * Sign a transaction without submitting (for POS flows)
+         *
+         * Signs the transaction and returns the signature without submitting to blockchain.
+         * Use this for Point-of-Sale flows where the business scans a QR code and submits.
+         *
+         * @param {string} jwt - JWT token with transaction and user data
+         * @param {StatusCallback} [onStatusUpdate] - Optional callback for status updates
+         * @returns {Promise<TransactionSigningResult>} Signing result with signature for QR code
+         */
+        signPersTransaction,
         /**
          * Whether the transaction signer SDK has been successfully initialized
          *

package/dist/hooks/useTransactions.d.ts

@@ -1,5 +1,5 @@
 import { OnStatusUpdateFn } from './useTransactionSigner';
-import type { TransactionRequestDTO, TransactionRequestResponseDTO, TransactionDTO, TransactionRole, TransactionPaginationRequestDTO } from '@explorins/pers-shared';
+import type { TransactionRequestDTO, TransactionRequestResponseDTO, TransactionDTO, TransactionRole, TransactionPaginationRequestDTO, PaginatedResponseDTO } from '@explorins/pers-shared';
 /**
  * React hook for transaction operations in the PERS SDK
  *
@@ -39,8 +39,8 @@ import type { TransactionRequestDTO, TransactionRequestResponseDTO, TransactionD
 export declare const useTransactions: () => {
     createTransaction: (request: TransactionRequestDTO, onStatusUpdate?: OnStatusUpdateFn) => Promise<TransactionRequestResponseDTO>;
     getTransactionById: (transactionId: string) => Promise<TransactionDTO | null>;
-    getUserTransactionHistory: (role?: TransactionRole) => Promise<TransactionDTO[]>;
-    getTenantTransactions: () => Promise<TransactionDTO[]>;
+    getUserTransactionHistory: (role?: TransactionRole) => Promise<PaginatedResponseDTO<TransactionDTO>>;
+    getTenantTransactions: () => Promise<PaginatedResponseDTO<TransactionDTO>>;
     getPaginatedTransactions: (params: TransactionPaginationRequestDTO) => Promise<any>;
     exportTransactionsCSV: () => Promise<Blob>;
     isAvailable: boolean;

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

@@ -1 +1 @@
-{"version":3,"file":"useTransactions.d.ts","sourceRoot":"","sources":["../../src/hooks/useTransactions.ts"],"names":[],"mappings":"AAEA,OAAO,EAAwB,gBAAgB,EAAE,MAAM,wBAAwB,CAAC;AAChF,OAAO,KAAK,EACV,qBAAqB,EACrB,6BAA6B,EAC7B,cAAc,EACd,eAAe,EACf,+BAA+B,EAChC,MAAM,wBAAwB,CAAC;AAEhC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAmCG;AACH,eAAO,MAAM,eAAe;iCAgC4B,qBAAqB,mBAAmB,gBAAgB,KAAG,QAAQ,6BAA6B,CAAC;wCA2D1F,MAAM,KAAG,QAAQ,cAAc,GAAG,IAAI,CAAC;uCA4BxC,eAAe,KAAG,QAAQ,cAAc,EAAE,CAAC;iCAenD,QAAQ,cAAc,EAAE,CAAC;uCAcjB,+BAA+B,KAAG,QAAQ,GAAG,CAAC;iCActD,QAAQ,IAAI,CAAC;;;;CA0BlE,CAAC;AAEF,MAAM,MAAM,eAAe,GAAG,UAAU,CAAC,OAAO,eAAe,CAAC,CAAC"}
+{"version":3,"file":"useTransactions.d.ts","sourceRoot":"","sources":["../../src/hooks/useTransactions.ts"],"names":[],"mappings":"AAEA,OAAO,EAAwB,gBAAgB,EAAE,MAAM,wBAAwB,CAAC;AAChF,OAAO,KAAK,EACV,qBAAqB,EACrB,6BAA6B,EAC7B,cAAc,EACd,eAAe,EACf,+BAA+B,EAC/B,oBAAoB,EACrB,MAAM,wBAAwB,CAAC;AAEhC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAmCG;AACH,eAAO,MAAM,eAAe;iCAgC4B,qBAAqB,mBAAmB,gBAAgB,KAAG,QAAQ,6BAA6B,CAAC;wCA2D1F,MAAM,KAAG,QAAQ,cAAc,GAAG,IAAI,CAAC;uCA4BxC,eAAe,KAAG,QAAQ,qBAAqB,cAAc,CAAC,CAAC;iCAevE,QAAQ,qBAAqB,cAAc,CAAC,CAAC;uCAcrC,+BAA+B,KAAG,QAAQ,GAAG,CAAC;iCActD,QAAQ,IAAI,CAAC;;;;CA0BlE,CAAC;AAEF,MAAM,MAAM,eAAe,GAAG,UAAU,CAAC,OAAO,eAAe,CAAC,CAAC"}

package/dist/hooks/useUserStatus.d.ts

@@ -1,7 +1,7 @@
-import type { UserStatusTypeDTO } from '@explorins/pers-shared';
+import type { UserStatusTypeDTO, PaginatedResponseDTO } from '@explorins/pers-shared';
 export declare const useUserStatus: () => {
-    getUserStatusTypes: () => Promise<UserStatusTypeDTO[]>;
-    getEarnedUserStatus: () => Promise<UserStatusTypeDTO[]>;
+    getUserStatusTypes: () => Promise<PaginatedResponseDTO<UserStatusTypeDTO>>;
+    getEarnedUserStatus: () => Promise<PaginatedResponseDTO<UserStatusTypeDTO>>;
     createUserStatusType: (userStatusType: UserStatusTypeDTO) => Promise<UserStatusTypeDTO>;
     isAvailable: boolean;
 };

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

@@ -1 +1 @@
-{"version":3,"file":"useUserStatus.d.ts","sourceRoot":"","sources":["../../src/hooks/useUserStatus.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,wBAAwB,CAAC;AAEhE,eAAO,MAAM,aAAa;8BAGyB,QAAQ,iBAAiB,EAAE,CAAC;+BAc3B,QAAQ,iBAAiB,EAAE,CAAC;2CAkBd,iBAAiB,KAAG,QAAQ,iBAAiB,CAAC;;CAoB/G,CAAC;AAEF,MAAM,MAAM,cAAc,GAAG,UAAU,CAAC,OAAO,aAAa,CAAC,CAAC"}
+{"version":3,"file":"useUserStatus.d.ts","sourceRoot":"","sources":["../../src/hooks/useUserStatus.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,iBAAiB,EAAE,oBAAoB,EAAE,MAAM,wBAAwB,CAAC;AAEtF,eAAO,MAAM,aAAa;8BAGyB,QAAQ,qBAAqB,iBAAiB,CAAC,CAAC;+BAc/C,QAAQ,qBAAqB,iBAAiB,CAAC,CAAC;2CAkBlC,iBAAiB,KAAG,QAAQ,iBAAiB,CAAC;;CAoB/G,CAAC;AAEF,MAAM,MAAM,cAAc,GAAG,UAAU,CAAC,OAAO,aAAa,CAAC,CAAC"}

package/dist/hooks/useUsers.d.ts

@@ -1,4 +1,4 @@
-import type { UserDTO, UserCreateRequestDTO } from '@explorins/pers-shared';
+import type { UserDTO, UserCreateRequestDTO, PaginatedResponseDTO } from '@explorins/pers-shared';
 import type { UserPublicProfileDTO } from '@explorins/pers-sdk/user';
 export declare const useUsers: () => {
     getCurrentUser: () => Promise<UserDTO>;
@@ -7,8 +7,8 @@ export declare const useUsers: () => {
     getAllUsersPublic: (filter?: {
         key: string;
         value: string;
-    }) => Promise<UserPublicProfileDTO[]>;
-    getAllUsers: () => Promise<UserDTO[]>;
+    }) => Promise<PaginatedResponseDTO<UserPublicProfileDTO>>;
+    getAllUsers: () => Promise<PaginatedResponseDTO<UserDTO>>;
     updateUser: (userId: string, userData: UserCreateRequestDTO) => Promise<UserDTO>;
     toggleUserStatus: (user: UserDTO) => Promise<UserDTO>;
     isAvailable: boolean;

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

@@ -1 +1 @@
-{"version":3,"file":"useUsers.d.ts","sourceRoot":"","sources":["../../src/hooks/useUsers.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,OAAO,EAAE,oBAAoB,EAAE,MAAM,wBAAwB,CAAC;AAC5E,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,0BAA0B,CAAC;AAErE,eAAO,MAAM,QAAQ;0BAG0B,QAAQ,OAAO,CAAC;kCAiBN,oBAAoB,KAAG,QAAQ,OAAO,CAAC;0BAiB/C,MAAM,KAAG,QAAQ,OAAO,CAAC;iCAclB;QAAE,GAAG,EAAE,MAAM,CAAC;QAAC,KAAK,EAAE,MAAM,CAAA;KAAE,KAAG,QAAQ,oBAAoB,EAAE,CAAC;uBAe5E,QAAQ,OAAO,EAAE,CAAC;yBAcd,MAAM,YAAY,oBAAoB,KAAG,QAAQ,OAAO,CAAC;6BAcrD,OAAO,KAAG,QAAQ,OAAO,CAAC;;CAwB7E,CAAC;AAEF,MAAM,MAAM,QAAQ,GAAG,UAAU,CAAC,OAAO,QAAQ,CAAC,CAAC"}
+{"version":3,"file":"useUsers.d.ts","sourceRoot":"","sources":["../../src/hooks/useUsers.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,OAAO,EAAE,oBAAoB,EAAE,oBAAoB,EAAE,MAAM,wBAAwB,CAAC;AAClG,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,0BAA0B,CAAC;AAErE,eAAO,MAAM,QAAQ;0BAG0B,QAAQ,OAAO,CAAC;kCAiBN,oBAAoB,KAAG,QAAQ,OAAO,CAAC;0BAiB/C,MAAM,KAAG,QAAQ,OAAO,CAAC;iCAclB;QAAE,GAAG,EAAE,MAAM,CAAC;QAAC,KAAK,EAAE,MAAM,CAAA;KAAE,KAAG,QAAQ,qBAAqB,oBAAoB,CAAC,CAAC;uBAehG,QAAQ,qBAAqB,OAAO,CAAC,CAAC;yBAclC,MAAM,YAAY,oBAAoB,KAAG,QAAQ,OAAO,CAAC;6BAcrD,OAAO,KAAG,QAAQ,OAAO,CAAC;;CAwB7E,CAAC;AAEF,MAAM,MAAM,QAAQ,GAAG,UAAU,CAAC,OAAO,QAAQ,CAAC,CAAC"}