@novu/js 3.11.1 → 3.11.2-nightly.20251224.97b30e30dd

package/dist/esm/{chunk-76A4RQYD.mjs → chunk-GDLXUD4E.mjs}

@@ -1,5 +1,5 @@
-import { buildSubscriber, buildContextKey, Notification, NovuError, read, unread, seen, archive, unarchive, deleteNotification, snooze, unsnooze, completeAction, revertAction, readAll, seenAll, archiveAll, archiveAllRead, deleteAll, createNotification } from './chunk-GY4JXBST.mjs';
-import { __privateAdd, __privateSet, __privateGet, __async, __objRest, __spreadValues, __spreadProps, __privateMethod } from './chunk-STZMOEWR.mjs';
+import { NovuError, buildSubscriber, buildContextKey, buildSubscriptionIdentifier, Notification, read, unread, seen, archive, unarchive, deleteNotification, snooze, unsnooze, completeAction, revertAction, readAll, seenAll, archiveAll, archiveAllRead, deleteAll, createNotification } from './chunk-SWKDFXVR.mjs';
+import { __privateAdd, __privateSet, __spreadValues, __privateGet, __async, __spreadProps, __objRest, __privateMethod } from './chunk-STZMOEWR.mjs';
 import mitt from 'mitt';
 import 'event-target-polyfill';
 import { WebSocket } from 'partysocket';
@@ -96,9 +96,779 @@ function checkNotificationMatchesFilter(notification, filter) {
   return checkBasicFilters(notification, filter) && checkNotificationTagFilter(notification.tags, filter.tags) && checkNotificationDataFilter(notification.data, filter.data);
 }
 
