@orpc/server 0.0.0-next.8f9385e → 0.0.0-next.904b0c2

package/dist/index.js

@@ -1,394 +0,0 @@
-import {
-  Procedure,
-  createProcedureCaller,
-  decorateMiddleware,
-  decorateProcedure,
-  isProcedure,
-  mergeContext
-} from "./chunk-TDFYNRZV.js";
-
-// src/builder.ts
-import {
-  ContractProcedure,
-  isContractProcedure as isContractProcedure2
-} from "@orpc/contract";
-
-// src/procedure-builder.ts
-import {
-  DecoratedContractProcedure
-} from "@orpc/contract";
-
-// src/procedure-implementer.ts
-var ProcedureImplementer = class _ProcedureImplementer {
-  constructor(zz$pi) {
-    this.zz$pi = zz$pi;
-  }
-  use(middleware, mapInput) {
-    const middleware_ = mapInput ? decorateMiddleware(middleware).mapInput(mapInput) : middleware;
-    return new _ProcedureImplementer({
-      ...this.zz$pi,
-      middlewares: [...this.zz$pi.middlewares ?? [], middleware_]
-    });
-  }
-  func(func) {
-    return decorateProcedure({
-      zz$p: {
-        middlewares: this.zz$pi.middlewares,
-        contract: this.zz$pi.contract,
-        func
-      }
-    });
-  }
-};
-
-// src/procedure-builder.ts
-var ProcedureBuilder = class _ProcedureBuilder {
-  constructor(zz$pb) {
-    this.zz$pb = zz$pb;
-  }
-  /**
-   * Self chainable
-   */
-  route(opts) {
-    return new _ProcedureBuilder({
-      ...this.zz$pb,
-      contract: DecoratedContractProcedure.decorate(this.zz$pb.contract).route(
-        opts
-      )
-    });
-  }
-  input(schema, example) {
-    return new _ProcedureBuilder({
-      ...this.zz$pb,
-      contract: DecoratedContractProcedure.decorate(this.zz$pb.contract).input(
-        schema,
-        example
-      )
-    });
-  }
-  output(schema, example) {
-    return new _ProcedureBuilder({
-      ...this.zz$pb,
-      contract: DecoratedContractProcedure.decorate(this.zz$pb.contract).output(
-        schema,
-        example
-      )
-    });
-  }
-  use(middleware, mapInput) {
-    if (!mapInput) {
-      return new ProcedureImplementer({
-        contract: this.zz$pb.contract,
-        middlewares: this.zz$pb.middlewares
-      }).use(middleware);
-    }
-    return new ProcedureImplementer({
-      contract: this.zz$pb.contract,
-      middlewares: this.zz$pb.middlewares
-    }).use(middleware, mapInput);
-  }
-  /**
-   * Convert to Procedure
-   */
-  func(func) {
-    return decorateProcedure({
-      zz$p: {
-        middlewares: this.zz$pb.middlewares,
-        contract: this.zz$pb.contract,
-        func
-      }
-    });
-  }
-};
-
-// src/router-builder.ts
-import { DecoratedContractProcedure as DecoratedContractProcedure2 } from "@orpc/contract";
-var RouterBuilder = class _RouterBuilder {
-  constructor(zz$rb) {
-    this.zz$rb = zz$rb;
-  }
-  prefix(prefix) {
-    return new _RouterBuilder({
-      ...this.zz$rb,
-      prefix: `${this.zz$rb.prefix ?? ""}${prefix}`
-    });
-  }
-  tags(...tags) {
-    if (!tags.length)
-      return this;
-    return new _RouterBuilder({
-      ...this.zz$rb,
-      tags: [...this.zz$rb.tags ?? [], ...tags]
-    });
-  }
-  use(middleware, mapInput) {
-    const middleware_ = mapInput ? decorateMiddleware(middleware).mapInput(mapInput) : middleware;
-    return new _RouterBuilder({
-      ...this.zz$rb,
-      middlewares: [...this.zz$rb.middlewares || [], middleware_]
-    });
-  }
-  router(router) {
-    const handled = {};
-    for (const key in router) {
-      const item = router[key];
-      if (isProcedure(item)) {
-        const builderMiddlewares = this.zz$rb.middlewares ?? [];
-        const itemMiddlewares = item.zz$p.middlewares ?? [];
-        const middlewares = [
-          ...builderMiddlewares,
-          ...itemMiddlewares.filter(
-            (item2) => !builderMiddlewares.includes(item2)
-          )
-        ];
-        const contract = DecoratedContractProcedure2.decorate(
-          item.zz$p.contract
-        ).addTags(...this.zz$rb.tags ?? []);
-        handled[key] = decorateProcedure({
-          zz$p: {
-            ...item.zz$p,
-            contract: this.zz$rb.prefix ? contract.prefix(this.zz$rb.prefix) : contract,
-            middlewares
-          }
-        });
-      } else {
-        handled[key] = this.router(item);
-      }
-    }
-    return handled;
-  }
-};
-
-// src/router-implementer.ts
-import {
-  isContractProcedure
-} from "@orpc/contract";
-var RouterImplementer = class {
-  constructor(zz$ri) {
-    this.zz$ri = zz$ri;
-  }
-  router(router) {
-    assertRouterImplementation(this.zz$ri.contract, router);
-    return router;
-  }
-};
-function chainRouterImplementer(contract, middlewares) {
-  const result = {};
-  for (const key in contract) {
-    const item = contract[key];
-    if (isContractProcedure(item)) {
-      result[key] = new ProcedureImplementer({
-        contract: item,
-        middlewares
-      });
-    } else {
-      result[key] = chainRouterImplementer(item, middlewares);
-    }
-  }
-  const implementer = new RouterImplementer({ contract });
-  return Object.assign(implementer, result);
-}
-function assertRouterImplementation(contract, router, path = []) {
-  for (const key in contract) {
-    const currentPath = [...path, key];
-    const contractItem = contract[key];
-    const routerItem = router[key];
-    if (!routerItem) {
-      throw new Error(
-        `Missing implementation for procedure at [${currentPath.join(".")}]`
-      );
-    }
-    if (isContractProcedure(contractItem)) {
-      if (isProcedure(routerItem)) {
-        if (routerItem.zz$p.contract !== contractItem) {
-          throw new Error(
-            `Mismatch implementation for procedure at [${currentPath.join(".")}]`
-          );
-        }
-      } else {
-        throw new Error(
-          `Mismatch implementation for procedure at [${currentPath.join(".")}]`
-        );
-      }
-    } else {
-      assertRouterImplementation(
-        contractItem,
-        routerItem,
-        currentPath
-      );
-    }
-  }
-}
-
-// src/builder.ts
-var Builder = class _Builder {
-  constructor(zz$b = {}) {
-    this.zz$b = zz$b;
-  }
-  /**
-   * Self chainable
-   */
-  context() {
-    return this;
-  }
-  use(middleware, mapInput) {
-    const middleware_ = mapInput ? decorateMiddleware(middleware).mapInput(mapInput) : middleware;
-    return new _Builder({
-      ...this.zz$b,
-      middlewares: [...this.zz$b.middlewares || [], middleware_]
-    });
-  }
-  /**
-   * Convert to ContractProcedureBuilder
-   */
-  route(opts) {
-    return new ProcedureBuilder({
-      middlewares: this.zz$b.middlewares,
-      contract: new ContractProcedure({
-        ...opts,
-        InputSchema: void 0,
-        OutputSchema: void 0
-      })
-    });
-  }
-  input(schema, example) {
-    return new ProcedureBuilder({
-      middlewares: this.zz$b.middlewares,
-      contract: new ContractProcedure({
-        OutputSchema: void 0,
-        InputSchema: schema,
-        inputExample: example
-      })
-    });
-  }
-  output(schema, example) {
-    return new ProcedureBuilder({
-      middlewares: this.zz$b.middlewares,
-      contract: new ContractProcedure({
-        InputSchema: void 0,
-        OutputSchema: schema,
-        outputExample: example
-      })
-    });
-  }
-  /**
-   * Convert to Procedure
-   */
-  func(func) {
-    return decorateProcedure({
-      zz$p: {
-        middlewares: this.zz$b.middlewares,
-        contract: new ContractProcedure({
-          InputSchema: void 0,
-          OutputSchema: void 0
-        }),
-        func
-      }
-    });
-  }
-  /**
-   * Convert to ProcedureImplementer | RouterBuilder
-   */
-  contract(contract) {
-    if (isContractProcedure2(contract)) {
-      return new ProcedureImplementer({
-        contract,
-        middlewares: this.zz$b.middlewares
-      });
-    }
-    return chainRouterImplementer(
-      contract,
-      this.zz$b.middlewares
-    );
-  }
-  /**
-   * Create ExtendedMiddleware
-   */
-  // TODO: TOutput always any, infer not work at all, because TOutput used inside middleware params,
-  // solution (maybe): create new generic for .output() method
-  middleware(middleware) {
-    return decorateMiddleware(middleware);
-  }
-  prefix(prefix) {
-    return new RouterBuilder({
-      ...this.zz$b,
-      prefix
-    });
-  }
-  tags(...tags) {
-    return new RouterBuilder({
-      ...this.zz$b,
-      tags
-    });
-  }
-  /**
-   * Create DecoratedRouter
-   */
-  router(router) {
-    return new RouterBuilder(this.zz$b).router(router);
-  }
-};
-
-// src/router.ts
-import {
-  isContractProcedure as isContractProcedure3
-} from "@orpc/contract";
-function toContractRouter(router) {
-  const contract = {};
-  for (const key in router) {
-    const item = router[key];
-    if (isContractProcedure3(item)) {
-      contract[key] = item;
-    } else if (isProcedure(item)) {
-      contract[key] = item.zz$p.contract;
-    } else {
-      contract[key] = toContractRouter(item);
-    }
-  }
-  return contract;
-}
-
-// src/router-caller.ts
-function createRouterCaller(options) {
-  const caller = {};
-  for (const key in options.router) {
-    const path = [...options.basePath ?? [], key];
-    const item = options.router[key];
-    if (isProcedure(item)) {
-      caller[key] = createProcedureCaller({
-        procedure: item,
-        context: options.context,
-        path
-      });
-    } else {
-      caller[key] = createRouterCaller({
-        router: item,
-        context: options.context,
-        basePath: path
-      });
-    }
-  }
-  return caller;
-}
-
-// src/index.ts
-export * from "@orpc/shared/error";
-var os = new Builder();
-export {
-  Builder,
-  Procedure,
-  ProcedureBuilder,
-  ProcedureImplementer,
-  RouterImplementer,
-  assertRouterImplementation,
-  chainRouterImplementer,
-  createProcedureCaller,
-  createRouterCaller,
-  decorateMiddleware,
-  decorateProcedure,
-  isProcedure,
-  mergeContext,
-  os,
-  toContractRouter
-};
-//# sourceMappingURL=index.js.map

