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

package/dist/hooks/useBusiness.js

@@ -1,64 +1,218 @@
 import { useCallback } from 'react';
 import { usePersSDK } from '../providers/PersSDKProvider';
+/**
+ * React hook for business operations in the PERS SDK
+ *
+ * Provides methods for fetching, creating, and managing businesses within the platform.
+ * Includes both public business queries and administrative operations.
+ *
+ * @returns Business hook with methods for business management
+ *
+ * @example
+ * ```typescript
+ * function BusinessesComponent() {
+ *   const {
+ *     getActiveBusinesses,
+ *     getBusinessById,
+ *     createBusiness
+ *   } = useBusiness();
+ *
+ *   const loadBusinesses = async () => {
+ *     try {
+ *       const businesses = await getActiveBusinesses();
+ *       console.log('Active businesses:', businesses);
+ *     } catch (error) {
+ *       console.error('Failed to load businesses:', error);
+ *     }
+ *   };
+ *
+ *   return (
+ *     <div>
+ *       <button onClick={loadBusinesses}>Load Businesses</button>
+ *     </div>
+ *   );
+ * }
+ * ```
+ */
 export const useBusiness = () => {
-    const { business, isInitialized } = usePersSDK();
+    const { sdk, isInitialized } = usePersSDK();
+    /**
+     * Retrieves all currently active businesses in the system
+     *
+     * @returns Promise resolving to array of active businesses
+     * @throws Error if SDK is not initialized
+     *
+     * @example
+     * ```typescript
+     * const { getActiveBusinesses } = useBusiness();
+     * const businesses = await getActiveBusinesses();
+     * console.log('Active businesses:', businesses);
+     * ```
+     */
     const getActiveBusinesses = useCallback(async () => {
-        if (!isInitialized) {
+        if (!isInitialized || !sdk) {
             throw new Error('SDK not initialized. Call initialize() first.');
         }
-        if (!business?.getActiveBusinesses) {
-            console.warn('getActiveBusinesses method not available');
-            return [];
+        try {
+            const result = await sdk.businesses.getActiveBusinesses();
+            console.log('Active businesses fetched successfully:', result);
+            return result;
+        }
+        catch (error) {
+            console.error('Failed to fetch active businesses:', error);
+            throw error;
+        }
+    }, [sdk, isInitialized]);
+    /**
+     * Retrieves all available business types/categories
+     *
+     * @returns Promise resolving to array of business types
+     * @throws Error if SDK is not initialized
+     *
+     * @example
+     * ```typescript
+     * const { getBusinessTypes } = useBusiness();
+     * const types = await getBusinessTypes();
+     * console.log('Business types:', types);
+     * ```
+     */
+    const getBusinessTypes = useCallback(async () => {
+        if (!isInitialized || !sdk) {
+            throw new Error('SDK not initialized. Call initialize() first.');
+        }
+        try {
+            const result = await sdk.businesses.getBusinessTypes();
+            console.log('Business types fetched successfully:', result);
+            return result;
+        }
+        catch (error) {
+            console.error('Failed to fetch business types:', error);
+            throw error;
+        }
+    }, [sdk, isInitialized]);
+    const getBusinessById = useCallback(async (businessId) => {
+        if (!isInitialized || !sdk) {
+            throw new Error('SDK not initialized. Call initialize() first.');
         }
         try {
-            const result = await business.getActiveBusinesses();
-            console.log('✅ Active businesses fetched successfully:', result);
+            const result = await sdk.businesses.getBusinessById(businessId);
+            console.log('Business fetched successfully:', result);
             return result;
         }
         catch (error) {
-            console.error('❌ Failed to fetch active businesses:', error);
+            console.error('Failed to fetch business:', error);
             throw error;
         }
-    }, [business]);
-    const getAllBusinessTypes = useCallback(async () => {
-        if (!isInitialized) {
+    }, [sdk, isInitialized]);
+    const getBusinesses = useCallback(async () => {
+        if (!isInitialized || !sdk) {
             throw new Error('SDK not initialized. Call initialize() first.');
         }
-        if (!business?.getAllBusinessTypes) {
-            console.warn('getAllBusinessTypes method not available');
-            return [];
+        try {
+            const result = await sdk.businesses.getBusinesses();
+            console.log('All businesses fetched successfully:', result);
+            return result;
+        }
+        catch (error) {
+            console.error('Failed to fetch all businesses:', error);
+            throw error;
+        }
+    }, [sdk, isInitialized]);
+    const getBusinessByAccount = useCallback(async (accountAddress) => {
+        if (!isInitialized || !sdk) {
+            throw new Error('SDK not initialized. Call initialize() first.');
         }
         try {
-            const result = await business.getAllBusinessTypes();
-            console.log('✅ Business types fetched successfully:', result);
+            const result = await sdk.businesses.getBusinessByAccount(accountAddress);
+            console.log('Business by account fetched successfully:', result);
             return result;
         }
         catch (error) {
-            console.error('❌ Failed to fetch business types:', error);
+            console.error('Failed to fetch business by account:', error);
             throw error;
         }
-    }, [business]);
-    const getBusinessById = useCallback(async (businessId) => {
-        if (!isInitialized) {
+    }, [sdk, isInitialized]);
+    const getBusinessesByType = useCallback(async (typeId) => {
+        if (!isInitialized || !sdk) {
             throw new Error('SDK not initialized. Call initialize() first.');
         }
-        if (!business?.getBusinessById) {
-            throw new Error('getBusinessById method not available');
+        try {
+            const result = await sdk.businesses.getBusinessesByType(typeId);
+            console.log('Businesses by type fetched successfully:', result);
+            return result;
+        }
+        catch (error) {
+            console.error('Failed to fetch businesses by type:', error);
+            throw error;
+        }
+    }, [sdk, isInitialized]);
+    // Admin methods
+    /**
+     * Creates a new business (Admin operation)
+     *
+     * @param displayName - The display name for the new business
+     * @returns Promise resolving to the created business data
+     * @throws Error if SDK is not initialized or user lacks permissions
+     *
+     * @example
+     * ```typescript
+     * const { createBusiness } = useBusiness();
+     * const business = await createBusiness('My Coffee Shop');
+     * console.log('Business created:', business);
+     * ```
+     */
+    const createBusiness = useCallback(async (displayName) => {
+        if (!isInitialized || !sdk) {
+            throw new Error('SDK not initialized. Call initialize() first.');
+        }
+        try {
+            const result = await sdk.businesses.createBusiness(displayName);
+            console.log('Business created successfully:', result);
+            return result;
+        }
+        catch (error) {
+            console.error('Failed to create business:', error);
+            throw error;
+        }
+    }, [sdk, isInitialized]);
+    const updateBusiness = useCallback(async (businessId, businessData) => {
+        if (!isInitialized || !sdk) {
+            throw new Error('SDK not initialized. Call initialize() first.');
+        }
+        try {
+            const result = await sdk.businesses.updateBusiness(businessId, businessData);
+            console.log('Business updated successfully:', result);
+            return result;
+        }
+        catch (error) {
+            console.error('Failed to update business:', error);
+            throw error;
+        }
+    }, [sdk, isInitialized]);
+    const toggleBusinessStatus = useCallback(async (businessId, toggleData) => {
+        if (!isInitialized || !sdk) {
+            throw new Error('SDK not initialized. Call initialize() first.');
         }
         try {
-            const result = await business.getBusinessById(businessId);
-            console.log('✅ Business fetched successfully:', result);
+            const result = await sdk.businesses.toggleBusinessStatus(businessId, toggleData);
+            console.log('Business status toggled successfully:', result);
             return result;
         }
         catch (error) {
-            console.error('❌ Failed to fetch business:', error);
+            console.error('Failed to toggle business status:', error);
             throw error;
         }
-    }, [business]);
+    }, [sdk, isInitialized]);
     return {
         getActiveBusinesses,
-        getAllBusinessTypes,
+        getBusinessTypes,
+        getBusinesses,
         getBusinessById,
-        isAvailable: isInitialized && !!business,
+        getBusinessByAccount,
+        getBusinessesByType,
+        createBusiness,
+        updateBusiness,
+        toggleBusinessStatus,
+        isAvailable: isInitialized && !!sdk?.businesses,
     };
 };

package/dist/hooks/useCampaigns.d.ts

@@ -1,8 +1,15 @@
+import type { CampaignClaimRequestDTO, CampaignDTO, CampaignClaimDTO, CampaignTriggerDTO } from '@explorins/pers-shared';
 export declare const useCampaigns: () => {
-    getActiveCampaigns: () => Promise<any>;
-    getCampaignById: (campaignId: string) => Promise<any>;
-    claimCampaign: (request: any) => Promise<any>;
-    getClaimsForLoggedUser: () => Promise<any>;
+    getActiveCampaigns: () => Promise<CampaignDTO[]>;
+    getCampaignById: (campaignId: string) => Promise<CampaignDTO | null>;
+    claimCampaign: (request: CampaignClaimRequestDTO) => Promise<CampaignClaimDTO | null>;
+    getUserClaims: () => Promise<CampaignClaimDTO[]>;
+    getCampaignTriggers: () => Promise<CampaignTriggerDTO[]>;
+    getAllCampaigns: (active?: boolean) => Promise<CampaignDTO[]>;
+    getCampaignClaims: () => Promise<CampaignClaimDTO[]>;
+    getCampaignClaimsByUserId: (userId: string) => Promise<CampaignClaimDTO[]>;
+    getCampaignClaimsByBusinessId: (businessId: string) => Promise<CampaignClaimDTO[]>;
     isAvailable: boolean;
 };
+export type CampaignHook = ReturnType<typeof useCampaigns>;
 //# sourceMappingURL=useCampaigns.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"useCampaigns.d.ts","sourceRoot":"","sources":["../../src/hooks/useCampaigns.ts"],"names":[],"mappings":"AAGA,eAAO,MAAM,YAAY;;kCAsBgC,MAAM;6BAkBX,GAAG;;;CAoDtD,CAAC"}
+{"version":3,"file":"useCampaigns.d.ts","sourceRoot":"","sources":["../../src/hooks/useCampaigns.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EACV,uBAAuB,EACvB,WAAW,EACX,gBAAgB,EAChB,kBAAkB,EAInB,MAAM,wBAAwB,CAAC;AAEhC,eAAO,MAAM,YAAY;8BAG0B,QAAQ,WAAW,EAAE,CAAC;kCAehB,MAAM,KAAG,QAAQ,WAAW,GAAG,IAAI,CAAC;6BAezC,uBAAuB,KAAG,QAAQ,gBAAgB,GAAG,IAAI,CAAC;yBAmBhE,QAAQ,gBAAgB,EAAE,CAAC;+BAmBrB,QAAQ,kBAAkB,EAAE,CAAC;+BAgB3B,OAAO,KAAG,QAAQ,WAAW,EAAE,CAAC;6BAepC,QAAQ,gBAAgB,EAAE,CAAC;wCAed,MAAM,KAAG,QAAQ,gBAAgB,EAAE,CAAC;gDAe5B,MAAM,KAAG,QAAQ,gBAAgB,EAAE,CAAC;;CA2B1G,CAAC;AAEF,MAAM,MAAM,YAAY,GAAG,UAAU,CAAC,OAAO,YAAY,CAAC,CAAC"}

package/dist/hooks/useCampaigns.js

@@ -1,90 +1,152 @@
 import { useCallback } from 'react';
 import { usePersSDK } from '../providers/PersSDKProvider';
 export const useCampaigns = () => {
-    const { campaigns, isInitialized, isAuthenticated } = usePersSDK();
+    const { sdk, isInitialized, isAuthenticated } = usePersSDK();
     const getActiveCampaigns = useCallback(async () => {
-        if (!isInitialized) {
+        if (!isInitialized || !sdk) {
             throw new Error('SDK not initialized. Call initialize() first.');
         }
-        if (!campaigns?.getActiveCampaigns) {
-            console.warn('getActiveCampaigns method not available');
-            return [];
-        }
         try {
-            const result = await campaigns.getActiveCampaigns();
-            console.log('✅ Active campaigns fetched successfully:', result);
+            const result = await sdk.campaigns.getActiveCampaigns();
+            console.log('Active campaigns fetched successfully:', result);
             return result;
         }
         catch (error) {
-            console.error('❌ Failed to fetch active campaigns:', error);
+            console.error('Failed to fetch active campaigns:', error);
             throw error;
         }
-    }, [campaigns]);
+    }, [sdk, isInitialized]);
     const getCampaignById = useCallback(async (campaignId) => {
-        if (!isInitialized) {
+        if (!isInitialized || !sdk) {
             throw new Error('SDK not initialized. Call initialize() first.');
         }
-        if (!campaigns?.getCampaignById) {
-            throw new Error('getCampaignById method not available');
-        }
         try {
-            const result = await campaigns.getCampaignById(campaignId);
-            console.log('✅ Campaign fetched successfully:', result);
+            const result = await sdk.campaigns.getCampaignById(campaignId);
+            console.log('Campaign fetched successfully:', result);
             return result;
         }
         catch (error) {
-            console.error('❌ Failed to fetch campaign:', error);
+            console.error('Failed to fetch campaign:', error);
             throw error;
         }
-    }, [campaigns]);
+    }, [sdk, isInitialized]);
     const claimCampaign = useCallback(async (request) => {
-        if (!isInitialized) {
+        if (!isInitialized || !sdk) {
             throw new Error('SDK not initialized. Call initialize() first.');
         }
         if (!isAuthenticated) {
             throw new Error('SDK not authenticated. claimCampaign requires authentication.');
         }
-        if (!campaigns?.claimCampaign) {
-            throw new Error('claimCampaign method not available');
-        }
         try {
-            console.log('🔄 Claiming campaign with request:', request);
-            const result = await campaigns.claimCampaign(request);
-            console.log('✅ Campaign claimed successfully:', result);
+            console.log('Claiming campaign with request:', request);
+            const result = await sdk.campaigns.claimCampaign(request);
+            console.log('Campaign claimed successfully:', result);
             return result;
         }
         catch (error) {
-            console.error('❌ Failed to claim campaign:', error);
+            console.error('Failed to claim campaign:', error);
             throw error;
         }
-    }, [isInitialized, isAuthenticated, campaigns]);
-    const getClaimsForLoggedUser = useCallback(async () => {
-        if (!isInitialized) {
+    }, [sdk, isInitialized, isAuthenticated]);
+    const getUserClaims = useCallback(async () => {
+        if (!isInitialized || !sdk) {
             throw new Error('SDK not initialized. Call initialize() first.');
         }
         if (!isAuthenticated) {
-            console.warn('SDK not authenticated. getClaimsForLoggedUser requires authentication.');
+            console.warn('SDK not authenticated. getUserClaims requires authentication.');
             return [];
         }
-        if (!campaigns?.getClaimsForLoggedUser) {
-            console.warn('getClaimsForLoggedUser method not available');
-            return [];
+        try {
+            const result = await sdk.campaigns.getUserClaims();
+            console.log('User claims fetched successfully:', result);
+            return result;
+        }
+        catch (error) {
+            console.error('Failed to fetch user claims:', error);
+            throw error;
+        }
+    }, [sdk, isInitialized, isAuthenticated]);
+    const getCampaignTriggers = useCallback(async () => {
+        if (!isInitialized || !sdk) {
+            throw new Error('SDK not initialized. Call initialize() first.');
+        }
+        try {
+            const result = await sdk.campaigns.getCampaignTriggers();
+            console.log('Campaign triggers fetched successfully:', result);
+            return result;
+        }
+        catch (error) {
+            console.error('Failed to fetch campaign triggers:', error);
+            throw error;
+        }
+    }, [sdk, isInitialized]);
+    // Admin methods
+    const getAllCampaigns = useCallback(async (active) => {
+        if (!isInitialized || !sdk) {
+            throw new Error('SDK not initialized. Call initialize() first.');
+        }
+        try {
+            const result = await sdk.campaigns.getAllCampaigns(active);
+            console.log('All campaigns fetched successfully:', result);
+            return result;
+        }
+        catch (error) {
+            console.error('Failed to fetch all campaigns:', error);
+            throw error;
+        }
+    }, [sdk, isInitialized]);
+    const getCampaignClaims = useCallback(async () => {
+        if (!isInitialized || !sdk) {
+            throw new Error('SDK not initialized. Call initialize() first.');
+        }
+        try {
+            const result = await sdk.campaigns.getCampaignClaims();
+            console.log('Campaign claims fetched successfully:', result);
+            return result;
+        }
+        catch (error) {
+            console.error('Failed to fetch campaign claims:', error);
+            throw error;
+        }
+    }, [sdk, isInitialized]);
+    const getCampaignClaimsByUserId = useCallback(async (userId) => {
+        if (!isInitialized || !sdk) {
+            throw new Error('SDK not initialized. Call initialize() first.');
+        }
+        try {
+            const result = await sdk.campaigns.getCampaignClaimsByUserId(userId);
+            console.log('Campaign claims by user ID fetched successfully:', result);
+            return result;
+        }
+        catch (error) {
+            console.error('Failed to fetch campaign claims by user ID:', error);
+            throw error;
+        }
+    }, [sdk, isInitialized]);
+    const getCampaignClaimsByBusinessId = useCallback(async (businessId) => {
+        if (!isInitialized || !sdk) {
+            throw new Error('SDK not initialized. Call initialize() first.');
         }
         try {
-            const result = await campaigns.getClaimsForLoggedUser();
-            console.log('✅ User claims fetched successfully:', result);
+            const result = await sdk.campaigns.getCampaignClaimsByBusinessId(businessId);
+            console.log('Campaign claims by business ID fetched successfully:', result);
             return result;
         }
         catch (error) {
-            console.error('❌ Failed to fetch user claims:', error);
+            console.error('Failed to fetch campaign claims by business ID:', error);
             throw error;
         }
-    }, [isInitialized, isAuthenticated, campaigns]);
+    }, [sdk, isInitialized]);
     return {
         getActiveCampaigns,
         getCampaignById,
         claimCampaign,
-        getClaimsForLoggedUser,
-        isAvailable: isInitialized && !!campaigns,
+        getUserClaims,
+        getCampaignTriggers,
+        getAllCampaigns,
+        getCampaignClaims,
+        getCampaignClaimsByUserId,
+        getCampaignClaimsByBusinessId,
+        isAvailable: isInitialized && !!sdk?.campaigns,
     };
 };

package/dist/hooks/useDonations.d.ts

@@ -0,0 +1,33 @@
+import type { DonationTypeDTO } from '@explorins/pers-shared';
+/**
+ * React hook for donation operations in the PERS SDK
+ *
+ * Provides methods for managing donations and donation types within the platform.
+ * Supports retrieving available donation categories and types.
+ *
+ * @returns Donation hook with methods for donation management
+ *
+ * @example
+ * ```typescript
+ * function DonationsComponent() {
+ *   const { getDonationTypes } = useDonations();
+ *
+ *   const loadDonationTypes = async () => {
+ *     try {
+ *       const types = await getDonationTypes();
+ *       console.log('Available donation types:', types);
+ *     } catch (error) {
+ *       console.error('Failed to load donation types:', error);
+ *     }
+ *   };
+ *
+ *   return <button onClick={loadDonationTypes}>Load Donation Types</button>;
+ * }
+ * ```
+ */
+export declare const useDonations: () => {
+    getDonationTypes: () => Promise<DonationTypeDTO[]>;
+    isAvailable: boolean;
+};
+export type DonationHook = ReturnType<typeof useDonations>;
+//# sourceMappingURL=useDonations.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"useDonations.d.ts","sourceRoot":"","sources":["../../src/hooks/useDonations.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,wBAAwB,CAAC;AAE9D;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AACH,eAAO,MAAM,YAAY;4BAgBwB,QAAQ,eAAe,EAAE,CAAC;;CAmB1E,CAAC;AAEF,MAAM,MAAM,YAAY,GAAG,UAAU,CAAC,OAAO,YAAY,CAAC,CAAC"}

package/dist/hooks/useDonations.js

@@ -0,0 +1,62 @@
+import { useCallback } from 'react';
+import { usePersSDK } from '../providers/PersSDKProvider';
+/**
+ * React hook for donation operations in the PERS SDK
+ *
+ * Provides methods for managing donations and donation types within the platform.
+ * Supports retrieving available donation categories and types.
+ *
+ * @returns Donation hook with methods for donation management
+ *
+ * @example
+ * ```typescript
+ * function DonationsComponent() {
+ *   const { getDonationTypes } = useDonations();
+ *
+ *   const loadDonationTypes = async () => {
+ *     try {
+ *       const types = await getDonationTypes();
+ *       console.log('Available donation types:', types);
+ *     } catch (error) {
+ *       console.error('Failed to load donation types:', error);
+ *     }
+ *   };
+ *
+ *   return <button onClick={loadDonationTypes}>Load Donation Types</button>;
+ * }
+ * ```
+ */
+export const useDonations = () => {
+    const { sdk, isInitialized } = usePersSDK();
+    /**
+     * Retrieves all available donation types in the system
+     *
+     * @returns Promise resolving to array of donation types
+     * @throws Error if SDK is not initialized
+     *
+     * @example
+     * ```typescript
+     * const { getDonationTypes } = useDonations();
+     * const types = await getDonationTypes();
+     * console.log('Donation types:', types.map(t => t.name));
+     * ```
+     */
+    const getDonationTypes = useCallback(async () => {
+        if (!isInitialized || !sdk) {
+            throw new Error('SDK not initialized. Call initialize() first.');
+        }
+        try {
+            const result = await sdk.donations.getDonationTypes();
+            console.log('Donation types fetched successfully:', result);
+            return result;
+        }
+        catch (error) {
+            console.error('Failed to fetch donation types:', error);
+            throw error;
+        }
+    }, [sdk, isInitialized]);
+    return {
+        getDonationTypes,
+        isAvailable: isInitialized && !!sdk?.donations,
+    };
+};

package/dist/hooks/useFiles.d.ts

@@ -0,0 +1,50 @@
+import type { SignedUrlRequest, FileUploadEntityType } from '@explorins/pers-sdk';
+/**
+ * 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 declare const useFiles: () => {
+    getSignedPutUrl: (entityId: string, entityType: FileUploadEntityType, fileExtension: string) => Promise<string>;
+    getSignedGetUrl: (entityId: string, entityType: FileUploadEntityType, expireSeconds?: number) => Promise<string>;
+    getSignedUrl: (request: SignedUrlRequest) => Promise<string>;
+    optimizeMedia: (url: string, width?: number, height?: number) => Promise<string>;
+    isAvailable: boolean;
+};
+export type FileHook = ReturnType<typeof useFiles>;
+//# sourceMappingURL=useFiles.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"useFiles.d.ts","sourceRoot":"","sources":["../../src/hooks/useFiles.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EACV,gBAAgB,EAChB,oBAAoB,EACrB,MAAM,qBAAqB,CAAC;AAE7B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAuCG;AACH,eAAO,MAAM,QAAQ;gCAoBP,MAAM,cACJ,oBAAoB,iBACjB,MAAM,KACpB,QAAQ,MAAM,CAAC;gCAgCN,MAAM,cACJ,oBAAoB,kBAChB,MAAM,KACrB,QAAQ,MAAM,CAAC;4BAe+B,gBAAgB,KAAG,QAAQ,MAAM,CAAC;yBAerC,MAAM,UAAU,MAAM,WAAW,MAAM,KAAG,QAAQ,MAAM,CAAC;;CAsBxG,CAAC;AAEF,MAAM,MAAM,QAAQ,GAAG,UAAU,CAAC,OAAO,QAAQ,CAAC,CAAC"}