import { C as Context, R as Router } from '../../shared/orpc-server.CtmmTVAK.js';
import { c as StandardHandlerPlugin, S as StandardHandleOptions, i as StandardHandler } from '../../shared/orpc-server.BrY97_XD.js';
import { Interceptor, MaybeOptionalOptions } from '@rubenbupe/orpc-shared';
import { F as FriendlyStandardHandleOptions } from '../../shared/orpc-server.2wDUefFa.js';
import { ToFetchResponseOptions } from '@rubenbupe/orpc-standard-server-fetch';
import { S as StandardRPCHandlerOptions } from '../../shared/orpc-server.BoIsVLSO.js';
import '@rubenbupe/orpc-client';
import '@rubenbupe/orpc-contract';
import '@rubenbupe/orpc-standard-server';
import '@rubenbupe/orpc-client/standard';

type FetchHandleResult = {
    matched: true;
    response: Response;
} | {
    matched: false;
    response: undefined;
};
interface FetchHandlerPlugin<T extends Context> extends StandardHandlerPlugin<T> {
    initRuntimeAdapter?(options: FetchHandlerOptions<T>): void;
}
interface FetchHandlerInterceptorOptions<T extends Context> extends StandardHandleOptions<T> {
    request: Request;
    toFetchResponseOptions: ToFetchResponseOptions;
}
interface FetchHandlerOptions<T extends Context> extends ToFetchResponseOptions {
    adapterInterceptors?: Interceptor<FetchHandlerInterceptorOptions<T>, FetchHandleResult, unknown>[];
    plugins?: FetchHandlerPlugin<T>[];
}
declare class FetchHandler<T extends Context> {
    private readonly standardHandler;
    private readonly toFetchResponseOptions;
    private readonly adapterInterceptors;
    constructor(standardHandler: StandardHandler<T>, options?: NoInfer<FetchHandlerOptions<T>>);
    handle(request: Request, ...rest: MaybeOptionalOptions<FriendlyStandardHandleOptions<T>>): Promise<FetchHandleResult>;
}

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

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

export { BodyLimitPlugin, FetchHandler, RPCHandler };
export type { BodyLimitPluginOptions, FetchHandleResult, FetchHandlerInterceptorOptions, FetchHandlerOptions, FetchHandlerPlugin };