@temporary-name/server 1.9.3-alpha.e098b3d1c5bffbad2fadfda89ba01f6452db46b5 → 1.9.3-alpha.ec3bfb9dce56198911349c322c970208b21b50db

package/dist/shared/server.ChOv1yG3.mjs

@@ -0,0 +1,319 @@
+import { HTTPMethods } from '@temporary-name/shared';
+import * as z from '@temporary-name/zod';
+
+function isStartWithMiddlewares(middlewares, compare) {
+  if (compare.length > middlewares.length) {
+    return false;
+  }
+  for (let i = 0; i < middlewares.length; i++) {
+    if (compare[i] === void 0) {
+      return true;
+    }
+    if (middlewares[i] !== compare[i]) {
+      return false;
+    }
+  }
+  return true;
+}
+function mergeMiddlewares(first, second, options) {
+  if (options.dedupeLeading && isStartWithMiddlewares(second, first)) {
+    return second;
+  }
+  return [...first, ...second];
+}
+function addMiddleware(middlewares, addition) {
+  return [...middlewares, addition];
+}
+
+class Contract {
+  /**
+   * This property holds the defined options.
+   */
+  "~orpc";
+  constructor(def) {
+    this["~orpc"] = def;
+  }
+}
+class Procedure extends Contract {
+}
+function isProcedure(item) {
+  return item instanceof Procedure || // This is so we'll return true for Proxy-wrapped Procedures e.g. as returned by `callable`
+  (typeof item === "object" || typeof item === "function") && item !== null && "~orpc" in item && typeof item["~orpc"] === "object" && item["~orpc"] !== null && "route" in item["~orpc"] && "meta" in item["~orpc"] && "middlewares" in item["~orpc"] && "inputValidationIndex" in item["~orpc"] && "outputValidationIndex" in item["~orpc"] && "handler" in item["~orpc"];
+}
+
+class ValidationError extends Error {
+  issues;
+  data;
+  constructor(options) {
+    super(options.message, options);
+    this.issues = options.issues;
+    this.data = options.data;
+  }
+}
+
+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 enhanceRoute(route, options) {
+  let router = route;
+  if (options.prefix) {
+    router = prefixRoute(router, options.prefix);
+  }
+  if (options.tags?.length) {
+    router = unshiftTagRoute(router, options.tags);
+  }
+  return router;
+}
+
+function getRouter(router, path) {
+  let current = router;
+  for (let i = 0; i < path.length; i++) {
+    const segment = path[i];
+    if (!current) {
+      return void 0;
+    }
+    if (isProcedure(current)) {
+      return void 0;
+    }
+    if (!isLazy(current)) {
+      current = current[segment];
+      continue;
+    }
+    const lazied = current;
+    const rest = path.slice(i);
+    return lazyInternal(async () => {
+      const unwrapped = await unlazy(lazied);
+      const next = getRouter(unwrapped.default, rest);
+      return unlazy(next);
+    }, getLazyMeta(lazied));
+  }
+  return current;
+}
+function createAccessibleLazyRouter(lazied) {
+  const recursive = new Proxy(lazied, {
+    get(target, key) {
+      if (typeof key !== "string") {
+        return Reflect.get(target, key);
+      }
+      const next = getRouter(lazied, [key]);
+      return createAccessibleLazyRouter(next);
+    }
+  });
+  return recursive;
+}
+function enhanceRouter(router, options) {
+  if (isLazy(router)) {
+    const laziedMeta = getLazyMeta(router);
+    const enhancedPrefix = laziedMeta?.prefix ? mergePrefix(options.prefix, laziedMeta?.prefix) : options.prefix;
+    const enhanced2 = lazyInternal(
+      async () => {
+        const { default: unlaziedRouter } = await unlazy(router);
+        const enhanced3 = enhanceRouter(unlaziedRouter, options);
+        return unlazy(enhanced3);
+      },
+      {
+        ...laziedMeta,
+        prefix: enhancedPrefix
+      }
+    );
+    const accessible = createAccessibleLazyRouter(enhanced2);
+    return accessible;
+  }
+  if (isProcedure(router)) {
+    const newMiddlewares = mergeMiddlewares(options.middlewares, router["~orpc"].middlewares, {
+      dedupeLeading: options.dedupeLeadingMiddlewares
+    });
+    const newMiddlewareAdded = newMiddlewares.length - router["~orpc"].middlewares.length;
+    const enhanced2 = new Procedure({
+      ...router["~orpc"],
+      route: enhanceRoute(router["~orpc"].route, options),
+      middlewares: newMiddlewares,
+      inputValidationIndex: router["~orpc"].inputValidationIndex + newMiddlewareAdded,
+      outputValidationIndex: router["~orpc"].outputValidationIndex + newMiddlewareAdded
+    });
+    return enhanced2;
+  }
+  const enhanced = {};
+  for (const key in router) {
+    enhanced[key] = enhanceRouter(router[key], options);
+  }
+  return enhanced;
+}
+function traverseContractProcedures(options, callback, lazyOptions = []) {
+  const currentRouter = options.router;
+  if (isLazy(currentRouter)) {
+    lazyOptions.push({
+      router: currentRouter,
+      path: options.path
+    });
+  } else if (currentRouter instanceof Contract) {
+    callback({
+      contract: currentRouter,
+      path: options.path
+    });
+  } else if (typeof currentRouter === "string") {
+    throw new Error("Unexpected: got string instead of router");
+  } else {
+    for (const key in currentRouter) {
+      traverseContractProcedures(
+        {
+          router: currentRouter[key],
+          path: [...options.path, key]
+        },
+        callback,
+        lazyOptions
+      );
+    }
+  }
+  return lazyOptions;
+}
+async function resolveContractProcedures(options, callback) {
+  const pending = [options];
+  for (const options2 of pending) {
+    const lazyOptions = traverseContractProcedures(options2, callback);
+    for (const options3 of lazyOptions) {
+      const { default: router } = await unlazy(options3.router);
+      pending.push({
+        router,
+        path: options3.path
+      });
+    }
+  }
+}
+async function unlazyRouter(router) {
+  if (isProcedure(router)) {
+    return router;
+  }
+  const unlazied = {};
+  for (const key in router) {
+    const item = router[key];
+    const { default: unlaziedRouter } = await unlazy(item);
+    unlazied[key] = await unlazyRouter(unlaziedRouter);
+  }
+  return unlazied;
+}
+
+const LAZY_SYMBOL = Symbol("ORPC_LAZY_SYMBOL");
+function lazyInternal(loader, meta = {}) {
+  return {
+    [LAZY_SYMBOL]: {
+      loader,
+      meta
+    }
+  };
+}
+function lazy(prefix, loader) {
+  return enhanceRouter(lazyInternal(loader), {
+    middlewares: [],
+    dedupeLeadingMiddlewares: true,
+    prefix
+  });
+}
+function isLazy(item) {
+  return (typeof item === "object" || typeof item === "function") && item !== null && LAZY_SYMBOL in item;
+}
+function getLazyMeta(lazied) {
+  return lazied[LAZY_SYMBOL].meta;
+}
+function unlazy(lazied) {
+  return isLazy(lazied) ? lazied[LAZY_SYMBOL].loader() : Promise.resolve({ default: lazied });
+}
+
+const endpointRegex = new RegExp(`^(${HTTPMethods.join("|")})`);
+function standardizeHTTPPath(path) {
+  return `/${path.replace(/\/{2,}/g, "/").replace(/^\/|\/$/g, "")}`;
+}
+function getDynamicParams(path) {
+  return path ? standardizeHTTPPath(path).match(/\/\{[^}]+\}/g)?.map((v) => ({
+    raw: v,
+    name: v.match(/\{\+?([^}]+)\}/)[1]
+  })) : void 0;
+}
+function parseEndpointDefinition(stringsOrEndpoint, values) {
+  let method, path, pathSchema;
+  if (stringsOrEndpoint instanceof Array) {
+    let endpoint = stringsOrEndpoint[0];
+    if (endpoint === void 0 || !endpointRegex.test(endpoint)) {
+      throw new Error(".endpoint() must start with a valid HTTP endpoint string.");
+    }
+    const shape = {};
+    for (let i = 1; i < stringsOrEndpoint.length; i++) {
+      const str = stringsOrEndpoint[i];
+      const value = values[i - 1];
+      if (typeof value !== "object" || value instanceof z.core.$ZodType) {
+        throw new Error(
+          `Each template value for .endpoint must be an object with a single key, whose value is a ZodType.`
+        );
+      }
+      const valueEntries = Object.entries(value);
+      if (valueEntries.length !== 1) {
+        throw new Error(
+          `Each template value for .endpoint must be an object with a single key, whose value is a ZodType.`
+        );
+      }
+      const [key, schema] = valueEntries[0];
+      endpoint += `{${key}}${str}`;
+      if (key in schema) {
+        throw new Error(`Duplicate path parameter name "${key}" in endpoint.`);
+      }
+      shape[key] = schema;
+    }
+    [method, path] = endpoint.split(" ", 2);
+    pathSchema = z.object(shape);
+  } else if (values.length <= 1) {
+    const endpoint = stringsOrEndpoint;
+    const schema = values[0];
+    [method, path] = endpoint.split(" ", 2);
+    const pathParamNames = getDynamicParams(path)?.map((p) => p.name) ?? [];
+    let schemaKeys;
+    if (schema instanceof z.core.$ZodType) {
+      if (schema instanceof z.core.$ZodObject) {
+        schemaKeys = Object.keys(schema._zod.def.shape);
+        pathSchema = schema;
+      } else {
+        throw new Error(
+          `Path schema for endpoint "${endpoint}" must be a ZodObject schema (or object where each value is a ZodType).`
+        );
+      }
+    } else if (typeof schema === "object") {
+      schemaKeys = Object.keys(schema);
+      pathSchema = z.object(schema);
+    } else if (schema !== void 0) {
+      throw new Error(
+        `Path schema for endpoint "${endpoint}" must be a ZodObject schema (or object where each value is a ZodType).`
+      );
+    } else {
+      schemaKeys = [];
+      pathSchema = z.object({});
+    }
+    if (pathParamNames.length !== schemaKeys.length || !pathParamNames.every((name) => schemaKeys.includes(name))) {
+      throw new Error(`Path schema keys do not match dynamic parameters in endpoint "${endpoint}".`);
+    }
+  } else {
+    throw new Error("Invalid arguments for .endpoint() method.");
+  }
+  return { method, path, pathSchema };
+}
+
+export { Contract as C, LAZY_SYMBOL as L, Procedure as P, ValidationError as V, mergeTags as a, mergeRoute as b, prefixRoute as c, addMiddleware as d, enhanceRouter as e, getLazyMeta as f, getDynamicParams as g, isLazy as h, isProcedure as i, getRouter as j, lazy as k, lazyInternal as l, mergePrefix as m, isStartWithMiddlewares as n, mergeMiddlewares as o, parseEndpointDefinition as p, createAccessibleLazyRouter as q, resolveContractProcedures as r, standardizeHTTPPath as s, traverseContractProcedures as t, unlazy as u, unlazyRouter as v, endpointRegex as w };

