@temporary-name/server 1.9.3-alpha.5dc8b200530586870ac736830d4584e0333cfd05 → 1.9.3-alpha.62d88f5cf3908d4411b5278f1824b69334da8072

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

@@ -0,0 +1,515 @@
+import { Promisable, IsEqual, StandardResponse, HTTPMethod, HTTPPath, OutputStructure, OpenAPI, 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 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'];
+};
+
+interface ValidationErrorOptions extends ErrorOptions {
+    issues: readonly SchemaIssue[];
+    data: unknown;
+}
+/**
+ * This errors usually used for APIError.cause when the error is a validation error.
+ *
+ * @see {@link https://orpc.unnoq.com/docs/advanced/validation-errors Validation Errors Docs}
+ */
+declare class ValidationError extends Error {
+    readonly issues: readonly SchemaIssue[];
+    readonly data: unknown;
+    constructor(options: ValidationErrorOptions);
+}
+type Extra = Record<string, any>;
+type ErrorOpts = {
+    message?: string;
+    cause?: unknown;
+};
+type APIErrorConstructorArgs<TExtra extends Extra> = {} extends TExtra ? [options?: ErrorOpts & TExtra] : [options: ErrorOpts & TExtra];
+type InferExtra<T extends APIErrorStatic> = T['extraSchema'] extends z.core.$ZodShape ? $InferObjectOutput<T['extraSchema']> : {};
+interface APIErrorStatic {
+    status: number;
+    type: string;
+    defaultMessage: string;
+    extraSchema?: z.core.$ZodShape;
+}
+declare abstract class APIError<TSubclass extends APIErrorStatic> extends Error {
+    extra: InferExtra<TSubclass>;
+    constructor(...args: APIErrorConstructorArgs<InferExtra<TSubclass>>);
+    static get defaultMessage(): string;
+    toJSON(): {
+        type: string;
+        message: string;
+    } & InferExtra<TSubclass>;
+}
+declare class BadRequestError<TSubclass extends APIErrorStatic = typeof BadRequestError> extends APIError<TSubclass> {
+    static status: number;
+    static type: string;
+    static extraSchema: {
+        code: z.KrustyString<z.KrustyInternals<string>>;
+    };
+}
+declare class UnauthorizedError<TSubclass extends APIErrorStatic = typeof UnauthorizedError> extends APIError<TSubclass> {
+    static status: number;
+    static type: string;
+}
+declare class ForbiddenError<TSubclass extends APIErrorStatic = typeof ForbiddenError> extends APIError<TSubclass> {
+    static status: number;
+    static type: string;
+}
+declare class NotFoundError<TSubclass extends APIErrorStatic = typeof NotFoundError> extends APIError<TSubclass> {
+    static status: number;
+    static type: string;
+}
+declare class MethodNotAllowedError<TSubclass extends APIErrorStatic = typeof MethodNotAllowedError> extends APIError<TSubclass> {
+    static status: number;
+    static type: string;
+}
+declare class NotAcceptableError<TSubclass extends APIErrorStatic = typeof NotAcceptableError> extends APIError<TSubclass> {
+    static status: number;
+    static type: string;
+}
+declare class RequestTimeoutError<TSubclass extends APIErrorStatic = typeof RequestTimeoutError> extends APIError<TSubclass> {
+    static status: number;
+    static type: string;
+}
+declare class ConflictError<TSubclass extends APIErrorStatic = typeof ConflictError> extends APIError<TSubclass> {
+    static status: number;
+    static type: string;
+}
+declare class PreconditionFailedError<TSubclass extends APIErrorStatic = typeof PreconditionFailedError> extends APIError<TSubclass> {
+    static status: number;
+    static type: string;
+}
+declare class ContentTooLargeError<TSubclass extends APIErrorStatic = typeof ContentTooLargeError> extends APIError<TSubclass> {
+    static status: number;
+    static type: string;
+}
+declare class UnsupportedMediaTypeError<TSubclass extends APIErrorStatic = typeof UnsupportedMediaTypeError> extends APIError<TSubclass> {
+    static status: number;
+    static type: string;
+}
+declare class UnprocessableContentError<TSubclass extends APIErrorStatic = typeof UnprocessableContentError> extends APIError<TSubclass> {
+    static status: number;
+    static type: string;
+}
+declare class TooManyRequestsError<TSubclass extends APIErrorStatic = typeof TooManyRequestsError> extends APIError<TSubclass> {
+    static status: number;
+    static type: string;
+}
+declare class InternalServerError<TSubclass extends APIErrorStatic = typeof InternalServerError> extends APIError<TSubclass> {
+    static status: number;
+    static type: string;
+}
+declare class NotImplementedError<TSubclass extends APIErrorStatic = typeof NotImplementedError> extends APIError<TSubclass> {
+    static status: number;
+    static type: string;
+}
+declare class BadGatewayError<TSubclass extends APIErrorStatic = typeof BadGatewayError> extends APIError<TSubclass> {
+    static status: number;
+    static type: string;
+}
+declare class ServiceUnavailableError<TSubclass extends APIErrorStatic = typeof ServiceUnavailableError> extends APIError<TSubclass> {
+    static status: number;
+    static type: string;
+}
+declare class GatewayTimeoutError<TSubclass extends APIErrorStatic = typeof GatewayTimeoutError> extends APIError<TSubclass> {
+    static status: number;
+    static type: string;
+}
+type ErrorMap = Record<string, APIErrorStatic | undefined>;
+type OptionalOutSchema = {
+    _zod: {
+        optout: 'optional';
+    };
+};
+type $InferObjectOutput<T extends z.core.$ZodLooseShape> = string extends keyof T ? z.core.util.IsAny<T[keyof T]> extends true ? Record<string, unknown> : Record<string, z.core.output<T[keyof T]>> : keyof (T & Extra) extends never ? Record<string, never> : z.core.util.Prettify<{
+    -readonly [k in keyof T as T[k] extends OptionalOutSchema ? never : k]: T[k]['_zod']['output'];
+} & {
+    -readonly [k in keyof T as T[k] extends OptionalOutSchema ? k : never]?: T[k]['_zod']['output'];
+}>;
+declare function isAPIErrorStatus(status: number): boolean;
+declare function toAPIError(error: unknown): APIError<any>;
+declare function encodeError(error: APIError<any>): StandardResponse;
+
+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[];
+}
+
+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;
+    errorMap: ErrorMap;
+    schemas: TSchemas;
+    middlewares: readonly AnyMiddleware[];
+    authConfigs: AnyAuthConfig[];
+    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 BaseAuthConfig {
+    oasDescription?: string;
+    oasName?: string;
+}
+interface BasicAuthConfig<TAuthContext extends ValidatedAuthContext, TCurrentContext extends Context, TMeta extends Meta> extends BaseAuthConfig {
+    tokenPrefix?: string;
+    validate: (username: string, password: string, options: ProcedureHandlerOptions<TCurrentContext, TMeta>) => Promisable<TAuthContext>;
+}
+interface BearerAuthConfig<TAuthContext extends ValidatedAuthContext, TCurrentContext extends Context, TMeta extends Meta> extends TokenAuthConfig<TAuthContext, TCurrentContext, TMeta> {
+    oasBearerFormat?: string;
+}
+interface TokenAuthConfig<TAuthContext extends ValidatedAuthContext, TCurrentContext extends Context, TMeta extends Meta> extends BaseAuthConfig {
+    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 AnyAuthConfig = AuthConfig<any, any, any>;
+type AuthConfig<TAuthContext extends ValidatedAuthContext, TCurrentContext extends Context, TMeta extends Meta> = ({
+    type: 'basic';
+} & BasicAuthConfig<TAuthContext, TCurrentContext, TMeta>) | ({
+    type: 'bearer';
+} & BearerAuthConfig<TAuthContext, TCurrentContext, TMeta>) | ({
+    type: 'header';
+} & NamedTokenAuthConfig<TAuthContext, TCurrentContext, TMeta>) | ({
+    type: 'query';
+} & NamedTokenAuthConfig<TAuthContext, TCurrentContext, TMeta>) | ({
+    type: 'cookie';
+} & NamedTokenAuthConfig<TAuthContext, TCurrentContext, TMeta>) | {
+    type: 'none';
+};
+
+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 { NotImplementedError as $, BadRequestError as D, UnauthorizedError as F, ForbiddenError as G, MethodNotAllowedError as H, NotAcceptableError as J, RequestTimeoutError as K, NotFoundError as N, ConflictError as O, Procedure as P, PreconditionFailedError as Q, ContentTooLargeError as T, UnsupportedMediaTypeError as X, UnprocessableContentError as Y, TooManyRequestsError as Z, InternalServerError as _, BadGatewayError as a0, ServiceUnavailableError as a1, GatewayTimeoutError as a2, isAPIErrorStatus as a3, toAPIError as a4, encodeError as a5, LAZY_SYMBOL as a6, lazyInternal as a8, lazy as a9, traverseContractProcedures as aC, resolveContractProcedures as aD, unlazyRouter as aF, initialSchemas as aH, isLazy as aa, getLazyMeta as ab, unlazy as ac, mergeMeta as ad, middlewareOutputFn as ai, isProcedure as am, getRouter as au, createAccessibleLazyRouter as aw, enhanceRouter as ax, Contract as b, mergeCurrentContext as v, ValidationError as x, APIError as z };
+export type { AnyShape as A, BuildContextWithAuth as B, Context as C, ErrorMap as E, InferProcedureClientInputs as I, Lazyable as L, Meta as M, Route as R, Schemas as S, UnionToIntersection as U, ValidatedAuthContext as V, WrapShape as W, InferSchemaOutput as a, LazyMeta as a7, ContractProcedureCallbackOptions as aA, LazyTraverseContractProceduresOptions as aB, UnlaziedRouter as aE, TypeRest as aG, InitialSchemas as aI, MiddlewareResult as ae, MiddlewareNextFn as af, MiddlewareOutputFn as ag, MiddlewareOptions as ah, ProcedureHandlerOptions as aj, AnyContractDef as ak, ProcedureDef as al, ContractRouter as an, AnyRouter as ao, InferRouterInitialContext as ap, InferRouterInitialContexts as aq, InferRouterCurrentContexts as ar, InferRouterInputs as as, InferRouterOutputs as at, AccessibleLazyRouter as av, TraverseContractProceduresOptions as ay, TraverseContractProcedureCallbackOptions as az, MergedSchemas as c, AnySchema as d, Middleware as e, MergedCurrentContext as f, MergedInitialContext as g, AuthConfig as h, ProcedureHandler as i, InferHandlerInputs as j, InferSchemaInput as k, EnhanceRouterOptions as l, Router as m, EnhancedRouter as n, MapInputMiddleware as o, ContractDef as p, Schema as q, AnyMiddleware as r, Lazy as s, AnyProcedure as t, SchemaIssue as u, ValidationErrorOptions as w, APIErrorStatic as y };