@novu/js 3.11.0 → 3.12.0-rc.2

package/dist/{cjs/novu-ThMWeiRt.d.ts → esm/novu-YP3PwsQR.d.mts}

@@ -1,4 +1,5 @@
-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.js';
+import { I as InboxNotification, R as Result, m as Session, N as NotificationFilter, S as SeverityLevelEnum, i as WeeklySchedule, j as WorkflowCriticalityEnum, C as ChannelPreference, P as PreferenceLevel, n as Workflow, o as Prettify, p as SubscriptionPreferenceResponse, l as NonEmptyArray, h as Subscriber, c as DefaultSchedule, b as Context, A as ActionTypeEnum, f as PreferencesResponse, q as SubscriptionResponse, O as Options, W as WebSocketEvent, r as ContextValue, e as NovuOptions } from './types-D-9ozWeQ.mjs';
+import { RulesLogic } from 'json-logic-js';
 
 type HttpClientOptions = {
     apiVersion?: string;
@@ -7,6 +8,220 @@ type HttpClientOptions = {
     headers?: Record<string, string>;
 };
 
+declare class Notification implements Pick<NovuEventEmitter, 'on'>, InboxNotification {
+    #private;
+    readonly id: InboxNotification['id'];
+    readonly transactionId: InboxNotification['transactionId'];
+    readonly subject?: InboxNotification['subject'];
+    readonly body: InboxNotification['body'];
+    readonly to: InboxNotification['to'];
+    readonly isRead: InboxNotification['isRead'];
+    readonly isSeen: InboxNotification['isSeen'];
+    readonly isArchived: InboxNotification['isArchived'];
+    readonly isSnoozed: InboxNotification['isSnoozed'];
+    readonly snoozedUntil?: InboxNotification['snoozedUntil'];
+    readonly deliveredAt?: InboxNotification['deliveredAt'];
+    readonly createdAt: InboxNotification['createdAt'];
+    readonly readAt?: InboxNotification['readAt'];
+    readonly firstSeenAt?: InboxNotification['firstSeenAt'];
+    readonly archivedAt?: InboxNotification['archivedAt'];
+    readonly avatar?: InboxNotification['avatar'];
+    readonly primaryAction?: InboxNotification['primaryAction'];
+    readonly secondaryAction?: InboxNotification['secondaryAction'];
+    readonly channelType: InboxNotification['channelType'];
+    readonly tags: InboxNotification['tags'];
+    readonly redirect: InboxNotification['redirect'];
+    readonly data?: InboxNotification['data'];
+    readonly workflow?: InboxNotification['workflow'];
+    readonly severity: InboxNotification['severity'];
+    constructor(notification: InboxNotification, emitter: NovuEventEmitter, inboxService: InboxService);
+    read(): Result<Notification>;
+    unread(): Result<Notification>;
+    seen(): Result<Notification>;
+    archive(): Result<Notification>;
+    unarchive(): Result<Notification>;
+    delete(): Result<void>;
+    snooze(snoozeUntil: string): Result<Notification>;
+    unsnooze(): Result<Notification>;
+    completePrimary(): Result<Notification>;
+    completeSecondary(): Result<Notification>;
+    revertPrimary(): Result<Notification>;
+    revertSecondary(): Result<Notification>;
+    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;
+}
+
+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>;
+}
+
+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;
+    data?: Record<string, unknown>;
+    archived?: boolean;
+    snoozed?: boolean;
+    seen?: boolean;
+    severity?: SeverityLevelEnum | SeverityLevelEnum[];
+    limit?: number;
+    after?: string;
+    offset?: number;
+    useCache?: boolean;
+};
+type ListNotificationsResponse = {
+    notifications: Notification[];
+    hasMore: boolean;
+    filter: NotificationFilter;
+};
+type FilterCountArgs = {
+    tags?: string[];
+    data?: Record<string, unknown>;
+    read?: boolean;
+    archived?: boolean;
+    snoozed?: boolean;
+    seen?: boolean;
+    severity?: SeverityLevelEnum | SeverityLevelEnum[];
+};
+type FiltersCountArgs = {
+    filters: Array<{
+        tags?: string[];
+        read?: boolean;
+        archived?: boolean;
+        snoozed?: boolean;
+        seen?: boolean;
+        data?: Record<string, unknown>;
+        severity?: SeverityLevelEnum | SeverityLevelEnum[];
+    }>;
+};
+type CountArgs = undefined | FilterCountArgs | FiltersCountArgs;
+type FilterCountResponse = {
+    count: number;
+    filter: NotificationFilter;
+};
+type FiltersCountResponse = {
+    counts: Array<{
+        count: number;
+        filter: NotificationFilter;
+    }>;
+};
+type CountResponse = FilterCountResponse | FiltersCountResponse;
+type BaseArgs = {
+    notificationId: string;
+};
+type InstanceArgs = {
+    notification: Notification;
+};
+type ReadArgs = BaseArgs | InstanceArgs;
+type UnreadArgs = BaseArgs | InstanceArgs;
+type ArchivedArgs = BaseArgs | InstanceArgs;
+type UnarchivedArgs = BaseArgs | InstanceArgs;
+type DeletedArgs = BaseArgs | InstanceArgs;
+type SeenArgs = BaseArgs | InstanceArgs;
+type SnoozeArgs = (BaseArgs | InstanceArgs) & {
+    snoozeUntil: string;
+};
+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 ListPreferencesArgs = {
     tags?: string[];
     severity?: SeverityLevelEnum | SeverityLevelEnum[];
@@ -41,19 +256,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;
@@ -134,6 +336,79 @@ declare class Preference {
     }>): Result<Preference>;
 }
 
