@novu/js 3.11.0 → 3.11.1

package/dist/esm/index.d.mts

@@ -1,7 +1,6 @@
-import { N as Notification } from './novu-DY-mm8Og.mjs';
-export { E as EventHandler, a as Events, F as FiltersCountResponse, L as ListNotificationsResponse, b as Novu, P as Preference, c as Schedule, S as SocketEventNames } from './novu-DY-mm8Og.mjs';
-import { S as SeverityLevelEnum, N as NotificationFilter } from './types-BM_9Xx5Z.mjs';
-export { C as ChannelPreference, a as ChannelType, b as Context, D as DaySchedule, c as DefaultSchedule, I as InboxNotification, d as NotificationStatus, e as NovuError, f as NovuOptions, P as PreferenceLevel, g as PreferencesResponse, h as StandardNovuOptions, i as Subscriber, T as TimeRange, U as UnreadCount, W as WebSocketEvent, j as WeeklySchedule, k as WorkflowCriticalityEnum } from './types-BM_9Xx5Z.mjs';
+import { S as SeverityLevelEnum, N as NotificationFilter, a as Notification } from './novu-event-emitter-C7GZ7-r1.mjs';
+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.mjs';
+export { N as Novu } from './novu-3CfttQ8e.mjs';
 
 declare const areTagsEqual: (tags1?: string[], tags2?: string[]) => boolean;
 declare const areSeveritiesEqual: (el1?: SeverityLevelEnum | SeverityLevelEnum[], el2?: SeverityLevelEnum | SeverityLevelEnum[]) => boolean;

package/dist/esm/index.mjs

@@ -1,3 +1,3 @@
-export { ChannelType, NotificationStatus, Novu, PreferenceLevel, SeverityLevelEnum, WebSocketEvent, WorkflowCriticalityEnum, areSeveritiesEqual, areTagsEqual, checkNotificationDataFilter, checkNotificationMatchesFilter, isSameFilter } from './chunk-UM35OVAD.mjs';
-import './chunk-RZWQYM3H.mjs';
+export { Novu, areSeveritiesEqual, areTagsEqual, checkNotificationDataFilter, checkNotificationMatchesFilter, isSameFilter } from './chunk-76A4RQYD.mjs';
+export { ChannelType, NotificationStatus, PreferenceLevel, SeverityLevelEnum, WebSocketEvent, WorkflowCriticalityEnum } from './chunk-GY4JXBST.mjs';
 import './chunk-STZMOEWR.mjs';

package/dist/esm/internal/index.d.mts

