@phygitallabs/tapquest-core 2.7.0 → 2.9.0

package/dist/index.cjs

@@ -5,10 +5,6 @@ var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
 var __getOwnPropNames = Object.getOwnPropertyNames;
 var __getProtoOf = Object.getPrototypeOf;
 var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
-var __esm = (fn, res) => function __init() {
-  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
-};
 var __export = (target, all) => {
   for (var name in all)
     __defProp(target, name, { get: all[name], enumerable: true });
@@ -31,337 +27,28 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
   mod
 ));
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
-
-// src/modules/auth/constants/index.ts
-var userInfoKey, accessTokenKey, refreshTokenKey, httpMaxRetries, retryAttemptsRefreshToken, deviceUIDKey, chipAuthTokenKey;
-var init_constants = __esm({
-  "src/modules/auth/constants/index.ts"() {
-    "use strict";
-    userInfoKey = "phygital-user-info";
-    accessTokenKey = "accessToken";
-    refreshTokenKey = "refreshToken";
-    httpMaxRetries = 3;
-    retryAttemptsRefreshToken = "retryAttemptsRefreshToken";
-    deviceUIDKey = "Device-UID";
-    chipAuthTokenKey = "chip-auth-token";
-  }
-});
-
-// src/modules/auth/services/FirebaseAuthService.ts
-var firebaseApp, firebaseAuth, getFirebaseModules, FirebaseAuthService;
-var init_FirebaseAuthService = __esm({
-  "src/modules/auth/services/FirebaseAuthService.ts"() {
-    "use strict";
-    init_constants();
-    getFirebaseModules = async () => {
-      if (typeof window === "undefined") {
-        throw new Error("Firebase can only be used in client environment");
-      }
-      if (!firebaseApp || !firebaseAuth) {
-        const [
-          { initializeApp, getApps },
-          {
-            getAuth,
-            signInWithEmailAndPassword,
-            createUserWithEmailAndPassword,
-            signInWithPopup,
-            GoogleAuthProvider,
-            signOut: signOut2,
-            sendPasswordResetEmail,
-            sendEmailVerification,
-            updatePassword,
-            onAuthStateChanged
-          }
-        ] = await Promise.all([
-          import("firebase/app"),
-          import("firebase/auth")
-        ]);
-        firebaseApp = { initializeApp, getApps };
-        firebaseAuth = {
-          getAuth,
-          signInWithEmailAndPassword,
-          createUserWithEmailAndPassword,
-          signInWithPopup,
-          GoogleAuthProvider,
-          signOut: signOut2,
-          sendPasswordResetEmail,
-          sendEmailVerification,
-          updatePassword,
-          onAuthStateChanged
-        };
-      }
-      return { firebaseApp, firebaseAuth };
-    };
-    FirebaseAuthService = class {
-      constructor(config) {
-        __publicField(this, "app");
-        __publicField(this, "auth");
-        __publicField(this, "googleProvider");
-        __publicField(this, "config");
-        __publicField(this, "initialized", false);
-        this.config = config;
-      }
-      async ensureInitialized() {
-        if (this.initialized) return;
-        const { firebaseApp: firebaseApp2, firebaseAuth: firebaseAuth2 } = await getFirebaseModules();
-        if (!firebaseApp2.getApps().length) {
-          this.app = firebaseApp2.initializeApp(this.config);
-        } else {
-          this.app = firebaseApp2.getApps()[0];
-        }
-        this.auth = firebaseAuth2.getAuth(this.app);
-        this.googleProvider = new firebaseAuth2.GoogleAuthProvider();
-        this.initialized = true;
-      }
-      transformUserData(user) {
-        return {
-          id: user.uid,
-          uid: user.uid,
-          userName: user.displayName || "",
-          displayName: user.displayName || "",
-          email: user.email || "",
-          refreshToken: user.refreshToken,
-          accessToken: user.accessToken || "",
-          exp: user.stsTokenManager?.expirationTime || 0,
-          emailVerified: user.emailVerified,
-          avatar: user.photoURL || "/images/default-avatar.jpg",
-          signInProvider: this.getSignInProvider(user),
-          role: void 0,
-          scanStatus: false
-        };
-      }
-      getSignInProvider(user) {
-        const providers = user.providerData.map((p) => p.providerId);
-        if (providers.includes("google.com")) return "google.com";
-        return "password";
-      }
-      translateErrorCode(errorCode) {
-        switch (errorCode) {
-          case "auth/invalid-email":
-            return "Email kh\xF4ng h\u1EE3p l\u1EC7";
-          case "auth/user-disabled":
-            return "T\xE0i kho\u1EA3n \u0111\xE3 b\u1ECB kh\xF3a";
-          case "auth/wrong-password":
-            return "T\xE0i kho\u1EA3n/m\u1EADt kh\u1EA9u kh\xF4ng \u0111\xFAng";
-          case "auth/user-not-found":
-            return "T\xE0i kho\u1EA3n/m\u1EADt kh\u1EA9u kh\xF4ng \u0111\xFAng";
-          case "auth/weak-password":
-            return "Weak password! Please use stronger password.";
-          case "auth/email-already-in-use":
-            return "Email \u0111\xE3 \u0111\u01B0\u1EE3c s\u1EED d\u1EE5ng";
-          case "auth/account-exists-with-different-credential":
-            return "T\xE0i kho\u1EA3n email \u0111\xE3 \u0111\u01B0\u1EE3c s\u1EED d\u1EE5ng b\u1EDFi m\u1ED9t ph\u01B0\u01A1ng th\u1EE9c \u0111\u0103ng nh\u1EADp kh\xE1c";
-          case "auth/email-not-verified":
-            return "Email ch\u01B0a \u0111\u01B0\u1EE3c x\xE1c th\u1EF1c";
-          default:
-            return "\u0110\xE3 c\xF3 l\u1ED7i x\u1EA3y ra";
-        }
-      }
-      async signInWithEmailAndPassword(email, password) {
-        try {
-          await this.ensureInitialized();
-          const { firebaseAuth: firebaseAuth2 } = await getFirebaseModules();
-          const signInResponse = await firebaseAuth2.signInWithEmailAndPassword(this.auth, email, password);
-          const { user } = signInResponse;
-          const data = this.transformUserData(user);
-          const { emailVerified } = data;
-          if (!emailVerified) {
-            await this.signOut();
-            localStorage.removeItem("phygital-user-info");
-            localStorage.removeItem(accessTokenKey);
-            localStorage.removeItem(refreshTokenKey);
-            throw new Error("Email is not verified");
-          }
-          return {
-            errorCode: "",
-            data
-          };
-        } catch (err) {
-          const errorCode = this.translateErrorCode(err.code);
-          return {
-            errorCode,
-            data: null
-          };
-        }
-      }
-      async signInWithGoogle() {
-        try {
-          await this.ensureInitialized();
-          const { firebaseAuth: firebaseAuth2 } = await getFirebaseModules();
-          const signInResponse = await firebaseAuth2.signInWithPopup(this.auth, this.googleProvider);
-          const { user } = signInResponse;
-          const data = this.transformUserData(user);
-          const { emailVerified } = data;
-          if (!emailVerified) {
-            await this.signOut();
-            throw new Error("Email is not verified");
-          }
-          return {
-            errorCode: "",
-            data
-          };
-        } catch (err) {
-          const errorCode = this.translateErrorCode(err.code);
-          return {
-            errorCode,
-            data: null
-          };
-        }
-      }
-      async signUp(email, password) {
-        try {
-          await this.ensureInitialized();
-          const { firebaseAuth: firebaseAuth2 } = await getFirebaseModules();
-          const signUpResponse = await firebaseAuth2.createUserWithEmailAndPassword(this.auth, email, password);
-          const { user } = signUpResponse;
-          const data = this.transformUserData(user);
-          return {
-            errorCode: "",
-            data
-          };
-        } catch (err) {
-          const errorCode = this.translateErrorCode(err.code);
-          return {
-            errorCode,
-            data: null
-          };
-        }
-      }
-      async signOut() {
-        try {
-          await this.ensureInitialized();
-          const { firebaseAuth: firebaseAuth2 } = await getFirebaseModules();
-          await firebaseAuth2.signOut(this.auth);
-        } catch (err) {
-          console.log("Firebase signOut error:", err);
-        }
-      }
-      async sendPasswordResetEmail(email) {
-        await this.ensureInitialized();
-        const { firebaseAuth: firebaseAuth2 } = await getFirebaseModules();
-        const actionCodeSettings = {
-          url: window.location.origin,
-          handleCodeInApp: true
-        };
-        await firebaseAuth2.sendPasswordResetEmail(this.auth, email, actionCodeSettings);
-      }
-      async sendEmailVerification() {
-        await this.ensureInitialized();
-        const { firebaseAuth: firebaseAuth2 } = await getFirebaseModules();
-        if (!this.auth.currentUser) {
-          throw new Error("No current user");
-        }
-        const actionCodeSettings = {
-          url: window.location.origin,
-          handleCodeInApp: true
-        };
-        await firebaseAuth2.sendEmailVerification(this.auth.currentUser, actionCodeSettings);
-      }
-      async changePassword(newPassword) {
-        await this.ensureInitialized();
-        const { firebaseAuth: firebaseAuth2 } = await getFirebaseModules();
-        const user = this.auth.currentUser;
-        if (!user) {
-          throw new Error("No current user");
-        }
-        return firebaseAuth2.updatePassword(user, newPassword);
-      }
-      onAuthStateChanged(callback) {
-        if (typeof window === "undefined") {
-          return () => {
-          };
-        }
-        let unsubscriber = null;
-        this.ensureInitialized().then(async () => {
-          const { firebaseAuth: firebaseAuth2 } = await getFirebaseModules();
-          unsubscriber = firebaseAuth2.onAuthStateChanged(this.auth, (user) => {
-            if (user && user.emailVerified) {
-              const userData = this.transformUserData(user);
-              callback(userData);
-            } else {
-              callback(null);
-            }
-          });
-        });
-        return () => {
-          if (unsubscriber) {
-            unsubscriber();
-          }
-        };
-      }
-      getCurrentUser() {
-        if (typeof window === "undefined" || !this.initialized) {
-          return null;
-        }
-        const user = this.auth.currentUser;
-        if (user && user.emailVerified) {
-          return this.transformUserData(user);
-        }
-        return null;
-      }
-    };
-  }
-});
-
-// src/modules/auth/services/authServiceFactory.ts
-var authServiceInstance, createAuthService, getAuthService, resetAuthService;
-var init_authServiceFactory = __esm({
-  "src/modules/auth/services/authServiceFactory.ts"() {
-    "use strict";
-    init_FirebaseAuthService();
-    authServiceInstance = null;
-    createAuthService = (config) => {
-      if (!authServiceInstance) {
-        authServiceInstance = new FirebaseAuthService(config.firebaseConfig);
-      }
-      return authServiceInstance;
-    };
-    getAuthService = () => {
-      return authServiceInstance;
-    };
-    resetAuthService = () => {
-      authServiceInstance = null;
-    };
-  }
-});
-
-// src/modules/auth/services/index.ts
-var services_exports = {};
-__export(services_exports, {
-  FirebaseAuthService: () => FirebaseAuthService,
-  createAuthService: () => createAuthService,
-  getAuthService: () => getAuthService,
-  resetAuthService: () => resetAuthService
-});
-var init_services = __esm({
-  "src/modules/auth/services/index.ts"() {
-    "use strict";
-    init_FirebaseAuthService();
-    init_authServiceFactory();
-  }
-});
 
 // src/index.ts
 var index_exports = {};
 __export(index_exports, {
+  ALLOWED_ORIGINS: () => ALLOWED_ORIGINS,
   AchievementRuleActionType: () => import_achievement3.AchievementRuleActionType,
   AchievementServiceProvider: () => import_achievement3.AchievementServiceProvider,
   AchievementType: () => AchievementType,
   AuthProvider: () => AuthProvider,
-  CampaignState: () => import_api_core8.CampaignState,
-  CmentityRewardType: () => import_reward.CmentityRewardType,
+  CALLBACK_URL: () => CALLBACK_URL,
+  CampaignState: () => import_api_core10.CampaignState,
+  CmentityRewardType: () => import_reward2.CmentityRewardType,
   NotificationProvider: () => NotificationProvider,
   RewardClaimStatus: () => RewardClaimStatus,
   TapquestCoreProvider: () => TapquestCoreProvider,
   TaskType: () => TaskType,
-  UserSourceType: () => import_api_core4.UserSourceType,
+  UserSourceType: () => import_api_core6.UserSourceType,
   accessTokenKey: () => accessTokenKey,
   checkDeviceUid: () => checkDeviceUid,
   chipAuthTokenKey: () => chipAuthTokenKey,
   cn: () => import_helpers5.cn,
   convertSnakeToCamel: () => convertSnakeToCamel,
-  createRefreshTokenFunction: () => createRefreshTokenFunction,
   deviceUIDKey: () => deviceUIDKey,
   fileToBase64: () => import_helpers5.fileToBase64,
   filterLocationsByProperty: () => filterLocationsByProperty,
@@ -376,7 +63,7 @@ __export(index_exports, {
   getUserInfo: () => getUserInfo,
   httpMaxRetries: () => httpMaxRetries,
   isAchievementCompleted: () => isAchievementCompleted,
-  locationQueryKeys: () => import_api_core9.locationQueryKeys,
+  locationQueryKeys: () => import_api_core11.locationQueryKeys,
   memoriesKey: () => import_api_core2.memoriesKey,
   parse: () => import_helpers5.parse,
   refreshTokenKey: () => refreshTokenKey,
@@ -397,48 +84,53 @@ __export(index_exports, {
   useAchievementProgress: () => import_achievement2.useAchievementProgress,
   useAchivementPlusRewardModel: () => achivementPlusRewardModel_default,
   useAuth: () => useAuth,
-  useCampaignDetail: () => import_api_core7.useOneCampaign,
-  useCancelUserRewardsRequest: () => import_api_core3.useCancelUserRewardsRequest,
-  useChipScanStory: () => import_api_core5.useChipScanStory,
-  useClaimUserReward: () => import_hooks.useClaimUserReward,
-  useClearUserRewardCache: () => import_hooks.useClearUserRewardCache,
+  useCampaignDetail: () => import_api_core9.useOneCampaign,
+  useCancelUserRewardsRequest: () => import_api_core5.useCancelUserRewardsRequest,
+  useChipScanStory: () => import_api_core7.useChipScanStory,
+  useClaimUserReward: () => import_reward.useClaimUserReward,
+  useClearUserRewardCache: () => import_reward.useClearUserRewardCache,
+  useCreateCertificate: () => import_generate_certificate2.useCreateCertificate,
+  useCreateCertificateAnonymous: () => import_generate_certificate2.useCreateCertificateAnonymous,
+  useCreateCertificateWithMask: () => import_generate_certificate2.useCreateCertificateWithMask,
   useCreateMemory: () => import_api_core2.useCreateMemory,
-  useCreateModelGroupReward: () => import_hooks.useCreateModelGroupReward,
-  useCreateRewardModel: () => import_hooks.useApiCreateRewardModel,
+  useCreateModelGroupReward: () => import_reward.useCreateModelGroupReward,
+  useCreateRewardModel: () => import_reward.useCreateRewardModel,
   useDataTracking: () => useDataTracking,
-  useDeleteRewardModel: () => import_hooks.useApiDeleteRewardModel,
-  useGenerateFansipanCertificate: () => import_generate_certificate.useGenerateFansipanCertificate,
-  useGenerateTemplateCertificate: () => import_generate_certificate.useGenerateTemplateCertificate,
-  useGenerateThaocamvienCertificate: () => import_generate_certificate.useGenerateThaocamvienCertificate,
-  useGetRewardModel: () => import_hooks.useApiGetRewardModel,
-  useGetUserRewards: () => import_hooks.useGetUserRewards,
+  useDeleteRewardModel: () => import_reward.useDeleteRewardModel,
+  useGenerateFansipanCertificate: () => import_generate_certificate2.useGenerateFansipanCertificate,
+  useGenerateTemplateCertificate: () => import_generate_certificate2.useGenerateTemplateCertificate,
+  useGenerateThaocamvienCertificate: () => import_generate_certificate2.useGenerateThaocamvienCertificate,
+  useGetRewardModel: () => import_reward.useGetRewardModel,
+  useGetUserRewards: () => import_reward.useGetUserRewards,
+  useGoogleLogin: () => useGoogleLogin,
   useInfiniteMemories: () => import_api_core2.useInfiniteMemories,
-  useListRewardModels: () => import_hooks.useApiListRewardModels,
-  useLocationDetail: () => import_api_core9.useOneLocation,
-  useLocationProgress: () => import_api_core9.useUserCampaignsCompletedLocation,
-  useLocationsList: () => import_api_core9.useManyLocations,
+  useListRewardModels: () => import_reward.useListRewardModels,
+  useLocationDetail: () => import_api_core11.useOneLocation,
+  useLocationProgress: () => import_api_core11.useUserCampaignsCompletedLocation,
+  useLocationsList: () => import_api_core11.useManyLocations,
   useManyAchievementProgress: () => useManyAchievementProgress,
   useManyAchievements: () => import_achievement2.useManyAchievements,
   useManyAchievementsRewardModels: () => import_achievement2.useManyAchievementsRewardModels,
   useManyChildrenAchievements: () => import_achievement2.useManyChildrenAchievements,
   useManyMemory: () => import_api_core2.useManyMemory,
-  useManyUserActionLocations: () => import_api_core9.useManyUserActionLocations,
-  useManyUserRewards: () => import_hooks.useManyUserRewards,
-  useMyProfile: () => import_api_core3.useMyProfile,
+  useManyUserActionLocations: () => import_api_core11.useManyUserActionLocations,
+  useManyUserRewards: () => import_reward.useManyUserRewards,
+  useMyProfile: () => import_api_core5.useMyProfile,
   useOneAchievement: () => import_achievement2.useOneAchievement,
   useOneMemory: () => import_api_core2.useOneMemory,
-  useOneUserCampaign: () => import_api_core7.useOneUserCampaign,
-  usePGLCoreService: () => import_api_core6.usePGLCoreService,
+  useOneUserCampaign: () => import_api_core9.useOneUserCampaign,
+  usePGLCoreService: () => import_api_core8.usePGLCoreService,
   useScanChip: () => useScanChip,
-  useSendEmail: () => import_api_core11.useSendEmail,
-  useSyncCheckin: () => import_api_core3.useSyncCheckin,
-  useUpdateMyProfile: () => import_api_core3.useUpdateMyProfile,
-  useUpdateRewardModel: () => import_hooks.useApiUpdateRewardModel,
+  useSendEmail: () => import_api_core13.useSendEmail,
+  useSyncCheckin: () => import_api_core5.useSyncCheckin,
+  useUpdateMyProfile: () => import_api_core5.useUpdateMyProfile,
+  useUpdateRewardModel: () => import_reward.useUpdateRewardModel,
   useUploadMedia: () => import_api_core2.useUploadMedia,
   useUserAchievementAction: () => import_achievement2.useUserAchievementAction,
-  useUserCampaignAction: () => import_api_core7.useUserCampaignAction,
-  useV1ListRewards: () => import_hooks.useV1ListRewards,
-  userInfoKey: () => userInfoKey
+  useUserCampaignAction: () => import_api_core9.useUserCampaignAction,
+  useV1ListRewards: () => import_reward.useV1ListRewards,
+  userInfoKey: () => userInfoKey,
+  wrapTextWithFont: () => import_generate_certificate3.wrapTextWithFont
 });
 module.exports = __toCommonJS(index_exports);
 
@@ -564,10 +256,10 @@ var AchievementType = /* @__PURE__ */ ((AchievementType2) => {
 })(AchievementType || {});
 
 // src/modules/reward/hooks/useRewardService.ts
-var import_hooks = require("@phygitallabs/reward/src/hooks");
+var import_reward = require("@phygitallabs/reward");
 
 // src/modules/reward/types/enums.ts
-var import_reward = require("@phygitallabs/reward");
+var import_reward2 = require("@phygitallabs/reward");
 var RewardClaimStatus = /* @__PURE__ */ ((RewardClaimStatus2) => {
   RewardClaimStatus2["NOT_CLAIMED"] = "not_claimed";
   RewardClaimStatus2["CLAIMED"] = "claimed";
@@ -630,8 +322,8 @@ var NotificationProvider = ({
   return /* @__PURE__ */ (0, import_jsx_runtime.jsx)(
     import_notification_api.NotificationProvider,
     {
-      userUid: user.id,
-      accessToken: user.accessToken,
+      userUid: user?.id,
+      accessToken: user?.accessToken ?? null,
       webSocketUrl,
       autoConnect,
       onWebSocketOpen,
@@ -649,69 +341,761 @@ __reExport(index_exports, notification_exports, module.exports);
 var import_api_core2 = require("@phygitallabs/api-core");
 
 // src/modules/auth/providers/AuthProvider.tsx
+var import_authentication3 = require("@phygitallabs/authentication");
 var import_react = require("react");
 
-// src/store/hooks.ts
-var import_react_redux = require("react-redux");
-var useAppDispatch = () => (0, import_react_redux.useDispatch)();
-var useAppSelector = import_react_redux.useSelector;
+// src/modules/auth/store/authStore.ts
+var import_zustand = require("zustand");
+var import_immer = require("zustand/middleware/immer");
+var import_middleware = require("zustand/middleware");
+var import_authentication = require("@phygitallabs/authentication");
 
-// src/modules/auth/store/authSlice.ts
-var import_toolkit = require("@reduxjs/toolkit");
+// src/modules/auth/constants/index.ts
+var userInfoKey = "phygital-user-info";
+var accessTokenKey = "accessToken";
+var refreshTokenKey = "refreshToken";
+var httpMaxRetries = 3;
+var retryAttemptsRefreshToken = "retryAttemptsRefreshToken";
+var deviceUIDKey = "Device-UID";
+var chipAuthTokenKey = "chip-auth-token";
+var CALLBACK_URL = "https://s3-sgn10.fptcloud.com/nomion-assets/platform/callback.html";
+var ALLOWED_ORIGINS = [
+  "https://s3-sgn10.fptcloud.com",
+  "https://accounts.google.com/"
+];
 
-// src/modules/auth/helpers/index.ts
-init_constants();
-var import_uuid = require("uuid");
+// src/modules/auth/store/authStore.ts
+var initialState = {
+  user: null,
+  isSignedIn: false,
+  isInitialized: false,
+  isLoading: false,
+  error: null,
+  cleanupFunctions: {},
+  eventCallbacks: {}
+};
+var useAuthStore = (0, import_zustand.create)()(
+  (0, import_middleware.devtools)(
+    (0, import_middleware.persist)(
+      (0, import_middleware.subscribeWithSelector)(
+        (0, import_immer.immer)((set, get) => ({
+          ...initialState,
+          actions: {
+            setIsLoading: (isLoading) => set((state) => {
+              state.isLoading = isLoading;
+            }),
+            setCleanupFunctions: (newCleanupFunctions) => set((state) => {
+              state.cleanupFunctions = {
+                ...state.cleanupFunctions,
+                ...newCleanupFunctions
+              };
+            }),
+            // Event management
+            addEventCallbacks: (callbacks) => {
+              set((state) => {
+                state.eventCallbacks = {
+                  ...state.eventCallbacks,
+                  ...callbacks
+                };
+              });
+              return () => {
+                set((state) => {
+                  state.eventCallbacks = {
+                    ...state.eventCallbacks,
+                    ...callbacks
+                  };
+                });
+              };
+            },
+            // Sign in with email and password
+            signInWithEmail: async (email, password) => {
+              const { eventCallbacks } = get();
+              set((state) => {
+                state.isLoading = true;
+                state.error = null;
+              });
+              try {
+                const response = await import_authentication.authService.signIn({
+                  email,
+                  password
+                });
+                if (response?.data?.idToken && response?.data?.refreshToken) {
+                  import_authentication.tokenStorage.setTokens({
+                    idToken: response.data.idToken,
+                    refreshToken: response.data.refreshToken
+                  });
+                  set((state) => {
+                    state.isSignedIn = true;
+                  });
+                  eventCallbacks.onLoginSuccess?.(response.data.idToken);
+                }
+                return response;
+              } catch (error) {
+                if (error?.response?.data?.code === 7) {
+                  return {
+                    data: void 0,
+                    message: "Email verification required",
+                    code: 7
+                  };
+                }
+                const errorMessage = error instanceof Error ? error.message : "Login failed";
+                set((state) => {
+                  state.error = errorMessage;
+                });
+                eventCallbacks.onLoginError?.(new Error(errorMessage));
+                throw error;
+              } finally {
+                set((state) => {
+                  state.isLoading = false;
+                });
+              }
+            },
+            // Sign in with Google
+            signInWithGoogle: async () => {
+              const { eventCallbacks } = get();
+              try {
+                const currentDomain = CALLBACK_URL;
+                const userData = await import_authentication.authService.getOAuthSignInUrl(currentDomain);
+                return userData;
+              } catch (error) {
+                const errorMessage = error instanceof Error ? error.message : "Google sign in failed";
+                set((state) => {
+                  state.error = errorMessage;
+                });
+                eventCallbacks.onLoginError?.(new Error(errorMessage));
+                throw error;
+              }
+            },
+            // Sign up with email and password
+            signUpWithEmail: async (email, password) => {
+              const { eventCallbacks } = get();
+              set((state) => {
+                state.isLoading = true;
+                state.error = null;
+              });
+              try {
+                const response = await import_authentication.authService.signUp({
+                  email,
+                  password
+                });
+                if (response.data) {
+                  eventCallbacks.onSignupSuccess?.();
+                }
+                return response;
+              } catch (error) {
+                const errorMessage = error instanceof Error ? error.message : "Signup failed";
+                set((state) => {
+                  state.error = errorMessage;
+                });
+                eventCallbacks.onSignupError?.(new Error(errorMessage));
+                throw error;
+              } finally {
+                set((state) => {
+                  state.isLoading = false;
+                  state.user = null;
+                  state.isSignedIn = false;
+                });
+              }
+            },
+            // Sign out
+            signOut: async () => {
+              const { eventCallbacks, cleanupFunctions } = get();
+              set((state) => {
+                state.isLoading = true;
+                state.error = null;
+              });
+              try {
+                set((state) => {
+                  state.user = null;
+                  state.isSignedIn = false;
+                  state.error = null;
+                });
+                const isTokenExpired = import_authentication.tokenStorage.isTokenExpired();
+                if (isTokenExpired) {
+                  import_authentication.tokenStorage.clearTokens();
+                  localStorage.clear();
+                  return;
+                }
+                await import_authentication.authService.logout();
+                localStorage.clear();
+                import_authentication.tokenStorage.clearTokens();
+                try {
+                  cleanupFunctions.clearQueryCache?.();
+                  cleanupFunctions.clearOrganization?.();
+                  cleanupFunctions.clearCustomData?.();
+                  cleanupFunctions.clearHeaders?.();
+                } catch (cleanupError) {
+                  console.warn("Error during logout cleanup:", cleanupError);
+                }
+                eventCallbacks.onLogoutSuccess?.();
+              } catch (error) {
+                console.log(error);
+                const errorMessage = error instanceof Error ? error.message : "Logout failed";
+                set((state) => {
+                  state.error = errorMessage;
+                });
+                eventCallbacks.onLogoutError?.(new Error(errorMessage));
+                throw error;
+              } finally {
+                set((state) => {
+                  state.isLoading = false;
+                });
+              }
+            },
+            // Send password reset email
+            sendPasswordResetEmail: async (email) => {
+              set((state) => {
+                state.isLoading = true;
+                state.error = null;
+              });
+              try {
+                await import_authentication.verifyCodeService.forgotPassword({
+                  email
+                });
+              } catch (error) {
+                const errorMessage = error instanceof Error ? error.message : "Failed to send reset email";
+                set((state) => {
+                  state.error = errorMessage;
+                });
+                throw error;
+              } finally {
+                set((state) => {
+                  state.isLoading = false;
+                });
+              }
+            },
+            resetPassword: async (data) => {
+              set((state) => {
+                state.isLoading = true;
+                state.error = null;
+              });
+              try {
+                const resetPasswordResponse = await import_authentication.verifyCodeService.resetPassword(data);
+                return resetPasswordResponse;
+              } catch (error) {
+                const errorMessage = error instanceof Error ? error.message : "Failed to reset password";
+                set((state) => {
+                  state.error = errorMessage;
+                });
+                throw error;
+              } finally {
+                set((state) => {
+                  state.isLoading = false;
+                });
+              }
+            },
+            changePassword: async (data) => {
+              set((state) => {
+                state.isLoading = true;
+                state.error = null;
+              });
+              try {
+                const changePasswordResponse = await import_authentication.verifyCodeService.changePassword(data);
+                return changePasswordResponse;
+              } catch (error) {
+                throw error;
+              } finally {
+                set((state) => {
+                  state.isLoading = false;
+                });
+              }
+            },
+            verifyEmailCode: async (data) => {
+              set((state) => {
+                state.isLoading = true;
+                state.error = null;
+              });
+              try {
+                const verifyEmailResponse = await import_authentication.verifyCodeService.verifyEmail(data);
+                return verifyEmailResponse;
+              } catch (error) {
+                const errorMessage = error instanceof Error ? error.message : "Failed to send reset email";
+                set((state) => {
+                  state.error = errorMessage;
+                });
+                throw error;
+              } finally {
+                set((state) => {
+                  state.isLoading = false;
+                });
+              }
+            },
+            sendVerifyCode: async (data) => {
+              set((state) => {
+                state.isLoading = true;
+                state.error = null;
+              });
+              try {
+                const sendVerifyCodeResponse = await import_authentication.verifyCodeService.sendVerifyCode(data);
+                return sendVerifyCodeResponse;
+              } catch (error) {
+                const errorMessage = error instanceof Error ? error.message : "Failed to send verify code";
+                set((state) => {
+                  state.error = errorMessage;
+                });
+                throw error;
+              } finally {
+                set((state) => {
+                  state.isLoading = false;
+                });
+              }
+            },
+            refreshToken: async (refreshToken) => {
+              const refreshTokenResponse = await import_authentication.authService.refreshToken({
+                refreshToken: refreshToken ?? import_authentication.tokenStorage.getRefreshToken() ?? ""
+              });
+              return refreshTokenResponse;
+            },
+            // Clear error
+            clearError: () => set((state) => {
+              state.error = null;
+            }),
+            setUser: (user) => set((state) => {
+              state.user = user;
+            }),
+            setIsSignedIn: (isSignedIn) => set((state) => {
+              state.isSignedIn = isSignedIn;
+            }),
+            setIsInitialized: (isInitialized) => set((state) => {
+              state.isInitialized = isInitialized;
+            }),
+            patchUser: (user) => set((state) => {
+              if (state.user) {
+                state.user = { ...state.user, ...user };
+              } else {
+                state.user = user;
+              }
+            }),
+            // Initialize the store - check if user is already authenticated from tokenStorage
+            initialize: () => {
+              set((state) => {
+                const token = import_authentication.tokenStorage.getAuthToken();
+                state.isSignedIn = !!token;
+                state.isInitialized = true;
+              });
+            },
+            // Sync auth state from tokenStorage (called when axios interceptor updates tokens)
+            syncAuthState: () => {
+              set((state) => {
+                const token = import_authentication.tokenStorage.getAuthToken();
+                const wasSignedIn = state.isSignedIn;
+                state.isSignedIn = !!token;
+                if (wasSignedIn !== state.isSignedIn) {
+                  if (state.isSignedIn) {
+                    state.eventCallbacks?.onAuthStateChange?.(state.user, true);
+                  } else {
+                    state.eventCallbacks?.onAuthStateChange?.(null, false);
+                  }
+                }
+              });
+            }
+          }
+        }))
+      ),
+      {
+        version: 1,
+        name: "auth-store",
+        storage: (0, import_middleware.createJSONStorage)(() => localStorage),
+        partialize: (state) => ({
+          isSignedIn: state.isSignedIn,
+          user: state.user
+        })
+      }
+    )
+  )
+);
+var useAuth = () => {
+  const user = useAuthStore((state) => state.user);
+  const isSignedIn = useAuthStore((state) => state.isSignedIn);
+  const isInitialized = useAuthStore((state) => state.isInitialized);
+  const isLoading = useAuthStore((state) => state.isLoading);
+  const error = useAuthStore((state) => state.error);
+  const actions = useAuthStore((state) => state.actions);
+  return {
+    user,
+    isSignedIn,
+    isInitialized,
+    isLoading,
+    error,
+    ...actions
+  };
+};
 
-// src/modules/auth/helpers/refreshToken.ts
-var import_mem = __toESM(require("mem"), 1);
-var REFRESH_TOKEN_CONFIG = {
-  maxAge: 1e4
-  // 10 seconds cache
+// src/modules/auth/utils/user.ts
+var import_jwt_decode = __toESM(require("jwt-decode"), 1);
+var transformProtoUserData = (user, accessToken) => {
+  const userData = { ...user };
+  let tokenDecoded = {};
+  try {
+    tokenDecoded = (0, import_jwt_decode.default)(accessToken);
+  } catch (error) {
+    console.warn("Failed to decode token in transformUserData:", error);
+  }
+  userData.exp = tokenDecoded.exp || 0;
+  userData.accessToken = accessToken || "";
+  userData.roles = tokenDecoded?.roles || ["USER" /* USER */];
+  userData.account_type = tokenDecoded?.account_type || 0 /* C */;
+  userData.picture = user.picture || "";
+  return userData;
 };
-var createRefreshTokenFunction = (config) => {
-  const refreshTokenFn = async () => {
+
+// src/modules/auth/providers/AuthProvider.tsx
+var import_api_core3 = require("@phygitallabs/api-core");
+var import_api_core4 = require("@phygitallabs/api-core");
+var import_achievement4 = require("@phygitallabs/achievement");
+var import_reward3 = require("@phygitallabs/reward");
+var import_generate_certificate = require("@phygitallabs/generate-certificate");
+
+// src/modules/auth/hooks/useTokenRefresher.ts
+var import_react_query = require("@tanstack/react-query");
+var import_authentication2 = require("@phygitallabs/authentication");
+function useTokenRefresher() {
+  const { refreshToken, signOut } = useAuth();
+  const handleRefreshToken = async () => {
     try {
-      const session = getUserInfo();
-      const refreshToken = getRefreshToken();
-      if (!refreshToken) {
-        removeUserInfo();
+      const isTokenExpired = import_authentication2.tokenStorage.isTokenExpired();
+      if (!isTokenExpired) {
         return;
       }
-      const params = new URLSearchParams();
-      params.append("grant_type", "refresh_token");
-      params.append("refresh_token", refreshToken);
-      const fetchData = {
-        method: "POST",
-        headers: new Headers({
-          "Content-Type": "application/x-www-form-urlencoded;charset=UTF-8"
-        }),
-        body: params
-      };
-      const response = await fetch(
-        `https://securetoken.googleapis.com/v1/token?key=${config.firebaseApiKey}`,
-        fetchData
+      const newToken = await refreshToken();
+      if (newToken.data?.idToken && newToken.data?.refreshToken) {
+        import_authentication2.tokenStorage.setTokens({
+          idToken: newToken.data?.idToken,
+          refreshToken: newToken.data?.refreshToken
+        });
+      }
+    } catch (error) {
+      console.error("Failed to refresh token:", error);
+      signOut();
+    }
+  };
+  (0, import_react_query.useQuery)({
+    queryKey: ["refresh-token"],
+    queryFn: () => handleRefreshToken(),
+    refetchInterval: 30 * 60 * 1e3,
+    // every 30 minutes
+    refetchIntervalInBackground: false,
+    // even when tab is hidden
+    refetchOnWindowFocus: true,
+    // also refresh when user returns to tab
+    retry: false,
+    // don't retry repeatedly if refresh fails
+    enabled: !!import_authentication2.tokenStorage.getAuthToken()
+    // only run if logged in
+  });
+}
+
+// src/modules/auth/providers/AuthProvider.tsx
+var import_jsx_runtime2 = require("react/jsx-runtime");
+var AuthStateManager = () => {
+  const { updateHeaders } = (0, import_authentication3.useAuthenticationHeaders)();
+  const { updateHeaders: updateHeadersPGL, coreApi } = (0, import_api_core4.usePGLCoreService)();
+  const { updateHeaders: updateHeadersAchievement } = (0, import_achievement4.useAchievementService)();
+  const { updateHeaders: updateHeadersReward } = (0, import_reward3.useRewardService)();
+  const { updateHeaders: updateHeadersGenerateCertificate } = (0, import_generate_certificate.useGenerateCertificateService)();
+  (0, import_react.useEffect)(() => {
+    useAuthStore.getState().actions.initialize();
+    const token = import_authentication3.tokenStorage.getAuthToken();
+    if (token) {
+      updateHeaders({
+        Authorization: `Bearer ${token}`
+      });
+      updateHeadersPGL({
+        Authorization: `Bearer ${token}`
+      });
+      updateHeadersAchievement({
+        Authorization: `Bearer ${token}`
+      });
+      updateHeadersReward({
+        Authorization: `Bearer ${token}`
+      });
+      updateHeadersGenerateCertificate({
+        Authorization: `Bearer ${token}`
+      });
+      const { user } = useAuthStore.getState();
+      if (user && user.accessToken !== token) {
+        useAuthStore.getState().actions.setUser({
+          ...user,
+          accessToken: token
+        });
+      }
+    }
+    let previousIsSignedIn = useAuthStore.getState().isSignedIn;
+    const unsub = useAuthStore.subscribe(
+      (state) => [state.isSignedIn, state.user],
+      async ([isSignedIn]) => {
+        if (isSignedIn === previousIsSignedIn) {
+          return;
+        }
+        previousIsSignedIn = isSignedIn;
+        if (isSignedIn) {
+          const token2 = import_authentication3.tokenStorage.getAuthToken();
+          if (token2) {
+            updateHeaders({
+              Authorization: `Bearer ${token2}`
+            });
+            updateHeadersPGL({
+              Authorization: `Bearer ${token2}`
+            });
+            updateHeadersAchievement({
+              Authorization: `Bearer ${token2}`
+            });
+            updateHeadersReward({
+              Authorization: `Bearer ${token2}`
+            });
+            updateHeadersGenerateCertificate({
+              Authorization: `Bearer ${token2}`
+            });
+            try {
+              const userApi = (0, import_api_core3.userService)(coreApi);
+              const userProfile = await userApi.getMyProfile();
+              const transformedUserData = transformProtoUserData(
+                userProfile,
+                token2
+              );
+              useAuthStore.getState().actions.setUser(transformedUserData);
+            } catch (error) {
+              useAuthStore.getState().actions.signOut();
+            }
+          }
+          const { eventCallbacks, user } = useAuthStore.getState();
+          eventCallbacks?.onAuthStateChange?.(user, true);
+        } else {
+          updateHeaders({});
+          updateHeadersPGL({});
+          updateHeadersAchievement({
+            Authorization: ``
+          });
+          updateHeadersReward({
+            Authorization: ``
+          });
+          updateHeadersGenerateCertificate({
+            Authorization: ``
+          });
+          const { eventCallbacks } = useAuthStore.getState();
+          eventCallbacks?.onAuthStateChange?.(null, false);
+        }
+      }
+    );
+    const unsubTokenChange = import_authentication3.tokenStorage.addTokenChangeListener(async () => {
+      const { isSignedIn, user } = useAuthStore.getState();
+      if (isSignedIn) {
+        const token2 = import_authentication3.tokenStorage.getAuthToken();
+        if (token2) {
+          updateHeaders({
+            Authorization: `Bearer ${token2}`
+          });
+          updateHeadersPGL({
+            Authorization: `Bearer ${token2}`
+          });
+          updateHeadersAchievement({
+            Authorization: `Bearer ${token2}`
+          });
+          updateHeadersReward({
+            Authorization: `Bearer ${token2}`
+          });
+          updateHeadersGenerateCertificate({
+            Authorization: `Bearer ${token2}`
+          });
+          if (user && user.accessToken !== token2) {
+            useAuthStore.getState().actions.setUser({
+              ...user,
+              accessToken: token2
+            });
+          }
+        } else {
+          useAuthStore.getState().actions.signOut();
+          updateHeaders({});
+          updateHeadersPGL({});
+          updateHeadersAchievement({
+            Authorization: ``
+          });
+          updateHeadersReward({
+            Authorization: ``
+          });
+          updateHeadersGenerateCertificate({
+            Authorization: ``
+          });
+        }
+      }
+    });
+    return () => {
+      unsub();
+      unsubTokenChange();
+    };
+  }, [
+    updateHeaders,
+    updateHeadersPGL,
+    updateHeadersAchievement,
+    updateHeadersReward,
+    updateHeadersGenerateCertificate,
+    coreApi
+  ]);
+  return null;
+};
+var TokenRefresher = () => {
+  useTokenRefresher();
+  return null;
+};
+var AuthProvider = ({
+  children,
+  baseURL,
+  queryClient
+}) => {
+  const axiosConfig = {
+    headers: {
+      "Content-Type": "application/json"
+    }
+  };
+  return /* @__PURE__ */ (0, import_jsx_runtime2.jsxs)(
+    import_authentication3.AuthenticationProvider,
+    {
+      axiosConfig,
+      baseURL,
+      queryClient,
+      children: [
+        /* @__PURE__ */ (0, import_jsx_runtime2.jsx)(AuthStateManager, {}),
+        /* @__PURE__ */ (0, import_jsx_runtime2.jsx)(TokenRefresher, {}),
+        children
+      ]
+    }
+  );
+};
+
+// src/modules/auth/hooks/useGoogleLogin.ts
+var import_react2 = require("react");
+var import_authentication4 = require("@phygitallabs/authentication");
+function useGoogleLogin(options = {}) {
+  const { onSuccess, onError, onPopupBlocked, onPopupClosed } = options;
+  const { signInWithGoogle, refreshToken, setIsSignedIn, setIsLoading, isLoading } = useAuth();
+  const popupRef = (0, import_react2.useRef)(null);
+  const gotDataRef = (0, import_react2.useRef)(false);
+  const timerRef = (0, import_react2.useRef)(null);
+  const errorRef = (0, import_react2.useRef)(null);
+  const handleTokenRefresh = (0, import_react2.useCallback)(
+    async (refresh) => {
+      if (refresh) {
+        try {
+          const newToken = await refreshToken(refresh);
+          if (newToken.data?.idToken && newToken.data?.refreshToken) {
+            import_authentication4.tokenStorage.setTokens({
+              idToken: newToken.data.idToken,
+              refreshToken: newToken.data.refreshToken
+            });
+            setIsSignedIn(true);
+            setIsLoading(false);
+            onSuccess?.();
+          }
+        } catch (error) {
+          const errorMessage = error instanceof Error ? error.message : "Token refresh failed";
+          errorRef.current = errorMessage;
+          onError?.(errorMessage);
+          setIsLoading(false);
+        }
+      }
+    },
+    [refreshToken, setIsSignedIn, setIsLoading, onSuccess, onError]
+  );
+  const cleanup = (0, import_react2.useCallback)(() => {
+    if (timerRef.current) {
+      clearInterval(timerRef.current);
+      timerRef.current = null;
+    }
+    gotDataRef.current = false;
+  }, []);
+  const handleMessage = (0, import_react2.useCallback)(
+    (event) => {
+      const allowedOrigins = ALLOWED_ORIGINS.concat(window?.location?.origin);
+      if (event.origin !== "*" && !allowedOrigins.includes(event.origin)) {
+        console.warn("Rejected message from untrusted origin:", event.origin);
+        return;
+      }
+      if (!event.data || typeof event.data !== "object") {
+        console.warn("Invalid message data received");
+        return;
+      }
+      if (event.data.type === "LOGIN_SUCCESS") {
+        const { refreshToken: refresh } = event.data;
+        if (refresh) {
+          handleTokenRefresh(refresh);
+        }
+        gotDataRef.current = true;
+        cleanup();
+      } else if (event.data.type === "LOGIN_ERROR") {
+        const errorMessage = event.data.error || "Login failed";
+        errorRef.current = errorMessage;
+        onError?.(errorMessage);
+        setIsLoading(false);
+        gotDataRef.current = true;
+        cleanup();
+      }
+    },
+    [handleTokenRefresh, setIsLoading, cleanup, onError]
+  );
+  const signIn = (0, import_react2.useCallback)(async () => {
+    const width = 500;
+    const height = 600;
+    const left = window.screenX + (window.outerWidth - width) / 2;
+    const top = window.screenY + (window.outerHeight - height) / 2;
+    try {
+      errorRef.current = null;
+      setIsLoading(true);
+      const response = await signInWithGoogle();
+      popupRef.current = window.open(
+        `${response.statusMessage}`,
+        "oauthPopup",
+        `width=${width},height=${height},left=${left},top=${top},resizable,scrollbars`
       );
-      const data = await response.json();
-      if (data.error) {
-        removeUserInfo();
+      if (!popupRef.current) {
+        setIsLoading(false);
+        const error = "Popup blocked. Please allow popups for this site.";
+        errorRef.current = error;
+        onPopupBlocked?.();
+        onError?.(error);
         return;
       }
-      const newSession = {
-        ...session,
-        accessToken: data.access_token,
-        refreshToken: data.refresh_token
-      };
-      setUserInfo(newSession);
-      return newSession;
-    } catch {
-      removeUserInfo();
+      timerRef.current = setInterval(() => {
+        if (popupRef.current && popupRef.current.closed) {
+          if (timerRef.current) {
+            clearInterval(timerRef.current);
+            timerRef.current = null;
+          }
+          if (!gotDataRef.current) {
+            const error = "Authentication popup was closed";
+            errorRef.current = error;
+            onPopupClosed?.();
+            onError?.(error);
+            setIsLoading(false);
+          }
+        }
+      }, 500);
+    } catch (error) {
+      const errorMessage = error instanceof Error ? error.message : "Google sign in failed";
+      errorRef.current = errorMessage;
+      onError?.(errorMessage);
+      setIsLoading(false);
     }
+  }, [signInWithGoogle, setIsLoading, handleMessage, onError, onPopupBlocked, onPopupClosed]);
+  (0, import_react2.useEffect)(() => {
+    window.addEventListener("message", handleMessage);
+    return () => {
+      window.removeEventListener("message", handleMessage);
+    };
+  }, [handleMessage]);
+  (0, import_react2.useEffect)(() => {
+    return () => {
+      cleanup();
+    };
+  }, [cleanup, handleMessage]);
+  return {
+    signIn,
+    isLoading,
+    error: errorRef.current
   };
-  return (0, import_mem.default)(refreshTokenFn, { maxAge: REFRESH_TOKEN_CONFIG.maxAge });
-};
+}
 
 // src/modules/auth/helpers/index.ts
+var import_uuid = require("uuid");
 var generateDeviceId = async () => {
   try {
     const deviceFingerprint = await generateDeviceFingerprint();
@@ -826,221 +1210,19 @@ var removeUserInfo = () => {
   localStorage.removeItem(userInfoKey);
 };
 
-// src/modules/auth/store/authSlice.ts
-var defaultUser = {
-  uid: "",
-  id: "",
-  userName: "",
-  displayName: "",
-  avatar: "/images/default-avatar.jpg",
-  email: "",
-  exp: 0,
-  emailVerified: false,
-  refreshToken: "",
-  accessToken: "",
-  role: "NULL" /* NULL */,
-  scanStatus: false
-};
-var initialState = {
-  user: defaultUser,
-  isSignedIn: false,
-  pending: true
-};
-var authSlice = (0, import_toolkit.createSlice)({
-  name: "auth",
-  initialState,
-  reducers: {
-    signIn: (state, action) => {
-      const userData = action.payload;
-      state.user = userData;
-      state.isSignedIn = true;
-      state.pending = false;
-      setUserInfo(userData);
-      setAccessToken(userData.accessToken);
-      setRefreshToken(userData.refreshToken);
-    },
-    signOut: (state) => {
-      state.user = defaultUser;
-      state.isSignedIn = false;
-      state.pending = false;
-      removeUserInfo();
-      removeAccessToken();
-      removeRefreshToken();
-    },
-    updateScanStatus: (state, action) => {
-      state.user.scanStatus = action.payload;
-      setUserInfo(state.user);
-    },
-    refreshUser: (state, action) => {
-      const userData = action.payload;
-      if (userData) {
-        state.user = userData;
-        state.isSignedIn = true;
-        state.pending = false;
-        setUserInfo(userData);
-        setAccessToken(userData.accessToken);
-        setRefreshToken(userData.refreshToken);
-      }
-    },
-    setPending: (state, action) => {
-      state.pending = action.payload;
-    },
-    initializeFromStorage: (state) => {
-      const storedUser = getUserInfo();
-      const accessToken = getAccessToken();
-      if (storedUser && accessToken) {
-        state.user = storedUser;
-        state.isSignedIn = true;
-      }
-      state.pending = false;
-    }
-  }
-});
-var {
-  signIn,
-  signOut,
-  updateScanStatus,
-  refreshUser,
-  setPending,
-  initializeFromStorage
-} = authSlice.actions;
-var selectUser = (state) => state.auth.user;
-var selectIsSignedIn = (state) => state.auth.isSignedIn;
-var selectIsLoading = (state) => state.auth.pending;
-var authSlice_default = authSlice.reducer;
-
-// src/modules/auth/providers/AuthProvider.tsx
-var import_jsx_runtime2 = require("react/jsx-runtime");
-var AuthContext = (0, import_react.createContext)(null);
-function AuthProvider({ children, authService, authCallbacks }) {
-  const dispatch = useAppDispatch();
-  (0, import_react.useEffect)(() => {
-    dispatch(initializeFromStorage());
-    const unsubscribe = authService.onAuthStateChanged((user2) => {
-      if (user2) {
-        dispatch(signIn(user2));
-        if (authCallbacks?.onUserIdentify && user2.email) {
-          authCallbacks.onUserIdentify({
-            email: user2.email,
-            name: user2.displayName,
-            avatar: user2.avatar,
-            uid: user2.uid
-          });
-        }
-        if (authCallbacks?.onSignInSuccess) {
-          authCallbacks.onSignInSuccess(user2);
-        }
-      } else {
-        dispatch(signOut());
-        if (authCallbacks?.onTrackingReset) {
-          authCallbacks.onTrackingReset();
-        }
-      }
-      dispatch(setPending(false));
-    });
-    return () => {
-      unsubscribe();
-    };
-  }, [authService, dispatch, authCallbacks]);
-  const user = useAppSelector(selectUser);
-  const isSignedIn = useAppSelector(selectIsSignedIn);
-  const isLoading = useAppSelector(selectIsLoading);
-  const signInWithCredential = async (email, password) => {
-    const result = await authService.signInWithEmailAndPassword(email, password);
-    if (result.data && authCallbacks?.onSignInSuccess) {
-      authCallbacks.onSignInSuccess(result.data);
-    } else if (result.errorCode && authCallbacks?.onSignInError) {
-      authCallbacks.onSignInError(result.errorCode);
-    }
-    return result;
-  };
-  const signInWithGoogle = async () => {
-    const result = await authService.signInWithGoogle();
-    if (result.data && authCallbacks?.onSignInSuccess) {
-      authCallbacks.onSignInSuccess(result.data);
-      return result;
-    } else if (result.errorCode && authCallbacks?.onSignInError) {
-      authCallbacks.onSignInError(result.errorCode);
-    }
-    return null;
-  };
-  const signUp = async (email, password) => {
-    const result = await authService.signUp(email, password);
-    if (result.data && authCallbacks?.onSignUpSuccess) {
-      authCallbacks.onSignUpSuccess(result.data);
-    } else if (result.errorCode && authCallbacks?.onSignUpError) {
-      authCallbacks.onSignUpError(result.errorCode);
-    }
-    return result;
-  };
-  const signOut2 = async () => {
-    await authService.signOut();
-    dispatch(signOut());
-    if (authCallbacks?.onSignOutSuccess) {
-      authCallbacks.onSignOutSuccess();
-    }
-  };
-  const forgotPassword = async (email) => {
-    return await authService.sendPasswordResetEmail(email);
-  };
-  const sendEmailVerification = async () => {
-    return await authService.sendEmailVerification();
-  };
-  const changePassword = async (newPassword) => {
-    return await authService.changePassword(newPassword);
-  };
-  const updateScanStatus2 = (status) => {
-    dispatch(updateScanStatus(status));
-  };
-  const refreshUser2 = (userData) => {
-    dispatch(refreshUser(userData));
-  };
-  const contextValue = {
-    authService,
-    authCallbacks,
-    // User state
-    user,
-    isSignedIn,
-    isLoading,
-    // Auth actions
-    signInWithCredential,
-    signInWithGoogle,
-    signUp,
-    signOut: signOut2,
-    // Password actions
-    forgotPassword,
-    sendEmailVerification,
-    changePassword,
-    // User management
-    updateScanStatus: updateScanStatus2,
-    refreshUser: refreshUser2
-  };
-  return /* @__PURE__ */ (0, import_jsx_runtime2.jsx)(AuthContext.Provider, { value: contextValue, children });
-}
-var useAuth = () => {
-  const authContext = (0, import_react.useContext)(AuthContext);
-  if (!authContext) {
-    throw new Error("useAuth must be used within an AuthProvider");
-  }
-  return authContext;
-};
-
-// src/modules/auth/index.ts
-init_constants();
-
 // src/modules/user-profile/hooks/index.ts
-var import_api_core3 = require("@phygitallabs/api-core");
+var import_api_core5 = require("@phygitallabs/api-core");
 
 // src/modules/user-profile/types/index.ts
-var import_api_core4 = require("@phygitallabs/api-core");
+var import_api_core6 = require("@phygitallabs/api-core");
 
 // src/modules/scan-chip/hooks/index.tsx
-var import_react2 = require("react");
-var import_api_core5 = require("@phygitallabs/api-core");
-var import_api_core6 = require("@phygitallabs/api-core");
+var import_react3 = require("react");
+var import_api_core7 = require("@phygitallabs/api-core");
+var import_api_core8 = require("@phygitallabs/api-core");
 function useScanChip({ token, id, onScanChipError }) {
-  const { updateHeaders } = (0, import_api_core6.usePGLCoreService)();
-  (0, import_react2.useEffect)(() => {
+  const { updateHeaders } = (0, import_api_core8.usePGLCoreService)();
+  (0, import_react3.useEffect)(() => {
     if (!!token) {
       const header = {
         "Chip-Authorization": token
@@ -1049,11 +1231,11 @@ function useScanChip({ token, id, onScanChipError }) {
       updateHeaders(header);
     }
   }, [token, updateHeaders]);
-  const { data, isLoading, isError, isSuccess } = (0, import_api_core5.useChipScanStory)({
+  const { data, isLoading, isError, isSuccess } = (0, import_api_core7.useChipScanStory)({
     token,
     id
   });
-  (0, import_react2.useEffect)(() => {
+  (0, import_react3.useEffect)(() => {
     if (isError) {
       onScanChipError?.();
     }
@@ -1085,10 +1267,10 @@ function useScanChip({ token, id, onScanChipError }) {
 }
 
 // src/modules/campaign/hooks/useCampaignService.ts
-var import_api_core7 = require("@phygitallabs/api-core");
+var import_api_core9 = require("@phygitallabs/api-core");
 
 // src/modules/campaign/types/enums.ts
-var import_api_core8 = require("@phygitallabs/api-core");
+var import_api_core10 = require("@phygitallabs/api-core");
 
 // src/modules/campaign/types/campaign.ts
 var TaskType = /* @__PURE__ */ ((TaskType2) => {
@@ -1100,7 +1282,7 @@ var TaskType = /* @__PURE__ */ ((TaskType2) => {
 })(TaskType || {});
 
 // src/modules/location/hooks/useLocationService.ts
-var import_api_core9 = require("@phygitallabs/api-core");
+var import_api_core11 = require("@phygitallabs/api-core");
 
 // src/modules/location/utils/locationHelpers.ts
 var sortLocationsByIndex = (locations) => {
@@ -1111,10 +1293,168 @@ var filterLocationsByProperty = (locations, propertyName, value) => {
 };
 
 // src/modules/generate-certificate/hooks/index.ts
-var import_generate_certificate = require("@phygitallabs/generate-certificate");
+var import_generate_certificate2 = require("@phygitallabs/generate-certificate");
+
+// src/modules/generate-certificate/helpers/index.ts
+var import_generate_certificate3 = require("@phygitallabs/generate-certificate");
 
 // src/modules/data-tracking/hooks/index.ts
 var import_posthog_js = __toESM(require("posthog-js"), 1);
+
+// src/modules/session-replay/providers/SessionReplayProvider.tsx
+var import_react4 = require("react");
+var import_uuid2 = require("uuid");
+
+// src/modules/session-replay/utils/index.ts
+var isBrowser = () => {
+  return typeof window !== "undefined";
+};
+
+// src/modules/session-replay/providers/SessionReplayProvider.tsx
+var import_jsx_runtime3 = require("react/jsx-runtime");
+var TrackerContext = (0, import_react4.createContext)(null);
+function defaultGetUserId() {
+  return (0, import_uuid2.v4)();
+}
+async function newTracker(config) {
+  try {
+    const OpenReplay = (await import("@openreplay/tracker")).default;
+    const getUserId = config?.userIdEnabled && config?.getUserId ? config.getUserId : defaultGetUserId;
+    const trackerConfig = {
+      projectKey: config?.projectKey || process.env.NEXT_PUBLIC_OPENREPLAY_PROJECT_KEY,
+      ingestPoint: config?.ingestPoint,
+      // Capture options
+      captureExceptions: config.captureExceptions ?? true,
+      capturePerformance: config.capturePerformance ?? true,
+      // Network tracking
+      network: config.network || {
+        capturePayload: true,
+        sanitizer: (data) => data
+      },
+      // Console tracking
+      console: config.console || {
+        levels: ["error", "warn", "log"]
+      },
+      // Privacy settings
+      obscureTextEmails: config.obscureTextEmails ?? true,
+      obscureTextNumbers: config.obscureTextNumbers ?? false,
+      obscureInputEmails: config.obscureInputEmails ?? true,
+      // Development mode
+      __DISABLE_SECURE_MODE: config.__DISABLE_SECURE_MODE ?? (typeof process !== "undefined" && process.env?.NODE_ENV === "development")
+    };
+    const tracker = new OpenReplay(trackerConfig);
+    if (config?.userIdEnabled) {
+      const userId = getUserId();
+      tracker.setUserID(userId);
+      console.log("User ID set:", userId);
+    }
+    console.log("OpenReplay tracker initialized");
+    console.log("Project Key:", trackerConfig.projectKey);
+    console.log("Ingest Point:", trackerConfig.ingestPoint);
+    return tracker;
+  } catch (error) {
+    console.error("Failed to create tracker:", error);
+    throw error;
+  }
+}
+function reducer(state, action) {
+  const { debug = false } = state.config;
+  switch (action.type) {
+    case "init":
+      if (!state.tracker && isBrowser()) {
+        if (!state.config.projectKey && !process.env.NEXT_PUBLIC_OPENREPLAY_PROJECT_KEY) {
+          console.warn(
+            debug,
+            "Project key not found. Skipping session replay initialization."
+          );
+          return state;
+        }
+        return {
+          ...state,
+          tracker: newTracker(state.config)
+        };
+      }
+      return state;
+    case "start":
+      if (state.tracker) {
+        Promise.resolve(state.tracker).then((tracker) => {
+          tracker.start();
+          console.log(debug, "Session replay tracker started");
+        }).catch((error) => {
+          console.error("Failed to start tracker:", error);
+        });
+      } else {
+        console.warn(debug, "Tracker not initialized. Call initTracker() first.");
+      }
+      return state;
+    case "setUserId":
+      if (state.tracker) {
+        Promise.resolve(state.tracker).then((tracker) => {
+          tracker.setUserID(action.payload);
+          console.log(debug, "User ID updated:", action.payload);
+        }).catch((error) => {
+          console.error("Failed to set user ID:", error);
+        });
+      } else {
+        console.warn(debug, "Tracker not initialized. Call initTracker() first.");
+      }
+      return state;
+    // Set metadata
+    case "setMetadata":
+      if (state.tracker) {
+        Promise.resolve(state.tracker).then((tracker) => {
+          Object.entries(action.payload || {})?.forEach(([key, value]) => {
+            tracker.setMetadata(key, value);
+          });
+          console.log(debug, "Metadata updated:", action.payload.metadata);
+        }).catch((error) => {
+          console.error("Failed to set metadata:", error);
+        });
+      } else {
+        console.warn(debug, "Tracker not initialized. Call initTracker() first.");
+      }
+      return state;
+    default:
+      return state;
+  }
+}
+var SessionReplayProvider = ({
+  children,
+  config = {}
+}) => {
+  const [, dispatch] = (0, import_react4.useReducer)(reducer, {
+    tracker: null,
+    config
+  });
+  const initTracker = () => dispatch({ type: "init" });
+  const startTracking = () => dispatch({ type: "start" });
+  const setUserId = (userId) => dispatch({ type: "setUserId", payload: userId });
+  const setMetadata = (metadata) => dispatch({ type: "setMetadata", payload: metadata });
+  (0, import_react4.useEffect)(() => {
+    initTracker();
+    startTracking();
+  }, []);
+  return /* @__PURE__ */ (0, import_jsx_runtime3.jsx)(TrackerContext.Provider, { value: {
+    initTracker,
+    startTracking,
+    setUserId,
+    setMetadata
+  }, children });
+};
+
+// src/modules/session-replay/hooks/useSessionReplay.ts
+var import_react5 = require("react");
+function useSessionReplay() {
+  const context = (0, import_react5.useContext)(TrackerContext);
+  if (!context) {
+    throw new Error(
+      "useSessionReplay must be used within a SessionReplayProvider. Make sure your component is wrapped with <SessionReplayProvider>."
+    );
+  }
+  return context;
+}
+
+// src/modules/data-tracking/hooks/index.ts
 var pushEventToDataLayer = (event, data) => {
   try {
     window.dataLayer = window.dataLayer || [];
@@ -1137,6 +1477,7 @@ var pushEventToPosthog = (eventName, eventData) => {
   import_posthog_js.default.capture(eventName, eventData);
 };
 function useDataTracking() {
+  const { setUserId, setMetadata } = useSessionReplay();
   const trackEvent = (eventName, eventData, useTools) => {
     useTools = useTools || ["gtm"];
     if (useTools.includes("gtm") && typeof window !== "undefined") {
@@ -1149,91 +1490,58 @@ function useDataTracking() {
       pushEventToPosthog(eventName, eventData);
     }
   };
+  const trackUserIdentify = (userInfo) => {
+    import_posthog_js.default.identify(userInfo.email, {
+      email: userInfo.email,
+      name: userInfo.name,
+      avatar: userInfo.avatar,
+      uid: userInfo.uid
+    });
+    setUserId(userInfo.id);
+    setMetadata({
+      user_email: userInfo.email
+    });
+  };
+  const trackLogoutEvent = () => {
+    import_posthog_js.default.capture("user_signed_out");
+  };
   return {
-    trackEvent
+    trackEvent,
+    trackUserIdentify,
+    trackLogoutEvent
   };
 }
 
 // src/providers/TapquestCoreProvider.tsx
-var import_react4 = require("react");
-var import_react_redux2 = require("react-redux");
-var import_react5 = require("redux-persist/integration/react");
+var import_react7 = require("react");
 
 // src/providers/ServicesProvider.tsx
-var import_react3 = require("react");
-var import_api_core10 = require("@phygitallabs/api-core");
-var import_reward2 = require("@phygitallabs/reward");
-var import_achievement4 = require("@phygitallabs/achievement");
-var import_generate_certificate2 = require("@phygitallabs/generate-certificate");
-var import_axios = __toESM(require("axios"), 1);
-var import_jsx_runtime3 = require("react/jsx-runtime");
+var import_react6 = require("react");
+var import_api_core12 = require("@phygitallabs/api-core");
+var import_reward4 = require("@phygitallabs/reward");
+var import_achievement5 = require("@phygitallabs/achievement");
+var import_generate_certificate4 = require("@phygitallabs/generate-certificate");
+var import_jsx_runtime4 = require("react/jsx-runtime");
 var ServicesProvider = ({
   children,
   queryClient,
   apiConfig = {
     environment: "dev",
     version: "v1"
-  },
-  firebaseConfig
+  }
 }) => {
-  const { refreshUser: refreshUser2, signOut: signOut2 } = useAuth();
   const { environment, version } = apiConfig;
-  const [commonServiceConfig, setCommonServiceConfig] = (0, import_react3.useState)(null);
-  const memoizedRefreshToken = (0, import_react3.useMemo)(() => {
-    if (!firebaseConfig?.apiKey) {
-      console.warn("Firebase API key not provided, refresh token functionality will not work");
-      return null;
-    }
-    return createRefreshTokenFunction({
-      firebaseApiKey: firebaseConfig.apiKey
-    });
-  }, [firebaseConfig?.apiKey]);
-  (0, import_react3.useEffect)(() => {
+  const [commonServiceConfig, setCommonServiceConfig] = (0, import_react6.useState)(null);
+  (0, import_react6.useEffect)(() => {
     const initClient = async () => {
       try {
         const deviceUid = await checkDeviceUid();
         const responseInterceptors = {
           onFulfilled: (response) => response,
-          onRejected: async (error) => {
-            const originalRequest = error.config;
-            if (error.response?.status === 401 && !originalRequest._retry) {
-              const retryAttempts = parseInt(
-                getRetryAttemptsRefreshToken() || "0",
-                10
-              );
-              if (retryAttempts >= httpMaxRetries) {
-                await signOut2();
-                return Promise.reject(error);
-              }
-              setRetryAttemptsRefreshToken(`${retryAttempts + 1}`);
-              originalRequest._retry = true;
-              try {
-                if (!memoizedRefreshToken) {
-                  await signOut2();
-                  return Promise.reject(error);
-                }
-                const result = await memoizedRefreshToken();
-                if (result?.accessToken) {
-                  originalRequest.headers["Authorization"] = `Bearer ${result.accessToken}`;
-                  setRetryAttemptsRefreshToken("0");
-                  refreshUser2(result);
-                  return (0, import_axios.default)(originalRequest);
-                }
-              } catch (refreshError) {
-                console.log("Failed to refresh token:", refreshError);
-              }
-            }
-            return Promise.reject(error);
-          }
+          onRejected: async (error) => Promise.reject(error)
         };
         const requestInterceptors = {
-          onFulfilled: (config2) => {
-            const currentToken = getAccessToken();
-            if (currentToken && !config2.headers.Authorization) {
-              config2.headers.Authorization = `Bearer ${currentToken}`;
-            }
-            return config2;
-          },
+          onFulfilled: (config2) => config2,
           onRejected: (error) => Promise.reject(error)
         };
         const axiosConfig = {
@@ -1257,26 +1565,26 @@ var ServicesProvider = ({
     initClient();
   }, [queryClient]);
   if (!commonServiceConfig) {
-    return /* @__PURE__ */ (0, import_jsx_runtime3.jsx)(import_jsx_runtime3.Fragment, {});
+    return /* @__PURE__ */ (0, import_jsx_runtime4.jsx)(import_jsx_runtime4.Fragment, {});
   }
-  return /* @__PURE__ */ (0, import_jsx_runtime3.jsx)(
-    import_api_core10.PGLCoreServiceProvider,
+  return /* @__PURE__ */ (0, import_jsx_runtime4.jsx)(
+    import_api_core12.PGLCoreServiceProvider,
     {
       ...commonServiceConfig,
       baseURL: `${service_default[environment].API_BASE_URL}/${version}`,
       baseCoreURL: `${service_default[environment].API_BASE_CORE_URL}/${version}`,
-      children: /* @__PURE__ */ (0, import_jsx_runtime3.jsx)(
-        import_reward2.RewardServiceProvider,
+      children: /* @__PURE__ */ (0, import_jsx_runtime4.jsx)(
+        import_reward4.RewardServiceProvider,
         {
           ...commonServiceConfig,
           baseURL: `${service_default[environment].API_REWARD_URL}/v1`,
-          children: /* @__PURE__ */ (0, import_jsx_runtime3.jsx)(
-            import_achievement4.AchievementServiceProvider,
+          children: /* @__PURE__ */ (0, import_jsx_runtime4.jsx)(
+            import_achievement5.AchievementServiceProvider,
             {
               ...commonServiceConfig,
               baseURL: `${service_default[environment].API_ACHIEVEMENT_URL}/${version}`,
-              children: /* @__PURE__ */ (0, import_jsx_runtime3.jsx)(
-                import_generate_certificate2.GenerateCertificateServiceProvider,
+              children: /* @__PURE__ */ (0, import_jsx_runtime4.jsx)(
+                import_generate_certificate4.GenerateCertificateServiceProvider,
                 {
                   ...commonServiceConfig,
                   baseURL: `${service_default[environment].API_GENERATE_CERTIFICATE_URL}/v1`,
@@ -1291,80 +1599,51 @@ var ServicesProvider = ({
   );
 };
 
-// src/store/index.ts
-var import_toolkit2 = require("@reduxjs/toolkit");
-var import_storage = __toESM(require("redux-persist/lib/storage"), 1);
-var import_redux_persist = require("redux-persist");
-var authPersistConfig = {
-  key: "tapquest-auth",
-  storage: import_storage.default,
-  whitelist: ["user", "isSignedIn"]
-  // Only persist user and sign-in status
-};
-var persistedAuthReducer = (0, import_redux_persist.persistReducer)(authPersistConfig, authSlice.reducer);
-var store = (0, import_toolkit2.configureStore)({
-  reducer: {
-    auth: persistedAuthReducer
-  },
-  middleware: (getDefaultMiddleware) => getDefaultMiddleware({
-    serializableCheck: {
-      // Ignore redux-persist actions
-      ignoredActions: [
-        "persist/FLUSH",
-        "persist/REHYDRATE",
-        "persist/PAUSE",
-        "persist/PERSIST",
-        "persist/PURGE",
-        "persist/REGISTER"
-      ]
-    }
-  })
-});
-var persistor = (0, import_redux_persist.persistStore)(store);
-
 // src/providers/TapquestCoreProvider.tsx
-var import_jsx_runtime4 = require("react/jsx-runtime");
+var import_jsx_runtime5 = require("react/jsx-runtime");
 var TapquestCoreProvider = ({
   children,
   queryClient,
-  apiConfig,
-  firebaseConfig,
-  authCallbacks
+  apiConfig
+  // authCallbacks
 }) => {
-  const internalAuthService = (0, import_react4.useMemo)(() => {
-    if (firebaseConfig && typeof window !== "undefined") {
-      try {
-        const { createAuthService: createAuthService2 } = (init_services(), __toCommonJS(services_exports));
-        return createAuthService2({ firebaseConfig });
-      } catch (error) {
-        console.warn("Failed to create auth service from firebase config:", error);
-        return null;
-      }
+  const { environment } = apiConfig;
+  const sessionReplayConfig = (0, import_react7.useMemo)(() => {
+    const projectKey = process.env.NEXT_PUBLIC_OPENREPLAY_PROJECT_KEY;
+    if (!projectKey) {
+      return void 0;
     }
-    return null;
-  }, [firebaseConfig]);
-  return /* @__PURE__ */ (0, import_jsx_runtime4.jsx)(import_react_redux2.Provider, { store, children: /* @__PURE__ */ (0, import_jsx_runtime4.jsx)(import_react5.PersistGate, { loading: null, persistor, children: /* @__PURE__ */ (0, import_jsx_runtime4.jsx)(
-    AuthProvider,
+    return {
+      projectKey,
+      ingestPoint: process.env.NEXT_PUBLIC_OPENREPLAY_INGEST_POINT,
+      debug: process.env.NODE_ENV === "development",
+      captureExceptions: true,
+      capturePerformance: true,
+      obscureTextEmails: true,
+      obscureInputEmails: true
+    };
+  }, []);
+  return /* @__PURE__ */ (0, import_jsx_runtime5.jsx)(SessionReplayProvider, { config: sessionReplayConfig, children: /* @__PURE__ */ (0, import_jsx_runtime5.jsx)(
+    ServicesProvider,
     {
-      authService: internalAuthService,
-      authCallbacks,
-      children: /* @__PURE__ */ (0, import_jsx_runtime4.jsx)(
-        ServicesProvider,
+      queryClient,
+      apiConfig,
+      children: /* @__PURE__ */ (0, import_jsx_runtime5.jsx)(
+        AuthProvider,
         {
+          baseURL: `${service_default[environment].API_BASE_URL}`,
           queryClient,
-          apiConfig,
-          firebaseConfig,
           children
         }
       )
     }
-  ) }) });
+  ) });
 };
 
 // src/modules/achivementWithReward/hooks/achivementPlusRewardModel.ts
-var import_achievement5 = require("@phygitallabs/achievement");
+var import_achievement6 = require("@phygitallabs/achievement");
 var import_useGroupReward = require("@phygitallabs/reward/src/hooks/useGroupReward");
-var import_react6 = require("react");
+var import_react8 = require("react");
 function buildMappedAchievements(achievements, groupRewardData) {
   if (!groupRewardData?.reward_models) return [];
   const rewardModels = groupRewardData.reward_models;
@@ -1386,7 +1665,7 @@ function buildMappedAchievements(achievements, groupRewardData) {
   });
 }
 var useAchivementPlusRewardModel = ({ campaignId }) => {
-  const { data: achievements, isLoading: isLoadingAchievements } = (0, import_achievement5.useManyAchievements)(
+  const { data: achievements, isLoading: isLoadingAchievements } = (0, import_achievement6.useManyAchievements)(
     {
       "filter.labels": { campaign_id: campaignId },
       "filter.type": "group_mission",
@@ -1394,7 +1673,7 @@ var useAchivementPlusRewardModel = ({ campaignId }) => {
     },
     { enabled: !!campaignId }
   );
-  const groupRewardIds = (0, import_react6.useMemo)(() => {
+  const groupRewardIds = (0, import_react8.useMemo)(() => {
     if (!achievements?.data) return [];
     return achievements.data.map((achievement) => achievement.groupRewardId).filter((id) => id !== void 0);
   }, [achievements?.data]);
@@ -1403,12 +1682,12 @@ var useAchivementPlusRewardModel = ({ campaignId }) => {
     data: groupRewardModelsData,
     isPending: isPendingGroupRewardModels
   } = (0, import_useGroupReward.useCreateModelGroupReward)();
-  (0, import_react6.useEffect)(() => {
+  (0, import_react8.useEffect)(() => {
     if (groupRewardIds.length > 0) {
       fetchGroupRewardModels({ group_reward_ids: groupRewardIds });
     }
   }, [groupRewardIds, fetchGroupRewardModels]);
-  const mappedAchievements = (0, import_react6.useMemo)(() => {
+  const mappedAchievements = (0, import_react8.useMemo)(() => {
     if (!groupRewardModelsData?.data || !achievements?.data) return [];
     return buildMappedAchievements(achievements.data, groupRewardModelsData.data);
   }, [groupRewardModelsData, achievements?.data]);
@@ -1420,16 +1699,18 @@ var useAchivementPlusRewardModel = ({ campaignId }) => {
 var achivementPlusRewardModel_default = useAchivementPlusRewardModel;
 
 // src/modules/send-email/hooks/index.ts
-var import_api_core11 = require("@phygitallabs/api-core");
+var import_api_core13 = require("@phygitallabs/api-core");
 
 // src/helper/helpers.ts
 var import_helpers5 = require("@phygitallabs/helpers");
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
+  ALLOWED_ORIGINS,
   AchievementRuleActionType,
   AchievementServiceProvider,
   AchievementType,
   AuthProvider,
+  CALLBACK_URL,
   CampaignState,
   CmentityRewardType,
   NotificationProvider,
@@ -1442,7 +1723,6 @@ var import_helpers5 = require("@phygitallabs/helpers");
   chipAuthTokenKey,
   cn,
   convertSnakeToCamel,
-  createRefreshTokenFunction,
   deviceUIDKey,
   fileToBase64,
   filterLocationsByProperty,
@@ -1483,6 +1763,9 @@ var import_helpers5 = require("@phygitallabs/helpers");
   useChipScanStory,
   useClaimUserReward,
   useClearUserRewardCache,
+  useCreateCertificate,
+  useCreateCertificateAnonymous,
+  useCreateCertificateWithMask,
   useCreateMemory,
   useCreateModelGroupReward,
   useCreateRewardModel,
@@ -1493,6 +1776,7 @@ var import_helpers5 = require("@phygitallabs/helpers");
   useGenerateThaocamvienCertificate,
   useGetRewardModel,
   useGetUserRewards,
+  useGoogleLogin,
   useInfiniteMemories,
   useListRewardModels,
   useLocationDetail,
@@ -1519,6 +1803,7 @@ var import_helpers5 = require("@phygitallabs/helpers");
   useUserAchievementAction,
   useUserCampaignAction,
   useV1ListRewards,
-  userInfoKey
+  userInfoKey,
+  wrapTextWithFont
 });
 //# sourceMappingURL=index.cjs.map