+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>;
+}
+
+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;
+};
+type CreateSubscriptionArgs = {
+    topicKey: string;
+    topicName?: string;
+    identifier?: string;
+    name?: string;
+    preferences: NonEmptyArray<PreferenceFilter>;
+};
+type BaseUpdateSubscriptionArgs = {
+    topicKey: string;
+    subscriptionId: string;
+    name?: string;
+    preferences?: NonEmptyArray<PreferenceFilter>;
+};
+type InstanceUpdateSubscriptionArgs = {
+    subscription: TopicSubscription;
+    name?: string;
+    preferences?: NonEmptyArray<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,207 +511,102 @@ declare class InboxService {
     }): Promise<PreferencesResponse>;
     fetchGlobalPreferences(): Promise<PreferencesResponse>;
     triggerHelloWorldEvent(): Promise<unknown>;
+    fetchSubscriptions(topicKey: string): Promise<SubscriptionResponse[]>;
+    getSubscription({ topicKey, identifier, }: {
+        topicKey: string;
+        identifier: 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, }: {
+        subscriptionId: string;
+        workflowId: string;
+        enabled?: boolean;
+        condition?: RulesLogic;
+    }): Promise<SubscriptionPreferenceResponse>;
+    bulkUpdateSubscriptionPreferences(preferences: Array<{
+        subscriptionIdOrIdentifier: string;
+        workflowId: string;
+        enabled?: boolean;
+        condition?: RulesLogic;
+    }>): Promise<SubscriptionPreferenceResponse[]>;
+    deleteSubscription({ topicKey, subscriptionId }: {
+        topicKey: string;
+        subscriptionId: string;
+    }): Promise<void>;
 }
 
