@explorins/pers-sdk-react-native 1.3.2 → 1.5.2

package/dist/hooks/useFiles.js

@@ -0,0 +1,140 @@
+import { useCallback } from 'react';
+import { usePersSDK } from '../providers/PersSDKProvider';
+/**
+ * React hook for file operations in the PERS SDK
+ *
+ * Provides methods for generating signed URLs for file uploads and downloads,
+ * media optimization, and secure file access. Supports various entity types
+ * and customizable expiration times.
+ *
+ * @returns File hook with methods for file management
+ *
+ * @example
+ * ```typescript
+ * function FileUploadComponent() {
+ *   const { getSignedPutUrl, getSignedGetUrl, optimizeMedia } = useFiles();
+ *
+ *   const uploadFile = async (entityId: string, file: File) => {
+ *     try {
+ *       const uploadUrl = await getSignedPutUrl(
+ *         entityId,
+ *         'profile',
+ *         'jpg'
+ *       );
+ *
+ *       // Upload file to the signed URL
+ *       await fetch(uploadUrl, {
+ *         method: 'PUT',
+ *         body: file
+ *       });
+ *
+ *       // Get download URL
+ *       const downloadUrl = await getSignedGetUrl(entityId, 'profile');
+ *       console.log('File uploaded, download URL:', downloadUrl);
+ *     } catch (error) {
+ *       console.error('File upload failed:', error);
+ *     }
+ *   };
+ *
+ *   return <input type="file" onChange={(e) => uploadFile('user-123', e.target.files[0])} />;
+ * }
+ * ```
+ */
+export const useFiles = () => {
+    const { sdk, isInitialized } = usePersSDK();
+    /**
+     * Generates a signed URL for uploading files to cloud storage
+     *
+     * @param entityId - Unique identifier of the entity the file belongs to
+     * @param entityType - Type of entity ('profile', 'business', 'campaign', etc.)
+     * @param fileExtension - File extension without the dot (e.g., 'jpg', 'png')
+     * @returns Promise resolving to signed upload URL
+     * @throws Error if SDK is not initialized
+     *
+     * @example
+     * ```typescript
+     * const { getSignedPutUrl } = useFiles();
+     * const uploadUrl = await getSignedPutUrl('user-123', 'profile', 'jpg');
+     * // Use uploadUrl with PUT request to upload file
+     * ```
+     */
+    const getSignedPutUrl = useCallback(async (entityId, entityType, fileExtension) => {
+        if (!isInitialized || !sdk) {
+            throw new Error('SDK not initialized. Call initialize() first.');
+        }
+        try {
+            const result = await sdk.files.getSignedPutUrl(entityId, entityType, fileExtension);
+            console.log('Signed put URL generated successfully:', result);
+            return result;
+        }
+        catch (error) {
+            console.error('Failed to generate signed put URL:', error);
+            throw error;
+        }
+    }, [sdk, isInitialized]);
+    /**
+     * Generates a signed URL for downloading files from cloud storage
+     *
+     * @param entityId - Unique identifier of the entity the file belongs to
+     * @param entityType - Type of entity ('profile', 'business', 'campaign', etc.)
+     * @param expireSeconds - Optional expiration time in seconds (default varies by implementation)
+     * @returns Promise resolving to signed download URL
+     * @throws Error if SDK is not initialized
+     *
+     * @example
+     * ```typescript
+     * const { getSignedGetUrl } = useFiles();
+     * const downloadUrl = await getSignedGetUrl('user-123', 'profile', 3600); // 1 hour expiry
+     * // Use downloadUrl to display or download the file
+     * ```
+     */
+    const getSignedGetUrl = useCallback(async (entityId, entityType, expireSeconds) => {
+        if (!isInitialized || !sdk) {
+            throw new Error('SDK not initialized. Call initialize() first.');
+        }
+        try {
+            const result = await sdk.files.getSignedGetUrl(entityId, entityType, expireSeconds);
+            console.log('Signed get URL generated successfully:', result);
+            return result;
+        }
+        catch (error) {
+            console.error('Failed to generate signed get URL:', error);
+            throw error;
+        }
+    }, [sdk, isInitialized]);
+    const getSignedUrl = useCallback(async (request) => {
+        if (!isInitialized || !sdk) {
+            throw new Error('SDK not initialized. Call initialize() first.');
+        }
+        try {
+            const result = await sdk.files.getSignedUrl(request);
+            console.log('Signed URL generated successfully:', result);
+            return result;
+        }
+        catch (error) {
+            console.error('Failed to generate signed URL:', error);
+            throw error;
+        }
+    }, [sdk, isInitialized]);
+    const optimizeMedia = useCallback(async (url, width, height) => {
+        if (!isInitialized || !sdk) {
+            throw new Error('SDK not initialized. Call initialize() first.');
+        }
+        try {
+            const result = await sdk.files.optimizeMedia(url, width, height);
+            console.log('Media optimized successfully:', result);
+            return result;
+        }
+        catch (error) {
+            console.error('Failed to optimize media:', error);
+            throw error;
+        }
+    }, [sdk, isInitialized]);
+    return {
+        getSignedPutUrl,
+        getSignedGetUrl,
+        getSignedUrl,
+        optimizeMedia,
+        isAvailable: isInitialized && !!sdk?.files,
+    };
+};

