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

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

@@ -1,53 +1,10 @@
-import { buildSubscriber, buildContextKey } from './chunk-RZWQYM3H.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';
 import io from 'socket.io-client';
 
-// src/types.ts
-var NotificationStatus = /* @__PURE__ */ ((NotificationStatus2) => {
-  NotificationStatus2["READ"] = "read";
-  NotificationStatus2["SEEN"] = "seen";
-  NotificationStatus2["SNOOZED"] = "snoozed";
-  NotificationStatus2["UNREAD"] = "unread";
-  NotificationStatus2["UNSEEN"] = "unseen";
-  NotificationStatus2["UNSNOOZED"] = "unsnoozed";
-  return NotificationStatus2;
-})(NotificationStatus || {});
-var PreferenceLevel = /* @__PURE__ */ ((PreferenceLevel2) => {
-  PreferenceLevel2["GLOBAL"] = "global";
-  PreferenceLevel2["TEMPLATE"] = "template";
-  return PreferenceLevel2;
-})(PreferenceLevel || {});
-var ChannelType = /* @__PURE__ */ ((ChannelType2) => {
-  ChannelType2["IN_APP"] = "in_app";
-  ChannelType2["EMAIL"] = "email";
-  ChannelType2["SMS"] = "sms";
-  ChannelType2["CHAT"] = "chat";
-  ChannelType2["PUSH"] = "push";
-  return ChannelType2;
-})(ChannelType || {});
-var WebSocketEvent = /* @__PURE__ */ ((WebSocketEvent2) => {
-  WebSocketEvent2["RECEIVED"] = "notification_received";
-  WebSocketEvent2["UNREAD"] = "unread_count_changed";
-  WebSocketEvent2["UNSEEN"] = "unseen_count_changed";
-  return WebSocketEvent2;
-})(WebSocketEvent || {});
-var SeverityLevelEnum = /* @__PURE__ */ ((SeverityLevelEnum2) => {
-  SeverityLevelEnum2["HIGH"] = "high";
-  SeverityLevelEnum2["MEDIUM"] = "medium";
-  SeverityLevelEnum2["LOW"] = "low";
-  SeverityLevelEnum2["NONE"] = "none";
-  return SeverityLevelEnum2;
-})(SeverityLevelEnum || {});
-var WorkflowCriticalityEnum = /* @__PURE__ */ ((WorkflowCriticalityEnum2) => {
-  WorkflowCriticalityEnum2["CRITICAL"] = "critical";
-  WorkflowCriticalityEnum2["NON_CRITICAL"] = "nonCritical";
-  WorkflowCriticalityEnum2["ALL"] = "all";
-  return WorkflowCriticalityEnum2;
-})(WorkflowCriticalityEnum || {});
-
 // src/utils/arrays.ts
 var arrayValuesEqual = (arr1, arr2) => {
   if (arr1 === arr2) {
@@ -139,1098 +96,1197 @@ function checkNotificationMatchesFilter(notification, filter) {
   return checkBasicFilters(notification, filter) && checkNotificationTagFilter(notification.tags, filter.tags) && checkNotificationDataFilter(notification.data, filter.data);
 }
 
-// src/api/http-client.ts
-var DEFAULT_API_VERSION = "v1";
-var DEFAULT_USER_AGENT = `${"@novu/js"}@${"3.11.0"}`;
-var HttpClient = class {
-  constructor(options = {}) {
-    // Environment variable for local development that overrides the default API endpoint without affecting the Inbox DX
-    this.DEFAULT_BACKEND_URL = typeof window !== "undefined" && window.NOVU_LOCAL_BACKEND_URL || "https://api.novu.co";
-    const {
-      apiVersion = DEFAULT_API_VERSION,
-      apiUrl = this.DEFAULT_BACKEND_URL,
-      userAgent = DEFAULT_USER_AGENT,
-      headers = {}
-    } = options || {};
-    this.apiVersion = apiVersion;
-    this.apiUrl = `${apiUrl}/${apiVersion}`;
-    this.headers = __spreadValues({
-      "Novu-API-Version": "2024-06-26",
-      "Content-Type": "application/json",
-      "User-Agent": userAgent
-    }, headers);
-  }
-  setAuthorizationToken(token) {
-    this.headers.Authorization = `Bearer ${token}`;
-  }
-  setKeylessHeader(identifier) {
+// 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;
-    const keylessAppIdentifier = identifier || typeof window !== "undefined" && ((_a = window.localStorage) == null ? void 0 : _a.getItem("novu_keyless_application_identifier"));
-    if (!keylessAppIdentifier || !keylessAppIdentifier.startsWith("pk_keyless_")) {
-      return;
-    }
-    this.headers["Novu-Application-Identifier"] = keylessAppIdentifier;
-  }
-  setHeaders(headers) {
-    this.headers = __spreadValues(__spreadValues({}, this.headers), headers);
+    __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))
+    );
   }