package/dist/shared/server.Cj3_Lp61.d.mts

@@ -0,0 +1,373 @@
+import { Promisable, HTTPMethod, HTTPPath, OutputStructure, OpenAPI, IsEqual, StandardLazyRequest } from '@temporary-name/shared';
+import * as z from '@temporary-name/zod';
+
+type Context = object;
+type MergedInitialContext<TInitial extends Context, TAdditional extends Context, TCurrent extends Context> = TInitial & Omit<TAdditional, keyof TCurrent>;
+type MergedCurrentContext<T extends Context, U extends Context> = Omit<T, keyof U> & U;
+type BuildContextWithAuth<TContext extends Context, TAuthContext> = MergedCurrentContext<TContext, {
+    auth: TAuthContext | ('auth' extends keyof TContext ? TContext['auth'] : never);
+}>;
+declare function mergeCurrentContext<T extends Context, U extends Context>(context: T, other: U): MergedCurrentContext<T, U>;
+
+type Meta = Record<string, any>;
+declare function mergeMeta<T extends Meta>(meta1: T, meta2: T): T;
+
+type MiddlewareResult<TOutContext extends Context, TOutput> = Promisable<{
+    output: TOutput;
+    context: TOutContext;
+}>;
+interface MiddlewareNextFn<TOutput> {
+    <U extends Context = {}>(options?: {
+        context?: U;
+    }): MiddlewareResult<U, TOutput>;
+}
+interface MiddlewareOutputFn<TOutput> {
+    (output: TOutput): MiddlewareResult<{}, TOutput>;
+}
+interface MiddlewareOptions<TInContext extends Context, TOutput, TMeta extends Meta> extends ProcedureHandlerOptions<TInContext, TMeta> {
+    next: MiddlewareNextFn<TOutput>;
+}
+/**
+ * A function that represents a middleware.
+ *
+ * @see {@link https://orpc.unnoq.com/docs/middleware Middleware Docs}
+ */
+interface Middleware<TInContext extends Context, TOutContext extends Context, TInput, TOutput, TMeta extends Meta> {
+    (options: MiddlewareOptions<TInContext, TOutput, TMeta>, input: TInput, output: MiddlewareOutputFn<TOutput>): Promisable<MiddlewareResult<TOutContext, TOutput>>;
+}
+type AnyMiddleware = Middleware<any, any, any, any, any>;
+interface MapInputMiddleware<TInput, TMappedInput> {
+    (input: TInput): TMappedInput;
+}
+declare function middlewareOutputFn<TOutput>(output: TOutput): MiddlewareResult<{}, TOutput>;
+
+interface Route {
+    /**
+     * The HTTP method of the procedure.
+     * This option is typically relevant when integrating with OpenAPI.
+     *
+     * @see {@link https://orpc.unnoq.com/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.unnoq.com/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.unnoq.com/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.unnoq.com/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.unnoq.com/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.unnoq.com/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.unnoq.com/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.unnoq.com/docs/openapi/openapi-specification#operation-metadata OpenAPI Operation Metadata Docs}
+     * @default 'OK'
+     */
+    successDescription?: string;
+    /**
+     * 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.unnoq.com/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.unnoq.com/docs/openapi/openapi-specification#operation-metadata Operation Metadata Docs}
+     */
+    spec?: OpenAPI.OperationObject | ((current: OpenAPI.OperationObject) => OpenAPI.OperationObject);
+}
+interface EnhanceRouteOptions {
+    prefix?: HTTPPath;
+    tags?: readonly string[];
+}
+
+type Schema<TInput, TOutput> = z.core.$ZodType<TOutput, TInput>;
+type AnySchema = z.core.$ZodType<any, any>;
+type AnyShape = Readonly<Record<string, AnySchema>>;
+type UnionToIntersection<T extends readonly object[]> = T extends readonly [infer First, ...infer Rest] ? First & (Rest extends readonly object[] ? UnionToIntersection<Rest> : {}) : {};
+type WrapShape<U extends AnySchema | AnyShape> = U extends AnySchema ? U : U extends AnyShape ? z.KrustyObject<U, z.core.$strip> : never;
+type SchemaIssue = z.core.$ZodIssue;
+type InferSchemaInput<T extends AnySchema> = z.input<T>;
+type InferSchemaOutput<T extends AnySchema> = z.output<T>;
+type InferHandlerInputs<TSchemas extends Schemas> = {
+    path: InferSchemaOutput<TSchemas['pathSchema']>;
+    query: InferSchemaOutput<TSchemas['querySchema']>;
+    body: InferSchemaOutput<TSchemas['bodySchema']>;
+};
+type InferProcedureClientInputs<TSchemas extends Schemas> = {
+    path: InferSchemaInput<TSchemas['pathSchema']>;
+    query: InferSchemaInput<TSchemas['querySchema']>;
+    body: InferSchemaInput<TSchemas['bodySchema']>;
+};
+type TypeRest<TInput, TOutput> = [map: (input: TInput) => Promisable<TOutput>] | (IsEqual<TInput, TOutput> extends true ? [] : never);
+interface Schemas {
+    pathSchema: AnySchema;
+    querySchema: AnySchema;
+    bodySchema: AnySchema;
+    outputSchema: AnySchema;
+}
+declare const initialSchemas: {
+    pathSchema: z.KrustyObject<{}, z.core.$strict, z.KrustyInternals<string>>;
+    querySchema: z.KrustyObject<{}, z.core.$strict, z.KrustyInternals<string>>;
+    bodySchema: z.KrustyObject<{}, z.core.$strict, z.KrustyInternals<string>>;
+    outputSchema: z.KrustyUnknown<z.KrustyInternals<string>>;
+};
+type InitialSchemas = typeof initialSchemas;
+type MergedSchemas<T1 extends Schemas, T2 extends Partial<Schemas>> = {
+    pathSchema: T2['pathSchema'] extends AnySchema ? T2['pathSchema'] : T1['pathSchema'];
+    querySchema: T2['querySchema'] extends AnySchema ? T2['querySchema'] : T1['querySchema'];
+    bodySchema: T2['bodySchema'] extends AnySchema ? T2['bodySchema'] : T1['bodySchema'];
+    outputSchema: T2['outputSchema'] extends AnySchema ? T2['outputSchema'] : T1['outputSchema'];
+};
+
+type DefaultProcedureHandlerOptions = ProcedureHandlerOptions<Context, Meta>;
+interface ProcedureHandlerOptions<TCurrentContext extends Context, TMeta extends Meta> {
+    context: TCurrentContext;
+    path: readonly string[];
+    procedure: Procedure<Context, Context, Schemas, TMeta>;
+    signal?: AbortSignal;
+    request?: StandardLazyRequest;
+    lastEventId: string | undefined;
+}
+interface ProcedureHandler<TCurrentContext extends Context, TInput extends {
+    path: any;
+    query: any;
+    body: any;
+}, THandlerOutput, TMeta extends Meta> {
+    (input: TInput, opt: ProcedureHandlerOptions<TCurrentContext, TMeta>): Promisable<THandlerOutput>;
+}
+interface ContractDef<TSchemas extends Schemas, TMeta extends Meta> {
+    meta: TMeta;
+    route: Route;
+    schemas: TSchemas;
+    middlewares: readonly AnyMiddleware[];
+    authConfigs: TypedAuthConfig[];
+    inputValidationIndex: number;
+    outputValidationIndex: number;
+}
+type AnyContractDef = ContractDef<Schemas, Meta>;
+declare class Contract<TDef extends AnyContractDef = AnyContractDef> {
+    /**
+     * This property holds the defined options.
+     */
+    '~orpc': TDef;
+    constructor(def: TDef);
+}
+interface ProcedureDef<TInitialContext extends Context, TCurrentContext extends Context, TSchemas extends Schemas, TMeta extends Meta> extends ContractDef<TSchemas, TMeta> {
+    handler: ProcedureHandler<TCurrentContext, any, any, any>;
+    '~~DO_NOT_USE_initialContextHack'?: (type: TInitialContext) => unknown;
+}
+/**
+ * This class represents a procedure.
+ *
+ * @see {@link https://orpc.unnoq.com/docs/procedure Procedure Docs}
+ */
+declare class Procedure<TInitialContext extends Context, TCurrentContext extends Context, TSchemas extends Schemas, TMeta extends Meta> extends Contract<ProcedureDef<TInitialContext, TCurrentContext, TSchemas, TMeta>> {
+}
+type AnyProcedure = Procedure<any, any, Schemas, any>;
+declare function isProcedure(item: unknown): item is AnyProcedure;
+
+type ValidatedAuthContext = {};
+interface BasicAuthConfig<TAuthContext extends ValidatedAuthContext, TCurrentContext extends Context, TMeta extends Meta> {
+    tokenPrefix?: string;
+    validate: (username: string, password: string, options: ProcedureHandlerOptions<TCurrentContext, TMeta>) => Promisable<TAuthContext>;
+}
+interface TokenAuthConfig<TAuthContext extends ValidatedAuthContext, TCurrentContext extends Context, TMeta extends Meta> {
+    tokenPrefix?: string;
+    validate: (token: string, options: ProcedureHandlerOptions<TCurrentContext, TMeta>) => Promisable<TAuthContext>;
+}
+interface NamedTokenAuthConfig<TAuthContext extends ValidatedAuthContext, TCurrentContext extends Context, TMeta extends Meta> extends TokenAuthConfig<TAuthContext, TCurrentContext, TMeta> {
+    name: string;
+}
+type AuthType = 'header' | 'query' | 'cookie' | 'bearer' | 'basic' | 'none';
+type AuthConfig<TAuthType extends AuthType, TAuthContext extends ValidatedAuthContext = ValidatedAuthContext, TCurrentContext extends Context = Context, TMeta extends Meta = Meta> = TAuthType extends 'basic' ? BasicAuthConfig<TAuthContext, TCurrentContext, TMeta> : TAuthType extends 'bearer' ? TokenAuthConfig<TAuthContext, TCurrentContext, TMeta> : TAuthType extends 'header' ? NamedTokenAuthConfig<TAuthContext, TCurrentContext, TMeta> : TAuthType extends 'query' ? NamedTokenAuthConfig<TAuthContext, TCurrentContext, TMeta> : TAuthType extends 'cookie' ? NamedTokenAuthConfig<TAuthContext, TCurrentContext, TMeta> : TAuthType extends 'none' ? {} : never;
+type TypedAuthConfig<TAuthType extends AuthType = AuthType> = {
+    type: TAuthType;
+} & AuthConfig<TAuthType, object>;
+
+type ContractRouter = Contract | {
+    [k: string]: ContractRouter;
+};
+/**
+ * Represents a router, which defines a hierarchical structure of procedures.
+ *
+ * @info A procedure is a router too.
+ * @see {@link https://orpc.unnoq.com/docs/contract-first/define-contract#contract-router Contract Router Docs}
+ */
+type Router<TInitialContext extends Context> = Procedure<TInitialContext, any, any, any> | {
+    [k: string]: Lazyable<Router<TInitialContext>>;
+};
+type AnyRouter = Router<any>;
+type InferRouterInitialContext<T extends AnyRouter> = T extends Router<infer UInitialContext> ? UInitialContext : never;
+/**
+ * Infer all initial context of the router.
+ *
+ * @info A procedure is a router too.
+ * @see {@link https://orpc.unnoq.com/docs/router#utilities Router Utilities Docs}
+ */
+type InferRouterInitialContexts<T extends AnyRouter> = T extends Procedure<infer UInitialContext, any, any, any> ? UInitialContext : {
+    [K in keyof T]: T[K] extends Lazyable<infer U extends AnyRouter> ? InferRouterInitialContexts<U> : never;
+};
+/**
+ * Infer all current context of the router.
+ *
+ * @info A procedure is a router too.
+ * @see {@link https://orpc.unnoq.com/docs/router#utilities Router Utilities Docs}
+ */
+type InferRouterCurrentContexts<T extends AnyRouter> = T extends Procedure<any, infer UCurrentContext, any, any> ? UCurrentContext : {
+    [K in keyof T]: T[K] extends Lazyable<infer U extends AnyRouter> ? InferRouterCurrentContexts<U> : never;
+};
+/**
+ * Infer all router inputs
+ *
+ * @info A procedure is a router too.
+ * @see {@link https://orpc.unnoq.com/docs/router#utilities Router Utilities Docs}
+ */
+type InferRouterInputs<T extends AnyRouter> = T extends Procedure<any, any, infer USchemas, any> ? InferProcedureClientInputs<USchemas> : {
+    [K in keyof T]: T[K] extends Lazyable<infer U extends AnyRouter> ? InferRouterInputs<U> : never;
+};
+/**
+ * Infer all router outputs
+ *
+ * @info A procedure is a router too.
+ * @see {@link https://orpc.unnoq.com/docs/router#utilities Router Utilities Docs}
+ */
+type InferRouterOutputs<T extends AnyRouter> = T extends Procedure<any, any, infer USchemas, any> ? InferSchemaOutput<USchemas['outputSchema']> : {
+    [K in keyof T]: T[K] extends Lazyable<infer U extends AnyRouter> ? InferRouterOutputs<U> : never;
+};
+
+declare function getRouter<T extends Lazyable<AnyRouter | undefined>>(router: T, path: readonly string[]): T extends Lazy<any> ? Lazy<AnyRouter | undefined> : Lazyable<AnyRouter | undefined>;
+type AccessibleLazyRouter<T extends Lazyable<AnyRouter | undefined>> = T extends Lazy<infer U extends AnyRouter | undefined | Lazy<AnyRouter | undefined>> ? AccessibleLazyRouter<U> : T extends AnyProcedure | undefined ? Lazy<T> : Lazy<T> & {
+    [K in keyof T]: T[K] extends Lazyable<AnyRouter> ? AccessibleLazyRouter<T[K]> : never;
+};
+declare function createAccessibleLazyRouter<T extends Lazy<AnyRouter | undefined>>(lazied: T): AccessibleLazyRouter<T>;
+type EnhancedRouter<T extends Lazyable<AnyRouter>, TInitialContext extends Context, TCurrentContext extends Context> = T extends Lazy<infer U extends AnyRouter> ? AccessibleLazyRouter<EnhancedRouter<U, TInitialContext, TCurrentContext>> : T extends Procedure<infer UInitialContext, infer UCurrentContext, infer USchemas, infer UMeta> ? Procedure<MergedInitialContext<TInitialContext, UInitialContext, TCurrentContext>, UCurrentContext, USchemas, UMeta> : {
+    [K in keyof T]: T[K] extends Lazyable<AnyRouter> ? EnhancedRouter<T[K], TInitialContext, TCurrentContext> : never;
+};
+interface EnhanceRouterOptions extends EnhanceRouteOptions {
+    middlewares: readonly AnyMiddleware[];
+    dedupeLeadingMiddlewares: boolean;
+}
+declare function enhanceRouter<T extends Lazyable<AnyRouter>, TInitialContext extends Context, TCurrentContext extends Context>(router: T, options: EnhanceRouterOptions): EnhancedRouter<T, TInitialContext, TCurrentContext>;
+interface TraverseContractProceduresOptions {
+    router: ContractRouter | AnyRouter;
+    path: readonly string[];
+}
+interface TraverseContractProcedureCallbackOptions {
+    contract: Contract;
+    path: readonly string[];
+}
+/**
+ * @deprecated Use `TraverseContractProcedureCallbackOptions` instead.
+ */
+type ContractProcedureCallbackOptions = TraverseContractProcedureCallbackOptions;
+interface LazyTraverseContractProceduresOptions {
+    router: Lazy<AnyRouter>;
+    path: readonly string[];
+}
+declare function traverseContractProcedures(options: TraverseContractProceduresOptions, callback: (options: TraverseContractProcedureCallbackOptions) => void, lazyOptions?: LazyTraverseContractProceduresOptions[]): LazyTraverseContractProceduresOptions[];
+declare function resolveContractProcedures(options: TraverseContractProceduresOptions, callback: (options: TraverseContractProcedureCallbackOptions) => void): Promise<void>;
+type UnlaziedRouter<T extends AnyRouter> = T extends AnyProcedure ? T : {
+    [K in keyof T]: T[K] extends Lazyable<infer U extends AnyRouter> ? UnlaziedRouter<U> : never;
+};
+declare function unlazyRouter<T extends AnyRouter>(router: T): Promise<UnlaziedRouter<T>>;
+
+declare const LAZY_SYMBOL: unique symbol;
+interface LazyMeta {
+    prefix?: HTTPPath;
+}
+interface Lazy<T> {
+    [LAZY_SYMBOL]: {
+        loader: () => Promise<{
+            default: T;
+        }>;
+        meta: LazyMeta;
+    };
+}
+type Lazyable<T> = T | Lazy<T>;
+/**
+ * @internal
+ */
+declare function lazyInternal<T>(loader: () => Promise<{
+    default: T;
+}>, meta?: LazyMeta): Lazy<T>;
+/**
+ * Creates a lazy-loaded item.
+ *
+ * @warning The `prefix` in `meta` only holds metadata and does not apply the prefix to the lazy router, use `os.prefix(...).lazyRoute(...)` instead.
+ */
+declare function lazy<T extends Router<any>>(prefix: HTTPPath, loader: () => Promise<{
+    default: T;
+}>): EnhancedRouter<Lazy<T>, {}, {}>;
+declare function isLazy(item: unknown): item is Lazy<any>;
+declare function getLazyMeta(lazied: Lazy<any>): LazyMeta;
+declare function unlazy<T extends Lazyable<any>>(lazied: T): Promise<{
+    default: T extends Lazy<infer U> ? U : T;
+}>;
+
+export { lazyInternal as D, lazy as F, isLazy as G, getLazyMeta as H, unlazy as J, mergeMeta as K, Procedure as P, middlewareOutputFn as X, isProcedure as a0, getRouter as a6, createAccessibleLazyRouter as a8, enhanceRouter as a9, traverseContractProcedures as ae, resolveContractProcedures as af, unlazyRouter as ah, initialSchemas as aj, Contract as b, mergeCurrentContext as x, LAZY_SYMBOL as y };
+export type { ProcedureDef as $, AnyShape as A, BuildContextWithAuth as B, Context as C, EnhanceRouterOptions as E, InferProcedureClientInputs as I, Lazyable as L, Meta as M, MiddlewareResult as N, MiddlewareNextFn as O, MiddlewareOutputFn as Q, Route as R, Schemas as S, MiddlewareOptions as T, UnionToIntersection as U, ValidatedAuthContext as V, WrapShape as W, DefaultProcedureHandlerOptions as Y, ProcedureHandlerOptions as Z, AnyContractDef as _, InferSchemaOutput as a, ContractRouter as a1, InferRouterInitialContexts as a2, InferRouterCurrentContexts as a3, InferRouterInputs as a4, InferRouterOutputs as a5, AccessibleLazyRouter as a7, TraverseContractProceduresOptions as aa, TraverseContractProcedureCallbackOptions as ab, ContractProcedureCallbackOptions as ac, LazyTraverseContractProceduresOptions as ad, UnlaziedRouter as ag, TypeRest as ai, InitialSchemas as ak, MergedSchemas as c, AnySchema as d, Middleware as e, MergedCurrentContext as f, MergedInitialContext as g, AuthType as h, AuthConfig as i, ProcedureHandler as j, InferHandlerInputs as k, InferSchemaInput as l, Router as m, EnhancedRouter as n, MapInputMiddleware as o, ContractDef as p, SchemaIssue as q, Schema as r, AnyMiddleware as s, Lazy as t, AnyProcedure as u, AnyRouter as v, InferRouterInitialContext as w, LazyMeta as z };