import { ae as HttpClient, af as AgentEventEnvelope, ag as InboxService, ah as NovuEventEmitter, ai as Session, aj as Result, ak as ScheduleCache, U as Schedule, al as UpdateScheduleArgs, am as PreferencesCache, an as ListPreferencesArgs, P as Preference, ao as BasePreferenceArgs, ap as InstancePreferenceArgs, aq as ListNotificationsArgs, w as ListNotificationsResponse, I as InboxNotification, N as Notification, a as NotificationFilter, ar as FilterCountArgs, as as FilterCountResponse, at as FiltersCountArgs, F as FiltersCountResponse, au as BaseArgs, av as InstanceArgs, aw as SnoozeArgs, A as AgentMessage, y as LoadConversationArgs, z as LoadConversationResult, V as SendMessageArgs, W as SendMessageResult, G as GenerateChatOAuthUrlArgs, ax as GenerateConnectOAuthUrlArgs, u as ListChannelConnectionsArgs, c as ChannelConnectionResponse, o as GetChannelConnectionArgs, k as DeleteChannelConnectionArgs, ay as GenerateLinkUserOAuthUrlArgs, v as ListChannelEndpointsArgs, d as ChannelEndpointResponse, p as GetChannelEndpointArgs, h as CreateChannelEndpointArgs, l as DeleteChannelEndpointArgs, L as LinkChannelEndpointArgs, t as LinkChannelEndpointResponse, az as SubscriptionsCache, _ as Subscriber, x as ListSubscriptionsArgs, aA as Options, a3 as TopicSubscription, q as GetSubscriptionArgs, i as CreateSubscriptionArgs, b as BaseUpdateSubscriptionArgs, s as InstanceUpdateSubscriptionArgs, B as BaseDeleteSubscriptionArgs, r as InstanceDeleteSubscriptionArgs, X as SocketEventNames, aB as EventNames, E as EventHandler, n as Events, aC as ContextValue, K as NovuOptions, C as Context } from './inbox-service-C1TlfPSW.js';

type AgentChatSendMessageArgs = {
    agentId: string;
    text: string;
    /** Existing conversation id. Omit this field to create a new conversation. */
    conversationId?: string;
};
type AgentChatSendMessageResponse = {
    identifier: string;
    messageId: string;
};
type AgentChatGetEventsArgs = {
    conversationId: string;
};
type AgentChatGetEventsResponse = {
    events: AgentEventEnvelope[];
    /** Cursor for older history. */
    olderCursor: string | null;
};
declare class AgentChatService {
    #private;
    constructor({ httpClient }: {
        httpClient: HttpClient;
    });
    sendMessage(args: AgentChatSendMessageArgs): Promise<AgentChatSendMessageResponse>;
    getEvents(args: AgentChatGetEventsArgs): Promise<AgentChatGetEventsResponse>;
}

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 syncNotificationInBucket;
    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?: NotificationFilter['tags'];
        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>;
}

declare class AgentChat extends BaseModule {
    #private;
    constructor({ inboxServiceInstance, eventEmitterInstance, agentChatService, }: {
        inboxServiceInstance: InboxService;
        eventEmitterInstance: NovuEventEmitter;
        agentChatService: AgentChatService;
    });
    clearCache(): void;
    getConversation({ agentId, conversationId, key, }: {
        agentId: string;
        conversationId?: string;
        key?: string;
    }): {
        conversationId?: string;
        messages: AgentMessage[];
        key: string;
    } | undefined;
    /**
     * Load the newest history page into the local holder.
     * The holder key is the public conversation id.
     */
    loadConversation(args: LoadConversationArgs): Result<LoadConversationResult>;
    sendMessage(args: SendMessageArgs): Result<SendMessageResult>;
}

declare class ChannelConnections extends BaseModule {
    constructor({ inboxServiceInstance, eventEmitterInstance, }: {
        inboxServiceInstance: InboxService;
        eventEmitterInstance: NovuEventEmitter;
    });
    /**
     * @deprecated Use generateConnectOAuthUrl() instead. For user-level linking use channelEndpoints.generateLinkUserOAuthUrl().
     */
    generateOAuthUrl(args: GenerateChatOAuthUrlArgs): Result<{
        url: string;
    }>;
    generateConnectOAuthUrl(args: GenerateConnectOAuthUrlArgs): Result<{
        url: string;
    }>;
    list(args?: ListChannelConnectionsArgs): Result<ChannelConnectionResponse[]>;
    get(args: GetChannelConnectionArgs): Result<ChannelConnectionResponse | null>;
    delete(args: DeleteChannelConnectionArgs): Result<void>;
}

declare class ChannelEndpoints extends BaseModule {
    constructor({ inboxServiceInstance, eventEmitterInstance, }: {
        inboxServiceInstance: InboxService;
        eventEmitterInstance: NovuEventEmitter;
    });
    generateLinkUserOAuthUrl(args: GenerateLinkUserOAuthUrlArgs): Result<{
        url: string;
    }>;
    list(args?: ListChannelEndpointsArgs): Result<ChannelEndpointResponse[]>;
    get(args: GetChannelEndpointArgs): Result<ChannelEndpointResponse | null>;
    create(args: CreateChannelEndpointArgs): Result<ChannelEndpointResponse>;
    delete(args: DeleteChannelEndpointArgs): Result<void>;
    link(args: LinkChannelEndpointArgs): Result<LinkChannelEndpointResponse>;
}

declare class Subscriptions extends BaseModule {
    #private;
    readonly cache: SubscriptionsCache;
    constructor({ useCache, inboxServiceInstance, eventEmitterInstance, subscriber, contextKey, }: {
        useCache: boolean;
        inboxServiceInstance: InboxService;
        eventEmitterInstance: NovuEventEmitter;
        subscriber: Subscriber;
        contextKey: string;
    });
    list(args: ListSubscriptionsArgs, options?: Options): Result<TopicSubscription[]>;
    get(args: GetSubscriptionArgs, options?: Options): Result<TopicSubscription | null>;
    create(args: CreateSubscriptionArgs): Result<TopicSubscription>;
    update(args: BaseUpdateSubscriptionArgs): Result<TopicSubscription>;
    update(args: InstanceUpdateSubscriptionArgs): Result<TopicSubscription>;
    delete(args: BaseDeleteSubscriptionArgs): Result<void>;
    delete(args: InstanceDeleteSubscriptionArgs): Result<void>;
}

interface BaseSocketInterface {
    isSocketEvent(eventName: string): eventName is SocketEventNames;
    connect(): Result<void>;
    disconnect(): Result<void>;
}

declare class Novu implements Pick<NovuEventEmitter, 'on'> {
    #private;
    readonly notifications: Notifications;
    readonly preferences: Preferences;
    readonly subscriptions: Subscriptions;
    readonly channelConnections: ChannelConnections;
    readonly channelEndpoints: ChannelEndpoints;
    readonly agentChat: AgentChat;
    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 contextHash(): string | 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 { Novu as N };