import { I as INovuRequestHandlerOptions, N as NovuRequestHandler, S as ServeHandlerOptions, C as Client } from '../index-BvRGmHFw.js';
export { a as agent, i as isFromWorkflow, w as workflow } from '../index-BvRGmHFw.js';
import { W as Workflow } from '../health-check.types-DORn4djx.js';
export { C as ClientOptions, a as CronExpression, E as ExecuteInput, S as SeverityLevelEnum } from '../health-check.types-DORn4djx.js';
export { Actions, Button, Card, CardChild, CardElement, CardLink, CardText, Divider, Image, ImageElement, Select, SelectOption, TextInput } from 'chat';
import { A as Agent } from '../agent.types-DFLG1_vb.js';
export { a as AgentAction, b as AgentActionContext, c as AgentAttachment, d as AgentContext, e as AgentContextPayload, f as AgentContextValue, g as AgentConversation, h as AgentDeliveryError, i as AgentError, j as AgentHandlerContext, k as AgentHandlers, l as AgentHistoryEntry, m as AgentHumanResponse, n as AgentMessage, o as AgentMessageAuthor, p as AgentMessageContext, q as AgentNotification, r as AgentPlatformContext, s as AgentReaction, t as AgentReactionContext, u as AgentResolveContext, v as AgentSubscriber, w as AgentSubscriberAccess, x as AgentToolCall, F as FileRef, H as HumanAskApproveOptions, y as HumanChooseOptions, z as HumanInteractionKind, B as HumanTellOptions, M as MessageContent, R as ReplyHandle, T as ToolApprovalCard, C as ToolApprovalConfig, D as ToolApprovalDecision, E as toAgentError } from '../agent.types-DFLG1_vb.js';
export { AnyStepResolver, ChatStepResolver, EmailStepResolver, InAppStepResolver, PushStepResolver, SmsStepResolver, StepResolverContext, ToolStepResolver, step } from '../step-resolver.js';
export { C as ContextResolved, E as EnvironmentSystemVariables, S as Subscriber, p as providerSchemas } from '../subscriber.types-Drf26WPA.js';
import { Request, Response } from 'express';
import { S as SupportedFrameworkName } from '../server.types-Cc6o5eYH.js';
import { VercelRequest, VercelResponse } from '@vercel/node';
import { E as Either } from '../util.types-DaFfsxgy.js';
import * as _nestjs_common from '@nestjs/common';
import { Provider, FactoryProvider } from '@nestjs/common';
import '../base.schema.types-BApIn9jr.js';
import 'json-schema-to-ts';
import 'zod';

declare class NovuHandler {
    handler(incomingRequest: Either<VercelRequest, Request>, response: Either<Response, VercelResponse>): ReturnType<INovuRequestHandlerOptions['handler']>;
}

declare const frameworkName: SupportedFrameworkName;
declare class NovuClient {
    private options;
    private novuHandler;
    novuRequestHandler: NovuRequestHandler;
    constructor(options: ServeHandlerOptions, novuHandler: NovuHandler);
    handleRequest(req: Request, res: Response): Promise<void>;
}

type NovuModuleOptions = ServeHandlerOptions & {
    apiPath: string;
    controllerDecorators?: ClassDecorator[];
};