package/dist/hooks/usePurchases.d.ts

@@ -0,0 +1,9 @@
+import type { PurchaseTokenDTO, PurchaseDTO } 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[]>;
+    isAvailable: boolean;
+};
+export type PurchaseHook = ReturnType<typeof usePurchases>;
+//# sourceMappingURL=usePurchases.d.ts.map

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

@@ -0,0 +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;mCAgBiC,QAAQ,gBAAgB,EAAE,CAAC;+BAe/B,QAAQ,WAAW,EAAE,CAAC;;CAwBzE,CAAC;AAEF,MAAM,MAAM,YAAY,GAAG,UAAU,CAAC,OAAO,YAAY,CAAC,CAAC"}

package/dist/hooks/usePurchases.js

@@ -0,0 +1,56 @@
+import { useCallback } from 'react';
+import { usePersSDK } from '../providers/PersSDKProvider';
+export const usePurchases = () => {
+    const { sdk, isInitialized, isAuthenticated } = usePersSDK();
+    const createPaymentIntent = useCallback(async (amount, currency, receiptEmail, description) => {
+        if (!isInitialized || !sdk) {
+            throw new Error('SDK not initialized. Call initialize() first.');
+        }
+        try {
+            const result = await sdk.purchases.createPaymentIntent(amount, currency, receiptEmail, description);
+            console.log('Payment intent created successfully:', result);
+            return result;
+        }
+        catch (error) {
+            console.error('Failed to create payment intent:', error);
+            throw error;
+        }
+    }, [sdk, isInitialized]);
+    const getActivePurchaseTokens = useCallback(async () => {
+        if (!isInitialized || !sdk) {
+            throw new Error('SDK not initialized. Call initialize() first.');
+        }
+        try {
+            const result = await sdk.purchases.getActivePurchaseTokens();
+            console.log('Active purchase tokens fetched successfully:', result);
+            return result;
+        }
+        catch (error) {
+            console.error('Failed to fetch active purchase tokens:', error);
+            throw error;
+        }
+    }, [sdk, isInitialized]);
+    const getAllUserPurchases = useCallback(async () => {
+        if (!isInitialized || !sdk) {
+            throw new Error('SDK not initialized. Call initialize() first.');
+        }
+        if (!isAuthenticated) {
+            throw new Error('SDK not authenticated. getAllUserPurchases requires authentication.');
+        }
+        try {
+            const result = await sdk.purchases.getAllUserPurchases();
+            console.log('User purchases fetched successfully:', result);
+            return result;
+        }
+        catch (error) {
+            console.error('Failed to fetch user purchases:', error);
+            throw error;
+        }
+    }, [sdk, isInitialized, isAuthenticated]);
+    return {
+        createPaymentIntent,
+        getActivePurchaseTokens,
+        getAllUserPurchases,
+        isAvailable: isInitialized && !!sdk?.purchases,
+    };
+};

package/dist/hooks/useRedemptions.d.ts

