import * as h3 from 'h3';
import { H3Event } from 'h3';
import { ResponseMeta } from '@trpc/server/http';
import { AnyRouter, inferRouterContext, inferRouterError, ProcedureType, TRPCError } from '@trpc/server';
import { TRPCResponse } from '@trpc/server/rpc';

type MaybePromise<T> = T | Promise<T>;
type CreateContextFn<TRouter extends AnyRouter> = (event: H3Event) => MaybePromise<inferRouterContext<TRouter>>;
interface ResponseMetaFnPayload<TRouter extends AnyRouter> {
    data: TRPCResponse<unknown, inferRouterError<TRouter>>[];
    ctx?: inferRouterContext<TRouter>;
    paths?: string[];
    type: ProcedureType | 'unknown';
    errors: TRPCError[];
}
type ResponseMetaFn<TRouter extends AnyRouter> = (opts: ResponseMetaFnPayload<TRouter>) => ResponseMeta;
interface OnErrorPayload<TRouter extends AnyRouter> {
    error: TRPCError;
    type: ProcedureType | 'unknown';
    path: string | undefined;
    req: H3Event['node']['req'];
    input: unknown;
    ctx: undefined | inferRouterContext<TRouter>;
}
type OnErrorFn<TRouter extends AnyRouter> = (opts: OnErrorPayload<TRouter>) => void;
interface ResolveHTTPRequestOptions<TRouter extends AnyRouter> {
    router: TRouter;
    createContext?: CreateContextFn<TRouter>;
    responseMeta?: ResponseMetaFn<TRouter>;
    onError?: OnErrorFn<TRouter>;
    batching?: {
        enabled: boolean;
    };
}
declare function createTrpcNitroHandler<TRouter extends AnyRouter>({ router, createContext, responseMeta, onError, batching, }: ResolveHTTPRequestOptions<TRouter>): h3.EventHandler<h3.EventHandlerRequest, Promise<string | undefined>>;

export { createTrpcNitroHandler };
export type { CreateContextFn, OnErrorFn, OnErrorPayload, ResolveHTTPRequestOptions, ResponseMetaFn, ResponseMetaFnPayload };