import { type IRawResPacket } from '../../interface/rpc.js';
import { ExError } from '../../utility/ExError.js';
import { Connector } from './Connector.js';
import { type ListenerCallback } from './Listener.js';
import { Notify } from './packet/Notify.js';
import { Request } from './packet/Request.js';
import { Response } from './packet/Response.js';
export type RPCHandler<Req = unknown, Res = unknown> = (body: Req, ...args: any) => Promise<Res>;
export type MethodPramBuilder<T = unknown, R extends Route = Route, Req = unknown, Res = unknown> = (route: R, body: Req, req: Request<Req> | Notify<Req>, response: Response<Res> | null, connector: Connector) => Promise<T>;
export interface IRPCHandlerParam<T = unknown, R extends Route = Route, Req = unknown, Res = unknown> {
    type: any;
    provider: MethodPramBuilder<T, R, Req, Res>;
}
export type RPCMiddleware<T extends Route = Route, Req = unknown, Res = unknown> = (route: T, body: Req, req: Request<Req> | Notify<Req>, response: Response<Res> | null, connector: Connector, next: () => Promise<unknown>) => Promise<unknown>;
export interface IRPCHandler<Req = unknown, Res = unknown> {
    params: any[];
    handler: RPCHandler<Req, Res>;
}
export type NotifyHandler<Req = unknown> = (body: Req, ...args: any) => Promise<void>;
export interface INotifyHandler<Req = unknown> {
    params: any[];
    handler: NotifyHandler<Req>;
}
export declare enum MiddlewarePosition {
    Before = "before",
    After = "after"
}
declare class Route {
    protected static method(target: Route, key: string): void;
    protected static notify(target: Route, key: string): void;
    protected static registerMethod(target: Route, method: string, callback: RPCHandler, types: any[]): void;
    protected static registerNotify(target: Route, method: string, callback: NotifyHandler, types: any[]): void;
    protected static registerProvider<T = unknown, R extends Route = Route>(target: R, method: string, type: unknown, provider: MethodPramBuilder<T, R>): void;
    protected static registerMiddleware<T extends Route = Route>(target: T, method: string, middleware: RPCMiddleware<T>): void;
    protected static makeErrorRPCResponse(request: Request, response: Response, err: ExError): IRawResPacket<unknown>;
    static callback(route: Route): ListenerCallback;
    static compose(routes: Route[]): ListenerCallback;
    constructor();
    protected buildCallParams(method: string, paramTypes: any[], request: Request | Notify, response: Response | null, connector: Connector): Promise<unknown[]>;
    private composeMiddleware;
    protected callMethod(method: string, request: Request, response: Response, connector: Connector): Promise<void>;
    protected callNotify(method: string, request: Notify, connector: Connector): Promise<void>;
    protected hasMethod(method: string): boolean | undefined;
    protected hasNotify(method: string): boolean | undefined;
}
export { Route };
//# sourceMappingURL=Route.d.ts.map