@novu/js 3.9.2 → 3.10.0

package/dist/esm/{chunk-3CKXF2I4.mjs → chunk-OMH4MVCZ.mjs}

@@ -141,7 +141,7 @@ function checkNotificationMatchesFilter(notification, filter) {
 
 // src/api/http-client.ts
 var DEFAULT_API_VERSION = "v1";
-var DEFAULT_USER_AGENT = `${"@novu/js"}@${"3.9.2"}`;
+var DEFAULT_USER_AGENT = `${"@novu/js"}@${"3.10.0"}`;
 var HttpClient = class {
   constructor(options = {}) {
     // Environment variable for local development that overrides the default API endpoint without affecting the Inbox DX
@@ -269,12 +269,14 @@ var InboxService = class {
     return __async(this, arguments, function* ({
       applicationIdentifier,
       subscriberHash,
-      subscriber
+      subscriber,
+      defaultSchedule
     }) {
       const response = yield __privateGet(this, _httpClient).post(`${INBOX_ROUTE}/session`, {
         applicationIdentifier,
         subscriberHash,
-        subscriber
+        subscriber,
+        defaultSchedule
       });
       __privateGet(this, _httpClient).setAuthorizationToken(response.token);
       __privateGet(this, _httpClient).setKeylessHeader(response.applicationIdentifier);
@@ -377,6 +379,15 @@ var InboxService = class {
       data: data ? JSON.stringify(data) : void 0
     });
   }
+  delete(notificationId) {
+    return __privateGet(this, _httpClient).delete(`${INBOX_NOTIFICATIONS_ROUTE}/${notificationId}/delete`);
+  }
+  deleteAll({ tags, data }) {
+    return __privateGet(this, _httpClient).post(`${INBOX_NOTIFICATIONS_ROUTE}/delete`, {
+      tags,
+      data: data ? JSON.stringify(data) : void 0
+    });
+  }
   markAsSeen({
     notificationIds,
     tags,
@@ -434,8 +445,8 @@ var InboxService = class {
   bulkUpdatePreferences(preferences) {
     return __privateGet(this, _httpClient).patch(`${INBOX_ROUTE}/preferences/bulk`, { preferences });
   }
-  updateGlobalPreferences(channels) {
-    return __privateGet(this, _httpClient).patch(`${INBOX_ROUTE}/preferences`, channels);
+  updateGlobalPreferences(preferences) {
+    return __privateGet(this, _httpClient).patch(`${INBOX_ROUTE}/preferences`, preferences);
   }
   updateWorkflowPreferences({
     workflowId,
@@ -443,6 +454,9 @@ var InboxService = class {
   }) {
     return __privateGet(this, _httpClient).patch(`${INBOX_ROUTE}/preferences/${workflowId}`, channels);
   }
+  fetchGlobalPreferences() {
+    return __privateGet(this, _httpClient).get(`${INBOX_ROUTE}/preferences/global`);
+  }
   triggerHelloWorldEvent() {
     const payload = {
       name: "hello-world",
@@ -915,6 +929,49 @@ var archiveAllRead = (_0) => __async(void 0, [_0], function* ({
     return { error: new NovuError("Failed to archive all read notifications", error) };
   }
 });
+var deleteNotification = (_0) => __async(void 0, [_0], function* ({
+  emitter,
+  apiService,
+  args
+}) {
+  const { notificationId } = getNotificationDetails(
+    args,
+    {},
+    {
+      emitter,
+      apiService
+    }
+  );
+  try {
+    emitter.emit("notification.delete.pending", {
+      args
+    });
+    yield apiService.delete(notificationId);
+    emitter.emit("notification.delete.resolved", { args });
+    return {};
+  } catch (error) {
+    emitter.emit("notification.delete.resolved", { args, error });
+    return { error: new NovuError("Failed to delete notification", error) };
+  }
+});
+var deleteAll = (_0) => __async(void 0, [_0], function* ({
+  emitter,
+  inboxService,
+  notificationsCache,
+  tags,
+  data
+}) {
+  try {
+    const notifications = notificationsCache.getUniqueNotifications({ tags, data });
+    emitter.emit("notifications.delete_all.pending", { args: { tags, data }, data: notifications });
+    yield inboxService.deleteAll({ tags, data });
+    emitter.emit("notifications.delete_all.resolved", { args: { tags, data } });
+    return {};
+  } catch (error) {
+    emitter.emit("notifications.delete_all.resolved", { args: { tags, data }, error });
+    return { error: new NovuError("Failed to delete all notifications", error) };
+  }
+});
 
 // src/notifications/notification.ts
 var _emitter, _inboxService;
@@ -994,6 +1051,15 @@ var Notification = class {
       }
     });
   }
+  delete() {
+    return deleteNotification({
+      emitter: __privateGet(this, _emitter),
+      apiService: __privateGet(this, _inboxService),
+      args: {
+        notification: this
+      }
+    });
+  }
   snooze(snoozeUntil) {
     return snooze({
       emitter: __privateGet(this, _emitter),
@@ -1223,8 +1289,10 @@ var removeEvents = [
   "notification.unarchive.pending",
   "notification.snooze.pending",
   "notification.unsnooze.pending",
+  "notification.delete.pending",
   "notifications.archive_all.pending",
-  "notifications.archive_all_read.pending"
+  "notifications.archive_all_read.pending",
+  "notifications.delete_all.pending"
 ];
 var _emitter2, _cache2;
 var NotificationsCache = class {
@@ -1264,11 +1332,35 @@ var NotificationsCache = class {
       }));
       return true;
     };
-    this.handleNotificationEvent = ({ remove } = { remove: false }) => ({ data }) => {
-      if (!data) {
+    this.handleNotificationEvent = ({ remove } = { remove: false }) => (event) => {
+      const { data, args } = event;
+      let notifications = [];
+      if (data !== void 0 && data !== null) {
+        if (Array.isArray(data) && data.every((item) => typeof item === "object" && "id" in item)) {
+          notifications = data;
+        } else if (typeof data === "object" && "id" in data) {
+          notifications = [data];
+        }
+      } else if (remove && args) {
+        if ("notification" in args && args.notification) {
+          notifications = [args.notification];
+        } else if ("notificationId" in args && args.notificationId) {
+          const foundNotifications = [];
+          __privateGet(this, _cache2).keys().forEach((key) => {
+            const cachedResponse = __privateGet(this, _cache2).get(key);
+            if (cachedResponse) {
+              const found = cachedResponse.notifications.find((n) => n.id === args.notificationId);
+              if (found) {
+                foundNotifications.push(found);
+              }
+            }
+          });
+          notifications = foundNotifications;
+        }
+      }
+      if (notifications.length === 0) {
         return;
       }
-      const notifications = Array.isArray(data) ? data : [data];
       const uniqueFilterKeys = /* @__PURE__ */ new Set();
       __privateGet(this, _cache2).keys().forEach((key) => {
         notifications.forEach((notification) => {
@@ -1524,6 +1616,19 @@ var Notifications = class extends BaseModule {
       );
     });
   }
+  delete(args) {
+    return __async(this, null, function* () {
+      return this.callWithSession(
+        () => __async(this, null, function* () {
+          return deleteNotification({
+            emitter: this._emitter,
+            apiService: this._inboxService,
+            args
+          });
+        })
+      );
+    });
+  }
   snooze(args) {
     return __async(this, null, function* () {
       return this.callWithSession(
@@ -1679,11 +1784,30 @@ var Notifications = class extends BaseModule {
       );
     });
   }
+  deleteAll() {
+    return __async(this, arguments, function* ({
+      tags,
+      data
+    } = {}) {
+      return this.callWithSession(
+        () => __async(this, null, function* () {
+          return deleteAll({
+            emitter: this._emitter,
+            inboxService: this._inboxService,
+            notificationsCache: this.cache,
+            tags,
+            data
+          });
+        })
+      );
+    });
+  }
   clearCache({ filter } = {}) {
     if (filter) {
-      return this.cache.clear(filter != null ? filter : {});
+      this.cache.clear(filter != null ? filter : {});
+      return;
     }
-    return this.cache.clearAll();
+    this.cache.clearAll();
   }
   triggerHelloWorldEvent() {
     return __async(this, null, function* () {
@@ -1693,115 +1817,77 @@ var Notifications = class extends BaseModule {
 };
 _useCache = new WeakMap();
 
-// src/cache/preferences-cache.ts
-var updateEvents2 = [
-  "preference.update.pending",
-  "preference.update.resolved",
-  "preferences.bulk_update.pending",
-  "preferences.bulk_update.resolved"
-];
-var excludeEmpty2 = ({ tags, severity }) => Object.entries({ tags, severity }).reduce((acc, [key, value]) => {
-  if (value === null || value === void 0 || Array.isArray(value) && value.length === 0) {
-    return acc;
-  }
-  acc[key] = value;
-  return acc;
-}, {});
-var getCacheKey2 = ({ tags, severity }) => {
-  return JSON.stringify(excludeEmpty2({ tags, severity }));
-};
-var _emitter3, _cache3;
-var PreferencesCache = class {
-  constructor({ emitterInstance }) {
+// src/preferences/schedule.ts
+var _emitter3, _apiService, _cache3, _useCache2;
+var Schedule = class {
+  constructor(schedule, {
+    emitterInstance,
+    inboxServiceInstance,
+    cache,
+    useCache
+  }) {
     __privateAdd(this, _emitter3);
+    __privateAdd(this, _apiService);
     __privateAdd(this, _cache3);
-    this.updatePreference = (key, data) => {
-      const preferences = __privateGet(this, _cache3).get(key);
-      if (!preferences) {
-        return false;
-      }
-      const index = preferences.findIndex(
-        (el) => {
-          var _a, _b;
-          return ((_a = el.workflow) == null ? void 0 : _a.id) === ((_b = data.workflow) == null ? void 0 : _b.id) || el.level === data.level && data.level === "global" /* GLOBAL */;
-        }
-      );
-      if (index === -1) {
-        return false;
-      }
-      const updatedPreferences = [...preferences];
-      updatedPreferences[index] = data;
-      __privateGet(this, _cache3).set(key, updatedPreferences);
-      return true;
-    };
-    this.handlePreferenceEvent = ({ data }) => {
-      if (!data) {
-        return;
-      }
-      const preferences = Array.isArray(data) ? data : [data];
-      const uniqueFilterKeys = /* @__PURE__ */ new Set();
-      __privateGet(this, _cache3).keys().forEach((key) => {
-        preferences.forEach((preference) => {
-          const hasUpdatedPreference = this.updatePreference(key, preference);
-          const updatedPreference = __privateGet(this, _cache3).get(key);
-          if (!hasUpdatedPreference || !updatedPreference) {
-            return;
-          }
-          uniqueFilterKeys.add(key);
-        });
-      });
-      uniqueFilterKeys.forEach((key) => {
-        var _a;
-        __privateGet(this, _emitter3).emit("preferences.list.updated", {
-          data: (_a = __privateGet(this, _cache3).get(key)) != null ? _a : []
-        });
-      });
-    };
+    __privateAdd(this, _useCache2);
     __privateSet(this, _emitter3, emitterInstance);
-    updateEvents2.forEach((event) => {
-      __privateGet(this, _emitter3).on(event, this.handlePreferenceEvent);
-    });
-    __privateSet(this, _cache3, new InMemoryCache());
-  }
-  has(args) {
-    return __privateGet(this, _cache3).get(getCacheKey2(args)) !== void 0;
-  }
-  set(args, data) {
-    __privateGet(this, _cache3).set(getCacheKey2(args), data);
-  }
-  getAll(args) {
-    if (this.has(args)) {
-      return __privateGet(this, _cache3).get(getCacheKey2(args));
-    }
+    __privateSet(this, _apiService, inboxServiceInstance);
+    __privateSet(this, _cache3, cache);
+    __privateSet(this, _useCache2, useCache);
+    this.isEnabled = schedule.isEnabled;
+    this.weeklySchedule = schedule.weeklySchedule;
   }
-  clearAll() {
-    __privateGet(this, _cache3).clear();
+  update(args) {
+    return __async(this, null, function* () {
+      var _a;
+      const hasWeeklySchedule = !!args.weeklySchedule || !!this.weeklySchedule;
+      return updateSchedule({
+        emitter: __privateGet(this, _emitter3),
+        apiService: __privateGet(this, _apiService),
+        cache: __privateGet(this, _cache3),
+        useCache: __privateGet(this, _useCache2),
+        args: __spreadValues({
+          isEnabled: (_a = args.isEnabled) != null ? _a : this.isEnabled
+        }, hasWeeklySchedule && {
+          weeklySchedule: __spreadValues(__spreadValues({}, this.weeklySchedule), args.weeklySchedule)
+        })
+      });
+    });
   }
 };
 _emitter3 = new WeakMap();
+_apiService = new WeakMap();
 _cache3 = new WeakMap();
+_useCache2 = new WeakMap();
 
 // src/preferences/preference.ts
-var _emitter4, _apiService, _cache4, _useCache2;
+var _emitter4, _apiService2, _cache4, _scheduleCache, _useCache3;
 var Preference = class {
   constructor(preference, {
     emitterInstance,
     inboxServiceInstance,
     cache,
+    scheduleCache,
     useCache
   }) {
     __privateAdd(this, _emitter4);
-    __privateAdd(this, _apiService);
+    __privateAdd(this, _apiService2);
     __privateAdd(this, _cache4);
-    __privateAdd(this, _useCache2);
+    __privateAdd(this, _scheduleCache);
+    __privateAdd(this, _useCache3);
     __privateSet(this, _emitter4, emitterInstance);
-    __privateSet(this, _apiService, inboxServiceInstance);
+    __privateSet(this, _apiService2, inboxServiceInstance);
     __privateSet(this, _cache4, cache);
-    __privateSet(this, _useCache2, useCache);
+    __privateSet(this, _scheduleCache, scheduleCache);
+    __privateSet(this, _useCache3, useCache);
     this.level = preference.level;
     this.enabled = preference.enabled;
     this.channels = preference.channels;
     this.workflow = preference.workflow;
+    this.schedule = new Schedule(
+      __spreadValues({}, preference.schedule),
+      { emitterInstance, inboxServiceInstance, cache: scheduleCache, useCache }
+    );
   }
   update({
     channels,
@@ -1810,9 +1896,10 @@ var Preference = class {
     var _a;
     return updatePreference({
       emitter: __privateGet(this, _emitter4),
-      apiService: __privateGet(this, _apiService),
+      apiService: __privateGet(this, _apiService2),
       cache: __privateGet(this, _cache4),
-      useCache: __privateGet(this, _useCache2),
+      scheduleCache: __privateGet(this, _scheduleCache),
+      useCache: __privateGet(this, _useCache3),
       args: {
         workflowId: (_a = this.workflow) == null ? void 0 : _a.id,
         channels: channels || channelPreferences,
@@ -1822,15 +1909,17 @@ var Preference = class {
   }
 };
 _emitter4 = new WeakMap();
-_apiService = new WeakMap();
+_apiService2 = new WeakMap();
 _cache4 = new WeakMap();
-_useCache2 = new WeakMap();
+_scheduleCache = new WeakMap();
+_useCache3 = new WeakMap();
 
 // src/preferences/helpers.ts
 var updatePreference = (_0) => __async(void 0, [_0], function* ({
   emitter,
   apiService,
   cache,
+  scheduleCache,
   useCache,
   args
 }) {
@@ -1848,6 +1937,7 @@ var updatePreference = (_0) => __async(void 0, [_0], function* ({
           emitterInstance: emitter,
           inboxServiceInstance: apiService,
           cache,
+          scheduleCache,
           useCache
         }
       ) : void 0
@@ -1856,13 +1946,14 @@ var updatePreference = (_0) => __async(void 0, [_0], function* ({
     if (workflowId) {
       response = yield apiService.updateWorkflowPreferences({ workflowId, channels });
     } else {
-      optimisticUpdateWorkflowPreferences({ emitter, apiService, cache, useCache, args });
+      optimisticUpdateWorkflowPreferences({ emitter, apiService, cache, scheduleCache, useCache, args });
       response = yield apiService.updateGlobalPreferences(channels);
     }
     const preference = new Preference(response, {
       emitterInstance: emitter,
       inboxServiceInstance: apiService,
       cache,
+      scheduleCache,
       useCache
     });
     emitter.emit("preference.update.resolved", { args, data: preference });
@@ -1876,6 +1967,7 @@ var bulkUpdatePreference = (_0) => __async(void 0, [_0], function* ({
   emitter,
   apiService,
   cache,
+  scheduleCache,
   useCache,
   args
 }) {
@@ -1893,6 +1985,7 @@ var bulkUpdatePreference = (_0) => __async(void 0, [_0], function* ({
           emitterInstance: emitter,
           inboxServiceInstance: apiService,
           cache,
+          scheduleCache,
           useCache
         }
       ) : void 0
@@ -1913,6 +2006,7 @@ var bulkUpdatePreference = (_0) => __async(void 0, [_0], function* ({
         emitterInstance: emitter,
         inboxServiceInstance: apiService,
         cache,
+        scheduleCache,
         useCache
       })
     );
@@ -1927,6 +2021,7 @@ var optimisticUpdateWorkflowPreferences = ({
   emitter,
   apiService,
   cache,
+  scheduleCache,
   useCache,
   args
 }) => {
@@ -1946,6 +2041,7 @@ var optimisticUpdateWorkflowPreferences = ({
         emitterInstance: emitter,
         inboxServiceInstance: apiService,
         cache,
+        scheduleCache,
         useCache
       }) : void 0;
       if (updatedPreference) {
@@ -1960,9 +2056,326 @@ var optimisticUpdateWorkflowPreferences = ({
     }
   });
 };
+var updateSchedule = (_0) => __async(void 0, [_0], function* ({
+  emitter,
+  apiService,
+  cache,
+  useCache,
+  args
+}) {
+  var _a, _b;
+  try {
+    const { isEnabled, weeklySchedule } = args;
+    const optimisticallyUpdatedSchedule = new Schedule(
+      {
+        isEnabled,
+        weeklySchedule
+      },
+      {
+        emitterInstance: emitter,
+        inboxServiceInstance: apiService,
+        cache,
+        useCache
+      }
+    );
+    emitter.emit("preference.schedule.update.pending", { args, data: optimisticallyUpdatedSchedule });
+    const response = yield apiService.updateGlobalPreferences({
+      schedule: {
+        isEnabled,
+        weeklySchedule
+      }
+    });
+    const updatedSchedule = new Schedule(
+      {
+        isEnabled: (_a = response.schedule) == null ? void 0 : _a.isEnabled,
+        weeklySchedule: (_b = response.schedule) == null ? void 0 : _b.weeklySchedule
+      },
+      {
+        emitterInstance: emitter,
+        inboxServiceInstance: apiService,
+        cache,
+        useCache
+      }
+    );
+    emitter.emit("preference.schedule.update.resolved", {
+      args,
+      data: updatedSchedule
+    });
+    return { data: updatedSchedule };
+  } catch (error) {
+    emitter.emit("preference.schedule.update.resolved", { args, error });
+    return { error: new NovuError("Failed to update preference", error) };
+  }
+});
+
+// src/preferences/preference-schedule.ts
+var _useCache4;
+var PreferenceSchedule = class extends BaseModule {
+  constructor({
+    cache,
+    useCache,
+    inboxServiceInstance,
+    eventEmitterInstance
+  }) {
+    super({
+      eventEmitterInstance,
+      inboxServiceInstance
+    });
+    __privateAdd(this, _useCache4);
+    this.cache = cache;
+    __privateSet(this, _useCache4, useCache);
+  }
+  get() {
+    return __async(this, null, function* () {
+      return this.callWithSession(() => __async(this, null, function* () {
+        var _a, _b;
+        try {
+          let data = __privateGet(this, _useCache4) ? this.cache.getAll() : void 0;
+          this._emitter.emit("preference.schedule.get.pending", { args: void 0, data });
+          if (!data) {
+            const globalPreference = yield this._inboxService.fetchGlobalPreferences();
+            data = new Schedule(
+              {
+                isEnabled: (_a = globalPreference == null ? void 0 : globalPreference.schedule) == null ? void 0 : _a.isEnabled,
+                weeklySchedule: (_b = globalPreference == null ? void 0 : globalPreference.schedule) == null ? void 0 : _b.weeklySchedule
+              },
+              {
+                emitterInstance: this._emitter,
+                inboxServiceInstance: this._inboxService,
+                cache: this.cache,
+                useCache: __privateGet(this, _useCache4)
+              }
+            );
+            if (__privateGet(this, _useCache4)) {
+              this.cache.set(data);
+              data = this.cache.getAll();
+            }
+          }
+          this._emitter.emit("preference.schedule.get.resolved", {
+            args: void 0,
+            data
+          });
+          return { data };
+        } catch (error) {
+          this._emitter.emit("preference.schedule.get.resolved", { args: void 0, error });
+          throw error;
+        }
+      }));
+    });
+  }
+  update(args) {
+    return __async(this, null, function* () {
+      return this.callWithSession(
+        () => updateSchedule({
+          emitter: this._emitter,
+          apiService: this._inboxService,
+          cache: this.cache,
+          useCache: __privateGet(this, _useCache4),
+          args
+        })
+      );
+    });
+  }
+};
+_useCache4 = new WeakMap();
+
+// src/cache/preferences-cache.ts
+var updateEvents2 = [
+  "preference.update.pending",
+  "preference.update.resolved",
+  "preferences.bulk_update.pending",
+  "preferences.bulk_update.resolved"
+];
+var scheduleUpdateEvents = [
+  "preference.schedule.update.pending",
+  "preference.schedule.update.resolved"
+];
+var excludeEmpty2 = ({ tags, severity }) => Object.entries({ tags, severity }).reduce((acc, [key, value]) => {
+  if (value === null || value === void 0 || Array.isArray(value) && value.length === 0) {
+    return acc;
+  }
+  acc[key] = value;
+  return acc;
+}, {});
+var getCacheKey2 = ({ tags, severity }) => {
+  return JSON.stringify(excludeEmpty2({ tags, severity }));
+};
+var _emitter5, _cache5;
+var PreferencesCache = class {
+  constructor({ emitterInstance }) {
+    __privateAdd(this, _emitter5);
+    __privateAdd(this, _cache5);
+    this.updatePreference = (key, data) => {
+      const preferences = __privateGet(this, _cache5).get(key);
+      if (!preferences) {
+        return false;
+      }
+      const index = preferences.findIndex(
+        (el) => {
+          var _a, _b;
+          return ((_a = el.workflow) == null ? void 0 : _a.id) === ((_b = data.workflow) == null ? void 0 : _b.id) || el.level === data.level && data.level === "global" /* GLOBAL */;
+        }
+      );
+      if (index === -1) {
+        return false;
+      }
+      const updatedPreferences = [...preferences];
+      updatedPreferences[index] = data;
+      __privateGet(this, _cache5).set(key, updatedPreferences);
+      return true;
+    };
+    this.updatePreferenceSchedule = (key, data) => {
+      const preferences = __privateGet(this, _cache5).get(key);
+      if (!preferences) {
+        return false;
+      }
+      const index = preferences.findIndex((el) => el.level === "global" /* GLOBAL */);
+      if (index === -1) {
+        return false;
+      }
+      const updatedPreferences = [...preferences];
+      updatedPreferences[index].schedule = data;
+      __privateGet(this, _cache5).set(key, updatedPreferences);
+      return true;
+    };
+    this.handleScheduleEvent = ({ data }) => {
+      var _a;
+      if (!data) {
+        return;
+      }
+      const cacheKeys = __privateGet(this, _cache5).keys();
+      const uniqueFilterKeys = /* @__PURE__ */ new Set();
+      for (const key of cacheKeys) {
+        const hasUpdatedPreference = this.updatePreferenceSchedule(key, data);
+        const updatedPreference = __privateGet(this, _cache5).get(key);
+        if (!hasUpdatedPreference || !updatedPreference) {
+          continue;
+        }
+        uniqueFilterKeys.add(key);
+      }
+      for (const key of uniqueFilterKeys) {
+        __privateGet(this, _emitter5).emit("preferences.list.updated", {
+          data: (_a = __privateGet(this, _cache5).get(key)) != null ? _a : []
+        });
+      }
+    };
+    this.handlePreferenceEvent = ({ data }) => {
+      if (!data) {
+        return;
+      }
+      const preferences = Array.isArray(data) ? data : [data];
+      const uniqueFilterKeys = /* @__PURE__ */ new Set();
+      __privateGet(this, _cache5).keys().forEach((key) => {
+        preferences.forEach((preference) => {
+          const hasUpdatedPreference = this.updatePreference(key, preference);
+          const updatedPreference = __privateGet(this, _cache5).get(key);
+          if (!hasUpdatedPreference || !updatedPreference) {
+            return;
+          }
+          uniqueFilterKeys.add(key);
+        });
+      });
+      uniqueFilterKeys.forEach((key) => {
+        var _a;
+        __privateGet(this, _emitter5).emit("preferences.list.updated", {
+          data: (_a = __privateGet(this, _cache5).get(key)) != null ? _a : []
+        });
+      });
+    };
+    __privateSet(this, _emitter5, emitterInstance);
+    for (const event of updateEvents2) {
+      __privateGet(this, _emitter5).on(event, this.handlePreferenceEvent);
+    }
+    for (const event of scheduleUpdateEvents) {
+      __privateGet(this, _emitter5).on(event, this.handleScheduleEvent);
+    }
+    __privateSet(this, _cache5, new InMemoryCache());
+  }
+  has(args) {
+    return __privateGet(this, _cache5).get(getCacheKey2(args)) !== void 0;
+  }
+  set(args, data) {
+    __privateGet(this, _cache5).set(getCacheKey2(args), data);
+  }
+  getAll(args) {
+    if (this.has(args)) {
+      return __privateGet(this, _cache5).get(getCacheKey2(args));
+    }
+  }
+  clearAll() {
+    __privateGet(this, _cache5).clear();
+  }
+};
+_emitter5 = new WeakMap();
+_cache5 = new WeakMap();
+
+// src/cache/schedule-cache.ts
+var updateEvents3 = [
+  "preference.schedule.update.pending",
+  "preference.schedule.update.resolved"
+];
+var getCacheKey3 = () => {
+  return "schedule";
+};
+var _emitter6, _cache6;
+var ScheduleCache = class {
+  constructor({ emitterInstance }) {
+    __privateAdd(this, _emitter6);
+    __privateAdd(this, _cache6);
+    this.updateScheduleInCache = (key, data) => {
+      const schedule = __privateGet(this, _cache6).get(key);
+      if (!schedule) {
+        return false;
+      }
+      __privateGet(this, _cache6).set(key, data);
+      return true;
+    };
+    this.handleScheduleEvent = ({ data }) => {
+      if (!data) {
+        return;
+      }
+      const uniqueFilterKeys = /* @__PURE__ */ new Set();
+      const keys = __privateGet(this, _cache6).keys();
+      for (const key of keys) {
+        const hasUpdatedSchedule = this.updateScheduleInCache(key, data);
+        const updatedSchedule = __privateGet(this, _cache6).get(key);
+        if (!hasUpdatedSchedule || !updatedSchedule) {
+          continue;
+        }
+        uniqueFilterKeys.add(key);
+      }
+      for (const key of uniqueFilterKeys) {
+        __privateGet(this, _emitter6).emit("preference.schedule.get.updated", {
+          data: __privateGet(this, _cache6).get(key)
+        });
+      }
+    };
+    __privateSet(this, _emitter6, emitterInstance);
+    for (const event of updateEvents3) {
+      __privateGet(this, _emitter6).on(event, this.handleScheduleEvent);
+    }
+    __privateSet(this, _cache6, new InMemoryCache());
+  }
+  has() {
+    return __privateGet(this, _cache6).get(getCacheKey3()) !== void 0;
+  }
+  set(data) {
+    __privateGet(this, _cache6).set(getCacheKey3(), data);
+  }
+  getAll() {
+    if (this.has()) {
+      return __privateGet(this, _cache6).get(getCacheKey3());
+    }
+  }
+  clearAll() {
+    __privateGet(this, _cache6).clear();
+  }
+};
+_emitter6 = new WeakMap();
+_cache6 = new WeakMap();
 
 // src/preferences/preferences.ts
-var _useCache3;
+var _useCache5;
 var Preferences = class extends BaseModule {
   constructor({
     useCache,
@@ -1973,18 +2386,27 @@ var Preferences = class extends BaseModule {
       eventEmitterInstance,
       inboxServiceInstance
     });
-    __privateAdd(this, _useCache3);
+    __privateAdd(this, _useCache5);
     this.cache = new PreferencesCache({
       emitterInstance: this._emitter
     });
-    __privateSet(this, _useCache3, useCache);
+    this.scheduleCache = new ScheduleCache({
+      emitterInstance: this._emitter
+    });
+    __privateSet(this, _useCache5, useCache);
+    this.schedule = new PreferenceSchedule({
+      cache: this.scheduleCache,
+      useCache,
+      inboxServiceInstance,
+      eventEmitterInstance
+    });
   }
   list() {
     return __async(this, arguments, function* (args = {}) {
       return this.callWithSession(() => __async(this, null, function* () {
         var _a;
         try {
-          let data = __privateGet(this, _useCache3) ? this.cache.getAll(args) : void 0;
+          let data = __privateGet(this, _useCache5) ? this.cache.getAll(args) : void 0;
           this._emitter.emit("preferences.list.pending", { args, data });
           if (!data) {
             const response = yield this._inboxService.fetchPreferences({
@@ -1997,10 +2419,11 @@ var Preferences = class extends BaseModule {
                 emitterInstance: this._emitter,
                 inboxServiceInstance: this._inboxService,
                 cache: this.cache,
-                useCache: __privateGet(this, _useCache3)
+                scheduleCache: this.scheduleCache,
+                useCache: __privateGet(this, _useCache5)
               })
             );
-            if (__privateGet(this, _useCache3)) {
+            if (__privateGet(this, _useCache5)) {
               this.cache.set(args, data);
               data = this.cache.getAll(args);
             }
@@ -2021,7 +2444,8 @@ var Preferences = class extends BaseModule {
           emitter: this._emitter,
           apiService: this._inboxService,
           cache: this.cache,
-          useCache: __privateGet(this, _useCache3),
+          scheduleCache: this.scheduleCache,
+          useCache: __privateGet(this, _useCache5),
           args
         })
       );
@@ -2034,14 +2458,15 @@ var Preferences = class extends BaseModule {
           emitter: this._emitter,
           apiService: this._inboxService,
           cache: this.cache,
-          useCache: __privateGet(this, _useCache3),
+          scheduleCache: this.scheduleCache,
+          useCache: __privateGet(this, _useCache5),
           args
         })
       );
     });
   }
 };
-_useCache3 = new WeakMap();
+_useCache5 = new WeakMap();
 
 // src/utils/is-browser.ts
 function isBrowser() {
@@ -2049,13 +2474,13 @@ function isBrowser() {
 }
 
 // src/session/session.ts
-var _emitter5, _inboxService2, _options;
+var _emitter7, _inboxService2, _options;
 var Session = class {
   constructor(options, inboxServiceInstance, eventEmitterInstance) {
-    __privateAdd(this, _emitter5);
+    __privateAdd(this, _emitter7);
     __privateAdd(this, _inboxService2);
     __privateAdd(this, _options);
-    __privateSet(this, _emitter5, eventEmitterInstance);
+    __privateSet(this, _emitter7, eventEmitterInstance);
     __privateSet(this, _inboxService2, inboxServiceInstance);
     __privateSet(this, _options, options);
   }
@@ -2099,7 +2524,7 @@ var Session = class {
         if (options) {
           __privateSet(this, _options, options);
         }
-        const { subscriber, subscriberHash, applicationIdentifier } = __privateGet(this, _options);
+        const { subscriber, subscriberHash, applicationIdentifier, defaultSchedule } = __privateGet(this, _options);
         let currentTimezone;
         if (isBrowser()) {
           currentTimezone = Intl.DateTimeFormat().resolvedOptions().timeZone;
@@ -2113,14 +2538,15 @@ var Session = class {
         } else {
           this.handleApplicationIdentifier("delete");
         }
-        __privateGet(this, _emitter5).emit("session.initialize.pending", { args: __privateGet(this, _options) });
+        __privateGet(this, _emitter7).emit("session.initialize.pending", { args: __privateGet(this, _options) });
         const response = yield __privateGet(this, _inboxService2).initializeSession({
           applicationIdentifier: finalApplicationIdentifier,
           subscriberHash,
           subscriber: __spreadProps(__spreadValues({}, subscriber), {
             subscriberId: (_c = subscriber == null ? void 0 : subscriber.subscriberId) != null ? _c : "",
             timezone: (_d = subscriber == null ? void 0 : subscriber.timezone) != null ? _d : currentTimezone
-          })
+          }),
+          defaultSchedule
         });
         if ((_e = response == null ? void 0 : response.applicationIdentifier) == null ? void 0 : _e.startsWith("pk_keyless_")) {
           this.handleApplicationIdentifier("store", response.applicationIdentifier);
@@ -2128,14 +2554,14 @@ var Session = class {
         if (!((_f = response == null ? void 0 : response.applicationIdentifier) == null ? void 0 : _f.startsWith("pk_keyless_"))) {
           this.handleApplicationIdentifier("delete");
         }
-        __privateGet(this, _emitter5).emit("session.initialize.resolved", { args: __privateGet(this, _options), data: response });
+        __privateGet(this, _emitter7).emit("session.initialize.resolved", { args: __privateGet(this, _options), data: response });
       } catch (error) {
-        __privateGet(this, _emitter5).emit("session.initialize.resolved", { args: __privateGet(this, _options), error });
+        __privateGet(this, _emitter7).emit("session.initialize.resolved", { args: __privateGet(this, _options), error });
       }
     });
   }
 };
-_emitter5 = new WeakMap();
+_emitter7 = new WeakMap();
 _inboxService2 = new WeakMap();
 _options = new WeakMap();
 var PRODUCTION_SOCKET_URL = "wss://socket.novu.co";
@@ -2229,7 +2655,7 @@ var mapToNotification = ({
     severity
   });
 };
-var _token, _emitter6, _partySocket, _socketUrl, _notificationReceived, _unseenCountChanged, _unreadCountChanged, _handleMessage, _PartySocketClient_instances, initializeSocket_fn, handleConnectSocket_fn, handleDisconnectSocket_fn;
+var _token, _emitter8, _partySocket, _socketUrl, _notificationReceived, _unseenCountChanged, _unreadCountChanged, _handleMessage, _PartySocketClient_instances, initializeSocket_fn, handleConnectSocket_fn, handleDisconnectSocket_fn;
 var PartySocketClient = class extends BaseModule {
   constructor({
     socketUrl,
@@ -2242,15 +2668,15 @@ var PartySocketClient = class extends BaseModule {
     });
     __privateAdd(this, _PartySocketClient_instances);
     __privateAdd(this, _token);
-    __privateAdd(this, _emitter6);
+    __privateAdd(this, _emitter8);
     __privateAdd(this, _partySocket);
     __privateAdd(this, _socketUrl);
     __privateAdd(this, _notificationReceived, (event) => {
       try {
         const data = JSON.parse(event.data);
         if (data.event === "notification_received" /* RECEIVED */) {
-          __privateGet(this, _emitter6).emit(NOTIFICATION_RECEIVED, {
-            result: new Notification(mapToNotification(data.data.message), __privateGet(this, _emitter6), this._inboxService)
+          __privateGet(this, _emitter8).emit(NOTIFICATION_RECEIVED, {
+            result: new Notification(mapToNotification(data.data.message), __privateGet(this, _emitter8), this._inboxService)
           });
         }
       } catch (error) {
@@ -2261,7 +2687,7 @@ var PartySocketClient = class extends BaseModule {
       try {
         const data = JSON.parse(event.data);
         if (data.event === "unseen_count_changed" /* UNSEEN */) {
-          __privateGet(this, _emitter6).emit(UNSEEN_COUNT_CHANGED, {
+          __privateGet(this, _emitter8).emit(UNSEEN_COUNT_CHANGED, {
             result: data.data.unseenCount
           });
         }
@@ -2272,7 +2698,7 @@ var PartySocketClient = class extends BaseModule {
       try {
         const data = JSON.parse(event.data);
         if (data.event === "unread_count_changed" /* UNREAD */) {
-          __privateGet(this, _emitter6).emit(UNREAD_COUNT_CHANGED, {
+          __privateGet(this, _emitter8).emit(UNREAD_COUNT_CHANGED, {
             result: data.data.counts
           });
         }
@@ -2297,7 +2723,7 @@ var PartySocketClient = class extends BaseModule {
       } catch (error) {
       }
     });
-    __privateSet(this, _emitter6, eventEmitterInstance);
+    __privateSet(this, _emitter8, eventEmitterInstance);
     __privateSet(this, _socketUrl, socketUrl != null ? socketUrl : PRODUCTION_SOCKET_URL);
   }
   onSessionSuccess({ token }) {
@@ -2324,7 +2750,7 @@ var PartySocketClient = class extends BaseModule {
   }
 };
 _token = new WeakMap();
-_emitter6 = new WeakMap();
+_emitter8 = new WeakMap();
 _partySocket = new WeakMap();
 _socketUrl = new WeakMap();
 _notificationReceived = new WeakMap();
@@ -2338,15 +2764,15 @@ initializeSocket_fn = function() {
       return;
     }
     const args = { socketUrl: __privateGet(this, _socketUrl) };
-    __privateGet(this, _emitter6).emit("socket.connect.pending", { args });
+    __privateGet(this, _emitter8).emit("socket.connect.pending", { args });
     const url = new URL(__privateGet(this, _socketUrl));
     url.searchParams.set("token", __privateGet(this, _token));
     __privateSet(this, _partySocket, new WebSocket(url.toString()));
     __privateGet(this, _partySocket).addEventListener("open", () => {
-      __privateGet(this, _emitter6).emit("socket.connect.resolved", { args });
+      __privateGet(this, _emitter8).emit("socket.connect.resolved", { args });
     });
     __privateGet(this, _partySocket).addEventListener("error", (error) => {
-      __privateGet(this, _emitter6).emit("socket.connect.resolved", { args, error });
+      __privateGet(this, _emitter8).emit("socket.connect.resolved", { args, error });
     });
     __privateGet(this, _partySocket).addEventListener("message", __privateGet(this, _handleMessage));
   });
@@ -2464,7 +2890,7 @@ var mapToNotification2 = ({
     severity
   });
 };
-var _token2, _emitter7, _socketIo, _socketUrl2, _notificationReceived2, _unseenCountChanged2, _unreadCountChanged2, _Socket_instances, initializeSocket_fn2, handleConnectSocket_fn2, handleDisconnectSocket_fn2;
+var _token2, _emitter9, _socketIo, _socketUrl2, _notificationReceived2, _unseenCountChanged2, _unreadCountChanged2, _Socket_instances, initializeSocket_fn2, handleConnectSocket_fn2, handleDisconnectSocket_fn2;
 var Socket = class extends BaseModule {
   constructor({
     socketUrl,
@@ -2477,25 +2903,25 @@ var Socket = class extends BaseModule {
     });
     __privateAdd(this, _Socket_instances);
     __privateAdd(this, _token2);
-    __privateAdd(this, _emitter7);
+    __privateAdd(this, _emitter9);
     __privateAdd(this, _socketIo);
     __privateAdd(this, _socketUrl2);
     __privateAdd(this, _notificationReceived2, ({ message }) => {
-      __privateGet(this, _emitter7).emit(NOTIFICATION_RECEIVED2, {
-        result: new Notification(mapToNotification2(message), __privateGet(this, _emitter7), this._inboxService)
+      __privateGet(this, _emitter9).emit(NOTIFICATION_RECEIVED2, {
+        result: new Notification(mapToNotification2(message), __privateGet(this, _emitter9), this._inboxService)
       });
     });
     __privateAdd(this, _unseenCountChanged2, ({ unseenCount }) => {
-      __privateGet(this, _emitter7).emit(UNSEEN_COUNT_CHANGED2, {
+      __privateGet(this, _emitter9).emit(UNSEEN_COUNT_CHANGED2, {
         result: unseenCount
       });
     });
     __privateAdd(this, _unreadCountChanged2, ({ counts }) => {
-      __privateGet(this, _emitter7).emit(UNREAD_COUNT_CHANGED2, {
+      __privateGet(this, _emitter9).emit(UNREAD_COUNT_CHANGED2, {
         result: counts
       });
     });
-    __privateSet(this, _emitter7, eventEmitterInstance);
+    __privateSet(this, _emitter9, eventEmitterInstance);
     __privateSet(this, _socketUrl2, socketUrl != null ? socketUrl : PRODUCTION_SOCKET_URL2);
   }
   onSessionSuccess({ token }) {
@@ -2522,7 +2948,7 @@ var Socket = class extends BaseModule {
   }
 };
 _token2 = new WeakMap();
-_emitter7 = new WeakMap();
+_emitter9 = new WeakMap();
 _socketIo = new WeakMap();
 _socketUrl2 = new WeakMap();
 _notificationReceived2 = new WeakMap();
@@ -2536,7 +2962,7 @@ initializeSocket_fn2 = function() {
       return;
     }
     const args = { socketUrl: __privateGet(this, _socketUrl2) };
-    __privateGet(this, _emitter7).emit("socket.connect.pending", { args });
+    __privateGet(this, _emitter9).emit("socket.connect.pending", { args });
     __privateSet(this, _socketIo, io(__privateGet(this, _socketUrl2), {
       reconnectionDelayMax: 1e4,
       transports: ["websocket"],
@@ -2545,10 +2971,10 @@ initializeSocket_fn2 = function() {
       }
     }));
     __privateGet(this, _socketIo).on("connect", () => {
-      __privateGet(this, _emitter7).emit("socket.connect.resolved", { args });
+      __privateGet(this, _emitter9).emit("socket.connect.resolved", { args });
     });
     __privateGet(this, _socketIo).on("connect_error", (error) => {
-      __privateGet(this, _emitter7).emit("socket.connect.resolved", { args, error });
+      __privateGet(this, _emitter9).emit("socket.connect.resolved", { args, error });
     });
     (_a = __privateGet(this, _socketIo)) == null ? void 0 : _a.on("notification_received" /* RECEIVED */, __privateGet(this, _notificationReceived2));
     (_b = __privateGet(this, _socketIo)) == null ? void 0 : _b.on("unseen_count_changed" /* UNSEEN */, __privateGet(this, _unseenCountChanged2));
@@ -2622,10 +3048,10 @@ function createSocket({
 }
 
 // src/novu.ts
-var _emitter8, _session, _inboxService3;
+var _emitter10, _session, _inboxService3;
 var Novu = class {
   constructor(options) {
-    __privateAdd(this, _emitter8);
+    __privateAdd(this, _emitter10);
     __privateAdd(this, _session);
     __privateAdd(this, _inboxService3);
     var _a, _b;
@@ -2633,43 +3059,44 @@ var Novu = class {
       apiUrl: options.apiUrl || options.backendUrl,
       userAgent: options.__userAgent
     }));
-    __privateSet(this, _emitter8, new NovuEventEmitter());
+    __privateSet(this, _emitter10, new NovuEventEmitter());
     __privateSet(this, _session, new Session(
       {
         applicationIdentifier: options.applicationIdentifier || "",
         subscriberHash: options.subscriberHash,
-        subscriber: buildSubscriber({ subscriberId: options.subscriberId, subscriber: options.subscriber })
+        subscriber: buildSubscriber({ subscriberId: options.subscriberId, subscriber: options.subscriber }),
+        defaultSchedule: options.defaultSchedule
       },
       __privateGet(this, _inboxService3),
-      __privateGet(this, _emitter8)
+      __privateGet(this, _emitter10)
     ));
     __privateGet(this, _session).initialize();
     this.notifications = new Notifications({
       useCache: (_a = options.useCache) != null ? _a : true,
       inboxServiceInstance: __privateGet(this, _inboxService3),
-      eventEmitterInstance: __privateGet(this, _emitter8)
+      eventEmitterInstance: __privateGet(this, _emitter10)
     });
     this.preferences = new Preferences({
       useCache: (_b = options.useCache) != null ? _b : true,
       inboxServiceInstance: __privateGet(this, _inboxService3),
-      eventEmitterInstance: __privateGet(this, _emitter8)
+      eventEmitterInstance: __privateGet(this, _emitter10)
     });
     this.socket = createSocket({
       socketUrl: options.socketUrl,
-      eventEmitterInstance: __privateGet(this, _emitter8),
+      eventEmitterInstance: __privateGet(this, _emitter10),
       inboxServiceInstance: __privateGet(this, _inboxService3)
     });
     this.on = (eventName, listener) => {
       if (this.socket.isSocketEvent(eventName)) {
         this.socket.connect();
       }
-      const cleanup = __privateGet(this, _emitter8).on(eventName, listener);
+      const cleanup = __privateGet(this, _emitter10).on(eventName, listener);
       return () => {
         cleanup();
       };
     };
     this.off = (eventName, listener) => {
-      __privateGet(this, _emitter8).off(eventName, listener);
+      __privateGet(this, _emitter10).off(eventName, listener);
     };
   }
   get applicationIdentifier() {
@@ -2688,7 +3115,7 @@ var Novu = class {
     });
   }
 };
-_emitter8 = new WeakMap();
+_emitter10 = new WeakMap();
 _session = new WeakMap();
 _inboxService3 = new WeakMap();