@temporary-name/server 1.9.3-alpha.fb7b7d19964e1b2def7056f4345b63d6fcacce10 → 1.9.3-alpha.fb7e3a67f82deaeffad5063e136b2f3c03c4b5b3

package/dist/shared/{server.DXPMDozZ.d.mts → server.BwcJq6aP.d.mts}

@@ -1,4 +1,4 @@
-import { Promisable, HTTPMethod, HTTPPath, OutputStructure, OpenAPI, IsEqual, StandardLazyRequest } from '@temporary-name/shared';
+import { Promisable, IsEqual, StandardResponse, HTTPMethod, HTTPPath, OutputStructure, OpenAPI, StandardLazyRequest } from '@temporary-name/shared';
 import * as z from '@temporary-name/zod';
 
 type Context = object;
@@ -12,6 +12,464 @@ declare function mergeCurrentContext<T extends Context, U extends Context>(conte
 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 APIErrorConstructor<TExtra extends Extra, TKlass extends (typeof COMMON_ERRORS)[keyof typeof COMMON_ERRORS]> = {
+    new (...args: APIErrorConstructorArgs<TExtra & $InferObjectOutput<TKlass['extraSchema']>>): TExtra extends Record<string, never> ? InstanceType<TKlass> : InstanceType<TKlass> & {
+        extra: TExtra;
+    };
+    extraSchema: z.core.$ZodShape;
+};
+type CustomAPIErrorConstructor<TStatus extends number, TType extends string, TDefaultMessage extends string, TExtra extends Extra> = {
+    new (...args: APIErrorConstructorArgs<TExtra>): APIError<TExtra>;
+    status: TStatus;
+    type: TType;
+    defaultMessage: TDefaultMessage;
+    extraSchema: z.core.$ZodShape;
+};
+type SubclassOf<T> = {
+    new (...args: any[]): T;
+    extraSchema: z.core.$ZodShape;
+};
+declare abstract class APIError<TExtra extends Extra> extends Error {
+    extra: TExtra;
+    static extraSchema: z.core.$ZodShape;
+    static status: number;
+    static type: string;
+    static staticDefaultMessage: string | undefined;
+    constructor(...args: APIErrorConstructorArgs<TExtra>);
+    static get defaultMessage(): string;
+    toJSON(): {
+        type: string;
+        message: string;
+    } & TExtra;
+}
+declare class BadRequestError extends APIError<{
+    code: string;
+}> {
+    static status: number;
+    static type: string;
+    static extraSchema: {
+        code: z.KrustyString<z.KrustyInternals<string>>;
+    };
+}
+declare class UnauthorizedError extends APIError<{}> {
+    static status: number;
+    static type: string;
+}
+declare class ForbiddenError extends APIError<{}> {
+    static status: number;
+    static type: string;
+}
+declare class NotFoundError extends APIError<{}> {
+    static status: number;
+    static type: string;
+}
+declare class InternalServerError extends APIError<{}> {
+    static status: number;
+    static type: string;
+}
+declare const COMMON_ERRORS: {
+    readonly BadRequestError: typeof BadRequestError;
+    readonly UnauthorizedError: typeof UnauthorizedError;
+    readonly ForbiddenError: typeof ForbiddenError;
+    readonly NotFoundError: typeof NotFoundError;
+    readonly MethodNotAllowedError: {
+        new (options?: ErrorOpts | undefined): {
+            extra: {};
+            toJSON(): {
+                type: string;
+                message: string;
+            };
+            name: string;
+            message: string;
+            stack?: string;
+            cause?: unknown;
+        };
+        status: number;
+        type: string;
+        extraSchema: z.core.$ZodShape;
+        staticDefaultMessage: string | undefined;
+        get defaultMessage(): string;
+        captureStackTrace(targetObject: object, constructorOpt?: Function): void;
+        prepareStackTrace(err: Error, stackTraces: NodeJS.CallSite[]): any;
+        stackTraceLimit: number;
+    };
+    readonly NotAcceptableError: {
+        new (options?: ErrorOpts | undefined): {
+            extra: {};
+            toJSON(): {
+                type: string;
+                message: string;
+            };
+            name: string;
+            message: string;
+            stack?: string;
+            cause?: unknown;
+        };
+        status: number;
+        type: string;
+        extraSchema: z.core.$ZodShape;
+        staticDefaultMessage: string | undefined;
+        get defaultMessage(): string;
+        captureStackTrace(targetObject: object, constructorOpt?: Function): void;
+        prepareStackTrace(err: Error, stackTraces: NodeJS.CallSite[]): any;
+        stackTraceLimit: number;
+    };
+    readonly RequestTimeoutError: {
+        new (options?: ErrorOpts | undefined): {
+            extra: {};
+            toJSON(): {
+                type: string;
+                message: string;
+            };
+            name: string;
+            message: string;
+            stack?: string;
+            cause?: unknown;
+        };
+        status: number;
+        type: string;
+        extraSchema: z.core.$ZodShape;
+        staticDefaultMessage: string | undefined;
+        get defaultMessage(): string;
+        captureStackTrace(targetObject: object, constructorOpt?: Function): void;
+        prepareStackTrace(err: Error, stackTraces: NodeJS.CallSite[]): any;
+        stackTraceLimit: number;
+    };
+    readonly ConflictError: {
+        new (options?: ErrorOpts | undefined): {
+            extra: {};
+            toJSON(): {
+                type: string;
+                message: string;
+            };
+            name: string;
+            message: string;
+            stack?: string;
+            cause?: unknown;
+        };
+        status: number;
+        type: string;
+        extraSchema: z.core.$ZodShape;
+        staticDefaultMessage: string | undefined;
+        get defaultMessage(): string;
+        captureStackTrace(targetObject: object, constructorOpt?: Function): void;
+        prepareStackTrace(err: Error, stackTraces: NodeJS.CallSite[]): any;
+        stackTraceLimit: number;
+    };
+    readonly PreconditionFailedError: {
+        new (options?: ErrorOpts | undefined): {
+            extra: {};
+            toJSON(): {
+                type: string;
+                message: string;
+            };
+            name: string;
+            message: string;
+            stack?: string;
+            cause?: unknown;
+        };
+        status: number;
+        type: string;
+        extraSchema: z.core.$ZodShape;
+        staticDefaultMessage: string | undefined;
+        get defaultMessage(): string;
+        captureStackTrace(targetObject: object, constructorOpt?: Function): void;
+        prepareStackTrace(err: Error, stackTraces: NodeJS.CallSite[]): any;
+        stackTraceLimit: number;
+    };
+    readonly ContentTooLargeError: {
+        new (options?: ErrorOpts | undefined): {
+            extra: {};
+            toJSON(): {
+                type: string;
+                message: string;
+            };
+            name: string;
+            message: string;
+            stack?: string;
+            cause?: unknown;
+        };
+        status: number;
+        type: string;
+        extraSchema: z.core.$ZodShape;
+        staticDefaultMessage: string | undefined;
+        get defaultMessage(): string;
+        captureStackTrace(targetObject: object, constructorOpt?: Function): void;
+        prepareStackTrace(err: Error, stackTraces: NodeJS.CallSite[]): any;
+        stackTraceLimit: number;
+    };
+    readonly UnsupportedMediaTypeError: {
+        new (options?: ErrorOpts | undefined): {
+            extra: {};
+            toJSON(): {
+                type: string;
+                message: string;
+            };
+            name: string;
+            message: string;
+            stack?: string;
+            cause?: unknown;
+        };
+        status: number;
+        type: string;
+        extraSchema: z.core.$ZodShape;
+        staticDefaultMessage: string | undefined;
+        get defaultMessage(): string;
+        captureStackTrace(targetObject: object, constructorOpt?: Function): void;
+        prepareStackTrace(err: Error, stackTraces: NodeJS.CallSite[]): any;
+        stackTraceLimit: number;
+    };
+    readonly UnprocessableContentError: {
+        new (options?: ErrorOpts | undefined): {
+            extra: {};
+            toJSON(): {
+                type: string;
+                message: string;
+            };
+            name: string;
+            message: string;
+            stack?: string;
+            cause?: unknown;
+        };
+        status: number;
+        type: string;
+        extraSchema: z.core.$ZodShape;
+        staticDefaultMessage: string | undefined;
+        get defaultMessage(): string;
+        captureStackTrace(targetObject: object, constructorOpt?: Function): void;
+        prepareStackTrace(err: Error, stackTraces: NodeJS.CallSite[]): any;
+        stackTraceLimit: number;
+    };
+    readonly TooManyRequestsError: {
+        new (options?: ErrorOpts | undefined): {
+            extra: {};
+            toJSON(): {
+                type: string;
+                message: string;
+            };
+            name: string;
+            message: string;
+            stack?: string;
+            cause?: unknown;
+        };
+        status: number;
+        type: string;
+        extraSchema: z.core.$ZodShape;
+        staticDefaultMessage: string | undefined;
+        get defaultMessage(): string;
+        captureStackTrace(targetObject: object, constructorOpt?: Function): void;
+        prepareStackTrace(err: Error, stackTraces: NodeJS.CallSite[]): any;
+        stackTraceLimit: number;
+    };
+    readonly InternalServerError: typeof InternalServerError;
+    readonly NotImplementedError: {
+        new (options?: ErrorOpts | undefined): {
+            extra: {};
+            toJSON(): {
+                type: string;
+                message: string;
+            };
+            name: string;
+            message: string;
+            stack?: string;
+            cause?: unknown;
+        };
+        status: number;
+        type: string;
+        extraSchema: z.core.$ZodShape;
+        staticDefaultMessage: string | undefined;
+        get defaultMessage(): string;
+        captureStackTrace(targetObject: object, constructorOpt?: Function): void;
+        prepareStackTrace(err: Error, stackTraces: NodeJS.CallSite[]): any;
+        stackTraceLimit: number;
+    };
+    readonly BadGatewayError: {
+        new (options?: ErrorOpts | undefined): {
+            extra: {};
+            toJSON(): {
+                type: string;
+                message: string;
+            };
+            name: string;
+            message: string;
+            stack?: string;
+            cause?: unknown;
+        };
+        status: number;
+        type: string;
+        extraSchema: z.core.$ZodShape;
+        staticDefaultMessage: string | undefined;
+        get defaultMessage(): string;
+        captureStackTrace(targetObject: object, constructorOpt?: Function): void;
+        prepareStackTrace(err: Error, stackTraces: NodeJS.CallSite[]): any;
+        stackTraceLimit: number;
+    };
+    readonly ServiceUnavailableError: {
+        new (options?: ErrorOpts | undefined): {
+            extra: {};
+            toJSON(): {
+                type: string;
+                message: string;
+            };
+            name: string;
+            message: string;
+            stack?: string;
+            cause?: unknown;
+        };
+        status: number;
+        type: string;
+        extraSchema: z.core.$ZodShape;
+        staticDefaultMessage: string | undefined;
+        get defaultMessage(): string;
+        captureStackTrace(targetObject: object, constructorOpt?: Function): void;
+        prepareStackTrace(err: Error, stackTraces: NodeJS.CallSite[]): any;
+        stackTraceLimit: number;
+    };
+    readonly GatewayTimeoutError: {
+        new (options?: ErrorOpts | undefined): {
+            extra: {};
+            toJSON(): {
+                type: string;
+                message: string;
+            };
+            name: string;
+            message: string;
+            stack?: string;
+            cause?: unknown;
+        };
+        status: number;
+        type: string;
+        extraSchema: z.core.$ZodShape;
+        staticDefaultMessage: string | undefined;
+        get defaultMessage(): string;
+        captureStackTrace(targetObject: object, constructorOpt?: Function): void;
+        prepareStackTrace(err: Error, stackTraces: NodeJS.CallSite[]): any;
+        stackTraceLimit: number;
+    };
+};
+type ErrorMap = Record<string, SubclassOf<APIError<any>>>;
+type ErrorClassName = keyof typeof COMMON_ERRORS;
+type ErrorConfig<TExtraFields extends z.core.$ZodShape = {}> = {
+    extraFields?: TExtraFields;
+};
+type CustomErrorConfig<TExtraFields extends z.core.$ZodShape = {}> = ErrorConfig<TExtraFields> & {
+    status: number;
+    defaultMessage: string;
+    type: string;
+};
+type ValidateErrorsConfig<T extends ErrorsConfig> = {} extends T ? T : {
+    [K in keyof T]: K extends ErrorClassName ? T[K] extends ErrorConfig | boolean ? unknown : never : T[K] extends CustomErrorConfig ? unknown : never;
+}[keyof T] extends never ? {
+    [K in keyof T]: K extends ErrorClassName ? ErrorConfig | boolean : CustomErrorConfig;
+} : T;
+type ErrorsConfig = {
+    [K in ErrorClassName]?: ErrorConfig | boolean;
+} & {
+    [key: string]: CustomErrorConfig | ErrorConfig | boolean;
+};
+declare const DEFAULT_ERRORS_CONFIG: {
+    readonly BadRequestError: {
+        readonly extraFields: {
+            readonly code: z.KrustyString<z.KrustyInternals<string>>;
+        };
+    };
+    readonly UnauthorizedError: true;
+    readonly ForbiddenError: true;
+    readonly NotFoundError: true;
+    readonly InternalServerError: true;
+};
+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'];
+}>;
+type ErrorsReturn<T extends ErrorsConfig> = {
+    [K in keyof T]: K extends ErrorClassName ? T[K] extends true ? APIErrorConstructor<{}, (typeof COMMON_ERRORS)[K]> : T[K] extends {
+        extraFields?: any;
+    } ? T[K] extends {
+        extraFields: infer E extends z.core.$ZodShape;
+    } ? APIErrorConstructor<$InferObjectOutput<E>, (typeof COMMON_ERRORS)[K]> : APIErrorConstructor<{}, (typeof COMMON_ERRORS)[K]> : never : T[K] extends ({
+        status: infer Status extends number;
+        defaultMessage: infer DefaultMessage extends string;
+        type: infer Type extends string;
+        extraFields: z.core.$ZodShape;
+    }) ? CustomAPIErrorConstructor<Status, Type, DefaultMessage, $InferObjectOutput<T[K]['extraFields']>> : never;
+};
+type WithDefaultErrorConfig<T extends ErrorsConfig> = {
+    [K in keyof T]: T[K];
+} & {
+    [K in keyof typeof DEFAULT_ERRORS_CONFIG as Exclude<K, keyof T>]: (typeof DEFAULT_ERRORS_CONFIG)[K];
+};
+declare function makeErrors(): ErrorsReturn<WithDefaultErrorConfig<{}>>;
+declare function makeErrors<T extends ErrorsConfig>(config: ValidateErrorsConfig<T>): ErrorsReturn<WithDefaultErrorConfig<T>>;
+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;
@@ -145,45 +603,6 @@ interface EnhanceRouteOptions {
     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'];
-};
-
 interface ProcedureHandlerOptions<TCurrentContext extends Context, TMeta extends Meta> {
     context: TCurrentContext;
     path: readonly string[];
@@ -202,6 +621,7 @@ interface ProcedureHandler<TCurrentContext extends Context, TInput extends {
 interface ContractDef<TSchemas extends Schemas, TMeta extends Meta> {
     meta: TMeta;
     route: Route;
+    errorMap: ErrorMap;
     schemas: TSchemas;
     middlewares: readonly AnyMiddleware[];
     authConfigs: AnyAuthConfig[];
@@ -384,5 +804,5 @@ declare function unlazy<T extends Lazyable<any>>(lazied: T): Promise<{
     default: T extends Lazy<infer U> ? U : T;
 }>;
 
-export { lazy as D, isLazy as F, getLazyMeta as G, unlazy as H, mergeMeta as J, Procedure as P, middlewareOutputFn as T, isProcedure as _, getRouter as a4, createAccessibleLazyRouter as a6, enhanceRouter as a7, traverseContractProcedures as ac, resolveContractProcedures as ad, unlazyRouter as af, initialSchemas as ah, Contract as b, mergeCurrentContext as w, LAZY_SYMBOL as x, lazyInternal as z };
-export type { ContractRouter as $, AnyShape as A, BuildContextWithAuth as B, Context as C, EnhanceRouterOptions as E, InferProcedureClientInputs as I, MiddlewareResult as K, Lazyable as L, Meta as M, MiddlewareNextFn as N, MiddlewareOutputFn as O, MiddlewareOptions as Q, Route as R, Schemas as S, UnionToIntersection as U, ValidatedAuthContext as V, WrapShape as W, ProcedureHandlerOptions as X, AnyContractDef as Y, ProcedureDef as Z, InferSchemaOutput as a, InferRouterInitialContexts as a0, InferRouterCurrentContexts as a1, InferRouterInputs as a2, InferRouterOutputs as a3, AccessibleLazyRouter as a5, TraverseContractProceduresOptions as a8, TraverseContractProcedureCallbackOptions as a9, ContractProcedureCallbackOptions as aa, LazyTraverseContractProceduresOptions as ab, UnlaziedRouter as ae, TypeRest as ag, InitialSchemas as ai, 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, Router as l, EnhancedRouter as m, MapInputMiddleware as n, ContractDef as o, SchemaIssue as p, Schema as q, AnyMiddleware as r, Lazy as s, AnyProcedure as t, AnyRouter as u, InferRouterInitialContext as v, LazyMeta as y };
+export { isLazy as $, APIError as D, BadRequestError as F, UnauthorizedError as G, ForbiddenError as H, InternalServerError as J, makeErrors as K, NotFoundError as N, isAPIErrorStatus as O, Procedure as P, toAPIError as Q, encodeError as T, LAZY_SYMBOL as X, lazyInternal as Z, lazy as _, getLazyMeta as a0, unlazy as a1, mergeMeta as a2, middlewareOutputFn as a7, isProcedure as ab, getRouter as aj, createAccessibleLazyRouter as al, enhanceRouter as am, traverseContractProcedures as ar, resolveContractProcedures as as, unlazyRouter as au, initialSchemas as aw, Contract as b, mergeCurrentContext as v, ValidationError as x };
+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, LazyMeta as Y, InferSchemaOutput as a, MiddlewareResult as a3, MiddlewareNextFn as a4, MiddlewareOutputFn as a5, MiddlewareOptions as a6, ProcedureHandlerOptions as a8, AnyContractDef as a9, ProcedureDef as aa, ContractRouter as ac, AnyRouter as ad, InferRouterInitialContext as ae, InferRouterInitialContexts as af, InferRouterCurrentContexts as ag, InferRouterInputs as ah, InferRouterOutputs as ai, AccessibleLazyRouter as ak, TraverseContractProceduresOptions as an, TraverseContractProcedureCallbackOptions as ao, ContractProcedureCallbackOptions as ap, LazyTraverseContractProceduresOptions as aq, UnlaziedRouter as at, TypeRest as av, InitialSchemas as ax, 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, APIErrorConstructor as y, CustomAPIErrorConstructor as z };