@@ -1,4 +1,4 @@
-import { b as Context, i as Subscriber } from '../types-BM_9Xx5Z.mjs';
+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.mjs';
 
 /**
  * Builds a compact, stable string key from context objects by extracting only type:id pairs.
@@ -19,10 +19,16 @@ declare function buildSubscriber({ subscriberId, subscriber, }: {
     subscriber: Subscriber | string | undefined;
 }): Subscriber;
 
+declare function createNotification({ emitter, inboxService, notification, }: {
+    emitter: NovuEventEmitter;
+    inboxService: InboxService;
+    notification: InboxNotification;
+}): Notification;
+
 interface Token {
     type: 'bold' | 'text';
     content: string;
 }
 declare const parseMarkdownIntoTokens: (text: string) => Token[];
 
-export { type Token, buildContextKey, buildSubscriber, parseMarkdownIntoTokens };
+export { type Token, buildContextKey, buildSubscriber, createNotification, parseMarkdownIntoTokens };

package/dist/esm/internal/index.mjs

@@ -1,2 +1,2 @@
-export { buildContextKey, buildSubscriber, parseMarkdownIntoTokens } from '../chunk-RZWQYM3H.mjs';
+export { buildContextKey, buildSubscriber, createNotification, parseMarkdownIntoTokens } from '../chunk-GY4JXBST.mjs';
 import '../chunk-STZMOEWR.mjs';

package/dist/esm/novu-3CfttQ8e.d.mts

@@ -0,0 +1,165 @@
+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';
+
+declare class BaseModule {
+    #private;
+    _inboxService: InboxService;
+    _emitter: NovuEventEmitter;
+    constructor({ inboxServiceInstance, eventEmitterInstance, }: {
+        inboxServiceInstance: InboxService;
+        eventEmitterInstance: NovuEventEmitter;
+    });
+    protected onSessionSuccess(_: Session): void;
+    protected onSessionError(_: unknown): void;
+    callWithSession<T>(fn: () => Result<T>): Result<T>;
+}
+
+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 NotificationsCache {
+    #private;
+    constructor({ emitter, inboxService }: {
+        emitter: NovuEventEmitter;
+        inboxService: InboxService;
+    });
+    private updateNotification;
+    private removeNotification;
+    private handleNotificationEvent;
+    private getAggregated;
+    get(args: ListNotificationsArgs): ListNotificationsResponse | undefined;
+    has(args: ListNotificationsArgs): boolean;
+    set(args: ListNotificationsArgs, data: ListNotificationsResponse): void;
+    unshift(args: ListNotificationsArgs, notification: InboxNotification): 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;
+}
+
+declare class Notifications extends BaseModule {
+    #private;
+    readonly cache: NotificationsCache;
+    constructor({ useCache, inboxServiceInstance, eventEmitterInstance, }: {
+        useCache: boolean;
+        inboxServiceInstance: InboxService;
+        eventEmitterInstance: NovuEventEmitter;
+    });
+    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>;
+}
+
+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 { Novu as N };

package/dist/esm/{novu-DY-mm8Og.d.mts → novu-event-emitter-C7GZ7-r1.d.mts}

@@ -1,5 +1,3 @@
-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';
-
 type HttpClientOptions = {
     apiVersion?: string;
     apiUrl?: string;
@@ -7,6 +5,11 @@ type HttpClientOptions = {
     headers?: Record<string, string>;
 };
 
+declare class NovuError extends Error {
+    originalError: Error;
+    constructor(message: string, originalError: unknown);
+}
+
 type ListPreferencesArgs = {
     tags?: string[];
     severity?: SeverityLevelEnum | SeverityLevelEnum[];
@@ -41,19 +44,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 +58,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 +94,220 @@ 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;
+    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 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];
+} & {};
+
 type InboxServiceOptions = HttpClientOptions;
 declare class InboxService {
     #private;
@@ -285,28 +459,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 +528,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;
 };
@@ -563,36 +652,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 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 };

package/dist/esm/themes/index.d.mts

@@ -1,6 +1,6 @@
-import { r as Theme } from '../types-C5eX1GmB.mjs';
-import '../types-BM_9Xx5Z.mjs';
-import '../novu-DY-mm8Og.mjs';
+import { r as Theme } from '../types-4YuozpWu.mjs';
+import '../novu-event-emitter-C7GZ7-r1.mjs';
+import '../novu-3CfttQ8e.mjs';
 
 declare const dark: Theme;
 

package/dist/esm/{types-C5eX1GmB.d.mts → types-4YuozpWu.d.mts}

@@ -1,5 +1,5 @@
-import { U as UnreadCount, N as NotificationFilter, k as WorkflowCriticalityEnum, f as NovuOptions } from './types-BM_9Xx5Z.mjs';
-import { N as Notification, P as Preference, c as Schedule, b as Novu } from './novu-DY-mm8Og.mjs';
+import { a as Notification, U as UnreadCount, N as NotificationFilter, P as Preference, l as Schedule, p as WorkflowCriticalityEnum, i as NovuOptions } from './novu-event-emitter-C7GZ7-r1.mjs';
+import { N as Novu } from './novu-3CfttQ8e.mjs';
 
 declare const appearanceKeys: readonly ["button", "input", "icon", "badge", "popoverContent", "popoverTrigger", "popoverClose", "dropdownContent", "dropdownTrigger", "dropdownItem", "dropdownItemLabel", "dropdownItemLabelContainer", "dropdownItemLeft__icon", "dropdownItemRight__icon", "dropdownItem__icon", "collapsible", "tooltipContent", "tooltipTrigger", "datePicker", "datePickerGrid", "datePickerGridRow", "datePickerGridCell", "datePickerGridCellTrigger", "datePickerTrigger", "datePickerGridHeader", "datePickerControl", "datePickerControlPrevTrigger", "datePickerControlNextTrigger", "datePickerControlPrevTrigger__icon", "datePickerControlNextTrigger__icon", "datePickerCalendar", "datePickerHeaderMonth", "datePickerCalendarDay__button", "timePicker", "timePicker__hourSelect", "timePicker__minuteSelect", "timePicker__periodSelect", "timePicker__separator", "timePickerHour__input", "timePickerMinute__input", "snoozeDatePicker", "snoozeDatePicker__actions", "snoozeDatePickerCancel__button", "snoozeDatePickerApply__button", "snoozeDatePicker__timePickerContainer", "snoozeDatePicker__timePickerLabel", "back__button", "skeletonText", "skeletonAvatar", "skeletonSwitch", "skeletonSwitchThumb", "tabsRoot", "tabsList", "tabsContent", "tabsTrigger", "dots", "root", "bellIcon", "lockIcon", "bellContainer", "severityHigh__bellContainer", "severityMedium__bellContainer", "severityLow__bellContainer", "bellSeverityGlow", "severityGlowHigh__bellSeverityGlow", "severityGlowMedium__bellSeverityGlow", "severityGlowLow__bellSeverityGlow", "bellDot", "preferences__button", "preferencesContainer", "inboxHeader", "loading", "inboxContent", "inbox__popoverTrigger", "inbox__popoverContent", "notificationListContainer", "notificationList", "notificationListEmptyNoticeContainer", "notificationListEmptyNoticeOverlay", "notificationListEmptyNoticeIcon", "notificationListEmptyNotice", "notificationList__skeleton", "notificationList__skeletonContent", "notificationList__skeletonItem", "notificationList__skeletonAvatar", "notificationList__skeletonText", "notificationListNewNotificationsNotice__button", "notification", "severityHigh__notification", "severityMedium__notification", "severityLow__notification", "notificationBar", "severityHigh__notificationBar", "severityMedium__notificationBar", "severityLow__notificationBar", "notificationContent", "notificationTextContainer", "notificationDot", "notificationSubject", "notificationSubject__strong", "notificationBody", "notificationBody__strong", "notificationBodyContainer", "notificationImage", "notificationImageLoadingFallback", "notificationDate", "notificationDateActionsContainer", "notificationDefaultActions", "notificationCustomActions", "notificationPrimaryAction__button", "notificationSecondaryAction__button", "notificationRead__button", "notificationUnread__button", "notificationArchive__button", "notificationUnarchive__button", "notificationSnooze__button", "notificationUnsnooze__button", "notificationRead__icon", "notificationUnread__icon", "notificationArchive__icon", "notificationUnarchive__icon", "notificationSnooze__icon", "notificationUnsnooze__icon", "notificationsTabs__tabsRoot", "notificationsTabs__tabsList", "notificationsTabs__tabsContent", "notificationsTabs__tabsTrigger", "notificationsTabsTriggerLabel", "notificationsTabsTriggerCount", "inboxStatus__title", "inboxStatus__dropdownTrigger", "inboxStatus__dropdownContent", "inboxStatus__dropdownItem", "inboxStatus__dropdownItemLabel", "inboxStatus__dropdownItemLabelContainer", "inboxStatus__dropdownItemLeft__icon", "inboxStatus__dropdownItemRight__icon", "inboxStatus__dropdownItem__icon", "inboxStatus__dropdownItemCheck__icon", "moreActionsContainer", "moreActions__dropdownTrigger", "moreActions__dropdownContent", "moreActions__dropdownItem", "moreActions__dropdownItemLabel", "moreActions__dropdownItemLeft__icon", "moreActions__dots", "moreTabs__button", "moreTabs__icon", "moreTabs__dropdownTrigger", "moreTabs__dropdownContent", "moreTabs__dropdownItem", "moreTabs__dropdownItemLabel", "moreTabs__dropdownItemRight__icon", "workflowContainer", "workflowLabel", "workflowLabelHeader", "workflowLabelHeaderContainer", "workflowLabelIcon", "workflowLabelContainer", "workflowContainerDisabledNotice", "workflowLabelDisabled__icon", "workflowContainerRight__icon", "workflowArrow__icon", "workflowDescription", "preferencesGroupContainer", "preferencesGroupHeader", "preferencesGroupLabelContainer", "preferencesGroupLabelIcon", "preferencesGroupLabel", "preferencesGroupActionsContainer", "preferencesGroupActionsContainerRight__icon", "preferencesGroupBody", "preferencesGroupChannels", "preferencesGroupInfo", "preferencesGroupInfoIcon", "preferencesGroupWorkflows", "channelContainer", "channelIconContainer", "channel__icon", "channelsContainerCollapsible", "channelsContainer", "channelLabel", "channelLabelContainer", "channelName", "channelSwitchContainer", "channelSwitch", "channelSwitchThumb", "preferencesHeader", "preferencesHeader__back__button", "preferencesHeader__back__button__icon", "preferencesHeader__title", "preferencesHeader__icon", "preferencesListEmptyNoticeContainer", "preferencesListEmptyNotice", "preferencesList__skeleton", "preferencesList__skeletonContent", "preferencesList__skeletonItem", "preferencesList__skeletonIcon", "preferencesList__skeletonSwitch", "preferencesList__skeletonSwitchThumb", "preferencesList__skeletonText", "scheduleContainer", "scheduleHeader", "scheduleLabelContainer", "scheduleLabelScheduleIcon", "scheduleLabelInfoIcon", "scheduleLabel", "scheduleActionsContainer", "scheduleActionsContainerRight", "scheduleBody", "scheduleDescription", "scheduleTable", "scheduleTableHeader", "scheduleHeaderColumn", "scheduleTableBody", "scheduleBodyRow", "scheduleBodyColumn", "scheduleInfoContainer", "scheduleInfoIcon", "scheduleInfo", "dayScheduleCopyTitle", "dayScheduleCopyIcon", "dayScheduleCopySelectAll", "dayScheduleCopyDay", "dayScheduleCopyFooterContainer", "dayScheduleCopy__dropdownTrigger", "dayScheduleCopy__dropdownContent", "timeSelect__dropdownTrigger", "timeSelect__time", "timeSelect__dropdownContent", "timeSelect__dropdownItem", "timeSelect__dropdownItemLabel", "timeSelect__dropdownItemLabelContainer", "timeSelect__dropdownItemCheck__icon", "notificationSnooze__dropdownContent", "notificationSnooze__dropdownItem", "notificationSnooze__dropdownItem__icon", "notificationSnoozeCustomTime_popoverContent", "notificationDeliveredAt__badge", "notificationDeliveredAt__icon", "notificationSnoozedUntil__icon", "strong"];