@orpc/contract 0.0.0-next.d0e429d → 0.0.0-next.d12598b

package/dist/shared/contract.TuRtB1Ca.d.ts

@@ -0,0 +1,254 @@
+import { ORPCErrorCode, ORPCError, HTTPMethod, HTTPPath } from '@orpc/client';
+import { Promisable, IsEqual, ThrowableError } from '@orpc/shared';
+import { StandardSchemaV1 } from '@standard-schema/spec';
+import { OpenAPIV3_1 } from 'openapi-types';
+
+type Schema<TInput, TOutput> = StandardSchemaV1<TInput, TOutput>;
+type AnySchema = Schema<any, any>;
+type SchemaIssue = StandardSchemaV1.Issue;
+type InferSchemaInput<T extends AnySchema> = T extends StandardSchemaV1<infer UInput, any> ? UInput : never;
+type InferSchemaOutput<T extends AnySchema> = T extends StandardSchemaV1<any, infer UOutput> ? UOutput : never;
+type TypeRest<TInput, TOutput> = [map: (input: TInput) => Promisable<TOutput>] | (IsEqual<TInput, TOutput> extends true ? [] : never);
+/**
+ * The schema for things can be trust without validation.
+ * If the TInput and TOutput are different, you need pass a map function.
+ *
+ * @see {@link https://orpc.dev/docs/procedure#type-utility Type Utility Docs}
+ */
+declare function type<TInput, TOutput = TInput>(...[map]: TypeRest<TInput, TOutput>): Schema<TInput, TOutput>;
+
+interface ValidationErrorOptions extends ErrorOptions {
+    message: string;
+    issues: readonly SchemaIssue[];
+    /**
+     * @todo require this field in v2
+     */
+    data?: unknown;
+}
+/**
+ * This errors usually used for ORPCError.cause when the error is a validation error.
+ *
+ * @see {@link https://orpc.dev/docs/advanced/validation-errors Validation Errors Docs}
+ */
+declare class ValidationError extends Error {
+    readonly issues: readonly SchemaIssue[];
+    readonly data: unknown;
+    constructor(options: ValidationErrorOptions);
+}
+interface ErrorMapItem<TDataSchema extends AnySchema> {
+    status?: number;
+    message?: string;
+    data?: TDataSchema;
+}
+type ErrorMap = {
+    [key in ORPCErrorCode]?: ErrorMapItem<AnySchema>;
+};
+type MergedErrorMap<T1 extends ErrorMap, T2 extends ErrorMap> = Omit<T1, keyof T2> & T2;
+declare function mergeErrorMap<T1 extends ErrorMap, T2 extends ErrorMap>(errorMap1: T1, errorMap2: T2): MergedErrorMap<T1, T2>;
+type ORPCErrorFromErrorMap<TErrorMap extends ErrorMap> = {
+    [K in keyof TErrorMap]: K extends string ? TErrorMap[K] extends ErrorMapItem<infer TDataSchema extends Schema<unknown, unknown>> ? ORPCError<K, InferSchemaOutput<TDataSchema>> : never : never;
+}[keyof TErrorMap];
+type ErrorFromErrorMap<TErrorMap extends ErrorMap> = ORPCErrorFromErrorMap<TErrorMap> | ThrowableError;
+declare function validateORPCError(map: ErrorMap, error: ORPCError<any, any>): Promise<ORPCError<string, unknown>>;
+
+type Meta = Record<string, any>;
+declare function mergeMeta<T extends Meta>(meta1: T, meta2: T): T;
+
+type InputStructure = 'compact' | 'detailed';
+type OutputStructure = 'compact' | 'detailed';
+interface Route {
+    /**
+     * The HTTP method of the procedure.
+     * This option is typically relevant when integrating with OpenAPI.
+     *
+     * @see {@link https://orpc.dev/docs/openapi/routing OpenAPI Routing Docs}
+     */
+    method?: HTTPMethod;
+    /**
+     * The HTTP path of the procedure.
+     * This option is typically relevant when integrating with OpenAPI.
+     *
+     * @see {@link https://orpc.dev/docs/openapi/routing OpenAPI Routing Docs}
+     */
+    path?: HTTPPath;
+    /**
+     * The operation ID of the endpoint.
+     * This option is typically relevant when integrating with OpenAPI.
+     *
+     * @default Concatenation of router segments
+     */
+    operationId?: string;
+    /**
+     * The summary of the procedure.
+     * This option is typically relevant when integrating with OpenAPI.
+     *
+     * @see {@link https://orpc.dev/docs/openapi/openapi-specification#operation-metadata OpenAPI Operation Metadata Docs}
+     */
+    summary?: string;
+    /**
+     * The description of the procedure.
+     * This option is typically relevant when integrating with OpenAPI.
+     *
+     * @see {@link https://orpc.dev/docs/openapi/openapi-specification#operation-metadata OpenAPI Operation Metadata Docs}
+     */
+    description?: string;
+    /**
+     * Marks the procedure as deprecated.
+     * This option is typically relevant when integrating with OpenAPI.
+     *
+     * @see {@link https://orpc.dev/docs/openapi/openapi-specification#operation-metadata OpenAPI Operation Metadata Docs}
+     */
+    deprecated?: boolean;
+    /**
+     * The tags of the procedure.
+     * This option is typically relevant when integrating with OpenAPI.
+     *
+     * @see {@link https://orpc.dev/docs/openapi/openapi-specification#operation-metadata OpenAPI Operation Metadata Docs}
+     */
+    tags?: readonly string[];
+    /**
+     * The status code of the response when the procedure is successful.
+     * The status code must be in the 200-399 range.
+     * This option is typically relevant when integrating with OpenAPI.
+     *
+     * @see {@link https://orpc.dev/docs/openapi/routing OpenAPI Routing Docs}
+     * @default 200
+     */
+    successStatus?: number;
+    /**
+     * The description of the response when the procedure is successful.
+     *  This option is typically relevant when integrating with OpenAPI.
+     *
+     * @see {@link https://orpc.dev/docs/openapi/openapi-specification#operation-metadata OpenAPI Operation Metadata Docs}
+     * @default 'OK'
+     */
+    successDescription?: string;
+    /**
+     * Determines how the input should be structured based on `params`, `query`, `headers`, and `body`.
+     *
+     * @option 'compact'
+     * Combines `params` and either `query` or `body` (depending on the HTTP method) into a single object.
+     *
+     * @option 'detailed'
+     * Keeps each part of the request (`params`, `query`, `headers`, and `body`) as separate fields in the input object.
+     *
+     * Example:
+     * ```ts
+     * const input = {
+     *   params: { id: 1 },
+     *   query: { search: 'hello' },
+     *   headers: { 'Content-Type': 'application/json' },
+     *   body: { name: 'John' },
+     * }
+     * ```
+     *
+     * @see {@link https://orpc.dev/docs/openapi/input-output-structure OpenAPI Input/Output Structure Docs}
+     * @default 'compact'
+     */
+    inputStructure?: InputStructure;
+    /**
+     * Determines how the response should be structured based on the output.
+     *
+     * @option 'compact'
+     * The output data is directly returned as the response body.
+     *
+     * @option 'detailed'
+     * Return an object with optional properties:
+     * - `status`: The response status (must be in 200-399 range) if not set fallback to `successStatus`.
+     * - `headers`: Custom headers to merge with the response headers (`Record<string, string | string[] | undefined>`)
+     * - `body`: The response body.
+     *
+     * Example:
+     * ```ts
+     * const output = {
+     *   status: 201,
+     *   headers: { 'x-custom-header': 'value' },
+     *   body: { message: 'Hello, world!' },
+     * };
+     * ```
+     *
+     * @see {@link https://orpc.dev/docs/openapi/input-output-structure OpenAPI Input/Output Structure Docs}
+     * @default 'compact'
+     */
+    outputStructure?: OutputStructure;
+    /**
+     * Override entire auto-generated OpenAPI Operation Object Specification.
+     *
+     * @see {@link https://orpc.dev/docs/openapi/openapi-specification#operation-metadata Operation Metadata Docs}
+     */
+    spec?: OpenAPIV3_1.OperationObject | ((current: OpenAPIV3_1.OperationObject) => OpenAPIV3_1.OperationObject);
+}
+declare function mergeRoute(a: Route, b: Route): Route;
+declare function prefixRoute(route: Route, prefix: HTTPPath): Route;
+declare function unshiftTagRoute(route: Route, tags: readonly string[]): Route;
+declare function mergePrefix(a: HTTPPath | undefined, b: HTTPPath): HTTPPath;
+declare function mergeTags(a: readonly string[] | undefined, b: readonly string[]): readonly string[];
+interface EnhanceRouteOptions {
+    prefix?: HTTPPath;
+    tags?: readonly string[];
+}
+declare function enhanceRoute(route: Route, options: EnhanceRouteOptions): Route;
+
+interface ContractProcedureDef<TInputSchema extends AnySchema, TOutputSchema extends AnySchema, TErrorMap extends ErrorMap, TMeta extends Meta> {
+    meta: TMeta;
+    route: Route;
+    inputSchema?: TInputSchema;
+    outputSchema?: TOutputSchema;
+    errorMap: TErrorMap;
+}
+/**
+ * This class represents a contract procedure.
+ *
+ * @see {@link https://orpc.dev/docs/contract-first/define-contract#procedure-contract Contract Procedure Docs}
+ */
+declare class ContractProcedure<TInputSchema extends AnySchema, TOutputSchema extends AnySchema, TErrorMap extends ErrorMap, TMeta extends Meta> {
+    /**
+     * This property holds the defined options for the contract procedure.
+     */
+    '~orpc': ContractProcedureDef<TInputSchema, TOutputSchema, TErrorMap, TMeta>;
+    constructor(def: ContractProcedureDef<TInputSchema, TOutputSchema, TErrorMap, TMeta>);
+}
+type AnyContractProcedure = ContractProcedure<any, any, any, any>;
+declare function isContractProcedure(item: unknown): item is AnyContractProcedure;
+
+/**
+ * Represents a contract router, which defines a hierarchical structure of contract procedures.
+ *
+ * @info A contract procedure is a contract router too.
+ * @see {@link https://orpc.dev/docs/contract-first/define-contract#contract-router Contract Router Docs}
+ */
+type ContractRouter<TMeta extends Meta> = ContractProcedure<any, any, any, TMeta> | {
+    [k: string]: ContractRouter<TMeta>;
+};
+type AnyContractRouter = ContractRouter<any>;
+/**
+ * Infer all inputs of the contract router.
+ *
+ * @info A contract procedure is a contract router too.
+ * @see {@link https://orpc.dev/docs/contract-first/define-contract#utilities Contract Utilities Docs}
+ */
+type InferContractRouterInputs<T extends AnyContractRouter> = T extends ContractProcedure<infer UInputSchema, any, any, any> ? InferSchemaInput<UInputSchema> : {
+    [K in keyof T]: T[K] extends AnyContractRouter ? InferContractRouterInputs<T[K]> : never;
+};
+/**
+ * Infer all outputs of the contract router.
+ *
+ * @info A contract procedure is a contract router too.
+ * @see {@link https://orpc.dev/docs/contract-first/define-contract#utilities Contract Utilities Docs}
+ */
+type InferContractRouterOutputs<T extends AnyContractRouter> = T extends ContractProcedure<any, infer UOutputSchema, any, any> ? InferSchemaOutput<UOutputSchema> : {
+    [K in keyof T]: T[K] extends AnyContractRouter ? InferContractRouterOutputs<T[K]> : never;
+};
+/**
+ * Infer all errors of the contract router.
+ *
+ * @info A contract procedure is a contract router too.
+ * @see {@link https://orpc.dev/docs/contract-first/define-contract#utilities Contract Utilities Docs}
+ */
+type InferContractRouterErrorMap<T extends AnyContractRouter> = T extends ContractProcedure<any, any, infer UErrorMap, any> ? UErrorMap : {
+    [K in keyof T]: T[K] extends AnyContractRouter ? InferContractRouterErrorMap<T[K]> : never;
+}[keyof T];
+type InferContractRouterMeta<T extends AnyContractRouter> = T extends ContractRouter<infer UMeta> ? UMeta : never;
+
+export { ContractProcedure as C, type as D, ValidationError as j, mergeErrorMap as m, mergeMeta as n, isContractProcedure as p, mergeRoute as q, prefixRoute as r, mergePrefix as s, mergeTags as t, unshiftTagRoute as u, validateORPCError as v, enhanceRoute as w };
+export type { AnyContractRouter as A, InferContractRouterMeta as B, ErrorMap as E, InputStructure as I, MergedErrorMap as M, OutputStructure as O, Route as R, Schema as S, TypeRest as T, ValidationErrorOptions as V, EnhanceRouteOptions as a, AnySchema as b, Meta as c, ContractRouter as d, ContractProcedureDef as e, InferSchemaInput as f, InferSchemaOutput as g, ErrorFromErrorMap as h, SchemaIssue as i, ErrorMapItem as k, ORPCErrorFromErrorMap as l, AnyContractProcedure as o, InferContractRouterInputs as x, InferContractRouterOutputs as y, InferContractRouterErrorMap as z };

