import http from 'node:http';
import { EventEmitter } from 'node:events';
import type { ServerRequest } from 'srvx';
import { EVENTS } from '@tus/utils';
import type { DataStore, Upload, CancellationContext } from '@tus/utils';
import { GetHandler } from './handlers/GetHandler.js';
import { HeadHandler } from './handlers/HeadHandler.js';
import { OptionsHandler } from './handlers/OptionsHandler.js';
import { PatchHandler } from './handlers/PatchHandler.js';
import { PostHandler } from './handlers/PostHandler.js';
import { DeleteHandler } from './handlers/DeleteHandler.js';
import type { ServerOptions, RouteHandler, WithOptional } from './types.js';
type Handlers = {
    GET: InstanceType<typeof GetHandler>;
    HEAD: InstanceType<typeof HeadHandler>;
    OPTIONS: InstanceType<typeof OptionsHandler>;
    PATCH: InstanceType<typeof PatchHandler>;
    POST: InstanceType<typeof PostHandler>;
    DELETE: InstanceType<typeof DeleteHandler>;
};
interface TusEvents {
    [EVENTS.POST_CREATE]: (req: ServerRequest, upload: Upload, url: string) => void;
    [EVENTS.POST_RECEIVE]: (req: ServerRequest, upload: Upload) => void;
    [EVENTS.POST_FINISH]: (req: ServerRequest, res: Response, upload: Upload) => void;
    [EVENTS.POST_TERMINATE]: (req: ServerRequest, res: Response, id: string) => void;
}
type on = EventEmitter['on'];
type emit = EventEmitter['emit'];
export declare interface Server {
    on<Event extends keyof TusEvents>(event: Event, listener: TusEvents[Event]): this;
    on(eventName: Parameters<on>[0], listener: Parameters<on>[1]): this;
    emit<Event extends keyof TusEvents>(event: Event, listener: TusEvents[Event]): ReturnType<emit>;
    emit(eventName: Parameters<emit>[0], listener: Parameters<emit>[1]): ReturnType<emit>;
}
export declare class Server extends EventEmitter {
    datastore: DataStore;
    handlers: Handlers;
    options: ServerOptions;
    constructor(options: WithOptional<ServerOptions, 'locker'> & {
        datastore: DataStore;
    });
    get(path: string, handler: RouteHandler): void;
    handle(req: http.IncomingMessage, res: http.ServerResponse): Promise<void>;
    handleWeb(req: Request): Promise<Response>;
    private handler;
    private getCorsOrigin;
    write(context: CancellationContext, headers: Headers, status: number, body?: string): Promise<import("undici-types").Response>;
    listen(...args: any[]): http.Server;
    cleanUpExpiredUploads(): Promise<number>;
    protected createContext(): {
        signal: AbortSignal;
        abort: () => void;
        cancel: () => void;
    };
}
export {};
//# sourceMappingURL=server.d.ts.map