-  get(path, searchParams, unwrapEnvelope = true) {
+  update(args) {
     return __async(this, null, function* () {
-      return this.doFetch({
-        path,
-        searchParams,
-        options: {
-          method: "GET"
-        },
-        unwrapEnvelope
+      return updateSubscription({
+        emitter: __privateGet(this, _emitter),
+        apiService: __privateGet(this, _inboxService),
+        cache: __privateGet(this, _cache),
+        useCache: __privateGet(this, _useCache),
+        args: __spreadProps(__spreadValues({}, args), { subscription: this })
       });
     });
   }
-  post(path, body, options) {
+  updatePreference(args) {
     return __async(this, null, function* () {
-      return this.doFetch({
-        path,
-        options: {
-          method: "POST",
-          body,
-          headers: options == null ? void 0 : options.headers
-        }
+      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 })
       });
     });
   }
-  patch(path, body) {
+  bulkUpdatePreferences(args) {
     return __async(this, null, function* () {
-      return this.doFetch({
-        path,
-        options: {
-          method: "PATCH",
-          body
-        }
+      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(path, body) {
+  delete() {
     return __async(this, null, function* () {
-      return this.doFetch({
-        path,
-        options: {
-          method: "DELETE",
-          body
-        }
-      });
-    });
-  }
-  doFetch(_0) {
-    return __async(this, arguments, function* ({
-      path,
-      searchParams,
-      options,
-      unwrapEnvelope = true
-    }) {
-      const fullUrl = combineUrl(this.apiUrl, path, searchParams ? `?${searchParams.toString()}` : "");
-      const reqInit = {
-        method: (options == null ? void 0 : options.method) || "GET",
-        headers: __spreadValues(__spreadValues({}, this.headers), (options == null ? void 0 : options.headers) || {}),
-        body: (options == null ? void 0 : options.body) ? JSON.stringify(options.body) : void 0
-      };
-      const response = yield fetch(fullUrl, reqInit);
-      if (!response.ok) {
-        const errorData = yield response.json();
-        throw new Error(`${this.headers["User-Agent"]} error. Status: ${response.status}, Message: ${errorData.message}`);
-      }
-      if (response.status === 204) {
-        return void 0;
+      if (__privateGet(this, _isStale)) {
+        return {
+          error: new NovuError("Cannot delete an already deleted subscription", new Error("Subscription is stale"))
+        };
       }
-      const res = yield response.json();
-      return unwrapEnvelope ? res.data : res;
+      return deleteSubscription({
+        emitter: __privateGet(this, _emitter),
+        apiService: __privateGet(this, _inboxService),
+        args: { subscription: this }
+      });
     });
   }
 };
-function combineUrl(...args) {
-  return args.reduce((acc, part) => {
-    if (part) {
-      acc.push(part.replace(new RegExp("(?<!https?:)\\/+", "g"), "/").replace(/^\/+|\/+$/g, ""));
-    }
-    return acc;
-  }, []).join("/").replace(/\/\?/, "?");
-}
+_emitter = new WeakMap();
+_inboxService = new WeakMap();
+_cache = new WeakMap();
+_useCache = new WeakMap();
+_isStale = new WeakMap();
 
-// src/api/inbox-service.ts
-var INBOX_ROUTE = "/inbox";
-var INBOX_NOTIFICATIONS_ROUTE = `${INBOX_ROUTE}/notifications`;
-var _httpClient;
-var InboxService = class {
-  constructor(options = {}) {
-    this.isSessionInitialized = false;
-    __privateAdd(this, _httpClient);
-    __privateSet(this, _httpClient, new HttpClient(options));
-  }
-  initializeSession(_0) {
-    return __async(this, arguments, function* ({
-      applicationIdentifier,
-      subscriberHash,
-      contextHash,
-      subscriber,
-      defaultSchedule,
-      context
-    }) {
-      const response = yield __privateGet(this, _httpClient).post(`${INBOX_ROUTE}/session`, {
-        applicationIdentifier,
-        subscriberHash,
-        contextHash,
-        subscriber,
-        defaultSchedule,
-        context
+// 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);
       });
-      __privateGet(this, _httpClient).setAuthorizationToken(response.token);
-      __privateGet(this, _httpClient).setKeylessHeader(response.applicationIdentifier);
-      this.isSessionInitialized = true;
-      return response;
-    });
-  }
-  fetchNotifications({
-    after,
-    archived,
-    limit = 10,
-    offset,
-    read: read2,
-    tags,
-    snoozed,
-    seen: seen2,
-    data,
-    severity
-  }) {
-    const searchParams = new URLSearchParams(`limit=${limit}`);
-    if (after) {
-      searchParams.append("after", after);
-    }
-    if (offset) {
-      searchParams.append("offset", `${offset}`);
-    }
-    if (tags) {
-      for (const tag of tags) {
-        searchParams.append("tags[]", tag);
+      if (useCache) {
+        cache.set(args, data);
+        data = cache.getAll(args);
       }
     }
-    if (read2 !== void 0) {
-      searchParams.append("read", `${read2}`);
-    }
-    if (archived !== void 0) {
-      searchParams.append("archived", `${archived}`);
-    }
-    if (snoozed !== void 0) {
-      searchParams.append("snoozed", `${snoozed}`);
-    }
-    if (seen2 !== void 0) {
-      searchParams.append("seen", `${seen2}`);
-    }
-    if (data !== void 0) {
-      searchParams.append("data", JSON.stringify(data));
-    }
-    if (severity && Array.isArray(severity)) {
-      for (const el of severity) {
-        searchParams.append("severity[]", el);
+    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);
       }
-    } else if (severity) {
-      searchParams.append("severity", severity);
     }
-    return __privateGet(this, _httpClient).get(INBOX_NOTIFICATIONS_ROUTE, searchParams, false);
+    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) };
   }
-  count({
-    filters
-  }) {
-    return __privateGet(this, _httpClient).get(
-      `${INBOX_NOTIFICATIONS_ROUTE}/count`,
-      new URLSearchParams({
-        filters: JSON.stringify(filters)
-      }),
-      false
+});
+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) };
   }
-  read(notificationId) {
-    return __privateGet(this, _httpClient).patch(`${INBOX_NOTIFICATIONS_ROUTE}/${notificationId}/read`);
-  }
-  unread(notificationId) {
-    return __privateGet(this, _httpClient).patch(`${INBOX_NOTIFICATIONS_ROUTE}/${notificationId}/unread`);
-  }
-  archive(notificationId) {
-    return __privateGet(this, _httpClient).patch(`${INBOX_NOTIFICATIONS_ROUTE}/${notificationId}/archive`);
-  }
-  unarchive(notificationId) {
-    return __privateGet(this, _httpClient).patch(`${INBOX_NOTIFICATIONS_ROUTE}/${notificationId}/unarchive`);
-  }
-  snooze(notificationId, snoozeUntil) {
-    return __privateGet(this, _httpClient).patch(`${INBOX_NOTIFICATIONS_ROUTE}/${notificationId}/snooze`, { snoozeUntil });
-  }
-  unsnooze(notificationId) {
-    return __privateGet(this, _httpClient).patch(`${INBOX_NOTIFICATIONS_ROUTE}/${notificationId}/unsnooze`);
-  }
-  readAll({ tags, data }) {
-    return __privateGet(this, _httpClient).post(`${INBOX_NOTIFICATIONS_ROUTE}/read`, {
-      tags,
-      data: data ? JSON.stringify(data) : void 0
-    });
-  }
-  archiveAll({ tags, data }) {
-    return __privateGet(this, _httpClient).post(`${INBOX_NOTIFICATIONS_ROUTE}/archive`, {
-      tags,
-      data: data ? JSON.stringify(data) : void 0
-    });
-  }
-  archiveAllRead({ tags, data }) {
-    return __privateGet(this, _httpClient).post(`${INBOX_NOTIFICATIONS_ROUTE}/read-archive`, {
-      tags,
-      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,
-    data
-  }) {
-    return __privateGet(this, _httpClient).post(`${INBOX_NOTIFICATIONS_ROUTE}/seen`, {
-      notificationIds,
-      tags,
-      data: data ? JSON.stringify(data) : void 0
-    });
-  }
-  seen(notificationId) {
-    return this.markAsSeen({ notificationIds: [notificationId] });
-  }
-  completeAction({
-    actionType,
-    notificationId
-  }) {
-    return __privateGet(this, _httpClient).patch(`${INBOX_NOTIFICATIONS_ROUTE}/${notificationId}/complete`, {
-      actionType
-    });
-  }
-  revertAction({
-    actionType,
-    notificationId
-  }) {
-    return __privateGet(this, _httpClient).patch(`${INBOX_NOTIFICATIONS_ROUTE}/${notificationId}/revert`, {
-      actionType
-    });
-  }
-  fetchPreferences({
-    tags,
-    severity,
-    criticality
-  }) {
-    const queryParams = new URLSearchParams();
-    if (tags) {
-      for (const tag of tags) {
-        queryParams.append("tags[]", tag);
-      }
-    }
-    if (severity && Array.isArray(severity)) {
-      for (const el of severity) {
-        queryParams.append("severity[]", el);
-      }
-    } else if (severity) {
-      queryParams.append("severity", severity);
-    }
-    if (criticality) {
-      queryParams.append("criticality", criticality);
-    }
-    const query = queryParams.size ? `?${queryParams.toString()}` : "";
-    return __privateGet(this, _httpClient).get(`${INBOX_ROUTE}/preferences${query}`);
-  }
-  bulkUpdatePreferences(preferences) {
-    return __privateGet(this, _httpClient).patch(`${INBOX_ROUTE}/preferences/bulk`, { preferences });
-  }
-  updateGlobalPreferences(preferences) {
-    return __privateGet(this, _httpClient).patch(`${INBOX_ROUTE}/preferences`, preferences);
-  }
-  updateWorkflowPreferences({
-    workflowId,
-    channels
-  }) {
-    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",
-      to: {
-        subscriberId: "keyless-subscriber-id"
-      },
-      payload: {
-        subject: "Novu Keyless Environment",
-        body: "You're using a keyless demo environment. For full access to Novu features and cloud integration, obtain your API key.",
-        primaryActionText: "Obtain API Key",
-        primaryActionUrl: "https://go.novu.co/keyless",
-        secondaryActionText: "Explore Documentation",
-        secondaryActionUrl: "https://go.novu.co/keyless-docs"
-      }
-    };
-    return __privateGet(this, _httpClient).post("/inbox/events", payload);
-  }
-};
-_httpClient = new WeakMap();
-var _mittEmitter;
-var NovuEventEmitter = class {
-  constructor() {
-    __privateAdd(this, _mittEmitter);
-    __privateSet(this, _mittEmitter, mitt());
-  }
-  on(eventName, listener) {
-    __privateGet(this, _mittEmitter).on(eventName, listener);
-    return () => {
-      this.off(eventName, listener);
-    };
-  }
-  off(eventName, listener) {
-    __privateGet(this, _mittEmitter).off(eventName, listener);
-  }
-  emit(type, event) {
-    __privateGet(this, _mittEmitter).emit(type, event);
-  }
-};
-_mittEmitter = new WeakMap();
-
-// src/utils/errors.ts
-var NovuError = class extends Error {
-  constructor(message, originalError) {
-    super(message);
-    this.originalError = originalError;
-  }
-};
-
-// src/notifications/helpers.ts
-var read = (_0) => __async(void 0, [_0], function* ({
-  emitter,
-  apiService,
-  args
-}) {
-  const { notificationId, optimisticValue } = getNotificationDetails(
-    args,
-    {
-      isRead: true,
-      readAt: (/* @__PURE__ */ new Date()).toISOString(),
-      isArchived: false,
-      archivedAt: void 0
-    },
-    {
-      emitter,
-      apiService
-    }
-  );
-  try {
-    emitter.emit("notification.read.pending", {
-      args,
-      data: optimisticValue
-    });
-    const response = yield apiService.read(notificationId);
-    const updatedNotification = new Notification(response, emitter, apiService);
-    emitter.emit("notification.read.resolved", { args, data: updatedNotification });
-    return { data: updatedNotification };
-  } catch (error) {
-    emitter.emit("notification.read.resolved", { args, error });
-    return { error: new NovuError("Failed to read notification", error) };
-  }
-});
-var unread = (_0) => __async(void 0, [_0], function* ({
-  emitter,
-  apiService,
-  args
-}) {
-  const { notificationId, optimisticValue } = getNotificationDetails(
-    args,
-    {
-      isRead: false,
-      readAt: null,
-      isArchived: false,
-      archivedAt: void 0
-    },
-    {
-      emitter,
-      apiService
-    }
-  );
-  try {
-    emitter.emit("notification.unread.pending", {
-      args,
-      data: optimisticValue
-    });
-    const response = yield apiService.unread(notificationId);
-    const updatedNotification = new Notification(response, emitter, apiService);
-    emitter.emit("notification.unread.resolved", { args, data: updatedNotification });
-    return { data: updatedNotification };
-  } catch (error) {
-    emitter.emit("notification.unread.resolved", { args, error });
-    return { error: new NovuError("Failed to unread notification", 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 seen = (_0) => __async(void 0, [_0], function* ({
+var updateSubscriptionPreference = (_0) => __async(void 0, [_0], function* ({
   emitter,
   apiService,
+  cache,
+  useCache,
   args
 }) {
-  const { notificationId, optimisticValue } = getNotificationDetails(
-    args,
-    {
-      isSeen: true
-    },
-    {
-      emitter,
-      apiService
-    }
-  );
+  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("notification.seen.pending", {
+    emitter.emit("subscription.preference.update.pending", {
       args,
-      data: optimisticValue
+      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
     });
-    yield apiService.seen(notificationId);
-    if (!optimisticValue) {
-      throw new Error("Failed to create optimistic value for notification");
-    }
-    const updatedNotification = new Notification(optimisticValue, emitter, apiService);
-    emitter.emit("notification.seen.resolved", { args, data: updatedNotification });
-    return { data: updatedNotification };
+    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("notification.seen.resolved", { args, error });
-    return { error: new NovuError("Failed to mark notification as seen", error) };
+    emitter.emit("subscription.preference.update.resolved", { args, error });
+    return { error: new NovuError("Failed to update subscription", error) };
   }
 });
-var archive = (_0) => __async(void 0, [_0], function* ({
+var bulkUpdateSubscriptionPreference = (_0) => __async(void 0, [_0], function* ({
   emitter,
   apiService,
+  cache,
+  useCache,
   args
 }) {
-  const { notificationId, optimisticValue } = getNotificationDetails(
-    args,
-    {
-      isArchived: true,
-      archivedAt: (/* @__PURE__ */ new Date()).toISOString(),
-      isRead: true,
-      readAt: (/* @__PURE__ */ new Date()).toISOString()
-    },
-    {
-      emitter,
-      apiService
-    }
-  );
   try {
-    emitter.emit("notification.archive.pending", {
+    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: optimisticValue
+      data: optimisticallyUpdatedPreferences
     });
-    const response = yield apiService.archive(notificationId);
-    const updatedNotification = new Notification(response, emitter, apiService);
-    emitter.emit("notification.archive.resolved", { args, data: updatedNotification });
-    return { data: updatedNotification };
-  } catch (error) {
-    emitter.emit("notification.archive.resolved", { args, error });
-    return { error: new NovuError("Failed to archive notification", error) };
-  }
-});
-var unarchive = (_0) => __async(void 0, [_0], function* ({
-  emitter,
-  apiService,
-  args
-}) {
-  const { notificationId, optimisticValue } = getNotificationDetails(
-    args,
-    {
-      isArchived: false,
-      archivedAt: null,
-      isRead: true,
-      readAt: (/* @__PURE__ */ new Date()).toISOString()
-    },
-    {
-      emitter,
-      apiService
-    }
-  );
-  try {
-    emitter.emit("notification.unarchive.pending", {
-      args,
-      data: optimisticValue
+    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.unarchive(notificationId);
-    const updatedNotification = new Notification(response, emitter, apiService);
-    emitter.emit("notification.unarchive.resolved", { args, data: updatedNotification });
-    return { data: updatedNotification };
+    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("notification.unarchive.resolved", { args, error });
-    return { error: new NovuError("Failed to unarchive notification", error) };
+    emitter.emit("subscription.preferences.bulk_update.resolved", { args, error });
+    return { error: new NovuError("Failed to bulk update subscription preferences", error) };
   }
 });
-var snooze = (_0) => __async(void 0, [_0], function* ({
+var deleteSubscription = (_0) => __async(void 0, [_0], function* ({
   emitter,
   apiService,
   args
 }) {
-  const { notificationId, optimisticValue } = getNotificationDetails(
-    args,
-    {
-      isSnoozed: true,
-      snoozedUntil: args.snoozeUntil
-    },
-    {
-      emitter,
-      apiService
-    }
-  );
+  const subscriptionId = "subscriptionId" in args ? args.subscriptionId : args.subscription.id;
+  const topicKey = "topicKey" in args ? args.topicKey : args.subscription.topicKey;
   try {
-    emitter.emit("notification.snooze.pending", {
-      args,
-      data: optimisticValue
-    });
-    const response = yield apiService.snooze(notificationId, args.snoozeUntil);
-    const updatedNotification = new Notification(response, emitter, apiService);
-    emitter.emit("notification.snooze.resolved", { args, data: updatedNotification });
-    return { data: updatedNotification };
+    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("notification.snooze.resolved", { args, error });
-    return { error: new NovuError("Failed to snooze notification", error) };
+    emitter.emit("subscription.delete.resolved", { args, error });
+    return { error: new NovuError("Failed to delete subscription", error) };
   }
 });
-var unsnooze = (_0) => __async(void 0, [_0], function* ({
-  emitter,
-  apiService,
-  args
-}) {
-  const { notificationId, optimisticValue } = getNotificationDetails(
-    args,
-    {
-      isSnoozed: false,
-      snoozedUntil: null
-    },
-    {
-      emitter,
-      apiService
-    }
-  );
-  try {
-    emitter.emit("notification.unsnooze.pending", {
-      args,
-      data: optimisticValue
-    });
-    const response = yield apiService.unsnooze(notificationId);
-    const updatedNotification = new Notification(response, emitter, apiService);
-    emitter.emit("notification.unsnooze.resolved", { args, data: updatedNotification });
-    return { data: updatedNotification };
-  } catch (error) {
-    emitter.emit("notification.unsnooze.resolved", { args, error });
-    return { error: new NovuError("Failed to unsnooze notification", 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;
   }
-});
-var completeAction = (_0) => __async(void 0, [_0], function* ({
-  emitter,
-  apiService,
-  args,
-  actionType
-}) {
-  const optimisticUpdate = actionType === "primary" /* PRIMARY */ ? {
-    primaryAction: __spreadProps(__spreadValues({}, "notification" in args ? args.notification.primaryAction : {}), {
-      isCompleted: true
-    })
-  } : {
-    secondaryAction: __spreadProps(__spreadValues({}, "notification" in args ? args.notification.secondaryAction : {}), {
-      isCompleted: true
-    })
-  };
-  const { notificationId, optimisticValue } = getNotificationDetails(args, optimisticUpdate, {
-    emitter,
-    apiService
-  });
-  try {
-    emitter.emit("notification.complete_action.pending", {
-      args,
-      data: optimisticValue
+  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
+        }
+      });
     });
-    const response = yield apiService.completeAction({ actionType, notificationId });
-    const updatedNotification = new Notification(response, emitter, apiService);
-    emitter.emit("notification.complete_action.resolved", { args, data: updatedNotification });
-    return { data: updatedNotification };
-  } catch (error) {
-    emitter.emit("notification.complete_action.resolved", { args, error });
-    return { error: new NovuError(`Failed to complete ${actionType} action on the notification`, error) };
   }
-});
-var revertAction = (_0) => __async(void 0, [_0], function* ({
-  emitter,
-  apiService,
-  args,
-  actionType
-}) {
-  const optimisticUpdate = actionType === "primary" /* PRIMARY */ ? {
-    primaryAction: __spreadProps(__spreadValues({}, "notification" in args ? args.notification.primaryAction : {}), {
-      isCompleted: false
-    })
-  } : {
-    secondaryAction: __spreadProps(__spreadValues({}, "notification" in args ? args.notification.secondaryAction : {}), {
-      isCompleted: false
-    })
-  };
-  const { notificationId, optimisticValue } = getNotificationDetails(args, optimisticUpdate, {
-    emitter,
-    apiService
-  });
-  try {
-    emitter.emit("notification.revert_action.pending", {
-      args,
-      data: optimisticValue
+};
+_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, []);
+      }
     });
-    const response = yield apiService.revertAction({ actionType, notificationId });
-    const updatedNotification = new Notification(response, emitter, apiService);
-    emitter.emit("notification.revert_action.resolved", { args, data: updatedNotification });
-    return { data: updatedNotification };
-  } catch (error) {
-    emitter.emit("notification.revert_action.resolved", { args, error });
-    return { error: new NovuError("Failed to fetch notifications", error) };
   }
-});
-var getNotificationDetails = (args, update, dependencies) => {
-  if ("notification" in args) {
-    return {
-      notificationId: args.notification.id,
-      optimisticValue: new Notification(
-        __spreadValues(__spreadValues({}, args.notification), update),
-        dependencies.emitter,
-        dependencies.apiService
-      )
-    };
-  } else {
-    return {
-      notificationId: args.notificationId
-    };
+  onSessionSuccess(_) {
   }
-};
-var readAll = (_0) => __async(void 0, [_0], function* ({
-  emitter,
-  inboxService,
-  notificationsCache,
-  tags,
-  data
-}) {
-  try {
-    const notifications = notificationsCache.getUniqueNotifications({ tags, data });
-    const optimisticNotifications = notifications.map(
-      (notification) => new Notification(
-        __spreadProps(__spreadValues({}, notification), {
-          isRead: true,
-          readAt: (/* @__PURE__ */ new Date()).toISOString(),
-          isArchived: false,
-          archivedAt: void 0
-        }),
-        emitter,
-        inboxService
-      )
-    );
-    emitter.emit("notifications.read_all.pending", { args: { tags, data }, data: optimisticNotifications });
-    yield inboxService.readAll({ tags, data });
-    emitter.emit("notifications.read_all.resolved", { args: { tags, data }, data: optimisticNotifications });
-    return {};
-  } catch (error) {
-    emitter.emit("notifications.read_all.resolved", { args: { tags, data }, error });
-    return { error: new NovuError("Failed to read all notifications", error) };
+  onSessionError(_) {
   }
-});
-var seenAll = (_0) => __async(void 0, [_0], function* ({
-  emitter,
-  inboxService,
-  notificationsCache,
-  notificationIds,
-  tags,
-  data
-}) {
-  try {
-    const notifications = notificationsCache.getUniqueNotifications({ tags, data });
-    const filteredNotifications = notificationIds && notificationIds.length > 0 ? notifications.filter((notification) => notificationIds.includes(notification.id)) : notifications;
-    const optimisticNotifications = filteredNotifications.map(
-      (notification) => new Notification(
-        __spreadProps(__spreadValues({}, notification), {
-          isSeen: true,
-          firstSeenAt: notification.firstSeenAt || (/* @__PURE__ */ new Date()).toISOString()
-        }),
-        emitter,
-        inboxService
-      )
-    );
-    emitter.emit("notifications.seen_all.pending", {
-      args: { notificationIds, tags, data },
-      data: optimisticNotifications
-    });
-    yield inboxService.markAsSeen({ notificationIds, tags, data });
-    emitter.emit("notifications.seen_all.resolved", {
-      args: { notificationIds, tags, data },
-      data: optimisticNotifications
+  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 });
+      });
     });
-    return {};
-  } catch (error) {
-    emitter.emit("notifications.seen_all.resolved", { args: { notificationIds, tags, data }, error });
-    return { error: new NovuError("Failed to mark all notifications as seen", error) };
   }
-});
-var archiveAll = (_0) => __async(void 0, [_0], function* ({
-  emitter,
-  inboxService,
-  notificationsCache,
-  tags,
-  data
-}) {
-  try {
-    const notifications = notificationsCache.getUniqueNotifications({ tags, data });
-    const optimisticNotifications = notifications.map(
-      (notification) => new Notification(
-        __spreadProps(__spreadValues({}, notification), {
-          isRead: true,
-          readAt: (/* @__PURE__ */ new Date()).toISOString(),
-          isArchived: true,
-          archivedAt: (/* @__PURE__ */ new Date()).toISOString()
-        }),
-        emitter,
-        inboxService
-      )
-    );
-    emitter.emit("notifications.archive_all.pending", { args: { tags, data }, data: optimisticNotifications });
-    yield inboxService.archiveAll({ tags, data });
-    emitter.emit("notifications.archive_all.resolved", { args: { tags, data }, data: optimisticNotifications });
-    return {};
-  } catch (error) {
-    emitter.emit("notifications.archive_all.resolved", { args: { tags, data }, error });
-    return { error: new NovuError("Failed to archive all notifications", error) };
+};
+_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());
   }
-});
-var archiveAllRead = (_0) => __async(void 0, [_0], function* ({
-  emitter,
-  inboxService,
-  notificationsCache,
-  tags,
-  data
-}) {
-  try {
-    const notifications = notificationsCache.getUniqueNotifications({ tags, data, read: true });
-    const optimisticNotifications = notifications.map(
-      (notification) => new Notification(
-        __spreadProps(__spreadValues({}, notification), { isArchived: true, archivedAt: (/* @__PURE__ */ new Date()).toISOString() }),
-        emitter,
-        inboxService
-      )
-    );
-    emitter.emit("notifications.archive_all_read.pending", { args: { tags, data }, data: optimisticNotifications });
-    yield inboxService.archiveAllRead({ tags, data });
-    emitter.emit("notifications.archive_all_read.resolved", { args: { tags, data }, data: optimisticNotifications });
-    return {};
-  } catch (error) {
-    emitter.emit("notifications.archive_all_read.resolved", { args: { tags, data }, error });
-    return { error: new NovuError("Failed to archive all read notifications", error) };
+  get(key) {
+    return __privateGet(this, _cache3).get(key);
   }
-});
-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) };
+  getValues() {
+    return Array.from(__privateGet(this, _cache3).values());
   }
-});
-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) };
+  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/notifications/notification.ts
-var _emitter, _inboxService;
-var Notification = class {
-  constructor(notification, emitter, inboxService) {
-    __privateAdd(this, _emitter);
-    __privateAdd(this, _inboxService);
-    __privateSet(this, _emitter, emitter);
-    __privateSet(this, _inboxService, inboxService);
-    this.id = notification.id;
-    this.transactionId = notification.transactionId;
-    this.subject = notification.subject;
-    this.body = notification.body;
-    this.to = notification.to;
-    this.isRead = notification.isRead;
-    this.isSeen = notification.isSeen;
-    this.isArchived = notification.isArchived;
-    this.isSnoozed = notification.isSnoozed;
-    this.snoozedUntil = notification.snoozedUntil;
-    this.deliveredAt = notification.deliveredAt;
-    this.createdAt = notification.createdAt;
-    this.readAt = notification.readAt;
-    this.firstSeenAt = notification.firstSeenAt;
-    this.archivedAt = notification.archivedAt;
-    this.avatar = notification.avatar;
-    this.primaryAction = notification.primaryAction;
-    this.secondaryAction = notification.secondaryAction;
-    this.channelType = notification.channelType;
-    this.tags = notification.tags;
-    this.redirect = notification.redirect;
-    this.data = notification.data;
-    this.workflow = notification.workflow;
-    this.severity = notification.severity;
-  }
-  read() {
-    return read({
-      emitter: __privateGet(this, _emitter),
-      apiService: __privateGet(this, _inboxService),
-      args: {
-        notification: this
+// 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);
       }
     });
-  }
-  unread() {
-    return unread({
-      emitter: __privateGet(this, _emitter),
-      apiService: __privateGet(this, _inboxService),
-      args: {
-        notification: this
+    __privateGet(this, _emitter3).on("subscription.update.resolved", ({ data }) => {
+      if (data) {
+        this.handleUpdate(data);
       }
     });
-  }
-  seen() {
-    return seen({
-      emitter: __privateGet(this, _emitter),
-      apiService: __privateGet(this, _inboxService),
-      args: {
-        notification: this
+    __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);
       }
     });
-  }
-  archive() {
-    return archive({
-      emitter: __privateGet(this, _emitter),
-      apiService: __privateGet(this, _inboxService),
-      args: {
-        notification: this
+    __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);
       }
     });
   }
-  unarchive() {
-    return unarchive({
-      emitter: __privateGet(this, _emitter),
-      apiService: __privateGet(this, _inboxService),
-      args: {
-        notification: this
+  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);
   }
-  delete() {
-    return deleteNotification({
-      emitter: __privateGet(this, _emitter),
-      apiService: __privateGet(this, _inboxService),
-      args: {
-        notification: this
+  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.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
+    this.DEFAULT_BACKEND_URL = typeof window !== "undefined" && window.NOVU_LOCAL_BACKEND_URL || "https://api.novu.co";
+    const {
+      apiVersion = DEFAULT_API_VERSION,
+      apiUrl = this.DEFAULT_BACKEND_URL,
+      userAgent = DEFAULT_USER_AGENT,
+      headers = {}
+    } = options || {};
+    this.apiVersion = apiVersion;
+    this.apiUrl = `${apiUrl}/${apiVersion}`;
+    this.headers = __spreadValues({
+      "Novu-API-Version": "2024-06-26",
+      "Content-Type": "application/json",
+      "User-Agent": userAgent
+    }, headers);
+  }
+  setAuthorizationToken(token) {
+    this.headers.Authorization = `Bearer ${token}`;
+  }
+  setKeylessHeader(identifier) {
+    var _a;
+    const keylessAppIdentifier = identifier || typeof window !== "undefined" && ((_a = window.localStorage) == null ? void 0 : _a.getItem("novu_keyless_application_identifier"));
+    if (!keylessAppIdentifier || !keylessAppIdentifier.startsWith("pk_keyless_")) {
+      return;
+    }
+    this.headers["Novu-Application-Identifier"] = keylessAppIdentifier;
+  }
+  setHeaders(headers) {
+    this.headers = __spreadValues(__spreadValues({}, this.headers), headers);
+  }
+  get(path, searchParams, unwrapEnvelope = true) {
+    return __async(this, null, function* () {
+      return this.doFetch({
+        path,
+        searchParams,
+        options: {
+          method: "GET"
+        },
+        unwrapEnvelope
+      });
+    });
+  }
+  post(path, body, options) {
+    return __async(this, null, function* () {
+      return this.doFetch({
+        path,
+        options: {
+          method: "POST",
+          body,
+          headers: options == null ? void 0 : options.headers
+        }
+      });
+    });
+  }
+  patch(path, body) {
+    return __async(this, null, function* () {
+      return this.doFetch({
+        path,
+        options: {
+          method: "PATCH",
+          body
+        }
+      });
+    });
+  }
+  delete(path, body) {
+    return __async(this, null, function* () {
+      return this.doFetch({
+        path,
+        options: {
+          method: "DELETE",
+          body
+        }
+      });
+    });
+  }
+  doFetch(_0) {
+    return __async(this, arguments, function* ({
+      path,
+      searchParams,
+      options,
+      unwrapEnvelope = true
+    }) {
+      const fullUrl = combineUrl(this.apiUrl, path, searchParams ? `?${searchParams.toString()}` : "");
+      const reqInit = {
+        method: (options == null ? void 0 : options.method) || "GET",
+        headers: __spreadValues(__spreadValues({}, this.headers), (options == null ? void 0 : options.headers) || {}),
+        body: (options == null ? void 0 : options.body) ? JSON.stringify(options.body) : void 0
+      };
+      const response = yield fetch(fullUrl, reqInit);
+      if (!response.ok) {
+        const errorData = yield response.json();
+        throw new Error(`${this.headers["User-Agent"]} error. Status: ${response.status}, Message: ${errorData.message}`);
+      }
+      if (response.status === 204) {
+        return void 0;
+      }
+      const res = yield response.json();
+      return unwrapEnvelope ? res.data : res;
+    });
+  }
+};
+function combineUrl(...args) {
+  return args.reduce((acc, part) => {
+    if (part) {
+      acc.push(part.replace(new RegExp("(?<!https?:)\\/+", "g"), "/").replace(/^\/+|\/+$/g, ""));
+    }
+    return acc;
+  }, []).join("/").replace(/\/\?/, "?");
+}
+
+// src/api/inbox-service.ts
+var INBOX_ROUTE = "/inbox";
+var INBOX_NOTIFICATIONS_ROUTE = `${INBOX_ROUTE}/notifications`;
+var _httpClient;
+var InboxService = class {
+  constructor(options = {}) {
+    this.isSessionInitialized = false;
+    __privateAdd(this, _httpClient);
+    __privateSet(this, _httpClient, new HttpClient(options));
+  }
+  initializeSession(_0) {
+    return __async(this, arguments, function* ({
+      applicationIdentifier,
+      subscriberHash,
+      contextHash,
+      subscriber,
+      defaultSchedule,
+      context
+    }) {
+      const response = yield __privateGet(this, _httpClient).post(`${INBOX_ROUTE}/session`, {
+        applicationIdentifier,
+        subscriberHash,
+        contextHash,
+        subscriber,
+        defaultSchedule,
+        context
+      });
+      __privateGet(this, _httpClient).setAuthorizationToken(response.token);
+      __privateGet(this, _httpClient).setKeylessHeader(response.applicationIdentifier);
+      this.isSessionInitialized = true;
+      return response;
+    });
+  }
+  fetchNotifications({
+    after,
+    archived,
+    limit = 10,
+    offset,
+    read: read2,
+    tags,
+    snoozed,
+    seen: seen2,
+    data,
+    severity
+  }) {
+    const searchParams = new URLSearchParams(`limit=${limit}`);
+    if (after) {
+      searchParams.append("after", after);
+    }
+    if (offset) {
+      searchParams.append("offset", `${offset}`);
+    }
+    if (tags) {
+      for (const tag of tags) {
+        searchParams.append("tags[]", tag);
+      }
+    }
+    if (read2 !== void 0) {
+      searchParams.append("read", `${read2}`);
+    }
+    if (archived !== void 0) {
+      searchParams.append("archived", `${archived}`);
+    }
+    if (snoozed !== void 0) {
+      searchParams.append("snoozed", `${snoozed}`);
+    }
+    if (seen2 !== void 0) {
+      searchParams.append("seen", `${seen2}`);
+    }
+    if (data !== void 0) {
+      searchParams.append("data", JSON.stringify(data));
+    }
+    if (severity && Array.isArray(severity)) {
+      for (const el of severity) {
+        searchParams.append("severity[]", el);
+      }
+    } else if (severity) {
+      searchParams.append("severity", severity);
+    }
+    return __privateGet(this, _httpClient).get(INBOX_NOTIFICATIONS_ROUTE, searchParams, false);
+  }
+  count({
+    filters
+  }) {
+    return __privateGet(this, _httpClient).get(
+      `${INBOX_NOTIFICATIONS_ROUTE}/count`,
+      new URLSearchParams({
+        filters: JSON.stringify(filters)
+      }),
+      false
+    );
+  }
+  read(notificationId) {
+    return __privateGet(this, _httpClient).patch(`${INBOX_NOTIFICATIONS_ROUTE}/${notificationId}/read`);
+  }
+  unread(notificationId) {
+    return __privateGet(this, _httpClient).patch(`${INBOX_NOTIFICATIONS_ROUTE}/${notificationId}/unread`);
+  }
+  archive(notificationId) {
+    return __privateGet(this, _httpClient).patch(`${INBOX_NOTIFICATIONS_ROUTE}/${notificationId}/archive`);
+  }
+  unarchive(notificationId) {
+    return __privateGet(this, _httpClient).patch(`${INBOX_NOTIFICATIONS_ROUTE}/${notificationId}/unarchive`);
+  }
+  snooze(notificationId, snoozeUntil) {
+    return __privateGet(this, _httpClient).patch(`${INBOX_NOTIFICATIONS_ROUTE}/${notificationId}/snooze`, { snoozeUntil });
+  }
+  unsnooze(notificationId) {
+    return __privateGet(this, _httpClient).patch(`${INBOX_NOTIFICATIONS_ROUTE}/${notificationId}/unsnooze`);
+  }
+  readAll({ tags, data }) {
+    return __privateGet(this, _httpClient).post(`${INBOX_NOTIFICATIONS_ROUTE}/read`, {
+      tags,
+      data: data ? JSON.stringify(data) : void 0
+    });
+  }
+  archiveAll({ tags, data }) {
+    return __privateGet(this, _httpClient).post(`${INBOX_NOTIFICATIONS_ROUTE}/archive`, {
+      tags,
+      data: data ? JSON.stringify(data) : void 0
+    });
+  }
+  archiveAllRead({ tags, data }) {
+    return __privateGet(this, _httpClient).post(`${INBOX_NOTIFICATIONS_ROUTE}/read-archive`, {
+      tags,
+      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,
+    data
+  }) {
+    return __privateGet(this, _httpClient).post(`${INBOX_NOTIFICATIONS_ROUTE}/seen`, {
+      notificationIds,
+      tags,
+      data: data ? JSON.stringify(data) : void 0
+    });
+  }
+  seen(notificationId) {
+    return this.markAsSeen({ notificationIds: [notificationId] });
+  }
+  completeAction({
+    actionType,
+    notificationId
+  }) {
+    return __privateGet(this, _httpClient).patch(`${INBOX_NOTIFICATIONS_ROUTE}/${notificationId}/complete`, {
+      actionType
+    });
+  }
+  revertAction({
+    actionType,
+    notificationId
+  }) {
+    return __privateGet(this, _httpClient).patch(`${INBOX_NOTIFICATIONS_ROUTE}/${notificationId}/revert`, {
+      actionType
+    });
+  }
+  fetchPreferences({
+    tags,
+    severity,
+    criticality
+  }) {
+    const queryParams = new URLSearchParams();
+    if (tags) {
+      for (const tag of tags) {
+        queryParams.append("tags[]", tag);
       }
-    });
-  }
-  snooze(snoozeUntil) {
-    return snooze({
-      emitter: __privateGet(this, _emitter),
-      apiService: __privateGet(this, _inboxService),
-      args: {
-        notification: this,
-        snoozeUntil
+    }
+    if (severity && Array.isArray(severity)) {
+      for (const el of severity) {
+        queryParams.append("severity[]", el);
       }
-    });
+    } else if (severity) {
+      queryParams.append("severity", severity);
+    }
+    if (criticality) {
+      queryParams.append("criticality", criticality);
+    }
+    const query = queryParams.size ? `?${queryParams.toString()}` : "";
+    return __privateGet(this, _httpClient).get(`${INBOX_ROUTE}/preferences${query}`);
   }
-  unsnooze() {
-    return unsnooze({
-      emitter: __privateGet(this, _emitter),
-      apiService: __privateGet(this, _inboxService),
-      args: { notification: this }
-    });
+  bulkUpdatePreferences(preferences) {
+    return __privateGet(this, _httpClient).patch(`${INBOX_ROUTE}/preferences/bulk`, { preferences });
   }
-  completePrimary() {
-    if (!this.primaryAction) {
-      throw new Error("Primary action is not available");
-    }
-    return completeAction({
-      emitter: __privateGet(this, _emitter),
-      apiService: __privateGet(this, _inboxService),
-      args: {
-        notification: this
-      },
-      actionType: "primary" /* PRIMARY */
-    });
+  updateGlobalPreferences(preferences) {
+    return __privateGet(this, _httpClient).patch(`${INBOX_ROUTE}/preferences`, preferences);
   }
-  completeSecondary() {
-    if (!this.primaryAction) {
-      throw new Error("Secondary action is not available");
-    }
-    return completeAction({
-      emitter: __privateGet(this, _emitter),
-      apiService: __privateGet(this, _inboxService),
-      args: {
-        notification: this
-      },
-      actionType: "secondary" /* SECONDARY */
-    });
+  updateWorkflowPreferences({
+    workflowId,
+    channels
+  }) {
+    return __privateGet(this, _httpClient).patch(`${INBOX_ROUTE}/preferences/${workflowId}`, channels);
   }
-  revertPrimary() {
-    if (!this.primaryAction) {
-      throw new Error("Primary action is not available");
-    }
-    return revertAction({
-      emitter: __privateGet(this, _emitter),
-      apiService: __privateGet(this, _inboxService),
-      args: {
-        notification: this
-      },
-      actionType: "primary" /* PRIMARY */
-    });
+  fetchGlobalPreferences() {
+    return __privateGet(this, _httpClient).get(`${INBOX_ROUTE}/preferences/global`);
   }
-  revertSecondary() {
-    if (!this.primaryAction) {
-      throw new Error("Secondary action is not available");
-    }
-    return revertAction({
-      emitter: __privateGet(this, _emitter),
-      apiService: __privateGet(this, _inboxService),
-      args: {
-        notification: this
+  triggerHelloWorldEvent() {
+    const payload = {
+      name: "hello-world",
+      to: {
+        subscriberId: "keyless-subscriber-id"
       },
-      actionType: "secondary" /* SECONDARY */
-    });
-  }
-  on(eventName, listener) {
-    const cleanup = __privateGet(this, _emitter).on(eventName, listener);
-    return () => {
-      cleanup();
+      payload: {
+        subject: "Novu Keyless Environment",
+        body: "You're using a keyless demo environment. For full access to Novu features and cloud integration, obtain your API key.",
+        primaryActionText: "Obtain API Key",
+        primaryActionUrl: "https://go.novu.co/keyless",
+        secondaryActionText: "Explore Documentation",
+        secondaryActionUrl: "https://go.novu.co/keyless-docs"
+      }
     };
+    return __privateGet(this, _httpClient).post("/inbox/events", payload);
   }
-  /**
-   * @deprecated
-   * Use the cleanup function returned by the "on" method instead.
-   */
-  off(eventName, listener) {
-    __privateGet(this, _emitter).off(eventName, listener);
+  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 }));
   }
-};
-_emitter = new WeakMap();
-_inboxService = new WeakMap();
-
-// src/base-module.ts
-var _callsQueue, _sessionError;
-var BaseModule = class {
-  constructor({
-    inboxServiceInstance,
-    eventEmitterInstance
+  updateSubscriptionPreference({
+    subscriptionId,
+    workflowId,
+    enabled,
+    condition,
+    email,
+    sms,
+    in_app,
+    chat,
+    push
   }) {
-    __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, []);
-      }
+    return __privateGet(this, _httpClient).patch(`${INBOX_ROUTE}/subscriptions/${subscriptionId}/preferences/${workflowId}`, {
+      enabled,
+      condition,
+      email,
+      sms,
+      in_app,
+      chat,
+      push
     });
   }
-  onSessionSuccess(_) {
-  }
-  onSessionError(_) {
+  bulkUpdateSubscriptionPreferences(preferences) {
+    return __privateGet(this, _httpClient).patch(`${INBOX_ROUTE}/preferences/bulk`, { preferences });
   }
-  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 });
-      });
-    });
+  deleteSubscription({ topicKey, subscriptionId }) {
+    return __privateGet(this, _httpClient).delete(`${INBOX_ROUTE}/topics/${topicKey}/subscriptions/${subscriptionId}`);
   }
 };
-_callsQueue = new WeakMap();
-_sessionError = new WeakMap();
-
-// src/cache/in-memory-cache.ts
-var _cache;
-var InMemoryCache = class {
+_httpClient = new WeakMap();
+var _mittEmitter;
+var NovuEventEmitter = 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());
+    __privateAdd(this, _mittEmitter);
+    __privateSet(this, _mittEmitter, mitt());
   }
-  set(key, value) {
-    __privateGet(this, _cache).set(key, value);
+  on(eventName, listener) {
+    __privateGet(this, _mittEmitter).on(eventName, listener);
+    return () => {
+      this.off(eventName, listener);
+    };
   }
-  remove(key) {
-    __privateGet(this, _cache).delete(key);
+  off(eventName, listener) {
+    __privateGet(this, _mittEmitter).off(eventName, listener);
   }
-  clear() {
-    __privateGet(this, _cache).clear();
+  emit(type, event) {
+    __privateGet(this, _mittEmitter).emit(type, event);
   }
 };
-_cache = new WeakMap();
+_mittEmitter = new WeakMap();
 
 // src/cache/notifications-cache.ts
 var excludeEmpty = ({
@@ -1298,16 +1354,17 @@ var removeEvents = [
   "notifications.archive_all_read.pending",
   "notifications.delete_all.pending"
 ];
-var _emitter2, _cache2;
+var _emitter4, _inboxService4, _cache5;
 var NotificationsCache = class {
-  constructor({ emitter }) {
-    __privateAdd(this, _emitter2);
+  constructor({ emitter, 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;
       }
@@ -1317,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;
       }
@@ -1331,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;
@@ -1350,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) {
@@ -1366,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) {
@@ -1381,26 +1438,27 @@ var NotificationsCache = class {
       });
       uniqueFilterKeys.forEach((key) => {
         const notificationsResponse = this.getAggregated(getFilter(key));
-        __privateGet(this, _emitter2).emit("notifications.list.updated", {
+        __privateGet(this, _emitter4).emit("notifications.list.updated", {
           data: notificationsResponse
         });
       });
     };
-    __privateSet(this, _emitter2, emitter);
+    __privateSet(this, _emitter4, emitter);
+    __privateSet(this, _inboxService4, inboxService);
     updateEvents.forEach((event) => {
-      __privateGet(this, _emitter2).on(event, this.handleNotificationEvent());
+      __privateGet(this, _emitter4).on(event, this.handleNotificationEvent());
     });
     removeEvents.forEach((event) => {
-      __privateGet(this, _emitter2).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;
@@ -1414,16 +1472,35 @@ var NotificationsCache = class {
       { hasMore: false, filter: {}, notifications: [] }
     );
   }
+  get(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, _cache5).get(cacheKey) || {
+      hasMore: false,
+      filter: getFilter(cacheKey),
+      notifications: []
+    };
+    const notificationInstance = createNotification({
+      notification: __spreadValues({}, notification),
+      emitter: __privateGet(this, _emitter4),
+      inboxService: __privateGet(this, _inboxService4)
+    });
+    this.update(args, __spreadProps(__spreadValues({}, cachedData), {
+      notifications: [notificationInstance, ...cachedData.notifications]
+    }));
   }
   update(args, data) {
     this.set(args, data);
     const notificationsResponse = this.getAggregated(getFilter(getCacheKey(args)));
-    __privateGet(this, _emitter2).emit("notifications.list.updated", {
+    __privateGet(this, _emitter4).emit("notifications.list.updated", {
       data: notificationsResponse
     });
   }
@@ -1449,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;
         }
@@ -1466,22 +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();
   }
 };
-_emitter2 = 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,
@@ -1492,14 +1570,12 @@ var Notifications = class extends BaseModule {
       eventEmitterInstance,
       inboxServiceInstance
     });
-    __privateAdd(this, _useCache);
+    __privateAdd(this, _useCache5);
     this.cache = new NotificationsCache({
-      emitter: eventEmitterInstance
+      emitter: eventEmitterInstance,
+      inboxService: inboxServiceInstance
     });
-    __privateSet(this, _useCache, useCache);
-  }
-  get inboxService() {
-    return this._inboxService;
+    __privateSet(this, _useCache5, useCache);
   }
   list() {
     return __async(this, arguments, function* (_a = {}) {
@@ -1507,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) {
@@ -1819,10 +1895,10 @@ var Notifications = class extends BaseModule {
     });
   }
 };
-_useCache = new WeakMap();
+_useCache5 = new WeakMap();
 
 // src/preferences/schedule.ts
-var _emitter3, _apiService, _cache3, _useCache2;
+var _emitter5, _apiService, _cache6, _useCache6;
 var Schedule = class {
   constructor(schedule, {
     emitterInstance,
@@ -1830,14 +1906,14 @@ var Schedule = class {
     cache,
     useCache
   }) {
-    __privateAdd(this, _emitter3);
+    __privateAdd(this, _emitter5);
     __privateAdd(this, _apiService);
-    __privateAdd(this, _cache3);
-    __privateAdd(this, _useCache2);
-    __privateSet(this, _emitter3, 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;
   }
@@ -1846,10 +1922,10 @@ var Schedule = class {
       var _a;
       const hasWeeklySchedule = !!args.weeklySchedule || !!this.weeklySchedule;
       return updateSchedule({
-        emitter: __privateGet(this, _emitter3),
+        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 && {
@@ -1859,13 +1935,13 @@ var Schedule = class {
     });
   }
 };
-_emitter3 = 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 _emitter4, _apiService2, _cache4, _scheduleCache, _useCache3;
+var _emitter6, _apiService2, _cache7, _scheduleCache, _useCache7;
 var Preference = class {
   constructor(preference, {
     emitterInstance,
@@ -1874,16 +1950,16 @@ var Preference = class {
     scheduleCache,
     useCache
   }) {
-    __privateAdd(this, _emitter4);
+    __privateAdd(this, _emitter6);
     __privateAdd(this, _apiService2);
-    __privateAdd(this, _cache4);
+    __privateAdd(this, _cache7);
     __privateAdd(this, _scheduleCache);
-    __privateAdd(this, _useCache3);
-    __privateSet(this, _emitter4, 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;
@@ -1899,11 +1975,11 @@ var Preference = class {
   }) {
     var _a;
     return updatePreference({
-      emitter: __privateGet(this, _emitter4),
+      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,
@@ -1912,11 +1988,11 @@ var Preference = class {
     });
   }
 };
-_emitter4 = 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* ({
@@ -2113,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,
@@ -2125,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();
@@ -2147,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();
             }
@@ -2174,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 = [
@@ -2204,13 +2280,13 @@ var excludeEmpty2 = ({ tags, severity }) => Object.entries({ tags, severity }).r
 var getCacheKey2 = ({ tags, severity }) => {
   return JSON.stringify(excludeEmpty2({ tags, severity }));
 };
-var _emitter5, _cache5;
+var _emitter7, _cache8;
 var PreferencesCache = class {
   constructor({ emitterInstance }) {
-    __privateAdd(this, _emitter5);
-    __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;
       }
@@ -2225,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;
       }
@@ -2239,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 }) => {
@@ -2247,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, _emitter5).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 : []
         });
       }
     };
@@ -2269,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;
           }
@@ -2281,37 +2357,37 @@ var PreferencesCache = class {
       });
       uniqueFilterKeys.forEach((key) => {
         var _a;
-        __privateGet(this, _emitter5).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, _emitter5, emitterInstance);
+    __privateSet(this, _emitter7, emitterInstance);
     for (const event of updateEvents2) {
-      __privateGet(this, _emitter5).on(event, this.handlePreferenceEvent);
+      __privateGet(this, _emitter7).on(event, this.handlePreferenceEvent);
     }
     for (const event of scheduleUpdateEvents) {
-      __privateGet(this, _emitter5).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();
   }
 };
-_emitter5 = new WeakMap();
-_cache5 = new WeakMap();
+_emitter7 = new WeakMap();
+_cache8 = new WeakMap();
 
 // src/cache/schedule-cache.ts
 var updateEvents3 = [
@@ -2321,17 +2397,17 @@ var updateEvents3 = [
 var getCacheKey3 = () => {
   return "schedule";
 };
-var _emitter6, _cache6;
+var _emitter8, _cache9;
 var ScheduleCache = class {
   constructor({ emitterInstance }) {
-    __privateAdd(this, _emitter6);
-    __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 }) => {
@@ -2339,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, _emitter6).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, _emitter6, emitterInstance);
+    __privateSet(this, _emitter8, emitterInstance);
     for (const event of updateEvents3) {
-      __privateGet(this, _emitter6).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();
   }
 };
-_emitter6 = 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,
@@ -2390,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,
@@ -2410,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({
@@ -2424,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);
             }
@@ -2449,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
         })
       );
@@ -2463,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() {
@@ -2478,14 +2554,14 @@ function isBrowser() {
 }
 
 // src/session/session.ts
-var _emitter7, _inboxService2, _options;
+var _emitter9, _inboxService5, _options;
 var Session = class {
   constructor(options, inboxServiceInstance, eventEmitterInstance) {
-    __privateAdd(this, _emitter7);
-    __privateAdd(this, _inboxService2);
+    __privateAdd(this, _emitter9);
+    __privateAdd(this, _inboxService5);
     __privateAdd(this, _options);
-    __privateSet(this, _emitter7, eventEmitterInstance);
-    __privateSet(this, _inboxService2, inboxServiceInstance);
+    __privateSet(this, _emitter9, eventEmitterInstance);
+    __privateSet(this, _inboxService5, inboxServiceInstance);
     __privateSet(this, _options, options);
   }
   get applicationIdentifier() {
@@ -2556,8 +2632,8 @@ var Session = class {
         } else {
           this.handleApplicationIdentifier("delete");
         }
-        __privateGet(this, _emitter7).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,
@@ -2574,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, _emitter7).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, _emitter7).emit("session.initialize.resolved", { args: __privateGet(this, _options), error });
+        __privateGet(this, _emitter9).emit("session.initialize.resolved", { args: __privateGet(this, _options), error });
       }
     });
   }
 };
-_emitter7 = 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";
@@ -2675,7 +2751,7 @@ var mapToNotification = ({
     severity
   });
 };
-var _token, _emitter8, _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,
@@ -2688,15 +2764,15 @@ var PartySocketClient = class extends BaseModule {
     });
     __privateAdd(this, _PartySocketClient_instances);
     __privateAdd(this, _token);
-    __privateAdd(this, _emitter8);
+    __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, _emitter8).emit(NOTIFICATION_RECEIVED, {
-            result: new Notification(mapToNotification(data.data.message), __privateGet(this, _emitter8), this._inboxService)
+          __privateGet(this, _emitter10).emit(NOTIFICATION_RECEIVED, {
+            result: new Notification(mapToNotification(data.data.message), __privateGet(this, _emitter10), this._inboxService)
           });
         }
       } catch (error) {
@@ -2707,7 +2783,7 @@ var PartySocketClient = class extends BaseModule {
       try {
         const data = JSON.parse(event.data);
         if (data.event === "unseen_count_changed" /* UNSEEN */) {
-          __privateGet(this, _emitter8).emit(UNSEEN_COUNT_CHANGED, {
+          __privateGet(this, _emitter10).emit(UNSEEN_COUNT_CHANGED, {
             result: data.data.unseenCount
           });
         }
@@ -2718,7 +2794,7 @@ var PartySocketClient = class extends BaseModule {
       try {
         const data = JSON.parse(event.data);
         if (data.event === "unread_count_changed" /* UNREAD */) {
-          __privateGet(this, _emitter8).emit(UNREAD_COUNT_CHANGED, {
+          __privateGet(this, _emitter10).emit(UNREAD_COUNT_CHANGED, {
             result: data.data.counts
           });
         }
@@ -2743,7 +2819,7 @@ var PartySocketClient = class extends BaseModule {
       } catch (error) {
       }
     });
-    __privateSet(this, _emitter8, eventEmitterInstance);
+    __privateSet(this, _emitter10, eventEmitterInstance);
     __privateSet(this, _socketUrl, socketUrl != null ? socketUrl : PRODUCTION_SOCKET_URL);
   }
   onSessionSuccess({ token }) {
@@ -2770,7 +2846,7 @@ var PartySocketClient = class extends BaseModule {
   }
 };
 _token = new WeakMap();
-_emitter8 = new WeakMap();
+_emitter10 = new WeakMap();
 _partySocket = new WeakMap();
 _socketUrl = new WeakMap();
 _notificationReceived = new WeakMap();
@@ -2784,15 +2860,15 @@ initializeSocket_fn = function() {
       return;
     }
     const args = { socketUrl: __privateGet(this, _socketUrl) };
-    __privateGet(this, _emitter8).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, _emitter8).emit("socket.connect.resolved", { args });
+      __privateGet(this, _emitter10).emit("socket.connect.resolved", { args });
     });
     __privateGet(this, _partySocket).addEventListener("error", (error) => {
-      __privateGet(this, _emitter8).emit("socket.connect.resolved", { args, error });
+      __privateGet(this, _emitter10).emit("socket.connect.resolved", { args, error });
     });
     __privateGet(this, _partySocket).addEventListener("message", __privateGet(this, _handleMessage));
   });
@@ -2910,7 +2986,7 @@ var mapToNotification2 = ({
     severity
   });
 };
-var _token2, _emitter9, _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,
@@ -2923,25 +2999,25 @@ var Socket = class extends BaseModule {
     });
     __privateAdd(this, _Socket_instances);
     __privateAdd(this, _token2);
-    __privateAdd(this, _emitter9);
+    __privateAdd(this, _emitter11);
     __privateAdd(this, _socketIo);
     __privateAdd(this, _socketUrl2);
     __privateAdd(this, _notificationReceived2, ({ message }) => {
-      __privateGet(this, _emitter9).emit(NOTIFICATION_RECEIVED2, {
-        result: new Notification(mapToNotification2(message), __privateGet(this, _emitter9), this._inboxService)
+      __privateGet(this, _emitter11).emit(NOTIFICATION_RECEIVED2, {
+        result: new Notification(mapToNotification2(message), __privateGet(this, _emitter11), this._inboxService)
       });
     });
     __privateAdd(this, _unseenCountChanged2, ({ unseenCount }) => {
-      __privateGet(this, _emitter9).emit(UNSEEN_COUNT_CHANGED2, {
+      __privateGet(this, _emitter11).emit(UNSEEN_COUNT_CHANGED2, {
         result: unseenCount
       });
     });
     __privateAdd(this, _unreadCountChanged2, ({ counts }) => {
-      __privateGet(this, _emitter9).emit(UNREAD_COUNT_CHANGED2, {
+      __privateGet(this, _emitter11).emit(UNREAD_COUNT_CHANGED2, {
         result: counts
       });
     });
-    __privateSet(this, _emitter9, eventEmitterInstance);
+    __privateSet(this, _emitter11, eventEmitterInstance);
     __privateSet(this, _socketUrl2, socketUrl != null ? socketUrl : PRODUCTION_SOCKET_URL2);
   }
   onSessionSuccess({ token }) {
@@ -2968,7 +3044,7 @@ var Socket = class extends BaseModule {
   }
 };
 _token2 = new WeakMap();
-_emitter9 = new WeakMap();
+_emitter11 = new WeakMap();
 _socketIo = new WeakMap();
 _socketUrl2 = new WeakMap();
 _notificationReceived2 = new WeakMap();
@@ -2982,7 +3058,7 @@ initializeSocket_fn2 = function() {
       return;
     }
     const args = { socketUrl: __privateGet(this, _socketUrl2) };
-    __privateGet(this, _emitter9).emit("socket.connect.pending", { args });
+    __privateGet(this, _emitter11).emit("socket.connect.pending", { args });
     __privateSet(this, _socketIo, io(__privateGet(this, _socketUrl2), {
       reconnectionDelayMax: 1e4,
       transports: ["websocket"],
@@ -2991,10 +3067,10 @@ initializeSocket_fn2 = function() {
       }
     }));
     __privateGet(this, _socketIo).on("connect", () => {
-      __privateGet(this, _emitter9).emit("socket.connect.resolved", { args });
+      __privateGet(this, _emitter11).emit("socket.connect.resolved", { args });
     });
     __privateGet(this, _socketIo).on("connect_error", (error) => {
-      __privateGet(this, _emitter9).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));
@@ -3068,57 +3144,66 @@ function createSocket({
 }
 
 // src/novu.ts
-var _emitter10, _session, _inboxService3;
+var _emitter12, _session, _inboxService6, _options2;
 var Novu = class {
   constructor(options) {
-    __privateAdd(this, _emitter10);
+    __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, _emitter10, 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, _emitter10)
+      __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, _emitter10)
+      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, _emitter10)
+      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, _emitter10),
-      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, _emitter10).on(eventName, listener);
+      const cleanup = __privateGet(this, _emitter12).on(eventName, listener);
       return () => {
         cleanup();
       };
     };
     this.off = (eventName, listener) => {
-      __privateGet(this, _emitter10).off(eventName, listener);
+      __privateGet(this, _emitter12).off(eventName, listener);
     };
   }
   get applicationIdentifier() {
@@ -3130,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({
@@ -3143,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;
@@ -3164,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();
@@ -3172,8 +3272,9 @@ var Novu = class {
     });
   }
 };
-_emitter10 = new WeakMap();
+_emitter12 = new WeakMap();
 _session = new WeakMap();
-_inboxService3 = new WeakMap();
+_inboxService6 = new WeakMap();
+_options2 = new WeakMap();
 
-export { ChannelType, DEFAULT_API_VERSION, NotificationStatus, Novu, PreferenceLevel, SeverityLevelEnum, WebSocketEvent, WorkflowCriticalityEnum, areSeveritiesEqual, areTagsEqual, checkNotificationDataFilter, checkNotificationMatchesFilter, checkNotificationTagFilter, isBrowser, isSameFilter };
+export { DEFAULT_API_VERSION, Novu, SubscriptionPreference, TopicSubscription, areSeveritiesEqual, areTagsEqual, checkNotificationDataFilter, checkNotificationMatchesFilter, checkNotificationTagFilter, isBrowser, isSameFilter };