+// src/subscriptions/subscription.ts
+var _emitter, _inboxService, _cache, _useCache, _isStale;
+var TopicSubscription = class {
+  constructor(subscription, emitter, inboxService, cache, useCache) {
+    __privateAdd(this, _emitter);
+    __privateAdd(this, _inboxService);
+    __privateAdd(this, _cache);
+    __privateAdd(this, _useCache);
+    __privateAdd(this, _isStale, false);
+    var _a;
+    __privateSet(this, _emitter, emitter);
+    __privateSet(this, _inboxService, inboxService);
+    __privateSet(this, _cache, cache);
+    __privateSet(this, _useCache, useCache);
+    this.id = subscription.id;
+    this.identifier = subscription.identifier;
+    this.topicKey = subscription.topicKey;
+    this.preferences = (_a = subscription.preferences) == null ? void 0 : _a.map(
+      (pref) => new SubscriptionPreference(__spreadValues({}, pref), __privateGet(this, _emitter), __privateGet(this, _inboxService), __privateGet(this, _cache), __privateGet(this, _useCache))
+    );
+  }
+  update(args) {
+    return __async(this, null, function* () {
+      return updateSubscription({
+        emitter: __privateGet(this, _emitter),
+        apiService: __privateGet(this, _inboxService),
+        cache: __privateGet(this, _cache),
+        useCache: __privateGet(this, _useCache),
+        args: __spreadProps(__spreadValues({}, args), { subscription: this })
+      });
+    });
+  }
+  updatePreference(args) {
+    return __async(this, null, function* () {
+      if (__privateGet(this, _isStale)) {
+        return {
+          error: new NovuError("Cannot update a deleted subscription", new Error("Subscription is stale"))
+        };
+      }
+      return updateSubscriptionPreference({
+        emitter: __privateGet(this, _emitter),
+        apiService: __privateGet(this, _inboxService),
+        cache: __privateGet(this, _cache),
+        useCache: __privateGet(this, _useCache),
+        args: __spreadProps(__spreadValues({}, args), { subscriptionId: this.id })
+      });
+    });
+  }
+  bulkUpdatePreferences(args) {
+    return __async(this, null, function* () {
+      if (__privateGet(this, _isStale)) {
+        return {
+          error: new NovuError("Cannot bulk update a deleted subscription", new Error("Subscription is stale"))
+        };
+      }
+      return bulkUpdateSubscriptionPreference({
+        emitter: __privateGet(this, _emitter),
+        apiService: __privateGet(this, _inboxService),
+        cache: __privateGet(this, _cache),
+        useCache: __privateGet(this, _useCache),
+        args: args.map((arg) => __spreadProps(__spreadValues({}, arg), { subscriptionId: this.id }))
+      });
+    });
+  }
+  delete() {
+    return __async(this, null, function* () {
+      if (__privateGet(this, _isStale)) {
+        return {
+          error: new NovuError("Cannot delete an already deleted subscription", new Error("Subscription is stale"))
+        };
+      }
+      return deleteSubscription({
+        emitter: __privateGet(this, _emitter),
+        apiService: __privateGet(this, _inboxService),
+        args: { subscription: this }
+      });
+    });
+  }
+};
+_emitter = new WeakMap();
+_inboxService = new WeakMap();
+_cache = new WeakMap();
+_useCache = new WeakMap();
+_isStale = new WeakMap();
+
+// src/subscriptions/helpers.ts
+var listSubscriptions = (_0) => __async(void 0, [_0], function* ({
+  emitter,
+  apiService,
+  cache,
+  options,
+  args
+}) {
+  try {
+    const { useCache, refetch } = options;
+    let data = useCache && !refetch ? cache.getAll(args) : void 0;
+    emitter.emit("subscriptions.list.pending", { args, data });
+    if (!data || refetch) {
+      const response = yield apiService.fetchSubscriptions(args.topicKey);
+      data = response.map((el) => {
+        return new TopicSubscription(__spreadProps(__spreadValues({}, el), { topicKey: args.topicKey }), emitter, apiService, cache, useCache);
+      });
+      if (useCache) {
+        cache.set(args, data);
+        data = cache.getAll(args);
+      }
+    }
+    emitter.emit("subscriptions.list.resolved", { args, data });
+    return { data };
+  } catch (error) {
+    emitter.emit("subscriptions.list.resolved", { args, error });
+    return { error: new NovuError("Failed to fetch subscriptions", error) };
+  }
+});
+var getSubscription = (_0) => __async(void 0, [_0], function* ({
+  emitter,
+  apiService,
+  cache,
+  options,
+  args
+}) {
+  try {
+    const { useCache, refetch } = options;
+    let data = useCache && !refetch ? cache.get(args) : void 0;
+    emitter.emit("subscription.get.pending", { args, data });
+    if (!data || refetch) {
+      const response = yield apiService.getSubscription(args.topicKey, args.identifier, args.workflowIds, args.tags);
+      if (!response) {
+        emitter.emit("subscription.get.resolved", { args, data: null });
+        return { data: null };
+      }
+      data = new TopicSubscription(__spreadProps(__spreadValues({}, response), { topicKey: args.topicKey }), emitter, apiService, cache, useCache);
+      if (useCache) {
+        cache.setOne(args, data);
+        data = cache.get(args);
+      }
+    }
+    emitter.emit("subscription.get.resolved", { args, data });
+    return { data };
+  } catch (error) {
+    emitter.emit("subscription.get.resolved", { args, error });
+    return { error: new NovuError("Failed to fetch subscription", error) };
+  }
+});
+var createSubscription = (_0) => __async(void 0, [_0], function* ({
+  emitter,
+  apiService,
+  cache,
+  useCache,
+  args
+}) {
+  var _a;
+  try {
+    emitter.emit("subscription.create.pending", { args });
+    const response = yield apiService.createSubscription({
+      identifier: (_a = args.identifier) != null ? _a : "",
+      name: args.name,
+      topicKey: args.topicKey,
+      topicName: args.topicName,
+      preferences: args.preferences
+    });
+    const subscription = new TopicSubscription(
+      __spreadProps(__spreadValues({}, response), { topicKey: args.topicKey }),
+      emitter,
+      apiService,
+      cache,
+      useCache
+    );
+    emitter.emit("subscription.create.resolved", { args, data: subscription });
+    return { data: subscription };
+  } catch (error) {
+    emitter.emit("subscription.create.resolved", { args, error });
+    return { error: new NovuError("Failed to create subscription", error) };
+  }
+});
+var updateSubscription = (_0) => __async(void 0, [_0], function* ({
+  emitter,
+  apiService,
+  cache,
+  useCache,
+  args
+}) {
+  const subscriptionId = "subscriptionId" in args ? args.subscriptionId : args.subscription.id;
+  const topicKey = "topicKey" in args ? args.topicKey : args.subscription.topicKey;
+  try {
+    emitter.emit("subscription.update.pending", {
+      args
+    });
+    const response = yield apiService.updateSubscription({
+      topicKey,
+      subscriptionId,
+      name: args.name,
+      preferences: args.preferences
+    });
+    const updatedSubscription = new TopicSubscription(__spreadProps(__spreadValues({}, response), { topicKey }), emitter, apiService, cache, useCache);
+    emitter.emit("subscription.update.resolved", { args, data: updatedSubscription });
+    return { data: updatedSubscription };
+  } catch (error) {
+    emitter.emit("subscription.update.resolved", { args, error });
+    return { error: new NovuError("Failed to update subscription", error) };
+  }
+});
+var updateSubscriptionPreference = (_0) => __async(void 0, [_0], function* ({
+  emitter,
+  apiService,
+  cache,
+  useCache,
+  args
+}) {
+  var _a, _b;
+  const workflowId = "workflowId" in args ? args.workflowId : (_b = (_a = args.preference) == null ? void 0 : _a.workflow) == null ? void 0 : _b.id;
+  try {
+    emitter.emit("subscription.preference.update.pending", {
+      args,
+      data: "preference" in args ? new SubscriptionPreference(
+        __spreadValues(__spreadValues({}, args.preference), typeof args.value === "boolean" ? { enabled: args.value } : { condition: args.value }),
+        emitter,
+        apiService,
+        cache,
+        useCache
+      ) : void 0
+    });
+    const response = yield apiService.updateSubscriptionPreference(__spreadValues({
+      subscriptionId: args.subscriptionId,
+      workflowId
+    }, typeof args.value === "boolean" ? {
+      enabled: args.value,
+      email: args.value,
+      sms: args.value,
+      in_app: args.value,
+      chat: args.value,
+      push: args.value
+    } : { condition: args.value }));
+    const updatedSubscription = new SubscriptionPreference(__spreadValues({}, response), emitter, apiService, cache, useCache);
+    emitter.emit("subscription.preference.update.resolved", { args, data: updatedSubscription });
+    return { data: updatedSubscription };
+  } catch (error) {
+    emitter.emit("subscription.preference.update.resolved", { args, error });
+    return { error: new NovuError("Failed to update subscription", error) };
+  }
+});
+var bulkUpdateSubscriptionPreference = (_0) => __async(void 0, [_0], function* ({
+  emitter,
+  apiService,
+  cache,
+  useCache,
+  args
+}) {
+  try {
+    const optimisticallyUpdatedPreferences = args.map(
+      (arg) => "preference" in arg ? new SubscriptionPreference(
+        __spreadValues(__spreadValues({}, arg.preference), typeof arg.value === "boolean" ? { enabled: arg.value } : { condition: arg.value }),
+        emitter,
+        apiService,
+        cache,
+        useCache
+      ) : void 0
+    ).filter((el) => el !== void 0);
+    emitter.emit("subscription.preferences.bulk_update.pending", {
+      args,
+      data: optimisticallyUpdatedPreferences
+    });
+    const preferencesToUpdate = args.map((arg) => {
+      var _a, _b, _c, _d, _e, _f;
+      return __spreadValues({
+        subscriptionIdOrIdentifier: arg.subscriptionId,
+        workflowId: "workflowId" in arg ? arg.workflowId : (_f = (_e = (_b = (_a = arg.preference) == null ? void 0 : _a.workflow) == null ? void 0 : _b.id) != null ? _e : (_d = (_c = arg.preference) == null ? void 0 : _c.workflow) == null ? void 0 : _d.identifier) != null ? _f : ""
+      }, typeof arg.value === "boolean" ? { enabled: arg.value, email: arg.value, sms: arg.value, in_app: arg.value, chat: arg.value, push: arg.value } : { condition: arg.value });
+    });
+    const response = yield apiService.bulkUpdateSubscriptionPreferences(preferencesToUpdate);
+    const preferences = response.map((el) => new SubscriptionPreference(el, emitter, apiService, cache, useCache));
+    emitter.emit("subscription.preferences.bulk_update.resolved", { args, data: preferences });
+    return { data: preferences };
+  } catch (error) {
+    emitter.emit("subscription.preferences.bulk_update.resolved", { args, error });
+    return { error: new NovuError("Failed to bulk update subscription preferences", error) };
+  }
+});
+var deleteSubscription = (_0) => __async(void 0, [_0], function* ({
+  emitter,
+  apiService,
+  args
+}) {
+  const subscriptionId = "subscriptionId" in args ? args.subscriptionId : args.subscription.id;
+  const topicKey = "topicKey" in args ? args.topicKey : args.subscription.topicKey;
+  try {
+    emitter.emit("subscription.delete.pending", { args });
+    yield apiService.deleteSubscription({ topicKey, subscriptionId });
+    emitter.emit("subscription.delete.resolved", { args });
+    return { data: void 0 };
+  } catch (error) {
+    emitter.emit("subscription.delete.resolved", { args, error });
+    return { error: new NovuError("Failed to delete subscription", error) };
+  }
+});
+
+// src/subscriptions/subscription-preference.ts
+var _emitter2, _inboxService2, _cache2, _useCache2;
+var SubscriptionPreference = class {
+  constructor(preference, emitter, inboxService, cache, useCache) {
+    __privateAdd(this, _emitter2);
+    __privateAdd(this, _inboxService2);
+    __privateAdd(this, _cache2);
+    __privateAdd(this, _useCache2);
+    var _a;
+    __privateSet(this, _emitter2, emitter);
+    __privateSet(this, _inboxService2, inboxService);
+    __privateSet(this, _cache2, cache);
+    __privateSet(this, _useCache2, useCache);
+    this.enabled = preference.enabled;
+    this.condition = (_a = preference.condition) != null ? _a : void 0;
+    this.workflow = preference.workflow;
+    this.subscriptionId = preference.subscriptionId;
+  }
+  update(args) {
+    return __async(this, null, function* () {
+      var _a;
+      return updateSubscriptionPreference({
+        emitter: __privateGet(this, _emitter2),
+        apiService: __privateGet(this, _inboxService2),
+        cache: __privateGet(this, _cache2),
+        useCache: __privateGet(this, _useCache2),
+        args: {
+          subscriptionId: this.subscriptionId,
+          workflowId: (_a = this.workflow) == null ? void 0 : _a.id,
+          value: args.value,
+          preference: this
+        }
+      });
+    });
+  }
+};
+_emitter2 = new WeakMap();
+_inboxService2 = new WeakMap();
+_cache2 = new WeakMap();
+_useCache2 = new WeakMap();
+
+// src/base-module.ts
+var _callsQueue, _sessionError;
+var BaseModule = class {
+  constructor({
+    inboxServiceInstance,
+    eventEmitterInstance
+  }) {
+    __privateAdd(this, _callsQueue, []);
+    __privateAdd(this, _sessionError);
+    this._emitter = eventEmitterInstance;
+    this._inboxService = inboxServiceInstance;
+    this._emitter.on("session.initialize.resolved", ({ error, data }) => {
+      if (data) {
+        this.onSessionSuccess(data);
+        __privateGet(this, _callsQueue).forEach((_0) => __async(this, [_0], function* ({ fn, resolve }) {
+          resolve(yield fn());
+        }));
+        __privateSet(this, _callsQueue, []);
+      } else if (error) {
+        this.onSessionError(error);
+        __privateSet(this, _sessionError, error);
+        __privateGet(this, _callsQueue).forEach(({ resolve }) => {
+          resolve({ error: new NovuError("Failed to initialize session, please contact the support", error) });
+        });
+        __privateSet(this, _callsQueue, []);
+      }
+    });
+  }
+  onSessionSuccess(_) {
+  }
+  onSessionError(_) {
+  }
+  callWithSession(fn) {
+    return __async(this, null, function* () {
+      if (this._inboxService.isSessionInitialized) {
+        return fn();
+      }
+      if (__privateGet(this, _sessionError)) {
+        return Promise.resolve({
+          error: new NovuError("Failed to initialize session, please contact the support", __privateGet(this, _sessionError))
+        });
+      }
+      return new Promise((resolve, reject) => {
+        __privateGet(this, _callsQueue).push({ fn, resolve, reject });
+      });
+    });
+  }
+};
+_callsQueue = new WeakMap();
+_sessionError = new WeakMap();
+
+// src/cache/in-memory-cache.ts
+var _cache3;
+var InMemoryCache = class {
+  constructor() {
+    __privateAdd(this, _cache3);
+    __privateSet(this, _cache3, /* @__PURE__ */ new Map());
+  }
+  get(key) {
+    return __privateGet(this, _cache3).get(key);
+  }
+  getValues() {
+    return Array.from(__privateGet(this, _cache3).values());
+  }
+  entries() {
+    return Array.from(__privateGet(this, _cache3).entries());
+  }
+  keys() {
+    return Array.from(__privateGet(this, _cache3).keys());
+  }
+  set(key, value) {
+    __privateGet(this, _cache3).set(key, value);
+  }
+  remove(key) {
+    __privateGet(this, _cache3).delete(key);
+  }
+  clear() {
+    __privateGet(this, _cache3).clear();
+  }
+};
+_cache3 = new WeakMap();
+
+// src/cache/subscriptions-cache.ts
+var getListCacheKey = (args) => {
+  return `list:${args.topicKey}`;
+};
+var getTopicKeyFromListCacheKey = (key) => {
+  return key.split(":")[1];
+};
+var getItemCacheKey = (args) => {
+  return `item:${args.topicKey}:${args.identifier}`;
+};
+var _emitter3, _cache4, _useCache3, _itemCache, _inboxService3;
+var SubscriptionsCache = class {
+  constructor({
+    emitterInstance,
+    inboxServiceInstance,
+    useCache
+  }) {
+    __privateAdd(this, _emitter3);
+    __privateAdd(this, _cache4);
+    __privateAdd(this, _useCache3);
+    __privateAdd(this, _itemCache);
+    __privateAdd(this, _inboxService3);
+    this.handleCreate = (subscription) => {
+      const listKey = getListCacheKey({ topicKey: subscription.topicKey });
+      const subscriptions = __privateGet(this, _cache4).get(listKey);
+      if (subscriptions) {
+        const updatedSubscriptions = [...subscriptions, subscription];
+        __privateGet(this, _cache4).set(listKey, updatedSubscriptions);
+        __privateGet(this, _emitter3).emit("subscriptions.list.updated", {
+          data: { topicKey: subscription.topicKey, subscriptions: updatedSubscriptions }
+        });
+      }
+      __privateGet(this, _itemCache).set(
+        getItemCacheKey({ topicKey: subscription.topicKey, identifier: subscription.identifier }),
+        subscription
+      );
+    };
+    this.handleUpdate = (subscription) => {
+      const listKey = getListCacheKey({ topicKey: subscription.topicKey });
+      const subscriptions = __privateGet(this, _cache4).get(listKey);
+      if (subscriptions) {
+        const updatedSubscriptions = subscriptions.map((el) => el.id === subscription.id ? subscription : el);
+        __privateGet(this, _cache4).set(listKey, updatedSubscriptions);
+        __privateGet(this, _emitter3).emit("subscriptions.list.updated", {
+          data: { topicKey: subscription.topicKey, subscriptions: updatedSubscriptions }
+        });
+      }
+      __privateGet(this, _itemCache).set(
+        getItemCacheKey({ topicKey: subscription.topicKey, identifier: subscription.identifier }),
+        subscription
+      );
+    };
+    this.handlePreferenceUpdate = (preference) => {
+      this.updateSubscriptionPreferences([preference]);
+    };
+    this.handleBulkPreferenceUpdate = (preferences) => {
+      this.updateSubscriptionPreferences(preferences);
+    };
+    this.updateSubscriptionPreferences = (updatedPreferences) => {
+      var _a;
+      const preferencesBySubscription = /* @__PURE__ */ new Map();
+      for (const pref of updatedPreferences) {
+        const existing = (_a = preferencesBySubscription.get(pref.subscriptionId)) != null ? _a : [];
+        existing.push(pref);
+        preferencesBySubscription.set(pref.subscriptionId, existing);
+      }
+      const allListKeys = __privateGet(this, _cache4).keys();
+      for (const listKey of allListKeys) {
+        const subscriptions = __privateGet(this, _cache4).get(listKey);
+        if (!subscriptions) continue;
+        let hasUpdates = false;
+        const updatedSubscriptions = subscriptions.map((subscription) => {
+          const subscriptionPreferences = preferencesBySubscription.get(subscription.id);
+          if (subscriptionPreferences) {
+            hasUpdates = true;
+            return this.createUpdatedSubscription(subscription, subscriptionPreferences);
+          }
+          return subscription;
+        });
+        if (hasUpdates) {
+          __privateGet(this, _cache4).set(listKey, updatedSubscriptions);
+          __privateGet(this, _emitter3).emit("subscriptions.list.updated", {
+            data: { topicKey: getTopicKeyFromListCacheKey(listKey), subscriptions: updatedSubscriptions }
+          });
+        }
+      }
+      const allItemKeys = __privateGet(this, _itemCache).keys();
+      for (const key of allItemKeys) {
+        const subscription = __privateGet(this, _itemCache).get(key);
+        if (!subscription) continue;
+        const subscriptionPreferences = preferencesBySubscription.get(subscription.id);
+        if (subscriptionPreferences) {
+          const updatedSubscription = this.createUpdatedSubscription(subscription, subscriptionPreferences);
+          __privateGet(this, _itemCache).set(key, updatedSubscription);
+          __privateGet(this, _emitter3).emit("subscription.update.resolved", {
+            args: { subscription },
+            data: updatedSubscription
+          });
+        }
+      }
+    };
+    this.createUpdatedSubscription = (subscription, subscriptionPreferences) => {
+      var _a;
+      const updatedPreferences = (_a = subscription.preferences) == null ? void 0 : _a.map((pref) => {
+        const newPreference = subscriptionPreferences.find((el) => el.workflow.id === pref.workflow.id);
+        if (newPreference) {
+          return newPreference;
+        }
+        return pref;
+      });
+      return new TopicSubscription(
+        {
+          id: subscription.id,
+          identifier: subscription.identifier,
+          topicKey: subscription.topicKey,
+          preferences: updatedPreferences
+        },
+        __privateGet(this, _emitter3),
+        __privateGet(this, _inboxService3),
+        this,
+        __privateGet(this, _useCache3)
+      );
+    };
+    this.handleDelete = (subscription) => {
+      const listKey = getListCacheKey({ topicKey: subscription.topicKey });
+      const subscriptions = __privateGet(this, _cache4).get(listKey);
+      if (subscriptions) {
+        const updatedSubscriptions = subscriptions.filter((el) => el.id !== subscription.id);
+        __privateGet(this, _cache4).set(listKey, updatedSubscriptions);
+        __privateGet(this, _emitter3).emit("subscriptions.list.updated", {
+          data: { topicKey: subscription.topicKey, subscriptions: updatedSubscriptions }
+        });
+      }
+      __privateGet(this, _itemCache).remove(getItemCacheKey({ topicKey: subscription.topicKey, identifier: subscription.identifier }));
+    };
+    this.handleDeleteById = (subscriptionId) => {
+      const allListKeys = __privateGet(this, _cache4).keys();
+      for (const listKey of allListKeys) {
+        const subscriptions = __privateGet(this, _cache4).get(listKey);
+        if (subscriptions) {
+          const subscription = subscriptions.find((el) => el.id === subscriptionId || el.identifier === subscriptionId);
+          if (subscription) {
+            const updatedSubscriptions = subscriptions.filter((el) => el.id !== subscription.id);
+            __privateGet(this, _cache4).set(listKey, updatedSubscriptions);
+            __privateGet(this, _emitter3).emit("subscriptions.list.updated", {
+              data: { topicKey: getTopicKeyFromListCacheKey(listKey), subscriptions: updatedSubscriptions }
+            });
+            __privateGet(this, _itemCache).remove(
+              getItemCacheKey({ topicKey: subscription.topicKey, identifier: subscription.identifier })
+            );
+            return;
+          }
+        }
+      }
+      const allItemKeys = __privateGet(this, _itemCache).keys();
+      for (const key of allItemKeys) {
+        const subscription = __privateGet(this, _itemCache).get(key);
+        if (subscription && (subscription.id === subscriptionId || subscription.identifier === subscriptionId)) {
+          __privateGet(this, _itemCache).remove(key);
+          return;
+        }
+      }
+    };
+    __privateSet(this, _emitter3, emitterInstance);
+    __privateSet(this, _cache4, new InMemoryCache());
+    __privateSet(this, _itemCache, new InMemoryCache());
+    __privateSet(this, _inboxService3, inboxServiceInstance);
+    __privateSet(this, _useCache3, useCache);
+    __privateGet(this, _emitter3).on("subscription.create.resolved", ({ data }) => {
+      if (data) {
+        this.handleCreate(data);
+      }
+    });
+    __privateGet(this, _emitter3).on("subscription.update.resolved", ({ data }) => {
+      if (data) {
+        this.handleUpdate(data);
+      }
+    });
+    __privateGet(this, _emitter3).on("subscription.delete.resolved", ({ args }) => {
+      if ("subscription" in args) {
+        this.handleDelete(args.subscription);
+      } else if ("subscriptionId" in args) {
+        this.handleDeleteById(args.subscriptionId);
+      }
+    });
+    __privateGet(this, _emitter3).on("subscription.preference.update.pending", ({ data }) => {
+      if (data) {
+        this.handlePreferenceUpdate(data);
+      }
+    });
+    __privateGet(this, _emitter3).on("subscription.preference.update.resolved", ({ data }) => {
+      if (data) {
+        this.handlePreferenceUpdate(data);
+      }
+    });
+    __privateGet(this, _emitter3).on("subscription.preferences.bulk_update.resolved", ({ data }) => {
+      if (data && data.length > 0) {
+        this.handleBulkPreferenceUpdate(data);
+      }
+    });
+  }
+  has(args) {
+    return __privateGet(this, _cache4).get(getListCacheKey(args)) !== void 0;
+  }
+  set(args, data) {
+    __privateGet(this, _cache4).set(getListCacheKey(args), data);
+    for (const subscription of data) {
+      __privateGet(this, _itemCache).set(
+        getItemCacheKey({ topicKey: args.topicKey, identifier: subscription.identifier }),
+        subscription
+      );
+    }
+  }
+  setOne(args, data) {
+    __privateGet(this, _itemCache).set(getItemCacheKey(args), data);
+  }
+  getAll(args) {
+    return __privateGet(this, _cache4).get(getListCacheKey(args));
+  }
+  get(args) {
+    return __privateGet(this, _itemCache).get(getItemCacheKey(args));
+  }
+  invalidate(args) {
+    const listKey = getListCacheKey({ topicKey: args.topicKey });
+    const subscriptions = __privateGet(this, _cache4).get(listKey);
+    if (subscriptions) {
+      for (const subscription of subscriptions) {
+        __privateGet(this, _itemCache).remove(getItemCacheKey({ topicKey: args.topicKey, identifier: subscription.identifier }));
+      }
+    }
+    __privateGet(this, _cache4).remove(listKey);
+    const allItemKeys = __privateGet(this, _itemCache).keys();
+    for (const key of allItemKeys) {
+      if (key.startsWith(`item:${args.topicKey}:`)) {
+        __privateGet(this, _itemCache).remove(key);
+      }
+    }
+  }
+  clearAll() {
+    __privateGet(this, _cache4).clear();
+    __privateGet(this, _itemCache).clear();
+  }
+};
+_emitter3 = new WeakMap();
+_cache4 = new WeakMap();
+_useCache3 = new WeakMap();
+_itemCache = new WeakMap();
+_inboxService3 = new WeakMap();
+
+// src/subscriptions/subscriptions.ts
+var _useCache4, _subscriber;
+var Subscriptions = class extends BaseModule {
+  constructor({
+    useCache,
+    inboxServiceInstance,
+    eventEmitterInstance,
+    subscriber
+  }) {
+    super({
+      eventEmitterInstance,
+      inboxServiceInstance
+    });
+    __privateAdd(this, _useCache4);
+    __privateAdd(this, _subscriber);
+    this.cache = new SubscriptionsCache({
+      emitterInstance: this._emitter,
+      inboxServiceInstance: this._inboxService,
+      useCache
+    });
+    __privateSet(this, _useCache4, useCache);
+    __privateSet(this, _subscriber, subscriber);
+  }
+  list(args, options) {
+    return __async(this, null, function* () {
+      return this.callWithSession(
+        () => {
+          var _a;
+          return listSubscriptions({
+            emitter: this._emitter,
+            apiService: this._inboxService,
+            cache: this.cache,
+            options: __spreadProps(__spreadValues({}, options), {
+              useCache: (_a = options == null ? void 0 : options.useCache) != null ? _a : __privateGet(this, _useCache4)
+            }),
+            args
+          });
+        }
+      );
+    });
+  }
+  get(args, options) {
+    return __async(this, null, function* () {
+      return this.callWithSession(
+        () => {
+          var _a, _b;
+          return getSubscription({
+            emitter: this._emitter,
+            apiService: this._inboxService,
+            cache: this.cache,
+            options: __spreadProps(__spreadValues({}, options), {
+              useCache: (_a = options == null ? void 0 : options.useCache) != null ? _a : __privateGet(this, _useCache4)
+            }),
+            args: __spreadProps(__spreadValues({}, args), {
+              identifier: (_b = args.identifier) != null ? _b : buildSubscriptionIdentifier({ topicKey: args.topicKey, subscriberId: __privateGet(this, _subscriber).subscriberId })
+            })
+          });
+        }
+      );
+    });
+  }
+  create(args) {
+    return __async(this, null, function* () {
+      return this.callWithSession(
+        () => createSubscription({
+          emitter: this._emitter,
+          apiService: this._inboxService,
+          cache: this.cache,
+          useCache: __privateGet(this, _useCache4),
+          args
+        })
+      );
+    });
+  }
+  update(args) {
+    return __async(this, null, function* () {
+      return this.callWithSession(
+        () => updateSubscription({
+          emitter: this._emitter,
+          apiService: this._inboxService,
+          cache: this.cache,
+          useCache: __privateGet(this, _useCache4),
+          args
+        })
+      );
+    });
+  }
+  delete(args) {
+    return __async(this, null, function* () {
+      return this.callWithSession(
+        () => deleteSubscription({
+          emitter: this._emitter,
+          apiService: this._inboxService,
+          args
+        })
+      );
+    });
+  }
+};
+_useCache4 = new WeakMap();
+_subscriber = new WeakMap();
+
 // src/api/http-client.ts
 var DEFAULT_API_VERSION = "v1";