declare const NovuBaseModule: _nestjs_common.ConfigurableModuleCls<NovuModuleOptions, "register", "createNovuModuleOptions", (definition: NovuModuleOptions) => {
    isGlobal: boolean;
    client?: Client;
    workflows?: Array<Workflow>;
    agents?: Array<Agent>;
    waitUntil?: (promise: Promise<unknown>) => void;
    apiPath: string;
    controllerDecorators?: ClassDecorator[];
}>;
declare const NOVU_OPTIONS: string | symbol;
declare const OPTIONS_TYPE: ServeHandlerOptions & {
    apiPath: string;
    controllerDecorators?: ClassDecorator[];
} & Partial<(definition: NovuModuleOptions) => {
    isGlobal: boolean;
    client?: Client;
    workflows?: Array<Workflow>;
    agents?: Array<Agent>;
    waitUntil?: (promise: Promise<unknown>) => void;
    apiPath: string;
    controllerDecorators?: ClassDecorator[];
}>;
declare const ASYNC_OPTIONS_TYPE: _nestjs_common.ConfigurableModuleAsyncOptions<NovuModuleOptions, "createNovuModuleOptions"> & Partial<(definition: NovuModuleOptions) => {
    isGlobal: boolean;
    client?: Client;
    workflows?: Array<Workflow>;
    agents?: Array<Agent>;
    waitUntil?: (promise: Promise<unknown>) => void;
    apiPath: string;
    controllerDecorators?: ClassDecorator[];
}>;

declare const REGISTER_API_PATH = "REGISTER_API_PATH";
declare const REGISTER_CONTROLLER_DECORATORS = "REGISTER_CONTROLLER_DECORATORS";

declare class NovuController {
    private novuService;
    constructor(novuService: NovuClient);
    handleGet(req: Request, res: Response): Promise<void>;
    handlePost(req: Request, res: Response): Promise<void>;
    handleOptions(req: Request, res: Response): Promise<void>;
}

/**
 * In NestJS, serve and register any declared workflows with Novu, making
 * them available to be triggered by events.
 *
 * @example
 * ```ts
 * import { NovuModule } from "@novu/framework/nest";
 * import { myWorkflow } from "./src/novu/workflows"; // Your workflows
 *
 * @Module({
 *   imports: [
 *     // Expose the middleware on our recommended path at `/api/novu`.
 *     NovuModule.register({
 *       apiPath: '/api/novu',
 *       workflows: [myWorkflow]
 *     })
 *   ]
 * })
 * export class AppModule {}
 *
 * const app = await NestFactory.create(AppModule);
 *
 * // Important:  ensure you add JSON middleware to process incoming JSON POST payloads.
 * app.use(express.json());
 * ```
 */
declare class NovuModule extends NovuBaseModule {
    /**
     * Register the Novu module
     *
     * @param options - The options to register the Novu module
     * @param customProviders - Custom providers to register. These will be merged with the default providers.
     * @returns The Novu module
     */
    static register(options: typeof OPTIONS_TYPE, customProviders?: Provider[]): _nestjs_common.DynamicModule;
    /**
     * Register the Novu module asynchronously
     *
     * @param options - The options to register the Novu module
     * @param customProviders - Custom providers to register. These will be merged with the default providers.
     * @returns The Novu module
     */
    static registerAsync(options: typeof ASYNC_OPTIONS_TYPE, customProviders?: Provider[]): _nestjs_common.DynamicModule;
}

/**
 * Workaround to dynamically set the path for the controller.
 *
 * A custom provider is necessary to ensure that the controller path is set during
 * application initialization, because NestJS does not support declaration of
 * paths after the application has been initialized.
 *
 * @see https://github.com/nestjs/nest/issues/1438#issuecomment-863446608
 */
declare const registerApiPath: FactoryProvider;

/**
 * Apply controller decorators resolved from async module options.
 *
 * A custom provider is necessary because `controllerDecorators` are only
 * available after the async options factory runs, while NestJS requires
 * controllers to be declared when the dynamic module is created.
 *
 * This mirrors the `registerApiPath` pattern used for dynamic controller paths.
 */
declare const registerControllerDecorators: FactoryProvider;

export { Agent, Client, NOVU_OPTIONS, NovuClient, NovuController, NovuHandler, NovuModule, type NovuModuleOptions, NovuRequestHandler, REGISTER_API_PATH, REGISTER_CONTROLLER_DECORATORS, ServeHandlerOptions, Workflow, frameworkName, registerApiPath, registerControllerDecorators };