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

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

@@ -1,4 +1,4 @@
-import { j as WeeklySchedule, S as SeverityLevelEnum, k as WorkflowCriticalityEnum, C as ChannelPreference, l as Session, R as Result, P as PreferenceLevel, m as Workflow, n as Prettify, i as Subscriber, c as DefaultSchedule, b as Context, I as InboxNotification, N as NotificationFilter, A as ActionTypeEnum, g as PreferencesResponse, W as WebSocketEvent, o as ContextValue, f as NovuOptions } from './types-BM_9Xx5Z.mjs';
+import { RulesLogic } from 'json-logic-js';
 
 type HttpClientOptions = {
     apiVersion?: string;
@@ -7,6 +7,37 @@ 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);
+}
+
 type ListPreferencesArgs = {
     tags?: string[];
     severity?: SeverityLevelEnum | SeverityLevelEnum[];
@@ -41,19 +72,6 @@ declare class PreferencesCache {
     clearAll(): void;
 }
 
-declare class BaseModule {
-    #private;
-    protected _inboxService: InboxService;
-    protected _emitter: NovuEventEmitter;
-    constructor({ inboxServiceInstance, eventEmitterInstance, }: {
-        inboxServiceInstance: InboxService;
-        eventEmitterInstance: NovuEventEmitter;
-    });
-    protected onSessionSuccess(_: Session): void;
-    protected onSessionError(_: unknown): void;
-    callWithSession<T>(fn: () => Result<T>): Result<T>;
-}
-
 type ScheduleLike = Partial<Pick<Schedule, 'isEnabled' | 'weeklySchedule'>>;
 declare class Schedule {
     #private;
@@ -68,36 +86,6 @@ declare class Schedule {
     update(args: UpdateScheduleArgs): Result<Schedule>;
 }
 
-declare class PreferenceSchedule extends BaseModule {
-    #private;
-    readonly cache: ScheduleCache;
-    constructor({ cache, useCache, inboxServiceInstance, eventEmitterInstance, }: {
-        cache: ScheduleCache;
-        useCache: boolean;
-        inboxServiceInstance: InboxService;
-        eventEmitterInstance: NovuEventEmitter;
-    });
-    get(): Result<Schedule>;
-    update(args: UpdateScheduleArgs): Result<Schedule>;
-}
-
-declare class Preferences extends BaseModule {
-    #private;
-    readonly cache: PreferencesCache;
-    readonly scheduleCache: ScheduleCache;
-    readonly schedule: PreferenceSchedule;
-    constructor({ useCache, inboxServiceInstance, eventEmitterInstance, }: {
-        useCache: boolean;
-        inboxServiceInstance: InboxService;
-        eventEmitterInstance: NovuEventEmitter;
-    });
-    list(args?: ListPreferencesArgs): Result<Preference[]>;
-    update(args: BasePreferenceArgs): Result<Preference>;
-    update(args: InstancePreferenceArgs): Result<Preference>;
-    bulkUpdate(args: Array<BasePreferenceArgs>): Result<Preference[]>;
-    bulkUpdate(args: Array<InstancePreferenceArgs>): Result<Preference[]>;
-}
-
 declare class ScheduleCache {
     #private;
     constructor({ emitterInstance }: {
@@ -134,6 +122,329 @@ declare class Preference {
     }>): Result<Preference>;
 }
 
+declare global {
+    /**
+     * If you want to provide custom types for the notification.data object,
+     * simply redeclare this rule in the global namespace.
+     * Every notification object will use the provided type.
+     */
+    interface NotificationData {
+        [k: string]: unknown;
+    }
+}
+declare enum NotificationStatus {
+    READ = "read",
+    SEEN = "seen",
+    SNOOZED = "snoozed",
+    UNREAD = "unread",
+    UNSEEN = "unseen",
+    UNSNOOZED = "unsnoozed"
+}
+declare enum PreferenceLevel {
+    GLOBAL = "global",
+    TEMPLATE = "template"
+}
+declare enum ChannelType {
+    IN_APP = "in_app",
+    EMAIL = "email",
+    SMS = "sms",
+    CHAT = "chat",
+    PUSH = "push"
+}
+declare enum WebSocketEvent {
+    RECEIVED = "notification_received",
+    UNREAD = "unread_count_changed",
+    UNSEEN = "unseen_count_changed"
+}
+declare enum SeverityLevelEnum {
+    HIGH = "high",
+    MEDIUM = "medium",
+    LOW = "low",
+    NONE = "none"
+}
+declare enum WorkflowCriticalityEnum {
+    CRITICAL = "critical",
+    NON_CRITICAL = "nonCritical",
+    ALL = "all"
+}
+type UnreadCount = {
+    total: number;
+    severity: Record<SeverityLevelEnum, number>;
+};
+type Session = {
+    token: string;
+    /** @deprecated Use unreadCount.total instead */
+    totalUnreadCount: number;
+    unreadCount: UnreadCount;
+    removeNovuBranding: boolean;
+    isDevelopmentMode: boolean;
+    maxSnoozeDurationHours: number;
+    applicationIdentifier?: string;
+    contextKeys?: string[];
+};
+type Subscriber = {
+    id?: string;
+    subscriberId: string;
+    firstName?: string;
+    lastName?: string;
+    email?: string;
+    phone?: string;
+    avatar?: string;
+    locale?: string;
+    data?: Record<string, unknown>;
+    timezone?: string;
+};
+type Redirect = {
+    url: string;
+    target?: '_self' | '_blank' | '_parent' | '_top' | '_unfencedTop';
+};
+declare enum ActionTypeEnum {
+    PRIMARY = "primary",
+    SECONDARY = "secondary"
+}
+type Action = {
+    label: string;
+    isCompleted: boolean;
+    redirect?: Redirect;
+};
+type Workflow = {
+    id: string;
+    identifier: string;
+    name: string;
+    critical: boolean;
+    tags?: string[];
+    severity: SeverityLevelEnum;
+};
+type InboxNotification = {
+    id: string;
+    transactionId: string;
+    subject?: string;
+    body: string;
+    to: Subscriber;
+    isRead: boolean;
+    isSeen: boolean;
+    isArchived: boolean;
+    isSnoozed: boolean;
+    snoozedUntil?: string | null;
+    deliveredAt?: string[];
+    createdAt: string;
+    readAt?: string | null;
+    firstSeenAt?: string | null;
+    archivedAt?: string | null;
+    avatar?: string;
+    primaryAction?: Action;
+    secondaryAction?: Action;
+    channelType: ChannelType;
+    tags?: string[];
+    data?: NotificationData;
+    redirect?: Redirect;
+    workflow?: Workflow;
+    severity: SeverityLevelEnum;
+};
+type NotificationFilter = {
+    tags?: string[];
+    read?: boolean;
+    archived?: boolean;
+    snoozed?: boolean;
+    seen?: boolean;
+    data?: Record<string, unknown>;
+    severity?: SeverityLevelEnum | SeverityLevelEnum[];
+};
+type ChannelPreference = {
+    email?: boolean;
+    sms?: boolean;
+    in_app?: boolean;
+    chat?: boolean;
+    push?: boolean;
+};
+type TimeRange = {
+    start: string;
+    end: string;
+};
+type DaySchedule = {
+    isEnabled: boolean;
+    hours?: Array<TimeRange>;
+};
+type WeeklySchedule = {
+    monday?: DaySchedule;
+    tuesday?: DaySchedule;
+    wednesday?: DaySchedule;
+    thursday?: DaySchedule;
+    friday?: DaySchedule;
+    saturday?: DaySchedule;
+    sunday?: DaySchedule;
+};
+type DefaultSchedule = {
+    isEnabled?: boolean;
+    weeklySchedule?: WeeklySchedule;
+};
+type ContextValue = string | {
+    id: string;
+    data?: Record<string, unknown>;
+};
+type Context = Partial<Record<string, ContextValue>>;
+type PreferencesResponse = {
+    level: PreferenceLevel;
+    enabled: boolean;
+    condition?: RulesLogic;
+    subscriptionId?: string;
+    channels: ChannelPreference;
+    overrides?: IPreferenceOverride[];
+    workflow?: Workflow;
+    schedule?: {
+        isEnabled: boolean;
+        weeklySchedule?: WeeklySchedule;
+    };
+};
+declare enum PreferenceOverrideSourceEnum {
+    SUBSCRIBER = "subscriber",
+    TEMPLATE = "template",
+    WORKFLOW_OVERRIDE = "workflowOverride"
+}
+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;
+}>;
+type KeylessNovuOptions = {} & {
+    [K in string]?: never;
+};
+type StandardNovuOptions = {
+    /** @deprecated Use apiUrl instead  */
+    backendUrl?: string;
+    /** @internal Should be used internally for testing purposes */
+    __userAgent?: string;
+    applicationIdentifier: string;
+    subscriberHash?: string;
+    contextHash?: string;
+    apiUrl?: string;
+    socketUrl?: string;
+    useCache?: boolean;
+    defaultSchedule?: DefaultSchedule;
+    context?: Context;
+} & ({
+    /** @deprecated Use subscriber prop instead */
+    subscriberId: string;
+    subscriber?: never;
+} | {
+    subscriber: Subscriber | string;
+    subscriberId?: never;
+});
+type NovuOptions = KeylessNovuOptions | StandardNovuOptions;
+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;
@@ -236,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 {
@@ -285,28 +637,6 @@ declare class Notification implements Pick<NovuEventEmitter, 'on'>, InboxNotific
     off<Key extends EventNames>(eventName: Key, listener: EventHandler<Events[Key]>): void;
 }
 
-declare class NotificationsCache {
-    #private;
-    constructor({ emitter }: {
-        emitter: NovuEventEmitter;
-    });
-    private updateNotification;
-    private removeNotification;
-    private handleNotificationEvent;
-    private getAggregated;
-    has(args: ListNotificationsArgs): boolean;
-    set(args: ListNotificationsArgs, data: ListNotificationsResponse): void;
-    update(args: ListNotificationsArgs, data: ListNotificationsResponse): void;
-    getAll(args: ListNotificationsArgs): ListNotificationsResponse | undefined;
-    /**
-     * Get unique notifications based on specified filter fields.
-     * The same tags and data can be applied to multiple filters which means that the same notification can be duplicated.
-     */
-    getUniqueNotifications({ tags, read, data, }: Pick<ListNotificationsArgs, 'tags' | 'read' | 'data'>): Array<Notification>;
-    clear(filter: NotificationFilter): void;
-    clearAll(): void;
-}
-
 type ListNotificationsArgs = {
     tags?: string[];
     read?: boolean;
@@ -376,69 +706,6 @@ type UnsnoozeArgs = BaseArgs | InstanceArgs;
 type CompleteArgs = BaseArgs | InstanceArgs;
 type RevertArgs = BaseArgs | InstanceArgs;
 
-declare class Notifications extends BaseModule {
-    #private;
-    readonly cache: NotificationsCache;
-    constructor({ useCache, inboxServiceInstance, eventEmitterInstance, }: {
-        useCache: boolean;
-        inboxServiceInstance: InboxService;
-        eventEmitterInstance: NovuEventEmitter;
-    });
-    get inboxService(): InboxService;
-    list({ limit, ...restOptions }?: ListNotificationsArgs): Result<ListNotificationsResponse>;
-    count(args?: FilterCountArgs): Result<FilterCountResponse>;
-    count(args?: FiltersCountArgs): Result<FiltersCountResponse>;
-    read(args: BaseArgs): Result<Notification>;
-    read(args: InstanceArgs): Result<Notification>;
-    unread(args: BaseArgs): Result<Notification>;
-    unread(args: InstanceArgs): Result<Notification>;
-    seen(args: BaseArgs): Result<Notification>;
-    seen(args: InstanceArgs): Result<Notification>;
-    archive(args: BaseArgs): Result<Notification>;
-    archive(args: InstanceArgs): Result<Notification>;
-    unarchive(args: BaseArgs): Result<Notification>;
-    unarchive(args: InstanceArgs): Result<Notification>;
-    delete(args: BaseArgs): Result<void>;
-    delete(args: InstanceArgs): Result<void>;
-    snooze(args: SnoozeArgs): Result<Notification>;
-    unsnooze(args: BaseArgs): Result<Notification>;
-    unsnooze(args: InstanceArgs): Result<Notification>;
-    completePrimary(args: BaseArgs): Result<Notification>;
-    completePrimary(args: InstanceArgs): Result<Notification>;
-    completeSecondary(args: BaseArgs): Result<Notification>;
-    completeSecondary(args: InstanceArgs): Result<Notification>;
-    revertPrimary(args: BaseArgs): Result<Notification>;
-    revertPrimary(args: InstanceArgs): Result<Notification>;
-    revertSecondary(args: BaseArgs): Result<Notification>;
-    revertSecondary(args: InstanceArgs): Result<Notification>;
-    readAll({ tags, data, }?: {
-        tags?: NotificationFilter['tags'];
-        data?: Record<string, unknown>;
-    }): Result<void>;
-    seenAll(args?: {
-        notificationIds: string[];
-    } | {
-        tags?: NotificationFilter['tags'];
-        data?: Record<string, unknown>;
-    } | {}): Result<void>;
-    archiveAll({ tags, data, }?: {
-        tags?: NotificationFilter['tags'];
-        data?: Record<string, unknown>;
-    }): Result<void>;
-    archiveAllRead({ tags, data }?: {
-        tags?: string[];
-        data?: Record<string, unknown>;
-    }): Result<void>;
-    deleteAll({ tags, data, }?: {
-        tags?: NotificationFilter['tags'];
-        data?: Record<string, unknown>;
-    }): Result<void>;
-    clearCache({ filter }?: {
-        filter?: NotificationFilter;
-    }): void;
-    triggerHelloWorldEvent(): Promise<any>;
-}
-
 type KeylessInitializeSessionArgs = {} & {
     [K in string]?: never;
 };
@@ -504,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>;
@@ -550,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;
@@ -563,36 +846,4 @@ declare class NovuEventEmitter {
     emit<Key extends EventNames>(type: Key, event?: Events[Key]): void;
 }
 
-interface BaseSocketInterface {
-    isSocketEvent(eventName: string): eventName is SocketEventNames;
-    connect(): Result<void>;
-    disconnect(): Result<void>;
-}
-
-declare class Novu implements Pick<NovuEventEmitter, 'on'> {
-    #private;
-    readonly notifications: Notifications;
-    readonly preferences: Preferences;
-    readonly socket: BaseSocketInterface;
-    on: <Key extends EventNames>(eventName: Key, listener: EventHandler<Events[Key]>) => () => void;
-    /**
-     * @deprecated
-     * Use the cleanup function returned by the "on" method instead.
-     */
-    off: <Key extends EventNames>(eventName: Key, listener: EventHandler<Events[Key]>) => void;
-    get applicationIdentifier(): string | undefined;
-    get subscriberId(): string | undefined;
-    get context(): Partial<Record<string, ContextValue>> | undefined;
-    get contextKey(): string;
-    constructor(options: NovuOptions);
-    changeSubscriber(options: {
-        subscriber: Subscriber;
-        subscriberHash?: string;
-    }): Promise<void>;
-    changeContext(options: {
-        context: Context;
-        contextHash?: string;
-    }): Promise<void>;
-}
-
-export { type EventHandler as E, type FiltersCountResponse as F, type ListNotificationsResponse as L, Notification as N, Preference as P, type SocketEventNames as S, type Events as a, Novu as b, Schedule as c };
+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-BjANCN3c.js';
-import '../types-BM_9Xx5Z.js';
-import '../novu-ThMWeiRt.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;