import { AnyRootConfig } from './internals/config';
import { ProcedureCallOptions } from './internals/procedureBuilder';
import { AnyProcedure, ProcedureArgs } from './procedure';
import { MaybePromise } from './types';
/** @internal **/
export type ProcedureRecord = Record<string, AnyProcedure>;
export interface ProcedureRouterRecord {
    [key: string]: AnyProcedure | AnyRouter;
}
export interface RouterDef<TConfig extends AnyRootConfig, TRecord extends ProcedureRouterRecord> {
    _config: TConfig;
    router: true;
    procedure?: never;
    procedures: TRecord;
    record: TRecord;
}
export type AnyRouterDef<TConfig extends AnyRootConfig = AnyRootConfig> = RouterDef<TConfig, any>;
type DecorateProcedure<TProcedure extends AnyProcedure> = (input: ProcedureArgs<TProcedure['_def']>[0]) => Promise<TProcedure['_def']['_output_out']>;
/**
 * @internal
 */
type DecoratedProcedureRecord<TProcedures extends ProcedureRouterRecord> = {
    [TKey in keyof TProcedures]: TProcedures[TKey] extends AnyRouter ? DecoratedProcedureRecord<TProcedures[TKey]['_def']['record']> : TProcedures[TKey] extends AnyProcedure ? DecorateProcedure<TProcedures[TKey]> : never;
};
/**
 * @internal
 */
export type RouterCaller<TDef extends AnyRouterDef> = (
/**
 * @note
 * If passing a function, we recommend it's a cached function
 * e.g. wrapped in `React.cache` to avoid unnecessary computations
 */
ctx: TDef['_config']['$types']['ctx'] | (() => MaybePromise<TDef['_config']['$types']['ctx']>)) => DecoratedProcedureRecord<TDef['record']>;
export interface Router<TDef extends AnyRouterDef> {
    _def: TDef;
    /**
     * @deprecated use `t.createCallerFactory(router)` instead
     * @see https://trpc.io/docs/server/server-side-calls
     */
    createCaller: RouterCaller<TDef>;
}
export type AnyRouter = Router<AnyRouterDef>;
/**
 * @internal
 */
export type CreateRouterInner<TConfig extends AnyRootConfig, TProcRouterRecord extends ProcedureRouterRecord> = Router<RouterDef<TConfig, TProcRouterRecord>> & 
/**
 * This adds ability to call procedures directly but is primarily used for quick access in type inference
 */
TProcRouterRecord;
/**
 * @internal
 */
export declare function createRouterFactory<TConfig extends AnyRootConfig>(config: TConfig): <TProcRouterRecord extends ProcedureRouterRecord>(procedures: TProcRouterRecord) => CreateRouterInner<TConfig, TProcRouterRecord>;
/**
 * @internal
 */
export declare function callProcedure(opts: ProcedureCallOptions & {
    procedures: ProcedureRouterRecord;
}): Promise<unknown>;
export declare function createCallerFactory<TConfig extends AnyRootConfig>(): <TRouter extends Router<AnyRouterDef<TConfig>>>(router: TRouter) => RouterCaller<TRouter["_def"]>;
export {};
//# sourceMappingURL=router.d.ts.map