@@ -1,9 +1,14 @@
+import type { RedemptionCreateRequestDTO, RedemptionDTO, RedemptionRedeemDTO, RedemptionRedeemRequestResponseDTO, RedemptionTypeDTO } from '@explorins/pers-shared';
 export declare const useRedemptions: () => {
-    createRedemption: (redemptionData: any) => Promise<any>;
-    getActiveRedemptions: () => Promise<any>;
-    getUserRedeems: () => Promise<any>;
-    redeemRedemption: (redemptionId: string) => Promise<any>;
-    getRedemptionById: (redemptionId: string) => Promise<any>;
+    getActiveRedemptions: () => Promise<RedemptionDTO[]>;
+    getUserRedemptions: () => Promise<RedemptionRedeemDTO[]>;
+    redeemOffer: (redemptionId: string) => Promise<RedemptionRedeemRequestResponseDTO>;
+    getRedemptionTypes: () => Promise<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;
 };
+export type RedemptionHook = ReturnType<typeof useRedemptions>;
 //# sourceMappingURL=useRedemptions.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"useRedemptions.d.ts","sourceRoot":"","sources":["../../src/hooks/useRedemptions.ts"],"names":[],"mappings":"AAGA,eAAO,MAAM,cAAc;uCAImC,GAAG;;;qCA6DL,MAAM;sCAkCL,MAAM;;CA0BlE,CAAC"}
