@novu/js 3.15.0 → 3.17.0-rc.d0046861c6

package/dist/{esm/novu-event-emitter-D9AphR7g.d.mts → cjs/inbox-service-CGCuuYnv.d.ts}

@@ -6,32 +6,6 @@ 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 handleDeleteByIdentifier;
-    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);
@@ -121,280 +95,117 @@ 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"
-}
-type SocketTypeOption = 'cloud' | 'self-hosted';
-type NovuSocketOptions = {
-    socketType?: SocketTypeOption;
-    [key: string]: unknown;
-};
-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 KeylessInitializeSessionArgs = {} & {
+    [K in string]?: never;
 };
-type Session = {
-    token: string;
-    /** @deprecated Use unreadCount.total instead */
-    totalUnreadCount: number;
-    unreadCount: UnreadCount;
-    removeNovuBranding: boolean;
-    isDevelopmentMode: boolean;
-    maxSnoozeDurationHours: number;
-    applicationIdentifier?: string;
-    contextKeys?: string[];
+type InitializeSessionArgs = KeylessInitializeSessionArgs | {
+    applicationIdentifier: string;
+    subscriber: Subscriber;
+    subscriberHash?: string;
+    contextHash?: string;
+    defaultSchedule?: DefaultSchedule;
+    context?: Context;
 };
-type Subscriber = {
-    id?: string;
-    subscriberId: string;
-    firstName?: string;
-    lastName?: string;
-    email?: string;
-    phone?: string;
-    avatar?: string;
-    locale?: string;
-    data?: Record<string, unknown>;
-    timezone?: string;
+
+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 Redirect = {
-    url: string;
-    target?: '_self' | '_blank' | '_parent' | '_top' | '_unfencedTop';
+type WorkflowGroupFilter = {
+    filter: {
+        workflowIds?: Array<WorkflowIdentifierOrId>;
+        tags?: string[];
+    };
+    enabled?: boolean;
+    condition?: RulesLogic;
+    workflowId?: never;
 };
-declare enum ActionTypeEnum {
-    PRIMARY = "primary",
-    SECONDARY = "secondary"
-}
-type Action = {
-    label: string;
-    isCompleted: boolean;
-    redirect?: Redirect;
+type PreferenceFilter = WorkflowIdentifierOrId | WorkflowFilter | WorkflowGroupFilter;
+type ListSubscriptionsArgs = {
+    topicKey: string;
 };
-type Workflow = {
-    id: string;
-    identifier: string;
-    name: string;
-    critical: boolean;
+type GetSubscriptionArgs = {
+    topicKey: string;
+    identifier?: string;
+    workflowIds?: string[];
     tags?: string[];
-    severity: SeverityLevelEnum;
 };
-type TagsFilterOrGroup = {
-    or: string[];
+type CreateSubscriptionArgs = {
+    topicKey: string;
+    topicName?: string;
+    identifier?: string;
+    name?: string;
+    preferences?: Array<PreferenceFilter> | undefined;
 };
-type TagsFilterAndForm = {
-    and: TagsFilterOrGroup[];
+type BaseUpdateSubscriptionArgs = {
+    topicKey: string;
+    identifier: string;
+    name?: string;
+    preferences?: Array<PreferenceFilter>;
 };
-/**
- * Inbox tag filter: a **single** OR-group as `string[]` or `{ or: string[] }`, or **multiple** OR-groups (AND of OR) as `{ and: [{ or: string[] }, ...] }`.
- *
- * @example Single OR-group — match notifications tagged `promo` **or** `sale`
- * ```ts
- * const tags: TagsFilter = ['promo', 'sale'];
- * ```
- *
- * @example AND of OR-groups — match (`urgent` **or** `critical`) **and** (`billing`)
- * ```ts
- * const tags: TagsFilter = {
- *   and: [{ or: ['urgent', 'critical'] }, { or: ['billing'] }],
- * };
- * ```
- */
-type TagsFilter = string[] | TagsFilterOrGroup | TagsFilterAndForm;
-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 InstanceUpdateSubscriptionArgs = {
+    subscription: TopicSubscription;
+    name?: string;
+    preferences?: Array<PreferenceFilter>;
 };
-type NotificationFilter = {
-    tags?: TagsFilter;
-    read?: boolean;
-    archived?: boolean;
-    snoozed?: boolean;
-    seen?: boolean;
-    data?: Record<string, unknown>;
-    severity?: SeverityLevelEnum | SeverityLevelEnum[];
-    createdGte?: number;
-    createdLte?: number;
+type UpdateSubscriptionArgs = BaseUpdateSubscriptionArgs | InstanceUpdateSubscriptionArgs;
+type BaseSubscriptionPreferenceArgs = {
+    workflowId: string;
+    value: boolean | RulesLogic;
 };
-type ChannelPreference = {
-    email?: boolean;
-    sms?: boolean;
-    in_app?: boolean;
-    chat?: boolean;
-    push?: boolean;
+type InstanceSubscriptionPreferenceArgs = {
+    preference: SubscriptionPreference;
+    value: boolean | RulesLogic;
 };
-type TimeRange = {
-    start: string;
-    end: string;
+type UpdateSubscriptionPreferenceArgs = BaseSubscriptionPreferenceArgs | InstanceSubscriptionPreferenceArgs;
+type BaseDeleteSubscriptionArgs = {
+    identifier: string;
+    topicKey: string;
 };
-type DaySchedule = {
-    isEnabled: boolean;
-    hours?: Array<TimeRange>;
+type InstanceDeleteSubscriptionArgs = {
+    subscription: TopicSubscription;
 };
-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;
-    applicationIdentifier: string;
-    subscriberHash?: string;
-    contextHash?: string;
-    apiUrl?: string;
-    socketUrl?: string;
-    /**
-     * Custom socket configuration options. These options will be merged with the default socket configuration.
-     * Use `socketType` to explicitly select the socket implementation: `'cloud'` for PartySocket or `'self-hosted'` for socket.io.
-     * For socket.io-client connections, supports all socket.io-client options (e.g., `path`, `reconnectionDelay`, `timeout`, etc.).
-     * For PartySocket connections, options are applied to the WebSocket instance.
-     */
-    socketOptions?: NovuSocketOptions;
-    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 DeleteSubscriptionArgs = BaseDeleteSubscriptionArgs | InstanceDeleteSubscriptionArgs;
 
-declare class SubscriptionPreference {
+declare class SubscriptionsCache {
     #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>;
+    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 handleDeleteByIdentifier;
+    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 TopicSubscription {
@@ -415,214 +226,145 @@ declare class TopicSubscription {
     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;
-    identifier: string;
-    name?: string;
-    preferences?: Array<PreferenceFilter>;
+type NovuPendingEvent<A, D = undefined> = {
+    args: A;
+    data?: D;
 };
-type InstanceUpdateSubscriptionArgs = {
-    subscription: TopicSubscription;
-    name?: string;
-    preferences?: Array<PreferenceFilter>;
+type NovuResolvedEvent<A, D> = NovuPendingEvent<A, D> & {
+    error?: unknown;
 };
-type UpdateSubscriptionArgs = BaseUpdateSubscriptionArgs | InstanceUpdateSubscriptionArgs;
-type BaseSubscriptionPreferenceArgs = {
-    workflowId: string;
-    value: boolean | RulesLogic;
+type EventName<T extends string> = `${T}.pending` | `${T}.resolved`;
+type EventStatus<T extends string> = `${T extends `${infer _}.${infer __}.${infer V}` ? V : never}`;
+type EventObject<K extends string, ARGS, DATA, EVENT_STATUS = EventStatus<K>> = EVENT_STATUS extends 'pending' ? NovuPendingEvent<ARGS, DATA> : NovuResolvedEvent<ARGS, DATA>;
+type BaseEvents<T extends string, ARGS, DATA> = {
+    [key in `${EventName<T>}`]: EventObject<key, ARGS, DATA>;
 };
-type InstanceSubscriptionPreferenceArgs = {
-    preference: SubscriptionPreference;
-    value: boolean | RulesLogic;
+type SessionInitializeEvents = BaseEvents<'session.initialize', InitializeSessionArgs, Session>;
+type NotificationsFetchEvents = BaseEvents<'notifications.list', ListNotificationsArgs, ListNotificationsResponse>;
+type NotificationsFetchCountEvents = BaseEvents<'notifications.count', CountArgs, CountResponse>;
+type NotificationReadEvents = BaseEvents<'notification.read', ReadArgs, Notification>;
+type NotificationUnreadEvents = BaseEvents<'notification.unread', UnreadArgs, Notification>;
+type NotificationSeenEvents = BaseEvents<'notification.seen', SeenArgs, Notification>;
+type NotificationArchiveEvents = BaseEvents<'notification.archive', ArchivedArgs, Notification>;
+type NotificationUnarchiveEvents = BaseEvents<'notification.unarchive', UnarchivedArgs, Notification>;
+type NotificationDeleteEvents = BaseEvents<'notification.delete', DeletedArgs, Notification>;
+type NotificationSnoozeEvents = BaseEvents<'notification.snooze', SnoozeArgs, Notification>;
+type NotificationUnsnoozeEvents = BaseEvents<'notification.unsnooze', UnsnoozeArgs, Notification>;
+type NotificationCompleteActionEvents = BaseEvents<'notification.complete_action', CompleteArgs, Notification>;
+type NotificationRevertActionEvents = BaseEvents<'notification.revert_action', RevertArgs, Notification>;
+type NotificationsReadAllEvents = BaseEvents<'notifications.read_all', {
+    tags?: TagsFilter;
+    data?: Record<string, unknown>;
+}, Notification[]>;
+type NotificationsSeenAllEvents = BaseEvents<'notifications.seen_all', {
+    notificationIds: string[];
+} | {
+    tags?: TagsFilter;
+    data?: Record<string, unknown>;
+} | {}, Notification[]>;
+type NotificationsArchivedAllEvents = BaseEvents<'notifications.archive_all', {
+    tags?: TagsFilter;
+    data?: Record<string, unknown>;
+}, Notification[]>;
+type NotificationsReadArchivedAllEvents = BaseEvents<'notifications.archive_all_read', {
+    tags?: TagsFilter;
+    data?: Record<string, unknown>;
+}, Notification[]>;
+type NotificationsDeletedAllEvents = BaseEvents<'notifications.delete_all', {
+    tags?: TagsFilter;
+    data?: Record<string, unknown>;
+}, Notification[]>;
+type PreferencesFetchEvents = BaseEvents<'preferences.list', ListPreferencesArgs, Preference[]>;
+type PreferenceUpdateEvents = BaseEvents<'preference.update', UpdatePreferenceArgs, Preference>;
+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 ChannelConnectionOAuthUrlEvents = BaseEvents<'channel-connection.oauth-url', GenerateChatOAuthUrlArgs, {
+    url: string;
+}>;
+type ChannelConnectionsFetchEvents = BaseEvents<'channel-connections.list', ListChannelConnectionsArgs, ChannelConnectionResponse[]>;
+type ChannelConnectionGetEvents = BaseEvents<'channel-connection.get', GetChannelConnectionArgs, ChannelConnectionResponse | null>;
+type ChannelConnectionDeleteEvents = BaseEvents<'channel-connection.delete', DeleteChannelConnectionArgs, void>;
+type ChannelEndpointOAuthUrlEvents = BaseEvents<'channel-endpoint.oauth-url', GenerateLinkUserOAuthUrlArgs, {
+    url: string;
+}>;
+type ChannelEndpointsFetchEvents = BaseEvents<'channel-endpoints.list', ListChannelEndpointsArgs, ChannelEndpointResponse[]>;
+type ChannelEndpointGetEvents = BaseEvents<'channel-endpoint.get', GetChannelEndpointArgs, ChannelEndpointResponse | null>;
+type ChannelEndpointCreateEvents = BaseEvents<'channel-endpoint.create', CreateChannelEndpointArgs, ChannelEndpointResponse>;
+type ChannelEndpointDeleteEvents = BaseEvents<'channel-endpoint.delete', DeleteChannelEndpointArgs, void>;
+type SocketConnectEvents = BaseEvents<'socket.connect', {
+    socketUrl: string;
+}, undefined>;
+type NotificationReceivedEvent = `notifications.${WebSocketEvent.RECEIVED}`;
+type NotificationUnseenEvent = `notifications.${WebSocketEvent.UNSEEN}`;
+type NotificationUnreadEvent = `notifications.${WebSocketEvent.UNREAD}`;
+type SocketEvents = {
+    [key in NotificationReceivedEvent]: {
+        result: Notification;
+    };
+} & {
+    [key in NotificationUnseenEvent]: {
+        result: number;
+    };
+} & {
+    [key in NotificationUnreadEvent]: {
+        result: {
+            total: number;
+            severity: Record<string, number>;
+        };
+    };
 };
-type UpdateSubscriptionPreferenceArgs = BaseSubscriptionPreferenceArgs | InstanceSubscriptionPreferenceArgs;
-type BaseDeleteSubscriptionArgs = {
-    identifier: string;
-    topicKey: string;
-};
-type InstanceDeleteSubscriptionArgs = {
-    subscription: TopicSubscription;
-};
-type DeleteSubscriptionArgs = BaseDeleteSubscriptionArgs | InstanceDeleteSubscriptionArgs;
+/**
+ * Events that are emitted by Novu Event Emitter.
+ *
+ * The event name consists of second pattern: module.action.status
+ * - module: the name of the module
+ * - action: the action that is being performed
+ * - status: the status of the action, could be pending or resolved
+ *
+ * Each event has a corresponding payload that is associated with the event:
+ * - pending: the args that are passed to the action and the optional optimistic value
+ * - resolved: the args that are passed to the action and the result of the action or the error that is thrown
+ */
+type Events = SessionInitializeEvents & NotificationsFetchEvents & {
+    'notifications.list.updated': {
+        data: ListNotificationsResponse;
+    };
+} & NotificationsFetchCountEvents & PreferencesFetchEvents & {
+    'preferences.list.updated': {
+        data: Preference[];
+    };
+} & PreferenceUpdateEvents & PreferencesBulkUpdateEvents & PreferenceScheduleGetEvents & PreferenceScheduleUpdateEvents & {
+    'preference.schedule.get.updated': {
+        data: Schedule;
+    };
+} & SubscriptionsFetchEvents & SubscriptionGetEvents & SubscriptionCreateEvents & SubscriptionPreferenceUpdateEvents & SubscriptionUpdateEvents & SubscriptionPreferencesBulkUpdateEvents & SubscriptionDeleteEvents & {
+    'subscriptions.list.updated': {
+        data: {
+            topicKey: string;
+            subscriptions: TopicSubscription[];
+        };
+    };
+} & ChannelConnectionOAuthUrlEvents & ChannelConnectionsFetchEvents & ChannelConnectionGetEvents & ChannelConnectionDeleteEvents & ChannelEndpointOAuthUrlEvents & ChannelEndpointsFetchEvents & ChannelEndpointGetEvents & ChannelEndpointCreateEvents & ChannelEndpointDeleteEvents & 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;
+type EventHandler<T = unknown> = (event: T) => void;
 
-type InboxServiceOptions = HttpClientOptions;
-declare class InboxService {
+declare class NovuEventEmitter {
     #private;
-    isSessionInitialized: boolean;
-    constructor(options?: InboxServiceOptions);
-    initializeSession({ applicationIdentifier, subscriberHash, contextHash, subscriber, defaultSchedule, context, }: {
-        applicationIdentifier?: string;
-        subscriberHash?: string;
-        contextHash?: string;
-        subscriber?: Subscriber;
-        defaultSchedule?: DefaultSchedule;
-        context?: Context;
-    }): Promise<Session>;
-    fetchNotifications({ after, archived, limit, offset, read, tags, snoozed, seen, data, severity, createdGte, createdLte, }: {
-        tags?: TagsFilter;
-        read?: boolean;
-        archived?: boolean;
-        snoozed?: boolean;
-        seen?: boolean;
-        limit?: number;
-        after?: string;
-        offset?: number;
-        data?: Record<string, unknown>;
-        severity?: SeverityLevelEnum | SeverityLevelEnum[];
-        createdGte?: number;
-        createdLte?: number;
-    }): Promise<{
-        data: InboxNotification[];
-        hasMore: boolean;
-        filter: NotificationFilter;
-    }>;
-    count({ filters, }: {
-        filters: Array<{
-            tags?: TagsFilter;
-            read?: boolean;
-            archived?: boolean;
-            snoozed?: boolean;
-            seen?: boolean;
-            data?: Record<string, unknown>;
-            severity?: SeverityLevelEnum | SeverityLevelEnum[];
-        }>;
-    }): Promise<{
-        data: Array<{
-            count: number;
-            filter: NotificationFilter;
-        }>;
-    }>;
-    read(notificationId: string): Promise<InboxNotification>;
-    unread(notificationId: string): Promise<InboxNotification>;
-    archive(notificationId: string): Promise<InboxNotification>;
-    unarchive(notificationId: string): Promise<InboxNotification>;
-    snooze(notificationId: string, snoozeUntil: string): Promise<InboxNotification>;
-    unsnooze(notificationId: string): Promise<InboxNotification>;
-    readAll({ tags, data }: {
-        tags?: TagsFilter;
-        data?: Record<string, unknown>;
-    }): Promise<void>;
-    archiveAll({ tags, data }: {
-        tags?: TagsFilter;
-        data?: Record<string, unknown>;
-    }): Promise<void>;
-    archiveAllRead({ tags, data }: {
-        tags?: TagsFilter;
-        data?: Record<string, unknown>;
-    }): Promise<void>;
-    delete(notificationId: string): Promise<void>;
-    deleteAll({ tags, data }: {
-        tags?: TagsFilter;
-        data?: Record<string, unknown>;
-    }): Promise<void>;
-    markAsSeen({ notificationIds, tags, data, }: {
-        notificationIds?: string[];
-        tags?: TagsFilter;
-        data?: Record<string, unknown>;
-    }): Promise<void>;
-    seen(notificationId: string): Promise<void>;
-    completeAction({ actionType, notificationId, }: {
-        notificationId: string;
-        actionType: ActionTypeEnum;
-    }): Promise<InboxNotification>;
-    revertAction({ actionType, notificationId, }: {
-        notificationId: string;
-        actionType: ActionTypeEnum;
-    }): Promise<InboxNotification>;
-    fetchPreferences({ tags, severity, criticality, }: {
-        tags?: string[];
-        severity?: SeverityLevelEnum | SeverityLevelEnum[];
-        criticality: WorkflowCriticalityEnum;
-    }): Promise<PreferencesResponse[]>;
-    bulkUpdatePreferences(preferences: Array<{
-        workflowId: string;
-    } & ChannelPreference>): Promise<PreferencesResponse[]>;
-    updateGlobalPreferences(preferences: ChannelPreference & {
-        schedule?: {
-            isEnabled?: boolean;
-            weeklySchedule?: WeeklySchedule;
-        };
-    }): Promise<PreferencesResponse>;
-    updateWorkflowPreferences({ workflowId, channels, }: {
-        workflowId: string;
-        channels: ChannelPreference;
-    }): 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, identifier, name, preferences, }: {
-        topicKey: string;
-        identifier: string;
-        name?: string;
-        preferences?: Array<PreferenceFilter>;
-    }): Promise<SubscriptionResponse>;
-    updateSubscriptionPreference({ subscriptionIdentifier, workflowId, enabled, condition, email, sms, in_app, chat, push, }: {
-        subscriptionIdentifier: string;
-        workflowId: string;
-        enabled?: boolean;
-        condition?: RulesLogic;
-        email?: boolean;
-        sms?: boolean;
-        in_app?: boolean;
-        chat?: boolean;
-        push?: boolean;
-    }): Promise<SubscriptionPreferenceResponse>;
-    bulkUpdateSubscriptionPreferences(preferences: Array<{
-        subscriptionIdentifier: string;
-        workflowId: string;
-        enabled?: boolean;
-        condition?: RulesLogic;
-        email?: boolean;
-        sms?: boolean;
-        in_app?: boolean;
-        chat?: boolean;
-        push?: boolean;
-    }>): Promise<SubscriptionPreferenceResponse[]>;
-    deleteSubscription({ topicKey, identifier }: {
-        topicKey: string;
-        identifier: string;
-    }): Promise<void>;
+    constructor();
+    on<Key extends EventNames>(eventName: Key, listener: EventHandler<Events[Key]>): () => void;
+    off<Key extends EventNames>(eventName: Key, listener: EventHandler<Events[Key]>): void;
+    emit<Key extends EventNames>(type: Key, event?: Events[Key]): void;
 }
 
 declare class Notification implements Pick<NovuEventEmitter, 'on'>, InboxNotification {
@@ -747,144 +489,555 @@ type UnsnoozeArgs = BaseArgs | InstanceArgs;
 type CompleteArgs = BaseArgs | InstanceArgs;
 type RevertArgs = BaseArgs | InstanceArgs;
 
-type KeylessInitializeSessionArgs = {} & {
-    [K in string]?: never;
+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"
+}
+type SocketTypeOption = 'cloud' | 'self-hosted';
+type NovuSocketOptions = {
+    socketType?: SocketTypeOption;
+    [key: string]: unknown;
 };
-type InitializeSessionArgs = KeylessInitializeSessionArgs | {
-    applicationIdentifier: string;
-    subscriber: Subscriber;
-    subscriberHash?: string;
-    contextHash?: string;
-    defaultSchedule?: DefaultSchedule;
-    context?: Context;
+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 NovuPendingEvent<A, D = undefined> = {
-    args: A;
-    data?: D;
+type Session = {
+    token: string;
+    /** @deprecated Use unreadCount.total instead */
+    totalUnreadCount: number;
+    unreadCount: UnreadCount;
+    removeNovuBranding: boolean;
+    isDevelopmentMode: boolean;
+    maxSnoozeDurationHours: number;
+    applicationIdentifier?: string;
+    contextKeys?: string[];
 };
-type NovuResolvedEvent<A, D> = NovuPendingEvent<A, D> & {
-    error?: unknown;
+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 EventName<T extends string> = `${T}.pending` | `${T}.resolved`;
-type EventStatus<T extends string> = `${T extends `${infer _}.${infer __}.${infer V}` ? V : never}`;
-type EventObject<K extends string, ARGS, DATA, EVENT_STATUS = EventStatus<K>> = EVENT_STATUS extends 'pending' ? NovuPendingEvent<ARGS, DATA> : NovuResolvedEvent<ARGS, DATA>;
-type BaseEvents<T extends string, ARGS, DATA> = {
-    [key in `${EventName<T>}`]: EventObject<key, ARGS, DATA>;
+type Redirect = {
+    url: string;
+    target?: '_self' | '_blank' | '_parent' | '_top' | '_unfencedTop';
 };
-type SessionInitializeEvents = BaseEvents<'session.initialize', InitializeSessionArgs, Session>;
-type NotificationsFetchEvents = BaseEvents<'notifications.list', ListNotificationsArgs, ListNotificationsResponse>;
-type NotificationsFetchCountEvents = BaseEvents<'notifications.count', CountArgs, CountResponse>;
-type NotificationReadEvents = BaseEvents<'notification.read', ReadArgs, Notification>;
-type NotificationUnreadEvents = BaseEvents<'notification.unread', UnreadArgs, Notification>;
-type NotificationSeenEvents = BaseEvents<'notification.seen', SeenArgs, Notification>;
-type NotificationArchiveEvents = BaseEvents<'notification.archive', ArchivedArgs, Notification>;
-type NotificationUnarchiveEvents = BaseEvents<'notification.unarchive', UnarchivedArgs, Notification>;
-type NotificationDeleteEvents = BaseEvents<'notification.delete', DeletedArgs, Notification>;
-type NotificationSnoozeEvents = BaseEvents<'notification.snooze', SnoozeArgs, Notification>;
-type NotificationUnsnoozeEvents = BaseEvents<'notification.unsnooze', UnsnoozeArgs, Notification>;
-type NotificationCompleteActionEvents = BaseEvents<'notification.complete_action', CompleteArgs, Notification>;
-type NotificationRevertActionEvents = BaseEvents<'notification.revert_action', RevertArgs, Notification>;
-type NotificationsReadAllEvents = BaseEvents<'notifications.read_all', {
-    tags?: TagsFilter;
-    data?: Record<string, unknown>;
-}, Notification[]>;
-type NotificationsSeenAllEvents = BaseEvents<'notifications.seen_all', {
-    notificationIds: string[];
-} | {
-    tags?: TagsFilter;
-    data?: Record<string, unknown>;
-} | {}, Notification[]>;
-type NotificationsArchivedAllEvents = BaseEvents<'notifications.archive_all', {
-    tags?: TagsFilter;
-    data?: Record<string, unknown>;
-}, Notification[]>;
-type NotificationsReadArchivedAllEvents = BaseEvents<'notifications.archive_all_read', {
+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 TagsFilterOrGroup = {
+    or: string[];
+};
+type TagsFilterAndForm = {
+    and: TagsFilterOrGroup[];
+};
+/**
+ * Inbox tag filter: a **single** OR-group as `string[]` or `{ or: string[] }`, or **multiple** OR-groups (AND of OR) as `{ and: [{ or: string[] }, ...] }`.
+ *
+ * @example Single OR-group — match notifications tagged `promo` **or** `sale`
+ * ```ts
+ * const tags: TagsFilter = ['promo', 'sale'];
+ * ```
+ *
+ * @example AND of OR-groups — match (`urgent` **or** `critical`) **and** (`billing`)
+ * ```ts
+ * const tags: TagsFilter = {
+ *   and: [{ or: ['urgent', 'critical'] }, { or: ['billing'] }],
+ * };
+ * ```
+ */
+type TagsFilter = string[] | TagsFilterOrGroup | TagsFilterAndForm;
+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?: TagsFilter;
+    read?: boolean;
+    archived?: boolean;
+    snoozed?: boolean;
+    seen?: boolean;
+    /**
+     * Filter notifications by keys in their `data` object.
+     *
+     * Each top-level key value can be:
+     *  - a scalar (exact equality)
+     *  - `Scalar[]` (OR — match any of the listed values)
+     *  - `{ or: Scalar[] }` (explicit OR)
+     *  - `{ and: [{ or: Scalar[] }, ...] }` (AND of OR-groups)
+     *  - a 1-level nested object whose sub-keys follow the same rules
+     *
+     * Across keys clauses are AND-ed together.
+     */
     data?: Record<string, unknown>;
-}, Notification[]>;
-type NotificationsDeletedAllEvents = BaseEvents<'notifications.delete_all', {
-    tags?: TagsFilter;
+    severity?: SeverityLevelEnum | SeverityLevelEnum[];
+    createdGte?: number;
+    createdLte?: number;
+};
+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>;
-}, Notification[]>;
-type PreferencesFetchEvents = BaseEvents<'preferences.list', ListPreferencesArgs, Preference[]>;
-type PreferenceUpdateEvents = BaseEvents<'preference.update', UpdatePreferenceArgs, Preference>;
-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>;
-type NotificationReceivedEvent = `notifications.${WebSocketEvent.RECEIVED}`;
-type NotificationUnseenEvent = `notifications.${WebSocketEvent.UNSEEN}`;
-type NotificationUnreadEvent = `notifications.${WebSocketEvent.UNREAD}`;
-type SocketEvents = {
-    [key in NotificationReceivedEvent]: {
-        result: Notification;
-    };
-} & {
-    [key in NotificationUnseenEvent]: {
-        result: number;
-    };
-} & {
-    [key in NotificationUnreadEvent]: {
-        result: {
-            total: number;
-            severity: Record<string, number>;
-        };
+};
+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;
+    applicationIdentifier: string;
+    subscriberHash?: string;
+    contextHash?: string;
+    apiUrl?: string;
+    socketUrl?: string;
+    /**
+     * Custom socket configuration options. These options will be merged with the default socket configuration.
+     * Use `socketType` to explicitly select the socket implementation: `'cloud'` for PartySocket or `'self-hosted'` for socket.io.
+     * For socket.io-client connections, supports all socket.io-client options (e.g., `path`, `reconnectionDelay`, `timeout`, etc.).
+     * For PartySocket connections, options are applied to the WebSocket instance.
+     */
+    socketOptions?: NovuSocketOptions;
+    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 ChannelConnectionResponse = {
+    identifier: string;
+};
+type ChannelEndpointResponse = {
+    identifier: string;
+    type: string;
+};
+type OAuthMode = 'connect' | 'link_user';
+type ConnectionMode = 'subscriber' | 'shared';
 /**
- * Events that are emitted by Novu Event Emitter.
- *
- * The event name consists of second pattern: module.action.status
- * - module: the name of the module
- * - action: the action that is being performed
- * - status: the status of the action, could be pending or resolved
- *
- * Each event has a corresponding payload that is associated with the event:
- * - pending: the args that are passed to the action and the optional optimistic value
- * - resolved: the args that are passed to the action and the result of the action or the error that is thrown
+ * @deprecated Use GenerateConnectOAuthUrlArgs or GenerateLinkUserOAuthUrlArgs instead.
  */
-type Events = SessionInitializeEvents & NotificationsFetchEvents & {
-    'notifications.list.updated': {
-        data: ListNotificationsResponse;
-    };
-} & NotificationsFetchCountEvents & PreferencesFetchEvents & {
-    'preferences.list.updated': {
-        data: Preference[];
-    };
-} & PreferenceUpdateEvents & PreferencesBulkUpdateEvents & PreferenceScheduleGetEvents & PreferenceScheduleUpdateEvents & {
-    'preference.schedule.get.updated': {
-        data: Schedule;
+type GenerateChatOAuthUrlArgs = {
+    integrationIdentifier: string;
+    connectionIdentifier?: string;
+    subscriberId?: string;
+    context?: Context;
+    scope?: string[];
+    userScope?: string[];
+    mode?: OAuthMode;
+    connectionMode?: ConnectionMode;
+    autoLinkUser?: boolean;
+};
+/** Args for creating a workspace/tenant channel connection (Slack install or MS Teams admin consent). */
+type GenerateConnectOAuthUrlArgs = {
+    integrationIdentifier: string;
+    connectionIdentifier?: string;
+    subscriberId?: string;
+    context?: Context;
+    /** Slack only: OAuth bot scopes to request. */
+    scope?: string[];
+    connectionMode?: ConnectionMode;
+    autoLinkUser?: boolean;
+};
+/** Args for linking a subscriber to their personal chat identity (Slack user or MS Teams user OID). */
+type GenerateLinkUserOAuthUrlArgs = {
+    integrationIdentifier: string;
+    connectionIdentifier?: string;
+    /** Required — this operation always binds a specific subscriber to a user identity. */
+    subscriberId: string;
+    context?: Context;
+    /** Slack only: user-level OAuth scopes (e.g. identity.basic). */
+    userScope?: string[];
+};
+type ListChannelConnectionsArgs = {
+    subscriberId?: string;
+    integrationIdentifier?: string;
+    channel?: string;
+    providerId?: string;
+    contextKeys?: string[];
+    limit?: number;
+    after?: string;
+    before?: string;
+};
+type GetChannelConnectionArgs = {
+    identifier: string;
+};
+type CreateChannelConnectionArgs = {
+    identifier?: string;
+    integrationIdentifier: string;
+    subscriberId?: string;
+    context?: Context;
+    workspace: {
+        id: string;
+        name?: string;
     };
-} & SubscriptionsFetchEvents & SubscriptionGetEvents & SubscriptionCreateEvents & SubscriptionPreferenceUpdateEvents & SubscriptionUpdateEvents & SubscriptionPreferencesBulkUpdateEvents & SubscriptionDeleteEvents & {
-    'subscriptions.list.updated': {
-        data: {
-            topicKey: string;
-            subscriptions: TopicSubscription[];
-        };
+    auth: {
+        accessToken: string;
     };
-} & 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;
-type EventHandler<T = unknown> = (event: T) => void;
+};
+type DeleteChannelConnectionArgs = {
+    identifier: string;
+};
+type ListChannelEndpointsArgs = {
+    subscriberId?: string;
+    integrationIdentifier?: string;
+    connectionIdentifier?: string;
+    channel?: string;
+    providerId?: string;
+    contextKeys?: string[];
+    limit?: number;
+    after?: string;
+    before?: string;
+};
+type GetChannelEndpointArgs = {
+    identifier: string;
+};
+type CreateChannelEndpointArgs = {
+    identifier?: string;
+    integrationIdentifier: string;
+    connectionIdentifier?: string;
+    subscriberId: string;
+    context?: Context;
+    type: string;
+    endpoint: Record<string, string>;
+};
+type DeleteChannelEndpointArgs = {
+    identifier: string;
+};
 
-declare class NovuEventEmitter {
+type InboxServiceOptions = HttpClientOptions;
+declare class InboxService {
     #private;
-    constructor();
-    on<Key extends EventNames>(eventName: Key, listener: EventHandler<Events[Key]>): () => void;
-    off<Key extends EventNames>(eventName: Key, listener: EventHandler<Events[Key]>): void;
-    emit<Key extends EventNames>(type: Key, event?: Events[Key]): void;
+    isSessionInitialized: boolean;
+    constructor(options?: InboxServiceOptions);
+    initializeSession({ applicationIdentifier, subscriberHash, contextHash, subscriber, defaultSchedule, context, }: {
+        applicationIdentifier?: string;
+        subscriberHash?: string;
+        contextHash?: string;
+        subscriber?: Subscriber;
+        defaultSchedule?: DefaultSchedule;
+        context?: Context;
+    }): Promise<Session>;
+    fetchNotifications({ after, archived, limit, offset, read, tags, snoozed, seen, data, severity, createdGte, createdLte, }: {
+        tags?: TagsFilter;
+        read?: boolean;
+        archived?: boolean;
+        snoozed?: boolean;
+        seen?: boolean;
+        limit?: number;
+        after?: string;
+        offset?: number;
+        data?: Record<string, unknown>;
+        severity?: SeverityLevelEnum | SeverityLevelEnum[];
+        createdGte?: number;
+        createdLte?: number;
+    }): Promise<{
+        data: InboxNotification[];
+        hasMore: boolean;
+        filter: NotificationFilter;
+    }>;
+    count({ filters, }: {
+        filters: Array<{
+            tags?: TagsFilter;
+            read?: boolean;
+            archived?: boolean;
+            snoozed?: boolean;
+            seen?: boolean;
+            data?: Record<string, unknown>;
+            severity?: SeverityLevelEnum | SeverityLevelEnum[];
+        }>;
+    }): Promise<{
+        data: Array<{
+            count: number;
+            filter: NotificationFilter;
+        }>;
+    }>;
+    read(notificationId: string): Promise<InboxNotification>;
+    unread(notificationId: string): Promise<InboxNotification>;
+    archive(notificationId: string): Promise<InboxNotification>;
+    unarchive(notificationId: string): Promise<InboxNotification>;
+    snooze(notificationId: string, snoozeUntil: string): Promise<InboxNotification>;
+    unsnooze(notificationId: string): Promise<InboxNotification>;
+    readAll({ tags, data }: {
+        tags?: TagsFilter;
+        data?: Record<string, unknown>;
+    }): Promise<void>;
+    archiveAll({ tags, data }: {
+        tags?: TagsFilter;
+        data?: Record<string, unknown>;
+    }): Promise<void>;
+    archiveAllRead({ tags, data }: {
+        tags?: TagsFilter;
+        data?: Record<string, unknown>;
+    }): Promise<void>;
+    delete(notificationId: string): Promise<void>;
+    deleteAll({ tags, data }: {
+        tags?: TagsFilter;
+        data?: Record<string, unknown>;
+    }): Promise<void>;
+    markAsSeen({ notificationIds, tags, data, }: {
+        notificationIds?: string[];
+        tags?: TagsFilter;
+        data?: Record<string, unknown>;
+    }): Promise<void>;
+    seen(notificationId: string): Promise<void>;
+    completeAction({ actionType, notificationId, }: {
+        notificationId: string;
+        actionType: ActionTypeEnum;
+    }): Promise<InboxNotification>;
+    revertAction({ actionType, notificationId, }: {
+        notificationId: string;
+        actionType: ActionTypeEnum;
+    }): Promise<InboxNotification>;
+    fetchPreferences({ tags, severity, criticality, }: {
+        tags?: string[];
+        severity?: SeverityLevelEnum | SeverityLevelEnum[];
+        criticality: WorkflowCriticalityEnum;
+    }): Promise<PreferencesResponse[]>;
+    bulkUpdatePreferences(preferences: Array<{
+        workflowId: string;
+    } & ChannelPreference>): Promise<PreferencesResponse[]>;
+    updateGlobalPreferences(preferences: ChannelPreference & {
+        schedule?: {
+            isEnabled?: boolean;
+            weeklySchedule?: WeeklySchedule;
+        };
+    }): Promise<PreferencesResponse>;
+    updateWorkflowPreferences({ workflowId, channels, }: {
+        workflowId: string;
+        channels: ChannelPreference;
+    }): 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, identifier, name, preferences, }: {
+        topicKey: string;
+        identifier: string;
+        name?: string;
+        preferences?: Array<PreferenceFilter>;
+    }): Promise<SubscriptionResponse>;
+    updateSubscriptionPreference({ subscriptionIdentifier, workflowId, enabled, condition, email, sms, in_app, chat, push, }: {
+        subscriptionIdentifier: string;
+        workflowId: string;
+        enabled?: boolean;
+        condition?: RulesLogic;
+        email?: boolean;
+        sms?: boolean;
+        in_app?: boolean;
+        chat?: boolean;
+        push?: boolean;
+    }): Promise<SubscriptionPreferenceResponse>;
+    bulkUpdateSubscriptionPreferences(preferences: Array<{
+        subscriptionIdentifier: string;
+        workflowId: string;
+        enabled?: boolean;
+        condition?: RulesLogic;
+        email?: boolean;
+        sms?: boolean;
+        in_app?: boolean;
+        chat?: boolean;
+        push?: boolean;
+    }>): Promise<SubscriptionPreferenceResponse[]>;
+    deleteSubscription({ topicKey, identifier }: {
+        topicKey: string;
+        identifier: string;
+    }): Promise<void>;
+    /**
+     * @deprecated Use generateConnectOAuthUrl() or generateLinkUserOAuthUrl() instead.
+     */
+    generateChatOAuthUrl({ integrationIdentifier, connectionIdentifier, subscriberId, context, scope, userScope, mode, connectionMode, autoLinkUser, }: GenerateChatOAuthUrlArgs): Promise<{
+        url: string;
+    }>;
+    generateConnectOAuthUrl({ integrationIdentifier, connectionIdentifier, subscriberId, context, scope, connectionMode, autoLinkUser, }: GenerateConnectOAuthUrlArgs): Promise<{
+        url: string;
+    }>;
+    generateLinkUserOAuthUrl({ integrationIdentifier, connectionIdentifier, subscriberId, context, userScope, }: GenerateLinkUserOAuthUrlArgs): Promise<{
+        url: string;
+    }>;
+    listChannelConnections(args?: ListChannelConnectionsArgs): Promise<{
+        data: ChannelConnectionResponse[];
+        next?: string;
+        previous?: string;
+    }>;
+    getChannelConnection(identifier: string): Promise<ChannelConnectionResponse>;
+    createChannelConnection({ identifier, integrationIdentifier, subscriberId, context, workspace, auth, }: CreateChannelConnectionArgs): Promise<ChannelConnectionResponse>;
+    deleteChannelConnection(identifier: string): Promise<void>;
+    listChannelEndpoints(args?: ListChannelEndpointsArgs): Promise<{
+        data: ChannelEndpointResponse[];
+        next?: string;
+        previous?: string;
+    }>;
+    getChannelEndpoint(identifier: string): Promise<ChannelEndpointResponse>;
+    createChannelEndpoint({ identifier, integrationIdentifier, connectionIdentifier, subscriberId, context, type, endpoint, }: CreateChannelEndpointArgs): Promise<ChannelEndpointResponse>;
+    deleteChannelEndpoint(identifier: string): Promise<void>;
 }
 
-export { ScheduleCache as $, type TimeRange as A, type BaseDeleteSubscriptionArgs as B, type ChannelPreference as C, type DaySchedule as D, type EventHandler as E, type FiltersCountResponse as F, type GetSubscriptionArgs as G, TopicSubscription as H, type InboxNotification as I, type UpdateSubscriptionArgs as J, type UpdateSubscriptionPreferenceArgs as K, type ListNotificationsResponse as L, type WeeklySchedule as M, Notification as N, WorkflowCriticalityEnum as O, Preference as P, type WorkflowFilter as Q, type WorkflowGroupFilter as R, SeverityLevelEnum as S, type TagsFilter as T, type UnreadCount as U, type WorkflowIdentifierOrId as V, WebSocketEvent as W, InboxService as X, NovuEventEmitter as Y, type Session as Z, type Result as _, type NotificationFilter as a, type UpdateScheduleArgs as a0, PreferencesCache as a1, type ListPreferencesArgs as a2, type BasePreferenceArgs as a3, type InstancePreferenceArgs as a4, type ListNotificationsArgs as a5, type FilterCountArgs as a6, type FilterCountResponse as a7, type FiltersCountArgs as a8, type BaseArgs as a9, type InstanceArgs as aa, type SnoozeArgs as ab, SubscriptionsCache as ac, type Options as ad, type EventNames as ae, type ContextValue as af, type BaseUpdateSubscriptionArgs as b, ChannelType as c, type Context as d, type CreateSubscriptionArgs as e, type DefaultSchedule as f, type DeleteSubscriptionArgs as g, type Events as h, type InstanceDeleteSubscriptionArgs as i, type InstanceUpdateSubscriptionArgs as j, type ListSubscriptionsArgs as k, NotificationStatus as l, NovuError as m, type NovuOptions as n, type NovuSocketOptions as o, type PreferenceFilter as p, PreferenceLevel as q, type PreferencesResponse as r, Schedule as s, type SocketEventNames as t, type SocketTypeOption as u, type StandardNovuOptions as v, type Subscriber as w, SubscriptionPreference as x, type TagsFilterAndForm as y, type TagsFilterOrGroup as z };
+export { type UpdateSubscriptionPreferenceArgs as $, type PreferenceFilter as A, type BaseDeleteSubscriptionArgs as B, type ChannelConnectionResponse as C, type DaySchedule as D, type EventHandler as E, type FiltersCountResponse as F, type GenerateChatOAuthUrlArgs as G, PreferenceLevel as H, type InboxNotification as I, type PreferencesResponse as J, Schedule as K, type ListChannelConnectionsArgs as L, type SocketEventNames as M, Notification as N, type SocketTypeOption as O, Preference as P, type StandardNovuOptions as Q, type Subscriber as R, SeverityLevelEnum as S, type TagsFilter as T, SubscriptionPreference as U, type TagsFilterAndForm as V, type TagsFilterOrGroup as W, type TimeRange as X, TopicSubscription as Y, type UnreadCount as Z, type UpdateSubscriptionArgs as _, type NotificationFilter as a, WebSocketEvent as a0, type WeeklySchedule as a1, WorkflowCriticalityEnum as a2, type WorkflowFilter as a3, type WorkflowGroupFilter as a4, type WorkflowIdentifierOrId as a5, type ConnectionMode as a6, InboxService as a7, NovuEventEmitter as a8, type Session as a9, type Result as aa, ScheduleCache as ab, type UpdateScheduleArgs as ac, PreferencesCache as ad, type ListPreferencesArgs as ae, type BasePreferenceArgs as af, type InstancePreferenceArgs as ag, type ListNotificationsArgs as ah, type FilterCountArgs as ai, type FilterCountResponse as aj, type FiltersCountArgs as ak, type BaseArgs as al, type InstanceArgs as am, type SnoozeArgs as an, type GenerateConnectOAuthUrlArgs as ao, type GenerateLinkUserOAuthUrlArgs as ap, SubscriptionsCache as aq, type Options as ar, type EventNames as as, type ContextValue as at, type BaseUpdateSubscriptionArgs as b, type ChannelEndpointResponse as c, type ChannelPreference as d, ChannelType as e, type Context as f, type CreateChannelConnectionArgs as g, type CreateChannelEndpointArgs as h, type CreateSubscriptionArgs as i, type DefaultSchedule as j, type DeleteChannelConnectionArgs as k, type DeleteChannelEndpointArgs as l, type DeleteSubscriptionArgs as m, type Events as n, type GetChannelConnectionArgs as o, type GetChannelEndpointArgs as p, type GetSubscriptionArgs as q, type InstanceDeleteSubscriptionArgs as r, type InstanceUpdateSubscriptionArgs as s, type ListChannelEndpointsArgs as t, type ListNotificationsResponse as u, type ListSubscriptionsArgs as v, NotificationStatus as w, NovuError as x, type NovuOptions as y, type NovuSocketOptions as z };