@trpc/server 11.19.0 → 11.21.1-canary.20.10e2ef98f

package/dist/{unstable-core-do-not-import-B9ZnrQAU.d.cts → unstable-core-do-not-import-Jynlfuqc.d.cts}

@@ -279,112 +279,96 @@ type inferParser<TParser extends Parser> = TParser extends ParserStandardSchemaE
 type ParseFn<TType> = (value: unknown) => Promise<TType> | TType;
 declare function getParseFn<TType>(procedureParser: Parser): ParseFn<TType>;
 //#endregion
-//#region src/unstable-core-do-not-import/middleware.d.ts
-/** @internal */
-declare const middlewareMarker: 'middlewareMarker' & {
-  __brand: 'middlewareMarker';
+//#region src/unstable-core-do-not-import/stream/jsonl.d.ts
+/**
+ * A subset of the standard ReadableStream properties needed by tRPC internally.
+ * @see ReadableStream from lib.dom.d.ts
+ */
+type WebReadableStreamEsque = {
+  getReader: () => ReadableStreamDefaultReader<Uint8Array>;
 };
-type MiddlewareMarker = typeof middlewareMarker;
-interface MiddlewareResultBase {
+type NodeJSReadableStreamEsque = {
+  on(eventName: string | symbol, listener: (...args: any[]) => void): NodeJSReadableStreamEsque;
+};
+declare function isPromise(value: unknown): value is Promise<unknown>;
+type Serialize$2 = (value: any) => any;
+type Deserialize$1 = (value: any) => any;
+type PathArray = readonly (string | number)[];
+type ProducerOnError = (opts: {
+  error: unknown;
+  path: PathArray;
+}) => void;
+interface JSONLProducerOptions {
+  serialize?: Serialize$2;
+  data: Record<string, unknown> | unknown[];
+  onError?: ProducerOnError;
+  formatError?: (opts: {
+    error: unknown;
+    path: PathArray;
+  }) => unknown;
+  maxDepth?: number;
   /**
-   * All middlewares should pass through their `next()`'s output.
-   * Requiring this marker makes sure that can't be forgotten at compile-time.
+   * Interval in milliseconds to send a ping to the client to keep the connection alive
+   * This will be sent as a whitespace character
+   * @default undefined
    */
-  readonly marker: MiddlewareMarker;
-}
-interface MiddlewareOKResult<_TContextOverride> extends MiddlewareResultBase {
-  ok: true;
-  data: unknown;
-}
-interface MiddlewareErrorResult<_TContextOverride> extends MiddlewareResultBase {
-  ok: false;
-  error: TRPCError;
+  pingMs?: number;
 }
 /**
- * @internal
+ * JSON Lines stream producer
+ * @see https://jsonlines.org/
  */
-type MiddlewareResult<_TContextOverride> = MiddlewareErrorResult<_TContextOverride> | MiddlewareOKResult<_TContextOverride>;
+declare function jsonlStreamProducer(opts: JSONLProducerOptions): ReadableStream<Uint8Array<ArrayBuffer>>;
+type ConsumerOnError = (opts: {
+  error: unknown;
+}) => void;
 /**
- * @internal
+ * JSON Lines stream consumer
+ * @see https://jsonlines.org/
  */
-interface MiddlewareBuilder<TContext, TMeta, TContextOverrides, TInputOut> {
-  /**
-   * Create a new builder based on the current middleware builder
-   */
-  unstable_pipe<$ContextOverridesOut>(fn: MiddlewareFunction<TContext, TMeta, TContextOverrides, $ContextOverridesOut, TInputOut> | MiddlewareBuilder<Overwrite<TContext, TContextOverrides>, TMeta, $ContextOverridesOut, TInputOut>): MiddlewareBuilder<TContext, TMeta, Overwrite<TContextOverrides, $ContextOverridesOut>, TInputOut>;
+declare function jsonlStreamConsumer<THead>(opts: {
+  from: NodeJSReadableStreamEsque | WebReadableStreamEsque;
+  deserialize?: Deserialize$1;
+  onError?: ConsumerOnError;
+  formatError?: (opts: {
+    error: unknown;
+  }) => Error;
   /**
-   * List of middlewares within this middleware builder
+   * This `AbortController` will be triggered when there are no more listeners to the stream.
    */
-  _middlewares: MiddlewareFunction<TContext, TMeta, TContextOverrides, object, TInputOut>[];
-}
-/**
- * @internal
- */
-type MiddlewareFunction<TContext, TMeta, TContextOverridesIn, $ContextOverridesOut, TInputOut> = {
-  (opts: {
-    ctx: Simplify<Overwrite<TContext, TContextOverridesIn>>;
-    type: ProcedureType;
-    path: string;
-    input: TInputOut;
-    getRawInput: GetRawInputFn;
-    meta: TMeta | undefined;
-    signal: AbortSignal | undefined;
-    /**
-     * The index of this call in a batch request.
-     */
-    batchIndex: number;
-    next: {
-      (): Promise<MiddlewareResult<TContextOverridesIn>>;
-      <$ContextOverride>(opts: {
-        ctx?: $ContextOverride;
-        input?: unknown;
-      }): Promise<MiddlewareResult<$ContextOverride>>;
-      (opts: {
-        getRawInput: GetRawInputFn;
-      }): Promise<MiddlewareResult<TContextOverridesIn>>;
-    };
-  }): Promise<MiddlewareResult<$ContextOverridesOut>>;
-  _type?: string | undefined;
-};
-type AnyMiddlewareFunction = MiddlewareFunction<any, any, any, any, any>;
-type AnyMiddlewareBuilder = MiddlewareBuilder<any, any, any, any>;
-/**
- * @internal
- */
-declare function createMiddlewareFactory<TContext, TMeta, TInputOut = unknown>(): <$ContextOverrides>(fn: MiddlewareFunction<TContext, TMeta, object, $ContextOverrides, TInputOut>) => MiddlewareBuilder<TContext, TMeta, $ContextOverrides, TInputOut>;
-/**
- * Create a standalone middleware
- * @see https://trpc.io/docs/v11/server/middlewares#experimental-standalone-middlewares
- * @deprecated use `.concat()` instead
- */
-declare const experimental_standaloneMiddleware: <TCtx extends {
-  ctx?: object;
-  meta?: object;
-  input?: unknown;
-}>() => {
-  create: <$ContextOverrides>(fn: MiddlewareFunction<TCtx extends {
-    ctx: infer T extends object;
-  } ? T : any, TCtx extends {
-    meta: infer T_1 extends object;
-  } ? T_1 : object, object, $ContextOverrides, TCtx extends {
-    input: infer T_2;
-  } ? T_2 : unknown>) => MiddlewareBuilder<TCtx extends {
-    ctx: infer T extends object;
-  } ? T : any, TCtx extends {
-    meta: infer T_1 extends object;
-  } ? T_1 : object, $ContextOverrides, TCtx extends {
-    input: infer T_2;
-  } ? T_2 : unknown>;
-};
-/**
- * @internal
- * Please note, `trpc-openapi` uses this function.
- */
-declare function createInputMiddleware<TInput>(parse: ParseFn<TInput>): AnyMiddlewareFunction;
+  abortController: AbortController;
+}): Promise<readonly [Awaited<THead>]>;
+//#endregion
+//#region src/unstable-core-do-not-import/stream/sse.types.d.ts
 /**
  * @internal
  */
-declare function createOutputMiddleware<TOutput>(parse: ParseFn<TOutput>): AnyMiddlewareFunction;
+declare namespace EventSourceLike {
+  export interface InitDict {
+    withCredentials?: boolean;
+  }
+  export interface MessageEvent extends Event {
+    data: any;
+    lastEventId?: string;
+  }
+  export interface Event {}
+  type EventSourceListenerLike = (event: Event) => void;
+  export type AnyConstructorLike<TInit extends InitDict> = new (url: string, eventSourceInitDict?: TInit) => Instance;
+  export interface Instance {
+    readonly CLOSED: number;
+    readonly CONNECTING: number;
+    readonly OPEN: number;
+    addEventListener(type: string, listener: EventSourceListenerLike): void;
+    removeEventListener(type: string, listener: EventSourceListenerLike): void;
+    close: () => void;
+    readyState: number;
+  }
+  export type AnyConstructor = AnyConstructorLike<any>;
+  export type ListenerOf<T extends AnyConstructor> = Parameters<InstanceType<T>['addEventListener']>[1];
+  export type EventOf<T extends AnyConstructor> = Parameters<ListenerOf<T>>[0];
+  export type InitDictOf<T extends AnyConstructor> = ConstructorParameters<T>[1];
+  export {};
+}
 //#endregion
 //#region src/unstable-core-do-not-import/stream/tracked.d.ts
 declare const trackedSymbol: unique symbol;
@@ -417,288 +401,302 @@ declare function isTrackedEnvelope<TData>(value: unknown): value is TrackedEnvel
 declare function tracked<TData>(id: string, data: TData): TrackedEnvelope<TData>;
 type inferTrackedOutput<TData> = TData extends TrackedEnvelope<infer $Data> ? TrackedData<$Data> : TData;
 //#endregion
-//#region src/unstable-core-do-not-import/utils.d.ts
-/** @internal */
-type UnsetMarker = 'unsetMarker' & {
-  __brand: 'unsetMarker';
-};
-/**
- * Ensures there are no duplicate keys when building a procedure.
- * @internal
- */
-declare function mergeWithoutOverrides<TType extends Record<string, unknown>>(obj1: TType, ...objs: Partial<TType>[]): TType;
-/**
- * Check that value is object
- * @internal
- */
-declare function isObject(value: unknown): value is Record<string, unknown>;
-type AnyFn = ((...args: any[]) => unknown) & Record<keyof any, unknown>;
-declare function isFunction(fn: unknown): fn is AnyFn;
+//#region src/unstable-core-do-not-import/stream/sse.d.ts
+type Serialize$1 = (value: any) => any;
+type Deserialize = (value: any) => any;
 /**
- * Create an object without inheriting anything from `Object.prototype`
  * @internal
  */
-declare function emptyObject<TObj extends Record<string, unknown>>(): TObj;
-declare function isAsyncIterable<TValue>(value: unknown): value is AsyncIterable<TValue>;
-/**
- * Run an IIFE
- */
-declare const run: <TValue>(fn: () => TValue) => TValue;
-declare function noop(): void;
-declare function identity<T>(it: T): T;
-/**
- * Generic runtime assertion function. Throws, if the condition is not `true`.
- *
- * Can be used as a slightly less dangerous variant of type assertions. Code
- * mistakes would be revealed at runtime then (hopefully during testing).
- */
-declare function assert(condition: boolean, msg?: string): asserts condition;
-declare function sleep(ms?: number): Promise<void>;
-/**
- * Ponyfill for
- * [`AbortSignal.any`](https://developer.mozilla.org/en-US/docs/Web/API/AbortSignal/any_static).
- */
-declare function abortSignalsAnyPonyfill(signals: AbortSignal[]): AbortSignal;
-//#endregion
-//#region src/unstable-core-do-not-import/procedureBuilder.d.ts
-type IntersectIfDefined<TType, TWith> = TType extends UnsetMarker ? TWith : TWith extends UnsetMarker ? TType : Simplify<TType & TWith>;
-type DefaultValue<TValue, TFallback> = TValue extends UnsetMarker ? TFallback : TValue;
-type inferAsyncIterable<TOutput> = TOutput extends AsyncIterable<infer $Yield, infer $Return, infer $Next> ? {
-  yield: $Yield;
-  return: $Return;
-  next: $Next;
-} : never;
-type inferSubscriptionOutput$1<TOutput> = TOutput extends AsyncIterable<any> ? AsyncIterable<inferTrackedOutput<inferAsyncIterable<TOutput>['yield']>, inferAsyncIterable<TOutput>['return'], inferAsyncIterable<TOutput>['next']> : TypeError<'Subscription output could not be inferred'>;
-type CallerOverride<TContext> = (opts: {
-  args: unknown[];
-  invoke: (opts: ProcedureCallOptions<TContext>) => Promise<unknown>;
-  _def: AnyProcedure['_def'];
-}) => Promise<unknown>;
-type ProcedureBuilderDef<TMeta> = {
-  procedure: true;
-  inputs: Parser[];
-  output?: Parser;
-  meta?: TMeta;
-  resolver?: ProcedureBuilderResolver;
-  middlewares: AnyMiddlewareFunction[];
+interface SSEPingOptions {
   /**
-   * @deprecated use `type` instead
+   * Enable ping comments sent from the server
+   * @default false
    */
-  mutation?: boolean;
+  enabled: boolean;
   /**
-   * @deprecated use `type` instead
+   * Interval in milliseconds
+   * @default 1000
    */
-  query?: boolean;
+  intervalMs?: number;
+}
+interface SSEClientOptions {
   /**
-   * @deprecated use `type` instead
+   * Timeout and reconnect after inactivity in milliseconds
+   * @default undefined
    */
-  subscription?: boolean;
-  type?: ProcedureType;
-  caller?: CallerOverride<unknown>;
-};
-type AnyProcedureBuilderDef = ProcedureBuilderDef<any>;
-/**
- * Procedure resolver options (what the `.query()`, `.mutation()`, and `.subscription()` functions receive)
- * @internal
- */
-interface ProcedureResolverOptions<TContext, _TMeta, TContextOverridesIn, TInputOut> {
-  ctx: Simplify<Overwrite<TContext, TContextOverridesIn>>;
-  input: TInputOut extends UnsetMarker ? undefined : TInputOut;
+  reconnectAfterInactivityMs?: number;
+}
+interface SSEStreamProducerOptions<TValue = unknown> {
+  serialize?: Serialize$1;
+  data: AsyncIterable<TValue>;
+  maxDepth?: number;
+  ping?: SSEPingOptions;
   /**
-   * The AbortSignal of the request
+   * Maximum duration in milliseconds for the request before ending the stream
+   * @default undefined
    */
-  signal: AbortSignal | undefined;
+  maxDurationMs?: number;
   /**
-   * The path of the procedure
+   * End the request immediately after data is sent
+   * Only useful for serverless runtimes that do not support streaming responses
+   * @default false
    */
-  path: string;
+  emitAndEndImmediately?: boolean;
+  formatError?: (opts: {
+    error: unknown;
+  }) => unknown;
   /**
-   * The index of this call in a batch request.
-   * Will be set when the procedure is called as part of a batch.
+   * Client-specific options - these will be sent to the client as part of the first message
+   * @default {}
    */
-  batchIndex?: number;
+  client?: SSEClientOptions;
 }
 /**
- * A procedure resolver
+ *
+ * @see https://html.spec.whatwg.org/multipage/server-sent-events.html
  */
-type ProcedureResolver<TContext, TMeta, TContextOverrides, TInputOut, TOutputParserIn, $Output> = (opts: ProcedureResolverOptions<TContext, TMeta, TContextOverrides, TInputOut>) => MaybePromise<DefaultValue<TOutputParserIn, $Output>>;
-type AnyProcedureBuilder = ProcedureBuilder<any, any, any, any, any, any, any, any>;
+declare function sseStreamProducer<TValue = unknown>(opts: SSEStreamProducerOptions<TValue>): ReadableStream<Uint8Array<ArrayBuffer>>;
+interface ConsumerStreamResultBase<TConfig extends ConsumerConfig> {
+  eventSource: InstanceType<TConfig['EventSource']> | null;
+}
+interface ConsumerStreamResultData<TConfig extends ConsumerConfig> extends ConsumerStreamResultBase<TConfig> {
+  type: 'data';
+  data: inferTrackedOutput<TConfig['data']>;
+}
+interface ConsumerStreamResultError<TConfig extends ConsumerConfig> extends ConsumerStreamResultBase<TConfig> {
+  type: 'serialized-error';
+  error: TConfig['error'];
+}
+interface ConsumerStreamResultConnecting<TConfig extends ConsumerConfig> extends ConsumerStreamResultBase<TConfig> {
+  type: 'connecting';
+  event: EventSourceLike.EventOf<TConfig['EventSource']> | null;
+}
+interface ConsumerStreamResultTimeout<TConfig extends ConsumerConfig> extends ConsumerStreamResultBase<TConfig> {
+  type: 'timeout';
+  ms: number;
+}
+interface ConsumerStreamResultPing<TConfig extends ConsumerConfig> extends ConsumerStreamResultBase<TConfig> {
+  type: 'ping';
+}
+interface ConsumerStreamResultConnected<TConfig extends ConsumerConfig> extends ConsumerStreamResultBase<TConfig> {
+  type: 'connected';
+  options: SSEClientOptions;
+}
+type ConsumerStreamResult<TConfig extends ConsumerConfig> = ConsumerStreamResultData<TConfig> | ConsumerStreamResultError<TConfig> | ConsumerStreamResultConnecting<TConfig> | ConsumerStreamResultTimeout<TConfig> | ConsumerStreamResultPing<TConfig> | ConsumerStreamResultConnected<TConfig>;
+interface SSEStreamConsumerOptions<TConfig extends ConsumerConfig> {
+  url: () => MaybePromise<string>;
+  init: () => MaybePromise<EventSourceLike.InitDictOf<TConfig['EventSource']>> | undefined;
+  signal: AbortSignal;
+  deserialize?: Deserialize;
+  EventSource: TConfig['EventSource'];
+}
+interface ConsumerConfig {
+  data: unknown;
+  error: unknown;
+  EventSource: EventSourceLike.AnyConstructor;
+}
 /**
- * Infer the context type from a procedure builder
- * Useful to create common helper functions for different procedures
+ * @see https://html.spec.whatwg.org/multipage/server-sent-events.html
  */
-type inferProcedureBuilderResolverOptions<TProcedureBuilder extends AnyProcedureBuilder> = TProcedureBuilder extends ProcedureBuilder<infer TContext, infer TMeta, infer TContextOverrides, infer _TInputIn, infer TInputOut, infer _TOutputIn, infer _TOutputOut, infer _TCaller> ? ProcedureResolverOptions<TContext, TMeta, TContextOverrides, TInputOut extends UnsetMarker ? unknown : TInputOut extends object ? Simplify<TInputOut & {
-  /**
-   * Extra input params might have been added by a `.input()` further down the chain
-   */
-  [keyAddedByInputCallFurtherDown: string]: unknown;
-}> : TInputOut> : never;
-interface ProcedureBuilder<TContext, TMeta, TContextOverrides, TInputIn, TInputOut, TOutputIn, TOutputOut, TCaller extends boolean> {
-  /**
-   * Add an input parser to the procedure.
-   * @see https://trpc.io/docs/v11/server/validators
-   */
-  input<$Parser extends Parser>(schema: TInputOut extends UnsetMarker ? $Parser : inferParser<$Parser>['out'] extends Record<string, unknown> | undefined ? TInputOut extends Record<string, unknown> | undefined ? undefined extends inferParser<$Parser>['out'] ? undefined extends TInputOut ? $Parser : TypeError<'Cannot chain an optional parser to a required parser'> : $Parser : TypeError<'All input parsers did not resolve to an object'> : TypeError<'All input parsers did not resolve to an object'>): ProcedureBuilder<TContext, TMeta, TContextOverrides, IntersectIfDefined<TInputIn, inferParser<$Parser>['in']>, IntersectIfDefined<TInputOut, inferParser<$Parser>['out']>, TOutputIn, TOutputOut, TCaller>;
-  /**
-   * Add an output parser to the procedure.
-   * @see https://trpc.io/docs/v11/server/validators
-   */
-  output<$Parser extends Parser>(schema: $Parser): ProcedureBuilder<TContext, TMeta, TContextOverrides, TInputIn, TInputOut, IntersectIfDefined<TOutputIn, inferParser<$Parser>['in']>, IntersectIfDefined<TOutputOut, inferParser<$Parser>['out']>, TCaller>;
-  /**
-   * Add a meta data to the procedure.
-   * @see https://trpc.io/docs/v11/server/metadata
-   */
-  meta(meta: TMeta): ProcedureBuilder<TContext, TMeta, TContextOverrides, TInputIn, TInputOut, TOutputIn, TOutputOut, TCaller>;
-  /**
-   * Add a middleware to the procedure.
-   * @see https://trpc.io/docs/v11/server/middlewares
-   */
-  use<$ContextOverridesOut>(fn: MiddlewareBuilder<Overwrite<TContext, TContextOverrides>, TMeta, $ContextOverridesOut, TInputOut> | MiddlewareFunction<TContext, TMeta, TContextOverrides, $ContextOverridesOut, TInputOut>): ProcedureBuilder<TContext, TMeta, Overwrite<TContextOverrides, $ContextOverridesOut>, TInputIn, TInputOut, TOutputIn, TOutputOut, TCaller>;
+declare function sseStreamConsumer<TConfig extends ConsumerConfig>(opts: SSEStreamConsumerOptions<TConfig>): AsyncIterable<ConsumerStreamResult<TConfig>>;
+declare const sseHeaders: {
+  readonly 'Content-Type': 'text/event-stream';
+  readonly 'Cache-Control': 'no-cache, no-transform';
+  readonly 'X-Accel-Buffering': 'no';
+  readonly Connection: 'keep-alive';
+};
+//#endregion
+//#region src/unstable-core-do-not-import/rootConfig.d.ts
+/**
+ * The initial generics that are used in the init function
+ * @internal
+ */
+interface RootTypes {
+  ctx: object;
+  meta: object;
+  errorShape: DefaultErrorShape;
+  transformer: boolean;
+}
+/**
+ * The default check to see if we're in a server
+ */
+declare const isServerDefault: boolean;
+/**
+ * The default check to see if we're in development
+ */
+declare function isDevDefault(): boolean;
+/**
+ * The tRPC root config
+ * @internal
+ */
+interface RootConfig<TTypes extends RootTypes> {
   /**
-   * @deprecated use {@link concat} instead
+   * The types that are used in the config
+   * @internal
    */
-  unstable_concat<$Context, $Meta, $ContextOverrides, $InputIn, $InputOut, $OutputIn, $OutputOut>(builder: Overwrite<TContext, TContextOverrides> extends $Context ? TMeta extends $Meta ? ProcedureBuilder<$Context, $Meta, $ContextOverrides, $InputIn, $InputOut, $OutputIn, $OutputOut, TCaller> : TypeError<'Meta mismatch'> : TypeError<'Context mismatch'>): ProcedureBuilder<TContext, TMeta, Overwrite<TContextOverrides, $ContextOverrides>, IntersectIfDefined<TInputIn, $InputIn>, IntersectIfDefined<TInputOut, $InputOut>, IntersectIfDefined<TOutputIn, $OutputIn>, IntersectIfDefined<TOutputOut, $OutputOut>, TCaller>;
+  $types: TTypes;
   /**
-   * Combine two procedure builders
+   * Use a data transformer
+   * @see https://trpc.io/docs/v11/data-transformers
    */
-  concat<$Context, $Meta, $ContextOverrides, $InputIn, $InputOut, $OutputIn, $OutputOut>(builder: Overwrite<TContext, TContextOverrides> extends $Context ? TMeta extends $Meta ? ProcedureBuilder<$Context, $Meta, $ContextOverrides, $InputIn, $InputOut, $OutputIn, $OutputOut, TCaller> : TypeError<'Meta mismatch'> : TypeError<'Context mismatch'>): ProcedureBuilder<TContext, TMeta, Overwrite<TContextOverrides, $ContextOverrides>, IntersectIfDefined<TInputIn, $InputIn>, IntersectIfDefined<TInputOut, $InputOut>, IntersectIfDefined<TOutputIn, $OutputIn>, IntersectIfDefined<TOutputOut, $OutputOut>, TCaller>;
+  transformer: CombinedDataTransformer;
   /**
-   * Query procedure
-   * @see https://trpc.io/docs/v11/concepts#vocabulary
+   * Use custom error formatting
+   * @see https://trpc.io/docs/v11/error-formatting
    */
-  query<$Output>(resolver: ProcedureResolver<TContext, TMeta, TContextOverrides, TInputOut, TOutputIn, $Output>): TCaller extends true ? (input: DefaultValue<TInputIn, void>) => Promise<DefaultValue<TOutputOut, $Output>> : QueryProcedure<{
-    input: DefaultValue<TInputIn, void>;
-    output: DefaultValue<TOutputOut, $Output>;
-    meta: TMeta;
-  }>;
+  errorFormatter: ErrorFormatter<TTypes['ctx'], TTypes['errorShape']>;
   /**
-   * Mutation procedure
-   * @see https://trpc.io/docs/v11/concepts#vocabulary
+   * Allow `@trpc/server` to run in non-server environments
+   * @warning **Use with caution**, this should likely mainly be used within testing.
+   * @default false
    */
-  mutation<$Output>(resolver: ProcedureResolver<TContext, TMeta, TContextOverrides, TInputOut, TOutputIn, $Output>): TCaller extends true ? (input: DefaultValue<TInputIn, void>) => Promise<DefaultValue<TOutputOut, $Output>> : MutationProcedure<{
-    input: DefaultValue<TInputIn, void>;
-    output: DefaultValue<TOutputOut, $Output>;
-    meta: TMeta;
-  }>;
+  allowOutsideOfServer: boolean;
   /**
-   * Subscription procedure
-   * @see https://trpc.io/docs/v11/server/subscriptions
+   * Is this a server environment?
+   * @warning **Use with caution**, this should likely mainly be used within testing.
+   * @default typeof window === 'undefined' || 'Deno' in window || process.env.NODE_ENV === 'test'
    */
-  subscription<$Output extends AsyncIterable<any, void, any>>(resolver: ProcedureResolver<TContext, TMeta, TContextOverrides, TInputOut, TOutputIn, $Output>): TCaller extends true ? TypeError<'Not implemented'> : SubscriptionProcedure<{
-    input: DefaultValue<TInputIn, void>;
-    output: inferSubscriptionOutput$1<DefaultValue<TOutputOut, $Output>>;
-    meta: TMeta;
-  }>;
+  isServer: boolean;
   /**
-   * @deprecated Using subscriptions with an observable is deprecated. Use an async generator instead.
-   * This feature will be removed in v12 of tRPC.
-   * @see https://trpc.io/docs/v11/server/subscriptions
+   * Is this development?
+   * Will be used to decide if the API should return stack traces
+   * @default process.env.NODE_ENV !== 'production'
    */
-  subscription<$Output extends Observable<any, any>>(resolver: ProcedureResolver<TContext, TMeta, TContextOverrides, TInputOut, TOutputIn, $Output>): TCaller extends true ? TypeError<'Not implemented'> : LegacyObservableSubscriptionProcedure<{
-    input: DefaultValue<TInputIn, void>;
-    output: inferObservableValue<DefaultValue<TOutputOut, $Output>>;
-    meta: TMeta;
-  }>;
+  isDev: boolean;
+  defaultMeta?: TTypes['meta'] extends object ? TTypes['meta'] : never;
   /**
-   * Overrides the way a procedure is invoked
-   * Do not use this unless you know what you're doing - this is an experimental API
+   * Options for server-sent events (SSE) subscriptions
+   * @see https://trpc.io/docs/client/links/httpSubscriptionLink
    */
-  experimental_caller(caller: CallerOverride<TContext>): ProcedureBuilder<TContext, TMeta, TContextOverrides, TInputIn, TInputOut, TOutputIn, TOutputOut, true>;
+  sse?: {
+    /**
+     * Enable server-sent events (SSE) subscriptions
+     * @default true
+     */
+    enabled?: boolean;
+  } & Pick<SSEStreamProducerOptions, 'ping' | 'emitAndEndImmediately' | 'maxDurationMs' | 'client'>;
   /**
-   * @internal
+   * Options for batch stream
+   * @see https://trpc.io/docs/client/links/httpBatchStreamLink
    */
-  _def: ProcedureBuilderDef<TMeta>;
+  jsonl?: Pick<JSONLProducerOptions, 'pingMs'>;
+  experimental?: {};
 }
-type ProcedureBuilderResolver = (opts: ProcedureResolverOptions<any, any, any, any>) => Promise<unknown>;
-declare function createBuilder<TContext, TMeta>(initDef?: Partial<AnyProcedureBuilderDef>): ProcedureBuilder<TContext, TMeta, object, UnsetMarker, UnsetMarker, UnsetMarker, UnsetMarker, false>;
 /**
  * @internal
  */
-interface ProcedureCallOptions<TContext> {
-  ctx: TContext;
-  getRawInput: GetRawInputFn;
-  input?: unknown;
-  path: string;
-  type: ProcedureType;
-  signal: AbortSignal | undefined;
+type CreateRootTypes<TGenerics extends RootTypes> = TGenerics;
+type AnyRootTypes = CreateRootTypes<{
+  ctx: any;
+  meta: any;
+  errorShape: any;
+  transformer: any;
+}>;
+type PartialIf<TCondition extends boolean, TType> = TCondition extends true ? Partial<TType> : TType;
+/**
+ * Adds a `createContext` option with a given callback function
+ * If context is the default value, then the `createContext` option is optional
+ */
+type CreateContextCallback<TContext, TFunction extends (...args: any[]) => any> = PartialIf<object extends TContext ? true : false, {
   /**
-   * The index of this call in a batch request.
-   */
-  batchIndex: number;
-}
+   * @see https://trpc.io/docs/v11/context
+   **/
+  createContext: TFunction;
+}>;
 //#endregion
-//#region src/unstable-core-do-not-import/procedure.d.ts
-declare const procedureTypes: readonly ['query', 'mutation', 'subscription'];
+//#region src/unstable-core-do-not-import/router.d.ts
+interface RouterRecord {
+  [key: string]: AnyProcedure | RouterRecord;
+}
+type DecorateProcedure<TProcedure extends AnyProcedure> = (input: inferProcedureInput<TProcedure>) => Promise<TProcedure['_def']['type'] extends 'subscription' ? TProcedure extends LegacyObservableSubscriptionProcedure<any> ? Observable<inferProcedureOutput<TProcedure>, TRPCError> : inferProcedureOutput<TProcedure> : inferProcedureOutput<TProcedure>>;
 /**
- * @public
+ * @internal
  */
-type ProcedureType = (typeof procedureTypes)[number];
-interface BuiltProcedureDef {
-  meta: unknown;
-  input: unknown;
-  output: unknown;
-}
+type DecorateRouterRecord<TRecord extends RouterRecord> = { [TKey in keyof TRecord]: TRecord[TKey] extends (infer $Value) ? $Value extends AnyProcedure ? DecorateProcedure<$Value> : $Value extends RouterRecord ? DecorateRouterRecord<$Value> : never : never; };
 /**
- *
  * @internal
  */
-interface Procedure<TType extends ProcedureType, TDef extends BuiltProcedureDef> {
-  _def: {
-    /**
-     * These are just types, they can't be used at runtime
-     * @internal
-     */
-    $types: {
-      input: TDef['input'];
-      output: TDef['output'];
-    };
-    procedure: true;
-    type: TType;
-    /**
-     * @internal
-     * Meta is not inferrable on individual procedures, only on the router
-     */
-    meta: unknown;
-    experimental_caller: boolean;
-    /**
-     * The input parsers for the procedure
-     */
-    inputs: Parser[];
-  };
-  meta: TDef['meta'];
+type RouterCallerErrorHandler<TContext> = (opts: ErrorHandlerOptions<TContext>) => void;
+/**
+ * @internal
+ */
+type RouterCaller<TRoot extends AnyRootTypes, TRecord extends RouterRecord> = (
+/**
+ * @note
+ * If passing a function, we recommend it's a cached function
+ * e.g. wrapped in `React.cache` to avoid unnecessary computations
+ */
+ctx: TRoot['ctx'] | (() => MaybePromise<TRoot['ctx']>), options?: {
+  onError?: RouterCallerErrorHandler<TRoot['ctx']>;
+  signal?: AbortSignal;
+}) => DecorateRouterRecord<TRecord>;
+type Lazy<TAny> = (() => Promise<TAny>) & {};
+type LazyLoader<TAny> = {
+  load: () => Promise<void>;
+  ref: Lazy<TAny>;
+};
+/**
+ * Lazy load a router
+ * @see https://trpc.io/docs/server/merging-routers#lazy-load
+ */
+declare function lazy<TRouter extends AnyRouter>(importRouter: () => Promise<TRouter | {
+  [key: string]: TRouter;
+}>): Lazy<NoInfer<TRouter>>;
+/**
+ * @internal
+ */
+interface RouterDef<TRoot extends AnyRootTypes, TRecord extends RouterRecord> {
+  _config: RootConfig<TRoot>;
+  router: true;
+  procedure?: never;
+  procedures: TRecord;
+  record: TRecord;
+  lazy: Record<string, LazyLoader<AnyRouter>>;
+}
+interface Router<TRoot extends AnyRootTypes, TRecord extends RouterRecord> {
+  _def: RouterDef<TRoot, TRecord>;
   /**
-   * @internal
+   * @see https://trpc.io/docs/v11/server/server-side-calls
    */
-  (opts: ProcedureCallOptions<unknown>): Promise<TDef['output']>;
+  createCaller: RouterCaller<TRoot, TRecord>;
 }
-interface QueryProcedure<TDef extends BuiltProcedureDef> extends Procedure<'query', TDef> {}
-interface MutationProcedure<TDef extends BuiltProcedureDef> extends Procedure<'mutation', TDef> {}
-interface SubscriptionProcedure<TDef extends BuiltProcedureDef> extends Procedure<'subscription', TDef> {}
+type BuiltRouter<TRoot extends AnyRootTypes, TRecord extends RouterRecord> = Router<TRoot, TRecord> & TRecord;
+interface RouterBuilder<TRoot extends AnyRootTypes> {
+  <TIn extends CreateRouterOptions>(_: TIn): BuiltRouter<TRoot, DecorateCreateRouterOptions<TIn>>;
+}
+type AnyRouter = Router<any, any>;
+type inferRouterRootTypes<TRouter extends AnyRouter> = TRouter['_def']['_config']['$types'];
+type inferRouterContext<TRouter extends AnyRouter> = inferRouterRootTypes<TRouter>['ctx'];
+type inferRouterError<TRouter extends AnyRouter> = inferRouterRootTypes<TRouter>['errorShape'];
+type inferRouterMeta<TRouter extends AnyRouter> = inferRouterRootTypes<TRouter>['meta'];
+/** @internal */
+type CreateRouterOptions = {
+  [key: string]: AnyProcedure | AnyRouter | CreateRouterOptions | Lazy<AnyRouter>;
+};
+/** @internal */
+type DecorateCreateRouterOptions<TRouterOptions extends CreateRouterOptions> = { [K in keyof TRouterOptions]: TRouterOptions[K] extends (infer $Value) ? $Value extends AnyProcedure ? $Value : $Value extends Router<any, infer TRecord> ? TRecord : $Value extends Lazy<Router<any, infer TRecord>> ? TRecord : $Value extends CreateRouterOptions ? DecorateCreateRouterOptions<$Value> : never : never; };
 /**
- * @deprecated
+ * @internal
  */
-interface LegacyObservableSubscriptionProcedure<TDef extends BuiltProcedureDef> extends SubscriptionProcedure<TDef> {
-  _observable: true;
-}
-type AnyQueryProcedure = QueryProcedure<any>;
-type AnyMutationProcedure = MutationProcedure<any>;
-type AnySubscriptionProcedure = SubscriptionProcedure<any> | LegacyObservableSubscriptionProcedure<any>;
-type AnyProcedure = AnyQueryProcedure | AnyMutationProcedure | AnySubscriptionProcedure;
-type inferProcedureInput<TProcedure extends AnyProcedure> = undefined extends inferProcedureParams<TProcedure>['$types']['input'] ? void | inferProcedureParams<TProcedure>['$types']['input'] : inferProcedureParams<TProcedure>['$types']['input'];
-type inferProcedureParams<TProcedure> = TProcedure extends AnyProcedure ? TProcedure['_def'] : never;
-type inferProcedureOutput<TProcedure> = inferProcedureParams<TProcedure>['$types']['output'];
-type inferSubscriptionInput<TProcedure extends AnySubscriptionProcedure> = inferProcedureInput<TProcedure>;
-type inferSubscriptionOutput<TProcedure extends AnySubscriptionProcedure> = TProcedure extends LegacyObservableSubscriptionProcedure<any> ? inferProcedureOutput<TProcedure> : inferAsyncIterableYield<inferProcedureOutput<TProcedure>>;
+declare function createRouterFactory<TRoot extends AnyRootTypes>(config: RootConfig<TRoot>): <TInput extends CreateRouterOptions>(input: TInput) => BuiltRouter<TRoot, DecorateCreateRouterOptions<TInput>>;
 /**
  * @internal
  */
-interface ErrorHandlerOptions<TContext> {
-  error: TRPCError;
-  type: ProcedureType | 'unknown';
-  path: string | undefined;
-  input: unknown;
-  ctx: TContext | undefined;
+declare function getProcedureAtPath(router: Pick<Router<any, any>, '_def'>, path: string): Promise<AnyProcedure | null>;
+/**
+ * @internal
+ */
+declare function callProcedure(opts: ProcedureCallOptions<unknown> & {
+  router: AnyRouter;
+  allowMethodOverride?: boolean;
+}): Promise<any>;
+interface RouterCallerFactory<TRoot extends AnyRootTypes> {
+  <TRecord extends RouterRecord>(router: Pick<Router<TRoot, TRecord>, '_def'>): RouterCaller<TRoot, TRecord>;
 }
+declare function createCallerFactory<TRoot extends AnyRootTypes>(): RouterCallerFactory<TRoot>;
+/** @internal */
+type MergeRouters<TRouters extends AnyRouter[], TRoot extends AnyRootTypes = TRouters[0]['_def']['_config']['$types'], TRecord extends RouterRecord = {}> = TRouters extends [infer Head extends AnyRouter, ...infer Tail extends AnyRouter[]] ? MergeRouters<Tail, TRoot, Head['_def']['record'] & TRecord> : BuiltRouter<TRoot, TRecord>;
+declare function mergeRouters<TRouters extends AnyRouter[]>(...routerList: [...TRouters]): MergeRouters<TRouters>;
 //#endregion
 //#region src/unstable-core-do-not-import/http/types.d.ts
 /**
@@ -1017,13 +1015,13 @@ declare function transformTRPCResponse<TResponse extends TRPCResponse | TRPCResp
 declare function transformResultInner<TRouter extends AnyRouter, TOutput>(response: TRPCResponse<TOutput, inferRouterError<TRouter>> | TRPCResponseMessage<TOutput, inferRouterError<TRouter>>, transformer: DataTransformer): {
   readonly ok: false;
   readonly error: {
+    readonly error: inferRouterError<TRouter>;
     readonly id?: JSONRPC2.RequestId;
     readonly jsonrpc?: '2.0';
-    readonly error: inferRouterError<TRouter>;
   } | {
+    readonly error: inferRouterError<TRouter>;
     readonly jsonrpc?: '2.0';
     readonly id: JSONRPC2.RequestId;
-    readonly error: inferRouterError<TRouter>;
   };
   readonly result?: undefined;
 } | {
@@ -1051,14 +1049,26 @@ declare function parseTRPCMessage(obj: unknown, transformer: CombinedDataTransfo
 /**
  * @internal
  */
-type ErrorFormatter<TContext, TShape extends TRPCErrorShape> = (opts: {
+interface ErrorFormatterOptions<TContext> {
   error: TRPCError;
   type: ProcedureType | 'unknown';
   path: string | undefined;
   input: unknown;
-  ctx: TContext | undefined;
+  ctx: TContext;
   shape: DefaultErrorShape;
-}) => TShape;
+}
+/**
+ * @internal
+ */
+type ErrorFormatter<TContext, TShape extends TRPCErrorShape> = (opts: ErrorFormatterOptions<TContext | undefined>) => TShape;
+/**
+ * @internal
+ */
+type ProcedureErrorFormatter<TContext, TContextOverrides, TShape extends TRPCErrorShape | undefined | void> = (opts: ErrorFormatterOptions<Simplify<Overwrite<TContext, TContextOverrides>>>) => TShape;
+/**
+ * @internal
+ */
+type AnyProcedureErrorFormatter = ProcedureErrorFormatter<any, any, any>;
 /**
  * @internal
  */
@@ -1082,390 +1092,447 @@ interface DefaultErrorShape extends TRPCErrorShape<DefaultErrorData> {
   code: TRPC_ERROR_CODE_NUMBER;
 }
 declare const defaultFormatter: ErrorFormatter<any, any>;
-//#endregion
-//#region src/unstable-core-do-not-import/stream/jsonl.d.ts
 /**
- * A subset of the standard ReadableStream properties needed by tRPC internally.
- * @see ReadableStream from lib.dom.d.ts
+ * @internal
  */
-type WebReadableStreamEsque = {
-  getReader: () => ReadableStreamDefaultReader<Uint8Array>;
+declare function getDefaultErrorShape(opts: {
+  error: TRPCError;
+  path: string | undefined;
+  isDev: boolean;
+}): DefaultErrorShape;
+declare const formattedShapeSymbol: unique symbol;
+/**
+ * @internal
+ */
+declare function setFormattedErrorShape(error: TRPCError, shape: TRPCErrorShape): asserts error is TRPCError & {
+  [formattedShapeSymbol]: TRPCErrorShape;
 };
-type NodeJSReadableStreamEsque = {
-  on(eventName: string | symbol, listener: (...args: any[]) => void): NodeJSReadableStreamEsque;
+/**
+ * @internal
+ */
+declare function getFormattedErrorShape(error: TRPCError): TRPCErrorShape | undefined;
+declare function isFormattedErrorShape(error: TRPCError): error is TRPCError & {
+  [formattedShapeSymbol]: TRPCErrorShape;
 };
-declare function isPromise(value: unknown): value is Promise<unknown>;
-type Serialize$2 = (value: any) => any;
-type Deserialize$1 = (value: any) => any;
-type PathArray = readonly (string | number)[];
-type ProducerOnError = (opts: {
-  error: unknown;
-  path: PathArray;
-}) => void;
-interface JSONLProducerOptions {
-  serialize?: Serialize$2;
-  data: Record<string, unknown> | unknown[];
-  onError?: ProducerOnError;
-  formatError?: (opts: {
-    error: unknown;
-    path: PathArray;
-  }) => unknown;
-  maxDepth?: number;
+//#endregion
+//#region src/unstable-core-do-not-import/middleware.d.ts
+/** @internal */
+declare const middlewareMarker: 'middlewareMarker' & {
+  __brand: 'middlewareMarker';
+};
+type MiddlewareMarker = typeof middlewareMarker;
+interface MiddlewareResultBase {
   /**
-   * Interval in milliseconds to send a ping to the client to keep the connection alive
-   * This will be sent as a whitespace character
-   * @default undefined
+   * All middlewares should pass through their `next()`'s output.
+   * Requiring this marker makes sure that can't be forgotten at compile-time.
    */
-  pingMs?: number;
+  readonly marker: MiddlewareMarker;
+}
+interface MiddlewareOKResult<_TContextOverride> extends MiddlewareResultBase {
+  ok: true;
+  data: unknown;
+}
+interface MiddlewareErrorResult<_TContextOverride> extends MiddlewareResultBase {
+  ok: false;
+  error: TRPCError;
 }
 /**
- * JSON Lines stream producer
- * @see https://jsonlines.org/
+ * @internal
  */
-declare function jsonlStreamProducer(opts: JSONLProducerOptions): ReadableStream<Uint8Array<ArrayBuffer>>;
-type ConsumerOnError = (opts: {
-  error: unknown;
-}) => void;
+type MiddlewareResult<_TContextOverride> = MiddlewareErrorResult<_TContextOverride> | MiddlewareOKResult<_TContextOverride>;
 /**
- * JSON Lines stream consumer
- * @see https://jsonlines.org/
+ * @internal
  */
-declare function jsonlStreamConsumer<THead>(opts: {
-  from: NodeJSReadableStreamEsque | WebReadableStreamEsque;
-  deserialize?: Deserialize$1;
-  onError?: ConsumerOnError;
-  formatError?: (opts: {
-    error: unknown;
-  }) => Error;
+interface MiddlewareBuilder<TContext, TMeta, TContextOverrides, TInputOut> {
   /**
-   * This `AbortController` will be triggered when there are no more listeners to the stream.
+   * Create a new builder based on the current middleware builder
    */
-  abortController: AbortController;
-}): Promise<readonly [Awaited<THead>]>;
-//#endregion
-//#region src/unstable-core-do-not-import/stream/sse.types.d.ts
+  unstable_pipe<$ContextOverridesOut>(fn: MiddlewareFunction<TContext, TMeta, TContextOverrides, $ContextOverridesOut, TInputOut> | MiddlewareBuilder<Overwrite<TContext, TContextOverrides>, TMeta, $ContextOverridesOut, TInputOut>): MiddlewareBuilder<TContext, TMeta, Overwrite<TContextOverrides, $ContextOverridesOut>, TInputOut>;
+  /**
+   * List of middlewares within this middleware builder
+   */
+  _middlewares: MiddlewareFunction<TContext, TMeta, TContextOverrides, object, TInputOut>[];
+}
 /**
  * @internal
  */
-declare namespace EventSourceLike {
-  export interface InitDict {
-    withCredentials?: boolean;
-  }
-  export interface MessageEvent extends Event {
-    data: any;
-    lastEventId?: string;
-  }
-  export interface Event {}
-  type EventSourceListenerLike = (event: Event) => void;
-  export type AnyConstructorLike<TInit extends InitDict> = new (url: string, eventSourceInitDict?: TInit) => Instance;
-  export interface Instance {
-    readonly CLOSED: number;
-    readonly CONNECTING: number;
-    readonly OPEN: number;
-    addEventListener(type: string, listener: EventSourceListenerLike): void;
-    removeEventListener(type: string, listener: EventSourceListenerLike): void;
-    close: () => void;
-    readyState: number;
-  }
-  export type AnyConstructor = AnyConstructorLike<any>;
-  export type ListenerOf<T extends AnyConstructor> = Parameters<InstanceType<T>['addEventListener']>[1];
-  export type EventOf<T extends AnyConstructor> = Parameters<ListenerOf<T>>[0];
-  export type InitDictOf<T extends AnyConstructor> = ConstructorParameters<T>[1];
-  export {};
-}
+type MiddlewareFunction<TContext, TMeta, TContextOverridesIn, $ContextOverridesOut, TInputOut> = {
+  (opts: {
+    ctx: Simplify<Overwrite<TContext, TContextOverridesIn>>;
+    type: ProcedureType;
+    path: string;
+    input: TInputOut;
+    getRawInput: GetRawInputFn;
+    meta: TMeta | undefined;
+    signal: AbortSignal | undefined;
+    /**
+     * The index of this call in a batch request.
+     */
+    batchIndex: number;
+    next: {
+      (): Promise<MiddlewareResult<TContextOverridesIn>>;
+      <$ContextOverride>(opts: {
+        ctx?: $ContextOverride;
+        input?: unknown;
+      }): Promise<MiddlewareResult<$ContextOverride>>;
+      (opts: {
+        getRawInput: GetRawInputFn;
+      }): Promise<MiddlewareResult<TContextOverridesIn>>;
+    };
+  }): Promise<MiddlewareResult<$ContextOverridesOut>>;
+  _type?: string | undefined;
+};
+type AnyMiddlewareFunction = MiddlewareFunction<any, any, any, any, any>;
+type AnyMiddlewareBuilder = MiddlewareBuilder<any, any, any, any>;
+/**
+ * @internal
+ */
+declare function createMiddlewareFactory<TContext, TMeta, TInputOut = unknown>(): <$ContextOverrides>(fn: MiddlewareFunction<TContext, TMeta, object, $ContextOverrides, TInputOut>) => MiddlewareBuilder<TContext, TMeta, $ContextOverrides, TInputOut>;
+/**
+ * Create a standalone middleware
+ * @see https://trpc.io/docs/v11/server/middlewares#experimental-standalone-middlewares
+ * @deprecated use `.concat()` instead
+ */
+declare const experimental_standaloneMiddleware: <TCtx extends {
+  ctx?: object;
+  meta?: object;
+  input?: unknown;
+}>() => {
+  create: <$ContextOverrides>(fn: MiddlewareFunction<TCtx extends {
+    ctx: infer T extends object;
+  } ? T : any, TCtx extends {
+    meta: infer T_1 extends object;
+  } ? T_1 : object, object, $ContextOverrides, TCtx extends {
+    input: infer T_2;
+  } ? T_2 : unknown>) => MiddlewareBuilder<TCtx extends {
+    ctx: infer T extends object;
+  } ? T : any, TCtx extends {
+    meta: infer T_1 extends object;
+  } ? T_1 : object, $ContextOverrides, TCtx extends {
+    input: infer T_2;
+  } ? T_2 : unknown>;
+};
+/**
+ * @internal
+ * Please note, `trpc-openapi` uses this function.
+ */
+declare function createInputMiddleware<TInput>(parse: ParseFn<TInput>): AnyMiddlewareFunction;
+/**
+ * @internal
+ */
+declare function createErrorFormatterMiddleware(formatter: AnyProcedureErrorFormatter, isDev: boolean): AnyMiddlewareFunction;
+/**
+ * @internal
+ */
+declare function createOutputMiddleware<TOutput>(parse: ParseFn<TOutput>): AnyMiddlewareFunction;
 //#endregion
-//#region src/unstable-core-do-not-import/stream/sse.d.ts
-type Serialize$1 = (value: any) => any;
-type Deserialize = (value: any) => any;
+//#region src/unstable-core-do-not-import/utils.d.ts
+/** @internal */
+type UnsetMarker = 'unsetMarker' & {
+  __brand: 'unsetMarker';
+};
+/**
+ * Ensures there are no duplicate keys when building a procedure.
+ * @internal
+ */
+declare function mergeWithoutOverrides<TType extends Record<string, unknown>>(obj1: TType, ...objs: Partial<TType>[]): TType;
 /**
+ * Check that value is object
  * @internal
  */
-interface SSEPingOptions {
+declare function isObject(value: unknown): value is Record<string, unknown>;
+type AnyFn = ((...args: any[]) => unknown) & Record<keyof any, unknown>;
+declare function isFunction(fn: unknown): fn is AnyFn;
+/**
+ * Create an object without inheriting anything from `Object.prototype`
+ * @internal
+ */
+declare function emptyObject<TObj extends Record<string, unknown>>(): TObj;
+declare function isAsyncIterable<TValue>(value: unknown): value is AsyncIterable<TValue>;
+/**
+ * Run an IIFE
+ */
+declare const run: <TValue>(fn: () => TValue) => TValue;
+declare function noop(): void;
+declare function identity<T>(it: T): T;
+/**
+ * Generic runtime assertion function. Throws, if the condition is not `true`.
+ *
+ * Can be used as a slightly less dangerous variant of type assertions. Code
+ * mistakes would be revealed at runtime then (hopefully during testing).
+ */
+declare function assert(condition: boolean, msg?: string): asserts condition;
+declare function assertNever(value: never): never;
+declare function sleep(ms?: number): Promise<void>;
+/**
+ * Ponyfill for
+ * [`AbortSignal.any`](https://developer.mozilla.org/en-US/docs/Web/API/AbortSignal/any_static).
+ */
+declare function abortSignalsAnyPonyfill(signals: AbortSignal[]): AbortSignal;
+//#endregion
+//#region src/unstable-core-do-not-import/procedureBuilder.d.ts
+type IntersectIfDefined<TType, TWith> = TType extends UnsetMarker ? TWith : TWith extends UnsetMarker ? TType : Simplify<TType & TWith>;
+type DefaultValue<TValue, TFallback> = TValue extends UnsetMarker ? TFallback : TValue;
+type FoldErrorShape<TErrorShape, $Shape> = Extract<$Shape, TRPCErrorShape> | TErrorShape;
+type inferAsyncIterable<TOutput> = TOutput extends AsyncIterable<infer $Yield, infer $Return, infer $Next> ? {
+  yield: $Yield;
+  return: $Return;
+  next: $Next;
+} : never;
+type inferSubscriptionOutput$1<TOutput> = TOutput extends AsyncIterable<any> ? AsyncIterable<inferTrackedOutput<inferAsyncIterable<TOutput>['yield']>, inferAsyncIterable<TOutput>['return'], inferAsyncIterable<TOutput>['next']> : TypeError<'Subscription output could not be inferred'>;
+type CallerOverride<TContext> = (opts: {
+  args: unknown[];
+  invoke: (opts: ProcedureCallOptions<TContext>) => Promise<unknown>;
+  _def: AnyProcedure['_def'];
+}) => Promise<unknown>;
+type ProcedureBuilderDef<TMeta> = {
+  procedure: true;
+  inputs: Parser[];
+  output?: Parser;
+  meta?: TMeta;
+  resolver?: ProcedureBuilderResolver;
+  middlewares: AnyMiddlewareFunction[];
   /**
-   * Enable ping comments sent from the server
-   * @default false
+   * @deprecated use `type` instead
    */
-  enabled: boolean;
+  mutation?: boolean;
   /**
-   * Interval in milliseconds
-   * @default 1000
+   * @deprecated use `type` instead
    */
-  intervalMs?: number;
-}
-interface SSEClientOptions {
+  query?: boolean;
   /**
-   * Timeout and reconnect after inactivity in milliseconds
-   * @default undefined
+   * @deprecated use `type` instead
    */
-  reconnectAfterInactivityMs?: number;
-}
-interface SSEStreamProducerOptions<TValue = unknown> {
-  serialize?: Serialize$1;
-  data: AsyncIterable<TValue>;
-  maxDepth?: number;
-  ping?: SSEPingOptions;
+  subscription?: boolean;
+  type?: ProcedureType;
+  caller?: CallerOverride<unknown>;
+  config?: RootConfig<AnyRootTypes>;
+};
+type AnyProcedureBuilderDef = ProcedureBuilderDef<any>;
+/**
+ * Procedure resolver options (what the `.query()`, `.mutation()`, and `.subscription()` functions receive)
+ * @internal
+ */
+interface ProcedureResolverOptions<TContext, _TMeta, TContextOverridesIn, TInputOut> {
+  ctx: Simplify<Overwrite<TContext, TContextOverridesIn>>;
+  input: TInputOut extends UnsetMarker ? undefined : TInputOut;
   /**
-   * Maximum duration in milliseconds for the request before ending the stream
-   * @default undefined
+   * The AbortSignal of the request
    */
-  maxDurationMs?: number;
+  signal: AbortSignal | undefined;
   /**
-   * End the request immediately after data is sent
-   * Only useful for serverless runtimes that do not support streaming responses
-   * @default false
+   * The path of the procedure
    */
-  emitAndEndImmediately?: boolean;
-  formatError?: (opts: {
-    error: unknown;
-  }) => unknown;
+  path: string;
   /**
-   * Client-specific options - these will be sent to the client as part of the first message
-   * @default {}
+   * The index of this call in a batch request.
+   * Will be set when the procedure is called as part of a batch.
    */
-  client?: SSEClientOptions;
-}
-/**
- *
- * @see https://html.spec.whatwg.org/multipage/server-sent-events.html
- */
-declare function sseStreamProducer<TValue = unknown>(opts: SSEStreamProducerOptions<TValue>): ReadableStream<Uint8Array<ArrayBuffer>>;
-interface ConsumerStreamResultBase<TConfig extends ConsumerConfig> {
-  eventSource: InstanceType<TConfig['EventSource']> | null;
-}
-interface ConsumerStreamResultData<TConfig extends ConsumerConfig> extends ConsumerStreamResultBase<TConfig> {
-  type: 'data';
-  data: inferTrackedOutput<TConfig['data']>;
-}
-interface ConsumerStreamResultError<TConfig extends ConsumerConfig> extends ConsumerStreamResultBase<TConfig> {
-  type: 'serialized-error';
-  error: TConfig['error'];
-}
-interface ConsumerStreamResultConnecting<TConfig extends ConsumerConfig> extends ConsumerStreamResultBase<TConfig> {
-  type: 'connecting';
-  event: EventSourceLike.EventOf<TConfig['EventSource']> | null;
-}
-interface ConsumerStreamResultTimeout<TConfig extends ConsumerConfig> extends ConsumerStreamResultBase<TConfig> {
-  type: 'timeout';
-  ms: number;
-}
-interface ConsumerStreamResultPing<TConfig extends ConsumerConfig> extends ConsumerStreamResultBase<TConfig> {
-  type: 'ping';
-}
-interface ConsumerStreamResultConnected<TConfig extends ConsumerConfig> extends ConsumerStreamResultBase<TConfig> {
-  type: 'connected';
-  options: SSEClientOptions;
-}
-type ConsumerStreamResult<TConfig extends ConsumerConfig> = ConsumerStreamResultData<TConfig> | ConsumerStreamResultError<TConfig> | ConsumerStreamResultConnecting<TConfig> | ConsumerStreamResultTimeout<TConfig> | ConsumerStreamResultPing<TConfig> | ConsumerStreamResultConnected<TConfig>;
-interface SSEStreamConsumerOptions<TConfig extends ConsumerConfig> {
-  url: () => MaybePromise<string>;
-  init: () => MaybePromise<EventSourceLike.InitDictOf<TConfig['EventSource']>> | undefined;
-  signal: AbortSignal;
-  deserialize?: Deserialize;
-  EventSource: TConfig['EventSource'];
-}
-interface ConsumerConfig {
-  data: unknown;
-  error: unknown;
-  EventSource: EventSourceLike.AnyConstructor;
+  batchIndex?: number;
 }
 /**
- * @see https://html.spec.whatwg.org/multipage/server-sent-events.html
- */
-declare function sseStreamConsumer<TConfig extends ConsumerConfig>(opts: SSEStreamConsumerOptions<TConfig>): AsyncIterable<ConsumerStreamResult<TConfig>>;
-declare const sseHeaders: {
-  readonly 'Content-Type': 'text/event-stream';
-  readonly 'Cache-Control': 'no-cache, no-transform';
-  readonly 'X-Accel-Buffering': 'no';
-  readonly Connection: 'keep-alive';
-};
-//#endregion
-//#region src/unstable-core-do-not-import/rootConfig.d.ts
-/**
- * The initial generics that are used in the init function
- * @internal
+ * A procedure resolver
  */
-interface RootTypes {
-  ctx: object;
-  meta: object;
-  errorShape: DefaultErrorShape;
-  transformer: boolean;
-}
+type ProcedureResolver<TContext, TMeta, TContextOverrides, TInputOut, TOutputParserIn, $Output> = (opts: ProcedureResolverOptions<TContext, TMeta, TContextOverrides, TInputOut>) => MaybePromise<DefaultValue<TOutputParserIn, $Output>>;
+type AnyProcedureBuilder = ProcedureBuilder<any, any, any, any, any, any, any, any, any>;
 /**
- * The default check to see if we're in a server
+ * Infer the context type from a procedure builder
+ * Useful to create common helper functions for different procedures
  */
-declare const isServerDefault: boolean;
+type inferProcedureBuilderResolverOptions<TProcedureBuilder extends AnyProcedureBuilder> = TProcedureBuilder extends ProcedureBuilder<infer TContext, infer TMeta, infer TContextOverrides, infer _TInputIn, infer TInputOut, infer _TOutputIn, infer _TOutputOut, infer _TCaller, infer _TErrorShape> ? ProcedureResolverOptions<TContext, TMeta, TContextOverrides, TInputOut extends UnsetMarker ? unknown : TInputOut extends object ? Simplify<TInputOut & {
+  /**
+   * Extra input params might have been added by a `.input()` further down the chain
+   */
+  [keyAddedByInputCallFurtherDown: string]: unknown;
+}> : TInputOut> : never;
+interface ProcedureBuilder<TContext, TMeta, TContextOverrides, TInputIn, TInputOut, TOutputIn, TOutputOut, TCaller extends boolean,
 /**
- * The tRPC root config
- * @internal
+ * Defaults to `unknown` so that an annotation written without it falls back
+ * to the router-wide error shape rather than pinning the procedure to the
+ * default one.
+ * @see inferProcedureErrorShape
  */
-interface RootConfig<TTypes extends RootTypes> {
+TErrorShape = unknown> {
+  /**
+   * Add an input parser to the procedure.
+   * @see https://trpc.io/docs/v11/server/validators
+   */
+  input<$Parser extends Parser>(schema: TInputOut extends UnsetMarker ? $Parser : inferParser<$Parser>['out'] extends Record<string, unknown> | undefined ? TInputOut extends Record<string, unknown> | undefined ? undefined extends inferParser<$Parser>['out'] ? undefined extends TInputOut ? $Parser : TypeError<'Cannot chain an optional parser to a required parser'> : $Parser : TypeError<'All input parsers did not resolve to an object'> : TypeError<'All input parsers did not resolve to an object'>): ProcedureBuilder<TContext, TMeta, TContextOverrides, IntersectIfDefined<TInputIn, inferParser<$Parser>['in']>, IntersectIfDefined<TInputOut, inferParser<$Parser>['out']>, TOutputIn, TOutputOut, TCaller, TErrorShape>;
   /**
-   * The types that are used in the config
-   * @internal
+   * Add an output parser to the procedure.
+   * @see https://trpc.io/docs/v11/server/validators
    */
-  $types: TTypes;
+  output<$Parser extends Parser>(schema: $Parser): ProcedureBuilder<TContext, TMeta, TContextOverrides, TInputIn, TInputOut, IntersectIfDefined<TOutputIn, inferParser<$Parser>['in']>, IntersectIfDefined<TOutputOut, inferParser<$Parser>['out']>, TCaller, TErrorShape>;
   /**
-   * Use a data transformer
-   * @see https://trpc.io/docs/v11/data-transformers
+   * Add a meta data to the procedure.
+   * @see https://trpc.io/docs/v11/server/metadata
    */
-  transformer: CombinedDataTransformer;
+  meta(meta: TMeta): ProcedureBuilder<TContext, TMeta, TContextOverrides, TInputIn, TInputOut, TOutputIn, TOutputOut, TCaller, TErrorShape>;
   /**
-   * Use custom error formatting
-   * @see https://trpc.io/docs/v11/error-formatting
+   * Add per procedure error formatters.
+   *
+   * An error will bubble until a `.errors()` handler returns a shape
+   * or it reaches the global errorFormatter
+   *
+   * @see https://trpc.io/docs/v11/server/error-formatting
    */
-  errorFormatter: ErrorFormatter<TTypes['ctx'], TTypes['errorShape']>;
+  errors<$Shape extends TRPCErrorShape | undefined | void>(formatter: ProcedureErrorFormatter<TContext, TContextOverrides, $Shape>): ProcedureBuilder<TContext, TMeta, TContextOverrides, TInputIn, TInputOut, TOutputIn, TOutputOut, TCaller, FoldErrorShape<TErrorShape, $Shape>>;
   /**
-   * Allow `@trpc/server` to run in non-server environments
-   * @warning **Use with caution**, this should likely mainly be used within testing.
-   * @default false
+   * Add a middleware to the procedure.
+   * @see https://trpc.io/docs/v11/server/middlewares
    */
-  allowOutsideOfServer: boolean;
+  use<$ContextOverridesOut>(fn: MiddlewareBuilder<Overwrite<TContext, TContextOverrides>, TMeta, $ContextOverridesOut, TInputOut> | MiddlewareFunction<TContext, TMeta, TContextOverrides, $ContextOverridesOut, TInputOut>): ProcedureBuilder<TContext, TMeta, Overwrite<TContextOverrides, $ContextOverridesOut>, TInputIn, TInputOut, TOutputIn, TOutputOut, TCaller, TErrorShape>;
   /**
-   * Is this a server environment?
-   * @warning **Use with caution**, this should likely mainly be used within testing.
-   * @default typeof window === 'undefined' || 'Deno' in window || process.env.NODE_ENV === 'test'
+   * @deprecated use {@link concat} instead
    */
-  isServer: boolean;
+  unstable_concat<$Context, $Meta, $ContextOverrides, $InputIn, $InputOut, $OutputIn, $OutputOut, $ErrorShape>(builder: Overwrite<TContext, TContextOverrides> extends $Context ? TMeta extends $Meta ? ProcedureBuilder<$Context, $Meta, $ContextOverrides, $InputIn, $InputOut, $OutputIn, $OutputOut, TCaller, $ErrorShape> : TypeError<'Meta mismatch'> : TypeError<'Context mismatch'>): ProcedureBuilder<TContext, TMeta, Overwrite<TContextOverrides, $ContextOverrides>, IntersectIfDefined<TInputIn, $InputIn>, IntersectIfDefined<TInputOut, $InputOut>, IntersectIfDefined<TOutputIn, $OutputIn>, IntersectIfDefined<TOutputOut, $OutputOut>, TCaller, FoldErrorShape<TErrorShape, $ErrorShape>>;
   /**
-   * Is this development?
-   * Will be used to decide if the API should return stack traces
-   * @default process.env.NODE_ENV !== 'production'
+   * Combine two procedure builders
    */
-  isDev: boolean;
-  defaultMeta?: TTypes['meta'] extends object ? TTypes['meta'] : never;
+  concat<$Context, $Meta, $ContextOverrides, $InputIn, $InputOut, $OutputIn, $OutputOut, $ErrorShape>(builder: Overwrite<TContext, TContextOverrides> extends $Context ? TMeta extends $Meta ? ProcedureBuilder<$Context, $Meta, $ContextOverrides, $InputIn, $InputOut, $OutputIn, $OutputOut, TCaller, $ErrorShape> : TypeError<'Meta mismatch'> : TypeError<'Context mismatch'>): ProcedureBuilder<TContext, TMeta, Overwrite<TContextOverrides, $ContextOverrides>, IntersectIfDefined<TInputIn, $InputIn>, IntersectIfDefined<TInputOut, $InputOut>, IntersectIfDefined<TOutputIn, $OutputIn>, IntersectIfDefined<TOutputOut, $OutputOut>, TCaller, FoldErrorShape<TErrorShape, $ErrorShape>>;
   /**
-   * Options for server-sent events (SSE) subscriptions
-   * @see https://trpc.io/docs/client/links/httpSubscriptionLink
+   * Query procedure
+   * @see https://trpc.io/docs/v11/concepts#vocabulary
    */
-  sse?: {
-    /**
-     * Enable server-sent events (SSE) subscriptions
-     * @default true
-     */
-    enabled?: boolean;
-  } & Pick<SSEStreamProducerOptions, 'ping' | 'emitAndEndImmediately' | 'maxDurationMs' | 'client'>;
+  query<$Output>(resolver: ProcedureResolver<TContext, TMeta, TContextOverrides, TInputOut, TOutputIn, $Output>): TCaller extends true ? (input: DefaultValue<TInputIn, void>) => Promise<DefaultValue<TOutputOut, $Output>> : QueryProcedure<{
+    input: DefaultValue<TInputIn, void>;
+    output: DefaultValue<TOutputOut, $Output>;
+    meta: TMeta;
+    errorShape: TErrorShape;
+  }>;
   /**
-   * Options for batch stream
-   * @see https://trpc.io/docs/client/links/httpBatchStreamLink
+   * Mutation procedure
+   * @see https://trpc.io/docs/v11/concepts#vocabulary
    */
-  jsonl?: Pick<JSONLProducerOptions, 'pingMs'>;
-  experimental?: {};
+  mutation<$Output>(resolver: ProcedureResolver<TContext, TMeta, TContextOverrides, TInputOut, TOutputIn, $Output>): TCaller extends true ? (input: DefaultValue<TInputIn, void>) => Promise<DefaultValue<TOutputOut, $Output>> : MutationProcedure<{
+    input: DefaultValue<TInputIn, void>;
+    output: DefaultValue<TOutputOut, $Output>;
+    meta: TMeta;
+    errorShape: TErrorShape;
+  }>;
+  /**
+   * Subscription procedure
+   * @see https://trpc.io/docs/v11/server/subscriptions
+   */
+  subscription<$Output extends AsyncIterable<any, void, any>>(resolver: ProcedureResolver<TContext, TMeta, TContextOverrides, TInputOut, TOutputIn, $Output>): TCaller extends true ? TypeError<'Not implemented'> : SubscriptionProcedure<{
+    input: DefaultValue<TInputIn, void>;
+    output: inferSubscriptionOutput$1<DefaultValue<TOutputOut, $Output>>;
+    meta: TMeta;
+    errorShape: TErrorShape;
+  }>;
+  /**
+   * @deprecated Using subscriptions with an observable is deprecated. Use an async generator instead.
+   * This feature will be removed in v12 of tRPC.
+   * @see https://trpc.io/docs/v11/server/subscriptions
+   */
+  subscription<$Output extends Observable<any, any>>(resolver: ProcedureResolver<TContext, TMeta, TContextOverrides, TInputOut, TOutputIn, $Output>): TCaller extends true ? TypeError<'Not implemented'> : LegacyObservableSubscriptionProcedure<{
+    input: DefaultValue<TInputIn, void>;
+    output: inferObservableValue<DefaultValue<TOutputOut, $Output>>;
+    meta: TMeta;
+    errorShape: TErrorShape;
+  }>;
+  /**
+   * Overrides the way a procedure is invoked
+   * Do not use this unless you know what you're doing - this is an experimental API
+   */
+  experimental_caller(caller: CallerOverride<TContext>): ProcedureBuilder<TContext, TMeta, TContextOverrides, TInputIn, TInputOut, TOutputIn, TOutputOut, true, TErrorShape>;
+  /**
+   * @internal
+   */
+  _def: ProcedureBuilderDef<TMeta>;
 }
+type ProcedureBuilderResolver = (opts: ProcedureResolverOptions<any, any, any, any>) => Promise<unknown>;
+declare function createBuilder<TContext, TMeta, TErrorShape = unknown>(initDef?: Partial<AnyProcedureBuilderDef>): ProcedureBuilder<TContext, TMeta, object, UnsetMarker, UnsetMarker, UnsetMarker, UnsetMarker, false, TErrorShape>;
 /**
  * @internal
  */
-type CreateRootTypes<TGenerics extends RootTypes> = TGenerics;
-type AnyRootTypes = CreateRootTypes<{
-  ctx: any;
-  meta: any;
-  errorShape: any;
-  transformer: any;
-}>;
-type PartialIf<TCondition extends boolean, TType> = TCondition extends true ? Partial<TType> : TType;
-/**
- * Adds a `createContext` option with a given callback function
- * If context is the default value, then the `createContext` option is optional
- */
-type CreateContextCallback<TContext, TFunction extends (...args: any[]) => any> = PartialIf<object extends TContext ? true : false, {
+interface ProcedureCallOptions<TContext> {
+  ctx: TContext;
+  getRawInput: GetRawInputFn;
+  input?: unknown;
+  path: string;
+  type: ProcedureType;
+  signal: AbortSignal | undefined;
   /**
-   * @see https://trpc.io/docs/v11/context
-   **/
-  createContext: TFunction;
-}>;
-//#endregion
-//#region src/unstable-core-do-not-import/router.d.ts
-interface RouterRecord {
-  [key: string]: AnyProcedure | RouterRecord;
+   * The index of this call in a batch request.
+   */
+  batchIndex: number;
 }
-type DecorateProcedure<TProcedure extends AnyProcedure> = (input: inferProcedureInput<TProcedure>) => Promise<TProcedure['_def']['type'] extends 'subscription' ? TProcedure extends LegacyObservableSubscriptionProcedure<any> ? Observable<inferProcedureOutput<TProcedure>, TRPCError> : inferProcedureOutput<TProcedure> : inferProcedureOutput<TProcedure>>;
-/**
- * @internal
- */
-type DecorateRouterRecord<TRecord extends RouterRecord> = { [TKey in keyof TRecord]: TRecord[TKey] extends (infer $Value) ? $Value extends AnyProcedure ? DecorateProcedure<$Value> : $Value extends RouterRecord ? DecorateRouterRecord<$Value> : never : never; };
-/**
- * @internal
- */
-type RouterCallerErrorHandler<TContext> = (opts: ErrorHandlerOptions<TContext>) => void;
-/**
- * @internal
- */
-type RouterCaller<TRoot extends AnyRootTypes, TRecord extends RouterRecord> = (
-/**
- * @note
- * If passing a function, we recommend it's a cached function
- * e.g. wrapped in `React.cache` to avoid unnecessary computations
- */
-ctx: TRoot['ctx'] | (() => MaybePromise<TRoot['ctx']>), options?: {
-  onError?: RouterCallerErrorHandler<TRoot['ctx']>;
-  signal?: AbortSignal;
-}) => DecorateRouterRecord<TRecord>;
-type Lazy<TAny> = (() => Promise<TAny>) & {};
-type LazyLoader<TAny> = {
-  load: () => Promise<void>;
-  ref: Lazy<TAny>;
-};
+//#endregion
+//#region src/unstable-core-do-not-import/procedure.d.ts
+declare const procedureTypes: readonly ['query', 'mutation', 'subscription'];
 /**
- * Lazy load a router
- * @see https://trpc.io/docs/server/merging-routers#lazy-load
+ * @public
  */
-declare function lazy<TRouter extends AnyRouter>(importRouter: () => Promise<TRouter | {
-  [key: string]: TRouter;
-}>): Lazy<NoInfer<TRouter>>;
+type ProcedureType = (typeof procedureTypes)[number];
+interface BuiltProcedureDef {
+  meta: unknown;
+  input: unknown;
+  output: unknown;
+  errorShape?: unknown;
+}
 /**
+ *
  * @internal
  */
-interface RouterDef<TRoot extends AnyRootTypes, TRecord extends RouterRecord> {
-  _config: RootConfig<TRoot>;
-  router: true;
-  procedure?: never;
-  procedures: TRecord;
-  record: TRecord;
-  lazy: Record<string, LazyLoader<AnyRouter>>;
-}
-interface Router<TRoot extends AnyRootTypes, TRecord extends RouterRecord> {
-  _def: RouterDef<TRoot, TRecord>;
+interface Procedure<TType extends ProcedureType, TDef extends BuiltProcedureDef> {
+  _def: {
+    /**
+     * These are just types, they can't be used at runtime
+     * @internal
+     */
+    $types: {
+      input: TDef['input'];
+      output: TDef['output'];
+      errorShape: TDef['errorShape'];
+    };
+    procedure: true;
+    type: TType;
+    /**
+     * @internal
+     * Meta is not inferrable on individual procedures, only on the router
+     */
+    meta: unknown;
+    experimental_caller: boolean;
+    /**
+     * The input parsers for the procedure
+     */
+    inputs: Parser[];
+  };
+  meta: TDef['meta'];
   /**
-   * @see https://trpc.io/docs/v11/server/server-side-calls
+   * @internal
    */
-  createCaller: RouterCaller<TRoot, TRecord>;
-}
-type BuiltRouter<TRoot extends AnyRootTypes, TRecord extends RouterRecord> = Router<TRoot, TRecord> & TRecord;
-interface RouterBuilder<TRoot extends AnyRootTypes> {
-  <TIn extends CreateRouterOptions>(_: TIn): BuiltRouter<TRoot, DecorateCreateRouterOptions<TIn>>;
+  (opts: ProcedureCallOptions<unknown>): Promise<TDef['output']>;
 }
-type AnyRouter = Router<any, any>;
-type inferRouterRootTypes<TRouter extends AnyRouter> = TRouter['_def']['_config']['$types'];
-type inferRouterContext<TRouter extends AnyRouter> = inferRouterRootTypes<TRouter>['ctx'];
-type inferRouterError<TRouter extends AnyRouter> = inferRouterRootTypes<TRouter>['errorShape'];
-type inferRouterMeta<TRouter extends AnyRouter> = inferRouterRootTypes<TRouter>['meta'];
-/** @internal */
-type CreateRouterOptions = {
-  [key: string]: AnyProcedure | AnyRouter | CreateRouterOptions | Lazy<AnyRouter>;
-};
-/** @internal */
-type DecorateCreateRouterOptions<TRouterOptions extends CreateRouterOptions> = { [K in keyof TRouterOptions]: TRouterOptions[K] extends (infer $Value) ? $Value extends AnyProcedure ? $Value : $Value extends Router<any, infer TRecord> ? TRecord : $Value extends Lazy<Router<any, infer TRecord>> ? TRecord : $Value extends CreateRouterOptions ? DecorateCreateRouterOptions<$Value> : never : never; };
-/**
- * @internal
- */
-declare function createRouterFactory<TRoot extends AnyRootTypes>(config: RootConfig<TRoot>): <TInput extends CreateRouterOptions>(input: TInput) => BuiltRouter<TRoot, DecorateCreateRouterOptions<TInput>>;
+interface QueryProcedure<TDef extends BuiltProcedureDef> extends Procedure<'query', TDef> {}
+interface MutationProcedure<TDef extends BuiltProcedureDef> extends Procedure<'mutation', TDef> {}
+interface SubscriptionProcedure<TDef extends BuiltProcedureDef> extends Procedure<'subscription', TDef> {}
 /**
- * @internal
+ * @deprecated
  */
-declare function getProcedureAtPath(router: Pick<Router<any, any>, '_def'>, path: string): Promise<AnyProcedure | null>;
+interface LegacyObservableSubscriptionProcedure<TDef extends BuiltProcedureDef> extends SubscriptionProcedure<TDef> {
+  _observable: true;
+}
+type AnyQueryProcedure = QueryProcedure<any>;
+type AnyMutationProcedure = MutationProcedure<any>;
+type AnySubscriptionProcedure = SubscriptionProcedure<any> | LegacyObservableSubscriptionProcedure<any>;
+type AnyProcedure = AnyQueryProcedure | AnyMutationProcedure | AnySubscriptionProcedure;
+type inferProcedureInput<TProcedure extends AnyProcedure> = undefined extends inferProcedureParams<TProcedure>['$types']['input'] ? void | inferProcedureParams<TProcedure>['$types']['input'] : inferProcedureParams<TProcedure>['$types']['input'];
+type inferProcedureParams<TProcedure> = TProcedure extends AnyProcedure ? TProcedure['_def'] : never;
+type inferProcedureOutput<TProcedure> = inferProcedureParams<TProcedure>['$types']['output'];
+type inferSubscriptionInput<TProcedure extends AnySubscriptionProcedure> = inferProcedureInput<TProcedure>;
+type inferSubscriptionOutput<TProcedure extends AnySubscriptionProcedure> = TProcedure extends LegacyObservableSubscriptionProcedure<any> ? inferProcedureOutput<TProcedure> : inferAsyncIterableYield<inferProcedureOutput<TProcedure>>;
 /**
  * @internal
  */
-declare function callProcedure(opts: ProcedureCallOptions<unknown> & {
-  router: AnyRouter;
-  allowMethodOverride?: boolean;
-}): Promise<any>;
-interface RouterCallerFactory<TRoot extends AnyRootTypes> {
-  <TRecord extends RouterRecord>(router: Pick<Router<TRoot, TRecord>, '_def'>): RouterCaller<TRoot, TRecord>;
+interface ErrorHandlerOptions<TContext> {
+  error: TRPCError;
+  type: ProcedureType | 'unknown';
+  path: string | undefined;
+  input: unknown;
+  ctx: TContext | undefined;
 }
-declare function createCallerFactory<TRoot extends AnyRootTypes>(): RouterCallerFactory<TRoot>;
-/** @internal */
-type MergeRouters<TRouters extends AnyRouter[], TRoot extends AnyRootTypes = TRouters[0]['_def']['_config']['$types'], TRecord extends RouterRecord = {}> = TRouters extends [infer Head extends AnyRouter, ...infer Tail extends AnyRouter[]] ? MergeRouters<Tail, TRoot, Head['_def']['record'] & TRecord> : BuiltRouter<TRoot, TRecord>;
-declare function mergeRouters<TRouters extends AnyRouter[]>(...routerList: [...TRouters]): MergeRouters<TRouters>;
 //#endregion
 //#region src/unstable-core-do-not-import/clientish/inferrable.d.ts
 type AnyClientTypes = Pick<AnyRootTypes, 'errorShape' | 'transformer'>;
@@ -1565,6 +1632,10 @@ type UndefinedToOptional<T extends object> = Pick<WithoutIndexSignature<T>, Filt
  * @internal
  */
 type inferTransformedProcedureOutput<TInferrable extends InferrableClientTypes, TProcedure extends AnyProcedure> = inferClientTypes<TInferrable>['transformer'] extends false ? Serialize<inferProcedureOutput<TProcedure>> : inferProcedureOutput<TProcedure>;
+/**
+ * @internal
+ */
+type inferProcedureErrorShape<TInferrable extends InferrableClientTypes, TProcedure extends AnyProcedure> = TProcedure['_def']['$types']['errorShape'] extends (infer $Shape) ? unknown extends $Shape ? inferClientTypes<TInferrable>['errorShape'] : $Shape : never;
 /** @internal */
 type inferTransformedSubscriptionOutput<TInferrable extends InferrableClientTypes, TProcedure extends AnyProcedure> = inferClientTypes<TInferrable>['transformer'] extends false ? Serialize<inferObservableValue<inferProcedureOutput<TProcedure>>> : inferObservableValue<inferProcedureOutput<TProcedure>>;
 type GetInferenceHelpers<TType extends 'input' | 'output', TRoot extends AnyClientTypes, TRecord extends RouterRecord> = { [TKey in keyof TRecord]: TRecord[TKey] extends (infer $Value) ? $Value extends AnyProcedure ? TType extends 'input' ? inferProcedureInput<$Value> : inferTransformedProcedureOutput<TRoot, $Value> : $Value extends RouterRecord ? GetInferenceHelpers<TType, TRoot, $Value> : never : never; };
@@ -1701,7 +1772,7 @@ interface TRPCRootObject<TContext extends object, TMeta extends object, TOptions
    * Builder object for creating procedures
    * @see https://trpc.io/docs/v11/server/procedures
    */
-  procedure: ProcedureBuilder<TContext, TMeta, object, UnsetMarker, UnsetMarker, UnsetMarker, UnsetMarker, false>;
+  procedure: ProcedureBuilder<TContext, TMeta, object, UnsetMarker, UnsetMarker, UnsetMarker, UnsetMarker, false, $Root['errorShape']>;
   /**
    * Create reusable middlewares
    * @see https://trpc.io/docs/v11/server/middlewares
@@ -1940,5 +2011,5 @@ declare class Unpromise<T> implements ProxyPromise<T> {
   static raceReferences<TPromise extends Promise<unknown>>(promises: readonly TPromise[]): Promise<readonly [TPromise]>;
 }
 //#endregion
-export { Lazy as $, identity as $n, GetRawInputFn as $r, JSONRPC2 as $t, OctetInput as A, LegacyObservableSubscriptionProcedure as An, ParserSuperstructEsque as Ar, sseStreamProducer as At, inferRouterOutputs as B, inferSubscriptionOutput as Bn, getCauseFromUnknown as Br, DefaultErrorData as Bt, JSONRPC2_TO_HTTP_CODE as C, TRPCRequestInfo as Cn, ParseFn as Cr, isServerDefault as Ct, getStatusKeyFromCode as D, AnyQueryProcedure as Dn, ParserMyZodEsque as Dr, SSEStreamProducerOptions as Dt, getStatusCodeFromKey as E, AnyProcedure as En, ParserCustomValidatorEsque as Er, SSEStreamConsumerOptions as Et, getErrorShape as F, SubscriptionProcedure as Fn, ParserZodEsque as Fr, ProducerOnError as Ft, AnyClientTypes as G, ProcedureCallOptions as Gn, TRPC_ERROR_CODE_NUMBER as Gr, CombinedDataTransformer as Gt, inferTransformedSubscriptionOutput as H, AnyProcedureBuilder as Hn, TRPC_ERROR_CODES_BY_KEY as Hr, ErrorFormatter as Ht, createFlatProxy as I, inferProcedureInput as In, getParseFn as Ir, WebReadableStreamEsque as It, AnyRouter as J, inferProcedureBuilderResolverOptions as Jn, Dict as Jr, DataTransformerOptions as Jt, InferrableClientTypes as K, ProcedureResolverOptions as Kn, retryableRpcCodes as Kr, CombinedDataTransformerClient as Kt, createRecursiveProxy as L, inferProcedureOutput as Ln, inferParser as Lr, isPromise as Lt, octetInputParser as M, Procedure as Mn, ParserWithInputOutput as Mr, ConsumerOnError as Mt, getAcceptHeader as N, ProcedureType as Nn, ParserWithoutInput as Nr, JSONLProducerOptions as Nt, formDataToObject as O, AnySubscriptionProcedure as On, ParserScaleEsque as Or, sseHeaders as Ot, getRequestInfo as P, QueryProcedure as Pn, ParserYupEsque as Pr, NodeJSReadableStreamEsque as Pt, DecorateRouterRecord as Q, emptyObject as Qn, FilterKeys as Qr, transformTRPCResponse as Qt, GetInferenceHelpers as R, inferProcedureParams as Rn, StandardSchemaV1 as Rr, jsonlStreamConsumer as Rt, HTTP_CODE_TO_JSONRPC2 as S, TRPCAcceptHeader as Sn, middlewareMarker as Sr, RootTypes as St, getHTTPStatusCodeFromError as T, AnyMutationProcedure as Tn, ParserArkTypeEsque as Tr, SSEPingOptions as Tt, Serialize as U, CallerOverride as Un, TRPC_ERROR_CODES_BY_NUMBER as Ur, defaultFormatter as Ut, inferTransformedProcedureOutput as V, procedureTypes as Vn, getTRPCErrorFromUnknown as Vr, DefaultErrorShape as Vt, SerializeObject as W, ProcedureBuilder as Wn, TRPC_ERROR_CODE_KEY as Wr, parseTRPCMessage as Wt, CreateRouterOptions as X, abortSignalsAnyPonyfill as Xn, ErrorSymbol as Xr, getDataTransformer as Xt, BuiltRouter as Y, UnsetMarker as Yn, DistributiveOmit as Yr, defaultTransformer as Yt, DecorateCreateRouterOptions as Z, assert as Zn, Filter as Zr, transformResult as Zt, resolveResponse as _, HTTPBaseHandlerOptions as _n, MiddlewareResult as _r, mergeRouters as _t, SubscribedPromise as a, Overwrite as ai, TRPCErrorResponse as an, run as ar, RouterCallerFactory as at, isAbortError as b, ResponseMeta as bn, createOutputMiddleware as br, CreateRootTypes as bt, takeWithGrace as c, Result$1 as ci, TRPCRequest as cn, TrackedEnvelope as cr, callProcedure as ct, Deferred as d, Unwrap as di, TRPCResponseMessage as dn, sse as dr, getProcedureAtPath as dt, IntersectionError as ei, TRPCClientIncomingMessage as en, isAsyncIterable as er, MergeRouters as et, createDeferred as f, ValidateShape as fi, TRPCResult as fn, tracked as fr, inferRouterContext as ft, initTRPC as g, inferAsyncIterableYield as gi, BaseHandlerOptions as gn, MiddlewareFunction as gr, lazy as gt, TRPCRootObject as h, coerceAsyncIterableToArray as hi, TRPCSuccessResponse as hn, MiddlewareBuilder as hr, inferRouterRootTypes as ht, ProxyPromise as i, MaybePromise as ii, TRPCConnectionParamsMessage as in, noop as ir, RouterCallerErrorHandler as it, UtilityParser as j, MutationProcedure as jn, ParserValibotEsque as jr, EventSourceLike as jt, FileLike as k, ErrorHandlerOptions as kn, ParserStandardSchemaEsque as kr, sseStreamConsumer as kt, makeAsyncResource as l, Simplify as li, TRPCRequestMessage as ln, inferTrackedOutput as lr, createCallerFactory as lt, TRPCBuilder as m, WithoutIndexSignature as mi, TRPCSubscriptionStopNotification as mn, AnyMiddlewareFunction as mr, inferRouterMeta as mt, PromiseExecutor as n, KeyFromValue as ni, TRPCClientOutgoingMessage as nn, isObject as nr, RouterBuilder as nt, StandardSchemaV1Error as o, PickFirstDefined as oi, TRPCErrorShape as on, sleep as or, RouterDef as ot, RuntimeConfigOptions as p, ValueOf as pi, TRPCResultMessage as pn, AnyMiddlewareBuilder as pr, inferRouterError as pt, inferClientTypes as q, createBuilder as qn, DeepPartial as qr, DataTransformer as qt, PromiseWithResolvers as r, Maybe as ri, TRPCClientOutgoingRequest as rn, mergeWithoutOverrides as rr, RouterCaller as rt, iteratorResource as s, ProtectedIntersection as si, TRPCReconnectNotification as sn, TrackedData as sr, RouterRecord as st, Unpromise as t, InvertKeyValue as ti, TRPCClientIncomingRequest as tn, isFunction as tr, Router as tt, makeResource as u, TypeError as ui, TRPCResponse as un, isTrackedEnvelope as ur, createRouterFactory as ut, parseConnectionParamsFromString as v, HTTPErrorHandler as vn, createInputMiddleware as vr, AnyRootTypes as vt, getHTTPStatusCode as w, TRPCRequestInfoProcedureCall as wn, Parser as wr, SSEClientOptions as wt, throwAbortError as x, ResponseMetaFn as xn, experimental_standaloneMiddleware as xr, RootConfig as xt, parseConnectionParamsFromUnknown as y, ResolveHTTPRequestOptionsContextFn as yn, createMiddlewareFactory as yr, CreateContextCallback as yt, inferRouterInputs as z, inferSubscriptionInput as zn, TRPCError as zr, jsonlStreamProducer as zt };
-//# sourceMappingURL=unstable-core-do-not-import-B9ZnrQAU.d.cts.map
+export { ErrorHandlerOptions as $, inferRouterContext as $n, TRPC_ERROR_CODES_BY_KEY as $r, setFormattedErrorShape as $t, OctetInput as A, ResponseMeta as An, WebReadableStreamEsque as Ar, run as At, inferRouterInputs as B, Lazy as Bn, ParserStandardSchemaEsque as Br, createOutputMiddleware as Bt, JSONRPC2_TO_HTTP_CODE as C, ValidateShape as Ci, TRPCResultMessage as Cn, sse as Cr, emptyObject as Ct, getStatusKeyFromCode as D, inferAsyncIterableYield as Di, HTTPBaseHandlerOptions as Dn, JSONLProducerOptions as Dr, isObject as Dt, getStatusCodeFromKey as E, coerceAsyncIterableToArray as Ei, BaseHandlerOptions as En, ConsumerOnError as Er, isFunction as Et, getErrorShape as F, AnyRouter as Fn, Parser as Fr, MiddlewareFunction as Ft, SerializeObject as G, RouterCallerErrorHandler as Gn, ParserYupEsque as Gr, DefaultErrorShape as Gt, inferTransformedProcedureOutput as H, Router as Hn, ParserValibotEsque as Hr, middlewareMarker as Ht, createFlatProxy as I, BuiltRouter as In, ParserArkTypeEsque as Ir, MiddlewareResult as It, inferClientTypes as J, RouterRecord as Jn, inferParser as Jr, ProcedureErrorFormatter as Jt, AnyClientTypes as K, RouterCallerFactory as Kn, ParserZodEsque as Kr, ErrorFormatter as Kt, createRecursiveProxy as L, CreateRouterOptions as Ln, ParserCustomValidatorEsque as Lr, createErrorFormatterMiddleware as Lt, octetInputParser as M, TRPCAcceptHeader as Mn, jsonlStreamConsumer as Mr, AnyMiddlewareBuilder as Mt, getAcceptHeader as N, TRPCRequestInfo as Nn, jsonlStreamProducer as Nr, AnyMiddlewareFunction as Nt, formDataToObject as O, HTTPErrorHandler as On, NodeJSReadableStreamEsque as Or, mergeWithoutOverrides as Ot, getRequestInfo as P, TRPCRequestInfoProcedureCall as Pn, ParseFn as Pr, MiddlewareBuilder as Pt, AnySubscriptionProcedure as Q, getProcedureAtPath as Qn, getTRPCErrorFromUnknown as Qr, isFormattedErrorShape as Qt, GetInferenceHelpers as R, DecorateCreateRouterOptions as Rn, ParserMyZodEsque as Rr, createInputMiddleware as Rt, HTTP_CODE_TO_JSONRPC2 as S, Unwrap as Si, TRPCResult as Sn, isTrackedEnvelope as Sr, assertNever as St, getHTTPStatusCodeFromError as T, WithoutIndexSignature as Ti, TRPCSuccessResponse as Tn, EventSourceLike as Tr, isAsyncIterable as Tt, inferTransformedSubscriptionOutput as U, RouterBuilder as Un, ParserWithInputOutput as Ur, AnyProcedureErrorFormatter as Ut, inferRouterOutputs as V, MergeRouters as Vn, ParserSuperstructEsque as Vr, experimental_standaloneMiddleware as Vt, Serialize as W, RouterCaller as Wn, ParserWithoutInput as Wr, DefaultErrorData as Wt, AnyProcedure as X, createCallerFactory as Xn, TRPCError as Xr, getDefaultErrorShape as Xt, AnyMutationProcedure as Y, callProcedure as Yn, StandardSchemaV1 as Yr, defaultFormatter as Yt, AnyQueryProcedure as Z, createRouterFactory as Zn, getCauseFromUnknown as Zr, getFormattedErrorShape as Zt, resolveResponse as _, PickFirstDefined as _i, TRPCReconnectNotification as _n, sseStreamConsumer as _r, createBuilder as _t, SubscribedPromise as a, Dict as ai, defaultTransformer as an, AnyRootTypes as ar, SubscriptionProcedure as at, isAbortError as b, Simplify as bi, TRPCResponse as bn, TrackedEnvelope as br, abortSignalsAnyPonyfill as bt, takeWithGrace as c, Filter as ci, transformTRPCResponse as cn, RootConfig as cr, inferProcedureParams as ct, Deferred as d, IntersectionError as di, TRPCClientIncomingRequest as dn, isServerDefault as dr, procedureTypes as dt, TRPC_ERROR_CODES_BY_NUMBER as ei, parseTRPCMessage as en, inferRouterError as er, LegacyObservableSubscriptionProcedure as et, createDeferred as f, InvertKeyValue as fi, TRPCClientOutgoingMessage as fn, SSEClientOptions as fr, AnyProcedureBuilder as ft, initTRPC as g, Overwrite as gi, TRPCErrorShape as gn, sseHeaders as gr, ProcedureResolverOptions as gt, TRPCRootObject as h, MaybePromise as hi, TRPCErrorResponse as hn, SSEStreamProducerOptions as hr, ProcedureCallOptions as ht, ProxyPromise as i, DeepPartial as ii, DataTransformerOptions as in, mergeRouters as ir, QueryProcedure as it, UtilityParser as j, ResponseMetaFn as jn, isPromise as jr, sleep as jt, FileLike as k, ResolveHTTPRequestOptionsContextFn as kn, ProducerOnError as kr, noop as kt, makeAsyncResource as l, FilterKeys as li, JSONRPC2 as ln, RootTypes as lr, inferSubscriptionInput as lt, TRPCBuilder as m, Maybe as mi, TRPCConnectionParamsMessage as mn, SSEStreamConsumerOptions as mr, ProcedureBuilder as mt, PromiseExecutor as n, TRPC_ERROR_CODE_NUMBER as ni, CombinedDataTransformerClient as nn, inferRouterRootTypes as nr, Procedure as nt, StandardSchemaV1Error as o, DistributiveOmit as oi, getDataTransformer as on, CreateContextCallback as or, inferProcedureInput as ot, RuntimeConfigOptions as p, KeyFromValue as pi, TRPCClientOutgoingRequest as pn, SSEPingOptions as pr, CallerOverride as pt, InferrableClientTypes as q, RouterDef as qn, getParseFn as qr, ErrorFormatterOptions as qt, PromiseWithResolvers as r, retryableRpcCodes as ri, DataTransformer as rn, lazy as rr, ProcedureType as rt, iteratorResource as s, ErrorSymbol as si, transformResult as sn, CreateRootTypes as sr, inferProcedureOutput as st, Unpromise as t, TRPC_ERROR_CODE_KEY as ti, CombinedDataTransformer as tn, inferRouterMeta as tr, MutationProcedure as tt, makeResource as u, GetRawInputFn as ui, TRPCClientIncomingMessage as un, isDevDefault as ur, inferSubscriptionOutput as ut, parseConnectionParamsFromString as v, ProtectedIntersection as vi, TRPCRequest as vn, sseStreamProducer as vr, inferProcedureBuilderResolverOptions as vt, getHTTPStatusCode as w, ValueOf as wi, TRPCSubscriptionStopNotification as wn, tracked as wr, identity as wt, throwAbortError as x, TypeError as xi, TRPCResponseMessage as xn, inferTrackedOutput as xr, assert as xt, parseConnectionParamsFromUnknown as y, Result$1 as yi, TRPCRequestMessage as yn, TrackedData as yr, UnsetMarker as yt, inferProcedureErrorShape as z, DecorateRouterRecord as zn, ParserScaleEsque as zr, createMiddlewareFactory as zt };
+//# sourceMappingURL=unstable-core-do-not-import-Jynlfuqc.d.cts.map