express-zod-api 16.1.0 → 16.2.0-beta1

package/dist/index.d.ts

@@ -3,15 +3,42 @@ import express, { Request, Response, NextFunction, RequestHandler, IRouter } fro
 import fileUpload, { UploadedFile } from 'express-fileupload';
 import https, { ServerOptions } from 'node:https';
 import { z, ZodTypeDef, ZodType, ParseInput, ParseReturnType, ZodError } from 'zod';
-import { HttpError } from 'http-errors';
 import Winston from 'winston';
+import { HttpError } from 'http-errors';
 import { ListenOptions } from 'node:net';
 import * as qs from 'qs';
 import * as express_serve_static_core from 'express-serve-static-core';
 import http from 'node:http';
-import { ReferenceObject, SchemaObject, OpenApiBuilder, SecuritySchemeType, SecuritySchemeObject } from 'openapi3-ts/oas31';
+import { OpenApiBuilder, SecuritySchemeType, SchemaObject, ReferenceObject, SecuritySchemeObject } from 'openapi3-ts/oas31';
 import ts from 'typescript';
 
+interface ApiResponse<S extends z.ZodTypeAny> {
+    schema: S;
+    /**
+     * @default 200 for a positive response
+     * @default 400 for a negative response
+     * @override statusCodes
+     * */
+    statusCode?: number;
+    /**
+     * @default [200] for positive response
+     * @default [400] for negative response
+     * */
+    statusCodes?: [number, ...number[]];
+    /**
+     * @default "application/json"
+     * @override mimeTypes
+     * */
+    mimeType?: string;
+    /** @default [ "application/json" ] */
+    mimeTypes?: [string, ...string[]];
+}
+type MultipleApiResponses = [
+    ApiResponse<z.ZodTypeAny>,
+    ...ApiResponse<z.ZodTypeAny>[]
+];
+type NormalizedResponse = Required<Pick<ApiResponse<z.ZodTypeAny>, "schema" | "statusCodes" | "mimeTypes">>;
+
 type LogicalOr<T> = {
     or: T[];
 };
@@ -182,112 +209,6 @@ type WithMeta<T extends z.ZodTypeAny> = T & {
 };
 declare const withMeta: <T extends z.ZodTypeAny>(schema: T) => WithMeta<T>;
 