package/dist/src/builder.d.ts

@@ -1,49 +0,0 @@
-import type { IsEqual } from '@orpc/shared';
-import type { HandledRouter, Router } from './router';
-import type { Context, MergeContext } from './types';
-import { ContractProcedure, type ContractRouter, type HTTPPath, type RouteOptions, type Schema, type SchemaInput, type SchemaOutput } from '@orpc/contract';
-import { type DecoratedMiddleware, type MapInputMiddleware, type Middleware } from './middleware';
-import { type DecoratedProcedure, type ProcedureFunc } from './procedure';
-import { ProcedureBuilder } from './procedure-builder';
-import { ProcedureImplementer } from './procedure-implementer';
-import { RouterBuilder } from './router-builder';
-import { type ChainedRouterImplementer } from './router-implementer';
-export declare class Builder<TContext extends Context, TExtraContext extends Context> {
-    zz$b: {
-        middlewares?: Middleware<any, any, any, any>[];
-    };
-    constructor(zz$b?: {
-        middlewares?: Middleware<any, any, any, any>[];
-    });
-    /**
-     * Self chainable
-     */
-    context<UContext extends Context>(): IsEqual<UContext, Context> extends true ? Builder<TContext, TExtraContext> : Builder<UContext, TExtraContext>;
-    use<UExtraContext extends Partial<MergeContext<Context, MergeContext<TContext, TExtraContext>>> | undefined = undefined>(middleware: Middleware<MergeContext<TContext, TExtraContext>, UExtraContext, unknown, unknown>): Builder<TContext, MergeContext<TExtraContext, UExtraContext>>;
-    use<UExtraContext extends Partial<MergeContext<Context, MergeContext<TContext, TExtraContext>>> | undefined = undefined, UMappedInput = unknown>(middleware: Middleware<MergeContext<TContext, TExtraContext>, UExtraContext, UMappedInput, unknown>, mapInput: MapInputMiddleware<unknown, UMappedInput>): Builder<TContext, MergeContext<TExtraContext, UExtraContext>>;
-    /**
-     * Convert to ContractProcedureBuilder
-     */
-    route(opts: RouteOptions): ProcedureBuilder<TContext, TExtraContext, undefined, undefined>;
-    input<USchema extends Schema = undefined>(schema: USchema, example?: SchemaInput<USchema>): ProcedureBuilder<TContext, TExtraContext, USchema, undefined>;
-    output<USchema extends Schema = undefined>(schema: USchema, example?: SchemaOutput<USchema>): ProcedureBuilder<TContext, TExtraContext, undefined, USchema>;
-    /**
-     * Convert to Procedure
-     */
-    func<UFuncOutput = undefined>(func: ProcedureFunc<TContext, TExtraContext, undefined, undefined, UFuncOutput>): DecoratedProcedure<TContext, TExtraContext, undefined, undefined, UFuncOutput>;
-    /**
-     * Convert to ProcedureImplementer | RouterBuilder
-     */
-    contract<UContract extends ContractProcedure<any, any> | ContractRouter>(contract: UContract): UContract extends ContractProcedure<infer UInputSchema, infer UOutputSchema> ? ProcedureImplementer<TContext, TExtraContext, UInputSchema, UOutputSchema> : UContract extends ContractRouter ? ChainedRouterImplementer<TContext, UContract, TExtraContext> : never;
-    /**
-     * Create ExtendedMiddleware
-     */
-    middleware<UExtraContext extends Context = undefined, TInput = unknown, TOutput = any>(middleware: Middleware<MergeContext<TContext, TExtraContext>, UExtraContext, TInput, TOutput>): DecoratedMiddleware<MergeContext<TContext, TExtraContext>, UExtraContext, TInput, TOutput>;
-    prefix(prefix: HTTPPath): RouterBuilder<TContext, TExtraContext>;
-    tags(...tags: string[]): RouterBuilder<TContext, TExtraContext>;
-    /**
-     * Create DecoratedRouter
-     */
-    router<URouter extends Router<TContext>>(router: URouter): HandledRouter<URouter>;
-}
-//# sourceMappingURL=builder.d.ts.map

