@novu/js 3.11.1 → 3.11.2-nightly.20251224.eb609546a3

package/dist/cjs/{chunk-WFVHYVDM.js → chunk-CDGREQFE.js}

@@ -31,6 +31,11 @@ function buildSubscriber({
   return { subscriberId: "" };
 }
 
+// src/ui/internal/buildSubscriptionIdentifier.ts
+function buildSubscriptionIdentifier({ topicKey, subscriberId }) {
+  return `tk_${topicKey}:si_${subscriberId}`;
+}
+
 // src/types.ts
 var NotificationStatus = /* @__PURE__ */ ((NotificationStatus2) => {
   NotificationStatus2["READ"] = "read";
@@ -777,6 +782,7 @@ exports.archiveAll = archiveAll;
 exports.archiveAllRead = archiveAllRead;
 exports.buildContextKey = buildContextKey;
 exports.buildSubscriber = buildSubscriber;
+exports.buildSubscriptionIdentifier = buildSubscriptionIdentifier;
 exports.completeAction = completeAction;
 exports.createNotification = createNotification;
 exports.deleteAll = deleteAll;

package/dist/cjs/index.d.ts

@@ -1,6 +1,7 @@
-import { S as SeverityLevelEnum, N as NotificationFilter, a as Notification } from './novu-event-emitter-C7GZ7-r1.js';
-export { C as ChannelPreference, d as ChannelType, e as Context, D as DaySchedule, f as DefaultSchedule, E as EventHandler, b as Events, F as FiltersCountResponse, I as InboxNotification, L as ListNotificationsResponse, g as NotificationStatus, h as NovuError, i as NovuOptions, P as Preference, j as PreferenceLevel, k as PreferencesResponse, l as Schedule, c as SocketEventNames, m as StandardNovuOptions, n as Subscriber, T as TimeRange, U as UnreadCount, W as WebSocketEvent, o as WeeklySchedule, p as WorkflowCriticalityEnum } from './novu-event-emitter-C7GZ7-r1.js';
-export { N as Novu } from './novu-CKWESYFZ.js';
+export * from 'json-logic-js';
+import { S as SeverityLevelEnum, N as NotificationFilter, a as Notification } from './novu-event-emitter-BOA_6GfJ.js';
+export { B as BaseDeleteSubscriptionArgs, f as BaseUpdateSubscriptionArgs, j as ChannelPreference, k as ChannelType, l as Context, C as CreateSubscriptionArgs, m as DaySchedule, n as DefaultSchedule, D as DeleteSubscriptionArgs, E as EventHandler, b as Events, F as FiltersCountResponse, G as GetSubscriptionArgs, o as InboxNotification, I as InstanceDeleteSubscriptionArgs, g as InstanceUpdateSubscriptionArgs, p as ListNotificationsResponse, L as ListSubscriptionsArgs, q as NotificationStatus, K as NovuError, r as NovuOptions, s as Preference, P as PreferenceFilter, t as PreferenceLevel, u as PreferencesResponse, v as Schedule, c as SocketEventNames, w as StandardNovuOptions, x as Subscriber, h as SubscriptionPreference, y as TimeRange, T as TopicSubscription, z as UnreadCount, U as UpdateSubscriptionArgs, i as UpdateSubscriptionPreferenceArgs, A as WebSocketEvent, H as WeeklySchedule, J as WorkflowCriticalityEnum, W as WorkflowFilter, d as WorkflowGroupFilter, e as WorkflowIdentifierOrId } from './novu-event-emitter-BOA_6GfJ.js';
+export { N as Novu } from './novu-DxuaDf-Z.js';
 
 declare const areTagsEqual: (tags1?: string[], tags2?: string[]) => boolean;
 declare const areSeveritiesEqual: (el1?: SeverityLevelEnum | SeverityLevelEnum[], el2?: SeverityLevelEnum | SeverityLevelEnum[]) => boolean;

package/dist/cjs/index.js

@@ -1,56 +1,68 @@
 'use strict';
 
-var chunkMKYWGA37_js = require('./chunk-MKYWGA37.js');
-var chunkWFVHYVDM_js = require('./chunk-WFVHYVDM.js');
+var chunkC6V4UPCA_js = require('./chunk-C6V4UPCA.js');
+var chunkCDGREQFE_js = require('./chunk-CDGREQFE.js');
 require('./chunk-7B52C2XE.js');
 
 
 
 Object.defineProperty(exports, "Novu", {
   enumerable: true,
-  get: function () { return chunkMKYWGA37_js.Novu; }
+  get: function () { return chunkC6V4UPCA_js.Novu; }
+});
+Object.defineProperty(exports, "SubscriptionPreference", {
+  enumerable: true,
+  get: function () { return chunkC6V4UPCA_js.SubscriptionPreference; }
+});
+Object.defineProperty(exports, "TopicSubscription", {
+  enumerable: true,
+  get: function () { return chunkC6V4UPCA_js.TopicSubscription; }
 });
 Object.defineProperty(exports, "areSeveritiesEqual", {
   enumerable: true,
-  get: function () { return chunkMKYWGA37_js.areSeveritiesEqual; }
+  get: function () { return chunkC6V4UPCA_js.areSeveritiesEqual; }
 });
 Object.defineProperty(exports, "areTagsEqual", {
   enumerable: true,
-  get: function () { return chunkMKYWGA37_js.areTagsEqual; }
+  get: function () { return chunkC6V4UPCA_js.areTagsEqual; }
 });
 Object.defineProperty(exports, "checkNotificationDataFilter", {
   enumerable: true,
-  get: function () { return chunkMKYWGA37_js.checkNotificationDataFilter; }
+  get: function () { return chunkC6V4UPCA_js.checkNotificationDataFilter; }
 });
 Object.defineProperty(exports, "checkNotificationMatchesFilter", {
   enumerable: true,
-  get: function () { return chunkMKYWGA37_js.checkNotificationMatchesFilter; }
+  get: function () { return chunkC6V4UPCA_js.checkNotificationMatchesFilter; }
 });
 Object.defineProperty(exports, "isSameFilter", {
   enumerable: true,
-  get: function () { return chunkMKYWGA37_js.isSameFilter; }
+  get: function () { return chunkC6V4UPCA_js.isSameFilter; }
 });
 Object.defineProperty(exports, "ChannelType", {
   enumerable: true,
-  get: function () { return chunkWFVHYVDM_js.ChannelType; }
+  get: function () { return chunkCDGREQFE_js.ChannelType; }
 });
 Object.defineProperty(exports, "NotificationStatus", {
   enumerable: true,
-  get: function () { return chunkWFVHYVDM_js.NotificationStatus; }
+  get: function () { return chunkCDGREQFE_js.NotificationStatus; }
+});
+Object.defineProperty(exports, "NovuError", {
+  enumerable: true,
+  get: function () { return chunkCDGREQFE_js.NovuError; }
 });
 Object.defineProperty(exports, "PreferenceLevel", {
   enumerable: true,
-  get: function () { return chunkWFVHYVDM_js.PreferenceLevel; }
+  get: function () { return chunkCDGREQFE_js.PreferenceLevel; }
 });
 Object.defineProperty(exports, "SeverityLevelEnum", {
   enumerable: true,
-  get: function () { return chunkWFVHYVDM_js.SeverityLevelEnum; }
+  get: function () { return chunkCDGREQFE_js.SeverityLevelEnum; }
 });
 Object.defineProperty(exports, "WebSocketEvent", {
   enumerable: true,
-  get: function () { return chunkWFVHYVDM_js.WebSocketEvent; }
+  get: function () { return chunkCDGREQFE_js.WebSocketEvent; }
 });
 Object.defineProperty(exports, "WorkflowCriticalityEnum", {
   enumerable: true,
-  get: function () { return chunkWFVHYVDM_js.WorkflowCriticalityEnum; }
+  get: function () { return chunkCDGREQFE_js.WorkflowCriticalityEnum; }
 });

package/dist/cjs/internal/index.d.ts

@@ -1,4 +1,5 @@
-import { e as Context, n as Subscriber, r as NovuEventEmitter, q as InboxService, I as InboxNotification, a as Notification } from '../novu-event-emitter-C7GZ7-r1.js';
+import { l as Context, x as Subscriber, O as NovuEventEmitter, M as InboxService, o as InboxNotification, a as Notification } from '../novu-event-emitter-BOA_6GfJ.js';
+import 'json-logic-js';
 
 /**
  * Builds a compact, stable string key from context objects by extracting only type:id pairs.
@@ -19,6 +20,11 @@ declare function buildSubscriber({ subscriberId, subscriber, }: {
     subscriber: Subscriber | string | undefined;
 }): Subscriber;
 
+declare function buildSubscriptionIdentifier({ topicKey, subscriberId }: {
+    topicKey: string;
+    subscriberId?: string;
+}): string;
+
 declare function createNotification({ emitter, inboxService, notification, }: {
     emitter: NovuEventEmitter;
     inboxService: InboxService;
@@ -31,4 +37,4 @@ interface Token {
 }
 declare const parseMarkdownIntoTokens: (text: string) => Token[];
 
-export { type Token, buildContextKey, buildSubscriber, createNotification, parseMarkdownIntoTokens };
+export { type Token, buildContextKey, buildSubscriber, buildSubscriptionIdentifier, createNotification, parseMarkdownIntoTokens };

package/dist/cjs/internal/index.js

@@ -1,23 +1,27 @@
 'use strict';
 
-var chunkWFVHYVDM_js = require('../chunk-WFVHYVDM.js');
+var chunkCDGREQFE_js = require('../chunk-CDGREQFE.js');
 require('../chunk-7B52C2XE.js');
 
 
 
 Object.defineProperty(exports, "buildContextKey", {
   enumerable: true,
-  get: function () { return chunkWFVHYVDM_js.buildContextKey; }
+  get: function () { return chunkCDGREQFE_js.buildContextKey; }
 });
 Object.defineProperty(exports, "buildSubscriber", {
   enumerable: true,
-  get: function () { return chunkWFVHYVDM_js.buildSubscriber; }
+  get: function () { return chunkCDGREQFE_js.buildSubscriber; }
+});
+Object.defineProperty(exports, "buildSubscriptionIdentifier", {
+  enumerable: true,
+  get: function () { return chunkCDGREQFE_js.buildSubscriptionIdentifier; }
 });
 Object.defineProperty(exports, "createNotification", {
   enumerable: true,
-  get: function () { return chunkWFVHYVDM_js.createNotification; }
+  get: function () { return chunkCDGREQFE_js.createNotification; }
 });
 Object.defineProperty(exports, "parseMarkdownIntoTokens", {
   enumerable: true,
-  get: function () { return chunkWFVHYVDM_js.parseMarkdownIntoTokens; }
+  get: function () { return chunkCDGREQFE_js.parseMarkdownIntoTokens; }
 });

package/dist/{esm/novu-3CfttQ8e.d.mts → cjs/novu-DxuaDf-Z.d.ts}

@@ -1,4 +1,4 @@
-import { q as InboxService, r as NovuEventEmitter, s as Session, R as Result, t as ScheduleCache, l as Schedule, u as UpdateScheduleArgs, v as PreferencesCache, w as ListPreferencesArgs, P as Preference, B as BasePreferenceArgs, x as InstancePreferenceArgs, y as ListNotificationsArgs, L as ListNotificationsResponse, I as InboxNotification, a as Notification, N as NotificationFilter, z as FilterCountArgs, A as FilterCountResponse, G as FiltersCountArgs, F as FiltersCountResponse, H as BaseArgs, J as InstanceArgs, K as SnoozeArgs, c as SocketEventNames, M as EventNames, E as EventHandler, b as Events, O as ContextValue, i as NovuOptions, n as Subscriber, e as Context } from './novu-event-emitter-C7GZ7-r1.mjs';
+import { M as InboxService, O as NovuEventEmitter, Q as Session, R as Result, V as ScheduleCache, v as Schedule, X as UpdateScheduleArgs, Y as PreferencesCache, Z as ListPreferencesArgs, s as Preference, _ as BasePreferenceArgs, $ as InstancePreferenceArgs, a0 as ListNotificationsArgs, p as ListNotificationsResponse, o as InboxNotification, a as Notification, N as NotificationFilter, a1 as FilterCountArgs, a2 as FilterCountResponse, a3 as FiltersCountArgs, F as FiltersCountResponse, a4 as BaseArgs, a5 as InstanceArgs, a6 as SnoozeArgs, a7 as SubscriptionsCache, x as Subscriber, L as ListSubscriptionsArgs, a8 as Options, T as TopicSubscription, G as GetSubscriptionArgs, C as CreateSubscriptionArgs, f as BaseUpdateSubscriptionArgs, g as InstanceUpdateSubscriptionArgs, B as BaseDeleteSubscriptionArgs, I as InstanceDeleteSubscriptionArgs, c as SocketEventNames, a9 as EventNames, E as EventHandler, b as Events, aa as ContextValue, r as NovuOptions, l as Context } from './novu-event-emitter-BOA_6GfJ.js';
 
 declare class BaseModule {
     #private;
@@ -130,6 +130,24 @@ declare class Notifications extends BaseModule {
     triggerHelloWorldEvent(): Promise<any>;
 }
 
+declare class Subscriptions extends BaseModule {
+    #private;
+    readonly cache: SubscriptionsCache;
+    constructor({ useCache, inboxServiceInstance, eventEmitterInstance, subscriber, }: {
+        useCache: boolean;
+        inboxServiceInstance: InboxService;
+        eventEmitterInstance: NovuEventEmitter;
+        subscriber: Subscriber;
+    });
+    list(args: ListSubscriptionsArgs, options?: Options): Result<TopicSubscription[]>;
+    get(args: GetSubscriptionArgs, options?: Options): Result<TopicSubscription | null>;
+    create(args: CreateSubscriptionArgs): Result<TopicSubscription>;
+    update(args: BaseUpdateSubscriptionArgs): Result<TopicSubscription>;
+    update(args: InstanceUpdateSubscriptionArgs): Result<TopicSubscription>;
+    delete(args: BaseDeleteSubscriptionArgs): Result<void>;
+    delete(args: InstanceDeleteSubscriptionArgs): Result<void>;
+}
+
 interface BaseSocketInterface {
     isSocketEvent(eventName: string): eventName is SocketEventNames;
     connect(): Result<void>;
@@ -140,6 +158,7 @@ declare class Novu implements Pick<NovuEventEmitter, 'on'> {
     #private;
     readonly notifications: Notifications;
     readonly preferences: Preferences;
+    readonly subscriptions: Subscriptions;
     readonly socket: BaseSocketInterface;
     on: <Key extends EventNames>(eventName: Key, listener: EventHandler<Events[Key]>) => () => void;
     /**
@@ -150,12 +169,20 @@ declare class Novu implements Pick<NovuEventEmitter, 'on'> {
     get applicationIdentifier(): string | undefined;
     get subscriberId(): string | undefined;
     get context(): Partial<Record<string, ContextValue>> | undefined;
+    get options(): NovuOptions;
     get contextKey(): string;
     constructor(options: NovuOptions);
+    private clearCache;
+    /**
+     * @deprecated
+     */
     changeSubscriber(options: {
         subscriber: Subscriber;
         subscriberHash?: string;
     }): Promise<void>;
+    /**
+     * @deprecated
+     */
     changeContext(options: {
         context: Context;
         contextHash?: string;

package/dist/{esm/novu-event-emitter-C7GZ7-r1.d.mts → cjs/novu-event-emitter-BOA_6GfJ.d.ts}

@@ -1,3 +1,5 @@
+import { RulesLogic } from 'json-logic-js';
+
 type HttpClientOptions = {
     apiVersion?: string;
     apiUrl?: string;
@@ -5,6 +7,32 @@ type HttpClientOptions = {
     headers?: Record<string, string>;
 };
 
+declare class SubscriptionsCache {
+    #private;
+    constructor({ emitterInstance, inboxServiceInstance, useCache, }: {
+        emitterInstance: NovuEventEmitter;
+        inboxServiceInstance: InboxService;
+        useCache: boolean;
+    });
+    private handleCreate;
+    private handleUpdate;
+    private handlePreferenceUpdate;
+    private handleBulkPreferenceUpdate;
+    private updateSubscriptionPreferences;
+    private createUpdatedSubscription;
+    private handleDelete;
+    private handleDeleteById;
+    has(args: ListSubscriptionsArgs): boolean;
+    set(args: ListSubscriptionsArgs, data: TopicSubscription[]): void;
+    setOne(args: GetSubscriptionArgs, data: TopicSubscription): void;
+    getAll(args: ListSubscriptionsArgs): TopicSubscription[] | undefined;
+    get(args: GetSubscriptionArgs): TopicSubscription | undefined;
+    invalidate(args: {
+        topicKey: string;
+    }): void;
+    clearAll(): void;
+}
+
 declare class NovuError extends Error {
     originalError: Error;
     constructor(message: string, originalError: unknown);
@@ -258,6 +286,8 @@ type Context = Partial<Record<string, ContextValue>>;
 type PreferencesResponse = {
     level: PreferenceLevel;
     enabled: boolean;
+    condition?: RulesLogic;
+    subscriptionId?: string;
     channels: ChannelPreference;
     overrides?: IPreferenceOverride[];
     workflow?: Workflow;
@@ -275,6 +305,20 @@ type IPreferenceOverride = {
     channel: ChannelType;
     source: PreferenceOverrideSourceEnum;
 };
+type SubscriptionPreferenceResponse = Omit<PreferencesResponse, 'subscriptionId' | 'workflow' | 'schedule' | 'level' | 'channels'> & {
+    subscriptionId: string;
+    workflow: Workflow;
+};
+type SubscriptionResponse = {
+    id: string;
+    identifier: string;
+    name?: string;
+    preferences?: Array<SubscriptionPreferenceResponse>;
+};
+type Options = {
+    refetch?: boolean;
+    useCache?: boolean;
+};
 type Result<D = undefined, E = NovuError> = Promise<{
     data?: D;
     error?: E;
@@ -308,6 +352,99 @@ type Prettify<T> = {
     [K in keyof T]: T[K];
 } & {};
 
+declare class SubscriptionPreference {
+    #private;
+    readonly subscriptionId: string;
+    readonly workflow: Workflow;
+    readonly enabled: boolean;
+    readonly condition?: RulesLogic;
+    constructor(preference: SubscriptionPreferenceResponse, emitter: NovuEventEmitter, inboxService: InboxService, cache: SubscriptionsCache, useCache?: boolean);
+    update(args: {
+        value: boolean | RulesLogic;
+    }): Result<SubscriptionPreference>;
+}
+
+declare class TopicSubscription {
+    #private;
+    readonly id: string;
+    readonly identifier: string;
+    readonly topicKey: string;
+    readonly preferences?: Array<SubscriptionPreference> | undefined;
+    constructor(subscription: SubscriptionResponse & {
+        topicKey: string;
+    }, emitter: NovuEventEmitter, inboxService: InboxService, cache: SubscriptionsCache, useCache?: boolean);
+    update(args: BaseUpdateSubscriptionArgs): Result<TopicSubscription>;
+    update(args: InstanceUpdateSubscriptionArgs): Result<TopicSubscription>;
+    updatePreference(args: BaseSubscriptionPreferenceArgs): Result<SubscriptionPreference>;
+    updatePreference(args: InstanceSubscriptionPreferenceArgs): Result<SubscriptionPreference>;
+    bulkUpdatePreferences(args: Array<BaseSubscriptionPreferenceArgs>): Result<SubscriptionPreference[]>;
+    bulkUpdatePreferences(args: Array<InstanceSubscriptionPreferenceArgs>): Result<SubscriptionPreference[]>;
+    delete(): Result<void>;
+}
+
+type WorkflowIdentifierOrId = string;
+type WorkflowFilter = {
+    workflowId: WorkflowIdentifierOrId;
+    enabled?: boolean;
+    condition?: RulesLogic;
+    filter?: never;
+};
+type WorkflowGroupFilter = {
+    filter: {
+        workflowIds?: Array<WorkflowIdentifierOrId>;
+        tags?: string[];
+    };
+    enabled?: boolean;
+    condition?: RulesLogic;
+    workflowId?: never;
+};
+type PreferenceFilter = WorkflowIdentifierOrId | WorkflowFilter | WorkflowGroupFilter;
+type ListSubscriptionsArgs = {
+    topicKey: string;
+};
+type GetSubscriptionArgs = {
+    topicKey: string;
+    identifier?: string;
+    workflowIds?: string[];
+    tags?: string[];
+};
+type CreateSubscriptionArgs = {
+    topicKey: string;
+    topicName?: string;
+    identifier?: string;
+    name?: string;
+    preferences?: Array<PreferenceFilter> | undefined;
+};
+type BaseUpdateSubscriptionArgs = {
+    topicKey: string;
+    subscriptionId: string;
+    name?: string;
+    preferences?: Array<PreferenceFilter>;
+};
+type InstanceUpdateSubscriptionArgs = {
+    subscription: TopicSubscription;
+    name?: string;
+    preferences?: Array<PreferenceFilter>;
+};
+type UpdateSubscriptionArgs = BaseUpdateSubscriptionArgs | InstanceUpdateSubscriptionArgs;
+type BaseSubscriptionPreferenceArgs = {
+    workflowId: string;
+    value: boolean | RulesLogic;
+};
+type InstanceSubscriptionPreferenceArgs = {
+    preference: SubscriptionPreference;
+    value: boolean | RulesLogic;
+};
+type UpdateSubscriptionPreferenceArgs = BaseSubscriptionPreferenceArgs | InstanceSubscriptionPreferenceArgs;
+type BaseDeleteSubscriptionArgs = {
+    subscriptionId: string;
+    topicKey: string;
+};
+type InstanceDeleteSubscriptionArgs = {
+    subscription: TopicSubscription;
+};
+type DeleteSubscriptionArgs = BaseDeleteSubscriptionArgs | InstanceDeleteSubscriptionArgs;
+
 type InboxServiceOptions = HttpClientOptions;
 declare class InboxService {
     #private;
@@ -410,6 +547,47 @@ declare class InboxService {
     }): Promise<PreferencesResponse>;
     fetchGlobalPreferences(): Promise<PreferencesResponse>;
     triggerHelloWorldEvent(): Promise<unknown>;
+    fetchSubscriptions(topicKey: string): Promise<SubscriptionResponse[]>;
+    getSubscription(topicKey: string, identifier?: string, workflowIds?: string[], tags?: string[]): Promise<SubscriptionResponse | undefined>;
+    createSubscription({ identifier, name, topicKey, topicName, preferences, }: {
+        identifier?: string;
+        name?: string;
+        topicKey: string;
+        topicName?: string;
+        preferences?: Array<PreferenceFilter>;
+    }): Promise<SubscriptionResponse>;
+    updateSubscription({ topicKey, subscriptionId, name, preferences, }: {
+        topicKey: string;
+        subscriptionId: string;
+        name?: string;
+        preferences?: Array<PreferenceFilter>;
+    }): Promise<SubscriptionResponse>;
+    updateSubscriptionPreference({ subscriptionId, workflowId, enabled, condition, email, sms, in_app, chat, push, }: {
+        subscriptionId: string;
+        workflowId: string;
+        enabled?: boolean;
+        condition?: RulesLogic;
+        email?: boolean;
+        sms?: boolean;
+        in_app?: boolean;
+        chat?: boolean;
+        push?: boolean;
+    }): Promise<SubscriptionPreferenceResponse>;
+    bulkUpdateSubscriptionPreferences(preferences: Array<{
+        subscriptionIdOrIdentifier: string;
+        workflowId: string;
+        enabled?: boolean;
+        condition?: RulesLogic;
+        email?: boolean;
+        sms?: boolean;
+        in_app?: boolean;
+        chat?: boolean;
+        push?: boolean;
+    }>): Promise<SubscriptionPreferenceResponse[]>;
+    deleteSubscription({ topicKey, subscriptionId }: {
+        topicKey: string;
+        subscriptionId: string;
+    }): Promise<void>;
 }
 
 declare class Notification implements Pick<NovuEventEmitter, 'on'>, InboxNotification {
@@ -593,6 +771,15 @@ type PreferenceUpdateEvents = BaseEvents<'preference.update', UpdatePreferenceAr
 type PreferencesBulkUpdateEvents = BaseEvents<'preferences.bulk_update', Array<UpdatePreferenceArgs>, Preference[]>;
 type PreferenceScheduleGetEvents = BaseEvents<'preference.schedule.get', undefined, Schedule>;
 type PreferenceScheduleUpdateEvents = BaseEvents<'preference.schedule.update', UpdateScheduleArgs, Schedule>;
+type SubscriptionsFetchEvents = BaseEvents<'subscriptions.list', ListSubscriptionsArgs, TopicSubscription[]>;
+type SubscriptionGetEvents = BaseEvents<'subscription.get', GetSubscriptionArgs, TopicSubscription | null>;
+type SubscriptionCreateEvents = BaseEvents<'subscription.create', CreateSubscriptionArgs, TopicSubscription>;
+type SubscriptionUpdateEvents = BaseEvents<'subscription.update', UpdateSubscriptionArgs, TopicSubscription>;
+type SubscriptionPreferenceUpdateEvents = BaseEvents<'subscription.preference.update', UpdateSubscriptionPreferenceArgs, SubscriptionPreference>;
+type SubscriptionPreferencesBulkUpdateEvents = BaseEvents<'subscription.preferences.bulk_update', Array<UpdateSubscriptionPreferenceArgs & {
+    subscriptionId: string;
+}>, SubscriptionPreference[]>;
+type SubscriptionDeleteEvents = BaseEvents<'subscription.delete', DeleteSubscriptionArgs, void>;
 type SocketConnectEvents = BaseEvents<'socket.connect', {
     socketUrl: string;
 }, undefined>;
@@ -639,6 +826,13 @@ type Events = SessionInitializeEvents & NotificationsFetchEvents & {
     'preference.schedule.get.updated': {
         data: Schedule;
     };
+} & SubscriptionsFetchEvents & SubscriptionGetEvents & SubscriptionCreateEvents & SubscriptionPreferenceUpdateEvents & SubscriptionUpdateEvents & SubscriptionPreferencesBulkUpdateEvents & SubscriptionDeleteEvents & {
+    'subscriptions.list.updated': {
+        data: {
+            topicKey: string;
+            subscriptions: TopicSubscription[];
+        };
+    };
 } & SocketConnectEvents & SocketEvents & NotificationReadEvents & NotificationUnreadEvents & NotificationSeenEvents & NotificationArchiveEvents & NotificationUnarchiveEvents & NotificationDeleteEvents & NotificationSnoozeEvents & NotificationUnsnoozeEvents & NotificationCompleteActionEvents & NotificationRevertActionEvents & NotificationsReadAllEvents & NotificationsSeenAllEvents & NotificationsArchivedAllEvents & NotificationsReadArchivedAllEvents & NotificationsDeletedAllEvents;
 type EventNames = keyof Events;
 type SocketEventNames = keyof SocketEvents;
@@ -652,4 +846,4 @@ declare class NovuEventEmitter {
     emit<Key extends EventNames>(type: Key, event?: Events[Key]): void;
 }
 
-export { type FilterCountResponse as A, type BasePreferenceArgs as B, type ChannelPreference as C, type DaySchedule as D, type EventHandler as E, type FiltersCountResponse as F, type FiltersCountArgs as G, type BaseArgs as H, type InboxNotification as I, type InstanceArgs as J, type SnoozeArgs as K, type ListNotificationsResponse as L, type EventNames as M, type NotificationFilter as N, type ContextValue as O, Preference as P, type Result as R, SeverityLevelEnum as S, type TimeRange as T, type UnreadCount as U, WebSocketEvent as W, Notification as a, type Events as b, type SocketEventNames as c, ChannelType as d, type Context as e, type DefaultSchedule as f, NotificationStatus as g, NovuError as h, type NovuOptions as i, PreferenceLevel as j, type PreferencesResponse as k, Schedule as l, type StandardNovuOptions as m, type Subscriber as n, type WeeklySchedule as o, WorkflowCriticalityEnum as p, InboxService as q, NovuEventEmitter as r, type Session as s, ScheduleCache as t, type UpdateScheduleArgs as u, PreferencesCache as v, type ListPreferencesArgs as w, type InstancePreferenceArgs as x, type ListNotificationsArgs as y, type FilterCountArgs as z };
+export { type InstancePreferenceArgs as $, WebSocketEvent as A, type BaseDeleteSubscriptionArgs as B, type CreateSubscriptionArgs as C, type DeleteSubscriptionArgs as D, type EventHandler as E, type FiltersCountResponse as F, type GetSubscriptionArgs as G, type WeeklySchedule as H, type InstanceDeleteSubscriptionArgs as I, WorkflowCriticalityEnum as J, NovuError as K, type ListSubscriptionsArgs as L, InboxService as M, type NotificationFilter as N, NovuEventEmitter as O, type PreferenceFilter as P, type Session as Q, type Result as R, SeverityLevelEnum as S, TopicSubscription as T, type UpdateSubscriptionArgs as U, ScheduleCache as V, type WorkflowFilter as W, type UpdateScheduleArgs as X, PreferencesCache as Y, type ListPreferencesArgs as Z, type BasePreferenceArgs as _, Notification as a, type ListNotificationsArgs as a0, type FilterCountArgs as a1, type FilterCountResponse as a2, type FiltersCountArgs as a3, type BaseArgs as a4, type InstanceArgs as a5, type SnoozeArgs as a6, SubscriptionsCache as a7, type Options as a8, type EventNames as a9, type ContextValue as aa, type Events as b, type SocketEventNames as c, type WorkflowGroupFilter as d, type WorkflowIdentifierOrId as e, type BaseUpdateSubscriptionArgs as f, type InstanceUpdateSubscriptionArgs as g, SubscriptionPreference as h, type UpdateSubscriptionPreferenceArgs as i, type ChannelPreference as j, ChannelType as k, type Context as l, type DaySchedule as m, type DefaultSchedule as n, type InboxNotification as o, type ListNotificationsResponse as p, NotificationStatus as q, type NovuOptions as r, Preference as s, PreferenceLevel as t, type PreferencesResponse as u, Schedule as v, type StandardNovuOptions as w, type Subscriber as x, type TimeRange as y, type UnreadCount as z };

package/dist/cjs/themes/index.d.ts

@@ -1,7 +1,13 @@
-import { r as Theme } from '../types-CeLsxWJg.js';
-import '../novu-event-emitter-C7GZ7-r1.js';
-import '../novu-CKWESYFZ.js';
+import { G as InboxTheme, Y as SubscriptionTheme } from '../types-Buzm23uF.js';
+import '../novu-event-emitter-BOA_6GfJ.js';
+import 'json-logic-js';
+import '../novu-DxuaDf-Z.js';
 
-declare const dark: Theme;
+declare const inboxDarkTheme: InboxTheme;
+/**
+ * @deprecated Use inboxDarkTheme instead
+ */
+declare const dark: InboxTheme;
+declare const subscriptionDarkTheme: SubscriptionTheme;
 
-export { dark };
+export { dark, inboxDarkTheme, subscriptionDarkTheme };

package/dist/cjs/themes/index.js

@@ -3,7 +3,7 @@
 require('../chunk-7B52C2XE.js');
 
 // src/ui/themes/dark.ts
-var dark = {
+var inboxDarkTheme = {
   variables: {
     colorNeutral: "white",
     colorBackground: "#1A1A1A",
@@ -25,5 +25,21 @@ var dark = {
     bellSeverityGlow: "nt-bg-severity-none-alpha-300 before:nt-bg-severity-none-alpha-300"
   }
 };
+var dark = inboxDarkTheme;
+var subscriptionDarkTheme = {
+  variables: {
+    colorNeutral: "white",
+    colorBackground: "#1A1A1A",
+    colorForeground: "#EDEDEF",
+    colorSecondary: "#383838",
+    colorSecondaryForeground: "#EDEDEF",
+    colorShadow: "black",
+    colorRing: "#E1E4EA",
+    colorStripes: "#FF8447"
+  },
+  elements: {}
+};
 
 exports.dark = dark;
+exports.inboxDarkTheme = inboxDarkTheme;
+exports.subscriptionDarkTheme = subscriptionDarkTheme;