-var DEFAULT_USER_AGENT = `${"@novu/js"}@${"3.11.1"}`;
+var DEFAULT_USER_AGENT = `${"@novu/js"}@${"3.11.2-nightly.20251224.97b30e30dd"}`;
 var HttpClient = class {
   constructor(options = {}) {
     // Environment variable for local development that overrides the default API endpoint without affecting the Inbox DX
@@ -435,6 +1205,66 @@ var InboxService = class {
     };
     return __privateGet(this, _httpClient).post("/inbox/events", payload);
   }
+  fetchSubscriptions(topicKey) {
+    return __privateGet(this, _httpClient).get(`${INBOX_ROUTE}/topics/${topicKey}/subscriptions`);
+  }
+  getSubscription(topicKey, identifier, workflowIds, tags) {
+    const searchParams = new URLSearchParams();
+    if (workflowIds == null ? void 0 : workflowIds.length)
+      for (const workflowIdentifier of workflowIds) searchParams.append("workflowIds", workflowIdentifier);
+    if (tags == null ? void 0 : tags.length) for (const tag of tags) searchParams.append("tags", tag);
+    const query = searchParams.size ? `?${searchParams.toString()}` : "";
+    return __privateGet(this, _httpClient).get(`${INBOX_ROUTE}/topics/${topicKey}/subscriptions/${identifier}${query}`);
+  }
+  createSubscription({
+    identifier,
+    name,
+    topicKey,
+    topicName,
+    preferences
+  }) {
+    return __privateGet(this, _httpClient).post(`${INBOX_ROUTE}/topics/${topicKey}/subscriptions`, __spreadValues(__spreadValues({
+      identifier,
+      name
+    }, topicName && { topic: { name: topicName } }), preferences !== void 0 && { preferences }));
+  }
+  updateSubscription({
+    topicKey,
+    subscriptionId,
+    name,
+    preferences
+  }) {
+    return __privateGet(this, _httpClient).patch(`${INBOX_ROUTE}/topics/${topicKey}/subscriptions/${subscriptionId}`, __spreadValues({
+      name
+    }, preferences !== void 0 && { preferences }));
+  }
+  updateSubscriptionPreference({
+    subscriptionId,
+    workflowId,
+    enabled,
+    condition,
+    email,
+    sms,
+    in_app,
+    chat,
+    push
+  }) {
+    return __privateGet(this, _httpClient).patch(`${INBOX_ROUTE}/subscriptions/${subscriptionId}/preferences/${workflowId}`, {
+      enabled,
+      condition,
+      email,
+      sms,
+      in_app,
+      chat,
+      push
+    });
+  }
+  bulkUpdateSubscriptionPreferences(preferences) {
+    return __privateGet(this, _httpClient).patch(`${INBOX_ROUTE}/preferences/bulk`, { preferences });
+  }
+  deleteSubscription({ topicKey, subscriptionId }) {
+    return __privateGet(this, _httpClient).delete(`${INBOX_ROUTE}/topics/${topicKey}/subscriptions/${subscriptionId}`);
+  }
 };
 _httpClient = new WeakMap();
 var _mittEmitter;