package/dist/src/fetch/handle.d.ts

@@ -1,7 +0,0 @@
-import type { Router } from '../router';
-import type { FetchHandler, FetchHandlerOptions } from './types';
-export type HandleFetchRequestOptions<TRouter extends Router<any>> = FetchHandlerOptions<TRouter> & {
-    handlers: readonly [FetchHandler, ...FetchHandler[]];
-};
-export declare function handleFetchRequest<TRouter extends Router<any>>(options: HandleFetchRequestOptions<TRouter>): Promise<Response>;
-//# sourceMappingURL=handle.d.ts.map

package/dist/src/fetch/handler.d.ts

@@ -1,3 +0,0 @@
-import type { FetchHandler } from './types';
-export declare function createORPCHandler(): FetchHandler;
-//# sourceMappingURL=handler.d.ts.map

package/dist/src/fetch/index.d.ts

@@ -1,4 +0,0 @@
-export * from './handle';
-export * from './handler';
-export * from './types';
-//# sourceMappingURL=index.d.ts.map

package/dist/src/fetch/types.d.ts

@@ -1,35 +0,0 @@
-import type { PartialOnUndefinedDeep, Promisable, Value } from '@orpc/shared';
-import type { Router } from '../router';
-export interface FetchHandlerHooks {
-    next: () => Promise<Response>;
-    response: (response: Response) => Response;
-}
-export type FetchHandlerOptions<TRouter extends Router<any>> = {
-    /**
-     * The `router` used for handling the request and routing,
-     *
-     */
-    router: TRouter;
-    /**
-     * The request need to be handled.
-     */
-    request: Request;
-    /**
-     * Remove the prefix from the request path.
-     *
-     * @example /orpc
-     * @example /api
-     */
-    prefix?: string;
-    /**
-     * Hooks for executing logics on lifecycle events.
-     */
-    hooks?: (context: TRouter extends Router<infer UContext> ? UContext : never, hooks: FetchHandlerHooks) => Promisable<Response>;
-} & PartialOnUndefinedDeep<{
-    /**
-     * The context used to handle the request.
-     */
-    context: Value<TRouter extends Router<infer UContext> ? UContext : never>;
-}>;
-export type FetchHandler = <TRouter extends Router<any>>(options: FetchHandlerOptions<TRouter>) => Promise<Response | undefined>;
-//# sourceMappingURL=types.d.ts.map

