@codingfactory/notify-kit-client 0.1.0 → 0.2.0

package/dist/index.js

@@ -1,6 +1,24 @@
 import { useNotifyKitStore } from './chunk-7LQBNDRD.js';
 export { InvalidSnoozeDurationError, NOTIFY_KIT_MODALS_KEY, NOTIFY_KIT_STORE_KEY, provideNotifyKitModals, provideNotifyKitStore, resetNotifyKitStore, useNotifyKitModals, useNotifyKitStore } from './chunk-7LQBNDRD.js';
-import { provide, inject, ref, computed, onMounted, onUnmounted, watch } from 'vue';
+import { provide, inject, computed, ref, onMounted, onUnmounted, watch, reactive, readonly } from 'vue';
+
+// src/types/modal.ts
+function isModalSpec(value) {
+  if (typeof value !== "object" || value === null) {
+    return false;
+  }
+  const obj = value;
+  if (typeof obj["enabled"] !== "boolean") return false;
+  if (typeof obj["requires_ack"] !== "boolean") return false;
+  if (!Array.isArray(obj["snooze_options_minutes"])) return false;
+  const snoozeOptions = obj["snooze_options_minutes"];
+  for (const option of snoozeOptions) {
+    if (typeof option !== "number" || !Number.isInteger(option) || option < 1) {
+      return false;
+    }
+  }
+  return true;
+}
 
 // src/types/notification.ts
 var NOTIFICATION_CATEGORIES = [
@@ -46,38 +64,49 @@ function isNotifyKitNotification(value) {
       return false;
     }
   }
-  if (obj["modal"] !== null && typeof obj["modal"] !== "object") return false;
+  if (obj["modal"] !== null && !isModalSpec(obj["modal"])) return false;
   return true;
 }
 function isModalEnabled(notification) {
   return notification.modal?.enabled ?? false;
 }
 