@@ -458,88 +1288,6 @@ var NovuEventEmitter = class {
 };
 _mittEmitter = new WeakMap();
 
-// src/base-module.ts
-var _callsQueue, _sessionError;
-var BaseModule = class {
-  constructor({
-    inboxServiceInstance,
-    eventEmitterInstance
-  }) {
-    __privateAdd(this, _callsQueue, []);
-    __privateAdd(this, _sessionError);
-    this._emitter = eventEmitterInstance;
-    this._inboxService = inboxServiceInstance;
-    this._emitter.on("session.initialize.resolved", ({ error, data }) => {
-      if (data) {
-        this.onSessionSuccess(data);
-        __privateGet(this, _callsQueue).forEach((_0) => __async(this, [_0], function* ({ fn, resolve }) {
-          resolve(yield fn());
-        }));
-        __privateSet(this, _callsQueue, []);
-      } else if (error) {
-        this.onSessionError(error);
-        __privateSet(this, _sessionError, error);
-        __privateGet(this, _callsQueue).forEach(({ resolve }) => {
-          resolve({ error: new NovuError("Failed to initialize session, please contact the support", error) });
-        });
-        __privateSet(this, _callsQueue, []);
-      }
-    });
-  }
-  onSessionSuccess(_) {
-  }
-  onSessionError(_) {
-  }
-  callWithSession(fn) {
-    return __async(this, null, function* () {
-      if (this._inboxService.isSessionInitialized) {
-        return fn();
-      }
-      if (__privateGet(this, _sessionError)) {
-        return Promise.resolve({
-          error: new NovuError("Failed to initialize session, please contact the support", __privateGet(this, _sessionError))
-        });
-      }
-      return new Promise((resolve, reject) => {
-        __privateGet(this, _callsQueue).push({ fn, resolve, reject });
-      });
-    });
-  }
-};
-_callsQueue = new WeakMap();
-_sessionError = new WeakMap();
-
-// src/cache/in-memory-cache.ts
-var _cache;
-var InMemoryCache = class {
-  constructor() {
-    __privateAdd(this, _cache);
-    __privateSet(this, _cache, /* @__PURE__ */ new Map());
-  }
-  get(key) {
-    return __privateGet(this, _cache).get(key);
-  }
-  getValues() {
-    return Array.from(__privateGet(this, _cache).values());
-  }
-  entries() {
-    return Array.from(__privateGet(this, _cache).entries());
-  }
-  keys() {
-    return Array.from(__privateGet(this, _cache).keys());
-  }
-  set(key, value) {
-    __privateGet(this, _cache).set(key, value);
-  }
-  remove(key) {
-    __privateGet(this, _cache).delete(key);
-  }
-  clear() {
-    __privateGet(this, _cache).clear();
-  }
-};
-_cache = new WeakMap();
-
 // src/cache/notifications-cache.ts
 var excludeEmpty = ({
   tags,
@@ -606,17 +1354,17 @@ var removeEvents = [
   "notifications.archive_all_read.pending",
   "notifications.delete_all.pending"
 ];
-var _emitter, _inboxService, _cache2;
+var _emitter4, _inboxService4, _cache5;
 var NotificationsCache = class {
   constructor({ emitter, inboxService }) {
-    __privateAdd(this, _emitter);
-    __privateAdd(this, _inboxService);
+    __privateAdd(this, _emitter4);
+    __privateAdd(this, _inboxService4);
     /**
      * The key is the stringified notifications filter, the values are the paginated notifications.
      */
-    __privateAdd(this, _cache2);
+    __privateAdd(this, _cache5);
     this.updateNotification = (key, data) => {
-      const notificationsResponse = __privateGet(this, _cache2).get(key);
+      const notificationsResponse = __privateGet(this, _cache5).get(key);
       if (!notificationsResponse) {
         return false;
       }
@@ -626,11 +1374,11 @@ var NotificationsCache = class {
       }
       const updatedNotifications = [...notificationsResponse.notifications];
       updatedNotifications[index] = data;
-      __privateGet(this, _cache2).set(key, __spreadProps(__spreadValues({}, notificationsResponse), { notifications: updatedNotifications }));
+      __privateGet(this, _cache5).set(key, __spreadProps(__spreadValues({}, notificationsResponse), { notifications: updatedNotifications }));
       return true;
     };
     this.removeNotification = (key, data) => {
-      const notificationsResponse = __privateGet(this, _cache2).get(key);
+      const notificationsResponse = __privateGet(this, _cache5).get(key);
       if (!notificationsResponse) {
         return false;
       }
@@ -640,7 +1388,7 @@ var NotificationsCache = class {
       }
       const newNotifications = [...notificationsResponse.notifications];
       newNotifications.splice(index, 1);
-      __privateGet(this, _cache2).set(key, __spreadProps(__spreadValues({}, notificationsResponse), {
+      __privateGet(this, _cache5).set(key, __spreadProps(__spreadValues({}, notificationsResponse), {
         notifications: newNotifications
       }));
       return true;
@@ -659,8 +1407,8 @@ var NotificationsCache = class {
           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);
+          __privateGet(this, _cache5).keys().forEach((key) => {
+            const cachedResponse = __privateGet(this, _cache5).get(key);
             if (cachedResponse) {
               const found = cachedResponse.notifications.find((n) => n.id === args.notificationId);
               if (found) {
@@ -675,7 +1423,7 @@ var NotificationsCache = class {
         return;
       }
       const uniqueFilterKeys = /* @__PURE__ */ new Set();
-      __privateGet(this, _cache2).keys().forEach((key) => {
+      __privateGet(this, _cache5).keys().forEach((key) => {
         notifications.forEach((notification) => {
           let isNotificationFound = false;
           if (remove) {
@@ -690,27 +1438,27 @@ var NotificationsCache = class {
       });
       uniqueFilterKeys.forEach((key) => {
         const notificationsResponse = this.getAggregated(getFilter(key));
-        __privateGet(this, _emitter).emit("notifications.list.updated", {
+        __privateGet(this, _emitter4).emit("notifications.list.updated", {
           data: notificationsResponse
         });
       });
     };
-    __privateSet(this, _emitter, emitter);
-    __privateSet(this, _inboxService, inboxService);
+    __privateSet(this, _emitter4, emitter);
+    __privateSet(this, _inboxService4, inboxService);
     updateEvents.forEach((event) => {
-      __privateGet(this, _emitter).on(event, this.handleNotificationEvent());
+      __privateGet(this, _emitter4).on(event, this.handleNotificationEvent());
     });
     removeEvents.forEach((event) => {
-      __privateGet(this, _emitter).on(event, this.handleNotificationEvent({ remove: true }));
+      __privateGet(this, _emitter4).on(event, this.handleNotificationEvent({ remove: true }));
     });
-    __privateSet(this, _cache2, new InMemoryCache());
+    __privateSet(this, _cache5, new InMemoryCache());
   }
   getAggregated(filter) {
-    const cacheKeys = __privateGet(this, _cache2).keys().filter((key) => {
+    const cacheKeys = __privateGet(this, _cache5).keys().filter((key) => {
       const parsedFilter = getFilter(key);
       return isSameFilter(parsedFilter, filter);
     });
-    return cacheKeys.map((key) => __privateGet(this, _cache2).get(key)).reduce(
+    return cacheKeys.map((key) => __privateGet(this, _cache5).get(key)).reduce(
       (acc, el) => {
         if (!el) {
           return acc;
@@ -725,25 +1473,25 @@ var NotificationsCache = class {
     );
   }
   get(args) {
-    return __privateGet(this, _cache2).get(getCacheKey(args));
+    return __privateGet(this, _cache5).get(getCacheKey(args));
   }
   has(args) {
-    return __privateGet(this, _cache2).get(getCacheKey(args)) !== void 0;
+    return __privateGet(this, _cache5).get(getCacheKey(args)) !== void 0;
   }
   set(args, data) {
-    __privateGet(this, _cache2).set(getCacheKey(args), data);
+    __privateGet(this, _cache5).set(getCacheKey(args), data);
   }
   unshift(args, notification) {
     const cacheKey = getCacheKey(args);
-    const cachedData = __privateGet(this, _cache2).get(cacheKey) || {
+    const cachedData = __privateGet(this, _cache5).get(cacheKey) || {
       hasMore: false,
       filter: getFilter(cacheKey),
       notifications: []
     };
     const notificationInstance = createNotification({
       notification: __spreadValues({}, notification),
-      emitter: __privateGet(this, _emitter),
-      inboxService: __privateGet(this, _inboxService)
+      emitter: __privateGet(this, _emitter4),
+      inboxService: __privateGet(this, _inboxService4)
     });
     this.update(args, __spreadProps(__spreadValues({}, cachedData), {
       notifications: [notificationInstance, ...cachedData.notifications]
@@ -752,7 +1500,7 @@ var NotificationsCache = class {
   update(args, data) {
     this.set(args, data);
     const notificationsResponse = this.getAggregated(getFilter(getCacheKey(args)));
-    __privateGet(this, _emitter).emit("notifications.list.updated", {
+    __privateGet(this, _emitter4).emit("notifications.list.updated", {
       data: notificationsResponse
     });
   }
@@ -778,12 +1526,12 @@ var NotificationsCache = class {
     read: read2,
     data
   }) {
-    const keys = __privateGet(this, _cache2).keys();
+    const keys = __privateGet(this, _cache5).keys();
     const uniqueNotifications = /* @__PURE__ */ new Map();
     keys.forEach((key) => {
       const filter = getFilter(key);
       if (areTagsEqual(tags, filter.tags) && areDataEqual(data, filter.data)) {
-        const value = __privateGet(this, _cache2).get(key);
+        const value = __privateGet(this, _cache5).get(key);
         if (!value) {
           return;
         }
@@ -795,23 +1543,23 @@ var NotificationsCache = class {
     return Array.from(uniqueNotifications.values());
   }
   clear(filter) {
-    const keys = __privateGet(this, _cache2).keys();
+    const keys = __privateGet(this, _cache5).keys();
     keys.forEach((key) => {
       if (isSameFilter(getFilter(key), filter)) {
-        __privateGet(this, _cache2).remove(key);
+        __privateGet(this, _cache5).remove(key);
       }
     });
   }
   clearAll() {
-    __privateGet(this, _cache2).clear();
+    __privateGet(this, _cache5).clear();
   }
 };
-_emitter = new WeakMap();
-_inboxService = new WeakMap();
-_cache2 = new WeakMap();
+_emitter4 = new WeakMap();
+_inboxService4 = new WeakMap();
+_cache5 = new WeakMap();
 
 // src/notifications/notifications.ts
-var _useCache;
+var _useCache5;
 var Notifications = class extends BaseModule {
   constructor({
     useCache,
@@ -822,12 +1570,12 @@ var Notifications = class extends BaseModule {
       eventEmitterInstance,
       inboxServiceInstance
     });
-    __privateAdd(this, _useCache);
+    __privateAdd(this, _useCache5);
     this.cache = new NotificationsCache({
       emitter: eventEmitterInstance,
       inboxService: inboxServiceInstance
     });
-    __privateSet(this, _useCache, useCache);
+    __privateSet(this, _useCache5, useCache);
   }
   list() {
     return __async(this, arguments, function* (_a = {}) {
@@ -835,7 +1583,7 @@ var Notifications = class extends BaseModule {
       return this.callWithSession(() => __async(this, null, function* () {
         const args = __spreadValues({ limit }, restOptions);
         try {
-          const shouldUseCache = "useCache" in args ? args.useCache : __privateGet(this, _useCache);
+          const shouldUseCache = "useCache" in args ? args.useCache : __privateGet(this, _useCache5);
           let data = shouldUseCache ? this.cache.getAll(args) : void 0;
           this._emitter.emit("notifications.list.pending", { args, data });
           if (!data) {
@@ -1147,10 +1895,10 @@ var Notifications = class extends BaseModule {
     });
   }
 };
-_useCache = new WeakMap();
+_useCache5 = new WeakMap();
 
 // src/preferences/schedule.ts
-var _emitter2, _apiService, _cache3, _useCache2;
+var _emitter5, _apiService, _cache6, _useCache6;
 var Schedule = class {
   constructor(schedule, {
     emitterInstance,
@@ -1158,14 +1906,14 @@ var Schedule = class {
     cache,
     useCache
   }) {
-    __privateAdd(this, _emitter2);
+    __privateAdd(this, _emitter5);
     __privateAdd(this, _apiService);
-    __privateAdd(this, _cache3);
-    __privateAdd(this, _useCache2);
-    __privateSet(this, _emitter2, emitterInstance);
+    __privateAdd(this, _cache6);
+    __privateAdd(this, _useCache6);
+    __privateSet(this, _emitter5, emitterInstance);
     __privateSet(this, _apiService, inboxServiceInstance);
-    __privateSet(this, _cache3, cache);
-    __privateSet(this, _useCache2, useCache);
+    __privateSet(this, _cache6, cache);
+    __privateSet(this, _useCache6, useCache);
     this.isEnabled = schedule.isEnabled;
     this.weeklySchedule = schedule.weeklySchedule;
   }
@@ -1174,10 +1922,10 @@ var Schedule = class {
       var _a;
       const hasWeeklySchedule = !!args.weeklySchedule || !!this.weeklySchedule;
       return updateSchedule({
-        emitter: __privateGet(this, _emitter2),
+        emitter: __privateGet(this, _emitter5),
         apiService: __privateGet(this, _apiService),
-        cache: __privateGet(this, _cache3),
-        useCache: __privateGet(this, _useCache2),
+        cache: __privateGet(this, _cache6),
+        useCache: __privateGet(this, _useCache6),
         args: __spreadValues({
           isEnabled: (_a = args.isEnabled) != null ? _a : this.isEnabled
         }, hasWeeklySchedule && {
@@ -1187,13 +1935,13 @@ var Schedule = class {
     });
   }
 };
-_emitter2 = new WeakMap();
+_emitter5 = new WeakMap();
 _apiService = new WeakMap();
-_cache3 = new WeakMap();
-_useCache2 = new WeakMap();
+_cache6 = new WeakMap();
+_useCache6 = new WeakMap();
 
 // src/preferences/preference.ts
-var _emitter3, _apiService2, _cache4, _scheduleCache, _useCache3;
+var _emitter6, _apiService2, _cache7, _scheduleCache, _useCache7;
 var Preference = class {
   constructor(preference, {
     emitterInstance,
@@ -1202,16 +1950,16 @@ var Preference = class {
     scheduleCache,
     useCache
   }) {
-    __privateAdd(this, _emitter3);
+    __privateAdd(this, _emitter6);
     __privateAdd(this, _apiService2);
-    __privateAdd(this, _cache4);
+    __privateAdd(this, _cache7);
     __privateAdd(this, _scheduleCache);
-    __privateAdd(this, _useCache3);
-    __privateSet(this, _emitter3, emitterInstance);
+    __privateAdd(this, _useCache7);
+    __privateSet(this, _emitter6, emitterInstance);
     __privateSet(this, _apiService2, inboxServiceInstance);
-    __privateSet(this, _cache4, cache);
+    __privateSet(this, _cache7, cache);
     __privateSet(this, _scheduleCache, scheduleCache);
-    __privateSet(this, _useCache3, useCache);
+    __privateSet(this, _useCache7, useCache);
     this.level = preference.level;
     this.enabled = preference.enabled;
     this.channels = preference.channels;
@@ -1227,11 +1975,11 @@ var Preference = class {
   }) {
     var _a;
     return updatePreference({
-      emitter: __privateGet(this, _emitter3),
+      emitter: __privateGet(this, _emitter6),
       apiService: __privateGet(this, _apiService2),
-      cache: __privateGet(this, _cache4),
+      cache: __privateGet(this, _cache7),
       scheduleCache: __privateGet(this, _scheduleCache),
-      useCache: __privateGet(this, _useCache3),
+      useCache: __privateGet(this, _useCache7),
       args: {
         workflowId: (_a = this.workflow) == null ? void 0 : _a.id,
         channels: channels || channelPreferences,
@@ -1240,11 +1988,11 @@ var Preference = class {
     });
   }
 };
-_emitter3 = new WeakMap();
+_emitter6 = new WeakMap();
 _apiService2 = new WeakMap();
-_cache4 = new WeakMap();
+_cache7 = new WeakMap();
 _scheduleCache = new WeakMap();
-_useCache3 = new WeakMap();
+_useCache7 = new WeakMap();
 
 // src/preferences/helpers.ts
 var updatePreference = (_0) => __async(void 0, [_0], function* ({
@@ -1441,7 +2189,7 @@ var updateSchedule = (_0) => __async(void 0, [_0], function* ({
 });
 
 // src/preferences/preference-schedule.ts
-var _useCache4;
+var _useCache8;
 var PreferenceSchedule = class extends BaseModule {
   constructor({
     cache,
@@ -1453,16 +2201,16 @@ var PreferenceSchedule = class extends BaseModule {
       eventEmitterInstance,
       inboxServiceInstance
     });
-    __privateAdd(this, _useCache4);
+    __privateAdd(this, _useCache8);
     this.cache = cache;
-    __privateSet(this, _useCache4, useCache);
+    __privateSet(this, _useCache8, 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;
+          let data = __privateGet(this, _useCache8) ? this.cache.getAll() : void 0;
           this._emitter.emit("preference.schedule.get.pending", { args: void 0, data });
           if (!data) {
             const globalPreference = yield this._inboxService.fetchGlobalPreferences();
@@ -1475,10 +2223,10 @@ var PreferenceSchedule = class extends BaseModule {
                 emitterInstance: this._emitter,
                 inboxServiceInstance: this._inboxService,
                 cache: this.cache,
-                useCache: __privateGet(this, _useCache4)
+                useCache: __privateGet(this, _useCache8)
               }
             );
-            if (__privateGet(this, _useCache4)) {
+            if (__privateGet(this, _useCache8)) {
               this.cache.set(data);
               data = this.cache.getAll();
             }
@@ -1502,14 +2250,14 @@ var PreferenceSchedule = class extends BaseModule {
           emitter: this._emitter,
           apiService: this._inboxService,
           cache: this.cache,
-          useCache: __privateGet(this, _useCache4),
+          useCache: __privateGet(this, _useCache8),
           args
         })
       );
     });
   }
 };
-_useCache4 = new WeakMap();
+_useCache8 = new WeakMap();
 
 // src/cache/preferences-cache.ts
 var updateEvents2 = [
@@ -1532,13 +2280,13 @@ var excludeEmpty2 = ({ tags, severity }) => Object.entries({ tags, severity }).r
 var getCacheKey2 = ({ tags, severity }) => {
   return JSON.stringify(excludeEmpty2({ tags, severity }));
 };
-var _emitter4, _cache5;
+var _emitter7, _cache8;
 var PreferencesCache = class {
   constructor({ emitterInstance }) {
-    __privateAdd(this, _emitter4);
-    __privateAdd(this, _cache5);
+    __privateAdd(this, _emitter7);
+    __privateAdd(this, _cache8);
     this.updatePreference = (key, data) => {
-      const preferences = __privateGet(this, _cache5).get(key);
+      const preferences = __privateGet(this, _cache8).get(key);
       if (!preferences) {
         return false;
       }
@@ -1553,11 +2301,11 @@ var PreferencesCache = class {
       }
       const updatedPreferences = [...preferences];
       updatedPreferences[index] = data;
-      __privateGet(this, _cache5).set(key, updatedPreferences);
+      __privateGet(this, _cache8).set(key, updatedPreferences);
       return true;
     };
     this.updatePreferenceSchedule = (key, data) => {
-      const preferences = __privateGet(this, _cache5).get(key);
+      const preferences = __privateGet(this, _cache8).get(key);
       if (!preferences) {
         return false;
       }
@@ -1567,7 +2315,7 @@ var PreferencesCache = class {
       }
       const updatedPreferences = [...preferences];
       updatedPreferences[index].schedule = data;
-      __privateGet(this, _cache5).set(key, updatedPreferences);
+      __privateGet(this, _cache8).set(key, updatedPreferences);
       return true;
     };
     this.handleScheduleEvent = ({ data }) => {
@@ -1575,19 +2323,19 @@ var PreferencesCache = class {
       if (!data) {
         return;
       }
-      const cacheKeys = __privateGet(this, _cache5).keys();
+      const cacheKeys = __privateGet(this, _cache8).keys();
       const uniqueFilterKeys = /* @__PURE__ */ new Set();
       for (const key of cacheKeys) {
         const hasUpdatedPreference = this.updatePreferenceSchedule(key, data);
-        const updatedPreference = __privateGet(this, _cache5).get(key);
+        const updatedPreference = __privateGet(this, _cache8).get(key);
         if (!hasUpdatedPreference || !updatedPreference) {
           continue;
         }
         uniqueFilterKeys.add(key);
       }
       for (const key of uniqueFilterKeys) {
-        __privateGet(this, _emitter4).emit("preferences.list.updated", {
-          data: (_a = __privateGet(this, _cache5).get(key)) != null ? _a : []
+        __privateGet(this, _emitter7).emit("preferences.list.updated", {
+          data: (_a = __privateGet(this, _cache8).get(key)) != null ? _a : []
         });
       }
     };
@@ -1597,10 +2345,10 @@ var PreferencesCache = class {
       }
       const preferences = Array.isArray(data) ? data : [data];
       const uniqueFilterKeys = /* @__PURE__ */ new Set();
-      __privateGet(this, _cache5).keys().forEach((key) => {
+      __privateGet(this, _cache8).keys().forEach((key) => {
         preferences.forEach((preference) => {
           const hasUpdatedPreference = this.updatePreference(key, preference);
-          const updatedPreference = __privateGet(this, _cache5).get(key);
+          const updatedPreference = __privateGet(this, _cache8).get(key);
           if (!hasUpdatedPreference || !updatedPreference) {
             return;
           }
@@ -1609,37 +2357,37 @@ var PreferencesCache = class {
       });
       uniqueFilterKeys.forEach((key) => {
         var _a;
-        __privateGet(this, _emitter4).emit("preferences.list.updated", {
-          data: (_a = __privateGet(this, _cache5).get(key)) != null ? _a : []
+        __privateGet(this, _emitter7).emit("preferences.list.updated", {
+          data: (_a = __privateGet(this, _cache8).get(key)) != null ? _a : []
         });
       });
     };
-    __privateSet(this, _emitter4, emitterInstance);
+    __privateSet(this, _emitter7, emitterInstance);
     for (const event of updateEvents2) {
-      __privateGet(this, _emitter4).on(event, this.handlePreferenceEvent);
+      __privateGet(this, _emitter7).on(event, this.handlePreferenceEvent);
     }
     for (const event of scheduleUpdateEvents) {
-      __privateGet(this, _emitter4).on(event, this.handleScheduleEvent);
+      __privateGet(this, _emitter7).on(event, this.handleScheduleEvent);
     }
-    __privateSet(this, _cache5, new InMemoryCache());
+    __privateSet(this, _cache8, new InMemoryCache());
   }
   has(args) {
-    return __privateGet(this, _cache5).get(getCacheKey2(args)) !== void 0;
+    return __privateGet(this, _cache8).get(getCacheKey2(args)) !== void 0;
   }
   set(args, data) {
-    __privateGet(this, _cache5).set(getCacheKey2(args), data);
+    __privateGet(this, _cache8).set(getCacheKey2(args), data);
   }
   getAll(args) {
     if (this.has(args)) {
-      return __privateGet(this, _cache5).get(getCacheKey2(args));
+      return __privateGet(this, _cache8).get(getCacheKey2(args));
     }
   }
   clearAll() {
-    __privateGet(this, _cache5).clear();
+    __privateGet(this, _cache8).clear();
   }
 };
-_emitter4 = new WeakMap();
-_cache5 = new WeakMap();
+_emitter7 = new WeakMap();
+_cache8 = new WeakMap();
 
 // src/cache/schedule-cache.ts
 var updateEvents3 = [
@@ -1649,17 +2397,17 @@ var updateEvents3 = [
 var getCacheKey3 = () => {
   return "schedule";
 };
-var _emitter5, _cache6;
+var _emitter8, _cache9;
 var ScheduleCache = class {
   constructor({ emitterInstance }) {
-    __privateAdd(this, _emitter5);
-    __privateAdd(this, _cache6);
+    __privateAdd(this, _emitter8);
+    __privateAdd(this, _cache9);
     this.updateScheduleInCache = (key, data) => {
-      const schedule = __privateGet(this, _cache6).get(key);
+      const schedule = __privateGet(this, _cache9).get(key);
       if (!schedule) {
         return false;
       }
-      __privateGet(this, _cache6).set(key, data);
+      __privateGet(this, _cache9).set(key, data);
       return true;
     };
     this.handleScheduleEvent = ({ data }) => {
@@ -1667,47 +2415,47 @@ var ScheduleCache = class {
         return;
       }
       const uniqueFilterKeys = /* @__PURE__ */ new Set();
-      const keys = __privateGet(this, _cache6).keys();
+      const keys = __privateGet(this, _cache9).keys();
       for (const key of keys) {
         const hasUpdatedSchedule = this.updateScheduleInCache(key, data);
-        const updatedSchedule = __privateGet(this, _cache6).get(key);
+        const updatedSchedule = __privateGet(this, _cache9).get(key);
         if (!hasUpdatedSchedule || !updatedSchedule) {
           continue;
         }
         uniqueFilterKeys.add(key);
       }
       for (const key of uniqueFilterKeys) {
-        __privateGet(this, _emitter5).emit("preference.schedule.get.updated", {
-          data: __privateGet(this, _cache6).get(key)
+        __privateGet(this, _emitter8).emit("preference.schedule.get.updated", {
+          data: __privateGet(this, _cache9).get(key)
         });
       }
     };
-    __privateSet(this, _emitter5, emitterInstance);
+    __privateSet(this, _emitter8, emitterInstance);
     for (const event of updateEvents3) {
-      __privateGet(this, _emitter5).on(event, this.handleScheduleEvent);
+      __privateGet(this, _emitter8).on(event, this.handleScheduleEvent);
     }
-    __privateSet(this, _cache6, new InMemoryCache());
+    __privateSet(this, _cache9, new InMemoryCache());
   }
   has() {
-    return __privateGet(this, _cache6).get(getCacheKey3()) !== void 0;
+    return __privateGet(this, _cache9).get(getCacheKey3()) !== void 0;
   }
   set(data) {
-    __privateGet(this, _cache6).set(getCacheKey3(), data);
+    __privateGet(this, _cache9).set(getCacheKey3(), data);
   }
   getAll() {
     if (this.has()) {
-      return __privateGet(this, _cache6).get(getCacheKey3());
+      return __privateGet(this, _cache9).get(getCacheKey3());
     }
   }
   clearAll() {
-    __privateGet(this, _cache6).clear();
+    __privateGet(this, _cache9).clear();
   }
 };
-_emitter5 = new WeakMap();
-_cache6 = new WeakMap();
+_emitter8 = new WeakMap();
+_cache9 = new WeakMap();
 
 // src/preferences/preferences.ts
-var _useCache5;
+var _useCache9;
 var Preferences = class extends BaseModule {
   constructor({
     useCache,
@@ -1718,14 +2466,14 @@ var Preferences = class extends BaseModule {
       eventEmitterInstance,
       inboxServiceInstance
     });
-    __privateAdd(this, _useCache5);
+    __privateAdd(this, _useCache9);
     this.cache = new PreferencesCache({
       emitterInstance: this._emitter
     });
     this.scheduleCache = new ScheduleCache({
       emitterInstance: this._emitter
     });
-    __privateSet(this, _useCache5, useCache);
+    __privateSet(this, _useCache9, useCache);
     this.schedule = new PreferenceSchedule({
       cache: this.scheduleCache,
       useCache,
@@ -1738,7 +2486,7 @@ var Preferences = class extends BaseModule {
       return this.callWithSession(() => __async(this, null, function* () {
         var _a;
         try {
-          let data = __privateGet(this, _useCache5) ? this.cache.getAll(args) : void 0;
+          let data = __privateGet(this, _useCache9) ? this.cache.getAll(args) : void 0;
           this._emitter.emit("preferences.list.pending", { args, data });
           if (!data) {
             const response = yield this._inboxService.fetchPreferences({
@@ -1752,10 +2500,10 @@ var Preferences = class extends BaseModule {
                 inboxServiceInstance: this._inboxService,
                 cache: this.cache,
                 scheduleCache: this.scheduleCache,
-                useCache: __privateGet(this, _useCache5)
+                useCache: __privateGet(this, _useCache9)
               })
             );
-            if (__privateGet(this, _useCache5)) {
+            if (__privateGet(this, _useCache9)) {
               this.cache.set(args, data);
               data = this.cache.getAll(args);
             }
@@ -1777,7 +2525,7 @@ var Preferences = class extends BaseModule {
           apiService: this._inboxService,
           cache: this.cache,
           scheduleCache: this.scheduleCache,
-          useCache: __privateGet(this, _useCache5),
+          useCache: __privateGet(this, _useCache9),
           args
         })
       );
@@ -1791,14 +2539,14 @@ var Preferences = class extends BaseModule {
           apiService: this._inboxService,
           cache: this.cache,
           scheduleCache: this.scheduleCache,
-          useCache: __privateGet(this, _useCache5),
+          useCache: __privateGet(this, _useCache9),
           args
         })
       );
     });
   }
 };
-_useCache5 = new WeakMap();
+_useCache9 = new WeakMap();
 
 // src/utils/is-browser.ts
 function isBrowser() {
@@ -1806,14 +2554,14 @@ function isBrowser() {
 }
 
 // src/session/session.ts
-var _emitter6, _inboxService2, _options;
+var _emitter9, _inboxService5, _options;
 var Session = class {
   constructor(options, inboxServiceInstance, eventEmitterInstance) {
-    __privateAdd(this, _emitter6);
-    __privateAdd(this, _inboxService2);
+    __privateAdd(this, _emitter9);
+    __privateAdd(this, _inboxService5);
     __privateAdd(this, _options);
-    __privateSet(this, _emitter6, eventEmitterInstance);
-    __privateSet(this, _inboxService2, inboxServiceInstance);
+    __privateSet(this, _emitter9, eventEmitterInstance);
+    __privateSet(this, _inboxService5, inboxServiceInstance);
     __privateSet(this, _options, options);
   }
   get applicationIdentifier() {
@@ -1884,8 +2632,8 @@ var Session = class {
         } else {
           this.handleApplicationIdentifier("delete");
         }
-        __privateGet(this, _emitter6).emit("session.initialize.pending", { args: __privateGet(this, _options) });
-        const response = yield __privateGet(this, _inboxService2).initializeSession({
+        __privateGet(this, _emitter9).emit("session.initialize.pending", { args: __privateGet(this, _options) });
+        const response = yield __privateGet(this, _inboxService5).initializeSession({
           applicationIdentifier: finalApplicationIdentifier,
           subscriberHash,
           contextHash,
@@ -1902,15 +2650,15 @@ var Session = class {
         if (!((_f = response == null ? void 0 : response.applicationIdentifier) == null ? void 0 : _f.startsWith("pk_keyless_"))) {
           this.handleApplicationIdentifier("delete");
         }
-        __privateGet(this, _emitter6).emit("session.initialize.resolved", { args: __privateGet(this, _options), data: response });
+        __privateGet(this, _emitter9).emit("session.initialize.resolved", { args: __privateGet(this, _options), data: response });
       } catch (error) {
-        __privateGet(this, _emitter6).emit("session.initialize.resolved", { args: __privateGet(this, _options), error });
+        __privateGet(this, _emitter9).emit("session.initialize.resolved", { args: __privateGet(this, _options), error });
       }
     });
   }
 };
-_emitter6 = new WeakMap();
-_inboxService2 = new WeakMap();
+_emitter9 = new WeakMap();
+_inboxService5 = new WeakMap();
 _options = new WeakMap();
 var PRODUCTION_SOCKET_URL = "wss://socket.novu.co";
 var NOTIFICATION_RECEIVED = "notifications.notification_received";
@@ -2003,7 +2751,7 @@ var mapToNotification = ({
     severity
   });
 };
-var _token, _emitter7, _partySocket, _socketUrl, _notificationReceived, _unseenCountChanged, _unreadCountChanged, _handleMessage, _PartySocketClient_instances, initializeSocket_fn, handleConnectSocket_fn, handleDisconnectSocket_fn;
+var _token, _emitter10, _partySocket, _socketUrl, _notificationReceived, _unseenCountChanged, _unreadCountChanged, _handleMessage, _PartySocketClient_instances, initializeSocket_fn, handleConnectSocket_fn, handleDisconnectSocket_fn;
 var PartySocketClient = class extends BaseModule {
   constructor({
     socketUrl,
@@ -2016,15 +2764,15 @@ var PartySocketClient = class extends BaseModule {
     });
     __privateAdd(this, _PartySocketClient_instances);
     __privateAdd(this, _token);
-    __privateAdd(this, _emitter7);
+    __privateAdd(this, _emitter10);
     __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, _emitter7).emit(NOTIFICATION_RECEIVED, {
-            result: new Notification(mapToNotification(data.data.message), __privateGet(this, _emitter7), this._inboxService)
+          __privateGet(this, _emitter10).emit(NOTIFICATION_RECEIVED, {
+            result: new Notification(mapToNotification(data.data.message), __privateGet(this, _emitter10), this._inboxService)
           });
         }
       } catch (error) {
@@ -2035,7 +2783,7 @@ var PartySocketClient = class extends BaseModule {
       try {
         const data = JSON.parse(event.data);
         if (data.event === "unseen_count_changed" /* UNSEEN */) {
-          __privateGet(this, _emitter7).emit(UNSEEN_COUNT_CHANGED, {
+          __privateGet(this, _emitter10).emit(UNSEEN_COUNT_CHANGED, {
             result: data.data.unseenCount
           });
         }
@@ -2046,7 +2794,7 @@ var PartySocketClient = class extends BaseModule {
       try {
         const data = JSON.parse(event.data);
         if (data.event === "unread_count_changed" /* UNREAD */) {
-          __privateGet(this, _emitter7).emit(UNREAD_COUNT_CHANGED, {
+          __privateGet(this, _emitter10).emit(UNREAD_COUNT_CHANGED, {
             result: data.data.counts
           });
         }
@@ -2071,7 +2819,7 @@ var PartySocketClient = class extends BaseModule {
       } catch (error) {
       }
     });
-    __privateSet(this, _emitter7, eventEmitterInstance);
+    __privateSet(this, _emitter10, eventEmitterInstance);
     __privateSet(this, _socketUrl, socketUrl != null ? socketUrl : PRODUCTION_SOCKET_URL);
   }
   onSessionSuccess({ token }) {
@@ -2098,7 +2846,7 @@ var PartySocketClient = class extends BaseModule {
   }
 };
 _token = new WeakMap();
-_emitter7 = new WeakMap();
+_emitter10 = new WeakMap();
 _partySocket = new WeakMap();
 _socketUrl = new WeakMap();
 _notificationReceived = new WeakMap();
@@ -2112,15 +2860,15 @@ initializeSocket_fn = function() {
       return;
     }
     const args = { socketUrl: __privateGet(this, _socketUrl) };
-    __privateGet(this, _emitter7).emit("socket.connect.pending", { args });
+    __privateGet(this, _emitter10).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, _emitter7).emit("socket.connect.resolved", { args });
+      __privateGet(this, _emitter10).emit("socket.connect.resolved", { args });
     });
     __privateGet(this, _partySocket).addEventListener("error", (error) => {
-      __privateGet(this, _emitter7).emit("socket.connect.resolved", { args, error });
+      __privateGet(this, _emitter10).emit("socket.connect.resolved", { args, error });
     });
     __privateGet(this, _partySocket).addEventListener("message", __privateGet(this, _handleMessage));
   });
@@ -2238,7 +2986,7 @@ var mapToNotification2 = ({
     severity
   });
 };
-var _token2, _emitter8, _socketIo, _socketUrl2, _notificationReceived2, _unseenCountChanged2, _unreadCountChanged2, _Socket_instances, initializeSocket_fn2, handleConnectSocket_fn2, handleDisconnectSocket_fn2;
+var _token2, _emitter11, _socketIo, _socketUrl2, _notificationReceived2, _unseenCountChanged2, _unreadCountChanged2, _Socket_instances, initializeSocket_fn2, handleConnectSocket_fn2, handleDisconnectSocket_fn2;
 var Socket = class extends BaseModule {
   constructor({
     socketUrl,
@@ -2251,25 +2999,25 @@ var Socket = class extends BaseModule {
     });
     __privateAdd(this, _Socket_instances);
     __privateAdd(this, _token2);
-    __privateAdd(this, _emitter8);
+    __privateAdd(this, _emitter11);
     __privateAdd(this, _socketIo);
     __privateAdd(this, _socketUrl2);
     __privateAdd(this, _notificationReceived2, ({ message }) => {
-      __privateGet(this, _emitter8).emit(NOTIFICATION_RECEIVED2, {
-        result: new Notification(mapToNotification2(message), __privateGet(this, _emitter8), this._inboxService)
+      __privateGet(this, _emitter11).emit(NOTIFICATION_RECEIVED2, {
+        result: new Notification(mapToNotification2(message), __privateGet(this, _emitter11), this._inboxService)
       });
     });
     __privateAdd(this, _unseenCountChanged2, ({ unseenCount }) => {
-      __privateGet(this, _emitter8).emit(UNSEEN_COUNT_CHANGED2, {
+      __privateGet(this, _emitter11).emit(UNSEEN_COUNT_CHANGED2, {
         result: unseenCount
       });
     });
     __privateAdd(this, _unreadCountChanged2, ({ counts }) => {
-      __privateGet(this, _emitter8).emit(UNREAD_COUNT_CHANGED2, {
+      __privateGet(this, _emitter11).emit(UNREAD_COUNT_CHANGED2, {
         result: counts
       });
     });
-    __privateSet(this, _emitter8, eventEmitterInstance);
+    __privateSet(this, _emitter11, eventEmitterInstance);
     __privateSet(this, _socketUrl2, socketUrl != null ? socketUrl : PRODUCTION_SOCKET_URL2);
   }
   onSessionSuccess({ token }) {
@@ -2296,7 +3044,7 @@ var Socket = class extends BaseModule {
   }
 };
 _token2 = new WeakMap();
-_emitter8 = new WeakMap();
+_emitter11 = new WeakMap();
 _socketIo = new WeakMap();
 _socketUrl2 = new WeakMap();
 _notificationReceived2 = new WeakMap();
@@ -2310,7 +3058,7 @@ initializeSocket_fn2 = function() {
       return;
     }
     const args = { socketUrl: __privateGet(this, _socketUrl2) };
-    __privateGet(this, _emitter8).emit("socket.connect.pending", { args });
+    __privateGet(this, _emitter11).emit("socket.connect.pending", { args });
     __privateSet(this, _socketIo, io(__privateGet(this, _socketUrl2), {
       reconnectionDelayMax: 1e4,
       transports: ["websocket"],
@@ -2319,10 +3067,10 @@ initializeSocket_fn2 = function() {
       }
     }));
     __privateGet(this, _socketIo).on("connect", () => {
-      __privateGet(this, _emitter8).emit("socket.connect.resolved", { args });
+      __privateGet(this, _emitter11).emit("socket.connect.resolved", { args });
     });
     __privateGet(this, _socketIo).on("connect_error", (error) => {
-      __privateGet(this, _emitter8).emit("socket.connect.resolved", { args, error });
+      __privateGet(this, _emitter11).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));
@@ -2396,57 +3144,66 @@ function createSocket({
 }
 
 // src/novu.ts
-var _emitter9, _session, _inboxService3;
+var _emitter12, _session, _inboxService6, _options2;
 var Novu = class {
   constructor(options) {
-    __privateAdd(this, _emitter9);
+    __privateAdd(this, _emitter12);
     __privateAdd(this, _session);
-    __privateAdd(this, _inboxService3);
-    var _a, _b;
-    __privateSet(this, _inboxService3, new InboxService({
+    __privateAdd(this, _inboxService6);
+    __privateAdd(this, _options2);
+    var _a, _b, _c;
+    __privateSet(this, _options2, options);
+    __privateSet(this, _inboxService6, new InboxService({
       apiUrl: options.apiUrl || options.backendUrl,
       userAgent: options.__userAgent
     }));
-    __privateSet(this, _emitter9, new NovuEventEmitter());
+    __privateSet(this, _emitter12, new NovuEventEmitter());
+    const subscriber = buildSubscriber({ subscriberId: options.subscriberId, subscriber: options.subscriber });
     __privateSet(this, _session, new Session(
       {
         applicationIdentifier: options.applicationIdentifier || "",
         subscriberHash: options.subscriberHash,
-        subscriber: buildSubscriber({ subscriberId: options.subscriberId, subscriber: options.subscriber }),
+        subscriber,
         defaultSchedule: options.defaultSchedule,
         context: options.context,
         contextHash: options.contextHash
       },
-      __privateGet(this, _inboxService3),
-      __privateGet(this, _emitter9)
+      __privateGet(this, _inboxService6),
+      __privateGet(this, _emitter12)
     ));
     __privateGet(this, _session).initialize();
     this.notifications = new Notifications({
       useCache: (_a = options.useCache) != null ? _a : true,
-      inboxServiceInstance: __privateGet(this, _inboxService3),
-      eventEmitterInstance: __privateGet(this, _emitter9)
+      inboxServiceInstance: __privateGet(this, _inboxService6),
+      eventEmitterInstance: __privateGet(this, _emitter12)
     });
     this.preferences = new Preferences({
       useCache: (_b = options.useCache) != null ? _b : true,
-      inboxServiceInstance: __privateGet(this, _inboxService3),
-      eventEmitterInstance: __privateGet(this, _emitter9)
+      inboxServiceInstance: __privateGet(this, _inboxService6),
+      eventEmitterInstance: __privateGet(this, _emitter12)
+    });
+    this.subscriptions = new Subscriptions({
+      subscriber,
+      useCache: (_c = options.useCache) != null ? _c : true,
+      inboxServiceInstance: __privateGet(this, _inboxService6),
+      eventEmitterInstance: __privateGet(this, _emitter12)
     });
     this.socket = createSocket({
       socketUrl: options.socketUrl,
-      eventEmitterInstance: __privateGet(this, _emitter9),
-      inboxServiceInstance: __privateGet(this, _inboxService3)
+      eventEmitterInstance: __privateGet(this, _emitter12),
+      inboxServiceInstance: __privateGet(this, _inboxService6)
     });
     this.on = (eventName, listener) => {
       if (this.socket.isSocketEvent(eventName)) {
         this.socket.connect();
       }
-      const cleanup = __privateGet(this, _emitter9).on(eventName, listener);
+      const cleanup = __privateGet(this, _emitter12).on(eventName, listener);
       return () => {
         cleanup();
       };
     };
     this.off = (eventName, listener) => {
-      __privateGet(this, _emitter9).off(eventName, listener);
+      __privateGet(this, _emitter12).off(eventName, listener);
     };
   }
   get applicationIdentifier() {
@@ -2458,9 +3215,21 @@ var Novu = class {
   get context() {
     return __privateGet(this, _session).context;
   }
+  get options() {
+    return __privateGet(this, _options2);
+  }
   get contextKey() {
     return buildContextKey(__privateGet(this, _session).context);
   }
+  clearCache() {
+    this.notifications.cache.clearAll();
+    this.preferences.cache.clearAll();
+    this.preferences.scheduleCache.clearAll();
+    this.subscriptions.cache.clearAll();
+  }
+  /**
+   * @deprecated
+   */
   changeSubscriber(options) {
     return __async(this, null, function* () {
       yield __privateGet(this, _session).initialize({
@@ -2471,13 +3240,16 @@ var Novu = class {
         context: __privateGet(this, _session).context,
         contextHash: __privateGet(this, _session).contextHash
       });
-      this.notifications.cache.clearAll();
+      this.clearCache();
       const disconnectResult = yield this.socket.disconnect();
       if (!disconnectResult.error) {
         yield this.socket.connect();
       }
     });
   }
+  /**
+   * @deprecated
+   */
   changeContext(options) {
     return __async(this, null, function* () {
       const currentSubscriber = __privateGet(this, _session).subscriber;
@@ -2492,7 +3264,7 @@ var Novu = class {
         context: options.context,
         contextHash: options.contextHash
       });
-      this.notifications.cache.clearAll();
+      this.clearCache();
       const disconnectResult = yield this.socket.disconnect();
       if (!disconnectResult.error) {
         yield this.socket.connect();
@@ -2500,8 +3272,9 @@ var Novu = class {
     });
   }
 };
-_emitter9 = new WeakMap();
+_emitter12 = new WeakMap();
 _session = new WeakMap();
-_inboxService3 = new WeakMap();
+_inboxService6 = new WeakMap();
+_options2 = new WeakMap();
 
-export { DEFAULT_API_VERSION, Novu, areSeveritiesEqual, areTagsEqual, checkNotificationDataFilter, checkNotificationMatchesFilter, checkNotificationTagFilter, isBrowser, isSameFilter };
+export { DEFAULT_API_VERSION, Novu, SubscriptionPreference, TopicSubscription, areSeveritiesEqual, areTagsEqual, checkNotificationDataFilter, checkNotificationMatchesFilter, checkNotificationTagFilter, isBrowser, isSameFilter };