-declare class Notification implements Pick<NovuEventEmitter, 'on'>, InboxNotification {
-    #private;
-    readonly id: InboxNotification['id'];
-    readonly transactionId: InboxNotification['transactionId'];
-    readonly subject?: InboxNotification['subject'];
-    readonly body: InboxNotification['body'];
-    readonly to: InboxNotification['to'];
-    readonly isRead: InboxNotification['isRead'];
-    readonly isSeen: InboxNotification['isSeen'];
-    readonly isArchived: InboxNotification['isArchived'];
-    readonly isSnoozed: InboxNotification['isSnoozed'];
-    readonly snoozedUntil?: InboxNotification['snoozedUntil'];
-    readonly deliveredAt?: InboxNotification['deliveredAt'];
-    readonly createdAt: InboxNotification['createdAt'];
-    readonly readAt?: InboxNotification['readAt'];
-    readonly firstSeenAt?: InboxNotification['firstSeenAt'];
-    readonly archivedAt?: InboxNotification['archivedAt'];
-    readonly avatar?: InboxNotification['avatar'];
-    readonly primaryAction?: InboxNotification['primaryAction'];
-    readonly secondaryAction?: InboxNotification['secondaryAction'];
-    readonly channelType: InboxNotification['channelType'];
-    readonly tags: InboxNotification['tags'];
-    readonly redirect: InboxNotification['redirect'];
-    readonly data?: InboxNotification['data'];
-    readonly workflow?: InboxNotification['workflow'];
-    readonly severity: InboxNotification['severity'];
-    constructor(notification: InboxNotification, emitter: NovuEventEmitter, inboxService: InboxService);
-    read(): Result<Notification>;
-    unread(): Result<Notification>;
-    seen(): Result<Notification>;
-    archive(): Result<Notification>;
-    unarchive(): Result<Notification>;
-    delete(): Result<void>;
-    snooze(snoozeUntil: string): Result<Notification>;
-    unsnooze(): Result<Notification>;
-    completePrimary(): Result<Notification>;
-    completeSecondary(): Result<Notification>;
-    revertPrimary(): Result<Notification>;
-    revertSecondary(): Result<Notification>;
-    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;
-}
-
-declare class NotificationsCache {
+declare class SubscriptionsCache {
     #private;
-    constructor({ emitter }: {
-        emitter: NovuEventEmitter;
+    constructor({ emitterInstance, inboxServiceInstance, useCache, }: {
+        emitterInstance: NovuEventEmitter;
+        inboxServiceInstance: InboxService;
+        useCache: boolean;
     });
-    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;
+    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;
 }
 
-type ListNotificationsArgs = {
-    tags?: string[];
-    read?: boolean;
-    data?: Record<string, unknown>;
-    archived?: boolean;
-    snoozed?: boolean;
-    seen?: boolean;
-    severity?: SeverityLevelEnum | SeverityLevelEnum[];
-    limit?: number;
-    after?: string;
-    offset?: number;
-    useCache?: boolean;
-};
-type ListNotificationsResponse = {
-    notifications: Notification[];
-    hasMore: boolean;
-    filter: NotificationFilter;
-};
-type FilterCountArgs = {
-    tags?: string[];
-    data?: Record<string, unknown>;
-    read?: boolean;
-    archived?: boolean;
-    snoozed?: boolean;
-    seen?: boolean;
-    severity?: SeverityLevelEnum | SeverityLevelEnum[];
-};
-type FiltersCountArgs = {
-    filters: Array<{
-        tags?: string[];
-        read?: boolean;
-        archived?: boolean;
-        snoozed?: boolean;
-        seen?: boolean;
-        data?: Record<string, unknown>;
-        severity?: SeverityLevelEnum | SeverityLevelEnum[];
-    }>;
-};
-type CountArgs = undefined | FilterCountArgs | FiltersCountArgs;
-type FilterCountResponse = {
-    count: number;
-    filter: NotificationFilter;
-};
-type FiltersCountResponse = {
-    counts: Array<{
-        count: number;
-        filter: NotificationFilter;
-    }>;
-};
-type CountResponse = FilterCountResponse | FiltersCountResponse;
-type BaseArgs = {
-    notificationId: string;
-};
-type InstanceArgs = {
-    notification: Notification;
-};
-type ReadArgs = BaseArgs | InstanceArgs;
-type UnreadArgs = BaseArgs | InstanceArgs;
-type ArchivedArgs = BaseArgs | InstanceArgs;
-type UnarchivedArgs = BaseArgs | InstanceArgs;
-type DeletedArgs = BaseArgs | InstanceArgs;
-type SeenArgs = BaseArgs | InstanceArgs;
-type SnoozeArgs = (BaseArgs | InstanceArgs) & {
-    snoozeUntil: string;
-};
-type UnsnoozeArgs = BaseArgs | InstanceArgs;
-type CompleteArgs = BaseArgs | InstanceArgs;
-type RevertArgs = BaseArgs | InstanceArgs;
+declare class TopicSubscription {
+    #private;
+    readonly id: string;
+    readonly identifier: string;
+    readonly topicKey: string;
+    readonly preferences: Array<SubscriptionPreference>;
+    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>;
+}
 
-declare class Notifications extends BaseModule {
+declare class Subscriptions extends BaseModule {
     #private;
-    readonly cache: NotificationsCache;
-    constructor({ useCache, inboxServiceInstance, eventEmitterInstance, }: {
+    readonly cache: SubscriptionsCache;
+    constructor({ useCache, inboxServiceInstance, eventEmitterInstance, subscriber, }: {
         useCache: boolean;
         inboxServiceInstance: InboxService;
         eventEmitterInstance: NovuEventEmitter;
+        subscriber: Subscriber;
     });
-    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>;
+    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>;
 }
 
 type KeylessInitializeSessionArgs = {} & {
@@ -504,6 +674,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 +729,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;
@@ -573,6 +759,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;
     /**
@@ -583,16 +770,24 @@ 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;
     }): 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 BaseDeleteSubscriptionArgs as B, type CreateSubscriptionArgs as C, type DeleteSubscriptionArgs as D, type EventHandler as E, type FiltersCountResponse as F, type GetSubscriptionArgs as G, type InstanceDeleteSubscriptionArgs as I, type ListSubscriptionsArgs as L, Notification as N, type PreferenceFilter as P, type SocketEventNames as S, TopicSubscription as T, type UpdateSubscriptionArgs as U, type WorkflowFilter as W, type Events as a, Novu as b, type WorkflowGroupFilter as c, type WorkflowIdentifierOrId as d, type BaseUpdateSubscriptionArgs as e, type InstanceUpdateSubscriptionArgs as f, SubscriptionPreference as g, type UpdateSubscriptionPreferenceArgs as h, type ListNotificationsResponse as i, Preference as j, Schedule as k };