import { Request, Express, RequestHandler, ErrorRequestHandler } from 'express';
import { U as User, a as UnauthenticatedUser, A as A2ARequestHandler } from '../../a2a_request_handler-B3LxMq3P.cjs';
import { L as Logger } from '../../logger-DM9C11Ou.cjs';
export { C as ConsoleLogger, J as JsonLogger, b as LogContext, a as LogLevel, N as NoopLogger } from '../../logger-DM9C11Ou.cjs';
import { A as AgentCardProvider } from '../../agent_card_utils-DOP-AooS.cjs';
import '../../extensions-DvruCIzw.cjs';

type UserBuilder = (req: Request) => Promise<User>;
declare const UserBuilder: {
    noAuthentication: () => Promise<UnauthenticatedUser>;
};

/**
 * Configuration options for A2AExpressApp.
 * Extends the base A2AServerOptions pattern for consistency across all server implementations.
 */
interface A2AExpressOptions {
    /** Logger instance for request/error logging */
    logger?: Logger;
    /** Function to build user from Express Request */
    userBuilder?: UserBuilder;
    /** Path for agent card endpoint (default: '/.well-known/agent-card.json') */
    agentCardPath?: string;
    /** Enable REST API endpoints (default: false) */
    enableRest?: boolean;
    /** Base path for REST endpoints (default: '/rest') */
    restBasePath?: string;
}
/**
 * A2AExpressApp provides A2A protocol support for Express applications.
 *
 * @example
 * ```ts
 * // New API with options object
 * import express from 'express';
 * import { A2AExpressApp } from '@drew-foxall/a2a-js-sdk/server/express';
 * import { DefaultRequestHandler, InMemoryTaskStore } from '@drew-foxall/a2a-js-sdk/server';
 *
 * const requestHandler = new DefaultRequestHandler(agentCard, new InMemoryTaskStore(), executor);
 * const a2aApp = new A2AExpressApp(requestHandler, {
 *   enableRest: true,
 * });
 *
 * const app = express();
 * a2aApp.setupRoutes(app, '/a2a');
 * app.listen(3000);
 * ```
 *
 * @example
 * ```ts
 * // Legacy API with userBuilder function (still supported)
 * const a2aApp = new A2AExpressApp(requestHandler, myUserBuilder);
 * ```
 */
declare class A2AExpressApp {
    private requestHandler;
    private options;
    /**
     * Creates a new A2AExpressApp instance.
     *
     * @param requestHandler - The A2A request handler
     * @param optionsOrUserBuilder - Either an options object or a UserBuilder function (legacy API)
     */
    constructor(requestHandler: A2ARequestHandler, optionsOrUserBuilder?: A2AExpressOptions | UserBuilder);
    /**
     * Adds A2A routes to an existing Express app.
     *
     * @param app - The Express app instance
     * @param baseUrl - The base URL for A2A endpoints (e.g., "/a2a")
     * @param middlewares - Optional array of Express middlewares to apply to the A2A routes
     * @param agentCardPath - Optional custom path for the agent card endpoint (overrides constructor option)
     * @returns The Express app with A2A routes
     */
    setupRoutes(app: Express, baseUrl?: string, middlewares?: Array<RequestHandler | ErrorRequestHandler>, agentCardPath?: string): Express;
}

interface JsonRpcHandlerOptions {
    requestHandler: A2ARequestHandler;
    userBuilder: UserBuilder;
}
/**
 * Creates Express.js middleware to handle A2A JSON-RPC requests.
 *
 * This handler uses the core JSON-RPC logic for business processing
 * and only implements Express-specific I/O operations.
 *
 * @example
 * ```ts
 * app.use(jsonRpcHandler({ requestHandler, userBuilder: UserBuilder.noAuthentication }));
 * ```
 */
declare function jsonRpcHandler(options: JsonRpcHandlerOptions): RequestHandler;
/**
 * Express error handler for JSON parse errors.
 */
declare const jsonErrorHandler: ErrorRequestHandler;

interface AgentCardHandlerOptions {
    agentCardProvider: AgentCardProvider;
}
/**
 * Creates Express.js middleware to handle agent card requests.
 *
 * This handler uses the core agent card logic for business processing
 * and only implements Express-specific I/O operations.
 *
 * @example
 * ```ts
 * // With an existing A2ARequestHandler instance:
 * app.use('/.well-known/agent-card.json', agentCardHandler({ agentCardProvider: a2aRequestHandler }));
 *
 * // Or with a factory lambda:
 * app.use('/.well-known/agent-card.json', agentCardHandler({ agentCardProvider: async () => agentCard }));
 * ```
 */
declare function agentCardHandler(options: AgentCardHandlerOptions): RequestHandler;

/**
 * Options for configuring the HTTP+JSON/REST handler.
 */
interface RestHandlerOptions {
    requestHandler: A2ARequestHandler;
    userBuilder: UserBuilder;
}
/**
 * Creates Express.js middleware to handle A2A HTTP+JSON/REST requests.
 *
 * This handler implements the A2A REST API specification with snake_case
 * field names, providing endpoints for:
 * - Agent card retrieval (GET /v1/card)
 * - Message sending with optional streaming (POST /v1/message:send|stream)
 * - Task management (GET/POST /v1/tasks/:taskId:cancel|subscribe)
 * - Push notification configuration
 *
 * The handler acts as an adapter layer, converting between REST format
 * (snake_case) at the API boundary and internal TypeScript format (camelCase)
 * for business logic.
 *
 * @param options - Configuration options including the request handler
 * @returns Express router configured with all A2A REST endpoints
 *
 * @example
 * ```ts
 * const app = express();
 * const requestHandler = new DefaultRequestHandler(...);
 * app.use('/api/rest', restHandler({ requestHandler, userBuilder: UserBuilder.noAuthentication }));
 * ```
 */
declare function restHandler(options: RestHandlerOptions): RequestHandler;

export { A2AExpressApp, type A2AExpressOptions, type AgentCardHandlerOptions, AgentCardProvider, type JsonRpcHandlerOptions, Logger, type RestHandlerOptions, UserBuilder, agentCardHandler, jsonErrorHandler, jsonRpcHandler, restHandler };