package/dist/src/index.d.ts

@@ -1,15 +0,0 @@
-import { Builder } from './builder';
-export * from './builder';
-export * from './middleware';
-export * from './procedure';
-export * from './procedure-builder';
-export * from './procedure-caller';
-export * from './procedure-implementer';
-export * from './router';
-export * from './router-caller';
-export * from './router-implementer';
-export * from './types';
-export * from './utils';
-export * from '@orpc/shared/error';
-export declare const os: Builder<Record<string, unknown> | undefined, undefined>;
-//# sourceMappingURL=index.d.ts.map

package/dist/src/middleware.d.ts

@@ -1,26 +0,0 @@
-import type { Promisable } from '@orpc/shared';
-import type { Context, MergeContext, Meta } from './types';
-export type MiddlewareResult<TExtraContext extends Context, TOutput> = Promisable<{
-    output: TOutput;
-    context: TExtraContext;
-}>;
-export interface MiddlewareMeta<TOutput> extends Meta {
-    next: <UExtraContext extends Context = undefined>(options: UExtraContext extends undefined ? {
-        context?: UExtraContext;
-    } : {
-        context: UExtraContext;
-    }) => MiddlewareResult<UExtraContext, TOutput>;
-    output: <UOutput>(output: UOutput) => MiddlewareResult<undefined, UOutput>;
-}
-export interface Middleware<TContext extends Context, TExtraContext extends Context, TInput, TOutput> {
-    (input: TInput, context: TContext, meta: MiddlewareMeta<TOutput>): Promisable<MiddlewareResult<TExtraContext, TOutput>>;
-}
-export interface MapInputMiddleware<TInput, TMappedInput> {
-    (input: TInput): TMappedInput;
-}
-export interface DecoratedMiddleware<TContext extends Context, TExtraContext extends Context, TInput, TOutput> extends Middleware<TContext, TExtraContext, TInput, TOutput> {
-    concat: (<UExtraContext extends Partial<MergeContext<Context, MergeContext<TContext, TExtraContext>>> | undefined = undefined, UInput = TInput>(middleware: Middleware<MergeContext<TContext, TExtraContext>, UExtraContext, UInput & TInput, TOutput>) => DecoratedMiddleware<TContext, MergeContext<TExtraContext, UExtraContext>, TInput & UInput, TOutput>) & (<UExtraContext extends Partial<MergeContext<Context, MergeContext<TContext, TExtraContext>>> | undefined = undefined, UInput = TInput, UMappedInput = unknown>(middleware: Middleware<MergeContext<TContext, TExtraContext>, UExtraContext, UMappedInput, TOutput>, mapInput: MapInputMiddleware<UInput, UMappedInput>) => DecoratedMiddleware<TContext, MergeContext<TExtraContext, UExtraContext>, TInput & UInput, TOutput>);
-    mapInput: <UInput = unknown>(map: MapInputMiddleware<UInput, TInput>) => DecoratedMiddleware<TContext, TExtraContext, UInput, TOutput>;
-}
-export declare function decorateMiddleware<TContext extends Context, TExtraContext extends Context, TInput, TOutput>(middleware: Middleware<TContext, TExtraContext, TInput, TOutput>): DecoratedMiddleware<TContext, TExtraContext, TInput, TOutput>;
-//# sourceMappingURL=middleware.d.ts.map

