import { C as Context, R as Router } from '../../shared/orpc-server.CtmmTVAK.cjs';
import { SendStandardResponseOptions, NodeHttpRequest, NodeHttpResponse } from '@rubenbupe/orpc-standard-server-node';
import { c as StandardHandlerPlugin, S as StandardHandleOptions, i as StandardHandler } from '../../shared/orpc-server.yPp7bTcU.cjs';
import { Interceptor, MaybeOptionalOptions } from '@rubenbupe/orpc-shared';
import { F as FriendlyStandardHandleOptions } from '../../shared/orpc-server.CfBrd_zX.cjs';
import { S as StandardRPCHandlerOptions } from '../../shared/orpc-server.DSvlhvoQ.cjs';
import '@rubenbupe/orpc-client';
import '@rubenbupe/orpc-contract';
import '@rubenbupe/orpc-standard-server';
import '@rubenbupe/orpc-client/standard';

type NodeHttpHandleResult = {
    matched: true;
} | {
    matched: false;
};
interface NodeHttpHandlerPlugin<T extends Context> extends StandardHandlerPlugin<T> {
    initRuntimeAdapter?(options: NodeHttpHandlerOptions<T>): void;
}
interface NodeHttpHandlerInterceptorOptions<T extends Context> extends StandardHandleOptions<T> {
    request: NodeHttpRequest;
    response: NodeHttpResponse;
    sendStandardResponseOptions: SendStandardResponseOptions;
}
interface NodeHttpHandlerOptions<T extends Context> extends SendStandardResponseOptions {
    adapterInterceptors?: Interceptor<NodeHttpHandlerInterceptorOptions<T>, NodeHttpHandleResult, unknown>[];
    plugins?: NodeHttpHandlerPlugin<T>[];
}
declare class NodeHttpHandler<T extends Context> implements NodeHttpHandler<T> {
    private readonly standardHandler;
    private readonly sendStandardResponseOptions;
    private readonly adapterInterceptors;
    constructor(standardHandler: StandardHandler<T>, options?: NoInfer<NodeHttpHandlerOptions<T>>);
    handle(request: NodeHttpRequest, response: NodeHttpResponse, ...rest: MaybeOptionalOptions<FriendlyStandardHandleOptions<T>>): Promise<NodeHttpHandleResult>;
}

interface BodyLimitPluginOptions {
    /**
     * The maximum size of the body in bytes.
     */
    maxBodySize: number;
}
declare class BodyLimitPlugin<T extends Context> implements NodeHttpHandlerPlugin<T> {
    private readonly maxBodySize;
    constructor(options: BodyLimitPluginOptions);
    initRuntimeAdapter(options: NodeHttpHandlerOptions<T>): void;
}

declare class RPCHandler<T extends Context> extends NodeHttpHandler<T> {
    constructor(router: Router<any, T>, options?: NoInfer<StandardRPCHandlerOptions<T> & NodeHttpHandlerOptions<T>>);
}

export { BodyLimitPlugin, NodeHttpHandler, RPCHandler };
export type { BodyLimitPluginOptions, NodeHttpHandleResult, NodeHttpHandlerInterceptorOptions, NodeHttpHandlerOptions, NodeHttpHandlerPlugin };