-interface ApiResponse<S extends z.ZodTypeAny> {
-    schema: S;
-    /**
-     * @default 200 for a positive response
-     * @default 400 for a negative response
-     * */
-    statusCode?: number;
-    /**
-     * @default "application/json"
-     * @override mimeTypes
-     * */
-    mimeType?: string;
-    /** @default [ "application/json" ] */
-    mimeTypes?: [string, ...string[]];
-}
-
-declare const zodDateInKind = "ZodDateIn";
-interface ZodDateInDef extends ZodTypeDef {
-    typeName: typeof zodDateInKind;
-}
-declare class ZodDateIn extends ZodType<Date, ZodDateInDef, string> {
-    _parse(input: ParseInput): ParseReturnType<Date>;
-    static create: () => ZodDateIn;
-}
-
-declare const zodDateOutKind = "ZodDateOut";
-interface ZodDateOutDef extends ZodTypeDef {
-    typeName: typeof zodDateOutKind;
-}
-declare class ZodDateOut extends ZodType<string, ZodDateOutDef, Date> {
-    _parse(input: ParseInput): ParseReturnType<string>;
-    static create: () => ZodDateOut;
-}
-
-declare const zodFileKind = "ZodFile";
-interface ZodFileDef<T extends string | Buffer = string | Buffer> extends ZodTypeDef {
-    typeName: typeof zodFileKind;
-    type: T;
-    encoding?: "binary" | "base64";
-    message?: string;
-}
-declare class ZodFile<T extends string | Buffer = string | Buffer> extends ZodType<T, ZodFileDef<T>, T> {
-    _parse(input: ParseInput): ParseReturnType<T>;
-    string: (message?: ErrMessage) => ZodFile<string>;
-    buffer: (message?: ErrMessage) => ZodFile<Buffer>;
-    binary: (message?: ErrMessage) => ZodFile<T>;
-    base64: (message?: ErrMessage) => ZodFile<T>;
-    get isBinary(): boolean;
-    get isBase64(): boolean;
-    get isString(): boolean;
-    get isBuffer(): boolean;
-    static create: () => ZodFile<string>;
-}
-
-declare const zodUploadKind = "ZodUpload";
-interface ZodUploadDef extends ZodTypeDef {
-    typeName: typeof zodUploadKind;
-}
-declare class ZodUpload extends ZodType<UploadedFile, ZodUploadDef> {
-    _parse(input: ParseInput): ParseReturnType<UploadedFile>;
-    static create: () => ZodUpload;
-}
-
-interface OpenAPIContext extends FlatObject {
-    isResponse: boolean;
-    serializer: (schema: z.ZodTypeAny) => string;
-    getRef: (name: string) => ReferenceObject | undefined;
-    makeRef: (name: string, schema: SchemaObject | ReferenceObject) => ReferenceObject;
-    path: string;
-    method: Method;
-}
-
-/** @desc An error related to the wrong Routing declaration */
-declare class RoutingError extends Error {
-    name: string;
-}
-/**
- * @desc An error related to the generating of the documentation
- * */
-declare class DocumentationError extends Error {
-    name: string;
-    constructor({ message, method, path, isResponse, }: {
-        message: string;
-    } & Pick<OpenAPIContext, "path" | "method" | "isResponse">);
-}
-/** @desc An error related to the input and output schemas declaration */
-declare class IOSchemaError extends Error {
-    name: string;
-}
-/** @desc An error of validating the Endpoint handler's returns against the Endpoint output schema */
-declare class OutputValidationError extends IOSchemaError {
-    name: string;
-    readonly originalError: ZodError;
-    constructor(originalError: ZodError);
-}
-/** @desc An error of validating the input sources against the Middleware or Endpoint input schema */
-declare class InputValidationError extends IOSchemaError {
-    name: string;
-    readonly originalError: ZodError;
-    constructor(originalError: ZodError);
-}
-declare class MissingPeerError extends Error {
-    name: string;
-    constructor(module: string | string[]);
-}
-
 interface ResultHandlerParams<RES> {
     /** null in case of failure to parse or to find the matching endpoint (error: not found) */
     input: FlatObject | null;
@@ -304,8 +225,14 @@ interface ResultHandlerDefinition<POS extends z.ZodTypeAny, NEG extends z.ZodTyp
     getNegativeResponse: () => NEG | ApiResponse<NEG>;
     handler: ResultHandler<z.output<POS> | z.output<NEG>>;
 }