package/dist/src/procedure-builder.d.ts

@@ -1,31 +0,0 @@
-import type { MapInputMiddleware, Middleware } from './middleware';
-import type { Context, MergeContext } from './types';
-import { type ContractProcedure, type RouteOptions, type Schema, type SchemaInput, type SchemaOutput } from '@orpc/contract';
-import { type DecoratedProcedure, type ProcedureFunc } from './procedure';
-import { ProcedureImplementer } from './procedure-implementer';
-export declare class ProcedureBuilder<TContext extends Context, TExtraContext extends Context, TInputSchema extends Schema, TOutputSchema extends Schema> {
-    zz$pb: {
-        contract: ContractProcedure<TInputSchema, TOutputSchema>;
-        middlewares?: Middleware<any, any, any, any>[];
-    };
-    constructor(zz$pb: {
-        contract: ContractProcedure<TInputSchema, TOutputSchema>;
-        middlewares?: Middleware<any, any, any, any>[];
-    });
-    /**
-     * Self chainable
-     */
-    route(opts: RouteOptions): ProcedureBuilder<TContext, TExtraContext, TInputSchema, TOutputSchema>;
-    input<USchema extends Schema = undefined>(schema: USchema, example?: SchemaInput<USchema>): ProcedureBuilder<TContext, TExtraContext, USchema, TOutputSchema>;
-    output<USchema extends Schema = undefined>(schema: USchema, example?: SchemaOutput<USchema>): ProcedureBuilder<TContext, TExtraContext, TInputSchema, USchema>;
-    /**
-     * Convert to ProcedureBuilder
-     */
-    use<UExtraContext extends Partial<MergeContext<Context, MergeContext<TContext, TExtraContext>>> | undefined = undefined>(middleware: Middleware<MergeContext<TContext, TExtraContext>, UExtraContext, SchemaOutput<TInputSchema>, SchemaInput<TOutputSchema>>): ProcedureImplementer<TContext, MergeContext<TExtraContext, UExtraContext>, TInputSchema, TOutputSchema>;
-    use<UExtraContext extends Partial<MergeContext<Context, MergeContext<TContext, TExtraContext>>> | undefined = undefined, UMappedInput = unknown>(middleware: Middleware<MergeContext<TContext, TExtraContext>, UExtraContext, UMappedInput, SchemaInput<TOutputSchema>>, mapInput: MapInputMiddleware<SchemaOutput<TInputSchema>, UMappedInput>): ProcedureImplementer<TContext, MergeContext<TExtraContext, UExtraContext>, TInputSchema, TOutputSchema>;
-    /**
-     * Convert to Procedure
-     */
-    func<UFuncOutput extends SchemaOutput<TOutputSchema>>(func: ProcedureFunc<TContext, TExtraContext, TInputSchema, TOutputSchema, UFuncOutput>): DecoratedProcedure<TContext, TExtraContext, TInputSchema, TOutputSchema, UFuncOutput>;
-}
-//# sourceMappingURL=procedure-builder.d.ts.map