package/package.json

@@ -1,9 +1,9 @@
 {
   "name": "@orpc/contract",
   "type": "module",
-  "version": "0.0.0-next.d0e429d",
+  "version": "0.0.0-next.d12598b",
   "license": "MIT",
-  "homepage": "https://orpc.unnoq.com",
+  "homepage": "https://orpc.dev",
   "repository": {
     "type": "git",
     "url": "git+https://github.com/unnoq/orpc.git",
@@ -15,32 +15,32 @@
   ],
   "exports": {
     ".": {
-      "types": "./dist/src/index.d.ts",
-      "import": "./dist/index.js",
-      "default": "./dist/index.js"
+      "types": "./dist/index.d.mts",
+      "import": "./dist/index.mjs",
+      "default": "./dist/index.mjs"
     },
-    "./🔒/*": {
-      "types": "./dist/src/*.d.ts"
+    "./plugins": {
+      "types": "./dist/plugins/index.d.mts",
+      "import": "./dist/plugins/index.mjs",
+      "default": "./dist/plugins/index.mjs"
     }
   },
   "files": [
-    "!**/*.map",
-    "!**/*.tsbuildinfo",
     "dist"
   ],
   "dependencies": {
     "@standard-schema/spec": "^1.0.0",
-    "@orpc/standard-server": "0.0.0-next.d0e429d",
-    "@orpc/shared": "0.0.0-next.d0e429d",
-    "@orpc/client": "0.0.0-next.d0e429d"
+    "openapi-types": "^12.1.3",
+    "@orpc/client": "0.0.0-next.d12598b",
+    "@orpc/shared": "0.0.0-next.d12598b"
   },
   "devDependencies": {
-    "arktype": "2.0.0-rc.26",
-    "valibot": "1.0.0-beta.9",
-    "zod": "^3.24.1"
+    "arktype": "2.1.27",
+    "valibot": "^1.2.0",
+    "zod": "^4.1.12"
   },
   "scripts": {
-    "build": "tsup --clean --sourcemap --entry.index=src/index.ts --format=esm --onSuccess='tsc -b --noCheck'",
+    "build": "unbuild",
     "build:watch": "pnpm run build --watch",
     "type:check": "tsc -b"
   }

package/dist/index.js

@@ -1,270 +0,0 @@
-// src/error.ts
-var ValidationError = class extends Error {
-  issues;
-  constructor(options) {
-    super(options.message, options);
-    this.issues = options.issues;
-  }
-};
-function mergeErrorMap(errorMap1, errorMap2) {
-  return { ...errorMap1, ...errorMap2 };
-}
-
-// src/meta.ts
-function mergeMeta(meta1, meta2) {
-  return { ...meta1, ...meta2 };
-}
-
-// src/procedure.ts
-var ContractProcedure = class {
-  "~orpc";
-  constructor(def) {
-    if (def.route?.successStatus && (def.route.successStatus < 200 || def.route?.successStatus > 299)) {
-      throw new Error("[ContractProcedure] The successStatus must be between 200 and 299");
-    }
-    if (Object.values(def.errorMap).some((val) => val && val.status && (val.status < 400 || val.status > 599))) {
-      throw new Error("[ContractProcedure] The error status code must be in the 400-599 range.");
-    }
-    this["~orpc"] = def;
-  }
-};
-function isContractProcedure(item) {
-  if (item instanceof ContractProcedure) {
-    return true;
-  }
-  return (typeof item === "object" || typeof item === "function") && item !== null && "~orpc" in item && typeof item["~orpc"] === "object" && item["~orpc"] !== null && "inputSchema" in item["~orpc"] && "outputSchema" in item["~orpc"] && "errorMap" in item["~orpc"] && "route" in item["~orpc"] && "meta" in item["~orpc"];
-}
-
-// src/route.ts
-function mergeRoute(a, b) {
-  return { ...a, ...b };
-}
-function prefixRoute(route, prefix) {
-  if (!route.path) {
-    return route;
-  }
-  return {
-    ...route,
-    path: `${prefix}${route.path}`
-  };
-}
-function unshiftTagRoute(route, tags) {
-  return {
-    ...route,
-    tags: [...tags, ...route.tags ?? []]
-  };
-}
-function mergePrefix(a, b) {
-  return a ? `${a}${b}` : b;
-}
-function mergeTags(a, b) {
-  return a ? [...a, ...b] : b;
-}
-function adaptRoute(route, options) {
-  let router = route;
-  if (options.prefix) {
-    router = prefixRoute(router, options.prefix);
-  }
-  if (options.tags) {
-    router = unshiftTagRoute(router, options.tags);
-  }
-  return router;
-}
-
-// src/router.ts
-function adaptContractRouter(contract, options) {
-  if (isContractProcedure(contract)) {
-    const adapted2 = new ContractProcedure({
-      ...contract["~orpc"],
-      errorMap: mergeErrorMap(options.errorMap, contract["~orpc"].errorMap),
-      route: adaptRoute(contract["~orpc"].route, options)
-    });
-    return adapted2;
-  }
-  const adapted = {};
-  for (const key in contract) {
-    adapted[key] = adaptContractRouter(contract[key], options);
-  }
-  return adapted;
-}
-
-// src/builder.ts
-var ContractBuilder = class _ContractBuilder extends ContractProcedure {
-  constructor(def) {
-    super(def);
-    this["~orpc"].prefix = def.prefix;
-    this["~orpc"].tags = def.tags;
-  }
-  /**
-   * Reset initial meta
-   */
-  $meta(initialMeta) {
-    return new _ContractBuilder({
-      ...this["~orpc"],
-      meta: initialMeta
-    });
-  }
-  /**
-   * Reset initial route
-   */
-  $route(initialRoute) {
-    return new _ContractBuilder({
-      ...this["~orpc"],
-      route: initialRoute
-    });
-  }
-  errors(errors) {
-    return new _ContractBuilder({
-      ...this["~orpc"],
-      errorMap: mergeErrorMap(this["~orpc"].errorMap, errors)
-    });
-  }
-  meta(meta) {
-    return new _ContractBuilder({
-      ...this["~orpc"],
-      meta: mergeMeta(this["~orpc"].meta, meta)
-    });
-  }
-  route(route) {
-    return new _ContractBuilder({
-      ...this["~orpc"],
-      route: mergeRoute(this["~orpc"].route, route)
-    });
-  }
-  input(schema) {
-    return new _ContractBuilder({
-      ...this["~orpc"],
-      inputSchema: schema
-    });
-  }
-  output(schema) {
-    return new _ContractBuilder({
-      ...this["~orpc"],
-      outputSchema: schema
-    });
-  }
-  prefix(prefix) {
-    return new _ContractBuilder({
-      ...this["~orpc"],
-      prefix: mergePrefix(this["~orpc"].prefix, prefix)
-    });
-  }
-  tag(...tags) {
-    return new _ContractBuilder({
-      ...this["~orpc"],
-      tags: mergeTags(this["~orpc"].tags, tags)
-    });
-  }
-  router(router) {
-    return adaptContractRouter(router, this["~orpc"]);
-  }
-};
-var oc = new ContractBuilder({
-  errorMap: {},
-  inputSchema: void 0,
-  outputSchema: void 0,
-  route: {},
-  meta: {}
-});
-
-// src/config.ts
-var DEFAULT_CONFIG = {
-  defaultMethod: "POST",
-  defaultSuccessStatus: 200,
-  defaultSuccessDescription: "OK",
-  defaultInputStructure: "compact",
-  defaultOutputStructure: "compact"
-};
-function fallbackContractConfig(key, value) {
-  if (value === void 0) {
-    return DEFAULT_CONFIG[key];
-  }
-  return value;
-}
-
-// src/event-iterator.ts
-import { mapEventIterator, ORPCError } from "@orpc/client";
-import { isAsyncIteratorObject } from "@orpc/shared";
-var EVENT_ITERATOR_SCHEMA_SYMBOL = Symbol("ORPC_EVENT_ITERATOR_SCHEMA");
-function eventIterator(yields, returns) {
-  return {
-    "~standard": {
-      [EVENT_ITERATOR_SCHEMA_SYMBOL]: { yields, returns },
-      vendor: "orpc",
-      version: 1,
-      validate(iterator) {
-        if (!isAsyncIteratorObject(iterator)) {
-          return { issues: [{ message: "Expect event source iterator", path: [] }] };
-        }
-        const mapped = mapEventIterator(iterator, {
-          async value(value, done) {
-            const schema = done ? returns : yields;
-            if (!schema) {
-              return value;
-            }
-            const result = await schema["~standard"].validate(value);
-            if (result.issues) {
-              throw new ORPCError("EVENT_ITERATOR_VALIDATION_FAILED", {
-                message: "Event source iterator validation failed",
-                cause: new ValidationError({
-                  issues: result.issues,
-                  message: "Event source iterator validation failed"
-                })
-              });
-            }
-            return result.value;
-          },
-          error: async (error) => error
-        });
-        return { value: mapped };
-      }
-    }
-  };
-}
-function getEventIteratorSchemaDetails(schema) {
-  if (schema === void 0) {
-    return void 0;
-  }
-  return schema["~standard"][EVENT_ITERATOR_SCHEMA_SYMBOL];
-}
-
-// src/schema.ts
-function type(...[map]) {
-  return {
-    "~standard": {
-      vendor: "custom",
-      version: 1,
-      async validate(value) {
-        if (map) {
-          return { value: await map(value) };
-        }
-        return { value };
-      }
-    }
-  };
-}
-
-// src/index.ts
-import { ORPCError as ORPCError2 } from "@orpc/client";
-export {
-  ContractBuilder,
-  ContractProcedure,
-  ORPCError2 as ORPCError,
-  ValidationError,
-  adaptContractRouter,
-  adaptRoute,
-  eventIterator,
-  fallbackContractConfig,
-  getEventIteratorSchemaDetails,
-  isContractProcedure,
-  mergeErrorMap,
-  mergeMeta,
-  mergePrefix,
-  mergeRoute,
-  mergeTags,
-  oc,
-  prefixRoute,
-  type,
-  unshiftTagRoute
-};
-//# sourceMappingURL=index.js.map

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

@@ -1,38 +0,0 @@
-import type { ErrorMap, MergedErrorMap } from './error';
-import type { Meta } from './meta';
-import type { ContractProcedure } from './procedure';
-import type { HTTPPath, Route } from './route';
-import type { AdaptContractRouterOptions, AdaptedContractRouter, ContractRouter } from './router';
-import type { Schema } from './schema';
-export interface ContractProcedureBuilder<TInputSchema extends Schema, TOutputSchema extends Schema, TErrorMap extends ErrorMap, TMeta extends Meta> extends ContractProcedure<TInputSchema, TOutputSchema, TErrorMap, TMeta> {
-    errors<U extends ErrorMap>(errors: U): ContractProcedureBuilder<TInputSchema, TOutputSchema, MergedErrorMap<TErrorMap, U>, TMeta>;
-    meta(meta: TMeta): ContractProcedureBuilder<TInputSchema, TOutputSchema, TErrorMap, TMeta>;
-    route(route: Route): ContractProcedureBuilder<TInputSchema, TOutputSchema, TErrorMap, TMeta>;
-    input<U extends Schema>(schema: U): ContractProcedureBuilderWithInput<U, TOutputSchema, TErrorMap, TMeta>;
-    output<U extends Schema>(schema: U): ContractProcedureBuilderWithOutput<TInputSchema, U, TErrorMap, TMeta>;
-}
-export interface ContractProcedureBuilderWithInput<TInputSchema extends Schema, TOutputSchema extends Schema, TErrorMap extends ErrorMap, TMeta extends Meta> extends ContractProcedure<TInputSchema, TOutputSchema, TErrorMap, TMeta> {
-    errors<U extends ErrorMap>(errors: U): ContractProcedureBuilderWithInput<TInputSchema, TOutputSchema, MergedErrorMap<TErrorMap, U>, TMeta>;
-    meta(meta: TMeta): ContractProcedureBuilderWithInput<TInputSchema, TOutputSchema, TErrorMap, TMeta>;
-    route(route: Route): ContractProcedureBuilderWithInput<TInputSchema, TOutputSchema, TErrorMap, TMeta>;
-    output<U extends Schema>(schema: U): ContractProcedureBuilderWithInputOutput<TInputSchema, U, TErrorMap, TMeta>;
-}
-export interface ContractProcedureBuilderWithOutput<TInputSchema extends Schema, TOutputSchema extends Schema, TErrorMap extends ErrorMap, TMeta extends Meta> extends ContractProcedure<TInputSchema, TOutputSchema, TErrorMap, TMeta> {
-    errors<U extends ErrorMap>(errors: U): ContractProcedureBuilderWithOutput<TInputSchema, TOutputSchema, MergedErrorMap<TErrorMap, U>, TMeta>;
-    meta(meta: TMeta): ContractProcedureBuilderWithOutput<TInputSchema, TOutputSchema, TErrorMap, TMeta>;
-    route(route: Route): ContractProcedureBuilderWithOutput<TInputSchema, TOutputSchema, TErrorMap, TMeta>;
-    input<U extends Schema>(schema: U): ContractProcedureBuilderWithInputOutput<U, TOutputSchema, TErrorMap, TMeta>;
-}
-export interface ContractProcedureBuilderWithInputOutput<TInputSchema extends Schema, TOutputSchema extends Schema, TErrorMap extends ErrorMap, TMeta extends Meta> extends ContractProcedure<TInputSchema, TOutputSchema, TErrorMap, TMeta> {
-    errors<U extends ErrorMap>(errors: U): ContractProcedureBuilderWithInputOutput<TInputSchema, TOutputSchema, MergedErrorMap<TErrorMap, U>, TMeta>;
-    meta(meta: TMeta): ContractProcedureBuilderWithInputOutput<TInputSchema, TOutputSchema, TErrorMap, TMeta>;
-    route(route: Route): ContractProcedureBuilderWithInputOutput<TInputSchema, TOutputSchema, TErrorMap, TMeta>;
-}
-export interface ContractRouterBuilder<TErrorMap extends ErrorMap, TMeta extends Meta> {
-    '~orpc': AdaptContractRouterOptions<TErrorMap>;
-    'errors'<U extends ErrorMap>(errors: U): ContractRouterBuilder<MergedErrorMap<TErrorMap, U>, TMeta>;
-    'prefix'(prefix: HTTPPath): ContractRouterBuilder<TErrorMap, TMeta>;
-    'tag'(...tags: string[]): ContractRouterBuilder<TErrorMap, TMeta>;
-    'router'<T extends ContractRouter<TMeta>>(router: T): AdaptedContractRouter<T, TErrorMap>;
-}
-//# sourceMappingURL=builder-variants.d.ts.map

package/dist/src/builder.d.ts

@@ -1,32 +0,0 @@
-import type { ContractProcedureBuilder, ContractProcedureBuilderWithInput, ContractProcedureBuilderWithOutput, ContractRouterBuilder } from './builder-variants';
-import type { ContractProcedureDef } from './procedure';
-import type { AdaptContractRouterOptions, AdaptedContractRouter, ContractRouter } from './router';
-import type { Schema } from './schema';
-import { type ErrorMap, type MergedErrorMap } from './error';
-import { type Meta } from './meta';
-import { ContractProcedure } from './procedure';
-import { type HTTPPath, type Route } from './route';
-export interface ContractBuilderDef<TInputSchema extends Schema, TOutputSchema extends Schema, TErrorMap extends ErrorMap, TMeta extends Meta> extends ContractProcedureDef<TInputSchema, TOutputSchema, TErrorMap, TMeta>, AdaptContractRouterOptions<TErrorMap> {
-}
-export declare class ContractBuilder<TInputSchema extends Schema, TOutputSchema extends Schema, TErrorMap extends ErrorMap, TMeta extends Meta> extends ContractProcedure<TInputSchema, TOutputSchema, TErrorMap, TMeta> {
-    '~orpc': ContractBuilderDef<TInputSchema, TOutputSchema, TErrorMap, TMeta>;
-    constructor(def: ContractBuilderDef<TInputSchema, TOutputSchema, TErrorMap, TMeta>);
-    /**
-     * Reset initial meta
-     */
-    $meta<U extends Meta>(initialMeta: U): ContractBuilder<TInputSchema, TOutputSchema, TErrorMap, U>;
-    /**
-     * Reset initial route
-     */
-    $route(initialRoute: Route): ContractBuilder<TInputSchema, TOutputSchema, TErrorMap, TMeta>;
-    errors<U extends ErrorMap>(errors: U): ContractBuilder<TInputSchema, TOutputSchema, MergedErrorMap<TErrorMap, U>, TMeta>;
-    meta(meta: TMeta): ContractProcedureBuilder<TInputSchema, TOutputSchema, TErrorMap, TMeta>;
-    route(route: Route): ContractProcedureBuilder<TInputSchema, TOutputSchema, TErrorMap, TMeta>;
-    input<U extends Schema>(schema: U): ContractProcedureBuilderWithInput<U, TOutputSchema, TErrorMap, TMeta>;
-    output<U extends Schema>(schema: U): ContractProcedureBuilderWithOutput<TInputSchema, U, TErrorMap, TMeta>;
-    prefix(prefix: HTTPPath): ContractRouterBuilder<TErrorMap, TMeta>;
-    tag(...tags: string[]): ContractRouterBuilder<TErrorMap, TMeta>;
-    router<T extends ContractRouter<TMeta>>(router: T): AdaptedContractRouter<T, TErrorMap>;
-}
-export declare const oc: ContractBuilder<undefined, undefined, {}, {}>;
-//# sourceMappingURL=builder.d.ts.map

package/dist/src/config.d.ts

@@ -1,10 +0,0 @@
-import type { HTTPMethod, InputStructure } from './route';
-export interface ContractConfig {
-    defaultMethod: HTTPMethod;
-    defaultSuccessStatus: number;
-    defaultSuccessDescription: string;
-    defaultInputStructure: InputStructure;
-    defaultOutputStructure: InputStructure;
-}
-export declare function fallbackContractConfig<T extends keyof ContractConfig>(key: T, value: ContractConfig[T] | undefined): ContractConfig[T];
-//# sourceMappingURL=config.d.ts.map