/**
 * Stream Server
 *
 * Framework-agnostic streaming server factory.
 * Provides easy configuration and integration with Next.js, NestJS, Express, etc.
 *
 * Uses framework adapters for handling different runtimes:
 * - NextJSFrameworkAdapter - Next.js App Router (Web Request/Response)
 * - ExpressFrameworkAdapter - Express/Fastify (req/res pattern)
 * - NestJSFrameworkAdapter - NestJS controllers
 *
 * @example
 * ```ts
 * // Create server with builder pattern
 * const streamServer = StreamServer.create()
 *   .withAuth(new AnonymousAuthAdapter())
 *   .withSSE({ heartbeatInterval: 15000 })
 *   .build();
 *
 * // Use in Next.js
 * export const GET = streamServer.getHandler('nextjs');
 *
 * // Use in Express
 * app.get('/stream', streamServer.getHandler('express'));
 *
 * // Use in NestJS
 * const handler = streamServer.getHandler('nestjs');
 * await handler(req, res);
 * ```
 */
import { StreamBroadcaster } from './StreamBroadcaster';
import type { BaseAuthAdapter } from './auth/BaseAuthAdapter';
import type { BaseTransportAdapter } from './transports/BaseTransportAdapter';
import type { BaseFrameworkAdapter } from './frameworks';
import { type FrameworkType, type FrameworkHandlerOptions } from './frameworks';
import type { StreamAuthResult, StreamBroadcasterConfig, StreamChannel, StreamManagerStats, StreamTransportType, SSEConfig, WebSocketConfig } from '@plyaz/types/core';
/**
 * Stream server configuration
 */
export interface StreamServerConfig {
    /** Auth adapter to use */
    auth?: BaseAuthAdapter;
    /** Transport adapters to use */
    transports?: BaseTransportAdapter[];
    /** Broadcaster configuration */
    broadcaster?: StreamBroadcasterConfig;
    /** Default channels for new connections */
    defaultChannels?: StreamChannel[];
    /** Parse channels from request (default: query param 'channels') */
    parseChannels?: (request: Request) => StreamChannel[];
    /** Custom framework adapters (NextJS, Express, NestJS registered by default) */
    frameworkAdapters?: BaseFrameworkAdapter[];
}
/**
 * Builder for StreamServer
 */
export declare class StreamServerBuilder {
    private authAdapter?;
    private transports;
    private broadcasterConfig?;
    private defaultChannels;
    private channelParser?;
    /**
     * Configure authentication
     */
    withAuth(adapter: BaseAuthAdapter): this;
    /**
     * Enable SSE transport
     */
    withSSE(config?: SSEConfig): this;
    /**
     * Enable WebSocket transport (future)
     */
    withWebSocket(_config?: WebSocketConfig): this;
    /**
     * Add custom transport
     */
    withTransport(adapter: BaseTransportAdapter): this;
    /**
     * Configure broadcaster
     */
    withBroadcaster(config: StreamBroadcasterConfig): this;
    /**
     * Set default channels for new connections
     */
    withDefaultChannels(channels: StreamChannel[]): this;
    /**
     * Custom channel parser
     */
    withChannelParser(parser: (request: Request) => StreamChannel[]): this;
    /**
     * Build the stream server
     */
    build(): StreamServer;
}
/**
 * StreamServer - Framework-agnostic streaming server
 *
 * Features:
 * - Builder pattern for easy configuration
 * - Framework adapter pattern for easy integration
 * - Automatic connection lifecycle management
 * - Channel-based subscriptions
 *
 * @example
 * ```ts
 * const server = StreamServer.create()
 *   .withAuth(new TokenAuthAdapter({ verifyToken: myVerifier }))
 *   .withSSE({ heartbeatInterval: 30000 })
 *   .build();
 *
 * // Initialize on startup
 * server.initialize();
 *
 * // Get handler for your framework
 * export const GET = server.getHandler('nextjs');
 * // or
 * app.get('/stream', server.getHandler('express'));
 *
 * // Register endpoints via StreamRegistry
 * await StreamRegistry.initialize({
 *   broadcaster: server.getBroadcaster(),
 *   endpoints: [
 *     { endpoint: FilesStreamEndpoint, config: { enabled: true } },
 *     { endpoint: SystemStreamEndpoint, config: { enabled: true } },
 *   ],
 * });
 * ```
 */
export declare class StreamServer {
    private readonly broadcaster;
    private readonly config;
    private readonly frameworkAdapters;
    private initialized;
    constructor(config: StreamServerConfig);
    /**
     * Create a new builder
     */
    static create(): StreamServerBuilder;
    /**
     * Initialize the stream server
     * Call once on application startup
     */
    initialize(): void;
    /**
     * Dispose the stream server
     * Call on application shutdown
     */
    dispose(): void;
    /**
     * Handle a streaming request (framework-agnostic)
     *
     * @param request - HTTP request
     * @param transportType - Transport to use (default: 'sse')
     */
    handleRequest(request: Request, transportType?: StreamTransportType): Promise<Response>;
    /**
     * Parse channels from request
     */
    private parseChannels;
    /**
     * Register a framework adapter.
     *
     * Default adapters (NextJS, Express, NestJS) are registered automatically.
     * Use this to add custom adapters or override existing ones.
     *
     * @param adapter - Framework adapter to register
     *
     * @example
     * ```ts
     * // Register custom adapter
     * streamServer.registerFrameworkAdapter(new MyCustomAdapter());
     *
     * // Override default adapter
     * streamServer.registerFrameworkAdapter(new NextJSFrameworkAdapter({ name: 'custom-nextjs' }));
     * ```
     */
    registerFrameworkAdapter(adapter: BaseFrameworkAdapter): void;
    /**
     * Get a framework adapter by type.
     *
     * @param framework - Framework type to get
     * @returns Framework adapter or undefined if not registered
     */
    getFrameworkAdapter<T extends BaseFrameworkAdapter>(framework: FrameworkType): T | undefined;
    /**
     * Get handler for a specific framework.
     *
     * This is the primary API for integrating with frameworks.
     *
     * @param framework - Framework type ('nextjs', 'express', 'nestjs')
     * @param options - Handler options (transport type, etc.)
     * @returns Framework-specific handler function
     *
     * @example
     * ```ts
     * // Next.js App Router
     * export const GET = streamServer.getHandler('nextjs');
     *
     * // Express
     * app.get('/stream', streamServer.getHandler('express'));
     *
     * // NestJS controller
     * const handler = streamServer.getHandler('nestjs');
     * await handler(req, res);
     *
     * // With options
     * export const GET = streamServer.getHandler('nextjs', { transport: 'sse' });
     * ```
     */
    getHandler<T = unknown>(framework: FrameworkType, options?: FrameworkHandlerOptions): T;
    /**
     * Get list of registered framework adapters.
     */
    getRegisteredFrameworks(): FrameworkType[];
    /**
     * Get the underlying broadcaster for advanced usage
     */
    getBroadcaster(): StreamBroadcaster;
    /**
     * Authenticate a request
     */
    authenticate(request: Request): Promise<StreamAuthResult>;
    /**
     * Check if user can subscribe to a channel
     */
    canSubscribe(authResult: StreamAuthResult, channel: StreamChannel): boolean;
    /**
     * Get server statistics
     */
    getStats(): StreamManagerStats;
    /**
     * Check if server is initialized
     */
    isInitialized(): boolean;
}
//# sourceMappingURL=StreamServer.d.ts.map