package/dist/src/procedure-caller.d.ts

@@ -1,19 +0,0 @@
-import type { SchemaInput, SchemaOutput } from '@orpc/contract';
-import type { Procedure } from './procedure';
-import { type Value } from '@orpc/shared';
-export interface CreateProcedureCallerOptions<TProcedure extends Procedure<any, any, any, any, any>> {
-    procedure: TProcedure;
-    /**
-     * The context used when calling the procedure.
-     */
-    context: Value<TProcedure extends Procedure<infer UContext, any, any, any, any> ? UContext : never>;
-    /**
-     * This is helpful for logging and analytics.
-     *
-     * @internal
-     */
-    path?: string[];
-}
-export type ProcedureCaller<TProcedure extends Procedure<any, any, any, any, any>> = TProcedure extends Procedure<any, any, infer UInputSchema, infer UOutputSchema, infer UFuncOutput> ? (...input: [input: SchemaInput<UInputSchema> | FormData] | (undefined extends SchemaInput<UInputSchema> ? [] : never)) => Promise<SchemaOutput<UOutputSchema, UFuncOutput>> : never;
-export declare function createProcedureCaller<TProcedure extends Procedure<any, any, any, any, any>>(options: CreateProcedureCallerOptions<TProcedure>): ProcedureCaller<TProcedure>;
-//# sourceMappingURL=procedure-caller.d.ts.map

