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

package/dist/hooks/useTokens.js

@@ -1,48 +1,209 @@
 import { useCallback } from 'react';
 import { usePersSDK } from '../providers/PersSDKProvider';
+/**
+ * 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 const useTokens = () => {
-    const { tokens, isInitialized, isAuthenticated } = usePersSDK();
+    const { sdk, isInitialized, isAuthenticated } = usePersSDK();
     if (!isAuthenticated && isInitialized) {
         console.warn('SDK not authenticated. Some token operations may fail.');
     }
+    /**
+     * Retrieves all tokens available to the current user
+     *
+     * @returns Promise resolving to array of tokens
+     * @throws Error if SDK is not initialized
+     *
+     * @example
+     * ```typescript
+     * const { getTokens } = useTokens();
+     * const tokens = await getTokens();
+     * console.log('Available tokens:', tokens);
+     * ```
+     */
     const getTokens = useCallback(async () => {
-        if (!isInitialized) {
+        if (!isInitialized || !sdk) {
             throw new Error('SDK not initialized. Call initialize() first.');
         }
-        if (!tokens?.getTokens) {
-            console.warn('getTokens method not available');
-            return [];
+        try {
+            const result = await sdk.tokens.getTokens();
+            console.log('Tokens fetched successfully:', result);
+            return result;
+        }
+        catch (error) {
+            console.error('Failed to fetch tokens:', error);
+            throw error;
+        }
+    }, [sdk, isInitialized]);
+    /**
+     * Retrieves the currently active credit token
+     *
+     * @returns Promise resolving to active credit token
+     * @throws Error if SDK is not initialized
+     *
+     * @example
+     * ```typescript
+     * const { getActiveCreditToken } = useTokens();
+     * const creditToken = await getActiveCreditToken();
+     * console.log('Active credit token:', creditToken.name);
+     * ```
+     */
+    const getActiveCreditToken = useCallback(async () => {
+        if (!isInitialized || !sdk) {
+            throw new Error('SDK not initialized. Call initialize() first.');
+        }
+        try {
+            const result = await sdk.tokens.getActiveCreditToken();
+            console.log('Active credit token fetched successfully:', result);
+            return result;
+        }
+        catch (error) {
+            console.error('Failed to fetch active credit token:', error);
+            throw error;
+        }
+    }, [sdk, isInitialized]);
+    /**
+     * Retrieves all reward tokens available in the system
+     *
+     * @returns Promise resolving to array of reward tokens
+     * @throws Error if SDK is not initialized
+     *
+     * @example
+     * ```typescript
+     * const { getRewardTokens } = useTokens();
+     * const rewardTokens = await getRewardTokens();
+     * console.log('Reward tokens:', rewardTokens);
+     * ```
+     */
+    const getRewardTokens = useCallback(async () => {
+        if (!isInitialized || !sdk) {
+            throw new Error('SDK not initialized. Call initialize() first.');
         }
         try {
-            const result = await tokens.getTokens();
-            console.log('✅ Tokens fetched successfully:', result);
+            const result = await sdk.tokens.getRewardTokens();
+            console.log('Reward tokens fetched successfully:', result);
             return result;
         }
         catch (error) {
-            console.error('❌ Failed to fetch tokens:', error);
+            console.error('Failed to fetch reward tokens:', error);
             throw error;
         }
-    }, [tokens]);
-    const getTokenById = useCallback(async (tokenId) => {
-        if (!isInitialized) {
+    }, [sdk, isInitialized]);
+    /**
+     * Retrieves all available token types in the system
+     *
+     * @returns Promise resolving to array of token types
+     * @throws Error if SDK is not initialized
+     *
+     * @example
+     * ```typescript
+     * const { getTokenTypes } = useTokens();
+     * const types = await getTokenTypes();
+     * console.log('Token types:', types);
+     * ```
+     */
+    const getTokenTypes = useCallback(async () => {
+        if (!isInitialized || !sdk) {
             throw new Error('SDK not initialized. Call initialize() first.');
         }
-        if (!tokens?.getTokenById) {
-            throw new Error('getTokenById method not available');
+        try {
+            const result = await sdk.tokens.getTokenTypes();
+            console.log('Token types fetched successfully:', result);
+            return result;
+        }
+        catch (error) {
+            console.error('Failed to fetch token types:', error);
+            throw error;
+        }
+    }, [sdk, isInitialized]);
+    /**
+     * Retrieves all status tokens (tokens that represent user status/achievements)
+     *
+     * @returns Promise resolving to array of status tokens
+     * @throws Error if SDK is not initialized
+     *
+     * @example
+     * ```typescript
+     * const { getStatusTokens } = useTokens();
+     * const statusTokens = await getStatusTokens();
+     * console.log('Status tokens:', statusTokens);
+     * ```
+     */
+    const getStatusTokens = useCallback(async () => {
+        if (!isInitialized || !sdk) {
+            throw new Error('SDK not initialized. Call initialize() first.');
+        }
+        try {
+            const result = await sdk.tokens.getStatusTokens();
+            console.log('Status tokens fetched successfully:', result);
+            return result;
+        }
+        catch (error) {
+            console.error('Failed to fetch status tokens:', error);
+            throw error;
+        }
+    }, [sdk, isInitialized]);
+    /**
+     * Retrieves a specific token by its contract address and optional token ID
+     *
+     * @param contractAddress - The contract address of the token
+     * @param contractTokenId - Optional specific token ID within the contract
+     * @returns Promise resolving to the token data
+     * @throws Error if SDK is not initialized
+     *
+     * @example
+     * ```typescript
+     * const { getTokenByContract } = useTokens();
+     * const token = await getTokenByContract('0x123...', 'token-1');
+     * console.log('Token from contract:', token);
+     * ```
+     */
+    const getTokenByContract = useCallback(async (contractAddress, contractTokenId) => {
+        if (!isInitialized || !sdk) {
+            throw new Error('SDK not initialized. Call initialize() first.');
         }
         try {
-            const result = await tokens.getTokenById(tokenId);
-            console.log('✅ Token fetched successfully:', result);
+            const result = await sdk.tokens.getTokenByContract(contractAddress, contractTokenId);
+            console.log('Token by contract fetched successfully:', result);
             return result;
         }
         catch (error) {
-            console.error('❌ Failed to fetch token:', error);
+            console.error('Failed to fetch token by contract:', error);
             throw error;
         }
-    }, [tokens]);
+    }, [sdk, isInitialized]);
     return {
         getTokens,
-        getTokenById,
-        isAvailable: isInitialized && !!tokens,
+        getActiveCreditToken,
+        getRewardTokens,
+        getTokenTypes,
+        getStatusTokens,
+        getTokenByContract,
+        isAvailable: isInitialized && !!sdk?.tokens,
     };
 };

package/dist/hooks/useTransactions.d.ts

@@ -1,7 +1,49 @@
+import type { TransactionRequestDTO, TransactionRequestResponseDTO, TransactionDTO } from '@explorins/pers-shared';
+import type { TransactionPaginationParams } from '@explorins/pers-sdk/transaction';
+/**
+ * React hook for transaction operations in the PERS SDK
+ *
+ * Provides comprehensive transaction management including creation, retrieval, history,
+ * and administrative operations. Supports pagination and CSV export functionality.
+ *
+ * @returns Transaction hook with methods for transaction management
+ *
+ * @example
+ * ```typescript
+ * function TransactionsComponent() {
+ *   const {
+ *     createTransaction,
+ *     getUserTransactionHistory
+ *   } = useTransactions();
+ *
+ *   const handleCreateTransaction = async (request) => {
+ *     try {
+ *       const result = await createTransaction(request);
+ *       console.log('Transaction created:', result);
+ *       // Handle signature URL if returned
+ *     } catch (error) {
+ *       console.error('Transaction failed:', error);
+ *     }
+ *   };
+ *
+ *   return (
+ *     <div>
+ *       <button onClick={() => handleCreateTransaction(transactionRequest)}>
+ *         Create Transaction
+ *       </button>
+ *     </div>
+ *   );
+ * }
+ * ```
+ */
 export declare const useTransactions: () => {
-    createTransaction: (request: any) => Promise<any>;
-    getTransactionById: (transactionId: string) => Promise<any>;
-    getTransactionHistory: (filters?: any) => Promise<any>;
+    createTransaction: (request: TransactionRequestDTO) => Promise<TransactionRequestResponseDTO>;
+    getTransactionById: (transactionId: string) => Promise<TransactionDTO | null>;
+    getUserTransactionHistory: (type?: string) => Promise<TransactionDTO[]>;
+    getTenantTransactions: () => Promise<TransactionDTO[]>;
+    getPaginatedTransactions: (params: TransactionPaginationParams) => Promise<any>;
+    exportTransactionsCSV: () => Promise<Blob>;
     isAvailable: boolean;
 };
+export type TransactionHook = ReturnType<typeof useTransactions>;
 //# sourceMappingURL=useTransactions.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"useTransactions.d.ts","sourceRoot":"","sources":["../../src/hooks/useTransactions.ts"],"names":[],"mappings":"AAGA,eAAO,MAAM,eAAe;iCAO4B,GAAG;wCA+BI,MAAM;sCAkBR,GAAG;;CAyB/D,CAAC"}
+{"version":3,"file":"useTransactions.d.ts","sourceRoot":"","sources":["../../src/hooks/useTransactions.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EACV,qBAAqB,EACrB,6BAA6B,EAC7B,cAAc,EACf,MAAM,wBAAwB,CAAC;AAChC,OAAO,KAAK,EAAE,2BAA2B,EAAE,MAAM,iCAAiC,CAAC;AAMnF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAmCG;AACH,eAAO,MAAM,eAAe;iCA6B4B,qBAAqB,KAAG,QAAQ,6BAA6B,CAAC;wCA0CvD,MAAM,KAAG,QAAQ,cAAc,GAAG,IAAI,CAAC;uCA6BzC,MAAM,KAAW,QAAQ,cAAc,EAAE,CAAC;iCAejD,QAAQ,cAAc,EAAE,CAAC;uCAejB,2BAA2B,KAAG,QAAQ,GAAG,CAAC;iCAelD,QAAQ,IAAI,CAAC;;CAwBlE,CAAC;AAEF,MAAM,MAAM,eAAe,GAAG,UAAU,CAAC,OAAO,eAAe,CAAC,CAAC"}

package/dist/hooks/useTransactions.js

@@ -1,78 +1,199 @@
 import { useCallback } from 'react';
 import { usePersSDK } from '../providers/PersSDKProvider';
+/**
+ * React hook for transaction operations in the PERS SDK
+ *
+ * Provides comprehensive transaction management including creation, retrieval, history,
+ * and administrative operations. Supports pagination and CSV export functionality.
+ *
+ * @returns Transaction hook with methods for transaction management
+ *
+ * @example
+ * ```typescript
+ * function TransactionsComponent() {
+ *   const {
+ *     createTransaction,
+ *     getUserTransactionHistory
+ *   } = useTransactions();
+ *
+ *   const handleCreateTransaction = async (request) => {
+ *     try {
+ *       const result = await createTransaction(request);
+ *       console.log('Transaction created:', result);
+ *       // Handle signature URL if returned
+ *     } catch (error) {
+ *       console.error('Transaction failed:', error);
+ *     }
+ *   };
+ *
+ *   return (
+ *     <div>
+ *       <button onClick={() => handleCreateTransaction(transactionRequest)}>
+ *         Create Transaction
+ *       </button>
+ *     </div>
+ *   );
+ * }
+ * ```
+ */
 export const useTransactions = () => {
-    const { transactions, isInitialized, isAuthenticated } = usePersSDK();
+    const { sdk, isInitialized, isAuthenticated } = usePersSDK();
     if (!isAuthenticated && isInitialized) {
         console.warn('SDK not authenticated. Some transaction operations may fail.');
     }
+    /**
+     * Creates a new transaction in the system
+     *
+     * Automatically handles signature URLs by opening them in the device's browser.
+     * The transaction may require user approval through external wallet applications.
+     *
+     * @param request - Transaction request data including amount, recipient, etc.
+     * @returns Promise resolving to transaction response with potential actionable items
+     * @throws Error if SDK is not initialized
+     *
+     * @example
+     * ```typescript
+     * const { createTransaction } = useTransactions();
+     * const request = {
+     *   amount: '100',
+     *   recipient: '0x123...',
+     *   tokenId: 'token-123'
+     * };
+     * const result = await createTransaction(request);
+     * console.log('Transaction created:', result);
+     * ```
+     */
     const createTransaction = useCallback(async (request) => {
-        if (!isInitialized) {
+        if (!isInitialized || !sdk) {
             throw new Error('SDK not initialized. Call initialize() first.');
         }
-        if (!transactions?.createTransaction) {
-            throw new Error('createTransaction method not available');
-        }
         try {
-            console.log('🔄 Creating transaction with request:', request);
-            const result = await transactions.createTransaction(request);
-            // React Native specific: Handle signature URLs
+            console.log('Creating transaction with request:', request);
+            const result = await sdk.transactions.createTransaction(request);
+            // Cross-platform: Handle signature URLs
             if (result?.actionable?.actionUrl) {
                 try {
                     const { Linking } = require('react-native');
-                    console.log('🔗 Opening signature URL:', result.actionable.actionUrl);
+                    console.log('Opening signature URL:', result.actionable.actionUrl);
                     await Linking.openURL(result.actionable.actionUrl);
                 }
                 catch (linkingError) {
-                    console.error('❌ Failed to open signature URL:', linkingError);
+                    console.error('Failed to open signature URL:', linkingError);
                 }
             }
-            console.log('✅ Transaction created successfully:', result);
+            console.log('Transaction created successfully:', result);
             return result;
         }
         catch (error) {
-            console.error('❌ Failed to create transaction:', error);
+            console.error('Failed to create transaction:', error);
             throw error;
         }
-    }, [transactions]);
+    }, [sdk, isInitialized]);
+    /**
+     * Retrieves a specific transaction by its ID
+     *
+     * @param transactionId - Unique identifier of the transaction
+     * @returns Promise resolving to transaction data or null if not found
+     * @throws Error if SDK is not initialized
+     *
+     * @example
+     * ```typescript
+     * const { getTransactionById } = useTransactions();
+     * const transaction = await getTransactionById('txn-123');
+     * console.log('Transaction details:', transaction);
+     * ```
+     */
     const getTransactionById = useCallback(async (transactionId) => {
-        if (!isInitialized) {
+        if (!isInitialized || !sdk) {
             throw new Error('SDK not initialized. Call initialize() first.');
         }
-        if (!transactions?.getTransactionById) {
-            throw new Error('getTransactionById method not available');
+        try {
+            const result = await sdk.transactions.getTransactionById(transactionId);
+            console.log('Transaction fetched successfully:', result);
+            return result;
+        }
+        catch (error) {
+            console.error('Failed to fetch transaction:', error);
+            throw error;
+        }
+    }, [sdk, isInitialized]);
+    /**
+     * Retrieves transaction history for the authenticated user, filtered by type
+     *
+     * @param type - Transaction type filter (defaults to 'all')
+     * @returns Promise resolving to array of user's transactions
+     * @throws Error if SDK is not initialized
+     *
+     * @example
+     * ```typescript
+     * const { getUserTransactionHistory } = useTransactions();
+     * const transactions = await getUserTransactionHistory('credit');
+     * console.log('Credit transactions:', transactions);
+     * ```
+     */
+    const getUserTransactionHistory = useCallback(async (type = 'all') => {
+        if (!isInitialized || !sdk) {
+            throw new Error('SDK not initialized. Call initialize() first.');
         }
         try {
-            const result = await transactions.getTransactionById(transactionId);
-            console.log('✅ Transaction fetched successfully:', result);
+            const result = await sdk.transactions.getUserTransactionHistory(type);
+            console.log('Transaction history fetched successfully:', result);
             return result;
         }
         catch (error) {
-            console.error('❌ Failed to fetch transaction:', error);
+            console.error('Failed to fetch transaction history:', error);
             throw error;
         }
-    }, [transactions]);
-    const getTransactionHistory = useCallback(async (filters) => {
-        if (!isInitialized) {
+    }, [sdk, isInitialized]);
+    const getTenantTransactions = useCallback(async () => {
+        if (!isInitialized || !sdk) {
             throw new Error('SDK not initialized. Call initialize() first.');
         }
-        if (!transactions?.getTransactionHistory) {
-            console.warn('getTransactionHistory method not available');
-            return [];
+        try {
+            const result = await sdk.transactions.getTenantTransactions();
+            console.log('Tenant transactions fetched successfully:', result);
+            return result;
+        }
+        catch (error) {
+            console.error('Failed to fetch tenant transactions:', error);
+            throw error;
+        }
+    }, [sdk, isInitialized]);
+    const getPaginatedTransactions = useCallback(async (params) => {
+        if (!isInitialized || !sdk) {
+            throw new Error('SDK not initialized. Call initialize() first.');
+        }
+        try {
+            const result = await sdk.transactions.getPaginatedTransactions(params);
+            console.log('Paginated transactions fetched successfully:', result);
+            return result;
+        }
+        catch (error) {
+            console.error('Failed to fetch paginated transactions:', error);
+            throw error;
+        }
+    }, [sdk, isInitialized]);
+    const exportTransactionsCSV = useCallback(async () => {
+        if (!isInitialized || !sdk) {
+            throw new Error('SDK not initialized. Call initialize() first.');
         }
         try {
-            const result = await transactions.getTransactionHistory(filters);
-            console.log('✅ Transaction history fetched successfully:', result);
+            const result = await sdk.transactions.exportTransactionsCSV();
+            console.log('Transactions CSV exported successfully');
             return result;
         }
         catch (error) {
-            console.error('❌ Failed to fetch transaction history:', error);
+            console.error('Failed to export transactions CSV:', error);
             throw error;
         }
-    }, [transactions]);
+    }, [sdk, isInitialized]);
     return {
         createTransaction,
         getTransactionById,
-        getTransactionHistory,
-        isAvailable: isInitialized && !!transactions,
+        getUserTransactionHistory,
+        getTenantTransactions,
+        getPaginatedTransactions,
+        exportTransactionsCSV,
+        isAvailable: isInitialized && !!sdk?.transactions,
     };
 };

package/dist/hooks/useUserStatus.d.ts

@@ -0,0 +1,9 @@
+import type { UserStatusTypeDTO } from '@explorins/pers-shared';
+export declare const useUserStatus: () => {
+    getUserStatusTypes: () => Promise<UserStatusTypeDTO[]>;
+    getEarnedUserStatus: () => Promise<UserStatusTypeDTO[]>;
+    createUserStatusType: (userStatusType: UserStatusTypeDTO) => Promise<UserStatusTypeDTO>;
+    isAvailable: boolean;
+};
+export type UserStatusHook = ReturnType<typeof useUserStatus>;
+//# sourceMappingURL=useUserStatus.d.ts.map

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

@@ -0,0 +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;+BAe3B,QAAQ,iBAAiB,EAAE,CAAC;2CAmBd,iBAAiB,KAAG,QAAQ,iBAAiB,CAAC;;CAqB/G,CAAC;AAEF,MAAM,MAAM,cAAc,GAAG,UAAU,CAAC,OAAO,aAAa,CAAC,CAAC"}

package/dist/hooks/useUserStatus.js

@@ -0,0 +1,57 @@
+import { useCallback } from 'react';
+import { usePersSDK } from '../providers/PersSDKProvider';
+export const useUserStatus = () => {
+    const { sdk, isInitialized, isAuthenticated } = usePersSDK();
+    const getUserStatusTypes = useCallback(async () => {
+        if (!isInitialized || !sdk) {
+            throw new Error('SDK not initialized. Call initialize() first.');
+        }
+        try {
+            const result = await sdk.userStatus.getUserStatusTypes();
+            console.log('User status types fetched successfully:', result);
+            return result;
+        }
+        catch (error) {
+            console.error('Failed to fetch user status types:', error);
+            throw error;
+        }
+    }, [sdk, isInitialized]);
+    const getEarnedUserStatus = useCallback(async () => {
+        if (!isInitialized || !sdk) {
+            throw new Error('SDK not initialized. Call initialize() first.');
+        }
+        if (!isAuthenticated) {
+            throw new Error('SDK not authenticated. getEarnedUserStatus requires authentication.');
+        }
+        try {
+            const result = await sdk.userStatus.getEarnedUserStatus();
+            console.log('Earned user status fetched successfully:', result);
+            return result;
+        }
+        catch (error) {
+            console.error('Failed to fetch earned user status:', error);
+            throw error;
+        }
+    }, [sdk, isInitialized, isAuthenticated]);
+    // Admin methods
+    const createUserStatusType = useCallback(async (userStatusType) => {
+        if (!isInitialized || !sdk) {
+            throw new Error('SDK not initialized. Call initialize() first.');
+        }
+        try {
+            const result = await sdk.userStatus.createUserStatusType(userStatusType);
+            console.log('User status type created successfully:', result);
+            return result;
+        }
+        catch (error) {
+            console.error('Failed to create user status type:', error);
+            throw error;
+        }
+    }, [sdk, isInitialized]);
+    return {
+        getUserStatusTypes,
+        getEarnedUserStatus,
+        createUserStatusType,
+        isAvailable: isInitialized && !!sdk?.userStatus,
+    };
+};

package/dist/hooks/useUsers.d.ts

@@ -0,0 +1,17 @@
+import type { UserDTO, UserCreateRequestDTO } from '@explorins/pers-shared';
+import type { UserPublicProfileDTO } from '@explorins/pers-sdk/user';
+export declare const useUsers: () => {
+    getCurrentUser: () => Promise<UserDTO>;
+    updateCurrentUser: (userData: UserCreateRequestDTO) => Promise<UserDTO>;
+    getUserById: (userId: string) => Promise<UserDTO>;
+    getAllUsersPublic: (filter?: {
+        key: string;
+        value: string;
+    }) => Promise<UserPublicProfileDTO[]>;
+    getAllUsers: () => Promise<UserDTO[]>;
+    updateUser: (userId: string, userData: UserCreateRequestDTO) => Promise<UserDTO>;
+    toggleUserStatus: (user: UserDTO) => Promise<UserDTO>;
+    isAvailable: boolean;
+};
+export type UserHook = ReturnType<typeof useUsers>;
+//# sourceMappingURL=useUsers.d.ts.map

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

@@ -0,0 +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;kCAkBN,oBAAoB,KAAG,QAAQ,OAAO,CAAC;0BAkB/C,MAAM,KAAG,QAAQ,OAAO,CAAC;iCAelB;QAAE,GAAG,EAAE,MAAM,CAAC;QAAC,KAAK,EAAE,MAAM,CAAA;KAAE,KAAG,QAAQ,oBAAoB,EAAE,CAAC;uBAgB5E,QAAQ,OAAO,EAAE,CAAC;yBAed,MAAM,YAAY,oBAAoB,KAAG,QAAQ,OAAO,CAAC;6BAerD,OAAO,KAAG,QAAQ,OAAO,CAAC;;CAyB7E,CAAC;AAEF,MAAM,MAAM,QAAQ,GAAG,UAAU,CAAC,OAAO,QAAQ,CAAC,CAAC"}