-// src/types/modal.ts
-function isModalSpec(value) {
+// src/types/preferences.ts
+function isBooleanRecord(value) {
   if (typeof value !== "object" || value === null) {
     return false;
   }
-  const obj = value;
-  if (typeof obj["enabled"] !== "boolean") return false;
-  if (typeof obj["requires_ack"] !== "boolean") return false;
-  if (!Array.isArray(obj["snooze_options_minutes"])) return false;
-  const snoozeOptions = obj["snooze_options_minutes"];
-  for (const option of snoozeOptions) {
-    if (typeof option !== "number" || !Number.isInteger(option) || option < 1) {
-      return false;
-    }
+  return Object.values(value).every((entry) => typeof entry === "boolean");
+}
+function isStringRecord(value) {
+  if (typeof value !== "object" || value === null) {
+    return false;
   }
-  return true;
+  return Object.values(value).every((entry) => typeof entry === "string");
 }
-
-// src/types/preferences.ts
-function isChannelPreferences(value) {
+function isStringArray(value) {
+  return Array.isArray(value) && value.every((entry) => typeof entry === "string");
+}
+function isNotifyKitQuietHours(value) {
+  if (typeof value !== "object" || value === null) {
+    return false;
+  }
+  const obj = value;
+  return typeof obj["start"] === "string" && typeof obj["end"] === "string";
+}
+function isNotifyKitPreferenceSettings(value) {
   if (typeof value !== "object" || value === null) {
     return false;
   }
   const obj = value;
-  return typeof obj["database"] === "boolean" && typeof obj["broadcast"] === "boolean" && typeof obj["mail"] === "boolean";
+  const digest = obj["digest"];
+  if (typeof digest !== "object" || digest === null) {
+    return false;
+  }
+  const digestRecord = digest;
+  const quietHours = digestRecord["quiet_hours"];
+  const categories = digestRecord["categories"];
+  return isBooleanRecord(obj["channels"]) && isStringRecord(obj["channel_modes"]) && isBooleanRecord(obj["topics"]) && isBooleanRecord(obj["email_preferences"]) && isStringArray(obj["keyword_rules"]) && typeof digestRecord["enabled"] === "boolean" && (digestRecord["frequency"] === "daily" || digestRecord["frequency"] === "weekly") && (categories === null || isStringArray(categories)) && (digestRecord["workspace_id"] === null || typeof digestRecord["workspace_id"] === "string") && (digestRecord["timezone"] === null || typeof digestRecord["timezone"] === "string") && typeof digestRecord["hour"] === "number" && (quietHours === null || isNotifyKitQuietHours(quietHours)) && isStringArray(obj["available_channels"]) && isStringArray(obj["available_topics"]) && isStringArray(obj["available_email_preferences"]);
 }
 
 // src/types/api.ts
@@ -103,12 +132,146 @@ function isUnreadCountResponse(value) {
   return typeof obj["count"] === "number";
 }
 
+// src/client/normalizeNotification.ts
+var RESERVED_PAYLOAD_KEYS = /* @__PURE__ */ new Set([
+  "id",
+  "key",
+  "category",
+  "level",
+  "title",
+  "body",
+  "action_url",
+  "workspace_id",
+  "modal",
+  "group_key",
+  "idempotency_key",
+  "read_at",
+  "created_at",
+  "data"
+]);
+function isRecord(value) {
+  return typeof value === "object" && value !== null;
+}
+function nullableString(value) {
+  return typeof value === "string" && value.trim() !== "" ? value : null;
+}
+function stringOrFallback(value, fallback) {
+  return typeof value === "string" && value.trim() !== "" ? value : fallback;
+}
+function inferCategory(key) {
+  if (key.startsWith("workspace.")) {
+    return "workspace";
+  }
+  if (key.startsWith("security.")) {
+    return "security";
+  }
+  if (key.startsWith("orders.")) {
+    return "orders";
+  }
+  if (key.startsWith("social.") || key.includes("mention") || key.includes("comment")) {
+    return "social";
+  }
+  if (key.startsWith("marketing.")) {
+    return "marketing";
+  }
+  return "system";
+}
+function inferLevel(value) {
+  if (isValidLevel(value)) {
+    return value;
+  }
+  return "info";
+}
+function buildUser(payload) {
+  const actorId = nullableString(payload["actor_id"]);
+  if (actorId === null) {
+    return void 0;
+  }
+  const user = {
+    id: actorId,
+    name: stringOrFallback(payload["actor_name"], "Someone"),
+    handle: nullableString(payload["actor_handle"]) ?? ""
+  };
+  const avatar = nullableString(payload["actor_avatar"]);
+  if (avatar !== null) {
+    user["avatar"] = avatar;
+  }
+  return user;
+}
+function normalizeApiNotification(raw) {
+  if (isNotifyKitNotification(raw)) {
+    return raw;
+  }
+  const rawRecord = isRecord(raw) ? {
+    id: stringOrFallback(raw["id"], ""),
+    type: nullableString(raw["type"]) ?? void 0,
+    data: isRecord(raw["data"]) ? raw["data"] : {},
+    read_at: nullableString(raw["read_at"]),
+    created_at: nullableString(raw["created_at"]) ?? void 0
+  } : {
+    id: "",
+    type: void 0,
+    data: {},
+    read_at: void 0,
+    created_at: void 0
+  };
+  const payload = isRecord(rawRecord.data) ? rawRecord.data : {};
+  const nestedData = isRecord(payload["data"]) ? payload["data"] : {};
+  const key = stringOrFallback(payload["key"], stringOrFallback(rawRecord.type, "system.notification"));
+  const category = isValidCategory(payload["category"]) ? payload["category"] : inferCategory(key);
+  const title = stringOrFallback(payload["title"], stringOrFallback(payload["message"], "Notification"));
+  const body = stringOrFallback(payload["body"], stringOrFallback(payload["message"], title));
+  const actionUrl = nullableString(payload["action_url"]) ?? nullableString(payload["link"]);
+  const user = buildUser(payload);
+  const data = {
+    ...nestedData
+  };
+  for (const [entryKey, entryValue] of Object.entries(payload)) {
+    if (entryKey === "data" || RESERVED_PAYLOAD_KEYS.has(entryKey)) {
+      continue;
+    }
+    data[entryKey] = entryValue;
+  }
+  if (typeof payload["key"] === "string") {
+    data["key"] = payload["key"];
+  }
+  if (typeof payload["title"] === "string") {
+    data["title"] = payload["title"];
+  }
+  data["body"] = body;
+  data["message"] = body;
+  if (actionUrl !== null) {
+    data["action_url"] = actionUrl;
+    data["link"] = actionUrl;
+  }
+  if (user !== void 0) {
+    data["user"] = user;
+  }
+  return {
+    id: stringOrFallback(rawRecord.id, ""),
+    key,
+    category,
+    level: inferLevel(payload["level"]),
+    title,
+    body,
+    action_url: actionUrl,
+    workspace_id: nullableString(payload["workspace_id"]),
+    modal: isModalSpec(payload["modal"]) ? payload["modal"] : null,
+    group_key: nullableString(payload["group_key"]),
+    idempotency_key: nullableString(payload["idempotency_key"]),
+    data,
+    read_at: rawRecord.read_at ?? null,
+    created_at: stringOrFallback(rawRecord.created_at, (/* @__PURE__ */ new Date()).toISOString())
+  };
+}
+
 // src/client/NotifyKitClient.ts
 var NotifyKitApiError = class extends Error {
-  constructor(message, status, errors) {
+  constructor(message, status, errors, headers) {
     super(message);
     this.status = status;
     this.errors = errors;
+    this.headers = headers;
   }
   name = "NotifyKitApiError";
 };
@@ -140,7 +303,11 @@ var NotifyKitClient = class {
     const queryParams = this.buildNotificationParams(params);
     const queryString = queryParams.toString();
     const url = queryString.length > 0 ? `/notifications?${queryString}` : "/notifications";
-    return this.request("GET", url);
+    const response = await this.request("GET", url);
+    return {
+      data: response.data.map((notification) => normalizeApiNotification(notification)),
+      meta: response.meta
+    };
   }
   /**
    * Get the count of unread notifications.
@@ -151,11 +318,21 @@ var NotifyKitClient = class {
       "/notifications/unread-count"
     );
   }
+  /**
+   * Get a single notification for the current user.
+   */
+  async getNotification(id) {
+    const response = await this.request(
+      "GET",
+      `/notifications/${id}`
+    );
+    return normalizeApiNotification(response.data);
+  }
   /**
    * Mark a notification as read.
    */
   async markRead(id) {
-    await this.request("PATCH", `/notifications/${id}/read`);
+    return this.request("PATCH", `/notifications/${id}/read`);
   }
   /**
    * Mark all notifications as read.
@@ -191,7 +368,11 @@ var NotifyKitClient = class {
     }
     const queryString = queryParams.toString();
     const url = queryString.length > 0 ? `/notifications/groups/${groupKey}?${queryString}` : `/notifications/groups/${groupKey}`;
-    return this.request("GET", url);
+    const response = await this.request("GET", url);
+    return {
+      data: response.data.map((notification) => normalizeApiNotification(notification)),
+      meta: response.meta
+    };
   }
   // ============================================
   // Modals
@@ -222,16 +403,159 @@ var NotifyKitClient = class {
   // Preferences
   // ============================================
   /**
-   * Get the current user's notification preferences.
+   * Get the current user's notification preference settings.
+   */
+  async getPreferenceSettings(query) {
+    const queryParams = new URLSearchParams();
+    if (query?.workspace_id !== void 0 && query.workspace_id !== null) {
+      queryParams.set("workspace_id", query.workspace_id);
+    }
+    const queryString = queryParams.toString();
+    const url = queryString.length > 0 ? `/preference-settings?${queryString}` : "/preference-settings";
+    const response = await this.request("GET", url);
+    return response.data;
+  }
+  /**
+   * Alias for getPreferenceSettings.
    */
-  async getPreferences() {
-    return this.request("GET", "/preferences");
+  async getPreferences(query) {
+    return this.getPreferenceSettings(query);
+  }
+  /**
+   * Update the current user's notification preference settings.
+   */
+  async updatePreferenceSettings(preferences) {
+    const response = await this.request(
+      "PATCH",
+      "/preference-settings",
+      preferences
+    );
+    return response.data;
   }
   /**
-   * Update the current user's notification preferences.
+   * Alias for updatePreferenceSettings.
    */
   async updatePreferences(preferences) {
-    await this.request("PUT", "/preferences", preferences);
+    return this.updatePreferenceSettings(preferences);
+  }
+  // ============================================
+  // Bulk Actions
+  // ============================================
+  /**
+   * Bulk mark notifications as read.
+   */
+  async bulkMarkRead(ids) {
+    return this.request("POST", "/notifications/bulk/read", {
+      notification_ids: ids
+    });
+  }
+  /**
+   * Bulk mark all matching notifications as read.
+   */
+  async bulkMarkAllRead(filters) {
+    return this.request("POST", "/notifications/bulk/read", {
+      all: true,
+      filters
+    });
+  }
+  /**
+   * Bulk archive notifications.
+   */
+  async bulkArchive(ids) {
+    return this.request("POST", "/notifications/bulk/archive", {
+      notification_ids: ids
+    });
+  }
+  /**
+   * Bulk archive all matching notifications.
+   */
+  async bulkArchiveAll(filters) {
+    return this.request("POST", "/notifications/bulk/archive", {
+      all: true,
+      filters
+    });
+  }
+  /**
+   * Bulk delete notifications.
+   */
+  async bulkDelete(ids) {
+    return this.request("POST", "/notifications/bulk/delete", {
+      notification_ids: ids
+    });
+  }
+  /**
+   * Bulk delete all matching notifications.
+   */
+  async bulkDeleteAll(filters) {
+    return this.request("POST", "/notifications/bulk/delete", {
+      all: true,
+      filters
+    });
+  }
+  // ============================================
+  // Search
+  // ============================================
+  /**
+   * Search notifications by query.
+   */
+  async search(query, filters, limit) {
+    const queryParams = new URLSearchParams();
+    queryParams.set("q", query);
+    if (filters?.category !== void 0) {
+      queryParams.set("category", filters.category);
+    }
+    if (filters?.unread === true) {
+      queryParams.set("unread", "1");
+    }
+    if (filters?.level !== void 0) {
+      queryParams.set("level", filters.level);
+    }
+    if (limit !== void 0) {
+      queryParams.set("limit", String(limit));
+    }
+    const response = await this.request("GET", `/notifications/search?${queryParams.toString()}`);
+    return {
+      data: response.data.map((notification) => normalizeApiNotification(notification)),
+      total: response.total
+    };
+  }
+  /**
+   * Get saved filters (system + custom).
+   */
+  async getSavedFilters() {
+    const response = await this.request("GET", "/notifications/filters");
+    return response.data;
+  }
+  /**
+   * Save a custom filter.
+   */
+  async saveFilter(name, filters) {
+    const response = await this.request("POST", "/notifications/filters", {
+      name,
+      filters
+    });
+    return response.data;
+  }
+  /**
+   * Delete a custom filter.
+   */
+  async deleteFilter(filterId) {
+    await this.request("DELETE", `/notifications/filters/${filterId}`);
+  }
+  // ============================================
+  // Archive
+  // ============================================
+  /**
+   * Archive a notification.
+   */
+  async archiveNotification(id) {
+    await this.request("POST", `/notifications/${id}/archive`);
+  }
+  /**
+   * Unarchive a notification.
+   */
+  async unarchiveNotification(id) {
+    await this.request("POST", `/notifications/${id}/unarchive`);
   }
   // ============================================
   // Private helpers
@@ -280,11 +604,15 @@ var NotifyKitClient = class {
     }
     const response = await this.fetchFn(url, requestInit);
     if (!response.ok) {
+      const responseHeaders = Object.fromEntries(
+        Array.from(response.headers.entries()).map(([key, value]) => [key.toLowerCase(), value])
+      );
       const errorData = await response.json();
       throw new NotifyKitApiError(
         errorData.message ?? `Request failed with status ${String(response.status)}`,
         response.status,
-        errorData.errors
+        errorData.errors,
+        responseHeaders
       );
     }
     const text = await response.text();
@@ -322,8 +650,9 @@ var ENDPOINTS = {
   ACK_MODAL: (id) => `/modals/${id}/ack`,
   /** POST - Snooze a modal notification */
   SNOOZE_MODAL: (id) => `/modals/${id}/snooze`,
-  /** GET - Get user's notification preferences */
-  PREFERENCES: "/preferences"
+  /** GET/PATCH - Get or update user's notification preference settings */
+  PREFERENCE_SETTINGS: "/preference-settings",
+  PREFERENCES: "/preference-settings"
 };
 var NOTIFY_KIT_CLIENT_KEY = /* @__PURE__ */ Symbol(
   "notify-kit-client"
@@ -353,6 +682,7 @@ function useNotifyKitClient(config) {
     // Notifications
     listNotifications: (params) => client.listNotifications(params),
     getUnreadCount: () => client.getUnreadCount(),
+    getNotification: (id) => client.getNotification(id),
     markRead: (id) => client.markRead(id),
     markAllRead: () => client.markAllRead(),
     deleteNotification: (id) => client.deleteNotification(id),
@@ -364,10 +694,493 @@ function useNotifyKitClient(config) {
     ackModal: (id) => client.ackModal(id),
     snoozeModal: (id, minutes) => client.snoozeModal(id, minutes),
     // Preferences
-    getPreferences: () => client.getPreferences(),
+    getPreferenceSettings: (query) => client.getPreferenceSettings(query),
+    updatePreferenceSettings: (preferences) => client.updatePreferenceSettings(preferences),
+    getPreferences: (query) => client.getPreferences(query),
     updatePreferences: (preferences) => client.updatePreferences(preferences)
   };
 }
+var DEFAULT_UNREAD_COUNT_RETRY_AFTER_MS = 3e4;
+var MIN_UNREAD_COUNT_RETRY_AFTER_MS = 5e3;
+var DEFAULT_UNREAD_COUNT_TRANSIENT_RETRY_MS = 1e4;
+var MAX_UNREAD_COUNT_TRANSIENT_RETRY_MS = 12e4;
+var MIN_UNREAD_COUNT_REFRESH_INTERVAL_MS = 5e3;
+var DEFAULT_PER_PAGE = 20;
+function createInitialInboxState() {
+  return {
+    error: null,
+    currentPage: 0,
+    lastPage: 1,
+    hasMore: true,
+    unreadCountRetryAfterUntil: 0,
+    unreadCountLastLoadedAt: 0,
+    unreadCountTransientFailureCount: 0,
+    unreadCountRequest: null
+  };
+}
+var inboxState = null;
+function getInboxState() {
+  inboxState ??= reactive(createInitialInboxState());
+  return inboxState;
+}
+function resetNotifyKitInbox() {
+  if (inboxState !== null) {
+    Object.assign(inboxState, createInitialInboxState());
+  }
+}
+function resolveStatusCode(statusCode) {
+  if (typeof statusCode === "number" && Number.isFinite(statusCode)) {
+    return statusCode;
+  }
+  if (typeof statusCode === "string") {
+    const parsedStatus = Number.parseInt(statusCode, 10);
+    if (Number.isFinite(parsedStatus)) {
+      return parsedStatus;
+    }
+  }
+  return void 0;
+}
+function resolveRetryAfterMs(retryAfterHeader) {
+  if (typeof retryAfterHeader === "number" && Number.isFinite(retryAfterHeader) && retryAfterHeader > 0) {
+    return Math.max(MIN_UNREAD_COUNT_RETRY_AFTER_MS, retryAfterHeader * 1e3);
+  }
+  if (typeof retryAfterHeader === "string") {
+    const parsedSeconds = Number.parseInt(retryAfterHeader, 10);
+    if (Number.isFinite(parsedSeconds) && parsedSeconds > 0) {
+      return Math.max(MIN_UNREAD_COUNT_RETRY_AFTER_MS, parsedSeconds * 1e3);
+    }
+  }
+  return DEFAULT_UNREAD_COUNT_RETRY_AFTER_MS;
+}
+function isServerFailureStatus(statusCode) {
+  return typeof statusCode === "number" && statusCode >= 500 && statusCode < 600;
+}
+function resolveTransientRetryMs(failureCount) {
+  const sanitizedFailureCount = Math.max(1, failureCount);
+  const exponentialRetryMs = DEFAULT_UNREAD_COUNT_TRANSIENT_RETRY_MS * 2 ** (sanitizedFailureCount - 1);
+  return Math.min(MAX_UNREAD_COUNT_TRANSIENT_RETRY_MS, exponentialRetryMs);
+}
+function resolveErrorMessage(error) {
+  if (error instanceof Error && error.message.length > 0) {
+    return error.message;
+  }
+  if (typeof error === "string" && error.length > 0) {
+    return error;
+  }
+  return "Request failed";
+}
+function asNotifyKitApiError(error) {
+  if (typeof error !== "object" || error === null) {
+    return null;
+  }
+  const status = "status" in error ? error.status : void 0;
+  const headers = "headers" in error ? error.headers : void 0;
+  const resolvedStatus = typeof status === "number" || typeof status === "string" ? status : void 0;
+  const resolvedHeaders = typeof headers === "object" && headers !== null ? headers : void 0;
+  if (resolvedStatus === void 0 && resolvedHeaders === void 0) {
+    return {};
+  }
+  return {
+    ...resolvedStatus !== void 0 ? { status: resolvedStatus } : {},
+    ...resolvedHeaders !== void 0 ? { headers: resolvedHeaders } : {}
+  };
+}
+function useNotifyKitInbox(options) {
+  const { client, perPage = DEFAULT_PER_PAGE } = options;
+  const store = useNotifyKitStore();
+  const state = getInboxState();
+  const notifications = computed(() => store.state.notifications);
+  const unreadCount = computed(() => store.state.unreadCount);
+  const loading = computed(() => store.state.notificationsLoading);
+  const error = computed(() => state.error);
+  const hasMore = computed(() => state.hasMore);
+  const nextPage = computed(() => state.hasMore ? state.currentPage + 1 : null);
+  const isUnreadCountCoolingDown = computed(
+    () => Date.now() < state.unreadCountRetryAfterUntil
+  );
+  function reconcileUnreadCountForFullyLoadedList() {
+    if (state.hasMore) {
+      return;
+    }
+    const resolvedUnreadCount = store.state.notifications.filter(
+      (notification) => notification.read_at === null
+    ).length;
+    store.setUnreadCount(resolvedUnreadCount);
+  }
+  async function loadUnreadCount() {
+    if (Date.now() < state.unreadCountRetryAfterUntil) {
+      return false;
+    }
+    if (state.unreadCountRequest !== null) {
+      return await state.unreadCountRequest;
+    }
+    const now = Date.now();
+    if (now - state.unreadCountLastLoadedAt < MIN_UNREAD_COUNT_REFRESH_INTERVAL_MS) {
+      return true;
+    }
+    store.setUnreadCountLoading(true);
+    state.unreadCountRequest = (async () => {
+      try {
+        const response = await client.getUnreadCount();
+        store.setUnreadCount(response.count);
+        state.unreadCountLastLoadedAt = Date.now();
+        state.unreadCountTransientFailureCount = 0;
+        state.unreadCountRetryAfterUntil = 0;
+        return true;
+      } catch (error2) {
+        const apiError = asNotifyKitApiError(error2);
+        const statusCode = resolveStatusCode(apiError?.status);
+        if (statusCode === 429) {
+          const retryAfterHeader = apiError?.headers?.["retry-after"];
+          state.unreadCountRetryAfterUntil = Date.now() + resolveRetryAfterMs(retryAfterHeader);
+          return false;
+        }
+        if (statusCode === 404) {
+          store.setUnreadCount(0);
+          state.unreadCountLastLoadedAt = Date.now();
+          state.unreadCountTransientFailureCount = 0;
+          state.unreadCountRetryAfterUntil = 0;
+          return true;
+        }
+        state.unreadCountTransientFailureCount += 1;
+        if (statusCode === void 0 || isServerFailureStatus(statusCode)) {
+          state.unreadCountRetryAfterUntil = Date.now() + resolveTransientRetryMs(state.unreadCountTransientFailureCount);
+          return false;
+        }
+        state.unreadCountRetryAfterUntil = Date.now() + DEFAULT_UNREAD_COUNT_TRANSIENT_RETRY_MS;
+        return false;
+      } finally {
+        store.setUnreadCountLoading(false);
+      }
+    })();
+    const wasSuccessful = await state.unreadCountRequest.finally(() => {
+      state.unreadCountRequest = null;
+    });
+    return wasSuccessful;
+  }
+  async function fetchNotifications(page = null, append = false) {
+    if (store.state.notificationsLoading) {
+      return void 0;
+    }
+    store.setNotificationsLoading(true);
+    state.error = null;
+    try {
+      const pageNumber = page !== null ? Number(page) : 1;
+      const response = await client.listNotifications({
+        per_page: perPage,
+        page: pageNumber
+      });
+      const items = [...response.data];
+      if (append) {
+        store.setNotifications([...store.state.notifications, ...items]);
+      } else {
+        store.setNotifications(items);
+      }
+      store.setNotificationsMeta(response.meta);
+      store.setLastNotificationsSync(Date.now());
+      state.currentPage = response.meta.current_page;
+      state.lastPage = response.meta.last_page;
+      state.hasMore = response.meta.current_page < response.meta.last_page;
+      reconcileUnreadCountForFullyLoadedList();
+      return items;
+    } catch (error2) {
+      state.error = resolveErrorMessage(error2);
+      store.setNotificationsMeta(null);
+      state.currentPage = 0;
+      state.lastPage = 1;
+      state.hasMore = false;
+      if (!append) {
+        store.setNotifications([]);
+        store.setUnreadCount(0);
+      }
+      throw error2;
+    } finally {
+      store.setNotificationsLoading(false);
+    }
+  }
+  async function markAsRead(notificationId) {
+    const notification = store.state.notifications.find((item) => item.id === notificationId);
+    const wasUnread = notification?.read_at === null;
+    const response = await client.markRead(notificationId);
+    if (wasUnread) {
+      store.markNotificationRead(notificationId);
+    }
+    if (typeof response.unread_count === "number") {
+      store.setUnreadCount(Math.max(0, response.unread_count));
+      return;
+    }
+    if (wasUnread) {
+      store.decrementUnreadCount();
+    }
+  }
+  async function markAllAsRead() {
+    try {
+      await client.markAllRead();
+      const readTimestamp = (/* @__PURE__ */ new Date()).toISOString();
+      const nextNotifications = store.state.notifications.map(
+        (notification) => notification.read_at === null ? {
+          ...notification,
+          read_at: readTimestamp
+        } : notification
+      );
+      store.setNotifications(nextNotifications);
+      await loadUnreadCount();
+    } catch (error2) {
+      state.error = resolveErrorMessage(error2);
+      throw error2;
+    }
+  }
+  async function deleteNotification(notificationId) {
+    await client.deleteNotification(notificationId);
+    const notification = store.state.notifications.find((item) => item.id === notificationId);
+    const wasUnread = notification?.read_at === null;
+    store.removeNotification(notificationId);
+    if (wasUnread) {
+      store.decrementUnreadCount();
+    }
+  }
+  async function clearAll() {
+    try {
+      await client.markAllRead();
+      store.setNotifications([]);
+      store.setUnreadCount(0);
+    } catch (error2) {
+      state.error = resolveErrorMessage(error2);
+      throw error2;
+    }
+  }
+  async function loadMore() {
+    if (!state.hasMore || store.state.notificationsLoading) {
+      return;
+    }
+    await fetchNotifications(state.currentPage + 1, true);
+  }
+  function reset() {
+    store.reset();
+    Object.assign(state, createInitialInboxState());
+  }
+  return {
+    notifications,
+    unreadCount,
+    loading,
+    error,
+    hasMore,
+    nextPage,
+    isUnreadCountCoolingDown,
+    loadUnreadCount,
+    fetchNotifications,
+    loadMore,
+    markAsRead,
+    markAllAsRead,
+    deleteNotification,
+    clearAll,
+    reset
+  };
+}
+
+// src/composables/useNotifyKitRealtimeState.ts
+function isRecord2(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function normalizeNullableString(value) {
+  if (value === void 0 || value === null) {
+    return null;
+  }
+  return typeof value === "string" ? value : void 0;
+}
+function normalizeModalSpec(value) {
+  if (value === void 0 || value === null) {
+    return null;
+  }
+  return isModalSpec(value) ? value : void 0;
+}
+function normalizeRealtimeNotificationPayload(payload) {
+  if (!isRecord2(payload)) {
+    return null;
+  }
+  const id = payload["id"];
+  const key = payload["key"];
+  const category = payload["category"];
+  const level = payload["level"];
+  const title = payload["title"];
+  const body = payload["body"];
+  const createdAt = payload["created_at"];
+  if (typeof id !== "string" || typeof key !== "string" || !isValidCategory(category) || !isValidLevel(level) || typeof title !== "string" || typeof body !== "string" || typeof createdAt !== "string") {
+    return null;
+  }
+  const data = payload["data"];
+  if (data !== void 0 && !isRecord2(data)) {
+    return null;
+  }
+  const actionUrl = normalizeNullableString(payload["action_url"]);
+  const workspaceId = normalizeNullableString(payload["workspace_id"]);
+  const groupKey = normalizeNullableString(payload["group_key"]);
+  const idempotencyKey = normalizeNullableString(payload["idempotency_key"]);
+  const readAt = normalizeNullableString(payload["read_at"]);
+  const modal = normalizeModalSpec(payload["modal"]);
+  if (actionUrl === void 0 || workspaceId === void 0 || groupKey === void 0 || idempotencyKey === void 0 || readAt === void 0 || modal === void 0) {
+    return null;
+  }
+  return {
+    id,
+    key,
+    category,
+    level,
+    title,
+    body,
+    action_url: actionUrl,
+    workspace_id: workspaceId,
+    modal,
+    group_key: groupKey,
+    idempotency_key: idempotencyKey,
+    data: data ?? {},
+    read_at: readAt,
+    created_at: createdAt
+  };
+}
+function useNotifyKitRealtimeState() {
+  const store = useNotifyKitStore();
+  function applyIncomingNotification(notification) {
+    const existingIndex = store.state.notifications.findIndex((item) => item.id === notification.id);
+    if (existingIndex === -1) {
+      store.setNotifications([notification, ...store.state.notifications]);
+      if (notification.read_at === null) {
+        store.incrementUnreadCount();
+      }
+    } else {
+      const existing = store.state.notifications[existingIndex];
+      const wasRead = existing?.read_at !== null;
+      const isNowRead = notification.read_at !== null;
+      const nextNotifications = [...store.state.notifications];
+      nextNotifications.splice(existingIndex, 1);
+      nextNotifications.unshift(notification);
+      store.setNotifications(nextNotifications);
+      if (wasRead && !isNowRead) {
+        store.incrementUnreadCount();
+      } else if (!wasRead && isNowRead) {
+        store.decrementUnreadCount();
+      }
+    }
+    if (isModalEnabled(notification)) {
+      store.enqueueModal(notification);
+    }
+  }
+  function applyIncomingPayload(payload) {
+    const notification = normalizeRealtimeNotificationPayload(payload);
+    if (notification === null) {
+      return null;
+    }
+    applyIncomingNotification(notification);
+    return notification;
+  }
+  function handleNotificationRead(notificationId) {
+    const notification = store.state.notifications.find((item) => item.id === notificationId);
+    if (notification?.read_at === null) {
+      store.markNotificationRead(notificationId);
+      store.decrementUnreadCount();
+    }
+  }
+  function handleNotificationDeleted(notificationId) {
+    const notification = store.state.notifications.find((item) => item.id === notificationId);
+    const wasUnread = notification?.read_at === null;
+    store.removeNotification(notificationId);
+    if (wasUnread) {
+      store.decrementUnreadCount();
+    }
+  }
+  return {
+    applyIncomingPayload,
+    applyIncomingNotification,
+    handleNotificationRead,
+    handleNotificationDeleted
+  };
+}
+
+// src/helpers/toastPolicy.ts
+var DEFAULT_TOAST_CATEGORIES = {
+  workspace: true,
+  security: true,
+  orders: true,
+  social: false,
+  system: true,
+  marketing: true
+};
+var DEFAULT_SOUND_LEVELS = ["danger"];
+var DEFAULT_SOUND_CATEGORIES = ["security"];
+function isCriticalModal(notification) {
+  return notification.modal !== null && notification.modal.enabled && notification.modal.requires_ack;
+}
+function defaultShouldToast(notification, categorySettings) {
+  if (isCriticalModal(notification)) {
+    return false;
+  }
+  return categorySettings[notification.category];
+}
+function defaultShouldPlaySound(notification, soundLevels, soundCategories) {
+  if (soundLevels.includes(notification.level)) {
+    return true;
+  }
+  if (soundCategories.includes(notification.category)) {
+    return true;
+  }
+  return false;
+}
+var defaultToastPolicy = {
+  shouldToast(notification) {
+    return defaultShouldToast(notification, DEFAULT_TOAST_CATEGORIES);
+  },
+  shouldPlaySound(notification) {
+    return defaultShouldPlaySound(
+      notification,
+      DEFAULT_SOUND_LEVELS,
+      DEFAULT_SOUND_CATEGORIES
+    );
+  }
+};
+function createToastPolicy(config) {
+  const categorySettings = {
+    ...DEFAULT_TOAST_CATEGORIES,
+    ...config.toastCategories
+  };
+  const soundLevels = config.soundLevels ?? DEFAULT_SOUND_LEVELS;
+  const soundCategories = config.soundCategories ?? DEFAULT_SOUND_CATEGORIES;
+  return {
+    shouldToast(notification) {
+      if (config.shouldToast !== void 0) {
+        return config.shouldToast(notification);
+      }
+      return defaultShouldToast(notification, categorySettings);
+    },
+    shouldPlaySound(notification) {
+      if (config.shouldPlaySound !== void 0) {
+        return config.shouldPlaySound(notification);
+      }
+      return defaultShouldPlaySound(notification, soundLevels, soundCategories);
+    }
+  };
+}
+
+// src/helpers/notifyKitRealtimeChannel.ts
+async function resolveNotifyKitBroadcastChannel(options) {
+  const { client, channel } = options;
+  if (typeof channel === "string" && channel.length > 0) {
+    return channel;
+  }
+  const meResponse = await client.getMe();
+  return meResponse.broadcast_channel;
+}
+function bindNotifyKitBroadcastChannel(options) {
+  const { echo, channel, onNotification } = options;
+  echo.private(channel).notification(onNotification);
+  return {
+    channel,
+    unsubscribe: () => {
+      echo.leave(channel);
+    }
+  };
+}
+
+// src/composables/useNotifyKitRealtime.ts
 function useNotifyKitRealtime(options) {
   const {
     echo: echoOption,
@@ -377,6 +1190,7 @@ function useNotifyKitRealtime(options) {
     onConnectionChange
   } = options;
   const store = useNotifyKitStore();
+  const realtimeState = useNotifyKitRealtimeState();
   const connectionState = ref("disconnected");
   const currentChannel = ref(null);
   const isSubscribed = ref(false);
@@ -390,15 +1204,11 @@ function useNotifyKitRealtime(options) {
     onConnectionChange?.(state);
   }
   function handleNotification(payload) {
-    if (!isNotifyKitNotification(payload)) {
+    const notification = realtimeState.applyIncomingPayload(payload);
+    if (notification === null) {
       return;
     }
-    store.addNotification(payload);
-    store.incrementUnreadCount();
-    if (isModalEnabled(payload)) {
-      store.enqueueModal(payload);
-    }
-    onNotification?.(payload);
+    onNotification?.(notification);
   }
   async function connect() {
     if (connectionState.value === "connected" || connectionState.value === "connecting") {
@@ -406,12 +1216,15 @@ function useNotifyKitRealtime(options) {
     }
     setConnectionState("connecting");
     try {
-      const meResponse = await client.getMe();
-      const channel = meResponse.broadcast_channel;
+      const channel = await resolveNotifyKitBroadcastChannel({ client });
       currentChannel.value = channel;
       store.setBroadcastChannel(channel);
       const echo = getEcho();
-      echo.private(channel).notification(handleNotification);
+      bindNotifyKitBroadcastChannel({
+        echo,
+        channel,
+        onNotification: handleNotification
+      });
       isSubscribed.value = true;
       setConnectionState("connected");
     } catch (error) {
@@ -537,7 +1350,9 @@ function useNotifyKitFallback(options) {
         startPolling();
         disconnectTimer = null;
       }, config.disconnectThresholdMs);
-    } else if (state === "connected") {
+      return;
+    }
+    if (state === "connected") {
       if (disconnectTimer !== null) {
         clearTimeout(disconnectTimer);
         disconnectTimer = null;
@@ -566,172 +1381,299 @@ function useNotifyKitFallback(options) {
     pollModals
   };
 }
-
-// src/helpers/toastPolicy.ts
-var DEFAULT_TOAST_CATEGORIES = {
-  workspace: true,
-  security: true,
-  orders: true,
-  social: false,
-  system: true,
-  marketing: true
-};
-var DEFAULT_SOUND_LEVELS = ["danger"];
-var DEFAULT_SOUND_CATEGORIES = ["security"];
-function isCriticalModal(notification) {
-  return notification.modal !== null && notification.modal.enabled && notification.modal.requires_ack;
+function createInitialState() {
+  return {
+    selectedIds: /* @__PURE__ */ new Set(),
+    isSelectionMode: false,
+    isProcessing: false,
+    error: null
+  };
 }
-function defaultShouldToast(notification, categorySettings) {
-  if (isCriticalModal(notification)) {
-    return false;
+function useNotifyKitBulkActions(options) {
+  const { client } = options;
+  const store = useNotifyKitStore();
+  const state = reactive(createInitialState());
+  const selectedCount = computed(() => state.selectedIds.size);
+  const hasSelection = computed(() => state.selectedIds.size > 0);
+  const selectedIdsArray = computed(() => Array.from(state.selectedIds));
+  function toggleSelection(id) {
+    if (state.selectedIds.has(id)) {
+      state.selectedIds.delete(id);
+    } else {
+      state.selectedIds.add(id);
+    }
   }
-  return categorySettings[notification.category];
-}
-function defaultShouldPlaySound(notification, soundLevels, soundCategories) {
-  if (soundLevels.includes(notification.level)) {
-    return true;
+  function select(id) {
+    state.selectedIds.add(id);
   }
-  if (soundCategories.includes(notification.category)) {
-    return true;
+  function deselect(id) {
+    state.selectedIds.delete(id);
   }
-  return false;
-}
-var defaultToastPolicy = {
-  shouldToast(notification) {
-    return defaultShouldToast(notification, DEFAULT_TOAST_CATEGORIES);
-  },
-  shouldPlaySound(notification) {
-    return defaultShouldPlaySound(
-      notification,
-      DEFAULT_SOUND_LEVELS,
-      DEFAULT_SOUND_CATEGORIES
-    );
+  function selectAll(ids) {
+    for (const id of ids) {
+      state.selectedIds.add(id);
+    }
   }
-};
-function createToastPolicy(config) {
-  const categorySettings = {
-    ...DEFAULT_TOAST_CATEGORIES,
-    ...config.toastCategories
-  };
-  const soundLevels = config.soundLevels ?? DEFAULT_SOUND_LEVELS;
-  const soundCategories = config.soundCategories ?? DEFAULT_SOUND_CATEGORIES;
-  return {
-    shouldToast(notification) {
-      if (config.shouldToast !== void 0) {
-        return config.shouldToast(notification);
+  function clearSelection() {
+    state.selectedIds.clear();
+  }
+  function enterSelectionMode() {
+    state.isSelectionMode = true;
+  }
+  function exitSelectionMode() {
+    state.isSelectionMode = false;
+    state.selectedIds.clear();
+  }
+  async function markSelectedRead() {
+    if (state.selectedIds.size === 0) {
+      return { affected: 0, failed: 0 };
+    }
+    state.isProcessing = true;
+    state.error = null;
+    try {
+      const ids = Array.from(state.selectedIds);
+      const result = await client.bulkMarkRead(ids);
+      for (const id of ids) {
+        store.markNotificationRead(id);
       }
-      return defaultShouldToast(notification, categorySettings);
-    },
-    shouldPlaySound(notification) {
-      if (config.shouldPlaySound !== void 0) {
-        return config.shouldPlaySound(notification);
+      if (result.affected > 0) {
+        store.setUnreadCount(Math.max(0, store.state.unreadCount - result.affected));
       }
-      return defaultShouldPlaySound(notification, soundLevels, soundCategories);
+      clearSelection();
+      return result;
+    } catch (error) {
+      state.error = error instanceof Error ? error.message : "Failed to mark as read";
+      throw error;
+    } finally {
+      state.isProcessing = false;
     }
-  };
-}
-
-// src/helpers/modalHelpers.ts
-function getModalAriaAttributes(notification, ids) {
-  const ariaRole = notification.modal?.accessibility?.aria_role ?? "alertdialog";
-  return {
-    role: ariaRole,
-    "aria-modal": "true",
-    "aria-labelledby": ids.titleId,
-    "aria-describedby": ids.bodyId
-  };
-}
-function getEscapeKeyHandler(notification, callbacks) {
-  const behavior = notification.modal?.accessibility?.escape_key_behavior ?? "close";
-  if (behavior === "disabled") {
-    return null;
   }
-  return (event) => {
-    if (event.key !== "Escape") return;
-    switch (behavior) {
-      case "close":
-        event.preventDefault();
-        callbacks.onClose();
-        break;
-      case "snooze": {
-        event.preventDefault();
-        const minSnooze = notification.modal?.snooze_options_minutes[0] ?? 15;
-        callbacks.onSnooze(minSnooze);
-        break;
+  async function markAllRead(filters) {
+    state.isProcessing = true;
+    state.error = null;
+    try {
+      const result = await client.bulkMarkAllRead(filters);
+      if (filters === void 0) {
+        store.setUnreadCount(0);
       }
-    }
-  };
-}
-function createFocusTrap(modalElement) {
-  const focusableSelector = 'button, [href], input, select, textarea, [tabindex]:not([tabindex="-1"])';
-  let previousFocus = null;
-  let trapHandler = null;
-  function trapFocus(event) {
-    if (event.key !== "Tab") return;
-    const focusable = modalElement.querySelectorAll(focusableSelector);
-    if (focusable.length === 0) return;
-    const first = focusable[0];
-    const last = focusable[focusable.length - 1];
-    if (first === void 0 || last === void 0) return;
-    if (event.shiftKey && document.activeElement === first) {
-      event.preventDefault();
-      last.focus();
-    } else if (!event.shiftKey && document.activeElement === last) {
-      event.preventDefault();
-      first.focus();
+      clearSelection();
+      return result;
+    } catch (error) {
+      state.error = error instanceof Error ? error.message : "Failed to mark all as read";
+      throw error;
+    } finally {
+      state.isProcessing = false;
     }
   }
-  return {
-    activate() {
-      previousFocus = document.activeElement;
-      const focusable = modalElement.querySelectorAll(focusableSelector);
-      if (focusable.length > 0 && focusable[0] !== void 0) {
-        focusable[0].focus();
-      }
-      trapHandler = trapFocus;
-      modalElement.addEventListener("keydown", trapHandler);
-    },
-    deactivate() {
-      if (trapHandler !== null) {
-        modalElement.removeEventListener("keydown", trapHandler);
-        trapHandler = null;
+  async function archiveSelected() {
+    if (state.selectedIds.size === 0) {
+      return { affected: 0, failed: 0 };
+    }
+    state.isProcessing = true;
+    state.error = null;
+    try {
+      const ids = Array.from(state.selectedIds);
+      const result = await client.bulkArchive(ids);
+      for (const id of ids) {
+        store.removeNotification(id);
       }
-      if (previousFocus !== null) {
-        previousFocus.focus();
-        previousFocus = null;
+      clearSelection();
+      return result;
+    } catch (error) {
+      state.error = error instanceof Error ? error.message : "Failed to archive";
+      throw error;
+    } finally {
+      state.isProcessing = false;
+    }
+  }
+  async function archiveAll(filters) {
+    state.isProcessing = true;
+    state.error = null;
+    try {
+      const result = await client.bulkArchiveAll(filters);
+      clearSelection();
+      return result;
+    } catch (error) {
+      state.error = error instanceof Error ? error.message : "Failed to archive all";
+      throw error;
+    } finally {
+      state.isProcessing = false;
+    }
+  }
+  async function deleteSelected() {
+    if (state.selectedIds.size === 0) {
+      return { affected: 0, failed: 0 };
+    }
+    state.isProcessing = true;
+    state.error = null;
+    try {
+      const ids = Array.from(state.selectedIds);
+      const result = await client.bulkDelete(ids);
+      for (const id of ids) {
+        store.removeNotification(id);
       }
+      clearSelection();
+      return result;
+    } catch (error) {
+      state.error = error instanceof Error ? error.message : "Failed to delete";
+      throw error;
+    } finally {
+      state.isProcessing = false;
     }
+  }
+  async function deleteAll(filters) {
+    state.isProcessing = true;
+    state.error = null;
+    try {
+      const result = await client.bulkDeleteAll(filters);
+      clearSelection();
+      return result;
+    } catch (error) {
+      state.error = error instanceof Error ? error.message : "Failed to delete all";
+      throw error;
+    } finally {
+      state.isProcessing = false;
+    }
+  }
+  function reset() {
+    Object.assign(state, createInitialState());
+  }
+  return {
+    state: readonly(state),
+    selectedCount,
+    hasSelection,
+    selectedIdsArray,
+    toggleSelection,
+    select,
+    deselect,
+    selectAll,
+    clearSelection,
+    enterSelectionMode,
+    exitSelectionMode,
+    markSelectedRead,
+    markAllRead,
+    archiveSelected,
+    archiveAll,
+    deleteSelected,
+    deleteAll,
+    reset
   };
 }
-function getActionButtonAttributes(action, index) {
-  const attrs = {
-    type: "button",
-    "data-action-type": action.type,
-    "data-action-index": String(index),
-    "aria-label": action.label
+function createInitialState2() {
+  return {
+    query: "",
+    results: [],
+    total: 0,
+    isSearching: false,
+    hasSearched: false,
+    filters: null,
+    error: null
   };
-  if (action.primary === true) {
-    attrs["data-primary"] = true;
-  }
-  return attrs;
-}
-function isCriticalModal2(notification) {
-  return notification.modal?.enabled === true && notification.modal.requires_ack === true;
 }
-function shouldCloseOnBackdropClick(notification) {
-  return !isCriticalModal2(notification);
-}
-function getMinSnoozeDuration(notification) {
-  const options = notification.modal?.snooze_options_minutes;
-  if (options === void 0 || options.length === 0) {
-    return null;
+function useNotifyKitSearch(options) {
+  const { client, minQueryLength = 3 } = options;
+  const state = reactive(createInitialState2());
+  const savedFilters = ref([]);
+  const savedFiltersLoading = ref(false);
+  const hasResults = computed(() => state.results.length > 0);
+  const resultCount = computed(() => state.results.length);
+  const isValidQuery = computed(() => state.query.length >= minQueryLength);
+  async function search(query, filters) {
+    state.query = query;
+    if (query.length < minQueryLength) {
+      state.error = `Search query must be at least ${String(minQueryLength)} characters`;
+      return;
+    }
+    state.isSearching = true;
+    state.error = null;
+    try {
+      const effectiveFilters = filters ?? state.filters ?? void 0;
+      const result = await client.search(query, effectiveFilters);
+      state.results = [...result.data];
+      state.total = result.total;
+      state.hasSearched = true;
+      if (filters !== void 0) {
+        state.filters = filters;
+      }
+    } catch (error) {
+      state.error = error instanceof Error ? error.message : "Search failed";
+      state.results = [];
+      state.total = 0;
+    } finally {
+      state.isSearching = false;
+    }
+  }
+  function clearSearch() {
+    state.query = "";
+    state.results = [];
+    state.total = 0;
+    state.hasSearched = false;
+    state.error = null;
+  }
+  function setFilters(filters) {
+    state.filters = filters;
   }
-  return options[0] ?? null;
+  async function loadSavedFilters() {
+    savedFiltersLoading.value = true;
+    try {
+      savedFilters.value = await client.getSavedFilters();
+    } catch {
+    } finally {
+      savedFiltersLoading.value = false;
+    }
+  }
+  async function applyFilter(filter) {
+    const searchFilters = {};
+    const categoryValue = filter.filters["category"];
+    const levelValue = filter.filters["level"];
+    if (typeof categoryValue === "string") {
+      searchFilters.category = categoryValue;
+    }
+    if (filter.filters["unread_only"] === true) {
+      searchFilters.unread = true;
+    }
+    if (typeof levelValue === "string") {
+      searchFilters.level = levelValue;
+    }
+    state.filters = searchFilters;
+    if (state.query.length >= minQueryLength) {
+      await search(state.query, searchFilters);
+    }
+  }
+  async function saveFilter(name, filters) {
+    const createdFilter = await client.saveFilter(name, filters);
+    savedFilters.value = [...savedFilters.value, createdFilter];
+    return createdFilter;
+  }
+  async function deleteFilter(filterId) {
+    await client.deleteFilter(filterId);
+    savedFilters.value = savedFilters.value.filter((filter) => filter.id !== filterId);
+  }
+  function reset() {
+    Object.assign(state, createInitialState2());
+    savedFilters.value = [];
+  }
+  return {
+    state: readonly(state),
+    hasResults,
+    resultCount,
+    isValidQuery,
+    savedFilters,
+    savedFiltersLoading,
+    search,
+    clearSearch,
+    setFilters,
+    loadSavedFilters,
+    applyFilter,
+    saveFilter,
+    deleteFilter,
+    reset
+  };
 }
 
 // src/index.ts
 var VERSION = "0.1.0";
 
-export { ENDPOINTS, NOTIFICATION_CATEGORIES, NOTIFICATION_LEVELS, NOTIFY_KIT_CLIENT_KEY, NotifyKitApiError, NotifyKitClient, VERSION, createFocusTrap, createNotifyKitClient, createToastPolicy, defaultToastPolicy, getActionButtonAttributes, getEscapeKeyHandler, getMinSnoozeDuration, getModalAriaAttributes, isChannelPreferences, isCriticalModal2 as isCriticalModal, isMeResponse, isModalEnabled, isModalSpec, isNotifyKitNotification, isPaginationMeta, isUnreadCountResponse, isValidCategory, isValidLevel, provideNotifyKitClient, shouldCloseOnBackdropClick, useNotifyKitClient, useNotifyKitFallback, useNotifyKitRealtime };
+export { ENDPOINTS, NOTIFICATION_CATEGORIES, NOTIFICATION_LEVELS, NOTIFY_KIT_CLIENT_KEY, NotifyKitApiError, NotifyKitClient, VERSION, bindNotifyKitBroadcastChannel, createNotifyKitClient, createToastPolicy, defaultToastPolicy, isMeResponse, isModalEnabled, isModalSpec, isNotifyKitNotification, isNotifyKitPreferenceSettings, isNotifyKitQuietHours, isPaginationMeta, isUnreadCountResponse, isValidCategory, isValidLevel, provideNotifyKitClient, resetNotifyKitInbox, resolveNotifyKitBroadcastChannel, useNotifyKitBulkActions, useNotifyKitClient, useNotifyKitFallback, useNotifyKitInbox, useNotifyKitRealtime, useNotifyKitRealtimeState, useNotifyKitSearch };
 //# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map