package/dist/src/procedure-implementer.d.ts

@@ -1,18 +0,0 @@
-import type { ContractProcedure, Schema, SchemaInput, SchemaOutput } from '@orpc/contract';
-import type { Context, MergeContext } from './types';
-import { type MapInputMiddleware, type Middleware } from './middleware';
-import { type DecoratedProcedure, type ProcedureFunc } from './procedure';
-export declare class ProcedureImplementer<TContext extends Context, TExtraContext extends Context, TInputSchema extends Schema, TOutputSchema extends Schema> {
-    zz$pi: {
-        contract: ContractProcedure<TInputSchema, TOutputSchema>;
-        middlewares?: Middleware<any, any, any, any>[];
-    };
-    constructor(zz$pi: {
-        contract: ContractProcedure<TInputSchema, TOutputSchema>;
-        middlewares?: Middleware<any, any, any, any>[];
-    });
-    use<UExtraContext extends Partial<MergeContext<Context, MergeContext<TContext, TExtraContext>>> | undefined = undefined>(middleware: Middleware<MergeContext<TContext, TExtraContext>, UExtraContext, SchemaOutput<TInputSchema>, SchemaInput<TOutputSchema>>): ProcedureImplementer<TContext, MergeContext<TExtraContext, UExtraContext>, TInputSchema, TOutputSchema>;
-    use<UExtraContext extends Partial<MergeContext<Context, MergeContext<TContext, TExtraContext>>> | undefined = undefined, UMappedInput = unknown>(middleware: Middleware<MergeContext<TContext, TExtraContext>, UExtraContext, UMappedInput, SchemaInput<TOutputSchema>>, mapInput: MapInputMiddleware<SchemaOutput<TInputSchema>, UMappedInput>): ProcedureImplementer<TContext, MergeContext<TExtraContext, UExtraContext>, TInputSchema, TOutputSchema>;
-    func<UFuncOutput extends SchemaOutput<TOutputSchema>>(func: ProcedureFunc<TContext, TExtraContext, TInputSchema, TOutputSchema, UFuncOutput>): DecoratedProcedure<TContext, TExtraContext, TInputSchema, TOutputSchema, UFuncOutput>;
-}
-//# sourceMappingURL=procedure-implementer.d.ts.map

package/dist/src/procedure.d.ts