+{"version":3,"file":"useRedemptions.d.ts","sourceRoot":"","sources":["../../src/hooks/useRedemptions.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EACV,0BAA0B,EAC1B,aAAa,EACb,mBAAmB,EACnB,kCAAkC,EAClC,iBAAiB,EAElB,MAAM,wBAAwB,CAAC;AAEhC,eAAO,MAAM,cAAc;gCAI0B,QAAQ,aAAa,EAAE,CAAC;8BAe1B,QAAQ,mBAAmB,EAAE,CAAC;gCAmB1B,MAAM,KAAG,QAAQ,kCAAkC,CAAC;8BAsFxD,QAAQ,iBAAiB,EAAE,CAAC;uCA/BjB,0BAA0B,KAAG,QAAQ,aAAa,CAAC;iCAgBzD,OAAO,KAAG,QAAQ,aAAa,EAAE,CAAC;qCA8B9B,MAAM,kBAAkB,0BAA0B,KAAG,QAAQ,aAAa,CAAC;2CAerE,MAAM,KAAG,QAAQ,aAAa,CAAC;;CA0BhG,CAAC;AAEF,MAAM,MAAM,cAAc,GAAG,UAAU,CAAC,OAAO,cAAc,CAAC,CAAC"}

package/dist/hooks/useRedemptions.js

@@ -1,121 +1,173 @@
 import { useCallback } from 'react';
 import { usePersSDK } from '../providers/PersSDKProvider';
+import { useTransactionSigner } from './useTransactionSigner';
 export const useRedemptions = () => {
-    const { redemptions, isInitialized, isAuthenticated } = usePersSDK();
-    // Admin method: Create new redemption offers
-    const createRedemption = useCallback(async (redemptionData) => {
-        if (!isInitialized) {
+    const { sdk, isInitialized, isAuthenticated } = usePersSDK();
+    const { signTransaction, isSignerAvailable } = useTransactionSigner();
+    const getActiveRedemptions = useCallback(async () => {
+        if (!isInitialized || !sdk) {
             throw new Error('SDK not initialized. Call initialize() first.');
         }
-        if (!redemptions?.createRedemption) {
-            throw new Error('createRedemption method not available - admin access required');
-        }
         try {
-            console.log('🔄 Creating redemption offer with data:', redemptionData);
-            const result = await redemptions.createRedemption(redemptionData);
-            console.log('✅ Redemption offer created successfully:', result);
+            const result = await sdk.redemptions.getActiveRedemptions();
+            console.log('Active redemptions fetched successfully:', result);
             return result;
         }
         catch (error) {
-            console.error('❌ Failed to create redemption offer:', error);
+            console.error('Failed to fetch active redemptions:', error);
             throw error;
         }
-    }, [redemptions]);
-    const getActiveRedemptions = useCallback(async () => {
-        if (!isInitialized) {
+    }, [sdk, isInitialized]);
+    const getUserRedemptions = useCallback(async () => {
+        if (!isInitialized || !sdk) {
             throw new Error('SDK not initialized. Call initialize() first.');
         }
-        if (!redemptions?.getActiveRedemptions) {
-            console.warn('getActiveRedemptions method not available');
+        if (!isAuthenticated) {
+            console.warn('SDK not authenticated. getUserRedemptions requires authentication.');
             return [];
         }
         try {
-            const result = await redemptions.getActiveRedemptions();
-            console.log('✅ Active redemptions fetched successfully:', result);
+            const result = await sdk.redemptions.getUserRedemptions();
+            console.log('User redemptions fetched successfully:', result);
             return result;
         }
         catch (error) {
-            console.error('❌ Failed to fetch active redemptions:', error);
+            console.error('Failed to fetch user redemptions:', error);
             throw error;
         }
-    }, [redemptions]);
-    const getUserRedeems = useCallback(async () => {
-        if (!isInitialized) {
+    }, [sdk, isInitialized, isAuthenticated]);
+    const redeemOffer = useCallback(async (redemptionId) => {
+        if (!isInitialized || !sdk) {
             throw new Error('SDK not initialized. Call initialize() first.');
         }
         if (!isAuthenticated) {
-            console.warn('SDK not authenticated. getUserRedeems requires authentication.');
-            return [];
+            throw new Error('SDK not authenticated. redeemOffer requires authentication.');
         }
-        if (!redemptions?.getUserRedeems) {
-            console.warn('getUserRedeems method not available');
-            return [];
+        try {
+            console.log('Redeeming redemption:', redemptionId);
+            const result = await sdk.redemptions.redeemOffer(redemptionId);
+            // Check if result has signing fields and sign transaction if required and signer is available
+            console.log('Redemption processed successfully:', result);
+            const txToken = result.senderTransaction?.actionable?.authToken;
+            if (txToken && isSignerAvailable) {
+                console.log('Transaction requires blockchain signing, processing with WebAuthn signer...');
+                try {
+                    const signingResult = await signTransaction(txToken);
+                    console.log('Blockchain signing result:', signingResult);
+                    if (signingResult.success) {
+                        console.log('Transaction signed successfully:', signingResult.transactionHash);
+                        // Return enhanced result with signing information
+                        return {
+                            ...result,
+                            transactionHash: signingResult.transactionHash,
+                            signature: signingResult.signature,
+                            isSigned: true,
+                            signedAt: new Date().toISOString()
+                        };
+                    }
+                    else {
+                        console.error('Transaction signing failed:', signingResult.error);
+                        throw new Error(signingResult.error || 'Transaction signing failed');
+                    }
+                }
+                catch (signingError) {
+                    console.error('Blockchain signing error:', signingError);
+                    throw new Error(`Transaction signing failed: ${signingError}`);
+                }
+            }
+            else if (txToken && !isSignerAvailable) {
+                console.warn('Transaction requires signature but signer is not available');
+                throw new Error('Transaction requires signature but blockchain signer is not initialized');
+            }
+            // Return original result if no signing was required
+            return result;
+        }
+        catch (error) {
+            console.error('Failed to redeem redemption:', error);
+            throw error;
+        }
+    }, [sdk, isInitialized, isAuthenticated, signTransaction, isSignerAvailable]);
+    // Admin methods
+    const createRedemption = useCallback(async (redemptionData) => {
+        if (!isInitialized || !sdk) {
+            throw new Error('SDK not initialized. Call initialize() first.');
         }
         try {
-            const result = await redemptions.getUserRedeems();
-            console.log('✅ User redemptions fetched successfully:', result);
+            console.log('Creating redemption offer with data:', redemptionData);
+            const result = await sdk.redemptions.createRedemption(redemptionData);
+            console.log('Redemption offer created successfully:', result);
             return result;
         }
         catch (error) {
-            console.error('❌ Failed to fetch user redemptions:', error);
+            console.error('Failed to create redemption offer:', error);
             throw error;
         }
-    }, [isInitialized, isAuthenticated, redemptions]);
-    const redeemRedemption = useCallback(async (redemptionId) => {
-        if (!isInitialized) {
+    }, [sdk, isInitialized]);
+    const getAllRedemptions = useCallback(async (active) => {
+        if (!isInitialized || !sdk) {
             throw new Error('SDK not initialized. Call initialize() first.');
         }
-        if (!isAuthenticated) {
-            throw new Error('SDK not authenticated. redeemRedemption requires authentication.');
+        try {
+            const result = await sdk.redemptions.getAllRedemptions(active);
+            console.log('All redemptions fetched successfully:', result);
+            return result;
+        }
+        catch (error) {
+            console.error('Failed to fetch all redemptions:', error);
+            throw error;
         }
-        if (!redemptions?.redeemRedemption) {
-            throw new Error('redeemRedemption method not available');
+    }, [sdk, isInitialized]);
+    const getRedemptionTypes = useCallback(async () => {
+        if (!isInitialized || !sdk) {
+            throw new Error('SDK not initialized. Call initialize() first.');
         }
         try {
-            console.log('🔄 Redeeming redemption:', redemptionId);
-            const result = await redemptions.redeemRedemption(redemptionId);
-            // React Native specific: Handle signature URLs for redemptions
-            if (result?.actionable?.actionUrl) {
-                try {
-                    const { Linking } = require('react-native');
-                    console.log('🔗 Opening redemption signature URL:', result.actionable.actionUrl);
-                    await Linking.openURL(result.actionable.actionUrl);
-                }
-                catch (linkingError) {
-                    console.error('❌ Failed to open redemption signature URL:', linkingError);
-                }
-            }
-            console.log('✅ Redemption processed successfully:', result);
+            const result = await sdk.redemptions.getRedemptionTypes();
+            console.log('Redemption types fetched successfully:', result);
             return result;
         }
         catch (error) {
-            console.error('❌ Failed to redeem redemption:', error);
+            console.error('Failed to fetch redemption types:', error);
             throw error;
         }
-    }, [isInitialized, isAuthenticated, redemptions]);
-    const getRedemptionById = useCallback(async (redemptionId) => {
-        if (!isInitialized) {
+    }, [sdk, isInitialized]);
+    const updateRedemption = useCallback(async (redemptionId, redemptionData) => {
+        if (!isInitialized || !sdk) {
             throw new Error('SDK not initialized. Call initialize() first.');
         }
-        if (!redemptions?.getRedemptionById) {
-            throw new Error('getRedemptionById method not available');
+        try {
+            const result = await sdk.redemptions.updateRedemption(redemptionId, redemptionData);
+            console.log('Redemption updated successfully:', result);
+            return result;
+        }
+        catch (error) {
+            console.error('Failed to update redemption:', error);
+            throw error;
+        }
+    }, [sdk, isInitialized]);
+    const toggleRedemptionStatus = useCallback(async (redemptionId) => {
+        if (!isInitialized || !sdk) {
+            throw new Error('SDK not initialized. Call initialize() first.');
         }
         try {
-            const result = await redemptions.getRedemptionById(redemptionId);
-            console.log('✅ Redemption fetched successfully:', result);
+            const result = await sdk.redemptions.toggleRedemptionStatus(redemptionId);
+            console.log('Redemption status toggled successfully:', result);
             return result;
         }
         catch (error) {
-            console.error('❌ Failed to fetch redemption:', error);
+            console.error('Failed to toggle redemption status:', error);
             throw error;
         }
-    }, [redemptions]);
+    }, [sdk, isInitialized]);
     return {
-        createRedemption,
         getActiveRedemptions,
-        getUserRedeems,
-        redeemRedemption,
-        getRedemptionById,
-        isAvailable: isInitialized && !!redemptions,
+        getUserRedemptions,
+        redeemOffer,
+        getRedemptionTypes,
+        createRedemption,
+        getAllRedemptions,
+        updateRedemption,
+        toggleRedemptionStatus,
+        isAvailable: isInitialized && !!sdk?.redemptions,
     };
 };

package/dist/hooks/useTenants.d.ts

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

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

@@ -0,0 +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;2BAetB,QAAQ,qBAAqB,CAAC;yBAehC,QAAQ,MAAM,CAAC;qBAenB,QAAQ,QAAQ,EAAE,CAAC;;CAsB5D,CAAC;AAEF,MAAM,MAAM,UAAU,GAAG,UAAU,CAAC,OAAO,UAAU,CAAC,CAAC"}

package/dist/hooks/useTenants.js

@@ -0,0 +1,68 @@
+import { useCallback } from 'react';
+import { usePersSDK } from '../providers/PersSDKProvider';
+export const useTenants = () => {
+    const { sdk, isInitialized } = usePersSDK();
+    const getTenantInfo = useCallback(async () => {
+        if (!isInitialized || !sdk) {
+            throw new Error('SDK not initialized. Call initialize() first.');
+        }
+        try {
+            const result = await sdk.tenants.getTenantInfo();
+            console.log('Tenant info fetched successfully:', result);
+            return result;
+        }
+        catch (error) {
+            console.error('Failed to fetch tenant info:', error);
+            throw error;
+        }
+    }, [sdk, isInitialized]);
+    const getClientConfig = useCallback(async () => {
+        if (!isInitialized || !sdk) {
+            throw new Error('SDK not initialized. Call initialize() first.');
+        }
+        try {
+            const result = await sdk.tenants.getClientConfig();
+            console.log('Client config fetched successfully:', result);
+            return result;
+        }
+        catch (error) {
+            console.error('Failed to fetch client config:', error);
+            throw error;
+        }
+    }, [sdk, isInitialized]);
+    const getLoginToken = useCallback(async () => {
+        if (!isInitialized || !sdk) {
+            throw new Error('SDK not initialized. Call initialize() first.');
+        }
+        try {
+            const result = await sdk.tenants.getLoginToken();
+            console.log('Login token fetched successfully');
+            return result;
+        }
+        catch (error) {
+            console.error('Failed to fetch login token:', error);
+            throw error;
+        }
+    }, [sdk, isInitialized]);
+    const getAdmins = useCallback(async () => {
+        if (!isInitialized || !sdk) {
+            throw new Error('SDK not initialized. Call initialize() first.');
+        }
+        try {
+            const result = await sdk.tenants.getAdmins();
+            console.log('Admins fetched successfully:', result);
+            return result;
+        }
+        catch (error) {
+            console.error('Failed to fetch admins:', error);
+            throw error;
+        }
+    }, [sdk, isInitialized]);
+    return {
+        getTenantInfo,
+        getClientConfig,
+        getLoginToken,
+        getAdmins,
+        isAvailable: isInitialized && !!sdk?.tenants,
+    };
+};

package/dist/hooks/useTokens.d.ts

@@ -1,6 +1,40 @@
+import type { TokenDTO } from '@explorins/pers-shared';
+/**
+ * React hook for token operations in the PERS SDK
+ *
+ * Provides methods for fetching various types of tokens including credit, reward, and status tokens.
+ * Supports both general token queries and specific contract-based token retrieval.
+ *
+ * @returns Token hook with methods for token management
+ *
+ * @example
+ * ```typescript
+ * function TokensComponent() {
+ *   const { getTokens, getActiveCreditToken, getRewardTokens } = useTokens();
+ *
+ *   const loadTokens = async () => {
+ *     try {
+ *       const tokens = await getTokens();
+ *       const creditToken = await getActiveCreditToken();
+ *       console.log('Loaded tokens:', tokens);
+ *       console.log('Active credit token:', creditToken);
+ *     } catch (error) {
+ *       console.error('Failed to load tokens:', error);
+ *     }
+ *   };
+ *
+ *   return <button onClick={loadTokens}>Load Tokens</button>;
+ * }
+ * ```
+ */
 export declare const useTokens: () => {
-    getTokens: () => Promise<any>;
-    getTokenById: (tokenId: string) => Promise<any>;
+    getTokens: () => Promise<TokenDTO[]>;
+    getActiveCreditToken: () => Promise<TokenDTO>;
+    getRewardTokens: () => Promise<TokenDTO[]>;
+    getTokenTypes: () => Promise<any>;
+    getStatusTokens: () => Promise<TokenDTO[]>;
+    getTokenByContract: (contractAddress: string, contractTokenId?: string | null) => Promise<TokenDTO>;
     isAvailable: boolean;
 };
+export type TokenHook = ReturnType<typeof useTokens>;
 //# sourceMappingURL=useTokens.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"useTokens.d.ts","sourceRoot":"","sources":["../../src/hooks/useTokens.ts"],"names":[],"mappings":"AAGA,eAAO,MAAM,SAAS;;4BA0B6B,MAAM;;CAuBxD,CAAC"}
+{"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;gCA4BR,QAAQ,QAAQ,CAAC;2BA4BtB,QAAQ,QAAQ,EAAE,CAAC;yBA4BrB,QAAQ,GAAG,CAAC;2BA4BV,QAAQ,QAAQ,EAAE,CAAC;0CA8BF,MAAM,oBAAoB,MAAM,GAAG,IAAI,KAAG,QAAQ,QAAQ,CAAC;;CAwB3H,CAAC;AAEF,MAAM,MAAM,SAAS,GAAG,UAAU,CAAC,OAAO,SAAS,CAAC,CAAC"}