import { HTTPPath, ORPCError } from '@rubenbupe/orpc-client';
import { Meta, InferSchemaOutput, AnySchema, ErrorFromErrorMap } from '@rubenbupe/orpc-contract';
import { Interceptor } from '@rubenbupe/orpc-shared';
import { StandardResponse, StandardLazyRequest } from '@rubenbupe/orpc-standard-server';
import { a as AnyRouter, A as AnyProcedure, C as Context, P as ProcedureClientInterceptorOptions, R as Router } from './orpc-server.CtmmTVAK.mjs';

type StandardParams = Record<string, string>;
type StandardMatchResult = {
    path: readonly string[];
    procedure: AnyProcedure;
    params?: StandardParams;
} | undefined;
interface StandardMatcher {
    init(router: AnyRouter): void;
    match(method: string, pathname: HTTPPath): Promise<StandardMatchResult>;
}
interface StandardCodec {
    encode(output: unknown, procedure: AnyProcedure): StandardResponse;
    encodeError(error: ORPCError<any, any>): StandardResponse;
    decode(request: StandardLazyRequest, params: StandardParams | undefined, procedure: AnyProcedure): Promise<unknown>;
}

interface StandardHandleOptions<T extends Context> {
    prefix?: HTTPPath;
    context: T;
}
type StandardHandleResult = {
    matched: true;
    response: StandardResponse;
} | {
    matched: false;
    response: undefined;
};
interface StandardHandlerPlugin<TContext extends Context> {
    init?(options: StandardHandlerOptions<TContext>): void;
}
interface StandardHandlerInterceptorOptions<T extends Context> extends StandardHandleOptions<T> {
    request: StandardLazyRequest;
}
interface StandardHandlerOptions<TContext extends Context> {
    plugins?: StandardHandlerPlugin<TContext>[];
    /**
     * Interceptors at the request level, helpful when you want catch errors
     */
    interceptors?: Interceptor<StandardHandlerInterceptorOptions<TContext>, StandardHandleResult, unknown>[];
    /**
     * Interceptors at the root level, helpful when you want override the request/response
     */
    rootInterceptors?: Interceptor<StandardHandlerInterceptorOptions<TContext>, StandardHandleResult, unknown>[];
    /**
     *
     * Interceptors for procedure client.
     */
    clientInterceptors?: Interceptor<ProcedureClientInterceptorOptions<TContext, Record<never, never>, Meta>, InferSchemaOutput<AnySchema>, ErrorFromErrorMap<Record<never, never>>>[];
}
declare class StandardHandler<T extends Context> {
    private readonly matcher;
    private readonly codec;
    private readonly interceptors;
    private readonly clientInterceptors;
    private readonly rootInterceptors;
    constructor(router: Router<any, T>, matcher: StandardMatcher, codec: StandardCodec, options: NoInfer<StandardHandlerOptions<T>>);
    handle(request: StandardLazyRequest, options: StandardHandleOptions<T>): Promise<StandardHandleResult>;
}

export { StandardHandler as i };
export type { StandardHandleOptions as S, StandardHandlerOptions as a, StandardHandlerInterceptorOptions as b, StandardHandlerPlugin as c, StandardCodec as d, StandardParams as e, StandardMatcher as f, StandardMatchResult as g, StandardHandleResult as h };