-type AnyResultHandlerDefinition = ResultHandlerDefinition<z.ZodTypeAny, z.ZodTypeAny>;
-declare const createResultHandler: <POS extends z.ZodTypeAny, NEG extends z.ZodTypeAny>(definition: ResultHandlerDefinition<POS, NEG>) => ResultHandlerDefinition<POS, NEG>;
+interface StatusDependingDefinition<POS extends MultipleApiResponses, NEG extends MultipleApiResponses> {
+    getPositiveResponse: (output: IOSchema) => POS;
+    getNegativeResponse: () => NEG;
+    handler: ResultHandler<z.output<POS[number]["schema"]> | z.output<NEG[number]["schema"]>>;
+}
+type AnyResultHandlerDefinition = ResultHandlerDefinition<z.ZodTypeAny, z.ZodTypeAny> | StatusDependingDefinition<MultipleApiResponses, MultipleApiResponses>;
+declare function createResultHandler<POS extends MultipleApiResponses, NEG extends MultipleApiResponses>(definition: StatusDependingDefinition<POS, NEG>): typeof definition;
+declare function createResultHandler<POS extends z.ZodTypeAny, NEG extends z.ZodTypeAny>(definition: ResultHandlerDefinition<POS, NEG>): typeof definition;
 declare const defaultResultHandler: ResultHandlerDefinition<z.ZodObject<{
     status: z.ZodLiteral<"success">;
     data: IOSchema;
@@ -451,21 +378,21 @@ declare abstract class AbstractEndpoint {
     abstract getSchema(variant: IOVariant): IOSchema;
     abstract getSchema(variant: ResponseVariant): z.ZodTypeAny;
     abstract getMimeTypes(variant: MimeVariant): string[];
-    abstract getStatusCode(variant: ResponseVariant): number;
+    abstract getResponses(variant: ResponseVariant): NormalizedResponse[];
     abstract getSecurity(): LogicalContainer<Security>;
     abstract getScopes(): string[];
     abstract getTags(): string[];
     abstract _setSiblingMethods(methods: Method[]): void;
     abstract getOperationId(method: Method): string | undefined;
 }
-declare class Endpoint<IN extends IOSchema, OUT extends IOSchema, OPT extends FlatObject, POS extends z.ZodTypeAny, NEG extends z.ZodTypeAny, SCO extends string, TAG extends string> extends AbstractEndpoint {
+declare class Endpoint<IN extends IOSchema, OUT extends IOSchema, OPT extends FlatObject, SCO extends string, TAG extends string> extends AbstractEndpoint {
     #private;
     constructor({ methods, inputSchema, outputSchema, handler, resultHandler, getOperationId, scopes, middlewares, tags, description: long, shortDescription: short, }: {
         middlewares?: AnyMiddlewareDef[];
         inputSchema: IN;
         outputSchema: OUT;
         handler: Handler<z.output<IN>, z.input<OUT>, OPT>;
-        resultHandler: ResultHandlerDefinition<POS, NEG>;
+        resultHandler: AnyResultHandlerDefinition;
         description?: string;
         shortDescription?: string;
         getOperationId?: (method: Method) => string | undefined;
@@ -482,10 +409,9 @@ declare class Endpoint<IN extends IOSchema, OUT extends IOSchema, OPT extends Fl
     getMethods(): Method[];
     getSchema(variant: "input"): IN;
     getSchema(variant: "output"): OUT;
-    getSchema(variant: "positive"): POS;
-    getSchema(variant: "negative"): NEG;
+    getSchema(variant: ResponseVariant): z.ZodTypeAny;
     getMimeTypes(variant: MimeVariant): string[];
-    getStatusCode(variant: ResponseVariant): number;
+    getResponses(variant: ResponseVariant): Required<Pick<ApiResponse<z.ZodTypeAny>, "schema" | "statusCodes" | "mimeTypes">>[];
     getSecurity(): LogicalContainer<Security>;
     getScopes(): SCO[];
     getTags(): TAG[];
@@ -617,145 +543,29 @@ type BuildProps<IN extends IOSchema, OUT extends IOSchema, MIN extends IOSchema<
 } | {
     tag?: TAG;
 });
-declare class EndpointsFactory<POS extends z.ZodTypeAny, NEG extends z.ZodTypeAny, IN extends IOSchema<"strip"> | null = null, OUT extends FlatObject = {}, SCO extends string = string, TAG extends string = string> {
+declare class EndpointsFactory<IN extends IOSchema<"strip"> | null = null, OUT extends FlatObject = {}, SCO extends string = string, TAG extends string = string> {
     #private;
-    protected resultHandler: ResultHandlerDefinition<POS, NEG>;
+    protected resultHandler: AnyResultHandlerDefinition;
     protected middlewares: AnyMiddlewareDef[];
     /** @desc Consider using the "config" prop with the "tags" option to enforce constraints on tagging the endpoints */
-    constructor(resultHandler: ResultHandlerDefinition<POS, NEG>);
+    constructor(resultHandler: AnyResultHandlerDefinition);
     constructor(params: {
-        resultHandler: ResultHandlerDefinition<POS, NEG>;
+        resultHandler: AnyResultHandlerDefinition;
         config?: CommonConfig<TAG>;
     });
-    addMiddleware<AIN extends IOSchema<"strip">, AOUT extends FlatObject, ASCO extends string>(subject: MiddlewareDefinition<AIN, OUT, AOUT, ASCO>): EndpointsFactory<POS, NEG, ProbableIntersection<IN, AIN>, OUT & AOUT, SCO & ASCO, TAG>;
-    use: <R extends Request<express_serve_static_core.ParamsDictionary, any, any, qs.ParsedQs, Record<string, any>>, S extends Response<any, Record<string, any>>, AOUT extends FlatObject = {}>(middleware: ExpressMiddleware<R, S>, features?: ExpressMiddlewareFeatures<R, S, AOUT> | undefined) => EndpointsFactory<POS, NEG, IN, OUT & AOUT, SCO, TAG>;
-    addExpressMiddleware<R extends Request, S extends Response, AOUT extends FlatObject = {}>(middleware: ExpressMiddleware<R, S>, features?: ExpressMiddlewareFeatures<R, S, AOUT>): EndpointsFactory<POS, NEG, IN, OUT & AOUT, SCO, TAG>;
-    addOptions<AOUT extends FlatObject>(options: AOUT): EndpointsFactory<POS, NEG, IN, OUT & AOUT, SCO, TAG>;
-    build<BIN extends IOSchema, BOUT extends IOSchema>({ input, handler, output: outputSchema, description, shortDescription, operationId, ...rest }: BuildProps<BIN, BOUT, IN, OUT, SCO, TAG>): Endpoint<ProbableIntersection<IN, BIN>, BOUT, OUT, POS, NEG, SCO, TAG>;
+    addMiddleware<AIN extends IOSchema<"strip">, AOUT extends FlatObject, ASCO extends string>(subject: MiddlewareDefinition<AIN, OUT, AOUT, ASCO>): EndpointsFactory<ProbableIntersection<IN, AIN>, OUT & AOUT, SCO & ASCO, TAG>;
+    use: <R extends Request<express_serve_static_core.ParamsDictionary, any, any, qs.ParsedQs, Record<string, any>>, S extends Response<any, Record<string, any>>, AOUT extends FlatObject = {}>(middleware: ExpressMiddleware<R, S>, features?: ExpressMiddlewareFeatures<R, S, AOUT> | undefined) => EndpointsFactory<IN, OUT & AOUT, SCO, TAG>;
+    addExpressMiddleware<R extends Request, S extends Response, AOUT extends FlatObject = {}>(middleware: ExpressMiddleware<R, S>, features?: ExpressMiddlewareFeatures<R, S, AOUT>): EndpointsFactory<IN, OUT & AOUT, SCO, TAG>;
+    addOptions<AOUT extends FlatObject>(options: AOUT): EndpointsFactory<IN, OUT & AOUT, SCO, TAG>;
+    build<BIN extends IOSchema, BOUT extends IOSchema>({ input, handler, output: outputSchema, description, shortDescription, operationId, ...rest }: BuildProps<BIN, BOUT, IN, OUT, SCO, TAG>): Endpoint<ProbableIntersection<IN, BIN>, BOUT, OUT, SCO, TAG>;
 }
-declare const defaultEndpointsFactory: EndpointsFactory<z.ZodObject<{
-    status: z.ZodLiteral<"success">;
-    data: IOSchema;
-}, "strip", z.ZodTypeAny, {
-    status: "success";
-    data?: unknown;
-}, {
-    status: "success";
-    data?: unknown;
-}> & {
-    _def: z.ZodObjectDef<{
-        status: z.ZodLiteral<"success">;
-        data: IOSchema;
-    }, "strip", z.ZodTypeAny> & MetaDef<z.ZodObject<{
-        status: z.ZodLiteral<"success">;
-        data: IOSchema;
-    }, "strip", z.ZodTypeAny, {
-        status: "success";
-        data?: unknown;
-    }, {
-        status: "success";
-        data?: unknown;
-    }>>;
-    example: (example: {
-        status: "success";
-        data?: unknown;
-    }) => z.ZodObject<{
-        status: z.ZodLiteral<"success">;
-        data: IOSchema;
-    }, "strip", z.ZodTypeAny, {
-        status: "success";
-        data?: unknown;
-    }, {
-        status: "success";
-        data?: unknown;
-    }> & any;
-}, z.ZodObject<{
-    status: z.ZodLiteral<"error">;
-    error: z.ZodObject<{
-        message: z.ZodString;
-    }, "strip", z.ZodTypeAny, {
-        message: string;
-    }, {
-        message: string;
-    }>;
-}, "strip", z.ZodTypeAny, {
-    status: "error";
-    error: {
-        message: string;
-    };
-}, {
-    status: "error";
-    error: {
-        message: string;
-    };
-}> & {
-    _def: z.ZodObjectDef<{
-        status: z.ZodLiteral<"error">;
-        error: z.ZodObject<{
-            message: z.ZodString;
-        }, "strip", z.ZodTypeAny, {
-            message: string;
-        }, {
-            message: string;
-        }>;
-    }, "strip", z.ZodTypeAny> & MetaDef<z.ZodObject<{
-        status: z.ZodLiteral<"error">;
-        error: z.ZodObject<{
-            message: z.ZodString;
-        }, "strip", z.ZodTypeAny, {
-            message: string;
-        }, {
-            message: string;
-        }>;
-    }, "strip", z.ZodTypeAny, {
-        status: "error";
-        error: {
-            message: string;
-        };
-    }, {
-        status: "error";
-        error: {
-            message: string;
-        };
-    }>>;
-    example: (example: {
-        status: "error";
-        error: {
-            message: string;
-        };
-    }) => z.ZodObject<{
-        status: z.ZodLiteral<"error">;
-        error: z.ZodObject<{
-            message: z.ZodString;
-        }, "strip", z.ZodTypeAny, {
-            message: string;
-        }, {
-            message: string;
-        }>;
-    }, "strip", z.ZodTypeAny, {
-        status: "error";
-        error: {
-            message: string;
-        };
-    }, {
-        status: "error";
-        error: {
-            message: string;
-        };
-    }> & any;
-}, null, {}, string, string>;
+declare const defaultEndpointsFactory: EndpointsFactory<null, {}, string, string>;
 /**
  * @deprecated Resist the urge of using it: this factory is designed only to simplify the migration of legacy APIs.
  * @desc Responding with array is a bad practice keeping your endpoints from evolving without breaking changes.
  * @desc The result handler of this factory expects your endpoint to have the property 'items' in the output schema
  */
-declare const arrayEndpointsFactory: EndpointsFactory<z.ZodArray<z.ZodTypeAny, "many"> & {
-    _def: z.ZodArrayDef<z.ZodTypeAny> & MetaDef<z.ZodArray<z.ZodTypeAny, "many">>;
-    example: (example: any[]) => z.ZodArray<z.ZodTypeAny, "many"> & any;
-}, z.ZodString & {
-    _def: z.ZodStringDef & MetaDef<z.ZodString>;
-    example: (example: string) => z.ZodString & any;
-}, null, {}, string, string>;
+declare const arrayEndpointsFactory: EndpointsFactory<null, {}, string, string>;
 
 declare class DependsOnMethod {
     readonly endpoints: Partial<Record<Method, AbstractEndpoint>>;
@@ -787,7 +597,9 @@ declare const createServer: (config: ServerConfig, routing: Routing) => Promise<
 
 type Component = "positiveResponse" | "negativeResponse" | "requestParameter" | "requestBody";
 /** @desc user defined function that creates a component description from its properties */
-type Descriptor = (props: Record<"method" | "path" | "operationId", string>) => string;
+type Descriptor = (props: Record<"method" | "path" | "operationId", string> & {
+    statusCode?: number;
+}) => string;
 interface DocumentationParams {
     title: string;
     version: string;
@@ -820,6 +632,96 @@ declare class Documentation extends OpenApiBuilder {
     constructor({ routing, config, title, version, serverUrl, descriptions, hasSummaryFromDescription, composition, serializer, }: DocumentationParams);
 }
 
+declare const zodDateInKind = "ZodDateIn";
+interface ZodDateInDef extends ZodTypeDef {
+    typeName: typeof zodDateInKind;
+}
+declare class ZodDateIn extends ZodType<Date, ZodDateInDef, string> {
+    _parse(input: ParseInput): ParseReturnType<Date>;
+    static create: () => ZodDateIn;
+}
+
+declare const zodDateOutKind = "ZodDateOut";
+interface ZodDateOutDef extends ZodTypeDef {
+    typeName: typeof zodDateOutKind;
+}
+declare class ZodDateOut extends ZodType<string, ZodDateOutDef, Date> {
+    _parse(input: ParseInput): ParseReturnType<string>;
+    static create: () => ZodDateOut;
+}
+
+declare const zodFileKind = "ZodFile";
+interface ZodFileDef<T extends string | Buffer = string | Buffer> extends ZodTypeDef {
+    typeName: typeof zodFileKind;
+    type: T;
+    encoding?: "binary" | "base64";
+    message?: string;
+}
+declare class ZodFile<T extends string | Buffer = string | Buffer> extends ZodType<T, ZodFileDef<T>, T> {
+    _parse(input: ParseInput): ParseReturnType<T>;
+    string: (message?: ErrMessage) => ZodFile<string>;
+    buffer: (message?: ErrMessage) => ZodFile<Buffer>;
+    binary: (message?: ErrMessage) => ZodFile<T>;
+    base64: (message?: ErrMessage) => ZodFile<T>;
+    get isBinary(): boolean;
+    get isBase64(): boolean;
+    get isString(): boolean;
+    get isBuffer(): boolean;
+    static create: () => ZodFile<string>;
+}
+
+declare const zodUploadKind = "ZodUpload";
+interface ZodUploadDef extends ZodTypeDef {
+    typeName: typeof zodUploadKind;
+}
+declare class ZodUpload extends ZodType<UploadedFile, ZodUploadDef> {
+    _parse(input: ParseInput): ParseReturnType<UploadedFile>;
+    static create: () => ZodUpload;
+}
+
+interface OpenAPIContext extends FlatObject {
+    isResponse: boolean;
+    serializer: (schema: z.ZodTypeAny) => string;
+    getRef: (name: string) => ReferenceObject | undefined;
+    makeRef: (name: string, schema: SchemaObject | ReferenceObject) => ReferenceObject;
+    path: string;
+    method: Method;
+}
+
+/** @desc An error related to the wrong Routing declaration */
+declare class RoutingError extends Error {
+    name: string;
+}
+/**
+ * @desc An error related to the generating of the documentation
+ * */
+declare class DocumentationError extends Error {
+    name: string;
+    constructor({ message, method, path, isResponse, }: {
+        message: string;
+    } & Pick<OpenAPIContext, "path" | "method" | "isResponse">);
+}
+/** @desc An error related to the input and output schemas declaration */
+declare class IOSchemaError extends Error {
+    name: string;
+}
+/** @desc An error of validating the Endpoint handler's returns against the Endpoint output schema */
+declare class OutputValidationError extends IOSchemaError {
+    name: string;
+    readonly originalError: ZodError;
+    constructor(originalError: ZodError);
+}
+/** @desc An error of validating the input sources against the Middleware or Endpoint input schema */
+declare class InputValidationError extends IOSchemaError {
+    name: string;
+    readonly originalError: ZodError;
+    constructor(originalError: ZodError);
+}
+declare class MissingPeerError extends Error {
+    name: string;
+    constructor(module: string | string[]);
+}
+
 /**
  * @desc Using module augmentation approach you can set the Mock type of your actual testing framework.
  * @example declare module "express-zod-api" { interface MockOverrides extends Mock {} }
@@ -993,4 +895,4 @@ declare namespace proprietarySchemas {
   export { proprietarySchemas_dateIn as dateIn, proprietarySchemas_dateOut as dateOut, proprietarySchemas_file as file, proprietarySchemas_raw as raw, proprietarySchemas_upload as upload };
 }
 
-export { AbstractEndpoint, type AppConfig, type BasicSecurity, type BearerSecurity, type CommonConfig, type CookieSecurity, type CustomHeaderSecurity, DependsOnMethod, Documentation, DocumentationError, EndpointsFactory, type FlatObject, type IOSchema, type InputSecurity, InputValidationError, Integration, type LoggerOverrides, type Metadata, type Method, type MiddlewareDefinition, MissingPeerError, type MockOverrides, type OAuth2Security, type OpenIdSecurity, OutputValidationError, type ResultHandlerDefinition, type Routing, RoutingError, ServeStatic, type ServerConfig, type ZodDateInDef, type ZodDateOutDef, type ZodFileDef, type ZodUploadDef, arrayEndpointsFactory, arrayResultHandler, attachRouting, createConfig, createLogger, createMiddleware, createResultHandler, createServer, defaultEndpointsFactory, defaultResultHandler, proprietarySchemas as ez, getExamples, getMessageFromError, getStatusCodeFromError, testEndpoint, withMeta };
+export { AbstractEndpoint, type ApiResponse, type AppConfig, type BasicSecurity, type BearerSecurity, type CommonConfig, type CookieSecurity, type CustomHeaderSecurity, DependsOnMethod, Documentation, DocumentationError, EndpointsFactory, type FlatObject, type IOSchema, type InputSecurity, InputValidationError, Integration, type LoggerOverrides, type Metadata, type Method, type MiddlewareDefinition, MissingPeerError, type MockOverrides, type NormalizedResponse, type OAuth2Security, type OpenIdSecurity, OutputValidationError, type ResultHandlerDefinition, type Routing, RoutingError, ServeStatic, type ServerConfig, type StatusDependingDefinition, type ZodDateInDef, type ZodDateOutDef, type ZodFileDef, type ZodUploadDef, arrayEndpointsFactory, arrayResultHandler, attachRouting, createConfig, createLogger, createMiddleware, createResultHandler, createServer, defaultEndpointsFactory, defaultResultHandler, proprietarySchemas as ez, getExamples, getMessageFromError, getStatusCodeFromError, testEndpoint, withMeta };