@@ -1,29 +0,0 @@
-import type { Promisable } from '@orpc/shared';
-import type { ProcedureCaller } from './procedure-caller';
-import type { Context, MergeContext, Meta } from './types';
-import { type ContractProcedure, type HTTPPath, type RouteOptions, type Schema, type SchemaInput, type SchemaOutput } from '@orpc/contract';
-import { type MapInputMiddleware, type Middleware } from './middleware';
-export declare class Procedure<TContext extends Context, TExtraContext extends Context, TInputSchema extends Schema, TOutputSchema extends Schema, TFuncOutput extends SchemaOutput<TOutputSchema>> {
-    zz$p: {
-        middlewares?: Middleware<any, any, any, any>[];
-        contract: ContractProcedure<TInputSchema, TOutputSchema>;
-        func: ProcedureFunc<TContext, TExtraContext, TInputSchema, TOutputSchema, TFuncOutput>;
-    };
-    constructor(zz$p: {
-        middlewares?: Middleware<any, any, any, any>[];
-        contract: ContractProcedure<TInputSchema, TOutputSchema>;
-        func: ProcedureFunc<TContext, TExtraContext, TInputSchema, TOutputSchema, TFuncOutput>;
-    });
-}
-export type DecoratedProcedure<TContext extends Context, TExtraContext extends Context, TInputSchema extends Schema, TOutputSchema extends Schema, TFuncOutput extends SchemaOutput<TOutputSchema>> = Procedure<TContext, TExtraContext, TInputSchema, TOutputSchema, TFuncOutput> & {
-    prefix: (prefix: HTTPPath) => DecoratedProcedure<TContext, TExtraContext, TInputSchema, TOutputSchema, TFuncOutput>;
-    route: (opts: RouteOptions) => DecoratedProcedure<TContext, TExtraContext, TInputSchema, TOutputSchema, TFuncOutput>;
-    use: (<UExtraContext extends Partial<MergeContext<Context, MergeContext<TContext, TExtraContext>>> | undefined = undefined>(middleware: Middleware<MergeContext<TContext, TExtraContext>, UExtraContext, SchemaOutput<TInputSchema>, SchemaInput<TOutputSchema, TFuncOutput>>) => DecoratedProcedure<TContext, MergeContext<TExtraContext, UExtraContext>, TInputSchema, TOutputSchema, TFuncOutput>) & (<UExtraContext extends Partial<MergeContext<Context, MergeContext<TContext, TExtraContext>>> | undefined = undefined, UMappedInput = unknown>(middleware: Middleware<MergeContext<TContext, TExtraContext>, UExtraContext, UMappedInput, SchemaInput<TOutputSchema, TFuncOutput>>, mapInput: MapInputMiddleware<SchemaOutput<TInputSchema, TFuncOutput>, UMappedInput>) => DecoratedProcedure<TContext, MergeContext<TExtraContext, UExtraContext>, TInputSchema, TOutputSchema, TFuncOutput>);
-} & (undefined extends TContext ? ProcedureCaller<Procedure<TContext, TExtraContext, TInputSchema, TOutputSchema, TFuncOutput>> : unknown);
-export interface ProcedureFunc<TContext extends Context, TExtraContext extends Context, TInputSchema extends Schema, TOutputSchema extends Schema, TOutput extends SchemaOutput<TOutputSchema>> {
-    (input: SchemaOutput<TInputSchema>, context: MergeContext<TContext, TExtraContext>, meta: Meta): Promisable<SchemaInput<TOutputSchema, TOutput>>;
-}
-export declare function decorateProcedure<TContext extends Context, TExtraContext extends Context, TInputSchema extends Schema, TOutputSchema extends Schema, TFuncOutput extends SchemaOutput<TOutputSchema>>(procedure: Procedure<TContext, TExtraContext, TInputSchema, TOutputSchema, TFuncOutput>): DecoratedProcedure<TContext, TExtraContext, TInputSchema, TOutputSchema, TFuncOutput>;
-export type WELL_DEFINED_PROCEDURE = Procedure<Context, Context, Schema, Schema, unknown>;
-export declare function isProcedure(item: unknown): item is WELL_DEFINED_PROCEDURE;
-//# sourceMappingURL=procedure.d.ts.map

package/dist/src/router-builder.d.ts

@@ -1,22 +0,0 @@
-import type { HandledRouter, Router } from './router';
-import type { Context, MergeContext } from './types';
-import { type HTTPPath } from '@orpc/contract';
-import { type MapInputMiddleware, type Middleware } from './middleware';
-export declare class RouterBuilder<TContext extends Context, TExtraContext extends Context> {
-    zz$rb: {
-        prefix?: HTTPPath;
-        tags?: string[];
-        middlewares?: Middleware<any, any, any, any>[];
-    };
-    constructor(zz$rb: {
-        prefix?: HTTPPath;
-        tags?: string[];
-        middlewares?: Middleware<any, any, any, any>[];
-    });
-    prefix(prefix: HTTPPath): RouterBuilder<TContext, TExtraContext>;
-    tags(...tags: string[]): RouterBuilder<TContext, TExtraContext>;
-    use<UExtraContext extends Partial<MergeContext<Context, MergeContext<TContext, TExtraContext>>> | undefined = undefined>(middleware: Middleware<MergeContext<TContext, TExtraContext>, UExtraContext, unknown, unknown>): RouterBuilder<TContext, MergeContext<TExtraContext, UExtraContext>>;
-    use<UExtraContext extends Partial<MergeContext<Context, MergeContext<TContext, TExtraContext>>> | undefined = undefined, UMappedInput = unknown>(middleware: Middleware<MergeContext<TContext, TExtraContext>, UExtraContext, UMappedInput, unknown>, mapInput: MapInputMiddleware<unknown, UMappedInput>): RouterBuilder<TContext, MergeContext<TExtraContext, UExtraContext>>;
-    router<URouter extends Router<TContext>>(router: URouter): HandledRouter<URouter>;
-}
-//# sourceMappingURL=router-builder.d.ts.map